From fcb69b5dec15f82f9e2e446a83d718711fc0e97c Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 14 Feb 2026 04:46:38 +0500 Subject: [PATCH 01/32] feat: on-chain proof verification test for c0 --- crates/zk-prover/src/prover.rs | 4 + crates/zk-prover/tests/backend_tests.rs | 13 +- crates/zk-prover/tests/common/helpers.rs | 125 + crates/zk-prover/tests/common/mod.rs | 3 + crates/zk-prover/tests/fixtures/pk.json | 10 +- crates/zk-prover/tests/fixtures/pk.vk | Bin 3680 -> 1888 bytes crates/zk-prover/tests/integration_tests.rs | 13 +- crates/zk-prover/tests/local_e2e_tests.rs | 92 +- .../tests/onchain_verification_tests.rs | 255 + .../contracts/CRISPVerifier.sol | 4299 ++++++++--------- packages/enclave-contracts/.gitignore | 21 +- .../DkgPkVerifier.sol/DkgPkVerifier.json | 186 + .../DkgPkVerifier.sol/ZKTranscriptLib.json | 400 ++ scripts/build-circuits.ts | 7 +- 14 files changed, 3154 insertions(+), 2274 deletions(-) create mode 100644 crates/zk-prover/tests/common/helpers.rs create mode 100644 crates/zk-prover/tests/onchain_verification_tests.rs create mode 100644 packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json create mode 100644 packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json diff --git a/crates/zk-prover/src/prover.rs b/crates/zk-prover/src/prover.rs index 80c44593a1..7f8d55b135 100644 --- a/crates/zk-prover/src/prover.rs +++ b/crates/zk-prover/src/prover.rs @@ -85,6 +85,8 @@ impl ZkProver { "prove", "--scheme", "ultra_honk", + "--oracle_hash", + "keccak", "-b", &circuit_path.to_string_lossy(), "-w", @@ -179,6 +181,8 @@ impl ZkProver { "verify", "--scheme", "ultra_honk", + "--oracle_hash", + "keccak", "-i", &public_inputs_path.to_string_lossy(), "-p", diff --git a/crates/zk-prover/tests/backend_tests.rs b/crates/zk-prover/tests/backend_tests.rs index 9243fab059..ecc69f5053 100644 --- a/crates/zk-prover/tests/backend_tests.rs +++ b/crates/zk-prover/tests/backend_tests.rs @@ -4,18 +4,13 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -use e3_zk_prover::{ZkBackend, ZkConfig, ZkProver}; +mod common; + +use common::test_backend; +use e3_zk_prover::{ZkConfig, ZkProver}; use tempfile::tempdir; use tokio::fs; -fn test_backend(temp_path: &std::path::Path, config: ZkConfig) -> ZkBackend { - let noir_dir = temp_path.join("noir"); - let bb_binary = noir_dir.join("bin").join("bb"); - let circuits_dir = noir_dir.join("circuits"); - let work_dir = noir_dir.join("work").join("test_node"); - ZkBackend::new(bb_binary, circuits_dir, work_dir, config) -} - #[tokio::test] async fn test_backend_creates_directories() { let temp = tempdir().unwrap(); diff --git a/crates/zk-prover/tests/common/helpers.rs b/crates/zk-prover/tests/common/helpers.rs new file mode 100644 index 0000000000..1050635521 --- /dev/null +++ b/crates/zk-prover/tests/common/helpers.rs @@ -0,0 +1,125 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +use super::fixtures_dir; +use e3_zk_prover::{ZkBackend, ZkConfig}; +use std::path::PathBuf; +use tempfile::TempDir; +use tokio::{fs, process::Command}; + +/// Returns `None` when bb is not found — tests should skip gracefully. +pub async fn find_bb() -> Option { + if let Ok(output) = Command::new("which").arg("bb").output().await { + if output.status.success() { + let path = String::from_utf8_lossy(&output.stdout).trim().to_string(); + if !path.is_empty() { + return Some(PathBuf::from(path)); + } + } + } + if let Ok(home) = std::env::var("HOME") { + for path in [ + format!("{}/.bb/bb", home), + format!("{}/.nargo/bin/bb", home), + format!("{}/.enclave/noir/bin/bb", home), + ] { + if std::path::Path::new(&path).exists() { + return Some(PathBuf::from(path)); + } + } + } + None +} + +pub async fn find_anvil() -> bool { + if let Ok(output) = Command::new("which").arg("anvil").output().await { + if output.status.success() { + return true; + } + } + if let Ok(home) = std::env::var("HOME") { + let path = format!("{}/.foundry/bin/anvil", home); + if std::path::Path::new(&path).exists() { + return true; + } + } + false +} + +/// Creates a temp ZkBackend with the real bb binary symlinked in. +/// Caller must hold onto the returned TempDir or it gets cleaned up. +pub async fn setup_test_prover(bb: &PathBuf) -> (ZkBackend, TempDir) { + let target_tmp = env!("CARGO_TARGET_TMPDIR"); + let temp = TempDir::new_in(target_tmp).unwrap(); + + let temp_path = temp.path(); + let noir_dir = temp_path.join("noir"); + let bb_binary = noir_dir.join("bin").join("bb"); + let circuits_dir = noir_dir.join("circuits"); + let work_dir = noir_dir.join("work").join("test_node"); + let backend = ZkBackend::new( + bb_binary.clone(), + circuits_dir.clone(), + work_dir.clone(), + ZkConfig::default(), + ); + + fs::create_dir_all(&backend.circuits_dir).await.unwrap(); + fs::create_dir_all(backend.circuits_dir.join("vk")) + .await + .unwrap(); + fs::create_dir_all(&backend.work_dir).await.unwrap(); + fs::create_dir_all(backend.base_dir.join("bin")) + .await + .unwrap(); + + #[cfg(unix)] + std::os::unix::fs::symlink(bb, &backend.bb_binary).unwrap(); + + (backend, temp) +} + +/// Copies .json and .vk fixtures into the backend circuits layout. +/// Panics if fixtures are missing — run `pnpm sync:fixtures` to populate. +pub async fn setup_circuit_fixtures( + backend: &ZkBackend, + circuit_path: &[&str], + fixture_name: &str, +) { + let fixtures = fixtures_dir(); + let json_path = fixtures.join(format!("{fixture_name}.json")); + let vk_path = fixtures.join(format!("{fixture_name}.vk")); + assert!( + json_path.exists(), + "missing circuit fixture: {} (run `pnpm sync:fixtures` to copy from circuits target)", + json_path.display() + ); + assert!( + vk_path.exists(), + "missing verification key fixture: {}", + vk_path.display() + ); + + let circuit_dir = circuit_path + .iter() + .fold(backend.circuits_dir.clone(), |p, seg| p.join(seg)); + fs::create_dir_all(&circuit_dir).await.unwrap(); + fs::copy(json_path, circuit_dir.join(format!("{fixture_name}.json"))) + .await + .unwrap(); + fs::copy(vk_path, circuit_dir.join(format!("{fixture_name}.vk"))) + .await + .unwrap(); +} + +/// Lightweight backend for tests that don't need a real bb binary. +pub fn test_backend(temp_path: &std::path::Path, config: ZkConfig) -> ZkBackend { + let noir_dir = temp_path.join("noir"); + let bb_binary = noir_dir.join("bin").join("bb"); + let circuits_dir = noir_dir.join("circuits"); + let work_dir = noir_dir.join("work").join("test_node"); + ZkBackend::new(bb_binary, circuits_dir, work_dir, config) +} diff --git a/crates/zk-prover/tests/common/mod.rs b/crates/zk-prover/tests/common/mod.rs index 73e5822d7b..077e55df08 100644 --- a/crates/zk-prover/tests/common/mod.rs +++ b/crates/zk-prover/tests/common/mod.rs @@ -4,6 +4,9 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. +pub mod helpers; +pub use helpers::*; + use std::path::PathBuf; use num_bigint::{BigInt, Sign}; diff --git a/crates/zk-prover/tests/fixtures/pk.json b/crates/zk-prover/tests/fixtures/pk.json index 589596a065..b4b62d384f 100644 --- a/crates/zk-prover/tests/fixtures/pk.json +++ b/crates/zk-prover/tests/fixtures/pk.json @@ -42,23 +42,23 @@ }, "50": { "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::dkg::{L, N};\nuse lib::configs::default::dkg::PK_BIT_PK;\nuse lib::core::dkg::pk::Pk;\nuse lib::math::polynomial::Polynomial;\n\nfn main(pk0is: [Polynomial; L], pk1is: [Polynomial; L]) -> pub Field {\n let pk: Pk = Pk::new(pk0is, pk1is);\n pk.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/pk/src/main.nr" + "path": "/home/ace/main/gnosis/enclave/circuits/bin/dkg/pk/src/main.nr" }, "62": { "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::commitments::compute_dkg_pk_commitment;\nuse crate::math::polynomial::Polynomial;\n\n/// Correct DKG Public Key Circuit (Circuit 0).\npub struct Pk {\n /// Correct DKG public key components\n /// pk0[i] is the first component for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component for modulus i\n pk1: [Polynomial; L],\n}\n\nimpl Pk {\n pub fn new(pk0: [Polynomial; L], pk1: [Polynomial; L]) -> Self {\n Pk { pk0, pk1 }\n }\n\n /// Main verification function\n /// Returns commitment to correct DKG public key\n pub fn execute(self) -> Field {\n compute_dkg_pk_commitment::(self.pk0, self.pk1)\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/pk.nr" + "path": "/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/pk.nr" }, "74": { "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" + "path": "/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr" }, "75": { "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" + "path": "/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr" }, "81": { "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" + "path": "/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr" } }, "expression_width": { "Bounded": { "width": 4 } } diff --git a/crates/zk-prover/tests/fixtures/pk.vk b/crates/zk-prover/tests/fixtures/pk.vk index 56540013f3b7581917480f321d14eabda662e784..913fa7712f317c097f59822c203fa3657cdeb197 100644 GIT binary patch delta 1747 zcmV;^1}ypD9N-R+V1F81mcL!BM8sYwI1Q}M-|QWli5Z!i4RnfzhWGR=x^^hVhiXiS zau4*FaLdED^c*IkG4$1Z>0G>FCxx5{lOHT}0x+Q%tpxE%F7EQ@S`@C(`C+$X5)I=` z558l{60jSZr~O;`I?JlvVOwqpDd!YZpX71A&NQ=G&1#m=0)Lburvlc~m307kFiHO9 zuPP@MT>bI3!j*|a_08nGW6@&(HD|OqVMm)IMmG70SotH$>&;fO&Y#R&40069QPPy!J6~_u3i55`wU*cTzb?OT;BXV_niFuVq z?$Q+}W)lu;nSbw~B_G^GUE;X`aOlWvL8uc0yFKSqQu4iT30vB?bcRG)2J#G5;vgC^ojqLW zyf$HF4O98DO_Dv2KuoZ^$qr`ia8c463g1%B;(8J=b^wY_c>QpxFDsU_)?YYHrXP6UteNXQUU31 z7=;wIIDfa`CZw+l!U^nWFvQ^I%yuBBl3(j2ODm)uG22E_rpCs;XD-m^aUU-9!nmKD zN?#;$wK1bAeSd)LJTrBdd!&|+GG~TIJ~Yw&bARR|Z1!OS30_*w0iI6U_}4aJTS^t3 z>ixNj7ag^c?Ma&g8T(5HMD*NLta4^Om1-k268A{wOBIn-KFi8*I4P|6UPl@NE3Q>% zfD)mE)XSF(kD6^0GzooS9pyB>`ESYi+0YRvPU6&=CrE|7x1iU13ML(qlI%e{3<`$( zCx5Pp&DEzYE!fB9&R=S9Q^9k)6b(j$3b|s d>3W)~jiK)WH;13O3c_(^K`(kJg1 zTt~C_&1P=AlH%yLBmq)0zgOCy&Vlic(z< z-xTkd@qhb5sd4*|G6Brj7V1vxq=E*1XcpVDH0ldG8x1ZPe`U{F zv_7l`A5`f(+`^Kw^%(ABD+3OrDFH(hoCE)vXP1kTPeZRBarP)4<7$?{wnw}8!GC@{ zv|?arw~HYL=q_GavK!~ftOxDjPW)s=@E$R>&UlnWOt699L(v6sWE!zh&!jgLA^C*N ziFrk~oS^{FmJBZC${iQYmT)IonsFWM#$TkW*-=(i;3P=n8 zF1g^!5ewF2@!h? zvrooe(hri}aK`xHbH`QtN`KESbo2tosea?o8VQ~|)u5mXxBeIe0R_3Um9^Nnw5B@+ z-(@Qe5bqRiCIA(<(otP@;>_%s+|iU-At|pqV}Dv=Dl$Y5h7BGne;bi?7m^FDJ&V8` zm6Zu9A}ff22;3#nsznY9OTrSvelT8%lCenc+al)ak_UQ(NFhPT>wn}R0HM{4%XBy& zZ5b0*emjv|fdM+&6(eh<&!zzpv_L=$E6O+Gu?Sw0N_PQB(j|$x9}SO2bgx%L-rD_R z%Ic6yLr!#$mlNKM!`B2o20If9-?MWiPBE$%j zFl1`~mUCg0l#?)(Dw8t}9+40ZlYb2$K>{LY9s)eO>w?uANb8XqQKzB#!n=__KSHH% pCoUjeMkEuP-|7CDV?J8Gh=&6DWT#w!)**z@p=;ThgauQTOR=Q@Ko|f3 literal 3680 zcmajido+|=9|!O~H>96=Sf^v z1CG#!$7jM^Qe$N1|A=aP#F+<9yu)7%na(c{{i==x5Rd%hiES$u3JaD5^%BhC$4*TdfIvK4*A+VYy@@ZYtEUY4~0H%Kp$y zqS1o9+%e;k3a5$HrXbJb)rXS#W6^5l`No=Sc}_Io2&oq{X_MN{`h_Y+FL%1#0A84t zZXB9ozr&<^Irg1a_(C9XgtTL-jjrn*Pd+iVeN%jPB5+dv#4`7+yh?S(wBr@5;*v9P zgs`}PJsp^<)B!=?mcYGEz#Yb%Nf}-{+FGMbb<4g4*sldHeE%u)gPvtE`z%;tS|+kz zfJexg;Eo5Xyfvv`JoH4+&xh+He7^o2uh0{+Y{s*;YxDTBvY1j?xc3~ z7H|g50vm70V({-GJzC_9Oz)wkXgLqB;^yB;FRo`0GYV-m}$lyiu+fG_olt)8s zEs?Mj_?M1-k#(7K?=}Zbe*HvVc8qzsV!}LHtT02@7m>cMi?Nl8Jvn6C4ICj2@%Q8a-%6#ima;l~15K_sn!7~&OD<-%RJr}OQ{nve4KueIfdRL4qG0dFg z7~u-;FYMm}+6Lzj)-qe?dcE7f!Sl&l!`a9a3|y1{j>par<_M2UZX zYu767VP;3<#gf(<;Nvlg3B9GV$GGQ3iwhryw_O8{5ZU@v_TRD5Uq7>pc*OZ3;JR() z9v7xU9FNA*rUv&HwO7`&7pkduS`9>YFd(XGUnW{x70vGPz0cp$%hnbg}@5Y&{ zjxm7Wz^tyavcl`PZXKzR2w*xL0WLg$dMBA@_?^U<4Un`B7Igt1Sf;m5TynOh#-(S= zy*~e_54f=Z9D3HJan%UvJLAfID6fHUnC>oq6V4#yWm*o|xhn^E0vGnTg}Aw#Rm+6l?0aBEO!b*(7n ZkBackend { - let noir_dir = temp_path.join("noir"); - let bb_binary = noir_dir.join("bin").join("bb"); - let circuits_dir = noir_dir.join("circuits"); - let work_dir = noir_dir.join("work").join("test_node"); - ZkBackend::new(bb_binary, circuits_dir, work_dir, config) -} - fn versions_json_path() -> PathBuf { PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("versions.json") } diff --git a/crates/zk-prover/tests/local_e2e_tests.rs b/crates/zk-prover/tests/local_e2e_tests.rs index ecf68e3ecd..cb1103cc98 100644 --- a/crates/zk-prover/tests/local_e2e_tests.rs +++ b/crates/zk-prover/tests/local_e2e_tests.rs @@ -14,7 +14,9 @@ mod common; -use common::fixtures_dir; +use common::{ + extract_field, extract_field_from_end, find_bb, setup_circuit_fixtures, setup_test_prover, +}; use e3_fhe_params::BfvPreset; use e3_zk_helpers::circuits::dkg::pk::circuit::PkCircuit; use e3_zk_helpers::circuits::dkg::pk::circuit::PkCircuitData; @@ -39,93 +41,7 @@ use e3_zk_helpers::{ compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment, compute_threshold_pk_commitment, }; -use e3_zk_prover::{Provable, ZkBackend, ZkConfig, ZkProver}; -use std::path::PathBuf; -use tempfile::TempDir; -use tokio::{fs, process::Command}; - -use crate::common::extract_field; -use crate::common::extract_field_from_end; - -async fn find_bb() -> Option { - if let Ok(output) = Command::new("which").arg("bb").output().await { - if output.status.success() { - let path = String::from_utf8_lossy(&output.stdout).trim().to_string(); - if !path.is_empty() { - return Some(PathBuf::from(path)); - } - } - } - if let Ok(home) = std::env::var("HOME") { - for path in [ - format!("{}/.bb/bb", home), - format!("{}/.nargo/bin/bb", home), - format!("{}/.enclave/noir/bin/bb", home), - ] { - if std::path::Path::new(&path).exists() { - return Some(PathBuf::from(path)); - } - } - } - None -} - -async fn setup_test_prover(bb: &PathBuf) -> (ZkBackend, tempfile::TempDir) { - let target_tmp = env!("CARGO_TARGET_TMPDIR"); - let temp = TempDir::new_in(target_tmp).unwrap(); - - let temp_path = temp.path(); - let noir_dir = temp_path.join("noir"); - let bb_binary = noir_dir.join("bin").join("bb"); - let circuits_dir = noir_dir.join("circuits"); - let work_dir = noir_dir.join("work").join("test_node"); - let backend = ZkBackend::new( - bb_binary.clone(), - circuits_dir.clone(), - work_dir.clone(), - ZkConfig::default(), - ); - - fs::create_dir_all(&backend.circuits_dir).await.unwrap(); - fs::create_dir_all(backend.circuits_dir.join("vk")) - .await - .unwrap(); - fs::create_dir_all(&backend.work_dir).await.unwrap(); - fs::create_dir_all(backend.base_dir.join("bin")) - .await - .unwrap(); - - #[cfg(unix)] - std::os::unix::fs::symlink(bb, &backend.bb_binary).unwrap(); - - (backend, temp) -} - -async fn setup_circuit_fixtures(backend: &ZkBackend, circuit_path: &[&str], fixture_name: &str) { - let fixtures = fixtures_dir(); - let json_path = fixtures.join(format!("{fixture_name}.json")); - let vk_path = fixtures.join(format!("{fixture_name}.vk")); - assert!( - json_path.exists(), - "missing circuit fixture: {} (run `pnpm sync:fixtures` to copy from circuits target)", - json_path.display() - ); - assert!( - vk_path.exists(), - "missing verification key fixture: {}", - vk_path.display() - ); - let circuit_dir = circuit_path - .iter() - .fold(backend.circuits_dir.clone(), |p, seg| p.join(seg)); - fs::create_dir_all(&circuit_dir).await.unwrap(); - fs::copy(json_path, circuit_dir.join(format!("{fixture_name}.json"))) - .await - .unwrap(); - fs::copy(vk_path, circuit_dir.join(format!("{fixture_name}.vk"))) - .await - .unwrap(); -} +use e3_zk_prover::{Provable, ZkBackend, ZkProver}; async fn setup_share_encryption_e_sm_test() -> Option<( ZkBackend, diff --git a/crates/zk-prover/tests/onchain_verification_tests.rs b/crates/zk-prover/tests/onchain_verification_tests.rs new file mode 100644 index 0000000000..76b128a8ee --- /dev/null +++ b/crates/zk-prover/tests/onchain_verification_tests.rs @@ -0,0 +1,255 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! On-chain ZK proof verification tests. +//! Requires: `bb`, `anvil`, and compiled contract artifacts +//! (`npx hardhat compile` in packages/enclave-contracts). + +mod common; + +use alloy::{ + network::TransactionBuilder, + primitives::{Bytes, FixedBytes}, + providers::{Provider, ProviderBuilder}, + rpc::types::TransactionRequest, + sol, +}; +use common::{find_anvil, find_bb, setup_circuit_fixtures, setup_test_prover}; +use e3_fhe_params::BfvPreset; +use e3_zk_helpers::circuits::dkg::pk::circuit::{PkCircuit, PkCircuitData}; +use e3_zk_prover::{Provable, ZkProver}; +use std::path::PathBuf; +use tokio::{fs, process::Command}; + +sol! { + #[sol(rpc)] + contract DkgPkVerifier { + function verify(bytes calldata proof, bytes32[] calldata publicInputs) external view returns (bool verified); + } +} + +/// Linker placeholder that gets replaced with the deployed ZKTranscriptLib address. +const ZK_TRANSCRIPT_LIB_PLACEHOLDER: &str = "__$3f925933ac313a1c84f3f4c25b9ea43c90$__"; + +fn artifacts_dir() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol") +} + +fn read_artifact_bytecode_hex(artifact_name: &str) -> Option { + let path = artifacts_dir().join(artifact_name); + let json_str = std::fs::read_to_string(&path).ok()?; + let json: serde_json::Value = serde_json::from_str(&json_str).ok()?; + json["bytecode"].as_str().map(|s| s.to_string()) +} + +fn decode_bytecode(hex_str: &str) -> Vec { + let clean = hex_str.strip_prefix("0x").unwrap_or(hex_str); + hex::decode(clean).expect("failed to decode bytecode hex") +} + +fn link_transcript_lib(bytecode_hex: &str, lib_address: &alloy::primitives::Address) -> Vec { + let addr_hex = hex::encode(lib_address.as_slice()); + let linked = bytecode_hex.replace(ZK_TRANSCRIPT_LIB_PLACEHOLDER, &addr_hex); + decode_bytecode(&linked) +} + +#[tokio::test] +async fn test_pk_bfv_onchain_verification() { + // Generate ZK proof + + let bb = match find_bb().await { + Some(bb) => bb, + None => { + println!("skipping: bb not found"); + return; + } + }; + + let preset = BfvPreset::InsecureThreshold512; + let (backend, _temp) = setup_test_prover(&bb).await; + setup_circuit_fixtures(&backend, &["dkg", "pk"], "pk").await; + + let sample = match PkCircuitData::generate_sample(preset) { + Ok(s) => s, + Err(e) => { + println!("skipping: failed to generate sample: {e}"); + return; + } + }; + + let prover = ZkProver::new(&backend); + let e3_id = "0"; + + let proof = PkCircuit + .prove(&prover, &preset, &sample, e3_id) + .expect("proof generation should succeed"); + + assert!(!proof.data.is_empty(), "proof data should not be empty"); + assert!( + !proof.public_signals.is_empty(), + "public signals should not be empty" + ); + + let local_ok = PkCircuit.verify(&prover, &proof, e3_id, 1); + assert!( + local_ok.as_ref().is_ok_and(|&v| v), + "local proof verification failed: {local_ok:?}" + ); + + // Re-prove with `--oracle_hash keccak` for on-chain verification. + // The default ultra_honk proof uses Poseidon2 (for recursive verification in Noir), + // but the Solidity verifier expects a keccak-based Fiat-Shamir transcript. + // We reuse the witness file already written by prove() above. + + let circuit_dir = backend.circuits_dir.join("dkg").join("pk"); + let circuit_path = circuit_dir.join("pk.json"); + let vk_path = circuit_dir.join("pk.vk"); + let job_dir = backend.work_dir.join(e3_id); + let witness_path = job_dir.join("witness.gz"); + let onchain_out = job_dir.join("onchain_out"); + fs::create_dir_all(&onchain_out).await.unwrap(); + + let keccak_output = Command::new(&backend.bb_binary) + .args([ + "prove", + "--scheme", + "ultra_honk", + "--oracle_hash", + "keccak", + "-b", + &circuit_path.to_string_lossy(), + "-w", + &witness_path.to_string_lossy(), + "-k", + &vk_path.to_string_lossy(), + "-o", + &onchain_out.to_string_lossy(), + ]) + .output() + .await + .expect("failed to run bb prove with keccak oracle hash"); + + assert!( + keccak_output.status.success(), + "bb prove --oracle_hash keccak failed:\nstderr: {}\nstdout: {}", + String::from_utf8_lossy(&keccak_output.stderr), + String::from_utf8_lossy(&keccak_output.stdout), + ); + + let onchain_proof_data = fs::read(onchain_out.join("proof")).await.unwrap(); + let onchain_public_signals = fs::read(onchain_out.join("public_inputs")).await.unwrap(); + + println!( + "keccak proof: {} bytes, public_inputs: {} bytes", + onchain_proof_data.len(), + onchain_public_signals.len() + ); + + // Deploy verifier contract to Anvil + + let lib_bytecode_hex = match read_artifact_bytecode_hex("ZKTranscriptLib.json") { + Some(h) => h, + None => { + println!( + "skipping: ZKTranscriptLib artifact not found \ + (run `npx hardhat compile` in packages/enclave-contracts)" + ); + return; + } + }; + let verifier_bytecode_hex = match read_artifact_bytecode_hex("DkgPkVerifier.json") { + Some(h) => h, + None => { + println!( + "skipping: DkgPkVerifier artifact not found \ + (run `npx hardhat compile` in packages/enclave-contracts)" + ); + return; + } + }; + + if !find_anvil().await { + println!("skipping: anvil not found on PATH"); + return; + } + + let provider = ProviderBuilder::new().connect_anvil_with_wallet(); + + let lib_bytecode = decode_bytecode(&lib_bytecode_hex); + let lib_deploy_tx = TransactionRequest::default().with_deploy_code(Bytes::from(lib_bytecode)); + let lib_receipt = provider + .send_transaction(lib_deploy_tx) + .await + .expect("failed to send ZKTranscriptLib deploy tx") + .get_receipt() + .await + .expect("failed to get ZKTranscriptLib deploy receipt"); + let lib_address = lib_receipt + .contract_address + .expect("ZKTranscriptLib deploy receipt missing contract address"); + println!("ZKTranscriptLib deployed at: {lib_address}"); + + let linked_bytecode = link_transcript_lib(&verifier_bytecode_hex, &lib_address); + let verifier_deploy_tx = + TransactionRequest::default().with_deploy_code(Bytes::from(linked_bytecode)); + let verifier_receipt = provider + .send_transaction(verifier_deploy_tx) + .await + .expect("failed to send DkgPkVerifier deploy tx") + .get_receipt() + .await + .expect("failed to get DkgPkVerifier deploy receipt"); + let verifier_address = verifier_receipt + .contract_address + .expect("DkgPkVerifier deploy receipt missing contract address"); + println!("DkgPkVerifier deployed at: {verifier_address}"); + + let verifier = DkgPkVerifier::new(verifier_address, &provider); + + // Verify proof on-chain + + let proof_bytes = Bytes::from(onchain_proof_data); + + // pk_bfv has 17 public inputs, 16 are pairing points baked into the proof, + // so only 1 (the pk commitment) gets passed as publicInputs to the contract. + let public_inputs: Vec> = onchain_public_signals + .chunks(32) + .map(|chunk| { + let mut buf = [0u8; 32]; + buf[..chunk.len()].copy_from_slice(chunk); + FixedBytes::from(buf) + }) + .collect(); + + assert_eq!( + public_inputs.len(), + 1, + "pk_bfv circuit should produce exactly 1 public input (commitment), got {}", + public_inputs.len() + ); + + println!( + "calling on-chain verify with {} proof bytes, {} public input(s)", + proof_bytes.len(), + public_inputs.len() + ); + + let verified = verifier + .verify(proof_bytes, public_inputs) + .call() + .await + .expect("on-chain verification call reverted — the proof should be valid"); + + assert!( + verified, + "on-chain ZK proof verification should return true" + ); + + println!("on-chain verification passed"); + + prover.cleanup(e3_id).unwrap(); +} diff --git a/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol b/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol index 51a8dac58d..04a372f081 100644 --- a/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol +++ b/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol @@ -10,143 +10,143 @@ uint256 constant LOG_N = 19; uint256 constant NUMBER_OF_PUBLIC_INPUTS = 23; uint256 constant VK_HASH = 0x2349c3d182cb0307ecfa17d2cb91dcf9e7742a8daa67aa106831c761dd22030d; library HonkVerificationKey { - function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) { - Honk.VerificationKey memory vk = Honk.VerificationKey({ - circuitSize: uint256(524288), - logCircuitSize: uint256(19), - publicInputsSize: uint256(23), - ql: Honk.G1Point({ - x: uint256(0x253c5186ca1b682f7d302cd73b85ea3447a5a2c64fc82b70652f7fc44b203128), - y: uint256(0x14f602413e183c57d3d3124290ab48b6c8b0cbace773766a573ead30bf5c2f4f) - }), - qr: Honk.G1Point({ - x: uint256(0x2d20633d112c7c7efd2821f2860e9d1287f8f68ddd4b0216bb179078497a571c), - y: uint256(0x11928235f13ba529b1ee2f75fe26dda5ed5c79ec36028c09ad2bd8b957546344) - }), - qo: Honk.G1Point({ - x: uint256(0x2b570f8e2eccc265f39b9e73778cf6e282554452adb19d2a2406952447d4aa6e), - y: uint256(0x14afd678c64e0dacd64724504e36bca6eccb5a477a5e2987b6543246b8135a90) - }), - q4: Honk.G1Point({ - x: uint256(0x2d7f53a245e9c855325eeb73c8fea788f5b457293cacfd7e3e332210a27a7d2f), - y: uint256(0x182d5ef8840426caa829856d7e800ee98509383d9ee637d1facbc11f7a8fba0d) - }), - qm: Honk.G1Point({ - x: uint256(0x19d90118c106191d2f2f0350a56547c943c1ed5910d47dd067761099b54d11f3), - y: uint256(0x0f8f03c2def6108448f72f5177b6a2eed01250670efb63ea6f5ab65abc2a6885) - }), - qc: Honk.G1Point({ - x: uint256(0x2ead500c79e717f5cdbba88ffef46477c4f30926bf59547a9c141c4158f7c843), - y: uint256(0x027d6b571b395cf61aae9626f172ce4e41e598456f7b8e535c027e9129b2c98e) - }), - qLookup: Honk.G1Point({ - x: uint256(0x136236e1bfc2af648ac078e134c1b4b9114b11937ebafcdd87f8ca7660715ebb), - y: uint256(0x02293c705250462935a653b7b993e13e2e8bc6480c45c84976d526cbdbd071df) - }), - qArith: Honk.G1Point({ - x: uint256(0x074e7ead679c76d2c2d6d3f158cb522e71d14a169b2b1d0792cdfdad726f17a4), - y: uint256(0x21f9acd78d4150858f29c259c07e4552f6ec4bffac6c1e174cfb90e2e26bd68a) - }), - qDeltaRange: Honk.G1Point({ - x: uint256(0x0cebfba75751a4eff3d7855bf0f314e523e2c709a75992eb5674a546627248e3), - y: uint256(0x16b715150f4de399940c535932174f5c634c9fd9137a94008bb38f89f1350b4c) - }), - qElliptic: Honk.G1Point({ - x: uint256(0x174dba7fa4e38a55a78e43dda6c3fb81a1293285cf33eeb333ee186bb4331563), - y: uint256(0x0a2ff722359e35596e5abeec834c6cd73f4b06f5f2e837b31364f199f449ca77) - }), - qMemory: Honk.G1Point({ - x: uint256(0x29f116092db8eb3773b017110ca5d3a7b35fa1b064cde91c9e280e20399d7ec2), - y: uint256(0x1f0e39e18ded75167a270d6e31b9a6ad9a9d1b0d67c365eeb172a3fea4d1371e) - }), - qNnf: Honk.G1Point({ - x: uint256(0x19da50fca27dd36a006892b7cb6b36d7cfdac9d65fec6ae7a1a2e092e0988de5), - y: uint256(0x08f96f1d8e37be6dc83c9fbb3b912493841e4e81ab28a60c0fc85337cc4ed977) - }), - qPoseidon2External: Honk.G1Point({ - x: uint256(0x2d20446a333063e66c1a552fecdfe12d0fdddeef0034569ac350f3299b09955a), - y: uint256(0x175e6e8776625134217ce9516a11cbbeab8c4c1c8b41cfb75f43de1f500b07d2) - }), - qPoseidon2Internal: Honk.G1Point({ - x: uint256(0x090a76cca3c754a2ba40abdc2572fff64645060cfa5c48239a1df4dbb8360828), - y: uint256(0x0499d4c6aed1f78b33a6701459cd069e9bf7262754d2f15074a6c2401950761f) - }), - s1: Honk.G1Point({ - x: uint256(0x012609fcd0fa67214d78f2d5f5e3e2b459a3c4b21531646de7d51d9cd5383aa9), - y: uint256(0x21394cebbe5f66f3aecf43d318b3cb9fc7640825baba0c5a5c190a20ceeb5edb) - }), - s2: Honk.G1Point({ - x: uint256(0x080c7f024d9c813c60c84fc3e9bcad553c51f276d55e8d7a03c044b41cedef36), - y: uint256(0x2109db10b2da84ec2c4a1b62689d0952ababe94915293dfee09f1083010e5cfb) - }), - s3: Honk.G1Point({ - x: uint256(0x2f7d6b77cd5c3ee56c255be61d0e90fd7da5898a7ce4850aaf1060513cb7cd9d), - y: uint256(0x2ce5fdacbf91fc3358f4eba637d60f109f70fa929a6a1bc1f9d86e7856b87dcd) - }), - s4: Honk.G1Point({ - x: uint256(0x1db1540beb4dc13e8519b82205e9b4cb48833040c8b322d626df57e078afecc4), - y: uint256(0x28eb12f9f02ac092326277365f9eeaff536b8dbf771f9ace22d0e122f922196a) - }), - t1: Honk.G1Point({ - x: uint256(0x1f16b037f0b4c96ea2a30a118a44e139881c0db8a4d6c9fde7db5c1c1738e61f), - y: uint256(0x00c7781bda34afc32dedfb0d0f6b16c987c83375da000e180b44ad25685fc2ae) - }), - t2: Honk.G1Point({ - x: uint256(0x29345f914a28707887bee191c3a928191de584827a6d1a78ccce1d7629ca9dc0), - y: uint256(0x1920cebd0b33ac9713424e3bc03d53d79dc72f6afc24c90e56593094a213444c) - }), - t3: Honk.G1Point({ - x: uint256(0x261c990958bc2ef77a45467d9639ab2c68cf787ff7bce55ce3074dfdaedc8f8f), - y: uint256(0x23c1c05424a40360a61e46f4deab04988a6f5b71dda351e0da608cff1f332ee0) - }), - t4: Honk.G1Point({ - x: uint256(0x2b651d2fd644b2972d72ec439dc69d3339d0b052a296bfc48c6a08396aaca078), - y: uint256(0x2d7e8c1ecb92e2490049b50efc811df63f1ca97e58d5e82852dbec0c29715d71) - }), - id1: Honk.G1Point({ - x: uint256(0x0a10b2e79989b15e3a69bd491cdae007b0bf9c82d9be3d7867b33e2287b91dac), - y: uint256(0x257794eaba7a0e7aed16e03d4d8c4cf7d878b029f4ea45c559bbc19b5ec4d1de) - }), - id2: Honk.G1Point({ - x: uint256(0x25791b725ea7c712316ac4ffe10fdfcf37bd2b8f9d730ba2e26fa709bc7c3ae0), - y: uint256(0x15fba3e7928d36dc4dd6d6ff198b928c7246310974d4f74161cfd2781b9d3686) - }), - id3: Honk.G1Point({ - x: uint256(0x270be32427e6404801b9b014f983d80acf18b828c6cf049f430d98fbe34e85e0), - y: uint256(0x2e7d27a99c4b574557ea6117c390c65072cdfa51a08621141ae26d7e143d0669) - }), - id4: Honk.G1Point({ - x: uint256(0x18e2902febdb3e45358fe65981f338a7ffd1b16edd917de670fabe5d15307e20), - y: uint256(0x2f6f36f307a0f7012dc3918795312e71a1d4752966c2bc3151e5f5b3151fc236) - }), - lagrangeFirst: Honk.G1Point({ - x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001), - y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002) - }), - lagrangeLast: Honk.G1Point({ - x: uint256(0x12b14f226e24a52e0bc85bc5478c806023107f257430aae49136064dd3315c60), - y: uint256(0x0dfe490435cf839caf81df5c8a164afc5e3c8646f36bf27c19850b3f913edce4) - }) - }); - return vk; - } + function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) { + Honk.VerificationKey memory vk = Honk.VerificationKey({ + circuitSize: uint256(524288), + logCircuitSize: uint256(19), + publicInputsSize: uint256(23), + ql: Honk.G1Point({ + x: uint256(0x253c5186ca1b682f7d302cd73b85ea3447a5a2c64fc82b70652f7fc44b203128), + y: uint256(0x14f602413e183c57d3d3124290ab48b6c8b0cbace773766a573ead30bf5c2f4f) + }), + qr: Honk.G1Point({ + x: uint256(0x2d20633d112c7c7efd2821f2860e9d1287f8f68ddd4b0216bb179078497a571c), + y: uint256(0x11928235f13ba529b1ee2f75fe26dda5ed5c79ec36028c09ad2bd8b957546344) + }), + qo: Honk.G1Point({ + x: uint256(0x2b570f8e2eccc265f39b9e73778cf6e282554452adb19d2a2406952447d4aa6e), + y: uint256(0x14afd678c64e0dacd64724504e36bca6eccb5a477a5e2987b6543246b8135a90) + }), + q4: Honk.G1Point({ + x: uint256(0x2d7f53a245e9c855325eeb73c8fea788f5b457293cacfd7e3e332210a27a7d2f), + y: uint256(0x182d5ef8840426caa829856d7e800ee98509383d9ee637d1facbc11f7a8fba0d) + }), + qm: Honk.G1Point({ + x: uint256(0x19d90118c106191d2f2f0350a56547c943c1ed5910d47dd067761099b54d11f3), + y: uint256(0x0f8f03c2def6108448f72f5177b6a2eed01250670efb63ea6f5ab65abc2a6885) + }), + qc: Honk.G1Point({ + x: uint256(0x2ead500c79e717f5cdbba88ffef46477c4f30926bf59547a9c141c4158f7c843), + y: uint256(0x027d6b571b395cf61aae9626f172ce4e41e598456f7b8e535c027e9129b2c98e) + }), + qLookup: Honk.G1Point({ + x: uint256(0x136236e1bfc2af648ac078e134c1b4b9114b11937ebafcdd87f8ca7660715ebb), + y: uint256(0x02293c705250462935a653b7b993e13e2e8bc6480c45c84976d526cbdbd071df) + }), + qArith: Honk.G1Point({ + x: uint256(0x074e7ead679c76d2c2d6d3f158cb522e71d14a169b2b1d0792cdfdad726f17a4), + y: uint256(0x21f9acd78d4150858f29c259c07e4552f6ec4bffac6c1e174cfb90e2e26bd68a) + }), + qDeltaRange: Honk.G1Point({ + x: uint256(0x0cebfba75751a4eff3d7855bf0f314e523e2c709a75992eb5674a546627248e3), + y: uint256(0x16b715150f4de399940c535932174f5c634c9fd9137a94008bb38f89f1350b4c) + }), + qElliptic: Honk.G1Point({ + x: uint256(0x174dba7fa4e38a55a78e43dda6c3fb81a1293285cf33eeb333ee186bb4331563), + y: uint256(0x0a2ff722359e35596e5abeec834c6cd73f4b06f5f2e837b31364f199f449ca77) + }), + qMemory: Honk.G1Point({ + x: uint256(0x29f116092db8eb3773b017110ca5d3a7b35fa1b064cde91c9e280e20399d7ec2), + y: uint256(0x1f0e39e18ded75167a270d6e31b9a6ad9a9d1b0d67c365eeb172a3fea4d1371e) + }), + qNnf: Honk.G1Point({ + x: uint256(0x19da50fca27dd36a006892b7cb6b36d7cfdac9d65fec6ae7a1a2e092e0988de5), + y: uint256(0x08f96f1d8e37be6dc83c9fbb3b912493841e4e81ab28a60c0fc85337cc4ed977) + }), + qPoseidon2External: Honk.G1Point({ + x: uint256(0x2d20446a333063e66c1a552fecdfe12d0fdddeef0034569ac350f3299b09955a), + y: uint256(0x175e6e8776625134217ce9516a11cbbeab8c4c1c8b41cfb75f43de1f500b07d2) + }), + qPoseidon2Internal: Honk.G1Point({ + x: uint256(0x090a76cca3c754a2ba40abdc2572fff64645060cfa5c48239a1df4dbb8360828), + y: uint256(0x0499d4c6aed1f78b33a6701459cd069e9bf7262754d2f15074a6c2401950761f) + }), + s1: Honk.G1Point({ + x: uint256(0x012609fcd0fa67214d78f2d5f5e3e2b459a3c4b21531646de7d51d9cd5383aa9), + y: uint256(0x21394cebbe5f66f3aecf43d318b3cb9fc7640825baba0c5a5c190a20ceeb5edb) + }), + s2: Honk.G1Point({ + x: uint256(0x080c7f024d9c813c60c84fc3e9bcad553c51f276d55e8d7a03c044b41cedef36), + y: uint256(0x2109db10b2da84ec2c4a1b62689d0952ababe94915293dfee09f1083010e5cfb) + }), + s3: Honk.G1Point({ + x: uint256(0x2f7d6b77cd5c3ee56c255be61d0e90fd7da5898a7ce4850aaf1060513cb7cd9d), + y: uint256(0x2ce5fdacbf91fc3358f4eba637d60f109f70fa929a6a1bc1f9d86e7856b87dcd) + }), + s4: Honk.G1Point({ + x: uint256(0x1db1540beb4dc13e8519b82205e9b4cb48833040c8b322d626df57e078afecc4), + y: uint256(0x28eb12f9f02ac092326277365f9eeaff536b8dbf771f9ace22d0e122f922196a) + }), + t1: Honk.G1Point({ + x: uint256(0x1f16b037f0b4c96ea2a30a118a44e139881c0db8a4d6c9fde7db5c1c1738e61f), + y: uint256(0x00c7781bda34afc32dedfb0d0f6b16c987c83375da000e180b44ad25685fc2ae) + }), + t2: Honk.G1Point({ + x: uint256(0x29345f914a28707887bee191c3a928191de584827a6d1a78ccce1d7629ca9dc0), + y: uint256(0x1920cebd0b33ac9713424e3bc03d53d79dc72f6afc24c90e56593094a213444c) + }), + t3: Honk.G1Point({ + x: uint256(0x261c990958bc2ef77a45467d9639ab2c68cf787ff7bce55ce3074dfdaedc8f8f), + y: uint256(0x23c1c05424a40360a61e46f4deab04988a6f5b71dda351e0da608cff1f332ee0) + }), + t4: Honk.G1Point({ + x: uint256(0x2b651d2fd644b2972d72ec439dc69d3339d0b052a296bfc48c6a08396aaca078), + y: uint256(0x2d7e8c1ecb92e2490049b50efc811df63f1ca97e58d5e82852dbec0c29715d71) + }), + id1: Honk.G1Point({ + x: uint256(0x0a10b2e79989b15e3a69bd491cdae007b0bf9c82d9be3d7867b33e2287b91dac), + y: uint256(0x257794eaba7a0e7aed16e03d4d8c4cf7d878b029f4ea45c559bbc19b5ec4d1de) + }), + id2: Honk.G1Point({ + x: uint256(0x25791b725ea7c712316ac4ffe10fdfcf37bd2b8f9d730ba2e26fa709bc7c3ae0), + y: uint256(0x15fba3e7928d36dc4dd6d6ff198b928c7246310974d4f74161cfd2781b9d3686) + }), + id3: Honk.G1Point({ + x: uint256(0x270be32427e6404801b9b014f983d80acf18b828c6cf049f430d98fbe34e85e0), + y: uint256(0x2e7d27a99c4b574557ea6117c390c65072cdfa51a08621141ae26d7e143d0669) + }), + id4: Honk.G1Point({ + x: uint256(0x18e2902febdb3e45358fe65981f338a7ffd1b16edd917de670fabe5d15307e20), + y: uint256(0x2f6f36f307a0f7012dc3918795312e71a1d4752966c2bc3151e5f5b3151fc236) + }), + lagrangeFirst: Honk.G1Point({ + x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001), + y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002) + }), + lagrangeLast: Honk.G1Point({ + x: uint256(0x12b14f226e24a52e0bc85bc5478c806023107f257430aae49136064dd3315c60), + y: uint256(0x0dfe490435cf839caf81df5c8a164afc5e3c8646f36bf27c19850b3f913edce4) + }) + }); + return vk; + } } pragma solidity ^0.8.27; interface IVerifier { - function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external returns (bool); + function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external returns (bool); } type Fr is uint256; -using {add as +} for Fr global; -using {sub as -} for Fr global; -using {mul as *} for Fr global; +using { add as + } for Fr global; +using { sub as - } for Fr global; +using { mul as * } for Fr global; -using {exp as ^} for Fr global; -using {notEqual as !=} for Fr global; -using {equal as ==} for Fr global; +using { exp as ^ } for Fr global; +using { notEqual as != } for Fr global; +using { equal as == } for Fr global; uint256 constant SUBGROUP_SIZE = 256; uint256 constant MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617; // Prime field order @@ -159,135 +159,135 @@ Fr constant ZERO = Fr.wrap(0); // Instantiation library FrLib { - function from(uint256 value) internal pure returns (Fr) { - unchecked { - return Fr.wrap(value % MODULUS); - } - } - - function fromBytes32(bytes32 value) internal pure returns (Fr) { - unchecked { - return Fr.wrap(uint256(value) % MODULUS); - } - } - - function toBytes32(Fr value) internal pure returns (bytes32) { - unchecked { - return bytes32(Fr.unwrap(value)); - } - } - - function invert(Fr value) internal view returns (Fr) { - uint256 v = Fr.unwrap(value); - uint256 result; - - // Call the modexp precompile to invert in the field - assembly { - let free := mload(0x40) - mstore(free, 0x20) - mstore(add(free, 0x20), 0x20) - mstore(add(free, 0x40), 0x20) - mstore(add(free, 0x60), v) - mstore(add(free, 0x80), sub(MODULUS, 2)) - mstore(add(free, 0xa0), MODULUS) - let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) - if iszero(success) { - revert(0, 0) - } - result := mload(0x00) - mstore(0x40, add(free, 0x80)) - } - - return Fr.wrap(result); - } - - function pow(Fr base, uint256 v) internal view returns (Fr) { - uint256 b = Fr.unwrap(base); - uint256 result; - - // Call the modexp precompile to invert in the field - assembly { - let free := mload(0x40) - mstore(free, 0x20) - mstore(add(free, 0x20), 0x20) - mstore(add(free, 0x40), 0x20) - mstore(add(free, 0x60), b) - mstore(add(free, 0x80), v) - mstore(add(free, 0xa0), MODULUS) - let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) - if iszero(success) { - revert(0, 0) - } - result := mload(0x00) - mstore(0x40, add(free, 0x80)) - } - - return Fr.wrap(result); - } - - function div(Fr numerator, Fr denominator) internal view returns (Fr) { - unchecked { - return numerator * invert(denominator); - } - } - - function sqr(Fr value) internal pure returns (Fr) { - unchecked { - return value * value; - } - } - - function unwrap(Fr value) internal pure returns (uint256) { - unchecked { - return Fr.unwrap(value); - } - } - - function neg(Fr value) internal pure returns (Fr) { - unchecked { - return Fr.wrap(MODULUS - Fr.unwrap(value)); - } + function from(uint256 value) internal pure returns (Fr) { + unchecked { + return Fr.wrap(value % MODULUS); + } + } + + function fromBytes32(bytes32 value) internal pure returns (Fr) { + unchecked { + return Fr.wrap(uint256(value) % MODULUS); + } + } + + function toBytes32(Fr value) internal pure returns (bytes32) { + unchecked { + return bytes32(Fr.unwrap(value)); + } + } + + function invert(Fr value) internal view returns (Fr) { + uint256 v = Fr.unwrap(value); + uint256 result; + + // Call the modexp precompile to invert in the field + assembly { + let free := mload(0x40) + mstore(free, 0x20) + mstore(add(free, 0x20), 0x20) + mstore(add(free, 0x40), 0x20) + mstore(add(free, 0x60), v) + mstore(add(free, 0x80), sub(MODULUS, 2)) + mstore(add(free, 0xa0), MODULUS) + let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) + if iszero(success) { + revert(0, 0) + } + result := mload(0x00) + mstore(0x40, add(free, 0x80)) + } + + return Fr.wrap(result); + } + + function pow(Fr base, uint256 v) internal view returns (Fr) { + uint256 b = Fr.unwrap(base); + uint256 result; + + // Call the modexp precompile to invert in the field + assembly { + let free := mload(0x40) + mstore(free, 0x20) + mstore(add(free, 0x20), 0x20) + mstore(add(free, 0x40), 0x20) + mstore(add(free, 0x60), b) + mstore(add(free, 0x80), v) + mstore(add(free, 0xa0), MODULUS) + let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) + if iszero(success) { + revert(0, 0) + } + result := mload(0x00) + mstore(0x40, add(free, 0x80)) + } + + return Fr.wrap(result); + } + + function div(Fr numerator, Fr denominator) internal view returns (Fr) { + unchecked { + return numerator * invert(denominator); } + } + + function sqr(Fr value) internal pure returns (Fr) { + unchecked { + return value * value; + } + } + + function unwrap(Fr value) internal pure returns (uint256) { + unchecked { + return Fr.unwrap(value); + } + } + + function neg(Fr value) internal pure returns (Fr) { + unchecked { + return Fr.wrap(MODULUS - Fr.unwrap(value)); + } + } } // Free functions function add(Fr a, Fr b) pure returns (Fr) { - unchecked { - return Fr.wrap(addmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); - } + unchecked { + return Fr.wrap(addmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); + } } function mul(Fr a, Fr b) pure returns (Fr) { - unchecked { - return Fr.wrap(mulmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); - } + unchecked { + return Fr.wrap(mulmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); + } } function sub(Fr a, Fr b) pure returns (Fr) { - unchecked { - return Fr.wrap(addmod(Fr.unwrap(a), MODULUS - Fr.unwrap(b), MODULUS)); - } + unchecked { + return Fr.wrap(addmod(Fr.unwrap(a), MODULUS - Fr.unwrap(b), MODULUS)); + } } function exp(Fr base, Fr exponent) pure returns (Fr) { - if (Fr.unwrap(exponent) == 0) return Fr.wrap(1); - // Implement exponent with a loop as we will overflow otherwise - for (uint256 i = 1; i < Fr.unwrap(exponent); i += i) { - base = base * base; - } - return base; + if (Fr.unwrap(exponent) == 0) return Fr.wrap(1); + // Implement exponent with a loop as we will overflow otherwise + for (uint256 i = 1; i < Fr.unwrap(exponent); i += i) { + base = base * base; + } + return base; } function notEqual(Fr a, Fr b) pure returns (bool) { - unchecked { - return Fr.unwrap(a) != Fr.unwrap(b); - } + unchecked { + return Fr.unwrap(a) != Fr.unwrap(b); + } } function equal(Fr a, Fr b) pure returns (bool) { - unchecked { - return Fr.unwrap(a) == Fr.unwrap(b); - } + unchecked { + return Fr.unwrap(a) == Fr.unwrap(b); + } } uint256 constant CONST_PROOF_SIZE_LOG_N = 28; @@ -308,1332 +308,1325 @@ uint256 constant NUMBER_OF_ALPHAS = NUMBER_OF_SUBRELATIONS - 1; // ENUM FOR WIRES enum WIRE { - Q_M, - Q_C, - Q_L, - Q_R, - Q_O, - Q_4, - Q_LOOKUP, - Q_ARITH, - Q_RANGE, - Q_ELLIPTIC, - Q_MEMORY, - Q_NNF, - Q_POSEIDON2_EXTERNAL, - Q_POSEIDON2_INTERNAL, - SIGMA_1, - SIGMA_2, - SIGMA_3, - SIGMA_4, - ID_1, - ID_2, - ID_3, - ID_4, - TABLE_1, - TABLE_2, - TABLE_3, - TABLE_4, - LAGRANGE_FIRST, - LAGRANGE_LAST, - W_L, - W_R, - W_O, - W_4, - Z_PERM, - LOOKUP_INVERSES, - LOOKUP_READ_COUNTS, - LOOKUP_READ_TAGS, - W_L_SHIFT, - W_R_SHIFT, - W_O_SHIFT, - W_4_SHIFT, - Z_PERM_SHIFT + Q_M, + Q_C, + Q_L, + Q_R, + Q_O, + Q_4, + Q_LOOKUP, + Q_ARITH, + Q_RANGE, + Q_ELLIPTIC, + Q_MEMORY, + Q_NNF, + Q_POSEIDON2_EXTERNAL, + Q_POSEIDON2_INTERNAL, + SIGMA_1, + SIGMA_2, + SIGMA_3, + SIGMA_4, + ID_1, + ID_2, + ID_3, + ID_4, + TABLE_1, + TABLE_2, + TABLE_3, + TABLE_4, + LAGRANGE_FIRST, + LAGRANGE_LAST, + W_L, + W_R, + W_O, + W_4, + Z_PERM, + LOOKUP_INVERSES, + LOOKUP_READ_COUNTS, + LOOKUP_READ_TAGS, + W_L_SHIFT, + W_R_SHIFT, + W_O_SHIFT, + W_4_SHIFT, + Z_PERM_SHIFT } library Honk { - struct G1Point { - uint256 x; - uint256 y; - } - - struct VerificationKey { - // Misc Params - uint256 circuitSize; - uint256 logCircuitSize; - uint256 publicInputsSize; - // Selectors - G1Point qm; - G1Point qc; - G1Point ql; - G1Point qr; - G1Point qo; - G1Point q4; - G1Point qLookup; // Lookup - G1Point qArith; // Arithmetic widget - G1Point qDeltaRange; // Delta Range sort - G1Point qMemory; // Memory - G1Point qNnf; // Non-native Field - G1Point qElliptic; // Auxillary - G1Point qPoseidon2External; - G1Point qPoseidon2Internal; - // Copy cnstraints - G1Point s1; - G1Point s2; - G1Point s3; - G1Point s4; - // Copy identity - G1Point id1; - G1Point id2; - G1Point id3; - G1Point id4; - // Precomputed lookup table - G1Point t1; - G1Point t2; - G1Point t3; - G1Point t4; - // Fixed first and last - G1Point lagrangeFirst; - G1Point lagrangeLast; - } - - struct RelationParameters { - // challenges - Fr eta; - Fr etaTwo; - Fr etaThree; - Fr beta; - Fr gamma; - // derived - Fr publicInputsDelta; - } - - struct Proof { - // Pairing point object - Fr[PAIRING_POINTS_SIZE] pairingPointObject; - // Free wires - G1Point w1; - G1Point w2; - G1Point w3; - G1Point w4; - // Lookup helpers - Permutations - G1Point zPerm; - // Lookup helpers - logup - G1Point lookupReadCounts; - G1Point lookupReadTags; - G1Point lookupInverses; - // Sumcheck - Fr[BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; - Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; - // Shplemini - G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; - Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; - G1Point shplonkQ; - G1Point kzgQuotient; - } - - struct ZKProof { - // Pairing point object - Fr[PAIRING_POINTS_SIZE] pairingPointObject; - // Commitments to wire polynomials - G1Point w1; - G1Point w2; - G1Point w3; - G1Point w4; - // Commitments to logup witness polynomials - G1Point lookupReadCounts; - G1Point lookupReadTags; - G1Point lookupInverses; - // Commitment to grand permutation polynomial - G1Point zPerm; - G1Point[3] libraCommitments; - // Sumcheck - Fr libraSum; - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; - Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; - Fr libraEvaluation; - // ZK - G1Point geminiMaskingPoly; - Fr geminiMaskingEval; - // Shplemini - G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; - Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; - Fr[4] libraPolyEvals; - G1Point shplonkQ; - G1Point kzgQuotient; - } + struct G1Point { + uint256 x; + uint256 y; + } + + struct VerificationKey { + // Misc Params + uint256 circuitSize; + uint256 logCircuitSize; + uint256 publicInputsSize; + // Selectors + G1Point qm; + G1Point qc; + G1Point ql; + G1Point qr; + G1Point qo; + G1Point q4; + G1Point qLookup; // Lookup + G1Point qArith; // Arithmetic widget + G1Point qDeltaRange; // Delta Range sort + G1Point qMemory; // Memory + G1Point qNnf; // Non-native Field + G1Point qElliptic; // Auxillary + G1Point qPoseidon2External; + G1Point qPoseidon2Internal; + // Copy cnstraints + G1Point s1; + G1Point s2; + G1Point s3; + G1Point s4; + // Copy identity + G1Point id1; + G1Point id2; + G1Point id3; + G1Point id4; + // Precomputed lookup table + G1Point t1; + G1Point t2; + G1Point t3; + G1Point t4; + // Fixed first and last + G1Point lagrangeFirst; + G1Point lagrangeLast; + } + + struct RelationParameters { + // challenges + Fr eta; + Fr etaTwo; + Fr etaThree; + Fr beta; + Fr gamma; + // derived + Fr publicInputsDelta; + } + + struct Proof { + // Pairing point object + Fr[PAIRING_POINTS_SIZE] pairingPointObject; + // Free wires + G1Point w1; + G1Point w2; + G1Point w3; + G1Point w4; + // Lookup helpers - Permutations + G1Point zPerm; + // Lookup helpers - logup + G1Point lookupReadCounts; + G1Point lookupReadTags; + G1Point lookupInverses; + // Sumcheck + Fr[BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; + Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; + // Shplemini + G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; + Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; + G1Point shplonkQ; + G1Point kzgQuotient; + } + + struct ZKProof { + // Pairing point object + Fr[PAIRING_POINTS_SIZE] pairingPointObject; + // Commitments to wire polynomials + G1Point w1; + G1Point w2; + G1Point w3; + G1Point w4; + // Commitments to logup witness polynomials + G1Point lookupReadCounts; + G1Point lookupReadTags; + G1Point lookupInverses; + // Commitment to grand permutation polynomial + G1Point zPerm; + G1Point[3] libraCommitments; + // Sumcheck + Fr libraSum; + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; + Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; + Fr libraEvaluation; + // ZK + G1Point geminiMaskingPoly; + Fr geminiMaskingEval; + // Shplemini + G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; + Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; + Fr[4] libraPolyEvals; + G1Point shplonkQ; + G1Point kzgQuotient; + } } // ZKTranscript library to generate fiat shamir challenges, the ZK transcript only differest struct ZKTranscript { - // Oink - Honk.RelationParameters relationParameters; - Fr[NUMBER_OF_ALPHAS] alphas; - Fr[CONST_PROOF_SIZE_LOG_N] gateChallenges; - // Sumcheck - Fr libraChallenge; - Fr[CONST_PROOF_SIZE_LOG_N] sumCheckUChallenges; - // Shplemini - Fr rho; - Fr geminiR; - Fr shplonkNu; - Fr shplonkZ; - // Derived - Fr publicInputsDelta; + // Oink + Honk.RelationParameters relationParameters; + Fr[NUMBER_OF_ALPHAS] alphas; + Fr[CONST_PROOF_SIZE_LOG_N] gateChallenges; + // Sumcheck + Fr libraChallenge; + Fr[CONST_PROOF_SIZE_LOG_N] sumCheckUChallenges; + // Shplemini + Fr rho; + Fr geminiR; + Fr shplonkNu; + Fr shplonkZ; + // Derived + Fr publicInputsDelta; } library ZKTranscriptLib { - function generateTranscript( - Honk.ZKProof memory proof, - bytes32[] calldata publicInputs, - uint256 vkHash, - uint256 publicInputsSize, - uint256 logN - ) external pure returns (ZKTranscript memory t) { - Fr previousChallenge; - (t.relationParameters, previousChallenge) = - generateRelationParametersChallenges(proof, publicInputs, vkHash, publicInputsSize, previousChallenge); - - (t.alphas, previousChallenge) = generateAlphaChallenges(previousChallenge, proof); - - (t.gateChallenges, previousChallenge) = generateGateChallenges(previousChallenge, logN); - (t.libraChallenge, previousChallenge) = generateLibraChallenge(previousChallenge, proof); - (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges(proof, previousChallenge, logN); - - (t.rho, previousChallenge) = generateRhoChallenge(proof, previousChallenge); - - (t.geminiR, previousChallenge) = generateGeminiRChallenge(proof, previousChallenge, logN); - - (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge(proof, previousChallenge, logN); - - (t.shplonkZ, previousChallenge) = generateShplonkZChallenge(proof, previousChallenge); - return t; - } - - function splitChallenge(Fr challenge) internal pure returns (Fr first, Fr second) { - uint256 challengeU256 = uint256(Fr.unwrap(challenge)); - uint256 lo = challengeU256 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; - uint256 hi = challengeU256 >> 128; - first = FrLib.fromBytes32(bytes32(lo)); - second = FrLib.fromBytes32(bytes32(hi)); - } - - function generateRelationParametersChallenges( - Honk.ZKProof memory proof, - bytes32[] calldata publicInputs, - uint256 vkHash, - uint256 publicInputsSize, - Fr previousChallenge - ) internal pure returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) { - (rp.eta, rp.etaTwo, rp.etaThree, previousChallenge) = - generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); - - (rp.beta, rp.gamma, nextPreviousChallenge) = generateBetaAndGammaChallenges(previousChallenge, proof); - } - - function generateEtaChallenge( - Honk.ZKProof memory proof, - bytes32[] calldata publicInputs, - uint256 vkHash, - uint256 publicInputsSize - ) internal pure returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) { - bytes32[] memory round0 = new bytes32[](1 + publicInputsSize + 6); - round0[0] = bytes32(vkHash); - - for (uint256 i = 0; i < publicInputsSize - PAIRING_POINTS_SIZE; i++) { - round0[1 + i] = bytes32(publicInputs[i]); - } - for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib.toBytes32(proof.pairingPointObject[i]); - } - - // Create the first challenge - // Note: w4 is added to the challenge later on - round0[1 + publicInputsSize] = bytes32(proof.w1.x); - round0[1 + publicInputsSize + 1] = bytes32(proof.w1.y); - round0[1 + publicInputsSize + 2] = bytes32(proof.w2.x); - round0[1 + publicInputsSize + 3] = bytes32(proof.w2.y); - round0[1 + publicInputsSize + 4] = bytes32(proof.w3.x); - round0[1 + publicInputsSize + 5] = bytes32(proof.w3.y); - - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round0))); - (eta, etaTwo) = splitChallenge(previousChallenge); - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); - - (etaThree,) = splitChallenge(previousChallenge); - } - - function generateBetaAndGammaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) + function generateTranscript( + Honk.ZKProof memory proof, + bytes32[] calldata publicInputs, + uint256 vkHash, + uint256 publicInputsSize, + uint256 logN + ) external pure returns (ZKTranscript memory t) { + Fr previousChallenge; + (t.relationParameters, previousChallenge) = generateRelationParametersChallenges( + proof, + publicInputs, + vkHash, + publicInputsSize, + previousChallenge + ); + + (t.alphas, previousChallenge) = generateAlphaChallenges(previousChallenge, proof); + + (t.gateChallenges, previousChallenge) = generateGateChallenges(previousChallenge, logN); + (t.libraChallenge, previousChallenge) = generateLibraChallenge(previousChallenge, proof); + (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges(proof, previousChallenge, logN); + + (t.rho, previousChallenge) = generateRhoChallenge(proof, previousChallenge); + + (t.geminiR, previousChallenge) = generateGeminiRChallenge(proof, previousChallenge, logN); + + (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge(proof, previousChallenge, logN); + + (t.shplonkZ, previousChallenge) = generateShplonkZChallenge(proof, previousChallenge); + return t; + } + + function splitChallenge(Fr challenge) internal pure returns (Fr first, Fr second) { + uint256 challengeU256 = uint256(Fr.unwrap(challenge)); + uint256 lo = challengeU256 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; + uint256 hi = challengeU256 >> 128; + first = FrLib.fromBytes32(bytes32(lo)); + second = FrLib.fromBytes32(bytes32(hi)); + } + + function generateRelationParametersChallenges( + Honk.ZKProof memory proof, + bytes32[] calldata publicInputs, + uint256 vkHash, + uint256 publicInputsSize, + Fr previousChallenge + ) internal pure returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) { + (rp.eta, rp.etaTwo, rp.etaThree, previousChallenge) = generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); + + (rp.beta, rp.gamma, nextPreviousChallenge) = generateBetaAndGammaChallenges(previousChallenge, proof); + } + + function generateEtaChallenge( + Honk.ZKProof memory proof, + bytes32[] calldata publicInputs, + uint256 vkHash, + uint256 publicInputsSize + ) internal pure returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) { + bytes32[] memory round0 = new bytes32[](1 + publicInputsSize + 6); + round0[0] = bytes32(vkHash); + + for (uint256 i = 0; i < publicInputsSize - PAIRING_POINTS_SIZE; i++) { + round0[1 + i] = bytes32(publicInputs[i]); + } + for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { + round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib.toBytes32(proof.pairingPointObject[i]); + } + + // Create the first challenge + // Note: w4 is added to the challenge later on + round0[1 + publicInputsSize] = bytes32(proof.w1.x); + round0[1 + publicInputsSize + 1] = bytes32(proof.w1.y); + round0[1 + publicInputsSize + 2] = bytes32(proof.w2.x); + round0[1 + publicInputsSize + 3] = bytes32(proof.w2.y); + round0[1 + publicInputsSize + 4] = bytes32(proof.w3.x); + round0[1 + publicInputsSize + 5] = bytes32(proof.w3.y); + + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round0))); + (eta, etaTwo) = splitChallenge(previousChallenge); + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); + + (etaThree, ) = splitChallenge(previousChallenge); + } + + function generateBetaAndGammaChallenges( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) { + bytes32[7] memory round1; + round1[0] = FrLib.toBytes32(previousChallenge); + round1[1] = bytes32(proof.lookupReadCounts.x); + round1[2] = bytes32(proof.lookupReadCounts.y); + round1[3] = bytes32(proof.lookupReadTags.x); + round1[4] = bytes32(proof.lookupReadTags.y); + round1[5] = bytes32(proof.w4.x); + round1[6] = bytes32(proof.w4.y); + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round1))); + (beta, gamma) = splitChallenge(nextPreviousChallenge); + } + + // Alpha challenges non-linearise the gate contributions + function generateAlphaChallenges( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr[NUMBER_OF_ALPHAS] memory alphas, Fr nextPreviousChallenge) { + // Generate the original sumcheck alpha 0 by hashing zPerm and zLookup + uint256[5] memory alpha0; + alpha0[0] = Fr.unwrap(previousChallenge); + alpha0[1] = proof.lookupInverses.x; + alpha0[2] = proof.lookupInverses.y; + alpha0[3] = proof.zPerm.x; + alpha0[4] = proof.zPerm.y; + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(alpha0))); + Fr alpha; + (alpha, ) = splitChallenge(nextPreviousChallenge); + + // Compute powers of alpha for batching subrelations + alphas[0] = alpha; + for (uint256 i = 1; i < NUMBER_OF_ALPHAS; i++) { + alphas[i] = alphas[i - 1] * alpha; + } + } + + function generateGateChallenges( + Fr previousChallenge, + uint256 logN + ) internal pure returns (Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, Fr nextPreviousChallenge) { + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); + (gateChallenges[0], ) = splitChallenge(previousChallenge); + for (uint256 i = 1; i < logN; i++) { + gateChallenges[i] = gateChallenges[i - 1] * gateChallenges[i - 1]; + } + nextPreviousChallenge = previousChallenge; + } + + function generateLibraChallenge( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr libraChallenge, Fr nextPreviousChallenge) { + // 2 comm, 1 sum, 1 challenge + uint256[4] memory challengeData; + challengeData[0] = Fr.unwrap(previousChallenge); + challengeData[1] = proof.libraCommitments[0].x; + challengeData[2] = proof.libraCommitments[0].y; + challengeData[3] = Fr.unwrap(proof.libraSum); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(challengeData))); + (libraChallenge, ) = splitChallenge(nextPreviousChallenge); + } + + function generateSumcheckChallenges( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, Fr nextPreviousChallenge) { + for (uint256 i = 0; i < logN; i++) { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH + 1] memory univariateChal; + univariateChal[0] = prevChallenge; + + for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { + univariateChal[j + 1] = proof.sumcheckUnivariates[i][j]; + } + prevChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(univariateChal))); + + (sumcheckChallenges[i], ) = splitChallenge(prevChallenge); + } + nextPreviousChallenge = prevChallenge; + } + + // We add Libra claimed eval + 3 comm + 1 more eval + function generateRhoChallenge(Honk.ZKProof memory proof, Fr prevChallenge) internal pure returns (Fr rho, Fr nextPreviousChallenge) { + uint256[NUMBER_OF_ENTITIES + 9] memory rhoChallengeElements; + rhoChallengeElements[0] = Fr.unwrap(prevChallenge); + uint256 i; + for (i = 1; i <= NUMBER_OF_ENTITIES; i++) { + rhoChallengeElements[i] = Fr.unwrap(proof.sumcheckEvaluations[i - 1]); + } + rhoChallengeElements[i] = Fr.unwrap(proof.libraEvaluation); + + i += 1; + rhoChallengeElements[i] = proof.libraCommitments[1].x; + rhoChallengeElements[i + 1] = proof.libraCommitments[1].y; + i += 2; + rhoChallengeElements[i] = proof.libraCommitments[2].x; + rhoChallengeElements[i + 1] = proof.libraCommitments[2].y; + i += 2; + rhoChallengeElements[i] = proof.geminiMaskingPoly.x; + rhoChallengeElements[i + 1] = proof.geminiMaskingPoly.y; + + i += 2; + rhoChallengeElements[i] = Fr.unwrap(proof.geminiMaskingEval); + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(rhoChallengeElements))); + (rho, ) = splitChallenge(nextPreviousChallenge); + } + + function generateGeminiRChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr geminiR, Fr nextPreviousChallenge) { + uint256[] memory gR = new uint256[]((logN - 1) * 2 + 1); + gR[0] = Fr.unwrap(prevChallenge); + + for (uint256 i = 0; i < logN - 1; i++) { + gR[1 + i * 2] = proof.geminiFoldComms[i].x; + gR[2 + i * 2] = proof.geminiFoldComms[i].y; + } + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(gR))); + + (geminiR, ) = splitChallenge(nextPreviousChallenge); + } + + function generateShplonkNuChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr shplonkNu, Fr nextPreviousChallenge) { + uint256[] memory shplonkNuChallengeElements = new uint256[](logN + 1 + 4); + shplonkNuChallengeElements[0] = Fr.unwrap(prevChallenge); + + for (uint256 i = 1; i <= logN; i++) { + shplonkNuChallengeElements[i] = Fr.unwrap(proof.geminiAEvaluations[i - 1]); + } + + uint256 libraIdx = 0; + for (uint256 i = logN + 1; i <= logN + 4; i++) { + shplonkNuChallengeElements[i] = Fr.unwrap(proof.libraPolyEvals[libraIdx]); + libraIdx++; + } + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkNuChallengeElements))); + (shplonkNu, ) = splitChallenge(nextPreviousChallenge); + } + + function generateShplonkZChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge + ) internal pure returns (Fr shplonkZ, Fr nextPreviousChallenge) { + uint256[3] memory shplonkZChallengeElements; + shplonkZChallengeElements[0] = Fr.unwrap(prevChallenge); + + shplonkZChallengeElements[1] = proof.shplonkQ.x; + shplonkZChallengeElements[2] = proof.shplonkQ.y; + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkZChallengeElements))); + (shplonkZ, ) = splitChallenge(nextPreviousChallenge); + } + + function loadProof(bytes calldata proof, uint256 logN) internal pure returns (Honk.ZKProof memory p) { + uint256 boundary = 0x0; + + // Pairing point object + for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { + p.pairingPointObject[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + // Commitments + p.w1 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.w2 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.w3 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + + // Lookup / Permutation Helper Commitments + p.lookupReadCounts = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.lookupReadTags = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.w4 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.lookupInverses = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.zPerm = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.libraCommitments[0] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + + p.libraSum = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + // Sumcheck univariates + for (uint256 i = 0; i < logN; i++) { + for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { + p.sumcheckUnivariates[i][j] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + } + + // Sumcheck evaluations + for (uint256 i = 0; i < NUMBER_OF_ENTITIES; i++) { + p.sumcheckEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + + p.libraEvaluation = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + + p.libraCommitments[1] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.libraCommitments[2] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.geminiMaskingPoly = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.geminiMaskingEval = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + + // Gemini + // Read gemini fold univariates + for (uint256 i = 0; i < logN - 1; i++) { + p.geminiFoldComms[i] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + } + + // Read gemini a evaluations + for (uint256 i = 0; i < logN; i++) { + p.geminiAEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + + for (uint256 i = 0; i < 4; i++) { + p.libraPolyEvals[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + + // Shplonk + p.shplonkQ = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + // KZG + p.kzgQuotient = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + } +} + +// Field arithmetic libraries + +library RelationsLib { + Fr internal constant GRUMPKIN_CURVE_B_PARAMETER_NEGATED = Fr.wrap(17); // -(-17) + + function accumulateRelationEvaluations( + Fr[NUMBER_OF_ENTITIES] memory purportedEvaluations, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_ALPHAS] memory alphas, + Fr powPartialEval + ) internal pure returns (Fr accumulator) { + Fr[NUMBER_OF_SUBRELATIONS] memory evaluations; + + // Accumulate all relations in Ultra Honk - each with varying number of subrelations + accumulateArithmeticRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePermutationRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateLogDerivativeLookupRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateDeltaRangeRelation(purportedEvaluations, evaluations, powPartialEval); + accumulateEllipticRelation(purportedEvaluations, evaluations, powPartialEval); + accumulateMemoryRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateNnfRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePoseidonExternalRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePoseidonInternalRelation(purportedEvaluations, evaluations, powPartialEval); + + // batch the subrelations with the alpha challenges to obtain the full honk relation + accumulator = scaleAndBatchSubrelations(evaluations, alphas); + } + + /** + * Aesthetic helper function that is used to index by enum into proof.sumcheckEvaluations, it avoids + * the relation checking code being cluttered with uint256 type casting, which is often a different colour in code + * editors, and thus is noisy. + */ + function wire(Fr[NUMBER_OF_ENTITIES] memory p, WIRE _wire) internal pure returns (Fr) { + return p[uint256(_wire)]; + } + + uint256 internal constant NEG_HALF_MODULO_P = 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; + /** + * Ultra Arithmetic Relation + * + */ + + function accumulateArithmeticRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + // Relation 0 + Fr q_arith = wire(p, WIRE.Q_ARITH); { - bytes32[7] memory round1; - round1[0] = FrLib.toBytes32(previousChallenge); - round1[1] = bytes32(proof.lookupReadCounts.x); - round1[2] = bytes32(proof.lookupReadCounts.y); - round1[3] = bytes32(proof.lookupReadTags.x); - round1[4] = bytes32(proof.lookupReadTags.y); - round1[5] = bytes32(proof.w4.x); - round1[6] = bytes32(proof.w4.y); - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round1))); - (beta, gamma) = splitChallenge(nextPreviousChallenge); - } - - // Alpha challenges non-linearise the gate contributions - function generateAlphaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr[NUMBER_OF_ALPHAS] memory alphas, Fr nextPreviousChallenge) + Fr neg_half = Fr.wrap(NEG_HALF_MODULO_P); + + Fr accum = (q_arith - Fr.wrap(3)) * (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * neg_half; + accum = + accum + + (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) + + (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + + (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + + wire(p, WIRE.Q_C); + accum = accum + (q_arith - ONE) * wire(p, WIRE.W_4_SHIFT); + accum = accum * q_arith; + accum = accum * domainSep; + evals[0] = accum; + } + + // Relation 1 { - // Generate the original sumcheck alpha 0 by hashing zPerm and zLookup - uint256[5] memory alpha0; - alpha0[0] = Fr.unwrap(previousChallenge); - alpha0[1] = proof.lookupInverses.x; - alpha0[2] = proof.lookupInverses.y; - alpha0[3] = proof.zPerm.x; - alpha0[4] = proof.zPerm.y; - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(alpha0))); - Fr alpha; - (alpha,) = splitChallenge(nextPreviousChallenge); - - // Compute powers of alpha for batching subrelations - alphas[0] = alpha; - for (uint256 i = 1; i < NUMBER_OF_ALPHAS; i++) { - alphas[i] = alphas[i - 1] * alpha; - } - } - - function generateGateChallenges(Fr previousChallenge, uint256 logN) - internal - pure - returns (Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, Fr nextPreviousChallenge) + Fr accum = wire(p, WIRE.W_L) + wire(p, WIRE.W_4) - wire(p, WIRE.W_L_SHIFT) + wire(p, WIRE.Q_M); + accum = accum * (q_arith - Fr.wrap(2)); + accum = accum * (q_arith - ONE); + accum = accum * q_arith; + accum = accum * domainSep; + evals[1] = accum; + } + } + + function accumulatePermutationRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + Fr grand_product_numerator; + Fr grand_product_denominator; + { - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); - (gateChallenges[0],) = splitChallenge(previousChallenge); - for (uint256 i = 1; i < logN; i++) { - gateChallenges[i] = gateChallenges[i - 1] * gateChallenges[i - 1]; - } - nextPreviousChallenge = previousChallenge; - } - - function generateLibraChallenge(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr libraChallenge, Fr nextPreviousChallenge) + Fr num = wire(p, WIRE.W_L) + wire(p, WIRE.ID_1) * rp.beta + rp.gamma; + num = num * (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); + num = num * (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); + num = num * (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); + + grand_product_numerator = num; + } { - // 2 comm, 1 sum, 1 challenge - uint256[4] memory challengeData; - challengeData[0] = Fr.unwrap(previousChallenge); - challengeData[1] = proof.libraCommitments[0].x; - challengeData[2] = proof.libraCommitments[0].y; - challengeData[3] = Fr.unwrap(proof.libraSum); - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(challengeData))); - (libraChallenge,) = splitChallenge(nextPreviousChallenge); - } - - function generateSumcheckChallenges(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, Fr nextPreviousChallenge) + Fr den = wire(p, WIRE.W_L) + wire(p, WIRE.SIGMA_1) * rp.beta + rp.gamma; + den = den * (wire(p, WIRE.W_R) + wire(p, WIRE.SIGMA_2) * rp.beta + rp.gamma); + den = den * (wire(p, WIRE.W_O) + wire(p, WIRE.SIGMA_3) * rp.beta + rp.gamma); + den = den * (wire(p, WIRE.W_4) + wire(p, WIRE.SIGMA_4) * rp.beta + rp.gamma); + + grand_product_denominator = den; + } + + // Contribution 2 { - for (uint256 i = 0; i < logN; i++) { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH + 1] memory univariateChal; - univariateChal[0] = prevChallenge; + Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * grand_product_numerator; - for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { - univariateChal[j + 1] = proof.sumcheckUnivariates[i][j]; - } - prevChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(univariateChal))); + acc = acc - ((wire(p, WIRE.Z_PERM_SHIFT) + (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) * grand_product_denominator); + acc = acc * domainSep; + evals[2] = acc; + } - (sumcheckChallenges[i],) = splitChallenge(prevChallenge); - } - nextPreviousChallenge = prevChallenge; + // Contribution 3 + { + Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; + evals[3] = acc; } + } + + function accumulateLogDerivativeLookupRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + Fr write_term; + Fr read_term; - // We add Libra claimed eval + 3 comm + 1 more eval - function generateRhoChallenge(Honk.ZKProof memory proof, Fr prevChallenge) - internal - pure - returns (Fr rho, Fr nextPreviousChallenge) + // Calculate the write term (the table accumulation) { - uint256[NUMBER_OF_ENTITIES + 9] memory rhoChallengeElements; - rhoChallengeElements[0] = Fr.unwrap(prevChallenge); - uint256 i; - for (i = 1; i <= NUMBER_OF_ENTITIES; i++) { - rhoChallengeElements[i] = Fr.unwrap(proof.sumcheckEvaluations[i - 1]); - } - rhoChallengeElements[i] = Fr.unwrap(proof.libraEvaluation); - - i += 1; - rhoChallengeElements[i] = proof.libraCommitments[1].x; - rhoChallengeElements[i + 1] = proof.libraCommitments[1].y; - i += 2; - rhoChallengeElements[i] = proof.libraCommitments[2].x; - rhoChallengeElements[i + 1] = proof.libraCommitments[2].y; - i += 2; - rhoChallengeElements[i] = proof.geminiMaskingPoly.x; - rhoChallengeElements[i + 1] = proof.geminiMaskingPoly.y; - - i += 2; - rhoChallengeElements[i] = Fr.unwrap(proof.geminiMaskingEval); - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(rhoChallengeElements))); - (rho,) = splitChallenge(nextPreviousChallenge); - } - - function generateGeminiRChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr geminiR, Fr nextPreviousChallenge) + write_term = + wire(p, WIRE.TABLE_1) + + rp.gamma + + (wire(p, WIRE.TABLE_2) * rp.eta) + + (wire(p, WIRE.TABLE_3) * rp.etaTwo) + + (wire(p, WIRE.TABLE_4) * rp.etaThree); + } + + // Calculate the write term { - uint256[] memory gR = new uint256[]((logN - 1) * 2 + 1); - gR[0] = Fr.unwrap(prevChallenge); + Fr derived_entry_1 = wire(p, WIRE.W_L) + rp.gamma + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); + Fr derived_entry_2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_M) * wire(p, WIRE.W_R_SHIFT); + Fr derived_entry_3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_C) * wire(p, WIRE.W_O_SHIFT); + + read_term = derived_entry_1 + (derived_entry_2 * rp.eta) + (derived_entry_3 * rp.etaTwo) + (wire(p, WIRE.Q_O) * rp.etaThree); + } + + Fr read_inverse = wire(p, WIRE.LOOKUP_INVERSES) * write_term; + Fr write_inverse = wire(p, WIRE.LOOKUP_INVERSES) * read_term; + + Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + + wire(p, WIRE.Q_LOOKUP) - + (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); + + // Inverse calculated correctly relation + Fr accumulatorNone = read_term * write_term * wire(p, WIRE.LOOKUP_INVERSES) - inverse_exists_xor; + accumulatorNone = accumulatorNone * domainSep; + + // Inverse + Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * read_inverse - wire(p, WIRE.LOOKUP_READ_COUNTS) * write_inverse; + + Fr read_tag = wire(p, WIRE.LOOKUP_READ_TAGS); + + Fr read_tag_boolean_relation = read_tag * read_tag - read_tag; - for (uint256 i = 0; i < logN - 1; i++) { - gR[1 + i * 2] = proof.geminiFoldComms[i].x; - gR[2 + i * 2] = proof.geminiFoldComms[i].y; - } + evals[4] = accumulatorNone; + evals[5] = accumulatorOne; + evals[6] = read_tag_boolean_relation * domainSep; + } - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(gR))); + function accumulateDeltaRangeRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + Fr minus_one = ZERO - ONE; + Fr minus_two = ZERO - Fr.wrap(2); + Fr minus_three = ZERO - Fr.wrap(3); - (geminiR,) = splitChallenge(nextPreviousChallenge); + // Compute wire differences + Fr delta_1 = wire(p, WIRE.W_R) - wire(p, WIRE.W_L); + Fr delta_2 = wire(p, WIRE.W_O) - wire(p, WIRE.W_R); + Fr delta_3 = wire(p, WIRE.W_4) - wire(p, WIRE.W_O); + Fr delta_4 = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_4); + + // Contribution 6 + { + Fr acc = delta_1; + acc = acc * (delta_1 + minus_one); + acc = acc * (delta_1 + minus_two); + acc = acc * (delta_1 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[7] = acc; } - function generateShplonkNuChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr shplonkNu, Fr nextPreviousChallenge) + // Contribution 7 { - uint256[] memory shplonkNuChallengeElements = new uint256[](logN + 1 + 4); - shplonkNuChallengeElements[0] = Fr.unwrap(prevChallenge); + Fr acc = delta_2; + acc = acc * (delta_2 + minus_one); + acc = acc * (delta_2 + minus_two); + acc = acc * (delta_2 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[8] = acc; + } - for (uint256 i = 1; i <= logN; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap(proof.geminiAEvaluations[i - 1]); - } + // Contribution 8 + { + Fr acc = delta_3; + acc = acc * (delta_3 + minus_one); + acc = acc * (delta_3 + minus_two); + acc = acc * (delta_3 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[9] = acc; + } - uint256 libraIdx = 0; - for (uint256 i = logN + 1; i <= logN + 4; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap(proof.libraPolyEvals[libraIdx]); - libraIdx++; - } + // Contribution 9 + { + Fr acc = delta_4; + acc = acc * (delta_4 + minus_one); + acc = acc * (delta_4 + minus_two); + acc = acc * (delta_4 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[10] = acc; + } + } + + struct EllipticParams { + // Points + Fr x_1; + Fr y_1; + Fr x_2; + Fr y_2; + Fr y_3; + Fr x_3; + // push accumulators into memory + Fr x_double_identity; + } + + function accumulateEllipticRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + EllipticParams memory ep; + ep.x_1 = wire(p, WIRE.W_R); + ep.y_1 = wire(p, WIRE.W_O); + + ep.x_2 = wire(p, WIRE.W_L_SHIFT); + ep.y_2 = wire(p, WIRE.W_4_SHIFT); + ep.y_3 = wire(p, WIRE.W_O_SHIFT); + ep.x_3 = wire(p, WIRE.W_R_SHIFT); + + Fr q_sign = wire(p, WIRE.Q_L); + Fr q_is_double = wire(p, WIRE.Q_M); + + // Contribution 10 point addition, x-coordinate check + // q_elliptic * (x3 + x2 + x1)(x2 - x1)(x2 - x1) - y2^2 - y1^2 + 2(y2y1)*q_sign = 0 + Fr x_diff = (ep.x_2 - ep.x_1); + Fr y1_sqr = (ep.y_1 * ep.y_1); + { + // Move to top + Fr partialEval = domainSep; + + Fr y2_sqr = (ep.y_2 * ep.y_2); + Fr y1y2 = ep.y_1 * ep.y_2 * q_sign; + Fr x_add_identity = (ep.x_3 + ep.x_2 + ep.x_1); + x_add_identity = x_add_identity * x_diff * x_diff; + x_add_identity = x_add_identity - y2_sqr - y1_sqr + y1y2 + y1y2; - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkNuChallengeElements))); - (shplonkNu,) = splitChallenge(nextPreviousChallenge); + evals[11] = x_add_identity * partialEval * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); } - function generateShplonkZChallenge(Honk.ZKProof memory proof, Fr prevChallenge) - internal - pure - returns (Fr shplonkZ, Fr nextPreviousChallenge) + // Contribution 11 point addition, x-coordinate check + // q_elliptic * (q_sign * y1 + y3)(x2 - x1) + (x3 - x1)(y2 - q_sign * y1) = 0 { - uint256[3] memory shplonkZChallengeElements; - shplonkZChallengeElements[0] = Fr.unwrap(prevChallenge); - - shplonkZChallengeElements[1] = proof.shplonkQ.x; - shplonkZChallengeElements[2] = proof.shplonkQ.y; - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkZChallengeElements))); - (shplonkZ,) = splitChallenge(nextPreviousChallenge); - } - - function loadProof(bytes calldata proof, uint256 logN) internal pure returns (Honk.ZKProof memory p) { - uint256 boundary = 0x0; - - // Pairing point object - for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - p.pairingPointObject[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - // Commitments - p.w1 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.w2 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.w3 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - - // Lookup / Permutation Helper Commitments - p.lookupReadCounts = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.lookupReadTags = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.w4 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.lookupInverses = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.zPerm = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[0] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - - p.libraSum = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - // Sumcheck univariates - for (uint256 i = 0; i < logN; i++) { - for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { - p.sumcheckUnivariates[i][j] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - } - - // Sumcheck evaluations - for (uint256 i = 0; i < NUMBER_OF_ENTITIES; i++) { - p.sumcheckEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - - p.libraEvaluation = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; + Fr y1_plus_y3 = ep.y_1 + ep.y_3; + Fr y_diff = ep.y_2 * q_sign - ep.y_1; + Fr y_add_identity = y1_plus_y3 * x_diff + (ep.x_3 - ep.x_1) * y_diff; + evals[12] = y_add_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); + } - p.libraCommitments[1] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[2] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingPoly = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingEval = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; + // Contribution 10 point doubling, x-coordinate check + // (x3 + x1 + x1) (4y1*y1) - 9 * x1 * x1 * x1 * x1 = 0 + // N.B. we're using the equivalence x1*x1*x1 === y1*y1 - curve_b to reduce degree by 1 + { + Fr x_pow_4 = (y1_sqr + GRUMPKIN_CURVE_B_PARAMETER_NEGATED) * ep.x_1; + Fr y1_sqr_mul_4 = y1_sqr + y1_sqr; + y1_sqr_mul_4 = y1_sqr_mul_4 + y1_sqr_mul_4; + Fr x1_pow_4_mul_9 = x_pow_4 * Fr.wrap(9); + + // NOTE: pushed into memory (stack >:'( ) + ep.x_double_identity = (ep.x_3 + ep.x_1 + ep.x_1) * y1_sqr_mul_4 - x1_pow_4_mul_9; - // Gemini - // Read gemini fold univariates - for (uint256 i = 0; i < logN - 1; i++) { - p.geminiFoldComms[i] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - } - - // Read gemini a evaluations - for (uint256 i = 0; i < logN; i++) { - p.geminiAEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - - for (uint256 i = 0; i < 4; i++) { - p.libraPolyEvals[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - - // Shplonk - p.shplonkQ = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - // KZG - p.kzgQuotient = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + Fr acc = ep.x_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; + evals[11] = evals[11] + acc; } -} -// Field arithmetic libraries + // Contribution 11 point doubling, y-coordinate check + // (y1 + y1) (2y1) - (3 * x1 * x1)(x1 - x3) = 0 + { + Fr x1_sqr_mul_3 = (ep.x_1 + ep.x_1 + ep.x_1) * ep.x_1; + Fr y_double_identity = x1_sqr_mul_3 * (ep.x_1 - ep.x_3) - (ep.y_1 + ep.y_1) * (ep.y_1 + ep.y_3); + evals[12] = evals[12] + y_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; + } + } + + // Parameters used within the Memory Relation + // A struct is used to work around stack too deep. This relation has alot of variables + struct MemParams { + Fr memory_record_check; + Fr partial_record_check; + Fr next_gate_access_type; + Fr record_delta; + Fr index_delta; + Fr adjacent_values_match_if_adjacent_indices_match; + Fr adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation; + Fr access_check; + Fr next_gate_access_type_is_boolean; + Fr ROM_consistency_check_identity; + Fr RAM_consistency_check_identity; + Fr timestamp_delta; + Fr RAM_timestamp_check_identity; + Fr memory_identity; + Fr index_is_monotonically_increasing; + } + + function accumulateMemoryRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + MemParams memory ap; -library RelationsLib { - Fr internal constant GRUMPKIN_CURVE_B_PARAMETER_NEGATED = Fr.wrap(17); // -(-17) - - function accumulateRelationEvaluations( - Fr[NUMBER_OF_ENTITIES] memory purportedEvaluations, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_ALPHAS] memory alphas, - Fr powPartialEval - ) internal pure returns (Fr accumulator) { - Fr[NUMBER_OF_SUBRELATIONS] memory evaluations; - - // Accumulate all relations in Ultra Honk - each with varying number of subrelations - accumulateArithmeticRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePermutationRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateLogDerivativeLookupRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateDeltaRangeRelation(purportedEvaluations, evaluations, powPartialEval); - accumulateEllipticRelation(purportedEvaluations, evaluations, powPartialEval); - accumulateMemoryRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateNnfRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePoseidonExternalRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePoseidonInternalRelation(purportedEvaluations, evaluations, powPartialEval); - - // batch the subrelations with the alpha challenges to obtain the full honk relation - accumulator = scaleAndBatchSubrelations(evaluations, alphas); - } + /** + * MEMORY + * + * A RAM memory record contains a tuple of the following fields: + * * i: `index` of memory cell being accessed + * * t: `timestamp` of memory cell being accessed (used for RAM, set to 0 for ROM) + * * v: `value` of memory cell being accessed + * * a: `access` type of record. read: 0 = read, 1 = write + * * r: `record` of memory cell. record = access + index * eta + timestamp * eta_two + value * eta_three + * + * A ROM memory record contains a tuple of the following fields: + * * i: `index` of memory cell being accessed + * * v: `value1` of memory cell being accessed (ROM tables can store up to 2 values per index) + * * v2:`value2` of memory cell being accessed (ROM tables can store up to 2 values per index) + * * r: `record` of memory cell. record = index * eta + value2 * eta_two + value1 * eta_three + * + * When performing a read/write access, the values of i, t, v, v2, a, r are stored in the following wires + + * selectors, depending on whether the gate is a RAM read/write or a ROM read + * + * | gate type | i | v2/t | v | a | r | + * | --------- | -- | ----- | -- | -- | -- | + * | ROM | w1 | w2 | w3 | -- | w4 | + * | RAM | w1 | w2 | w3 | qc | w4 | + * + * (for accesses where `index` is a circuit constant, it is assumed the circuit will apply a copy constraint on + * `w2` to fix its value) + * + * + */ /** - * Aesthetic helper function that is used to index by enum into proof.sumcheckEvaluations, it avoids - * the relation checking code being cluttered with uint256 type casting, which is often a different colour in code - * editors, and thus is noisy. + * Memory Record Check + * Partial degree: 1 + * Total degree: 4 + * + * A ROM/ROM access gate can be evaluated with the identity: + * + * qc + w1 \eta + w2 \eta_two + w3 \eta_three - w4 = 0 + * + * For ROM gates, qc = 0 */ - function wire(Fr[NUMBER_OF_ENTITIES] memory p, WIRE _wire) internal pure returns (Fr) { - return p[uint256(_wire)]; - } + ap.memory_record_check = wire(p, WIRE.W_O) * rp.etaThree; + ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_R) * rp.etaTwo); + ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_L) * rp.eta); + ap.memory_record_check = ap.memory_record_check + wire(p, WIRE.Q_C); + ap.partial_record_check = ap.memory_record_check; // used in RAM consistency check; deg 1 or 4 + ap.memory_record_check = ap.memory_record_check - wire(p, WIRE.W_4); - uint256 internal constant NEG_HALF_MODULO_P = 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; /** - * Ultra Arithmetic Relation + * Contribution 13 & 14 + * ROM Consistency Check + * Partial degree: 1 + * Total degree: 4 + * + * For every ROM read, a set equivalence check is applied between the record witnesses, and a second set of + * records that are sorted. + * + * We apply the following checks for the sorted records: + * + * 1. w1, w2, w3 correctly map to 'index', 'v1, 'v2' for a given record value at w4 + * 2. index values for adjacent records are monotonically increasing + * 3. if, at gate i, index_i == index_{i + 1}, then value1_i == value1_{i + 1} and value2_i == value2_{i + 1} * */ + ap.index_delta = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_L); + ap.record_delta = wire(p, WIRE.W_4_SHIFT) - wire(p, WIRE.W_4); - function accumulateArithmeticRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - // Relation 0 - Fr q_arith = wire(p, WIRE.Q_ARITH); - { - Fr neg_half = Fr.wrap(NEG_HALF_MODULO_P); - - Fr accum = (q_arith - Fr.wrap(3)) * (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * neg_half; - accum = accum + (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) - + (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + wire(p, WIRE.Q_C); - accum = accum + (q_arith - ONE) * wire(p, WIRE.W_4_SHIFT); - accum = accum * q_arith; - accum = accum * domainSep; - evals[0] = accum; - } - - // Relation 1 - { - Fr accum = wire(p, WIRE.W_L) + wire(p, WIRE.W_4) - wire(p, WIRE.W_L_SHIFT) + wire(p, WIRE.Q_M); - accum = accum * (q_arith - Fr.wrap(2)); - accum = accum * (q_arith - ONE); - accum = accum * q_arith; - accum = accum * domainSep; - evals[1] = accum; - } - } - - function accumulatePermutationRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - Fr grand_product_numerator; - Fr grand_product_denominator; - - { - Fr num = wire(p, WIRE.W_L) + wire(p, WIRE.ID_1) * rp.beta + rp.gamma; - num = num * (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); - num = num * (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); - num = num * (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); - - grand_product_numerator = num; - } - { - Fr den = wire(p, WIRE.W_L) + wire(p, WIRE.SIGMA_1) * rp.beta + rp.gamma; - den = den * (wire(p, WIRE.W_R) + wire(p, WIRE.SIGMA_2) * rp.beta + rp.gamma); - den = den * (wire(p, WIRE.W_O) + wire(p, WIRE.SIGMA_3) * rp.beta + rp.gamma); - den = den * (wire(p, WIRE.W_4) + wire(p, WIRE.SIGMA_4) * rp.beta + rp.gamma); - - grand_product_denominator = den; - } - - // Contribution 2 - { - Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * grand_product_numerator; - - acc = acc - - ( - (wire(p, WIRE.Z_PERM_SHIFT) + (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) - * grand_product_denominator - ); - acc = acc * domainSep; - evals[2] = acc; - } - - // Contribution 3 - { - Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; - evals[3] = acc; - } - } - - function accumulateLogDerivativeLookupRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - Fr write_term; - Fr read_term; - - // Calculate the write term (the table accumulation) - { - write_term = wire(p, WIRE.TABLE_1) + rp.gamma + (wire(p, WIRE.TABLE_2) * rp.eta) - + (wire(p, WIRE.TABLE_3) * rp.etaTwo) + (wire(p, WIRE.TABLE_4) * rp.etaThree); - } - - // Calculate the write term - { - Fr derived_entry_1 = wire(p, WIRE.W_L) + rp.gamma + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); - Fr derived_entry_2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_M) * wire(p, WIRE.W_R_SHIFT); - Fr derived_entry_3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_C) * wire(p, WIRE.W_O_SHIFT); - - read_term = derived_entry_1 + (derived_entry_2 * rp.eta) + (derived_entry_3 * rp.etaTwo) - + (wire(p, WIRE.Q_O) * rp.etaThree); - } - - Fr read_inverse = wire(p, WIRE.LOOKUP_INVERSES) * write_term; - Fr write_inverse = wire(p, WIRE.LOOKUP_INVERSES) * read_term; - - Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + wire(p, WIRE.Q_LOOKUP) - - (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); - - // Inverse calculated correctly relation - Fr accumulatorNone = read_term * write_term * wire(p, WIRE.LOOKUP_INVERSES) - inverse_exists_xor; - accumulatorNone = accumulatorNone * domainSep; - - // Inverse - Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * read_inverse - wire(p, WIRE.LOOKUP_READ_COUNTS) * write_inverse; - - Fr read_tag = wire(p, WIRE.LOOKUP_READ_TAGS); - - Fr read_tag_boolean_relation = read_tag * read_tag - read_tag; - - evals[4] = accumulatorNone; - evals[5] = accumulatorOne; - evals[6] = read_tag_boolean_relation * domainSep; - } - - function accumulateDeltaRangeRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - Fr minus_one = ZERO - ONE; - Fr minus_two = ZERO - Fr.wrap(2); - Fr minus_three = ZERO - Fr.wrap(3); - - // Compute wire differences - Fr delta_1 = wire(p, WIRE.W_R) - wire(p, WIRE.W_L); - Fr delta_2 = wire(p, WIRE.W_O) - wire(p, WIRE.W_R); - Fr delta_3 = wire(p, WIRE.W_4) - wire(p, WIRE.W_O); - Fr delta_4 = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_4); - - // Contribution 6 - { - Fr acc = delta_1; - acc = acc * (delta_1 + minus_one); - acc = acc * (delta_1 + minus_two); - acc = acc * (delta_1 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[7] = acc; - } - - // Contribution 7 - { - Fr acc = delta_2; - acc = acc * (delta_2 + minus_one); - acc = acc * (delta_2 + minus_two); - acc = acc * (delta_2 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[8] = acc; - } - - // Contribution 8 - { - Fr acc = delta_3; - acc = acc * (delta_3 + minus_one); - acc = acc * (delta_3 + minus_two); - acc = acc * (delta_3 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[9] = acc; - } - - // Contribution 9 - { - Fr acc = delta_4; - acc = acc * (delta_4 + minus_one); - acc = acc * (delta_4 + minus_two); - acc = acc * (delta_4 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[10] = acc; - } - } - - struct EllipticParams { - // Points - Fr x_1; - Fr y_1; - Fr x_2; - Fr y_2; - Fr y_3; - Fr x_3; - // push accumulators into memory - Fr x_double_identity; - } - - function accumulateEllipticRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - EllipticParams memory ep; - ep.x_1 = wire(p, WIRE.W_R); - ep.y_1 = wire(p, WIRE.W_O); - - ep.x_2 = wire(p, WIRE.W_L_SHIFT); - ep.y_2 = wire(p, WIRE.W_4_SHIFT); - ep.y_3 = wire(p, WIRE.W_O_SHIFT); - ep.x_3 = wire(p, WIRE.W_R_SHIFT); - - Fr q_sign = wire(p, WIRE.Q_L); - Fr q_is_double = wire(p, WIRE.Q_M); - - // Contribution 10 point addition, x-coordinate check - // q_elliptic * (x3 + x2 + x1)(x2 - x1)(x2 - x1) - y2^2 - y1^2 + 2(y2y1)*q_sign = 0 - Fr x_diff = (ep.x_2 - ep.x_1); - Fr y1_sqr = (ep.y_1 * ep.y_1); - { - // Move to top - Fr partialEval = domainSep; - - Fr y2_sqr = (ep.y_2 * ep.y_2); - Fr y1y2 = ep.y_1 * ep.y_2 * q_sign; - Fr x_add_identity = (ep.x_3 + ep.x_2 + ep.x_1); - x_add_identity = x_add_identity * x_diff * x_diff; - x_add_identity = x_add_identity - y2_sqr - y1_sqr + y1y2 + y1y2; - - evals[11] = x_add_identity * partialEval * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); - } - - // Contribution 11 point addition, x-coordinate check - // q_elliptic * (q_sign * y1 + y3)(x2 - x1) + (x3 - x1)(y2 - q_sign * y1) = 0 - { - Fr y1_plus_y3 = ep.y_1 + ep.y_3; - Fr y_diff = ep.y_2 * q_sign - ep.y_1; - Fr y_add_identity = y1_plus_y3 * x_diff + (ep.x_3 - ep.x_1) * y_diff; - evals[12] = y_add_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); - } - - // Contribution 10 point doubling, x-coordinate check - // (x3 + x1 + x1) (4y1*y1) - 9 * x1 * x1 * x1 * x1 = 0 - // N.B. we're using the equivalence x1*x1*x1 === y1*y1 - curve_b to reduce degree by 1 - { - Fr x_pow_4 = (y1_sqr + GRUMPKIN_CURVE_B_PARAMETER_NEGATED) * ep.x_1; - Fr y1_sqr_mul_4 = y1_sqr + y1_sqr; - y1_sqr_mul_4 = y1_sqr_mul_4 + y1_sqr_mul_4; - Fr x1_pow_4_mul_9 = x_pow_4 * Fr.wrap(9); - - // NOTE: pushed into memory (stack >:'( ) - ep.x_double_identity = (ep.x_3 + ep.x_1 + ep.x_1) * y1_sqr_mul_4 - x1_pow_4_mul_9; - - Fr acc = ep.x_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; - evals[11] = evals[11] + acc; - } - - // Contribution 11 point doubling, y-coordinate check - // (y1 + y1) (2y1) - (3 * x1 * x1)(x1 - x3) = 0 - { - Fr x1_sqr_mul_3 = (ep.x_1 + ep.x_1 + ep.x_1) * ep.x_1; - Fr y_double_identity = x1_sqr_mul_3 * (ep.x_1 - ep.x_3) - (ep.y_1 + ep.y_1) * (ep.y_1 + ep.y_3); - evals[12] = evals[12] + y_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; - } - } - - // Parameters used within the Memory Relation - // A struct is used to work around stack too deep. This relation has alot of variables - struct MemParams { - Fr memory_record_check; - Fr partial_record_check; - Fr next_gate_access_type; - Fr record_delta; - Fr index_delta; - Fr adjacent_values_match_if_adjacent_indices_match; - Fr adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation; - Fr access_check; - Fr next_gate_access_type_is_boolean; - Fr ROM_consistency_check_identity; - Fr RAM_consistency_check_identity; - Fr timestamp_delta; - Fr RAM_timestamp_check_identity; - Fr memory_identity; - Fr index_is_monotonically_increasing; - } - - function accumulateMemoryRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - MemParams memory ap; - - /** - * MEMORY - * - * A RAM memory record contains a tuple of the following fields: - * * i: `index` of memory cell being accessed - * * t: `timestamp` of memory cell being accessed (used for RAM, set to 0 for ROM) - * * v: `value` of memory cell being accessed - * * a: `access` type of record. read: 0 = read, 1 = write - * * r: `record` of memory cell. record = access + index * eta + timestamp * eta_two + value * eta_three - * - * A ROM memory record contains a tuple of the following fields: - * * i: `index` of memory cell being accessed - * * v: `value1` of memory cell being accessed (ROM tables can store up to 2 values per index) - * * v2:`value2` of memory cell being accessed (ROM tables can store up to 2 values per index) - * * r: `record` of memory cell. record = index * eta + value2 * eta_two + value1 * eta_three - * - * When performing a read/write access, the values of i, t, v, v2, a, r are stored in the following wires + - * selectors, depending on whether the gate is a RAM read/write or a ROM read - * - * | gate type | i | v2/t | v | a | r | - * | --------- | -- | ----- | -- | -- | -- | - * | ROM | w1 | w2 | w3 | -- | w4 | - * | RAM | w1 | w2 | w3 | qc | w4 | - * - * (for accesses where `index` is a circuit constant, it is assumed the circuit will apply a copy constraint on - * `w2` to fix its value) - * - * - */ - - /** - * Memory Record Check - * Partial degree: 1 - * Total degree: 4 - * - * A ROM/ROM access gate can be evaluated with the identity: - * - * qc + w1 \eta + w2 \eta_two + w3 \eta_three - w4 = 0 - * - * For ROM gates, qc = 0 - */ - ap.memory_record_check = wire(p, WIRE.W_O) * rp.etaThree; - ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_R) * rp.etaTwo); - ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_L) * rp.eta); - ap.memory_record_check = ap.memory_record_check + wire(p, WIRE.Q_C); - ap.partial_record_check = ap.memory_record_check; // used in RAM consistency check; deg 1 or 4 - ap.memory_record_check = ap.memory_record_check - wire(p, WIRE.W_4); - - /** - * Contribution 13 & 14 - * ROM Consistency Check - * Partial degree: 1 - * Total degree: 4 - * - * For every ROM read, a set equivalence check is applied between the record witnesses, and a second set of - * records that are sorted. - * - * We apply the following checks for the sorted records: - * - * 1. w1, w2, w3 correctly map to 'index', 'v1, 'v2' for a given record value at w4 - * 2. index values for adjacent records are monotonically increasing - * 3. if, at gate i, index_i == index_{i + 1}, then value1_i == value1_{i + 1} and value2_i == value2_{i + 1} - * - */ - ap.index_delta = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_L); - ap.record_delta = wire(p, WIRE.W_4_SHIFT) - wire(p, WIRE.W_4); - - ap.index_is_monotonically_increasing = ap.index_delta * (ap.index_delta - Fr.wrap(1)); // deg 2 - - ap.adjacent_values_match_if_adjacent_indices_match = (ap.index_delta * MINUS_ONE + ONE) * ap.record_delta; // deg 2 - - evals[14] = ap.adjacent_values_match_if_adjacent_indices_match * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) - * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - evals[15] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) - * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - - ap.ROM_consistency_check_identity = ap.memory_record_check * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 - - /** - * Contributions 15,16,17 - * RAM Consistency Check - * - * The 'access' type of the record is extracted with the expression `w_4 - ap.partial_record_check` - * (i.e. for an honest Prover `w1 * eta + w2 * eta^2 + w3 * eta^3 - w4 = access`. - * This is validated by requiring `access` to be boolean - * - * For two adjacent entries in the sorted list if _both_ - * A) index values match - * B) adjacent access value is 0 (i.e. next gate is a READ) - * then - * C) both values must match. - * The gate boolean check is - * (A && B) => C === !(A && B) || C === !A || !B || C - * - * N.B. it is the responsibility of the circuit writer to ensure that every RAM cell is initialized - * with a WRITE operation. - */ - Fr access_type = (wire(p, WIRE.W_4) - ap.partial_record_check); // will be 0 or 1 for honest Prover; deg 1 or 4 - ap.access_check = access_type * (access_type - Fr.wrap(1)); // check value is 0 or 1; deg 2 or 8 - - // reverse order we could re-use `ap.partial_record_check` 1 - ((w3' * eta + w2') * eta + w1') * eta - // deg 1 or 4 - ap.next_gate_access_type = wire(p, WIRE.W_O_SHIFT) * rp.etaThree; - ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); - ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_L_SHIFT) * rp.eta); - ap.next_gate_access_type = wire(p, WIRE.W_4_SHIFT) - ap.next_gate_access_type; - - Fr value_delta = wire(p, WIRE.W_O_SHIFT) - wire(p, WIRE.W_O); - ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = - (ap.index_delta * MINUS_ONE + ONE) * value_delta * (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 - - // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the - // next gate would make the identity fail). We need to validate that its 'access type' bool is correct. Can't - // do with an arithmetic gate because of the `eta` factors. We need to check that the *next* gate's access - // type is correct, to cover this edge case - // deg 2 or 4 - ap.next_gate_access_type_is_boolean = - ap.next_gate_access_type * ap.next_gate_access_type - ap.next_gate_access_type; - - // Putting it all together... - evals[16] = ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation - * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 - evals[17] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 - evals[18] = ap.next_gate_access_type_is_boolean * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 - - ap.RAM_consistency_check_identity = ap.access_check * (wire(p, WIRE.Q_O)); // deg 3 or 9 - - /** - * RAM Timestamp Consistency Check - * - * | w1 | w2 | w3 | w4 | - * | index | timestamp | timestamp_check | -- | - * - * Let delta_index = index_{i + 1} - index_{i} - * - * Iff delta_index == 0, timestamp_check = timestamp_{i + 1} - timestamp_i - * Else timestamp_check = 0 - */ - ap.timestamp_delta = wire(p, WIRE.W_R_SHIFT) - wire(p, WIRE.W_R); - ap.RAM_timestamp_check_identity = (ap.index_delta * MINUS_ONE + ONE) * ap.timestamp_delta - wire(p, WIRE.W_O); // deg 3 - - /** - * Complete Contribution 12 - * The complete RAM/ROM memory identity - * Partial degree: - */ - ap.memory_identity = ap.ROM_consistency_check_identity; // deg 3 or 6 - ap.memory_identity = - ap.memory_identity + ap.RAM_timestamp_check_identity * (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 - ap.memory_identity = ap.memory_identity + ap.memory_record_check * (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 - ap.memory_identity = ap.memory_identity + ap.RAM_consistency_check_identity; // deg 3 or 9 - - // (deg 3 or 9) + (deg 4) + (deg 3) - ap.memory_identity = ap.memory_identity * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 - evals[13] = ap.memory_identity; - } - - // Constants for the Non-native Field relation - Fr constant LIMB_SIZE = Fr.wrap(uint256(1) << 68); - Fr constant SUBLIMB_SHIFT = Fr.wrap(uint256(1) << 14); - - // Parameters used within the Non-Native Field Relation - // A struct is used to work around stack too deep. This relation has alot of variables - struct NnfParams { - Fr limb_subproduct; - Fr non_native_field_gate_1; - Fr non_native_field_gate_2; - Fr non_native_field_gate_3; - Fr limb_accumulator_1; - Fr limb_accumulator_2; - Fr nnf_identity; - } - - function accumulateNnfRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - NnfParams memory ap; - - /** - * Contribution 12 - * Non native field arithmetic gate 2 - * deg 4 - * - * _ _ - * / _ _ _ 14 \ - * q_2 . q_4 | (w_1 . w_2) + (w_1 . w_2) + (w_1 . w_4 + w_2 . w_3 - w_3) . 2 - w_3 - w_4 | - * \_ _/ - * - * - */ - ap.limb_subproduct = wire(p, WIRE.W_L) * wire(p, WIRE.W_R_SHIFT) + wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R); - ap.non_native_field_gate_2 = - (wire(p, WIRE.W_L) * wire(p, WIRE.W_4) + wire(p, WIRE.W_R) * wire(p, WIRE.W_O) - wire(p, WIRE.W_O_SHIFT)); - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * LIMB_SIZE; - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 - wire(p, WIRE.W_4_SHIFT); - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 + ap.limb_subproduct; - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * wire(p, WIRE.Q_4); - - ap.limb_subproduct = ap.limb_subproduct * LIMB_SIZE; - ap.limb_subproduct = ap.limb_subproduct + (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); - ap.non_native_field_gate_1 = ap.limb_subproduct; - ap.non_native_field_gate_1 = ap.non_native_field_gate_1 - (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); - ap.non_native_field_gate_1 = ap.non_native_field_gate_1 * wire(p, WIRE.Q_O); - - ap.non_native_field_gate_3 = ap.limb_subproduct; - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 + wire(p, WIRE.W_4); - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 - (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 * wire(p, WIRE.Q_M); - - Fr non_native_field_identity = - ap.non_native_field_gate_1 + ap.non_native_field_gate_2 + ap.non_native_field_gate_3; - non_native_field_identity = non_native_field_identity * wire(p, WIRE.Q_R); - - // ((((w2' * 2^14 + w1') * 2^14 + w3) * 2^14 + w2) * 2^14 + w1 - w4) * qm - // deg 2 - ap.limb_accumulator_1 = wire(p, WIRE.W_R_SHIFT) * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L_SHIFT); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_O); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_R); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L); - ap.limb_accumulator_1 = ap.limb_accumulator_1 - wire(p, WIRE.W_4); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * wire(p, WIRE.Q_4); - - // ((((w3' * 2^14 + w2') * 2^14 + w1') * 2^14 + w4) * 2^14 + w3 - w4') * qm - // deg 2 - ap.limb_accumulator_2 = wire(p, WIRE.W_O_SHIFT) * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_R_SHIFT); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_L_SHIFT); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_4); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_O); - ap.limb_accumulator_2 = ap.limb_accumulator_2 - wire(p, WIRE.W_4_SHIFT); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * wire(p, WIRE.Q_M); - - Fr limb_accumulator_identity = ap.limb_accumulator_1 + ap.limb_accumulator_2; - limb_accumulator_identity = limb_accumulator_identity * wire(p, WIRE.Q_O); // deg 3 - - ap.nnf_identity = non_native_field_identity + limb_accumulator_identity; - ap.nnf_identity = ap.nnf_identity * (wire(p, WIRE.Q_NNF) * domainSep); - evals[19] = ap.nnf_identity; - } - - struct PoseidonExternalParams { - Fr s1; - Fr s2; - Fr s3; - Fr s4; - Fr u1; - Fr u2; - Fr u3; - Fr u4; - Fr t0; - Fr t1; - Fr t2; - Fr t3; - Fr v1; - Fr v2; - Fr v3; - Fr v4; - Fr q_pos_by_scaling; - } - - function accumulatePoseidonExternalRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - PoseidonExternalParams memory ep; - - ep.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); - ep.s2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_R); - ep.s3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_O); - ep.s4 = wire(p, WIRE.W_4) + wire(p, WIRE.Q_4); - - ep.u1 = ep.s1 * ep.s1 * ep.s1 * ep.s1 * ep.s1; - ep.u2 = ep.s2 * ep.s2 * ep.s2 * ep.s2 * ep.s2; - ep.u3 = ep.s3 * ep.s3 * ep.s3 * ep.s3 * ep.s3; - ep.u4 = ep.s4 * ep.s4 * ep.s4 * ep.s4 * ep.s4; - // matrix mul v = M_E * u with 14 additions - ep.t0 = ep.u1 + ep.u2; // u_1 + u_2 - ep.t1 = ep.u3 + ep.u4; // u_3 + u_4 - ep.t2 = ep.u2 + ep.u2 + ep.t1; // 2u_2 - // ep.t2 += ep.t1; // 2u_2 + u_3 + u_4 - ep.t3 = ep.u4 + ep.u4 + ep.t0; // 2u_4 - // ep.t3 += ep.t0; // u_1 + u_2 + 2u_4 - ep.v4 = ep.t1 + ep.t1; - ep.v4 = ep.v4 + ep.v4 + ep.t3; - // ep.v4 += ep.t3; // u_1 + u_2 + 4u_3 + 6u_4 - ep.v2 = ep.t0 + ep.t0; - ep.v2 = ep.v2 + ep.v2 + ep.t2; - // ep.v2 += ep.t2; // 4u_1 + 6u_2 + u_3 + u_4 - ep.v1 = ep.t3 + ep.v2; // 5u_1 + 7u_2 + u_3 + 3u_4 - ep.v3 = ep.t2 + ep.v4; // u_1 + 3u_2 + 5u_3 + 7u_4 - - ep.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_EXTERNAL) * domainSep; - evals[20] = evals[20] + ep.q_pos_by_scaling * (ep.v1 - wire(p, WIRE.W_L_SHIFT)); - - evals[21] = evals[21] + ep.q_pos_by_scaling * (ep.v2 - wire(p, WIRE.W_R_SHIFT)); - - evals[22] = evals[22] + ep.q_pos_by_scaling * (ep.v3 - wire(p, WIRE.W_O_SHIFT)); - - evals[23] = evals[23] + ep.q_pos_by_scaling * (ep.v4 - wire(p, WIRE.W_4_SHIFT)); - } - - struct PoseidonInternalParams { - Fr u1; - Fr u2; - Fr u3; - Fr u4; - Fr u_sum; - Fr v1; - Fr v2; - Fr v3; - Fr v4; - Fr s1; - Fr q_pos_by_scaling; - } - - function accumulatePoseidonInternalRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - PoseidonInternalParams memory ip; - - Fr[4] memory INTERNAL_MATRIX_DIAGONAL = [ - FrLib.from(0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7), - FrLib.from(0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b), - FrLib.from(0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15), - FrLib.from(0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b) - ]; - - // add round constants - ip.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); - - // apply s-box round - ip.u1 = ip.s1 * ip.s1 * ip.s1 * ip.s1 * ip.s1; - ip.u2 = wire(p, WIRE.W_R); - ip.u3 = wire(p, WIRE.W_O); - ip.u4 = wire(p, WIRE.W_4); - - // matrix mul with v = M_I * u 4 muls and 7 additions - ip.u_sum = ip.u1 + ip.u2 + ip.u3 + ip.u4; - - ip.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_INTERNAL) * domainSep; - - ip.v1 = ip.u1 * INTERNAL_MATRIX_DIAGONAL[0] + ip.u_sum; - evals[24] = evals[24] + ip.q_pos_by_scaling * (ip.v1 - wire(p, WIRE.W_L_SHIFT)); - - ip.v2 = ip.u2 * INTERNAL_MATRIX_DIAGONAL[1] + ip.u_sum; - evals[25] = evals[25] + ip.q_pos_by_scaling * (ip.v2 - wire(p, WIRE.W_R_SHIFT)); - - ip.v3 = ip.u3 * INTERNAL_MATRIX_DIAGONAL[2] + ip.u_sum; - evals[26] = evals[26] + ip.q_pos_by_scaling * (ip.v3 - wire(p, WIRE.W_O_SHIFT)); - - ip.v4 = ip.u4 * INTERNAL_MATRIX_DIAGONAL[3] + ip.u_sum; - evals[27] = evals[27] + ip.q_pos_by_scaling * (ip.v4 - wire(p, WIRE.W_4_SHIFT)); - } - - function scaleAndBatchSubrelations( - Fr[NUMBER_OF_SUBRELATIONS] memory evaluations, - Fr[NUMBER_OF_ALPHAS] memory subrelationChallenges - ) internal pure returns (Fr accumulator) { - accumulator = evaluations[0]; - - for (uint256 i = 1; i < NUMBER_OF_SUBRELATIONS; ++i) { - accumulator = accumulator + evaluations[i] * subrelationChallenges[i - 1]; - } - } + ap.index_is_monotonically_increasing = ap.index_delta * (ap.index_delta - Fr.wrap(1)); // deg 2 + + ap.adjacent_values_match_if_adjacent_indices_match = (ap.index_delta * MINUS_ONE + ONE) * ap.record_delta; // deg 2 + + evals[14] = + ap.adjacent_values_match_if_adjacent_indices_match * + (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + evals[15] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + + ap.ROM_consistency_check_identity = ap.memory_record_check * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 + + /** + * Contributions 15,16,17 + * RAM Consistency Check + * + * The 'access' type of the record is extracted with the expression `w_4 - ap.partial_record_check` + * (i.e. for an honest Prover `w1 * eta + w2 * eta^2 + w3 * eta^3 - w4 = access`. + * This is validated by requiring `access` to be boolean + * + * For two adjacent entries in the sorted list if _both_ + * A) index values match + * B) adjacent access value is 0 (i.e. next gate is a READ) + * then + * C) both values must match. + * The gate boolean check is + * (A && B) => C === !(A && B) || C === !A || !B || C + * + * N.B. it is the responsibility of the circuit writer to ensure that every RAM cell is initialized + * with a WRITE operation. + */ + Fr access_type = (wire(p, WIRE.W_4) - ap.partial_record_check); // will be 0 or 1 for honest Prover; deg 1 or 4 + ap.access_check = access_type * (access_type - Fr.wrap(1)); // check value is 0 or 1; deg 2 or 8 + + // reverse order we could re-use `ap.partial_record_check` 1 - ((w3' * eta + w2') * eta + w1') * eta + // deg 1 or 4 + ap.next_gate_access_type = wire(p, WIRE.W_O_SHIFT) * rp.etaThree; + ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); + ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_L_SHIFT) * rp.eta); + ap.next_gate_access_type = wire(p, WIRE.W_4_SHIFT) - ap.next_gate_access_type; + + Fr value_delta = wire(p, WIRE.W_O_SHIFT) - wire(p, WIRE.W_O); + ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = + (ap.index_delta * MINUS_ONE + ONE) * + value_delta * + (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 + + // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the + // next gate would make the identity fail). We need to validate that its 'access type' bool is correct. Can't + // do with an arithmetic gate because of the `eta` factors. We need to check that the *next* gate's access + // type is correct, to cover this edge case + // deg 2 or 4 + ap.next_gate_access_type_is_boolean = ap.next_gate_access_type * ap.next_gate_access_type - ap.next_gate_access_type; + + // Putting it all together... + evals[16] = + ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation * + (wire(p, WIRE.Q_O)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 + evals[17] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 + evals[18] = ap.next_gate_access_type_is_boolean * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 + + ap.RAM_consistency_check_identity = ap.access_check * (wire(p, WIRE.Q_O)); // deg 3 or 9 + + /** + * RAM Timestamp Consistency Check + * + * | w1 | w2 | w3 | w4 | + * | index | timestamp | timestamp_check | -- | + * + * Let delta_index = index_{i + 1} - index_{i} + * + * Iff delta_index == 0, timestamp_check = timestamp_{i + 1} - timestamp_i + * Else timestamp_check = 0 + */ + ap.timestamp_delta = wire(p, WIRE.W_R_SHIFT) - wire(p, WIRE.W_R); + ap.RAM_timestamp_check_identity = (ap.index_delta * MINUS_ONE + ONE) * ap.timestamp_delta - wire(p, WIRE.W_O); // deg 3 + + /** + * Complete Contribution 12 + * The complete RAM/ROM memory identity + * Partial degree: + */ + ap.memory_identity = ap.ROM_consistency_check_identity; // deg 3 or 6 + ap.memory_identity = ap.memory_identity + ap.RAM_timestamp_check_identity * (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 + ap.memory_identity = ap.memory_identity + ap.memory_record_check * (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 + ap.memory_identity = ap.memory_identity + ap.RAM_consistency_check_identity; // deg 3 or 9 + + // (deg 3 or 9) + (deg 4) + (deg 3) + ap.memory_identity = ap.memory_identity * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 + evals[13] = ap.memory_identity; + } + + // Constants for the Non-native Field relation + Fr constant LIMB_SIZE = Fr.wrap(uint256(1) << 68); + Fr constant SUBLIMB_SHIFT = Fr.wrap(uint256(1) << 14); + + // Parameters used within the Non-Native Field Relation + // A struct is used to work around stack too deep. This relation has alot of variables + struct NnfParams { + Fr limb_subproduct; + Fr non_native_field_gate_1; + Fr non_native_field_gate_2; + Fr non_native_field_gate_3; + Fr limb_accumulator_1; + Fr limb_accumulator_2; + Fr nnf_identity; + } + + function accumulateNnfRelation(Fr[NUMBER_OF_ENTITIES] memory p, Fr[NUMBER_OF_SUBRELATIONS] memory evals, Fr domainSep) internal pure { + NnfParams memory ap; + + /** + * Contribution 12 + * Non native field arithmetic gate 2 + * deg 4 + * + * _ _ + * / _ _ _ 14 \ + * q_2 . q_4 | (w_1 . w_2) + (w_1 . w_2) + (w_1 . w_4 + w_2 . w_3 - w_3) . 2 - w_3 - w_4 | + * \_ _/ + * + * + */ + ap.limb_subproduct = wire(p, WIRE.W_L) * wire(p, WIRE.W_R_SHIFT) + wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R); + ap.non_native_field_gate_2 = (wire(p, WIRE.W_L) * wire(p, WIRE.W_4) + wire(p, WIRE.W_R) * wire(p, WIRE.W_O) - wire(p, WIRE.W_O_SHIFT)); + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * LIMB_SIZE; + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 - wire(p, WIRE.W_4_SHIFT); + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 + ap.limb_subproduct; + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * wire(p, WIRE.Q_4); + + ap.limb_subproduct = ap.limb_subproduct * LIMB_SIZE; + ap.limb_subproduct = ap.limb_subproduct + (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); + ap.non_native_field_gate_1 = ap.limb_subproduct; + ap.non_native_field_gate_1 = ap.non_native_field_gate_1 - (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); + ap.non_native_field_gate_1 = ap.non_native_field_gate_1 * wire(p, WIRE.Q_O); + + ap.non_native_field_gate_3 = ap.limb_subproduct; + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 + wire(p, WIRE.W_4); + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 - (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 * wire(p, WIRE.Q_M); + + Fr non_native_field_identity = ap.non_native_field_gate_1 + ap.non_native_field_gate_2 + ap.non_native_field_gate_3; + non_native_field_identity = non_native_field_identity * wire(p, WIRE.Q_R); + + // ((((w2' * 2^14 + w1') * 2^14 + w3) * 2^14 + w2) * 2^14 + w1 - w4) * qm + // deg 2 + ap.limb_accumulator_1 = wire(p, WIRE.W_R_SHIFT) * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L_SHIFT); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_O); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_R); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L); + ap.limb_accumulator_1 = ap.limb_accumulator_1 - wire(p, WIRE.W_4); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * wire(p, WIRE.Q_4); + + // ((((w3' * 2^14 + w2') * 2^14 + w1') * 2^14 + w4) * 2^14 + w3 - w4') * qm + // deg 2 + ap.limb_accumulator_2 = wire(p, WIRE.W_O_SHIFT) * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_R_SHIFT); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_L_SHIFT); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_4); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_O); + ap.limb_accumulator_2 = ap.limb_accumulator_2 - wire(p, WIRE.W_4_SHIFT); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * wire(p, WIRE.Q_M); + + Fr limb_accumulator_identity = ap.limb_accumulator_1 + ap.limb_accumulator_2; + limb_accumulator_identity = limb_accumulator_identity * wire(p, WIRE.Q_O); // deg 3 + + ap.nnf_identity = non_native_field_identity + limb_accumulator_identity; + ap.nnf_identity = ap.nnf_identity * (wire(p, WIRE.Q_NNF) * domainSep); + evals[19] = ap.nnf_identity; + } + + struct PoseidonExternalParams { + Fr s1; + Fr s2; + Fr s3; + Fr s4; + Fr u1; + Fr u2; + Fr u3; + Fr u4; + Fr t0; + Fr t1; + Fr t2; + Fr t3; + Fr v1; + Fr v2; + Fr v3; + Fr v4; + Fr q_pos_by_scaling; + } + + function accumulatePoseidonExternalRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + PoseidonExternalParams memory ep; + + ep.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); + ep.s2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_R); + ep.s3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_O); + ep.s4 = wire(p, WIRE.W_4) + wire(p, WIRE.Q_4); + + ep.u1 = ep.s1 * ep.s1 * ep.s1 * ep.s1 * ep.s1; + ep.u2 = ep.s2 * ep.s2 * ep.s2 * ep.s2 * ep.s2; + ep.u3 = ep.s3 * ep.s3 * ep.s3 * ep.s3 * ep.s3; + ep.u4 = ep.s4 * ep.s4 * ep.s4 * ep.s4 * ep.s4; + // matrix mul v = M_E * u with 14 additions + ep.t0 = ep.u1 + ep.u2; // u_1 + u_2 + ep.t1 = ep.u3 + ep.u4; // u_3 + u_4 + ep.t2 = ep.u2 + ep.u2 + ep.t1; // 2u_2 + // ep.t2 += ep.t1; // 2u_2 + u_3 + u_4 + ep.t3 = ep.u4 + ep.u4 + ep.t0; // 2u_4 + // ep.t3 += ep.t0; // u_1 + u_2 + 2u_4 + ep.v4 = ep.t1 + ep.t1; + ep.v4 = ep.v4 + ep.v4 + ep.t3; + // ep.v4 += ep.t3; // u_1 + u_2 + 4u_3 + 6u_4 + ep.v2 = ep.t0 + ep.t0; + ep.v2 = ep.v2 + ep.v2 + ep.t2; + // ep.v2 += ep.t2; // 4u_1 + 6u_2 + u_3 + u_4 + ep.v1 = ep.t3 + ep.v2; // 5u_1 + 7u_2 + u_3 + 3u_4 + ep.v3 = ep.t2 + ep.v4; // u_1 + 3u_2 + 5u_3 + 7u_4 + + ep.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_EXTERNAL) * domainSep; + evals[20] = evals[20] + ep.q_pos_by_scaling * (ep.v1 - wire(p, WIRE.W_L_SHIFT)); + + evals[21] = evals[21] + ep.q_pos_by_scaling * (ep.v2 - wire(p, WIRE.W_R_SHIFT)); + + evals[22] = evals[22] + ep.q_pos_by_scaling * (ep.v3 - wire(p, WIRE.W_O_SHIFT)); + + evals[23] = evals[23] + ep.q_pos_by_scaling * (ep.v4 - wire(p, WIRE.W_4_SHIFT)); + } + + struct PoseidonInternalParams { + Fr u1; + Fr u2; + Fr u3; + Fr u4; + Fr u_sum; + Fr v1; + Fr v2; + Fr v3; + Fr v4; + Fr s1; + Fr q_pos_by_scaling; + } + + function accumulatePoseidonInternalRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + PoseidonInternalParams memory ip; + + Fr[4] memory INTERNAL_MATRIX_DIAGONAL = [ + FrLib.from(0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7), + FrLib.from(0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b), + FrLib.from(0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15), + FrLib.from(0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b) + ]; + + // add round constants + ip.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); + + // apply s-box round + ip.u1 = ip.s1 * ip.s1 * ip.s1 * ip.s1 * ip.s1; + ip.u2 = wire(p, WIRE.W_R); + ip.u3 = wire(p, WIRE.W_O); + ip.u4 = wire(p, WIRE.W_4); + + // matrix mul with v = M_I * u 4 muls and 7 additions + ip.u_sum = ip.u1 + ip.u2 + ip.u3 + ip.u4; + + ip.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_INTERNAL) * domainSep; + + ip.v1 = ip.u1 * INTERNAL_MATRIX_DIAGONAL[0] + ip.u_sum; + evals[24] = evals[24] + ip.q_pos_by_scaling * (ip.v1 - wire(p, WIRE.W_L_SHIFT)); + + ip.v2 = ip.u2 * INTERNAL_MATRIX_DIAGONAL[1] + ip.u_sum; + evals[25] = evals[25] + ip.q_pos_by_scaling * (ip.v2 - wire(p, WIRE.W_R_SHIFT)); + + ip.v3 = ip.u3 * INTERNAL_MATRIX_DIAGONAL[2] + ip.u_sum; + evals[26] = evals[26] + ip.q_pos_by_scaling * (ip.v3 - wire(p, WIRE.W_O_SHIFT)); + + ip.v4 = ip.u4 * INTERNAL_MATRIX_DIAGONAL[3] + ip.u_sum; + evals[27] = evals[27] + ip.q_pos_by_scaling * (ip.v4 - wire(p, WIRE.W_4_SHIFT)); + } + + function scaleAndBatchSubrelations( + Fr[NUMBER_OF_SUBRELATIONS] memory evaluations, + Fr[NUMBER_OF_ALPHAS] memory subrelationChallenges + ) internal pure returns (Fr accumulator) { + accumulator = evaluations[0]; + + for (uint256 i = 1; i < NUMBER_OF_SUBRELATIONS; ++i) { + accumulator = accumulator + evaluations[i] * subrelationChallenges[i - 1]; + } + } } // Field arithmetic libraries - prevent littering the code with modmul / addmul library CommitmentSchemeLib { - using FrLib for Fr; - - // Avoid stack too deep - struct ShpleminiIntermediates { - Fr unshiftedScalar; - Fr shiftedScalar; - Fr unshiftedScalarNeg; - Fr shiftedScalarNeg; - // Scalar to be multiplied by [1]₁ - Fr constantTermAccumulator; - // Accumulator for powers of rho - Fr batchingChallenge; - // Linear combination of multilinear (sumcheck) evaluations and powers of rho - Fr batchedEvaluation; - Fr[4] denominators; - Fr[4] batchingScalars; - // 1/(z - r^{2^i}) for i = 0, ..., logSize, dynamically updated - Fr posInvertedDenominator; - // 1/(z + r^{2^i}) for i = 0, ..., logSize, dynamically updated - Fr negInvertedDenominator; - // ν^{2i} * 1/(z - r^{2^i}) - Fr scalingFactorPos; - // ν^{2i+1} * 1/(z + r^{2^i}) - Fr scalingFactorNeg; - // Fold_i(r^{2^i}) reconstructed by Verifier - Fr[] foldPosEvaluations; - } - - function computeSquares(Fr r, uint256 logN) internal pure returns (Fr[] memory) { - Fr[] memory squares = new Fr[](logN); - squares[0] = r; - for (uint256 i = 1; i < logN; ++i) { - squares[i] = squares[i - 1].sqr(); - } - return squares; - } - // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., m-1 - - function computeFoldPosEvaluations( - Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckUChallenges, - Fr batchedEvalAccumulator, - Fr[CONST_PROOF_SIZE_LOG_N] memory geminiEvaluations, - Fr[] memory geminiEvalChallengePowers, - uint256 logSize - ) internal view returns (Fr[] memory) { - Fr[] memory foldPosEvaluations = new Fr[](logSize); - for (uint256 i = logSize; i > 0; --i) { - Fr challengePower = geminiEvalChallengePowers[i - 1]; - Fr u = sumcheckUChallenges[i - 1]; - - Fr batchedEvalRoundAcc = ( - (challengePower * batchedEvalAccumulator * Fr.wrap(2)) - - geminiEvaluations[i - 1] * (challengePower * (ONE - u) - u) - ); - // Divide by the denominator - batchedEvalRoundAcc = batchedEvalRoundAcc * (challengePower * (ONE - u) + u).invert(); - - batchedEvalAccumulator = batchedEvalRoundAcc; - foldPosEvaluations[i - 1] = batchedEvalRoundAcc; - } - return foldPosEvaluations; - } + using FrLib for Fr; + + // Avoid stack too deep + struct ShpleminiIntermediates { + Fr unshiftedScalar; + Fr shiftedScalar; + Fr unshiftedScalarNeg; + Fr shiftedScalarNeg; + // Scalar to be multiplied by [1]₁ + Fr constantTermAccumulator; + // Accumulator for powers of rho + Fr batchingChallenge; + // Linear combination of multilinear (sumcheck) evaluations and powers of rho + Fr batchedEvaluation; + Fr[4] denominators; + Fr[4] batchingScalars; + // 1/(z - r^{2^i}) for i = 0, ..., logSize, dynamically updated + Fr posInvertedDenominator; + // 1/(z + r^{2^i}) for i = 0, ..., logSize, dynamically updated + Fr negInvertedDenominator; + // ν^{2i} * 1/(z - r^{2^i}) + Fr scalingFactorPos; + // ν^{2i+1} * 1/(z + r^{2^i}) + Fr scalingFactorNeg; + // Fold_i(r^{2^i}) reconstructed by Verifier + Fr[] foldPosEvaluations; + } + + function computeSquares(Fr r, uint256 logN) internal pure returns (Fr[] memory) { + Fr[] memory squares = new Fr[](logN); + squares[0] = r; + for (uint256 i = 1; i < logN; ++i) { + squares[i] = squares[i - 1].sqr(); + } + return squares; + } + // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., m-1 + + function computeFoldPosEvaluations( + Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckUChallenges, + Fr batchedEvalAccumulator, + Fr[CONST_PROOF_SIZE_LOG_N] memory geminiEvaluations, + Fr[] memory geminiEvalChallengePowers, + uint256 logSize + ) internal view returns (Fr[] memory) { + Fr[] memory foldPosEvaluations = new Fr[](logSize); + for (uint256 i = logSize; i > 0; --i) { + Fr challengePower = geminiEvalChallengePowers[i - 1]; + Fr u = sumcheckUChallenges[i - 1]; + + Fr batchedEvalRoundAcc = ((challengePower * batchedEvalAccumulator * Fr.wrap(2)) - + geminiEvaluations[i - 1] * + (challengePower * (ONE - u) - u)); + // Divide by the denominator + batchedEvalRoundAcc = batchedEvalRoundAcc * (challengePower * (ONE - u) + u).invert(); + + batchedEvalAccumulator = batchedEvalRoundAcc; + foldPosEvaluations[i - 1] = batchedEvalRoundAcc; + } + return foldPosEvaluations; + } } uint256 constant Q = 21888242871839275222246405745257275088696311157297823662689037894645226208583; // EC group order. F_q function bytes32ToString(bytes32 value) pure returns (string memory result) { - bytes memory alphabet = "0123456789abcdef"; - - bytes memory str = new bytes(66); - str[0] = "0"; - str[1] = "x"; - for (uint256 i = 0; i < 32; i++) { - str[2 + i * 2] = alphabet[uint8(value[i] >> 4)]; - str[3 + i * 2] = alphabet[uint8(value[i] & 0x0f)]; - } - result = string(str); + bytes memory alphabet = "0123456789abcdef"; + + bytes memory str = new bytes(66); + str[0] = "0"; + str[1] = "x"; + for (uint256 i = 0; i < 32; i++) { + str[2 + i * 2] = alphabet[uint8(value[i] >> 4)]; + str[3 + i * 2] = alphabet[uint8(value[i] & 0x0f)]; + } + result = string(str); } // Fr utility function bytesToFr(bytes calldata proofSection) pure returns (Fr scalar) { - scalar = FrLib.fromBytes32(bytes32(proofSection)); + scalar = FrLib.fromBytes32(bytes32(proofSection)); } // EC Point utilities function bytesToG1Point(bytes calldata proofSection) pure returns (Honk.G1Point memory point) { - point = Honk.G1Point({ - x: uint256(bytes32(proofSection[0x00:0x20])) % Q, - y: uint256(bytes32(proofSection[0x20:0x40])) % Q - }); + point = Honk.G1Point({ x: uint256(bytes32(proofSection[0x00:0x20])) % Q, y: uint256(bytes32(proofSection[0x20:0x40])) % Q }); } function negateInplace(Honk.G1Point memory point) pure returns (Honk.G1Point memory) { - point.y = (Q - point.y) % Q; - return point; + point.y = (Q - point.y) % Q; + return point; } /** @@ -1648,33 +1641,32 @@ function negateInplace(Honk.G1Point memory point) pure returns (Honk.G1Point mem * @return lhs * @return rhs */ -function convertPairingPointsToG1(Fr[PAIRING_POINTS_SIZE] memory pairingPoints) - pure - returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) -{ - uint256 lhsX = Fr.unwrap(pairingPoints[0]); - lhsX |= Fr.unwrap(pairingPoints[1]) << 68; - lhsX |= Fr.unwrap(pairingPoints[2]) << 136; - lhsX |= Fr.unwrap(pairingPoints[3]) << 204; - lhs.x = lhsX; - - uint256 lhsY = Fr.unwrap(pairingPoints[4]); - lhsY |= Fr.unwrap(pairingPoints[5]) << 68; - lhsY |= Fr.unwrap(pairingPoints[6]) << 136; - lhsY |= Fr.unwrap(pairingPoints[7]) << 204; - lhs.y = lhsY; - - uint256 rhsX = Fr.unwrap(pairingPoints[8]); - rhsX |= Fr.unwrap(pairingPoints[9]) << 68; - rhsX |= Fr.unwrap(pairingPoints[10]) << 136; - rhsX |= Fr.unwrap(pairingPoints[11]) << 204; - rhs.x = rhsX; - - uint256 rhsY = Fr.unwrap(pairingPoints[12]); - rhsY |= Fr.unwrap(pairingPoints[13]) << 68; - rhsY |= Fr.unwrap(pairingPoints[14]) << 136; - rhsY |= Fr.unwrap(pairingPoints[15]) << 204; - rhs.y = rhsY; +function convertPairingPointsToG1( + Fr[PAIRING_POINTS_SIZE] memory pairingPoints +) pure returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) { + uint256 lhsX = Fr.unwrap(pairingPoints[0]); + lhsX |= Fr.unwrap(pairingPoints[1]) << 68; + lhsX |= Fr.unwrap(pairingPoints[2]) << 136; + lhsX |= Fr.unwrap(pairingPoints[3]) << 204; + lhs.x = lhsX; + + uint256 lhsY = Fr.unwrap(pairingPoints[4]); + lhsY |= Fr.unwrap(pairingPoints[5]) << 68; + lhsY |= Fr.unwrap(pairingPoints[6]) << 136; + lhsY |= Fr.unwrap(pairingPoints[7]) << 204; + lhs.y = lhsY; + + uint256 rhsX = Fr.unwrap(pairingPoints[8]); + rhsX |= Fr.unwrap(pairingPoints[9]) << 68; + rhsX |= Fr.unwrap(pairingPoints[10]) << 136; + rhsX |= Fr.unwrap(pairingPoints[11]) << 204; + rhs.x = rhsX; + + uint256 rhsY = Fr.unwrap(pairingPoints[12]); + rhsY |= Fr.unwrap(pairingPoints[13]) << 68; + rhsY |= Fr.unwrap(pairingPoints[14]) << 136; + rhsY |= Fr.unwrap(pairingPoints[15]) << 204; + rhs.y = rhsY; } /** @@ -1686,32 +1678,32 @@ function convertPairingPointsToG1(Fr[PAIRING_POINTS_SIZE] memory pairingPoints) * @return recursionSeparator The recursion separator - generated from hashing the above. */ function generateRecursionSeparator( - Fr[PAIRING_POINTS_SIZE] memory proofPairingPoints, - Honk.G1Point memory accLhs, - Honk.G1Point memory accRhs + Fr[PAIRING_POINTS_SIZE] memory proofPairingPoints, + Honk.G1Point memory accLhs, + Honk.G1Point memory accRhs ) pure returns (Fr recursionSeparator) { - // hash the proof aggregated X - // hash the proof aggregated Y - // hash the accum X - // hash the accum Y + // hash the proof aggregated X + // hash the proof aggregated Y + // hash the accum X + // hash the accum Y - (Honk.G1Point memory proofLhs, Honk.G1Point memory proofRhs) = convertPairingPointsToG1(proofPairingPoints); + (Honk.G1Point memory proofLhs, Honk.G1Point memory proofRhs) = convertPairingPointsToG1(proofPairingPoints); - uint256[8] memory recursionSeparatorElements; + uint256[8] memory recursionSeparatorElements; - // Proof points - recursionSeparatorElements[0] = proofLhs.x; - recursionSeparatorElements[1] = proofLhs.y; - recursionSeparatorElements[2] = proofRhs.x; - recursionSeparatorElements[3] = proofRhs.y; + // Proof points + recursionSeparatorElements[0] = proofLhs.x; + recursionSeparatorElements[1] = proofLhs.y; + recursionSeparatorElements[2] = proofRhs.x; + recursionSeparatorElements[3] = proofRhs.y; - // Accumulator points - recursionSeparatorElements[4] = accLhs.x; - recursionSeparatorElements[5] = accLhs.y; - recursionSeparatorElements[6] = accRhs.x; - recursionSeparatorElements[7] = accRhs.y; + // Accumulator points + recursionSeparatorElements[4] = accLhs.x; + recursionSeparatorElements[5] = accLhs.y; + recursionSeparatorElements[6] = accRhs.x; + recursionSeparatorElements[7] = accRhs.y; - recursionSeparator = FrLib.fromBytes32(keccak256(abi.encodePacked(recursionSeparatorElements))); + recursionSeparator = FrLib.fromBytes32(keccak256(abi.encodePacked(recursionSeparatorElements))); } /** @@ -1723,16 +1715,17 @@ function generateRecursionSeparator( * @param recursionSeperator The separator to use for the multiplication. * @return `(recursionSeperator * basePoint) + other`. */ -function mulWithSeperator(Honk.G1Point memory basePoint, Honk.G1Point memory other, Fr recursionSeperator) - view - returns (Honk.G1Point memory) -{ - Honk.G1Point memory result; +function mulWithSeperator( + Honk.G1Point memory basePoint, + Honk.G1Point memory other, + Fr recursionSeperator +) view returns (Honk.G1Point memory) { + Honk.G1Point memory result; - result = ecMul(recursionSeperator, basePoint); - result = ecAdd(result, other); + result = ecMul(recursionSeperator, basePoint); + result = ecAdd(result, other); - return result; + return result; } /** @@ -1744,41 +1737,41 @@ function mulWithSeperator(Honk.G1Point memory basePoint, Honk.G1Point memory oth * @return result The result of the multiplication. */ function ecMul(Fr value, Honk.G1Point memory point) view returns (Honk.G1Point memory) { - Honk.G1Point memory result; - - assembly { - let free := mload(0x40) - // Write the point into memory (two 32 byte words) - // Memory layout: - // Address | value - // free | point.x - // free + 0x20| point.y - mstore(free, mload(point)) - mstore(add(free, 0x20), mload(add(point, 0x20))) - // Write the scalar into memory (one 32 byte word) - // Memory layout: - // Address | value - // free + 0x40| value - mstore(add(free, 0x40), value) - - // Call the ecMul precompile, it takes in the following - // [point.x, point.y, scalar], and returns the result back into the free memory location. - let success := staticcall(gas(), 0x07, free, 0x60, free, 0x40) - if iszero(success) { - revert(0, 0) - } - // Copy the result of the multiplication back into the result memory location. - // Memory layout: - // Address | value - // result | result.x - // result + 0x20| result.y - mstore(result, mload(free)) - mstore(add(result, 0x20), mload(add(free, 0x20))) - - mstore(0x40, add(free, 0x60)) - } - - return result; + Honk.G1Point memory result; + + assembly { + let free := mload(0x40) + // Write the point into memory (two 32 byte words) + // Memory layout: + // Address | value + // free | point.x + // free + 0x20| point.y + mstore(free, mload(point)) + mstore(add(free, 0x20), mload(add(point, 0x20))) + // Write the scalar into memory (one 32 byte word) + // Memory layout: + // Address | value + // free + 0x40| value + mstore(add(free, 0x40), value) + + // Call the ecMul precompile, it takes in the following + // [point.x, point.y, scalar], and returns the result back into the free memory location. + let success := staticcall(gas(), 0x07, free, 0x60, free, 0x40) + if iszero(success) { + revert(0, 0) + } + // Copy the result of the multiplication back into the result memory location. + // Memory layout: + // Address | value + // result | result.x + // result + 0x20| result.y + mstore(result, mload(free)) + mstore(add(result, 0x20), mload(add(free, 0x20))) + + mstore(0x40, add(free, 0x60)) + } + + return result; } /** @@ -1790,649 +1783,637 @@ function ecMul(Fr value, Honk.G1Point memory point) view returns (Honk.G1Point m * @return result The result of the addition. */ function ecAdd(Honk.G1Point memory lhs, Honk.G1Point memory rhs) view returns (Honk.G1Point memory) { - Honk.G1Point memory result; - - assembly { - let free := mload(0x40) - // Write lhs into memory (two 32 byte words) - // Memory layout: - // Address | value - // free | lhs.x - // free + 0x20| lhs.y - mstore(free, mload(lhs)) - mstore(add(free, 0x20), mload(add(lhs, 0x20))) - - // Write rhs into memory (two 32 byte words) - // Memory layout: - // Address | value - // free + 0x40| rhs.x - // free + 0x60| rhs.y - mstore(add(free, 0x40), mload(rhs)) - mstore(add(free, 0x60), mload(add(rhs, 0x20))) - - // Call the ecAdd precompile, it takes in the following - // [lhs.x, lhs.y, rhs.x, rhs.y], and returns their addition back into the free memory location. - let success := staticcall(gas(), 0x06, free, 0x80, free, 0x40) - if iszero(success) { revert(0, 0) } - - // Copy the result of the addition back into the result memory location. - // Memory layout: - // Address | value - // result | result.x - // result + 0x20| result.y - mstore(result, mload(free)) - mstore(add(result, 0x20), mload(add(free, 0x20))) - - mstore(0x40, add(free, 0x80)) - } - - return result; + Honk.G1Point memory result; + + assembly { + let free := mload(0x40) + // Write lhs into memory (two 32 byte words) + // Memory layout: + // Address | value + // free | lhs.x + // free + 0x20| lhs.y + mstore(free, mload(lhs)) + mstore(add(free, 0x20), mload(add(lhs, 0x20))) + + // Write rhs into memory (two 32 byte words) + // Memory layout: + // Address | value + // free + 0x40| rhs.x + // free + 0x60| rhs.y + mstore(add(free, 0x40), mload(rhs)) + mstore(add(free, 0x60), mload(add(rhs, 0x20))) + + // Call the ecAdd precompile, it takes in the following + // [lhs.x, lhs.y, rhs.x, rhs.y], and returns their addition back into the free memory location. + let success := staticcall(gas(), 0x06, free, 0x80, free, 0x40) + if iszero(success) { + revert(0, 0) + } + + // Copy the result of the addition back into the result memory location. + // Memory layout: + // Address | value + // result | result.x + // result + 0x20| result.y + mstore(result, mload(free)) + mstore(add(result, 0x20), mload(add(free, 0x20))) + + mstore(0x40, add(free, 0x80)) + } + + return result; } function validateOnCurve(Honk.G1Point memory point) pure { - uint256 x = point.x; - uint256 y = point.y; + uint256 x = point.x; + uint256 y = point.y; - bool success = false; - assembly { - let xx := mulmod(x, x, Q) - success := eq(mulmod(y, y, Q), addmod(mulmod(x, xx, Q), 3, Q)) - } + bool success = false; + assembly { + let xx := mulmod(x, x, Q) + success := eq(mulmod(y, y, Q), addmod(mulmod(x, xx, Q), 3, Q)) + } - require(success, "point is not on the curve"); + require(success, "point is not on the curve"); } function pairing(Honk.G1Point memory rhs, Honk.G1Point memory lhs) view returns (bool decodedResult) { - bytes memory input = abi.encodePacked( - rhs.x, - rhs.y, - // Fixed G2 point - uint256(0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2), - uint256(0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed), - uint256(0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b), - uint256(0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa), - lhs.x, - lhs.y, - // G2 point from VK - uint256(0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1), - uint256(0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0), - uint256(0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4), - uint256(0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55) - ); - - (bool success, bytes memory result) = address(0x08).staticcall(input); - decodedResult = success && abi.decode(result, (bool)); + bytes memory input = abi.encodePacked( + rhs.x, + rhs.y, + // Fixed G2 point + uint256(0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2), + uint256(0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed), + uint256(0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b), + uint256(0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa), + lhs.x, + lhs.y, + // G2 point from VK + uint256(0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1), + uint256(0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0), + uint256(0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4), + uint256(0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55) + ); + + (bool success, bytes memory result) = address(0x08).staticcall(input); + decodedResult = success && abi.decode(result, (bool)); } // Field arithmetic libraries - prevent littering the code with modmul / addmul +abstract contract BaseZKHonkVerifier is IVerifier { + using FrLib for Fr; + + uint256 immutable $N; + uint256 immutable $LOG_N; + uint256 immutable $VK_HASH; + uint256 immutable $NUM_PUBLIC_INPUTS; + + constructor(uint256 _N, uint256 _logN, uint256 _vkHash, uint256 _numPublicInputs) { + $N = _N; + $LOG_N = _logN; + $VK_HASH = _vkHash; + $NUM_PUBLIC_INPUTS = _numPublicInputs; + } + + // Errors + error ProofLengthWrong(); + error ProofLengthWrongWithLogN(uint256 logN, uint256 actualLength, uint256 expectedLength); + error PublicInputsLengthWrong(); + error SumcheckFailed(); + error ShpleminiFailed(); + error GeminiChallengeInSubgroup(); + error ConsistencyCheckFailed(); + + // Constants for proof length calculation (matching UltraKeccakZKFlavor) + uint256 constant NUM_WITNESS_ENTITIES = 8; + uint256 constant NUM_ELEMENTS_COMM = 2; // uint256 elements for curve points + uint256 constant NUM_ELEMENTS_FR = 1; // uint256 elements for field elements + uint256 constant NUM_LIBRA_EVALUATIONS = 4; // libra evaluations + + // Calculate proof size based on log_n (matching UltraKeccakZKFlavor formula) + function calculateProofSize(uint256 logN) internal pure returns (uint256) { + // Witness and Libra commitments + uint256 proofLength = NUM_WITNESS_ENTITIES * NUM_ELEMENTS_COMM; // witness commitments + proofLength += NUM_ELEMENTS_COMM * 4; // Libra concat, grand sum, quotient comms + Gemini masking + // Sumcheck + proofLength += logN * ZK_BATCHED_RELATION_PARTIAL_LENGTH * NUM_ELEMENTS_FR; // sumcheck univariates + proofLength += NUMBER_OF_ENTITIES * NUM_ELEMENTS_FR; // sumcheck evaluations + // Libra and Gemini + proofLength += NUM_ELEMENTS_FR * 3; // Libra sum, claimed eval, Gemini masking eval + proofLength += logN * NUM_ELEMENTS_FR; // Gemini a evaluations + proofLength += NUM_LIBRA_EVALUATIONS * NUM_ELEMENTS_FR; // libra evaluations -abstract contract BaseZKHonkVerifier is IVerifier { - using FrLib for Fr; + // PCS commitments + proofLength += (logN - 1) * NUM_ELEMENTS_COMM; // Gemini Fold commitments + proofLength += NUM_ELEMENTS_COMM * 2; // Shplonk Q and KZG W commitments + + // Pairing points + proofLength += PAIRING_POINTS_SIZE; // pairing inputs carried on public inputs - uint256 immutable $N; - uint256 immutable $LOG_N; - uint256 immutable $VK_HASH; - uint256 immutable $NUM_PUBLIC_INPUTS; + return proofLength; + } - constructor(uint256 _N, uint256 _logN, uint256 _vkHash, uint256 _numPublicInputs) { - $N = _N; - $LOG_N = _logN; - $VK_HASH = _vkHash; - $NUM_PUBLIC_INPUTS = _numPublicInputs; + uint256 constant SHIFTED_COMMITMENTS_START = 30; + + function loadVerificationKey() internal pure virtual returns (Honk.VerificationKey memory); + + function verify(bytes calldata proof, bytes32[] calldata publicInputs) public view override returns (bool verified) { + // Calculate expected proof size based on $LOG_N + uint256 expectedProofSize = calculateProofSize($LOG_N); + + // Check the received proof is the expected size where each field element is 32 bytes + if (proof.length != expectedProofSize * 32) { + revert ProofLengthWrongWithLogN($LOG_N, proof.length, expectedProofSize * 32); } - // Errors - error ProofLengthWrong(); - error ProofLengthWrongWithLogN(uint256 logN, uint256 actualLength, uint256 expectedLength); - error PublicInputsLengthWrong(); - error SumcheckFailed(); - error ShpleminiFailed(); - error GeminiChallengeInSubgroup(); - error ConsistencyCheckFailed(); + Honk.VerificationKey memory vk = loadVerificationKey(); + Honk.ZKProof memory p = ZKTranscriptLib.loadProof(proof, $LOG_N); - // Constants for proof length calculation (matching UltraKeccakZKFlavor) - uint256 constant NUM_WITNESS_ENTITIES = 8; - uint256 constant NUM_ELEMENTS_COMM = 2; // uint256 elements for curve points - uint256 constant NUM_ELEMENTS_FR = 1; // uint256 elements for field elements - uint256 constant NUM_LIBRA_EVALUATIONS = 4; // libra evaluations + if (publicInputs.length != vk.publicInputsSize - PAIRING_POINTS_SIZE) { + revert PublicInputsLengthWrong(); + } - // Calculate proof size based on log_n (matching UltraKeccakZKFlavor formula) - function calculateProofSize(uint256 logN) internal pure returns (uint256) { - // Witness and Libra commitments - uint256 proofLength = NUM_WITNESS_ENTITIES * NUM_ELEMENTS_COMM; // witness commitments - proofLength += NUM_ELEMENTS_COMM * 4; // Libra concat, grand sum, quotient comms + Gemini masking + // Generate the fiat shamir challenges for the whole protocol + ZKTranscript memory t = ZKTranscriptLib.generateTranscript(p, publicInputs, $VK_HASH, $NUM_PUBLIC_INPUTS, $LOG_N); - // Sumcheck - proofLength += logN * ZK_BATCHED_RELATION_PARTIAL_LENGTH * NUM_ELEMENTS_FR; // sumcheck univariates - proofLength += NUMBER_OF_ENTITIES * NUM_ELEMENTS_FR; // sumcheck evaluations + // Derive public input delta + t.relationParameters.publicInputsDelta = computePublicInputDelta( + publicInputs, + p.pairingPointObject, + t.relationParameters.beta, + t.relationParameters.gamma /*pubInputsOffset=*/, + 1 + ); - // Libra and Gemini - proofLength += NUM_ELEMENTS_FR * 3; // Libra sum, claimed eval, Gemini masking eval - proofLength += logN * NUM_ELEMENTS_FR; // Gemini a evaluations - proofLength += NUM_LIBRA_EVALUATIONS * NUM_ELEMENTS_FR; // libra evaluations + // Sumcheck + if (!verifySumcheck(p, t)) revert SumcheckFailed(); - // PCS commitments - proofLength += (logN - 1) * NUM_ELEMENTS_COMM; // Gemini Fold commitments - proofLength += NUM_ELEMENTS_COMM * 2; // Shplonk Q and KZG W commitments + if (!verifyShplemini(p, vk, t)) revert ShpleminiFailed(); - // Pairing points - proofLength += PAIRING_POINTS_SIZE; // pairing inputs carried on public inputs + verified = true; + } - return proofLength; - } + uint256 constant PERMUTATION_ARGUMENT_VALUE_SEPARATOR = 1 << 28; - uint256 constant SHIFTED_COMMITMENTS_START = 30; + function computePublicInputDelta( + bytes32[] memory publicInputs, + Fr[PAIRING_POINTS_SIZE] memory pairingPointObject, + Fr beta, + Fr gamma, + uint256 offset + ) internal view returns (Fr publicInputDelta) { + Fr numerator = Fr.wrap(1); + Fr denominator = Fr.wrap(1); - function loadVerificationKey() internal pure virtual returns (Honk.VerificationKey memory); + Fr numeratorAcc = gamma + (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); + Fr denominatorAcc = gamma - (beta * FrLib.from(offset + 1)); - function verify(bytes calldata proof, bytes32[] calldata publicInputs) - public - view - override - returns (bool verified) { - // Calculate expected proof size based on $LOG_N - uint256 expectedProofSize = calculateProofSize($LOG_N); + for (uint256 i = 0; i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; i++) { + Fr pubInput = FrLib.fromBytes32(publicInputs[i]); + + numerator = numerator * (numeratorAcc + pubInput); + denominator = denominator * (denominatorAcc + pubInput); + + numeratorAcc = numeratorAcc + beta; + denominatorAcc = denominatorAcc - beta; + } - // Check the received proof is the expected size where each field element is 32 bytes - if (proof.length != expectedProofSize * 32) { - revert ProofLengthWrongWithLogN($LOG_N, proof.length, expectedProofSize * 32); - } + for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { + Fr pubInput = pairingPointObject[i]; - Honk.VerificationKey memory vk = loadVerificationKey(); - Honk.ZKProof memory p = ZKTranscriptLib.loadProof(proof, $LOG_N); + numerator = numerator * (numeratorAcc + pubInput); + denominator = denominator * (denominatorAcc + pubInput); - if (publicInputs.length != vk.publicInputsSize - PAIRING_POINTS_SIZE) { - revert PublicInputsLengthWrong(); - } + numeratorAcc = numeratorAcc + beta; + denominatorAcc = denominatorAcc - beta; + } + } - // Generate the fiat shamir challenges for the whole protocol - ZKTranscript memory t = - ZKTranscriptLib.generateTranscript(p, publicInputs, $VK_HASH, $NUM_PUBLIC_INPUTS, $LOG_N); + // Fr delta = numerator / denominator; // TOOO: batch invert later? + publicInputDelta = FrLib.div(numerator, denominator); + } - // Derive public input delta - t.relationParameters.publicInputsDelta = computePublicInputDelta( - publicInputs, - p.pairingPointObject, - t.relationParameters.beta, - t.relationParameters.gamma, /*pubInputsOffset=*/ - 1 - ); + function verifySumcheck(Honk.ZKProof memory proof, ZKTranscript memory tp) internal view returns (bool verified) { + Fr roundTargetSum = tp.libraChallenge * proof.libraSum; // default 0 + Fr powPartialEvaluation = Fr.wrap(1); - // Sumcheck - if (!verifySumcheck(p, t)) revert SumcheckFailed(); + // We perform sumcheck reductions over log n rounds ( the multivariate degree ) + for (uint256 round; round < $LOG_N; ++round) { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariate = proof.sumcheckUnivariates[round]; + Fr totalSum = roundUnivariate[0] + roundUnivariate[1]; + if (totalSum != roundTargetSum) revert SumcheckFailed(); - if (!verifyShplemini(p, vk, t)) revert ShpleminiFailed(); + Fr roundChallenge = tp.sumCheckUChallenges[round]; - verified = true; + // Update the round target for the next rounf + roundTargetSum = computeNextTargetSum(roundUnivariate, roundChallenge); + powPartialEvaluation = powPartialEvaluation * (Fr.wrap(1) + roundChallenge * (tp.gateChallenges[round] - Fr.wrap(1))); } - uint256 constant PERMUTATION_ARGUMENT_VALUE_SEPARATOR = 1 << 28; + // Last round + Fr grandHonkRelationSum = RelationsLib.accumulateRelationEvaluations( + proof.sumcheckEvaluations, + tp.relationParameters, + tp.alphas, + powPartialEvaluation + ); + + Fr evaluation = Fr.wrap(1); + for (uint256 i = 2; i < $LOG_N; i++) { + evaluation = evaluation * tp.sumCheckUChallenges[i]; + } + + grandHonkRelationSum = grandHonkRelationSum * (Fr.wrap(1) - evaluation) + proof.libraEvaluation * tp.libraChallenge; + verified = (grandHonkRelationSum == roundTargetSum); + } + + // Return the new target sum for the next sumcheck round + function computeNextTargetSum( + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, + Fr roundChallenge + ) internal view returns (Fr targetSum) { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), + Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000000240), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), + Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80) + ]; + + // To compute the next target sum, we evaluate the given univariate at a point u (challenge). + + // Performing Barycentric evaluations + // Compute B(x) + Fr numeratorValue = Fr.wrap(1); + for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { + numeratorValue = numeratorValue * (roundChallenge - Fr.wrap(i)); + } + + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory denominatorInverses; + for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { + denominatorInverses[i] = FrLib.invert(BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * (roundChallenge - Fr.wrap(i))); + } + + for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { + targetSum = targetSum + roundUnivariates[i] * denominatorInverses[i]; + } + + // Scale the sum by the value of B(x) + targetSum = targetSum * numeratorValue; + } + + uint256 constant LIBRA_COMMITMENTS = 3; + uint256 constant LIBRA_EVALUATIONS = 4; + uint256 constant LIBRA_UNIVARIATES_LENGTH = 9; + + struct PairingInputs { + Honk.G1Point P_0; + Honk.G1Point P_1; + } + + function verifyShplemini( + Honk.ZKProof memory proof, + Honk.VerificationKey memory vk, + ZKTranscript memory tp + ) internal view returns (bool verified) { + CommitmentSchemeLib.ShpleminiIntermediates memory mem; // stack + + // - Compute vector (r, r², ... , r²⁽ⁿ⁻¹⁾), where n = log_circuit_size + Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib.computeSquares(tp.geminiR, $LOG_N); + // Arrays hold values that will be linearly combined for the gemini and shplonk batch openings + Fr[] memory scalars = new Fr[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); + Honk.G1Point[] memory commitments = new Honk.G1Point[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); + + mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[0]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[0]).invert(); + + mem.unshiftedScalar = mem.posInvertedDenominator + (tp.shplonkNu * mem.negInvertedDenominator); + mem.shiftedScalar = tp.geminiR.invert() * (mem.posInvertedDenominator - (tp.shplonkNu * mem.negInvertedDenominator)); + + scalars[0] = Fr.wrap(1); + commitments[0] = proof.shplonkQ; + + /* Batch multivariate opening claims, shifted and unshifted + * The vector of scalars is populated as follows: + * \f[ + * \left( + * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) + * \right) + * \f] + * + * The following vector is concatenated to the vector of commitments: + * \f[ + * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} + * \f] + * + * Simultaneously, the evaluation of the multilinear polynomial + * \f[ + * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} + * \f] + * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. + * + * This approach minimizes the number of iterations over the commitments to multilinear polynomials + * and eliminates the need to store the powers of \f$ \rho \f$. + */ + mem.batchedEvaluation = proof.geminiMaskingEval; + mem.batchingChallenge = tp.rho; + mem.unshiftedScalarNeg = mem.unshiftedScalar.neg(); + mem.shiftedScalarNeg = mem.shiftedScalar.neg(); + + scalars[1] = mem.unshiftedScalarNeg; + for (uint256 i = 0; i < NUMBER_UNSHIFTED; ++i) { + scalars[i + 2] = mem.unshiftedScalarNeg * mem.batchingChallenge; + mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[i] * mem.batchingChallenge); + mem.batchingChallenge = mem.batchingChallenge * tp.rho; + } + // g commitments are accumulated at r + // For each of the to be shifted commitments perform the shift in place by + // adding to the unshifted value. + // We do so, as the values are to be used in batchMul later, and as + // `a * c + b * c = (a + b) * c` this will allow us to reduce memory and compute. + // Applied to w1, w2, w3, w4 and zPerm + for (uint256 i = 0; i < NUMBER_TO_BE_SHIFTED; ++i) { + uint256 scalarOff = i + SHIFTED_COMMITMENTS_START; + uint256 evaluationOff = i + NUMBER_UNSHIFTED; + + scalars[scalarOff] = scalars[scalarOff] + (mem.shiftedScalarNeg * mem.batchingChallenge); + mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[evaluationOff] * mem.batchingChallenge); + mem.batchingChallenge = mem.batchingChallenge * tp.rho; + } + + commitments[1] = proof.geminiMaskingPoly; + + commitments[2] = vk.qm; + commitments[3] = vk.qc; + commitments[4] = vk.ql; + commitments[5] = vk.qr; + commitments[6] = vk.qo; + commitments[7] = vk.q4; + commitments[8] = vk.qLookup; + commitments[9] = vk.qArith; + commitments[10] = vk.qDeltaRange; + commitments[11] = vk.qElliptic; + commitments[12] = vk.qMemory; + commitments[13] = vk.qNnf; + commitments[14] = vk.qPoseidon2External; + commitments[15] = vk.qPoseidon2Internal; + commitments[16] = vk.s1; + commitments[17] = vk.s2; + commitments[18] = vk.s3; + commitments[19] = vk.s4; + commitments[20] = vk.id1; + commitments[21] = vk.id2; + commitments[22] = vk.id3; + commitments[23] = vk.id4; + commitments[24] = vk.t1; + commitments[25] = vk.t2; + commitments[26] = vk.t3; + commitments[27] = vk.t4; + commitments[28] = vk.lagrangeFirst; + commitments[29] = vk.lagrangeLast; + + // Accumulate proof points + commitments[30] = proof.w1; + commitments[31] = proof.w2; + commitments[32] = proof.w3; + commitments[33] = proof.w4; + commitments[34] = proof.zPerm; + commitments[35] = proof.lookupInverses; + commitments[36] = proof.lookupReadCounts; + commitments[37] = proof.lookupReadTags; + + /* Batch gemini claims from the prover + * place the commitments to gemini aᵢ to the vector of commitments, compute the contributions from + * aᵢ(−r²ⁱ) for i=1, … , n−1 to the constant term accumulator, add corresponding scalars + * + * 1. Moves the vector + * \f[ + * \left( \text{com}(A_1), \text{com}(A_2), \ldots, \text{com}(A_{n-1}) \right) + * \f] + * to the 'commitments' vector. + * + * 2. Computes the scalars: + * \f[ + * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} + * \f] + * and places them into the 'scalars' vector. + * + * 3. Accumulates the summands of the constant term: + * \f[ + * \sum_{i=2}^{n-1} \frac{\nu^{i} \cdot A_i(-r^{2^i})}{z + r^{2^i}} + * \f] + * and adds them to the 'constant_term_accumulator'. + */ + + // Add contributions from A₀(r) and A₀(-r) to constant_term_accumulator: + // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., $LOG_N - 1 + Fr[] memory foldPosEvaluations = CommitmentSchemeLib.computeFoldPosEvaluations( + tp.sumCheckUChallenges, + mem.batchedEvaluation, + proof.geminiAEvaluations, + powers_of_evaluation_challenge, + $LOG_N + ); - function computePublicInputDelta( - bytes32[] memory publicInputs, - Fr[PAIRING_POINTS_SIZE] memory pairingPointObject, - Fr beta, - Fr gamma, - uint256 offset - ) internal view returns (Fr publicInputDelta) { - Fr numerator = Fr.wrap(1); - Fr denominator = Fr.wrap(1); + mem.constantTermAccumulator = foldPosEvaluations[0] * mem.posInvertedDenominator; + mem.constantTermAccumulator = mem.constantTermAccumulator + (proof.geminiAEvaluations[0] * tp.shplonkNu * mem.negInvertedDenominator); - Fr numeratorAcc = gamma + (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); - Fr denominatorAcc = gamma - (beta * FrLib.from(offset + 1)); + mem.batchingChallenge = tp.shplonkNu.sqr(); + uint256 boundary = NUMBER_UNSHIFTED + 2; - { - for (uint256 i = 0; i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; i++) { - Fr pubInput = FrLib.fromBytes32(publicInputs[i]); + // Compute Shplonk constant term contributions from Aₗ(± r^{2ˡ}) for l = 1, ..., m-1; + // Compute scalar multipliers for each fold commitment + for (uint256 i = 0; i < $LOG_N - 1; ++i) { + bool dummy_round = i >= ($LOG_N - 1); - numerator = numerator * (numeratorAcc + pubInput); - denominator = denominator * (denominatorAcc + pubInput); + if (!dummy_round) { + // Update inverted denominators + mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[i + 1]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[i + 1]).invert(); + + // Compute the scalar multipliers for Aₗ(± r^{2ˡ}) and [Aₗ] + mem.scalingFactorPos = mem.batchingChallenge * mem.posInvertedDenominator; + mem.scalingFactorNeg = mem.batchingChallenge * tp.shplonkNu * mem.negInvertedDenominator; + scalars[boundary + i] = mem.scalingFactorNeg.neg() + mem.scalingFactorPos.neg(); - numeratorAcc = numeratorAcc + beta; - denominatorAcc = denominatorAcc - beta; - } + // Accumulate the const term contribution given by + // v^{2l} * Aₗ(r^{2ˡ}) /(z-r^{2^l}) + v^{2l+1} * Aₗ(-r^{2ˡ}) /(z+ r^{2^l}) + Fr accumContribution = mem.scalingFactorNeg * proof.geminiAEvaluations[i + 1]; + accumContribution = accumContribution + mem.scalingFactorPos * foldPosEvaluations[i + 1]; + mem.constantTermAccumulator = mem.constantTermAccumulator + accumContribution; + } + // Update the running power of v + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; - for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - Fr pubInput = pairingPointObject[i]; + commitments[boundary + i] = proof.geminiFoldComms[i]; + } - numerator = numerator * (numeratorAcc + pubInput); - denominator = denominator * (denominatorAcc + pubInput); + boundary += $LOG_N - 1; - numeratorAcc = numeratorAcc + beta; - denominatorAcc = denominatorAcc - beta; - } - } + // Finalize the batch opening claim + mem.denominators[0] = Fr.wrap(1).div(tp.shplonkZ - tp.geminiR); + mem.denominators[1] = Fr.wrap(1).div(tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR); + mem.denominators[2] = mem.denominators[0]; + mem.denominators[3] = mem.denominators[0]; - // Fr delta = numerator / denominator; // TOOO: batch invert later? - publicInputDelta = FrLib.div(numerator, denominator); + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; + for (uint256 i = 0; i < LIBRA_EVALUATIONS; i++) { + Fr scalingFactor = mem.denominators[i] * mem.batchingChallenge; + mem.batchingScalars[i] = scalingFactor.neg(); + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu; + mem.constantTermAccumulator = mem.constantTermAccumulator + scalingFactor * proof.libraPolyEvals[i]; } + scalars[boundary] = mem.batchingScalars[0]; + scalars[boundary + 1] = mem.batchingScalars[1] + mem.batchingScalars[2]; + scalars[boundary + 2] = mem.batchingScalars[3]; - function verifySumcheck(Honk.ZKProof memory proof, ZKTranscript memory tp) internal view returns (bool verified) { - Fr roundTargetSum = tp.libraChallenge * proof.libraSum; // default 0 - Fr powPartialEvaluation = Fr.wrap(1); + for (uint256 i = 0; i < LIBRA_COMMITMENTS; i++) { + commitments[boundary++] = proof.libraCommitments[i]; + } + + commitments[boundary] = Honk.G1Point({ x: 1, y: 2 }); + scalars[boundary++] = mem.constantTermAccumulator; - // We perform sumcheck reductions over log n rounds ( the multivariate degree ) - for (uint256 round; round < $LOG_N; ++round) { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariate = proof.sumcheckUnivariates[round]; - Fr totalSum = roundUnivariate[0] + roundUnivariate[1]; - if (totalSum != roundTargetSum) revert SumcheckFailed(); + if (!checkEvalsConsistency(proof.libraPolyEvals, tp.geminiR, tp.sumCheckUChallenges, proof.libraEvaluation)) { + revert ConsistencyCheckFailed(); + } - Fr roundChallenge = tp.sumCheckUChallenges[round]; + Honk.G1Point memory quotient_commitment = proof.kzgQuotient; - // Update the round target for the next rounf - roundTargetSum = computeNextTargetSum(roundUnivariate, roundChallenge); - powPartialEvaluation = - powPartialEvaluation * (Fr.wrap(1) + roundChallenge * (tp.gateChallenges[round] - Fr.wrap(1))); - } + commitments[boundary] = quotient_commitment; + scalars[boundary] = tp.shplonkZ; // evaluation challenge - // Last round - Fr grandHonkRelationSum = RelationsLib.accumulateRelationEvaluations( - proof.sumcheckEvaluations, tp.relationParameters, tp.alphas, powPartialEvaluation - ); + PairingInputs memory pair; + pair.P_0 = batchMul(commitments, scalars); + pair.P_1 = negateInplace(quotient_commitment); - Fr evaluation = Fr.wrap(1); - for (uint256 i = 2; i < $LOG_N; i++) { - evaluation = evaluation * tp.sumCheckUChallenges[i]; - } + // Aggregate pairing points + Fr recursionSeparator = generateRecursionSeparator(proof.pairingPointObject, pair.P_0, pair.P_1); + (Honk.G1Point memory P_0_other, Honk.G1Point memory P_1_other) = convertPairingPointsToG1(proof.pairingPointObject); - grandHonkRelationSum = - grandHonkRelationSum * (Fr.wrap(1) - evaluation) + proof.libraEvaluation * tp.libraChallenge; - verified = (grandHonkRelationSum == roundTargetSum); + // Validate the points from the proof are on the curve + validateOnCurve(P_0_other); + validateOnCurve(P_1_other); + + // accumulate with aggregate points in proof + pair.P_0 = mulWithSeperator(pair.P_0, P_0_other, recursionSeparator); + pair.P_1 = mulWithSeperator(pair.P_1, P_1_other, recursionSeparator); + + return pairing(pair.P_0, pair.P_1); + } + + struct SmallSubgroupIpaIntermediates { + Fr[SUBGROUP_SIZE] challengePolyLagrange; + Fr challengePolyEval; + Fr lagrangeFirst; + Fr lagrangeLast; + Fr rootPower; + Fr[SUBGROUP_SIZE] denominators; // this has to disappear + Fr diff; + } + + function checkEvalsConsistency( + Fr[LIBRA_EVALUATIONS] memory libraPolyEvals, + Fr geminiR, + Fr[CONST_PROOF_SIZE_LOG_N] memory uChallenges, + Fr libraEval + ) internal view returns (bool check) { + Fr one = Fr.wrap(1); + Fr vanishingPolyEval = geminiR.pow(SUBGROUP_SIZE) - one; + if (vanishingPolyEval == Fr.wrap(0)) { + revert GeminiChallengeInSubgroup(); } - // Return the new target sum for the next sumcheck round - function computeNextTargetSum(Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, Fr roundChallenge) - internal - view - returns (Fr targetSum) - { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), - Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000000240), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), - Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80) - ]; - - // To compute the next target sum, we evaluate the given univariate at a point u (challenge). - - // Performing Barycentric evaluations - // Compute B(x) - Fr numeratorValue = Fr.wrap(1); - for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - numeratorValue = numeratorValue * (roundChallenge - Fr.wrap(i)); - } - - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory denominatorInverses; - for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - denominatorInverses[i] = FrLib.invert(BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * (roundChallenge - Fr.wrap(i))); - } - - for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - targetSum = targetSum + roundUnivariates[i] * denominatorInverses[i]; - } - - // Scale the sum by the value of B(x) - targetSum = targetSum * numeratorValue; - } - - uint256 constant LIBRA_COMMITMENTS = 3; - uint256 constant LIBRA_EVALUATIONS = 4; - uint256 constant LIBRA_UNIVARIATES_LENGTH = 9; - - struct PairingInputs { - Honk.G1Point P_0; - Honk.G1Point P_1; - } - - function verifyShplemini(Honk.ZKProof memory proof, Honk.VerificationKey memory vk, ZKTranscript memory tp) - internal - view - returns (bool verified) - { - CommitmentSchemeLib.ShpleminiIntermediates memory mem; // stack - - // - Compute vector (r, r², ... , r²⁽ⁿ⁻¹⁾), where n = log_circuit_size - Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib.computeSquares(tp.geminiR, $LOG_N); - // Arrays hold values that will be linearly combined for the gemini and shplonk batch openings - Fr[] memory scalars = new Fr[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); - Honk.G1Point[] memory commitments = new Honk.G1Point[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); - - mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[0]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[0]).invert(); - - mem.unshiftedScalar = mem.posInvertedDenominator + (tp.shplonkNu * mem.negInvertedDenominator); - mem.shiftedScalar = - tp.geminiR.invert() * (mem.posInvertedDenominator - (tp.shplonkNu * mem.negInvertedDenominator)); - - scalars[0] = Fr.wrap(1); - commitments[0] = proof.shplonkQ; - - /* Batch multivariate opening claims, shifted and unshifted - * The vector of scalars is populated as follows: - * \f[ - * \left( - * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) - * \right) - * \f] - * - * The following vector is concatenated to the vector of commitments: - * \f[ - * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} - * \f] - * - * Simultaneously, the evaluation of the multilinear polynomial - * \f[ - * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} - * \f] - * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. - * - * This approach minimizes the number of iterations over the commitments to multilinear polynomials - * and eliminates the need to store the powers of \f$ \rho \f$. - */ - mem.batchedEvaluation = proof.geminiMaskingEval; - mem.batchingChallenge = tp.rho; - mem.unshiftedScalarNeg = mem.unshiftedScalar.neg(); - mem.shiftedScalarNeg = mem.shiftedScalar.neg(); - - scalars[1] = mem.unshiftedScalarNeg; - for (uint256 i = 0; i < NUMBER_UNSHIFTED; ++i) { - scalars[i + 2] = mem.unshiftedScalarNeg * mem.batchingChallenge; - mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[i] * mem.batchingChallenge); - mem.batchingChallenge = mem.batchingChallenge * tp.rho; - } - // g commitments are accumulated at r - // For each of the to be shifted commitments perform the shift in place by - // adding to the unshifted value. - // We do so, as the values are to be used in batchMul later, and as - // `a * c + b * c = (a + b) * c` this will allow us to reduce memory and compute. - // Applied to w1, w2, w3, w4 and zPerm - for (uint256 i = 0; i < NUMBER_TO_BE_SHIFTED; ++i) { - uint256 scalarOff = i + SHIFTED_COMMITMENTS_START; - uint256 evaluationOff = i + NUMBER_UNSHIFTED; - - scalars[scalarOff] = scalars[scalarOff] + (mem.shiftedScalarNeg * mem.batchingChallenge); - mem.batchedEvaluation = - mem.batchedEvaluation + (proof.sumcheckEvaluations[evaluationOff] * mem.batchingChallenge); - mem.batchingChallenge = mem.batchingChallenge * tp.rho; - } - - commitments[1] = proof.geminiMaskingPoly; - - commitments[2] = vk.qm; - commitments[3] = vk.qc; - commitments[4] = vk.ql; - commitments[5] = vk.qr; - commitments[6] = vk.qo; - commitments[7] = vk.q4; - commitments[8] = vk.qLookup; - commitments[9] = vk.qArith; - commitments[10] = vk.qDeltaRange; - commitments[11] = vk.qElliptic; - commitments[12] = vk.qMemory; - commitments[13] = vk.qNnf; - commitments[14] = vk.qPoseidon2External; - commitments[15] = vk.qPoseidon2Internal; - commitments[16] = vk.s1; - commitments[17] = vk.s2; - commitments[18] = vk.s3; - commitments[19] = vk.s4; - commitments[20] = vk.id1; - commitments[21] = vk.id2; - commitments[22] = vk.id3; - commitments[23] = vk.id4; - commitments[24] = vk.t1; - commitments[25] = vk.t2; - commitments[26] = vk.t3; - commitments[27] = vk.t4; - commitments[28] = vk.lagrangeFirst; - commitments[29] = vk.lagrangeLast; - - // Accumulate proof points - commitments[30] = proof.w1; - commitments[31] = proof.w2; - commitments[32] = proof.w3; - commitments[33] = proof.w4; - commitments[34] = proof.zPerm; - commitments[35] = proof.lookupInverses; - commitments[36] = proof.lookupReadCounts; - commitments[37] = proof.lookupReadTags; - - /* Batch gemini claims from the prover - * place the commitments to gemini aᵢ to the vector of commitments, compute the contributions from - * aᵢ(−r²ⁱ) for i=1, … , n−1 to the constant term accumulator, add corresponding scalars - * - * 1. Moves the vector - * \f[ - * \left( \text{com}(A_1), \text{com}(A_2), \ldots, \text{com}(A_{n-1}) \right) - * \f] - * to the 'commitments' vector. - * - * 2. Computes the scalars: - * \f[ - * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} - * \f] - * and places them into the 'scalars' vector. - * - * 3. Accumulates the summands of the constant term: - * \f[ - * \sum_{i=2}^{n-1} \frac{\nu^{i} \cdot A_i(-r^{2^i})}{z + r^{2^i}} - * \f] - * and adds them to the 'constant_term_accumulator'. - */ - - // Add contributions from A₀(r) and A₀(-r) to constant_term_accumulator: - // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., $LOG_N - 1 - Fr[] memory foldPosEvaluations = CommitmentSchemeLib.computeFoldPosEvaluations( - tp.sumCheckUChallenges, - mem.batchedEvaluation, - proof.geminiAEvaluations, - powers_of_evaluation_challenge, - $LOG_N - ); - - mem.constantTermAccumulator = foldPosEvaluations[0] * mem.posInvertedDenominator; - mem.constantTermAccumulator = - mem.constantTermAccumulator + (proof.geminiAEvaluations[0] * tp.shplonkNu * mem.negInvertedDenominator); - - mem.batchingChallenge = tp.shplonkNu.sqr(); - uint256 boundary = NUMBER_UNSHIFTED + 2; - - // Compute Shplonk constant term contributions from Aₗ(± r^{2ˡ}) for l = 1, ..., m-1; - // Compute scalar multipliers for each fold commitment - for (uint256 i = 0; i < $LOG_N - 1; ++i) { - bool dummy_round = i >= ($LOG_N - 1); - - if (!dummy_round) { - // Update inverted denominators - mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[i + 1]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[i + 1]).invert(); - - // Compute the scalar multipliers for Aₗ(± r^{2ˡ}) and [Aₗ] - mem.scalingFactorPos = mem.batchingChallenge * mem.posInvertedDenominator; - mem.scalingFactorNeg = mem.batchingChallenge * tp.shplonkNu * mem.negInvertedDenominator; - scalars[boundary + i] = mem.scalingFactorNeg.neg() + mem.scalingFactorPos.neg(); - - // Accumulate the const term contribution given by - // v^{2l} * Aₗ(r^{2ˡ}) /(z-r^{2^l}) + v^{2l+1} * Aₗ(-r^{2ˡ}) /(z+ r^{2^l}) - Fr accumContribution = mem.scalingFactorNeg * proof.geminiAEvaluations[i + 1]; - accumContribution = accumContribution + mem.scalingFactorPos * foldPosEvaluations[i + 1]; - mem.constantTermAccumulator = mem.constantTermAccumulator + accumContribution; - } - // Update the running power of v - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; - - commitments[boundary + i] = proof.geminiFoldComms[i]; - } - - boundary += $LOG_N - 1; - - // Finalize the batch opening claim - mem.denominators[0] = Fr.wrap(1).div(tp.shplonkZ - tp.geminiR); - mem.denominators[1] = Fr.wrap(1).div(tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR); - mem.denominators[2] = mem.denominators[0]; - mem.denominators[3] = mem.denominators[0]; - - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; - for (uint256 i = 0; i < LIBRA_EVALUATIONS; i++) { - Fr scalingFactor = mem.denominators[i] * mem.batchingChallenge; - mem.batchingScalars[i] = scalingFactor.neg(); - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu; - mem.constantTermAccumulator = mem.constantTermAccumulator + scalingFactor * proof.libraPolyEvals[i]; - } - scalars[boundary] = mem.batchingScalars[0]; - scalars[boundary + 1] = mem.batchingScalars[1] + mem.batchingScalars[2]; - scalars[boundary + 2] = mem.batchingScalars[3]; - - for (uint256 i = 0; i < LIBRA_COMMITMENTS; i++) { - commitments[boundary++] = proof.libraCommitments[i]; - } - - commitments[boundary] = Honk.G1Point({x: 1, y: 2}); - scalars[boundary++] = mem.constantTermAccumulator; - - if (!checkEvalsConsistency(proof.libraPolyEvals, tp.geminiR, tp.sumCheckUChallenges, proof.libraEvaluation)) { - revert ConsistencyCheckFailed(); - } - - Honk.G1Point memory quotient_commitment = proof.kzgQuotient; - - commitments[boundary] = quotient_commitment; - scalars[boundary] = tp.shplonkZ; // evaluation challenge - - PairingInputs memory pair; - pair.P_0 = batchMul(commitments, scalars); - pair.P_1 = negateInplace(quotient_commitment); - - // Aggregate pairing points - Fr recursionSeparator = generateRecursionSeparator(proof.pairingPointObject, pair.P_0, pair.P_1); - (Honk.G1Point memory P_0_other, Honk.G1Point memory P_1_other) = - convertPairingPointsToG1(proof.pairingPointObject); - - // Validate the points from the proof are on the curve - validateOnCurve(P_0_other); - validateOnCurve(P_1_other); - - // accumulate with aggregate points in proof - pair.P_0 = mulWithSeperator(pair.P_0, P_0_other, recursionSeparator); - pair.P_1 = mulWithSeperator(pair.P_1, P_1_other, recursionSeparator); - - return pairing(pair.P_0, pair.P_1); - } - - struct SmallSubgroupIpaIntermediates { - Fr[SUBGROUP_SIZE] challengePolyLagrange; - Fr challengePolyEval; - Fr lagrangeFirst; - Fr lagrangeLast; - Fr rootPower; - Fr[SUBGROUP_SIZE] denominators; // this has to disappear - Fr diff; - } - - function checkEvalsConsistency( - Fr[LIBRA_EVALUATIONS] memory libraPolyEvals, - Fr geminiR, - Fr[CONST_PROOF_SIZE_LOG_N] memory uChallenges, - Fr libraEval - ) internal view returns (bool check) { - Fr one = Fr.wrap(1); - Fr vanishingPolyEval = geminiR.pow(SUBGROUP_SIZE) - one; - if (vanishingPolyEval == Fr.wrap(0)) { - revert GeminiChallengeInSubgroup(); - } - - SmallSubgroupIpaIntermediates memory mem; - mem.challengePolyLagrange[0] = one; - for (uint256 round = 0; round < $LOG_N; round++) { - uint256 currIdx = 1 + LIBRA_UNIVARIATES_LENGTH * round; - mem.challengePolyLagrange[currIdx] = one; - for (uint256 idx = currIdx + 1; idx < currIdx + LIBRA_UNIVARIATES_LENGTH; idx++) { - mem.challengePolyLagrange[idx] = mem.challengePolyLagrange[idx - 1] * uChallenges[round]; - } - } - - mem.rootPower = one; - mem.challengePolyEval = Fr.wrap(0); - for (uint256 idx = 0; idx < SUBGROUP_SIZE; idx++) { - mem.denominators[idx] = mem.rootPower * geminiR - one; - mem.denominators[idx] = mem.denominators[idx].invert(); - mem.challengePolyEval = mem.challengePolyEval + mem.challengePolyLagrange[idx] * mem.denominators[idx]; - mem.rootPower = mem.rootPower * SUBGROUP_GENERATOR_INVERSE; - } - - Fr numerator = vanishingPolyEval * Fr.wrap(SUBGROUP_SIZE).invert(); - mem.challengePolyEval = mem.challengePolyEval * numerator; - mem.lagrangeFirst = mem.denominators[0] * numerator; - mem.lagrangeLast = mem.denominators[SUBGROUP_SIZE - 1] * numerator; - - mem.diff = mem.lagrangeFirst * libraPolyEvals[2]; - - mem.diff = mem.diff - + (geminiR - SUBGROUP_GENERATOR_INVERSE) - * (libraPolyEvals[1] - libraPolyEvals[2] - libraPolyEvals[0] * mem.challengePolyEval); - mem.diff = mem.diff + mem.lagrangeLast * (libraPolyEvals[2] - libraEval) - vanishingPolyEval * libraPolyEvals[3]; - - check = mem.diff == Fr.wrap(0); - } - - // This implementation is the same as above with different constants - function batchMul(Honk.G1Point[] memory base, Fr[] memory scalars) - internal - view - returns (Honk.G1Point memory result) - { - uint256 limit = NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3; + SmallSubgroupIpaIntermediates memory mem; + mem.challengePolyLagrange[0] = one; + for (uint256 round = 0; round < $LOG_N; round++) { + uint256 currIdx = 1 + LIBRA_UNIVARIATES_LENGTH * round; + mem.challengePolyLagrange[currIdx] = one; + for (uint256 idx = currIdx + 1; idx < currIdx + LIBRA_UNIVARIATES_LENGTH; idx++) { + mem.challengePolyLagrange[idx] = mem.challengePolyLagrange[idx - 1] * uChallenges[round]; + } + } + + mem.rootPower = one; + mem.challengePolyEval = Fr.wrap(0); + for (uint256 idx = 0; idx < SUBGROUP_SIZE; idx++) { + mem.denominators[idx] = mem.rootPower * geminiR - one; + mem.denominators[idx] = mem.denominators[idx].invert(); + mem.challengePolyEval = mem.challengePolyEval + mem.challengePolyLagrange[idx] * mem.denominators[idx]; + mem.rootPower = mem.rootPower * SUBGROUP_GENERATOR_INVERSE; + } + + Fr numerator = vanishingPolyEval * Fr.wrap(SUBGROUP_SIZE).invert(); + mem.challengePolyEval = mem.challengePolyEval * numerator; + mem.lagrangeFirst = mem.denominators[0] * numerator; + mem.lagrangeLast = mem.denominators[SUBGROUP_SIZE - 1] * numerator; + + mem.diff = mem.lagrangeFirst * libraPolyEvals[2]; - // Validate all points are on the curve - for (uint256 i = 0; i < limit; ++i) { - validateOnCurve(base[i]); - } + mem.diff = + mem.diff + + (geminiR - SUBGROUP_GENERATOR_INVERSE) * + (libraPolyEvals[1] - libraPolyEvals[2] - libraPolyEvals[0] * mem.challengePolyEval); + mem.diff = mem.diff + mem.lagrangeLast * (libraPolyEvals[2] - libraEval) - vanishingPolyEval * libraPolyEvals[3]; - bool success = true; - assembly { - let free := mload(0x40) + check = mem.diff == Fr.wrap(0); + } - let count := 0x01 - for {} lt(count, add(limit, 1)) { count := add(count, 1) } { - // Get loop offsets - let base_base := add(base, mul(count, 0x20)) - let scalar_base := add(scalars, mul(count, 0x20)) + // This implementation is the same as above with different constants + function batchMul(Honk.G1Point[] memory base, Fr[] memory scalars) internal view returns (Honk.G1Point memory result) { + uint256 limit = NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3; - mstore(add(free, 0x40), mload(mload(base_base))) - mstore(add(free, 0x60), mload(add(0x20, mload(base_base)))) - // Add scalar - mstore(add(free, 0x80), mload(scalar_base)) + // Validate all points are on the curve + for (uint256 i = 0; i < limit; ++i) { + validateOnCurve(base[i]); + } + + bool success = true; + assembly { + let free := mload(0x40) - success := and(success, staticcall(gas(), 7, add(free, 0x40), 0x60, add(free, 0x40), 0x40)) - // accumulator = accumulator + accumulator_2 - success := and(success, staticcall(gas(), 6, free, 0x80, free, 0x40)) - } + let count := 0x01 + for {} lt(count, add(limit, 1)) { + count := add(count, 1) + } { + // Get loop offsets + let base_base := add(base, mul(count, 0x20)) + let scalar_base := add(scalars, mul(count, 0x20)) - // Return the result - mstore(result, mload(free)) - mstore(add(result, 0x20), mload(add(free, 0x20))) - } + mstore(add(free, 0x40), mload(mload(base_base))) + mstore(add(free, 0x60), mload(add(0x20, mload(base_base)))) + // Add scalar + mstore(add(free, 0x80), mload(scalar_base)) - require(success, ShpleminiFailed()); + success := and(success, staticcall(gas(), 7, add(free, 0x40), 0x60, add(free, 0x40), 0x40)) + // accumulator = accumulator + accumulator_2 + success := and(success, staticcall(gas(), 6, free, 0x80, free, 0x40)) + } + + // Return the result + mstore(result, mload(free)) + mstore(add(result, 0x20), mload(add(free, 0x20))) } + + require(success, ShpleminiFailed()); + } } contract HonkVerifier is BaseZKHonkVerifier(N, LOG_N, VK_HASH, NUMBER_OF_PUBLIC_INPUTS) { - function loadVerificationKey() internal pure override returns (Honk.VerificationKey memory) { - return HonkVerificationKey.loadVerificationKey(); - } + function loadVerificationKey() internal pure override returns (Honk.VerificationKey memory) { + return HonkVerificationKey.loadVerificationKey(); + } } diff --git a/packages/enclave-contracts/.gitignore b/packages/enclave-contracts/.gitignore index 08d40c50b7..919a65a056 100644 --- a/packages/enclave-contracts/.gitignore +++ b/packages/enclave-contracts/.gitignore @@ -2,21 +2,36 @@ .coverage_artifacts .coverage_cache .coverage_contracts + +# Base Dirs /artifacts/ !/artifacts/ /artifacts/** !/artifacts/contracts/ + +# Interfaces !/artifacts/contracts/interfaces/ -!/artifacts/contracts/registry/ -!/artifacts/contracts/token/ !/artifacts/contracts/interfaces/IEnclave.sol/ !/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ !/artifacts/contracts/interfaces/IBondingRegistry.sol/ -!/artifacts/contracts/token/EnclaveTicketToken.sol/ !/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json !/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json !/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json + +# Registry +!/artifacts/contracts/registry/ + +# Token +!/artifacts/contracts/token/ +!/artifacts/contracts/token/EnclaveTicketToken.sol/ !/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json + +# Verifier contracts +!/artifacts/contracts/verifier/ +!/artifacts/contracts/verifier/DkgPkVerifier.sol/ +!/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json +!/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json + build cache coverage diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json new file mode 100644 index 0000000000..272ae5f3f1 --- /dev/null +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json @@ -0,0 +1,186 @@ +{ + "_format": "hh3-artifact-1", + "contractName": "DkgPkVerifier", + "sourceName": "contracts/verifier/DkgPkVerifier.sol", + "abi": [ + { + "inputs": [], + "name": "ConsistencyCheckFailed", + "type": "error" + }, + { + "inputs": [], + "name": "GeminiChallengeInSubgroup", + "type": "error" + }, + { + "inputs": [], + "name": "ProofLengthWrong", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "logN", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "actualLength", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "expectedLength", + "type": "uint256" + } + ], + "name": "ProofLengthWrongWithLogN", + "type": "error" + }, + { + "inputs": [], + "name": "PublicInputsLengthWrong", + "type": "error" + }, + { + "inputs": [], + "name": "ShpleminiFailed", + "type": "error" + }, + { + "inputs": [], + "name": "SumcheckFailed", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "proof", + "type": "bytes" + }, + { + "internalType": "bytes32[]", + "name": "publicInputs", + "type": "bytes32[]" + } + ], + "name": "verify", + "outputs": [ + { + "internalType": "bool", + "name": "verified", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "bytecode": "0x610100604052348015610010575f5ffd5b50612000608052600d60a0527f170affbea8713b79ad326398ea7b49424c51fa4dca10a65185ad33dbce4d600160c052601160e05260805160a05160c05160e051615cbb6100dc5f395f81816101b0015261090201525f61018e01525f8181605b01528181609401528181610101015281816101d201528181610a3001528181610b3d01528181610bdc01528181610c0a01528181610c9001528181611524015281816115d3015281816116060152818161181001528181612b930152612ebc01525f5050615cbb5ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063ea50d0e41461002d575b5f5ffd5b61004061003b3660046154e5565b610054565b604051901515815260200160405180910390f35b5f5f61007f7f00000000000000000000000000000000000000000000000000000000000000006102ee565b905061008c8160206155bd565b85146100ee577f0000000000000000000000000000000000000000000000000000000000000000856100bf8360206155bd565b6040516359895a5360e01b81526004810193909352602483019190915260448201526064015b60405180910390fd5b5f6100f76103e4565b90505f61012588887f00000000000000000000000000000000000000000000000000000000000000006103f9565b90506010826040015161013891906155d4565b85146101575760405163fa06659360e01b815260040160405180910390fd5b60405163995bf45760e01b81525f9073__$3f925933ac313a1c84f3f4c25b9ea43c90$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", + "deployedBytecode": "0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063ea50d0e41461002d575b5f5ffd5b61004061003b3660046154e5565b610054565b604051901515815260200160405180910390f35b5f5f61007f7f00000000000000000000000000000000000000000000000000000000000000006102ee565b905061008c8160206155bd565b85146100ee577f0000000000000000000000000000000000000000000000000000000000000000856100bf8360206155bd565b6040516359895a5360e01b81526004810193909352602483019190915260448201526064015b60405180910390fd5b5f6100f76103e4565b90505f61012588887f00000000000000000000000000000000000000000000000000000000000000006103f9565b90506010826040015161013891906155d4565b85146101575760405163fa06659360e01b815260040160405180910390fd5b60405163995bf45760e01b81525f9073__$3f925933ac313a1c84f3f4c25b9ea43c90$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", + "linkReferences": { + "project/contracts/verifier/DkgPkVerifier.sol": { + "ZKTranscriptLib": [ + { + "length": 20, + "start": 580 + } + ] + } + }, + "deployedLinkReferences": { + "project/contracts/verifier/DkgPkVerifier.sol": { + "ZKTranscriptLib": [ + { + "length": 20, + "start": 360 + } + ] + } + }, + "immutableReferences": { + "32281": [ + { + "length": 32, + "start": 91 + }, + { + "length": 32, + "start": 148 + }, + { + "length": 32, + "start": 257 + }, + { + "length": 32, + "start": 466 + }, + { + "length": 32, + "start": 2608 + }, + { + "length": 32, + "start": 2877 + }, + { + "length": 32, + "start": 3036 + }, + { + "length": 32, + "start": 3082 + }, + { + "length": 32, + "start": 3216 + }, + { + "length": 32, + "start": 5412 + }, + { + "length": 32, + "start": 5587 + }, + { + "length": 32, + "start": 5638 + }, + { + "length": 32, + "start": 6160 + }, + { + "length": 32, + "start": 11155 + }, + { + "length": 32, + "start": 11964 + } + ], + "32283": [ + { + "length": 32, + "start": 398 + } + ], + "32285": [ + { + "length": 32, + "start": 432 + }, + { + "length": 32, + "start": 2306 + } + ] + }, + "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", + "buildInfoId": "solc-0_8_28-e60a5d7c133605edcf61acdd5ba43ab44ee0928e" +} \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json new file mode 100644 index 0000000000..4bc1877086 --- /dev/null +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json @@ -0,0 +1,400 @@ +{ + "_format": "hh3-artifact-1", + "contractName": "ZKTranscriptLib", + "sourceName": "contracts/verifier/DkgPkVerifier.sol", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "Fr[16]", + "name": "pairingPointObject", + "type": "uint256[16]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "w1", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "w2", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "w3", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "w4", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "lookupReadCounts", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "lookupReadTags", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "lookupInverses", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "zPerm", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point[3]", + "name": "libraCommitments", + "type": "tuple[3]" + }, + { + "internalType": "Fr", + "name": "libraSum", + "type": "uint256" + }, + { + "internalType": "Fr[9][28]", + "name": "sumcheckUnivariates", + "type": "uint256[9][28]" + }, + { + "internalType": "Fr[41]", + "name": "sumcheckEvaluations", + "type": "uint256[41]" + }, + { + "internalType": "Fr", + "name": "libraEvaluation", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "geminiMaskingPoly", + "type": "tuple" + }, + { + "internalType": "Fr", + "name": "geminiMaskingEval", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point[27]", + "name": "geminiFoldComms", + "type": "tuple[27]" + }, + { + "internalType": "Fr[28]", + "name": "geminiAEvaluations", + "type": "uint256[28]" + }, + { + "internalType": "Fr[4]", + "name": "libraPolyEvals", + "type": "uint256[4]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "shplonkQ", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "x", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "y", + "type": "uint256" + } + ], + "internalType": "struct Honk.G1Point", + "name": "kzgQuotient", + "type": "tuple" + } + ], + "internalType": "struct Honk.ZKProof", + "name": "proof", + "type": "tuple" + }, + { + "internalType": "bytes32[]", + "name": "publicInputs", + "type": "bytes32[]" + }, + { + "internalType": "uint256", + "name": "vkHash", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "publicInputsSize", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "logN", + "type": "uint256" + } + ], + "name": "generateTranscript", + "outputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "Fr", + "name": "eta", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "etaTwo", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "etaThree", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "beta", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "gamma", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "publicInputsDelta", + "type": "uint256" + } + ], + "internalType": "struct Honk.RelationParameters", + "name": "relationParameters", + "type": "tuple" + }, + { + "internalType": "Fr[27]", + "name": "alphas", + "type": "uint256[27]" + }, + { + "internalType": "Fr[28]", + "name": "gateChallenges", + "type": "uint256[28]" + }, + { + "internalType": "Fr", + "name": "libraChallenge", + "type": "uint256" + }, + { + "internalType": "Fr[28]", + "name": "sumCheckUChallenges", + "type": "uint256[28]" + }, + { + "internalType": "Fr", + "name": "rho", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "geminiR", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "shplonkNu", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "shplonkZ", + "type": "uint256" + }, + { + "internalType": "Fr", + "name": "publicInputsDelta", + "type": "uint256" + } + ], + "internalType": "struct ZKTranscript", + "name": "t", + "type": "tuple" + } + ], + "stateMutability": "pure", + "type": "function" + } + ], + "bytecode": "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", + "deployedBytecode": "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", + "linkReferences": {}, + "deployedLinkReferences": {}, + "immutableReferences": {}, + "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", + "buildInfoId": "solc-0_8_28-e60a5d7c133605edcf61acdd5ba43ab44ee0928e" +} \ No newline at end of file diff --git a/scripts/build-circuits.ts b/scripts/build-circuits.ts index 41f64a3150..d81f825957 100644 --- a/scripts/build-circuits.ts +++ b/scripts/build-circuits.ts @@ -27,6 +27,7 @@ interface BuildOptions { circuits?: string[] skipChecksums?: boolean skipVk?: boolean + oracleHash?: string outputDir?: string clean?: boolean dryRun?: boolean @@ -53,6 +54,7 @@ class NoirCircuitBuilder { outputDir: join(this.rootDir, 'dist', 'circuits'), clean: true, skipVk: false, + oracleHash: 'keccak', ...options, } } @@ -190,7 +192,8 @@ class NoirCircuitBuilder { private generateVk(jsonFile: string, targetDir: string, packageName: string): string | null { const vkFile = join(targetDir, `${packageName}.vk`) try { - execSync(`bb write_vk -b "${jsonFile}" -o "${targetDir}"`, { stdio: 'pipe' }) + const oracleFlag = this.options.oracleHash ? ` --oracle_hash ${this.options.oracleHash}` : '' + execSync(`bb write_vk -b "${jsonFile}" -o "${targetDir}"${oracleFlag}`, { stdio: 'pipe' }) const defaultVk = join(targetDir, 'vk') if (existsSync(defaultVk)) { if (existsSync(vkFile)) rmSync(vkFile) @@ -322,6 +325,7 @@ async function main() { else if (arg === '--skip-checksums') options.skipChecksums = true else if (arg === '--skip-vk') options.skipVk = true else if (arg === '--no-clean') options.clean = false + else if (arg === '--oracle-hash') options.oracleHash = args[++i] else if (arg === '--group') options.groups = args[++i]?.split(',') as CircuitGroup[] else if (arg === '--circuit') (options.circuits ??= []).push(args[++i]) else if (arg === '-o' || arg === '--output') options.outputDir = resolve(args[++i]) @@ -352,6 +356,7 @@ Options: --circuit Build specific circuit(s) --skip-vk Skip verification key generation --skip-checksums Skip checksum generation + --oracle-hash Oracle hash for VK generation (default: keccak) -o, --output Output directory (default: dist/circuits) --dry-run Show what would be built --no-clean Don't clean output directory From 31a6dce5d35cc6f04131a92d850a679fe7d20da8 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 14 Feb 2026 04:50:48 +0500 Subject: [PATCH 02/32] chore: remove conflict --- scripts/build-circuits.ts | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/scripts/build-circuits.ts b/scripts/build-circuits.ts index d81f825957..176a2d28ad 100644 --- a/scripts/build-circuits.ts +++ b/scripts/build-circuits.ts @@ -27,7 +27,6 @@ interface BuildOptions { circuits?: string[] skipChecksums?: boolean skipVk?: boolean - oracleHash?: string outputDir?: string clean?: boolean dryRun?: boolean @@ -54,7 +53,6 @@ class NoirCircuitBuilder { outputDir: join(this.rootDir, 'dist', 'circuits'), clean: true, skipVk: false, - oracleHash: 'keccak', ...options, } } @@ -192,8 +190,7 @@ class NoirCircuitBuilder { private generateVk(jsonFile: string, targetDir: string, packageName: string): string | null { const vkFile = join(targetDir, `${packageName}.vk`) try { - const oracleFlag = this.options.oracleHash ? ` --oracle_hash ${this.options.oracleHash}` : '' - execSync(`bb write_vk -b "${jsonFile}" -o "${targetDir}"${oracleFlag}`, { stdio: 'pipe' }) + execSync(`bb write_vk -b "${jsonFile}" -o "${targetDir}" --oracle_hash keccak`, { stdio: 'pipe' }) const defaultVk = join(targetDir, 'vk') if (existsSync(defaultVk)) { if (existsSync(vkFile)) rmSync(vkFile) @@ -325,7 +322,6 @@ async function main() { else if (arg === '--skip-checksums') options.skipChecksums = true else if (arg === '--skip-vk') options.skipVk = true else if (arg === '--no-clean') options.clean = false - else if (arg === '--oracle-hash') options.oracleHash = args[++i] else if (arg === '--group') options.groups = args[++i]?.split(',') as CircuitGroup[] else if (arg === '--circuit') (options.circuits ??= []).push(args[++i]) else if (arg === '-o' || arg === '--output') options.outputDir = resolve(args[++i]) @@ -356,7 +352,6 @@ Options: --circuit Build specific circuit(s) --skip-vk Skip verification key generation --skip-checksums Skip checksum generation - --oracle-hash Oracle hash for VK generation (default: keccak) -o, --output Output directory (default: dist/circuits) --dry-run Show what would be built --no-clean Don't clean output directory From 6571109e197916002b180d9d9f96adf9ef416409 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 14 Feb 2026 04:54:58 +0500 Subject: [PATCH 03/32] chore: remove conflict --- scripts/build-circuits.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/build-circuits.ts b/scripts/build-circuits.ts index 176a2d28ad..41f64a3150 100644 --- a/scripts/build-circuits.ts +++ b/scripts/build-circuits.ts @@ -190,7 +190,7 @@ class NoirCircuitBuilder { private generateVk(jsonFile: string, targetDir: string, packageName: string): string | null { const vkFile = join(targetDir, `${packageName}.vk`) try { - execSync(`bb write_vk -b "${jsonFile}" -o "${targetDir}" --oracle_hash keccak`, { stdio: 'pipe' }) + execSync(`bb write_vk -b "${jsonFile}" -o "${targetDir}"`, { stdio: 'pipe' }) const defaultVk = join(targetDir, 'vk') if (existsSync(defaultVk)) { if (existsSync(vkFile)) rmSync(vkFile) From 4f907a896fd870777aa8abcd97554c11c2330899 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 14 Feb 2026 11:53:41 +0500 Subject: [PATCH 04/32] feat: add circuit verifier and rewrite slashing manager --- .../IBondingRegistry.json | 2 +- .../ICiphernodeRegistry.json | 179 +++++++++++- .../interfaces/IEnclave.sol/IEnclave.json | 2 +- .../enclave-contracts/contracts/Enclave.sol | 69 +++-- .../interfaces/ICiphernodeRegistry.sol | 71 +++++ .../contracts/interfaces/ICircuitVerifier.sol | 23 ++ .../contracts/interfaces/ISlashVerifier.sol | 23 -- .../contracts/interfaces/ISlashingManager.sol | 105 +++---- .../registry/CiphernodeRegistryOwnable.sol | 113 ++++++++ .../contracts/slashing/SlashingManager.sol | 274 ++++++++++++------ .../contracts/test/MockCiphernodeRegistry.sol | 64 ++++ .../contracts/test/MockSlashingVerifier.sol | 23 +- .../ignition/modules/slashingManager.ts | 4 + .../scripts/deployAndSave/slashingManager.ts | 15 +- .../test/E3Lifecycle/E3Integration.spec.ts | 9 + 15 files changed, 778 insertions(+), 198 deletions(-) create mode 100644 packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol delete mode 100644 packages/enclave-contracts/contracts/interfaces/ISlashVerifier.sol diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json index bfcb8a4f4c..8b274a77bd 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json @@ -890,5 +890,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IBondingRegistry.sol", - "buildInfoId": "solc-0_8_28-d7b7e823e5eb177cd42a96206dc5c5f8387609a9" + "buildInfoId": "solc-0_8_28-9c1ebc56a4c13150b3adbadeabc6f1b966156894" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json index a953710b9f..c25e0a55f8 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json @@ -128,6 +128,37 @@ "name": "CommitteeFormationFailed", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "node", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "activeCountAfter", + "type": "uint256" + } + ], + "name": "CommitteeMemberExpelled", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -190,6 +221,37 @@ "name": "CommitteeRequested", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "activeCount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "thresholdM", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "viable", + "type": "bool" + } + ], + "name": "CommitteeViabilityUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -279,6 +341,40 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "node", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + } + ], + "name": "expelCommitteeMember", + "outputs": [ + { + "internalType": "uint256", + "name": "activeCount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "thresholdM", + "type": "uint32" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -298,6 +394,44 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + } + ], + "name": "getActiveCommitteeCount", + "outputs": [ + { + "internalType": "uint256", + "name": "count", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + } + ], + "name": "getActiveCommitteeNodes", + "outputs": [ + { + "internalType": "address[]", + "name": "nodes", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [], "name": "getBondingRegistry", @@ -349,6 +483,25 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + } + ], + "name": "getCommitteeThreshold", + "outputs": [ + { + "internalType": "uint32[2]", + "name": "threshold", + "type": "uint32[2]" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -368,6 +521,30 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "node", + "type": "address" + } + ], + "name": "isCommitteeMemberActive", + "outputs": [ + { + "internalType": "bool", + "name": "active", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -590,5 +767,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ICiphernodeRegistry.sol", - "buildInfoId": "solc-0_8_28-d7b7e823e5eb177cd42a96206dc5c5f8387609a9" + "buildInfoId": "solc-0_8_28-9c1ebc56a4c13150b3adbadeabc6f1b966156894" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json index 4578c7e43d..0c10882495 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json @@ -1202,5 +1202,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IEnclave.sol", - "buildInfoId": "solc-0_8_28-d7b7e823e5eb177cd42a96206dc5c5f8387609a9" + "buildInfoId": "solc-0_8_28-9c1ebc56a4c13150b3adbadeabc6f1b966156894" } \ No newline at end of file diff --git a/packages/enclave-contracts/contracts/Enclave.sol b/packages/enclave-contracts/contracts/Enclave.sol index 16206aaf22..4567276a6e 100644 --- a/packages/enclave-contracts/contracts/Enclave.sol +++ b/packages/enclave-contracts/contracts/Enclave.sol @@ -8,6 +8,7 @@ pragma solidity >=0.8.27; import { IEnclave, E3, IE3Program } from "./interfaces/IEnclave.sol"; import { ICiphernodeRegistry } from "./interfaces/ICiphernodeRegistry.sol"; import { IBondingRegistry } from "./interfaces/IBondingRegistry.sol"; +import { ISlashingManager } from "./interfaces/ISlashingManager.sol"; import { IE3RefundManager } from "./interfaces/IE3RefundManager.sol"; import { IDecryptionVerifier } from "./interfaces/IDecryptionVerifier.sol"; import { @@ -44,6 +45,10 @@ contract Enclave is IEnclave, OwnableUpgradeable { /// @dev Manages refund calculation and claiming for failed E3s. IE3RefundManager public e3RefundManager; + /// @notice Slashing Manager contract for fault attribution. + /// @dev Used to check which operators have been slashed for E3s. + ISlashingManager public slashingManager; + /// @notice Address of the ERC20 token used for E3 fees. /// @dev All E3 request fees must be paid in this token. IERC20 public feeToken; @@ -206,6 +211,16 @@ contract Enclave is IEnclave, OwnableUpgradeable { _; } + /// @notice Restricts function to CiphernodeRegistry or SlashingManager + modifier onlyCiphernodeRegistryOrSlashingManager() { + require( + msg.sender == address(ciphernodeRegistry) || + msg.sender == address(slashingManager), + "Only CiphernodeRegistry or SlashingManager" + ); + _; + } + //////////////////////////////////////////////////////////// // // // Initialization // @@ -454,21 +469,22 @@ contract Enclave is IEnclave, OwnableUpgradeable { // // //////////////////////////////////////////////////////////// - /// @notice Distributes rewards to committee members after successful E3 completion. - /// @dev Divides the E3 payment equally among all committee members and transfers via bonding registry. - /// @dev Emits RewardsDistributed event upon successful distribution. + /// @notice Distributes rewards to active committee members after successful E3 completion. + /// @dev Uses active committee nodes (excluding expelled members). + /// Divides the E3 payment equally among active members and transfers via bonding registry. /// @param e3Id The ID of the E3 for which to distribute rewards. function _distributeRewards(uint256 e3Id) internal { - address[] memory committeeNodes = ciphernodeRegistry.getCommitteeNodes( - e3Id - ); - uint256 committeeLength = committeeNodes.length; - uint256[] memory amounts = new uint256[](committeeLength); + address[] memory activeNodes = ciphernodeRegistry + .getActiveCommitteeNodes(e3Id); + uint256 activeLength = activeNodes.length; - // TODO: do we need to pay different amounts to different nodes? - // For now, we'll pay the same amount to all nodes. - uint256 amount = e3Payments[e3Id] / committeeLength; - for (uint256 i = 0; i < committeeLength; i++) { + if (activeLength == 0) return; + + uint256[] memory amounts = new uint256[](activeLength); + + // Distribute equally among active (non-expelled) committee members + uint256 amount = e3Payments[e3Id] / activeLength; + for (uint256 i = 0; i < activeLength; i++) { amounts[i] = amount; } @@ -477,16 +493,16 @@ contract Enclave is IEnclave, OwnableUpgradeable { feeToken.approve(address(bondingRegistry), totalAmount); - bondingRegistry.distributeRewards(feeToken, committeeNodes, amounts); + bondingRegistry.distributeRewards(feeToken, activeNodes, amounts); - // TODO: decide where does dust go? Treasury maybe? + // Dust goes to treasury (implicit via remaining approval) feeToken.approve(address(bondingRegistry), 0); - emit RewardsDistributed(e3Id, committeeNodes, amounts); + emit RewardsDistributed(e3Id, activeNodes, amounts); } /// @notice Retrieves the honest committee nodes for a given E3. - /// @dev Determines honest nodes based on failure reason and committee publication status. + /// @dev Uses active committee view from the registry (which excludes expelled/slashed members). /// @param e3Id The ID of the E3. /// @return honestNodes An array of addresses of honest committee nodes. function _getHonestNodes( @@ -502,12 +518,11 @@ contract Enclave is IEnclave, OwnableUpgradeable { return new address[](0); } - // Try to get published committee nodes - try ciphernodeRegistry.getCommitteeNodes(e3Id) returns ( + // Use active committee nodes (already filtered by expulsion) + try ciphernodeRegistry.getActiveCommitteeNodes(e3Id) returns ( address[] memory nodes ) { - // TODO: Implement fault attribution to filter honest from faulting nodes - return nodes; // Assume all are honest for now + return nodes; } catch { return new address[](0); // Committee not published (DKG failed) } @@ -634,6 +649,18 @@ contract Enclave is IEnclave, OwnableUpgradeable { emit E3RefundManagerSet(address(_e3RefundManager)); } + /// @notice Sets the Slashing Manager contract address + /// @param _slashingManager The new Slashing Manager contract address + function setSlashingManager( + ISlashingManager _slashingManager + ) public onlyOwner { + require( + address(_slashingManager) != address(0), + "Invalid SlashingManager address" + ); + slashingManager = _slashingManager; + } + /// @notice Process a failed E3 and calculate refunds /// @dev Can be called by anyone once E3 is in failed state /// @param e3Id The ID of the failed E3 @@ -701,7 +728,7 @@ contract Enclave is IEnclave, OwnableUpgradeable { function onE3Failed( uint256 e3Id, uint8 reason - ) external onlyCiphernodeRegistry { + ) external onlyCiphernodeRegistryOrSlashingManager { require(reason > 0 && reason <= 12, "Invalid failure reason"); // Mark E3 as failed with the given reason _markE3FailedWithReason(e3Id, FailureReason(reason)); diff --git a/packages/enclave-contracts/contracts/interfaces/ICiphernodeRegistry.sol b/packages/enclave-contracts/contracts/interfaces/ICiphernodeRegistry.sol index 4cfa7b1c8f..69b12a8752 100644 --- a/packages/enclave-contracts/contracts/interfaces/ICiphernodeRegistry.sol +++ b/packages/enclave-contracts/contracts/interfaces/ICiphernodeRegistry.sol @@ -41,6 +41,8 @@ interface ICiphernodeRegistry { address[] committee; mapping(address node => bool submitted) submitted; mapping(address node => uint256 score) scoreOf; + mapping(address node => bool active) active; + uint256 activeCount; } /// @notice This event MUST be emitted when a committee is selected for an E3. @@ -98,6 +100,30 @@ interface ICiphernodeRegistry { /// @param active True if committee is now active, false if completed. event CommitteeActivationChanged(uint256 indexed e3Id, bool active); + /// @notice This event MUST be emitted when a committee member is expelled due to slashing. + /// @param e3Id ID of the E3 for which the member was expelled. + /// @param node Address of the expelled committee member. + /// @param reason Hash of the slash reason that caused the expulsion. + /// @param activeCountAfter Number of active committee members remaining after expulsion. + event CommitteeMemberExpelled( + uint256 indexed e3Id, + address indexed node, + bytes32 reason, + uint256 activeCountAfter + ); + + /// @notice This event MUST be emitted when committee viability changes after an expulsion. + /// @param e3Id ID of the E3. + /// @param activeCount Current number of active committee members. + /// @param thresholdM The minimum threshold (M) required. + /// @param viable Whether the committee is still viable (activeCount >= M). + event CommitteeViabilityUpdated( + uint256 indexed e3Id, + uint256 activeCount, + uint256 thresholdM, + bool viable + ); + /// @notice This event MUST be emitted when `enclave` is set. /// @param enclave Address of the enclave contract. event EnclaveSet(address indexed enclave); @@ -249,4 +275,49 @@ interface ICiphernodeRegistry { /// @param e3Id ID of the E3 computation /// @return committeeDeadline The committee deadline timestamp function getCommitteeDeadline(uint256 e3Id) external view returns (uint256); + + /// @notice Expel a committee member from a specific E3 committee due to slashing + /// @dev Only callable by SlashingManager. Idempotent (re-expelling same member is no-op). + /// Returns viability data so the caller can decide whether to fail the E3 — + /// eliminating the need for separate getActiveCommitteeCount/getCommitteeThreshold calls. + /// @param e3Id ID of the E3 computation + /// @param node Address of the committee member to expel + /// @param reason Hash of the slash reason + /// @return activeCount Number of active committee members after expulsion + /// @return thresholdM The minimum threshold (M) required for viability + function expelCommitteeMember( + uint256 e3Id, + address node, + bytes32 reason + ) external returns (uint256 activeCount, uint32 thresholdM); + + /// @notice Check if a committee member is still active for a specific E3 + /// @param e3Id ID of the E3 computation + /// @param node Address of the committee member to check + /// @return active Whether the member is still active in the committee + function isCommitteeMemberActive( + uint256 e3Id, + address node + ) external view returns (bool active); + + /// @notice Get active (non-expelled) committee nodes for an E3 + /// @param e3Id ID of the E3 computation + /// @return nodes Array of active committee member addresses + function getActiveCommitteeNodes( + uint256 e3Id + ) external view returns (address[] memory nodes); + + /// @notice Get the count of active committee members for an E3 + /// @param e3Id ID of the E3 computation + /// @return count Number of active committee members + function getActiveCommitteeCount( + uint256 e3Id + ) external view returns (uint256 count); + + /// @notice Get the threshold configuration for an E3 committee + /// @param e3Id ID of the E3 computation + /// @return threshold The [M, N] threshold array + function getCommitteeThreshold( + uint256 e3Id + ) external view returns (uint32[2] memory threshold); } diff --git a/packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol b/packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol new file mode 100644 index 0000000000..ae43283b90 --- /dev/null +++ b/packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. +pragma solidity >=0.8.27; + +/** + * @title ICircuitVerifier + * @notice Interface for on-chain ZK circuit verifiers (e.g., DkgPkVerifier, Honk verifiers) + * @dev Standard interface matching the verification pattern used by Honk-generated verifiers. + * Set the circuit verifier address directly as the proofVerifier in a SlashPolicy. + */ +interface ICircuitVerifier { + /// @notice Verify a ZK proof against public inputs + /// @param _proof The raw proof bytes + /// @param _publicInputs The public inputs to verify against + /// @return True if the proof is valid + function verify( + bytes calldata _proof, + bytes32[] calldata _publicInputs + ) external returns (bool); +} diff --git a/packages/enclave-contracts/contracts/interfaces/ISlashVerifier.sol b/packages/enclave-contracts/contracts/interfaces/ISlashVerifier.sol deleted file mode 100644 index a2ac4b860f..0000000000 --- a/packages/enclave-contracts/contracts/interfaces/ISlashVerifier.sol +++ /dev/null @@ -1,23 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. -pragma solidity >=0.8.27; - -/** - * @title ISlashVerifier - * @notice Interface for verifying slash proofs - * @dev Slash verifiers implement cryptographic or logical verification of slash proposals - */ -interface ISlashVerifier { - /// @notice Verify a slash proof - /// @dev This function is called by the SlashingManager contract during slash proposal to verify proof validity - /// @param proposalId ID of the slash proposal - /// @param proof ABI encoded proof data supporting the slash - /// @return success Whether the proof was successfully verified - function verify( - uint256 proposalId, - bytes memory proof - ) external view returns (bool success); -} diff --git a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol index d5711fc77b..a8ddf370fe 100644 --- a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol +++ b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol @@ -11,7 +11,9 @@ import { IBondingRegistry } from "./IBondingRegistry.sol"; /** * @title ISlashingManager * @notice Interface for managing slashing proposals, appeals, and execution - * @dev Maintains policy table and handles slash workflows with appeals + * @dev Maintains policy table and handles slash workflows with two lanes: + * Lane A (proof-based): permissionless, atomic, no appeals + * Lane B (evidence-based): SLASHER_ROLE required, appeal window */ interface ISlashingManager { // ====================== @@ -28,6 +30,8 @@ interface ISlashingManager { * @param banNode Whether executing this slash will permanently ban the node * @param appealWindow Time window in seconds for operators to appeal (0 = immediate execution, no appeals) * @param enabled Whether this slash type is currently active and can be proposed + * @param affectsCommittee Whether executing this slash triggers committee expulsion for the target E3 + * @param failureReason The FailureReason enum value to use when committee drops below threshold (0 = no E3 failure) */ struct SlashPolicy { uint256 ticketPenalty; @@ -37,11 +41,14 @@ interface ISlashingManager { bool banNode; uint256 appealWindow; bool enabled; + bool affectsCommittee; + uint8 failureReason; } /** * @notice Slash proposal details tracking the full lifecycle of a slash * @dev Stores all state needed for proposal, appeal, and execution workflows + * @param e3Id ID of the E3 computation this slash relates to (0 for non-E3 slashes) * @param operator Address of the ciphernode operator being slashed * @param reason Hash of the slash reason (maps to SlashPolicy configuration) * @param ticketAmount Amount of ticket collateral to slash (copied from policy at proposal time) @@ -57,6 +64,7 @@ interface ISlashingManager { * @param proofVerified Whether the proof was successfully verified by the proof verifier contract */ struct SlashProposal { + uint256 e3Id; address operator; bytes32 reason; uint256 ticketAmount; @@ -127,6 +135,9 @@ interface ISlashingManager { /// @notice Thrown when a policy requires proof but no verifier contract is configured error VerifierNotSet(); + /// @notice Thrown when the same evidence bundle has already been used in a proposal + error DuplicateEvidence(); + // ====================== // Events // ====================== @@ -141,6 +152,7 @@ interface ISlashingManager { /** * @notice Emitted when a new slash proposal is created * @param proposalId Unique ID of the created proposal + * @param e3Id ID of the E3 computation related to this slash * @param operator Address of the ciphernode operator being slashed * @param reason Hash of the slash reason * @param ticketAmount Amount of ticket collateral to be slashed @@ -150,8 +162,9 @@ interface ISlashingManager { */ event SlashProposed( uint256 indexed proposalId, + uint256 indexed e3Id, address indexed operator, - bytes32 indexed reason, + bytes32 reason, uint256 ticketAmount, uint256 licenseAmount, uint256 executableAt, @@ -295,7 +308,7 @@ interface ISlashingManager { /** * @notice Grants SLASHER_ROLE to an address - * @dev Only callable by DEFAULT_ADMIN_ROLE. Slashers can propose and execute slashes + * @dev Only callable by DEFAULT_ADMIN_ROLE. Slashers can propose and execute evidence-based slashes * @param slasher Address to grant slashing permissions (must be non-zero) */ function addSlasher(address slasher) external; @@ -307,58 +320,48 @@ interface ISlashingManager { */ function removeSlasher(address slasher) external; - /** - * @notice Grants VERIFIER_ROLE to an address - * @dev Only callable by DEFAULT_ADMIN_ROLE. Verifiers can validate proof-based slashes - * @param verifier Address to grant verification permissions (must be non-zero) - */ - function addVerifier(address verifier) external; - - /** - * @notice Revokes VERIFIER_ROLE from an address - * @dev Only callable by DEFAULT_ADMIN_ROLE - * @param verifier Address to revoke verification permissions from - */ - function removeVerifier(address verifier) external; - // ====================== // Slashing Functions // ====================== /** - * @notice Creates a new slash proposal against an operator - * @dev Only callable by SLASHER_ROLE. Validates policy and proof if required + * @notice Creates a new slash proposal with cryptographic proof (Lane A - permissionless) + * @dev Anyone can call this for proof-based slashes. Proof is verified on-chain. + * For proof-based policies (appealWindow=0), slash is executed atomically. + * @param e3Id ID of the E3 computation this slash relates to * @param operator Address of the ciphernode operator to slash (must be non-zero) - * @param reason Hash of the slash reason (must have an enabled policy configured) - * @param proof Proof data to be verified (required if policy.requiresProof is true, can be empty otherwise) + * @param reason Hash of the slash reason (must have an enabled proof-required policy) + * @param proof Proof data to be verified by the policy's proof verifier contract * @return proposalId Sequential ID of the created proposal - * Requirements: - * - operator must not be zero address - * - reason must have an enabled policy configured - * - If policy requires proof, proof must be non-empty and pass verification - * - Caller must have SLASHER_ROLE */ function proposeSlash( + uint256 e3Id, address operator, bytes32 reason, bytes calldata proof ) external returns (uint256 proposalId); + /** + * @notice Creates a new slash proposal with evidence (Lane B - SLASHER_ROLE required) + * @dev Only callable by SLASHER_ROLE. Evidence-based slashes have appeal windows. + * @param e3Id ID of the E3 computation this slash relates to + * @param operator Address of the ciphernode operator to slash (must be non-zero) + * @param reason Hash of the slash reason (must have an enabled non-proof policy) + * @param evidence Evidence data supporting the slash proposal + * @return proposalId Sequential ID of the created proposal + */ + function proposeSlashEvidence( + uint256 e3Id, + address operator, + bytes32 reason, + bytes calldata evidence + ) external returns (uint256 proposalId); + /** * @notice Executes a slash proposal and applies penalties to the operator - * @dev Only callable by SLASHER_ROLE. Validates execution conditions and applies slashing + * @dev For evidence-based slashes, validates appeal window has expired. + * Proof-based slashes are executed atomically in proposeSlash. * @param proposalId ID of the proposal to execute (must exist and not be already executed) - * Requirements: - * - Proposal must exist and not be already executed - * - For proof-required slashes: proof must be verified - * - For evidence-based slashes: appeal window must have expired - * - If appeal was filed and resolved, appeal must not have been upheld - * - Caller must have SLASHER_ROLE - * Effects: - * - Marks proposal as executed - * - Slashes ticket balance if ticketAmount > 0 - * - Slashes license bond if licenseAmount > 0 - * - Bans node if policy.banNode is true */ function executeSlash(uint256 proposalId) external; @@ -367,32 +370,19 @@ interface ISlashingManager { // ====================== /** - * @notice Allows an operator to file an appeal against a slash proposal + * @notice Allows an operator to file an appeal against an evidence-based slash proposal * @dev Only the operator being slashed can file an appeal, and only within the appeal window * @param proposalId ID of the proposal to appeal (must exist) * @param evidence String containing evidence and arguments supporting the appeal - * Requirements: - * - Proposal must exist - * - Caller must be the operator being slashed - * - Current timestamp must be before proposal.executableAt (within appeal window) - * - Proposal must not already have an appeal filed */ function fileAppeal(uint256 proposalId, string calldata evidence) external; /** * @notice Resolves an appeal by accepting or rejecting it * @dev Only callable by GOVERNANCE_ROLE. If appeal is upheld, the slash cannot be executed - * @param proposalId ID of the proposal with the appeal to resolve (must exist and have an appeal) - * @param appealUpheld True to uphold the appeal (cancel the slash), false to deny the appeal - * (allow slash to proceed) + * @param proposalId ID of the proposal with the appeal to resolve + * @param appealUpheld True to uphold the appeal (cancel the slash), false to deny * @param resolution String explaining the governance decision - * Requirements: - * - Proposal must exist and have an appeal filed - * - Appeal must not already be resolved - * - Caller must have GOVERNANCE_ROLE - * Effects: - * - Marks appeal as resolved - * - Sets appealUpheld flag (true = slash cancelled, false = slash can proceed) */ function resolveAppeal( uint256 proposalId, @@ -410,13 +400,6 @@ interface ISlashingManager { * @param node Address of the node to ban (must be non-zero) * @param status Whether to ban the node * @param reason Hash of the reason for banning - * Requirements: - * - node must not be zero address - * - Caller must have GOVERNANCE_ROLE - * Effects: - * - Sets banned[node] to status - * - Emits NodeBanned event if status is true - * - Emits NodeUnbanned event if status is false */ function updateBanStatus( address node, diff --git a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol index 298ab77f9e..c48ccf187f 100644 --- a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol +++ b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol @@ -8,6 +8,7 @@ pragma solidity >=0.8.27; import { ICiphernodeRegistry } from "../interfaces/ICiphernodeRegistry.sol"; import { IBondingRegistry } from "../interfaces/IBondingRegistry.sol"; import { IEnclave } from "../interfaces/IEnclave.sol"; +import { ISlashingManager } from "../interfaces/ISlashingManager.sol"; import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; @@ -66,6 +67,9 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { /// @notice Maps E3 ID to its committee data mapping(uint256 e3Id => Committee committee) internal committees; + /// @notice Address of the slashing manager authorized to expel committee members + ISlashingManager public slashingManager; + //////////////////////////////////////////////////////////// // // // Errors // @@ -143,6 +147,9 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { /// @notice Caller is not authorized error Unauthorized(); + /// @notice Caller is not the slashing manager + error NotSlashingManager(); + /// @notice Not enough registered ciphernodes to meet threshold /// @param requested The requested committee size (N) /// @param available The number of registered ciphernodes @@ -175,6 +182,12 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { _; } + /// @dev Restricts function access to only the slashing manager + modifier onlySlashingManager() { + require(msg.sender == address(slashingManager), NotSlashingManager()); + _; + } + //////////////////////////////////////////////////////////// // // // Initialization // @@ -375,6 +388,16 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { } c.committee = c.topNodes; + // Initialize active committee tracking in Committee struct + uint256 committeeLen = c.committee.length; + for (uint256 i = 0; i < committeeLen; ) { + c.active[c.committee[i]] = true; + unchecked { + ++i; + } + } + c.activeCount = committeeLen; + enclave.onCommitteeFinalized(e3Id); emit CommitteeFinalized(e3Id, c.topNodes); return true; @@ -406,6 +429,16 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { emit BondingRegistrySet(address(_bondingRegistry)); } + /// @notice Sets the slashing manager contract address + /// @dev Only callable by owner + /// @param _slashingManager Address of the slashing manager contract + function setSlashingManager( + ISlashingManager _slashingManager + ) public onlyOwner { + require(address(_slashingManager) != address(0), ZeroAddress()); + slashingManager = _slashingManager; + } + /// @inheritdoc ICiphernodeRegistry function setSortitionSubmissionWindow( uint256 _sortitionSubmissionWindow @@ -496,6 +529,86 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { return c.committeeDeadline; } + //////////////////////////////////////////////////////////// + // // + // Committee Expulsion Functions // + // // + //////////////////////////////////////////////////////////// + + /// @inheritdoc ICiphernodeRegistry + function expelCommitteeMember( + uint256 e3Id, + address node, + bytes32 reason + ) + external + onlySlashingManager + returns (uint256 activeCount, uint32 thresholdM) + { + Committee storage c = committees[e3Id]; + thresholdM = c.threshold[0]; + + // Idempotent: if already expelled, return current state + if (!c.active[node]) { + activeCount = c.activeCount; + return (activeCount, thresholdM); + } + + c.active[node] = false; + c.activeCount--; + + activeCount = c.activeCount; + emit CommitteeMemberExpelled(e3Id, node, reason, activeCount); + + // Emit viability update + bool viable = activeCount >= thresholdM; + emit CommitteeViabilityUpdated(e3Id, activeCount, thresholdM, viable); + } + + /// @inheritdoc ICiphernodeRegistry + function isCommitteeMemberActive( + uint256 e3Id, + address node + ) external view returns (bool) { + return committees[e3Id].active[node]; + } + + /// @inheritdoc ICiphernodeRegistry + function getActiveCommitteeNodes( + uint256 e3Id + ) external view returns (address[] memory) { + Committee storage c = committees[e3Id]; + uint256 total = c.committee.length; + uint256 actCount = c.activeCount; + + address[] memory activeNodes = new address[](actCount); + uint256 idx = 0; + for (uint256 i = 0; i < total; ) { + if (c.active[c.committee[i]]) { + activeNodes[idx] = c.committee[i]; + idx++; + } + unchecked { + ++i; + } + } + return activeNodes; + } + + /// @inheritdoc ICiphernodeRegistry + function getActiveCommitteeCount( + uint256 e3Id + ) external view returns (uint256) { + return committees[e3Id].activeCount; + } + + /// @inheritdoc ICiphernodeRegistry + function getCommitteeThreshold( + uint256 e3Id + ) external view returns (uint32[2] memory) { + return committees[e3Id].threshold; + } + //////////////////////////////////////////////////////////// // // // Internal Functions // diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index 7001ef127d..11f17a89fb 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -11,24 +11,26 @@ import { } from "@openzeppelin/contracts/access/AccessControl.sol"; import { ISlashingManager } from "../interfaces/ISlashingManager.sol"; import { IBondingRegistry } from "../interfaces/IBondingRegistry.sol"; -import { ISlashVerifier } from "../interfaces/ISlashVerifier.sol"; +import { ICiphernodeRegistry } from "../interfaces/ICiphernodeRegistry.sol"; +import { IEnclave } from "../interfaces/IEnclave.sol"; +import { ICircuitVerifier } from "../interfaces/ICircuitVerifier.sol"; /** * @title SlashingManager - * @notice Implementation of slashing management with proposal, appeal, and execution workflows - * @dev Role-based access control for slashers, verifiers, and governance with configurable slash policies + * @notice Implementation of slashing management with two-lane architecture: + * Lane A (proof-based): permissionless, atomic propose+execute, no appeals + * Lane B (evidence-based): SLASHER_ROLE required, appeal window, separate execute + * @dev Role-based access control for slashers and governance with configurable slash policies. + * Integrates with CiphernodeRegistry for committee expulsion and Enclave for E3 failure. */ contract SlashingManager is ISlashingManager, AccessControl { // ====================== // Constants & Roles // ====================== - /// @notice Role identifier for accounts authorized to propose and execute slashes + /// @notice Role identifier for accounts authorized to propose evidence-based slashes bytes32 public constant SLASHER_ROLE = keccak256("SLASHER_ROLE"); - /// @notice Role identifier for accounts authorized to verify cryptographic proofs in slash proposals - bytes32 public constant VERIFIER_ROLE = keccak256("VERIFIER_ROLE"); - /// @notice Role identifier for governance accounts that can configure policies, resolve appeals, and manage bans bytes32 public constant GOVERNANCE_ROLE = keccak256("GOVERNANCE_ROLE"); @@ -37,45 +39,47 @@ contract SlashingManager is ISlashingManager, AccessControl { // ====================== /// @notice Reference to the bonding registry contract where slash penalties are executed - /// @dev Used to call slashTicketBalance() and slashLicenseBond() when executing slashes IBondingRegistry public bondingRegistry; + /// @notice Reference to the ciphernode registry for committee expulsion + ICiphernodeRegistry public ciphernodeRegistry; + + /// @notice Reference to the Enclave contract for E3 failure signaling + IEnclave public enclave; + /// @notice Mapping from slash reason hash to its configured policy - /// @dev Stores penalty amounts, proof requirements, and appeal settings for each slash type mapping(bytes32 reason => SlashPolicy policy) public slashPolicies; /// @notice Internal storage for all slash proposals indexed by proposal ID - /// @dev Sequentially indexed starting from 0, accessed via getSlashProposal() mapping(uint256 proposalId => SlashProposal proposal) internal _proposals; /// @notice Counter for total number of slash proposals ever created - /// @dev Also serves as the next proposal ID to be assigned uint256 public totalProposals; /// @notice Mapping tracking which nodes are currently banned from the network - /// @dev Set to true when a node is banned (either via executeSlash or banNode), false when unbanned mapping(address node => bool banned) public banned; + /// @notice Evidence replay protection: tracks consumed evidence keys + mapping(bytes32 evidenceKey => bool consumed) public evidenceConsumed; + + // ====================== + // Errors (contract-level) + // ====================== + + /// @notice The ZK proof verified successfully — the operator's submission was valid, not a fault + error ProofIsValid(); + // ====================== // Modifiers // ====================== /// @notice Restricts function access to accounts with SLASHER_ROLE - /// @dev Reverts with Unauthorized() if caller lacks the role modifier onlySlasher() { if (!hasRole(SLASHER_ROLE, msg.sender)) revert Unauthorized(); _; } - /// @notice Restricts function access to accounts with VERIFIER_ROLE - /// @dev Reverts with Unauthorized() if caller lacks the role - modifier onlyVerifier() { - if (!hasRole(VERIFIER_ROLE, msg.sender)) revert Unauthorized(); - _; - } - /// @notice Restricts function access to accounts with GOVERNANCE_ROLE - /// @dev Reverts with Unauthorized() if caller lacks the role modifier onlyGovernance() { if (!hasRole(GOVERNANCE_ROLE, msg.sender)) revert Unauthorized(); _; @@ -86,19 +90,26 @@ contract SlashingManager is ISlashingManager, AccessControl { // ====================== /** - * @notice Initializes the SlashingManager contract with admin and bonding registry - * @dev Sets up initial role assignments and bonding registry reference + * @notice Initializes the SlashingManager contract * @param admin Address to receive DEFAULT_ADMIN_ROLE and GOVERNANCE_ROLE - * @param _bondingRegistry Address of the bonding registry contract for executing slashes - * Requirements: - * - admin must not be zero address - * - _bondingRegistry must not be zero address + * @param _bondingRegistry Address of the bonding registry contract + * @param _ciphernodeRegistry Address of the ciphernode registry contract + * @param _enclave Address of the Enclave contract */ - constructor(address admin, address _bondingRegistry) { + constructor( + address admin, + address _bondingRegistry, + address _ciphernodeRegistry, + address _enclave + ) { require(admin != address(0), ZeroAddress()); require(_bondingRegistry != address(0), ZeroAddress()); + require(_ciphernodeRegistry != address(0), ZeroAddress()); + require(_enclave != address(0), ZeroAddress()); bondingRegistry = IBondingRegistry(_bondingRegistry); + ciphernodeRegistry = ICiphernodeRegistry(_ciphernodeRegistry); + enclave = IEnclave(_enclave); _grantRole(DEFAULT_ADMIN_ROLE, admin); _grantRole(GOVERNANCE_ROLE, admin); @@ -146,7 +157,6 @@ contract SlashingManager is ISlashingManager, AccessControl { if (policy.requiresProof) { require(policy.proofVerifier != address(0), VerifierNotSet()); - // TODO: Should we allow appeal window for proof required? require(policy.appealWindow == 0, InvalidPolicy()); } else { require(policy.appealWindow > 0, InvalidPolicy()); @@ -164,6 +174,24 @@ contract SlashingManager is ISlashingManager, AccessControl { bondingRegistry = IBondingRegistry(newBondingRegistry); } + /// @notice Updates the ciphernode registry contract address + /// @param newCiphernodeRegistry Address of the new ICiphernodeRegistry contract + function setCiphernodeRegistry( + address newCiphernodeRegistry + ) external onlyRole(DEFAULT_ADMIN_ROLE) { + require(newCiphernodeRegistry != address(0), ZeroAddress()); + ciphernodeRegistry = ICiphernodeRegistry(newCiphernodeRegistry); + } + + /// @notice Updates the Enclave contract address + /// @param newEnclave Address of the new IEnclave contract + function setEnclave( + address newEnclave + ) external onlyRole(DEFAULT_ADMIN_ROLE) { + require(newEnclave != address(0), ZeroAddress()); + enclave = IEnclave(newEnclave); + } + /// @inheritdoc ISlashingManager function addSlasher(address slasher) external onlyRole(DEFAULT_ADMIN_ROLE) { require(slasher != address(0), ZeroAddress()); @@ -177,69 +205,123 @@ contract SlashingManager is ISlashingManager, AccessControl { _revokeRole(SLASHER_ROLE, slasher); } - /// @inheritdoc ISlashingManager - function addVerifier( - address verifier - ) external onlyRole(DEFAULT_ADMIN_ROLE) { - require(verifier != address(0), ZeroAddress()); - _grantRole(VERIFIER_ROLE, verifier); - } - - /// @inheritdoc ISlashingManager - function removeVerifier( - address verifier - ) external onlyRole(DEFAULT_ADMIN_ROLE) { - _revokeRole(VERIFIER_ROLE, verifier); - } - // ====================== // Slashing Functions // ====================== /// @inheritdoc ISlashingManager + /// @dev Lane A: Permissionless proof-based slash. Anyone can call. + /// Atomically proposes, verifies proof, and executes slash. function proposeSlash( + uint256 e3Id, address operator, bytes32 reason, bytes calldata proof - ) - external - // TODO: Do we need an onlySlasher modifier? - // Can anyone propose a slash? - onlySlasher - returns (uint256 proposalId) - { + ) external returns (uint256 proposalId) { require(operator != address(0), ZeroAddress()); SlashPolicy memory policy = slashPolicies[reason]; require(policy.enabled, SlashReasonDisabled()); + require(policy.requiresProof, InvalidPolicy()); + require(proof.length != 0, ProofRequired()); + + // Evidence replay protection + bytes32 evidenceKey = keccak256( + abi.encode(e3Id, operator, reason, keccak256(proof)) + ); + require(!evidenceConsumed[evidenceKey], DuplicateEvidence()); + evidenceConsumed[evidenceKey] = true; + + // Decode proof: caller encodes (bytes zkProof, bytes32[] publicInputs) + (bytes memory zkProof, bytes32[] memory publicInputs) = abi.decode( + proof, + (bytes, bytes32[]) + ); + + // Verify against circuit verifier via staticcall + // INVERTED logic: proof must FAIL to confirm fault + // (the operator submitted a bad proof — re-verification fails) + (bool callSuccess, bytes memory returnData) = policy + .proofVerifier + .staticcall( + abi.encodeCall(ICircuitVerifier.verify, (zkProof, publicInputs)) + ); + + if (callSuccess) { + bool proofValid = abi.decode(returnData, (bool)); + if (proofValid) revert ProofIsValid(); + } + // If staticcall reverted or returned false → proof is invalid → fault confirmed + // Create proposal proposalId = totalProposals; totalProposals = proposalId + 1; - uint256 executableAt = block.timestamp + policy.appealWindow; SlashProposal storage p = _proposals[proposalId]; - + p.e3Id = e3Id; p.operator = operator; p.reason = reason; p.ticketAmount = policy.ticketPenalty; p.licenseAmount = policy.licensePenalty; p.proposedAt = block.timestamp; - p.executableAt = executableAt; + p.executableAt = block.timestamp; p.proposer = msg.sender; p.proofHash = keccak256(proof); + p.proofVerified = true; - if (policy.requiresProof) { - require(proof.length != 0, ProofRequired()); - bool ok = ISlashVerifier(policy.proofVerifier).verify( - proposalId, - proof - ); - require(ok, InvalidProof()); - p.proofVerified = true; - } + emit SlashProposed( + proposalId, + e3Id, + operator, + reason, + policy.ticketPenalty, + policy.licensePenalty, + block.timestamp, + msg.sender + ); + + _executeSlash(proposalId, policy); + } + + /// @inheritdoc ISlashingManager + /// @dev Lane B: Evidence-based slash with appeal window. SLASHER_ROLE required. + function proposeSlashEvidence( + uint256 e3Id, + address operator, + bytes32 reason, + bytes calldata evidence + ) external onlySlasher returns (uint256 proposalId) { + require(operator != address(0), ZeroAddress()); + + SlashPolicy memory policy = slashPolicies[reason]; + require(policy.enabled, SlashReasonDisabled()); + require(!policy.requiresProof, InvalidPolicy()); + + // Evidence replay protection + bytes32 evidenceKey = keccak256( + abi.encode(e3Id, operator, reason, keccak256(evidence)) + ); + require(!evidenceConsumed[evidenceKey], DuplicateEvidence()); + evidenceConsumed[evidenceKey] = true; + + proposalId = totalProposals; + totalProposals = proposalId + 1; + + uint256 executableAt = block.timestamp + policy.appealWindow; + SlashProposal storage p = _proposals[proposalId]; + p.e3Id = e3Id; + p.operator = operator; + p.reason = reason; + p.ticketAmount = policy.ticketPenalty; + p.licenseAmount = policy.licensePenalty; + p.proposedAt = block.timestamp; + p.executableAt = executableAt; + p.proposer = msg.sender; + p.proofHash = keccak256(evidence); emit SlashProposed( proposalId, + e3Id, operator, reason, policy.ticketPenalty, @@ -250,28 +332,44 @@ contract SlashingManager is ISlashingManager, AccessControl { } /// @inheritdoc ISlashingManager + /// @dev Only for evidence-based slashes (Lane B). Proof-based slashes execute atomically. function executeSlash(uint256 proposalId) external { require(proposalId < totalProposals, InvalidProposal()); SlashProposal storage p = _proposals[proposalId]; - - // Has already been executed? require(!p.executed, AlreadyExecuted()); - p.executed = true; SlashPolicy memory policy = slashPolicies[p.reason]; - if (policy.requiresProof) { - // Appeal window is 0 by policy validation, so we dont check for appeal gating - require(p.proofVerified, InvalidProof()); - } else { - // Evidence mode with appeals - require(block.timestamp >= p.executableAt, AppealWindowActive()); - if (p.appealed) { - require(p.resolved, AppealPending()); - require(!p.appealUpheld, AppealUpheld()); // approved = appeal upheld => cancel slash, return? - } + // Proof-based slashes are already executed atomically in proposeSlash + require(!policy.requiresProof, InvalidPolicy()); + + // Evidence mode: check appeal window + require(block.timestamp >= p.executableAt, AppealWindowActive()); + if (p.appealed) { + require(p.resolved, AppealPending()); + require(!p.appealUpheld, AppealUpheld()); } + _executeSlash(proposalId, policy); + } + + // ====================== + // Internal Execution + // ====================== + + /** + * @notice Internal function that executes a slash and handles committee expulsion + * @param proposalId ID of the proposal to execute + * @param policy The slash policy for this proposal + */ + function _executeSlash( + uint256 proposalId, + SlashPolicy memory policy + ) internal { + SlashProposal storage p = _proposals[proposalId]; + p.executed = true; + + // Execute financial penalties if (p.ticketAmount > 0) { bondingRegistry.slashTicketBalance( p.operator, @@ -288,9 +386,22 @@ contract SlashingManager is ISlashingManager, AccessControl { ); } + // Ban node if policy requires it if (policy.banNode) { banned[p.operator] = true; - emit NodeBanUpdated(p.operator, true, p.reason, msg.sender); + emit NodeBanUpdated(p.operator, true, p.reason, address(this)); + } + + // Committee expulsion for E3-scoped slashes + // expelCommitteeMember returns (activeCount, thresholdM) — one call instead of three + if (policy.affectsCommittee) { + (uint256 activeCount, uint32 thresholdM) = ciphernodeRegistry + .expelCommitteeMember(p.e3Id, p.operator, p.reason); + + // If active count drops below M, fail the E3 + if (activeCount < thresholdM && policy.failureReason > 0) { + enclave.onE3Failed(p.e3Id, policy.failureReason); + } } emit SlashExecuted( @@ -299,7 +410,7 @@ contract SlashingManager is ISlashingManager, AccessControl { p.reason, p.ticketAmount, p.licenseAmount, - p.executed + true ); } @@ -310,15 +421,16 @@ contract SlashingManager is ISlashingManager, AccessControl { /// @inheritdoc ISlashingManager function fileAppeal(uint256 proposalId, string calldata evidence) external { require(proposalId < totalProposals, InvalidProposal()); - // TODO: Should we reject the appeal if the proposal has a cryptographic proof? SlashProposal storage p = _proposals[proposalId]; // Only the accused can appeal require(msg.sender == p.operator, Unauthorized()); - // Only in the window + // Only within the appeal window require(block.timestamp < p.executableAt, AppealWindowExpired()); // Only once require(!p.appealed, AlreadyAppealed()); + // Cannot appeal proof-verified slashes (they have no appeal window) + require(!p.proofVerified, InvalidProposal()); p.appealed = true; @@ -338,7 +450,7 @@ contract SlashingManager is ISlashingManager, AccessControl { require(!p.resolved, AlreadyResolved()); p.resolved = true; - p.appealUpheld = appealUpheld; // true => cancel slash, false => slash stands + p.appealUpheld = appealUpheld; emit AppealResolved( proposalId, diff --git a/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol b/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol index db92a079df..2a307d9b08 100644 --- a/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol +++ b/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol @@ -94,6 +94,38 @@ contract MockCiphernodeRegistry is ICiphernodeRegistry { function isOpen(uint256) external pure returns (bool) { return false; } + + // solhint-disable-next-line no-empty-blocks + function expelCommitteeMember( + uint256, + address, + bytes32 + ) external pure returns (uint256, uint32) { + return (0, 0); + } + + function isCommitteeMemberActive( + uint256, + address + ) external pure returns (bool) { + return true; + } + + function getActiveCommitteeNodes( + uint256 + ) external pure returns (address[] memory) { + return new address[](0); + } + + function getActiveCommitteeCount(uint256) external pure returns (uint256) { + return 0; + } + + function getCommitteeThreshold( + uint256 + ) external pure returns (uint32[2] memory) { + return [uint32(0), uint32(0)]; + } } contract MockCiphernodeRegistryEmptyKey is ICiphernodeRegistry { @@ -179,4 +211,36 @@ contract MockCiphernodeRegistryEmptyKey is ICiphernodeRegistry { function isOpen(uint256) external pure returns (bool) { return false; } + + // solhint-disable-next-line no-empty-blocks + function expelCommitteeMember( + uint256, + address, + bytes32 + ) external pure returns (uint256, uint32) { + return (0, 0); + } + + function isCommitteeMemberActive( + uint256, + address + ) external pure returns (bool) { + return true; + } + + function getActiveCommitteeNodes( + uint256 + ) external pure returns (address[] memory) { + return new address[](0); + } + + function getActiveCommitteeCount(uint256) external pure returns (uint256) { + return 0; + } + + function getCommitteeThreshold( + uint256 + ) external pure returns (uint32[2] memory) { + return [uint32(0), uint32(0)]; + } } diff --git a/packages/enclave-contracts/contracts/test/MockSlashingVerifier.sol b/packages/enclave-contracts/contracts/test/MockSlashingVerifier.sol index 9a134afbea..5097d5eca8 100644 --- a/packages/enclave-contracts/contracts/test/MockSlashingVerifier.sol +++ b/packages/enclave-contracts/contracts/test/MockSlashingVerifier.sol @@ -5,15 +5,22 @@ // or FITNESS FOR A PARTICULAR PURPOSE. pragma solidity >=0.8.27; -import { ISlashVerifier } from "../interfaces/ISlashVerifier.sol"; +import { ICircuitVerifier } from "../interfaces/ICircuitVerifier.sol"; -contract MockSlashingVerifier is ISlashVerifier { - function verify( - uint256, - bytes memory data - ) external pure returns (bool success) { - data; +/// @notice Mock circuit verifier for testing. Returns configurable result. +/// @dev Default returnValue = false means proof is invalid = fault confirmed (slash proceeds). +/// Set returnValue = true to simulate a valid proof = no fault (ProofIsValid revert). +contract MockCircuitVerifier is ICircuitVerifier { + bool public returnValue; + + function setReturnValue(bool _returnValue) external { + returnValue = _returnValue; + } - if (data.length > 0) success = true; + function verify( + bytes calldata, + bytes32[] calldata + ) external view returns (bool) { + return returnValue; } } diff --git a/packages/enclave-contracts/ignition/modules/slashingManager.ts b/packages/enclave-contracts/ignition/modules/slashingManager.ts index 0d5919900e..2a4c8abbbf 100644 --- a/packages/enclave-contracts/ignition/modules/slashingManager.ts +++ b/packages/enclave-contracts/ignition/modules/slashingManager.ts @@ -9,11 +9,15 @@ import { buildModule } from "@nomicfoundation/hardhat-ignition/modules"; export default buildModule("SlashingManager", (m) => { const bondingRegistry = m.getParameter("bondingRegistry"); + const ciphernodeRegistry = m.getParameter("ciphernodeRegistry"); + const enclave = m.getParameter("enclave"); const admin = m.getParameter("admin"); const slashingManager = m.contract("SlashingManager", [ admin, bondingRegistry, + ciphernodeRegistry, + enclave, ]); return { slashingManager }; diff --git a/packages/enclave-contracts/scripts/deployAndSave/slashingManager.ts b/packages/enclave-contracts/scripts/deployAndSave/slashingManager.ts index 47b7e179e6..fdd28469b8 100644 --- a/packages/enclave-contracts/scripts/deployAndSave/slashingManager.ts +++ b/packages/enclave-contracts/scripts/deployAndSave/slashingManager.ts @@ -17,6 +17,8 @@ import { readDeploymentArgs, storeDeploymentArgs } from "../utils"; export interface SlashingManagerArgs { admin?: string; bondingRegistry?: string; + ciphernodeRegistry?: string; + enclave?: string; hre: HardhatRuntimeEnvironment; } @@ -28,6 +30,8 @@ export interface SlashingManagerArgs { export const deployAndSaveSlashingManager = async ({ admin, bondingRegistry, + ciphernodeRegistry, + enclave, hre, }: SlashingManagerArgs): Promise<{ slashingManager: SlashingManager; @@ -41,8 +45,13 @@ export const deployAndSaveSlashingManager = async ({ if ( !admin || !bondingRegistry || + !ciphernodeRegistry || + !enclave || (preDeployedArgs?.constructorArgs?.admin === admin && - preDeployedArgs?.constructorArgs?.bondingRegistry === bondingRegistry) + preDeployedArgs?.constructorArgs?.bondingRegistry === bondingRegistry && + preDeployedArgs?.constructorArgs?.ciphernodeRegistry === + ciphernodeRegistry && + preDeployedArgs?.constructorArgs?.enclave === enclave) ) { if (!preDeployedArgs?.address) { throw new Error( @@ -61,6 +70,8 @@ export const deployAndSaveSlashingManager = async ({ const slashingManager = await slashingManagerFactory.deploy( admin, bondingRegistry, + ciphernodeRegistry, + enclave, ); await slashingManager.waitForDeployment(); @@ -74,6 +85,8 @@ export const deployAndSaveSlashingManager = async ({ constructorArgs: { admin, bondingRegistry, + ciphernodeRegistry, + enclave, }, blockNumber, address: slashingManagerAddress, diff --git a/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts b/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts index 6b44dc185f..8c55add5c3 100644 --- a/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts +++ b/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts @@ -128,6 +128,8 @@ describe("E3 Integration - Refund/Timeout Mechanism", function () { SlashingManager: { admin: ownerAddress, bondingRegistry: addressOne, // Will be updated + ciphernodeRegistry: addressOne, // Will be updated + enclave: addressOne, // Will be updated }, }, }, @@ -253,7 +255,14 @@ describe("E3 Integration - Refund/Timeout Mechanism", function () { await slashingManagerContract.slashingManager.setBondingRegistry( await bondingRegistry.getAddress(), ); + await slashingManagerContract.slashingManager.setCiphernodeRegistry( + ciphernodeRegistryAddress, + ); + await slashingManagerContract.slashingManager.setEnclave(enclaveAddress); await registry.setBondingRegistry(await bondingRegistry.getAddress()); + await registry.setSlashingManager( + await slashingManagerContract.slashingManager.getAddress(), + ); // Update ticket token registry await ticketTokenContract.enclaveTicketToken.setRegistry( From ab2a02bb28be36798b0ca27e44ac89ecff449554 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 14 Feb 2026 15:45:05 +0500 Subject: [PATCH 05/32] feat: tests --- .../ignition/modules/mockSlashingVerifier.ts | 6 +- .../test/Slashing/SlashingManager.spec.ts | 2452 +++++++++-------- 2 files changed, 1281 insertions(+), 1177 deletions(-) diff --git a/packages/enclave-contracts/ignition/modules/mockSlashingVerifier.ts b/packages/enclave-contracts/ignition/modules/mockSlashingVerifier.ts index 3c4b663b6a..17a6ce70d6 100644 --- a/packages/enclave-contracts/ignition/modules/mockSlashingVerifier.ts +++ b/packages/enclave-contracts/ignition/modules/mockSlashingVerifier.ts @@ -5,8 +5,8 @@ // or FITNESS FOR A PARTICULAR PURPOSE. import { buildModule } from "@nomicfoundation/hardhat-ignition/modules"; -export default buildModule("MockSlashingVerifier", (m) => { - const mockSlashingVerifier = m.contract("MockSlashingVerifier"); +export default buildModule("MockCircuitVerifier", (m) => { + const mockCircuitVerifier = m.contract("MockCircuitVerifier"); - return { mockSlashingVerifier }; + return { mockCircuitVerifier }; }) as any; diff --git a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts index 20b29055e1..5c9b6e8563 100644 --- a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts +++ b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts @@ -1,1174 +1,1278 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. -import { expect } from "chai"; -import { network } from "hardhat"; - -import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; -import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; -import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; -import MockSlashingVerifierModule from "../../ignition/modules/mockSlashingVerifier"; -import MockStableTokenModule from "../../ignition/modules/mockStableToken"; -import SlashingManagerModule from "../../ignition/modules/slashingManager"; -import { - BondingRegistry__factory as BondingRegistryFactory, - EnclaveTicketToken__factory as EnclaveTicketTokenFactory, - EnclaveToken__factory as EnclaveTokenFactory, - MockSlashingVerifier__factory as MockSlashingVerifierFactory, - MockUSDC__factory as MockUSDCFactory, - SlashingManager__factory as SlashingManagerFactory, -} from "../../types"; -import type { SlashingManager } from "../../types/contracts/slashing/SlashingManager"; -import type { MockSlashingVerifier } from "../../types/contracts/test/MockSlashingVerifier"; - -const { ethers, networkHelpers, ignition } = await network.connect(); -const { loadFixture, time } = networkHelpers; - -describe("SlashingManager", function () { - const REASON_MISBEHAVIOR = ethers.encodeBytes32String("misbehavior"); - const REASON_INACTIVITY = ethers.encodeBytes32String("inactivity"); - const REASON_DOUBLE_SIGN = ethers.encodeBytes32String("doubleSign"); - - const SLASHER_ROLE = ethers.keccak256(ethers.toUtf8Bytes("SLASHER_ROLE")); - const VERIFIER_ROLE = ethers.keccak256(ethers.toUtf8Bytes("VERIFIER_ROLE")); - const GOVERNANCE_ROLE = ethers.keccak256( - ethers.toUtf8Bytes("GOVERNANCE_ROLE"), - ); - const DEFAULT_ADMIN_ROLE = ethers.ZeroHash; - - const APPEAL_WINDOW = 7 * 24 * 60 * 60; - - async function setupPolicies( - slashingManager: SlashingManager, - mockVerifier: MockSlashingVerifier, - ) { - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - }; - - const evidencePolicy = { - ticketPenalty: ethers.parseUnits("20", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - - const banPolicy = { - ticketPenalty: ethers.parseUnits("100", 6), - licensePenalty: ethers.parseEther("500"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: true, - appealWindow: 0, - enabled: true, - }; - - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - await slashingManager.setSlashPolicy(REASON_INACTIVITY, evidencePolicy); - await slashingManager.setSlashPolicy(REASON_DOUBLE_SIGN, banPolicy); - } - - async function setup() { - const [owner, slasher, verifier, operator, notTheOwner] = - await ethers.getSigners(); - const ownerAddress = await owner.getAddress(); - const operatorAddress = await operator.getAddress(); - - const usdcContract = await ignition.deploy(MockStableTokenModule, { - parameters: { - MockUSDC: { - initialSupply: 1000000, - }, - }, - }); - - const enclTokenContract = await ignition.deploy(EnclaveTokenModule, { - parameters: { - EnclaveToken: { - owner: ownerAddress, - }, - }, - }); - - const ticketTokenContract = await ignition.deploy( - EnclaveTicketTokenModule, - { - parameters: { - EnclaveTicketToken: { - baseToken: await usdcContract.mockUSDC.getAddress(), - registry: ownerAddress, - owner: ownerAddress, - }, - }, - }, - ); - - const mockVerifierContract = await ignition.deploy( - MockSlashingVerifierModule, - ); - - const slashingManagerContract = await ignition.deploy( - SlashingManagerModule, - { - parameters: { - SlashingManager: { - admin: ownerAddress, - bondingRegistry: ownerAddress, - }, - }, - }, - ); - - const bondingRegistryContract = await ignition.deploy( - BondingRegistryModule, - { - parameters: { - BondingRegistry: { - owner: ownerAddress, - ticketToken: - await ticketTokenContract.enclaveTicketToken.getAddress(), - licenseToken: await enclTokenContract.enclaveToken.getAddress(), - registry: ethers.ZeroAddress, - slashedFundsTreasury: ownerAddress, - ticketPrice: ethers.parseUnits("10", 6), - licenseRequiredBond: ethers.parseEther("1000"), - minTicketBalance: 5, - exitDelay: APPEAL_WINDOW, - }, - }, - }, - ); - - const usdcToken = MockUSDCFactory.connect( - await usdcContract.mockUSDC.getAddress(), - owner, - ); - const enclaveToken = EnclaveTokenFactory.connect( - await enclTokenContract.enclaveToken.getAddress(), - owner, - ); - const ticketToken = EnclaveTicketTokenFactory.connect( - await ticketTokenContract.enclaveTicketToken.getAddress(), - owner, - ); - const mockVerifier = MockSlashingVerifierFactory.connect( - await mockVerifierContract.mockSlashingVerifier.getAddress(), - owner, - ); - const slashingManager = SlashingManagerFactory.connect( - await slashingManagerContract.slashingManager.getAddress(), - owner, - ); - const bondingRegistry = BondingRegistryFactory.connect( - await bondingRegistryContract.bondingRegistry.getAddress(), - owner, - ); - - await ticketToken.setRegistry(await bondingRegistry.getAddress()); - await slashingManager.setBondingRegistry( - await bondingRegistry.getAddress(), - ); - await bondingRegistry.setSlashingManager( - await slashingManager.getAddress(), - ); - - await enclaveToken.setTransferRestriction(false); - - await enclaveToken.mintAllocation( - operatorAddress, - ethers.parseEther("2000"), - "Test allocation", - ); - - await slashingManager.addSlasher(await slasher.getAddress()); - await slashingManager.addVerifier(await verifier.getAddress()); - - return { - owner, - slasher, - verifier, - operator, - operatorAddress, - notTheOwner, - slashingManager, - bondingRegistry, - enclaveToken, - ticketToken, - usdcToken, - mockVerifier, - }; - } - - describe("constructor / initialization", function () { - it("should set the admin role correctly", async function () { - const { slashingManager, owner } = await loadFixture(setup); - - expect( - await slashingManager.hasRole( - DEFAULT_ADMIN_ROLE, - await owner.getAddress(), - ), - ).to.be.true; - expect( - await slashingManager.hasRole( - GOVERNANCE_ROLE, - await owner.getAddress(), - ), - ).to.be.true; - }); - - it("should set the bonding registry correctly", async function () { - const { slashingManager, bondingRegistry } = await loadFixture(setup); - - expect(await slashingManager.bondingRegistry()).to.equal( - await bondingRegistry.getAddress(), - ); - }); - - it("should revert if admin is zero address", async function () { - await expect( - ignition.deploy(SlashingManagerModule, { - parameters: { - SlashingManager: { - admin: ethers.ZeroAddress, - bondingRegistry: ethers.ZeroAddress, - }, - }, - }), - ).to.be.rejected; - }); - }); - - describe("setSlashPolicy()", function () { - it("should set a valid slash policy", async function () { - const { slashingManager, mockVerifier } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - }; - - await expect(slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy)) - .to.emit(slashingManager, "SlashPolicyUpdated") - .withArgs(REASON_MISBEHAVIOR, Object.values(policy)); - - const storedPolicy = - await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); - expect(storedPolicy.ticketPenalty).to.equal(policy.ticketPenalty); - expect(storedPolicy.licensePenalty).to.equal(policy.licensePenalty); - expect(storedPolicy.requiresProof).to.equal(policy.requiresProof); - expect(storedPolicy.enabled).to.equal(policy.enabled); - }); - - it("should set a policy without proof requirement", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("20", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - - await expect(slashingManager.setSlashPolicy(REASON_INACTIVITY, policy)) - .to.emit(slashingManager, "SlashPolicyUpdated") - .withArgs(REASON_INACTIVITY, Object.values(policy)); - }); - - it("should revert if caller is not governance", async function () { - const { slashingManager, notTheOwner } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - - await expect( - slashingManager - .connect(notTheOwner) - .setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError( - slashingManager, - "AccessControlUnauthorizedAccount", - ); - }); - - it("should revert if reason is zero", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - - await expect( - slashingManager.setSlashPolicy(ethers.ZeroHash, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if policy is disabled", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: false, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if no penalties are set", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: 0, - licensePenalty: 0, - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if proof required but no verifier set", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: 0, - enabled: true, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "VerifierNotSet"); - }); - - it("should revert if proof required but appeal window set", async function () { - const { slashingManager, mockVerifier } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if no proof required but no appeal window", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: 0, - enabled: true, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - }); - - describe("role management", function () { - it("should add and remove slasher role", async function () { - const { slashingManager, notTheOwner } = await loadFixture(setup); - - await slashingManager.addSlasher(await notTheOwner.getAddress()); - expect( - await slashingManager.hasRole( - SLASHER_ROLE, - await notTheOwner.getAddress(), - ), - ).to.be.true; - - await slashingManager.removeSlasher(await notTheOwner.getAddress()); - expect( - await slashingManager.hasRole( - SLASHER_ROLE, - await notTheOwner.getAddress(), - ), - ).to.be.false; - }); - - it("should add and remove verifier role", async function () { - const { slashingManager, notTheOwner } = await loadFixture(setup); - - await slashingManager.addVerifier(await notTheOwner.getAddress()); - expect( - await slashingManager.hasRole( - VERIFIER_ROLE, - await notTheOwner.getAddress(), - ), - ).to.be.true; - - await slashingManager.removeVerifier(await notTheOwner.getAddress()); - expect( - await slashingManager.hasRole( - VERIFIER_ROLE, - await notTheOwner.getAddress(), - ), - ).to.be.false; - }); - - it("should revert if non-admin tries to add slasher", async function () { - const { slashingManager, notTheOwner } = await loadFixture(setup); - - await expect( - slashingManager - .connect(notTheOwner) - .addSlasher(await notTheOwner.getAddress()), - ).to.be.revert(ethers); - }); - - it("should revert if zero address is added as slasher", async function () { - const { slashingManager } = await loadFixture(setup); - - await expect( - slashingManager.addSlasher(ethers.ZeroAddress), - ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); - }); - }); - - describe("proposeSlash()", function () { - it("should propose slash with proof", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - - const proof = ethers.toUtf8Bytes("Valid proof data"); - const currentTime = await time.latest(); - - await expect( - slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_MISBEHAVIOR, proof), - ) - .to.emit(slashingManager, "SlashProposed") - .withArgs( - 0, - operatorAddress, - REASON_MISBEHAVIOR, - ethers.parseUnits("50", 6), - ethers.parseEther("100"), - currentTime + 1, - await slasher.getAddress(), - ); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.operator).to.equal(operatorAddress); - expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); - expect(proposal.proofVerified).to.be.true; - expect(proposal.proposer).to.equal(await slasher.getAddress()); - }); - - it("should propose slash without proof (evidence-based)", async function () { - const { slashingManager, slasher, operatorAddress } = - await loadFixture(setup); - - const evidencePolicy = { - ticketPenalty: ethers.parseUnits("20", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - await slashingManager.setSlashPolicy(REASON_INACTIVITY, evidencePolicy); - - const proof = ethers.toUtf8Bytes(""); - const currentTime = await time.latest(); - - await expect( - slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_INACTIVITY, proof), - ) - .to.emit(slashingManager, "SlashProposed") - .withArgs( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.parseUnits("20", 6), - ethers.parseEther("50"), - currentTime + APPEAL_WINDOW + 1, - await slasher.getAddress(), - ); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.proofVerified).to.be.false; - expect(proposal.executableAt).to.be.greaterThan( - currentTime + APPEAL_WINDOW, - ); - }); - - it("should revert if caller is not slasher", async function () { - const { slashingManager, notTheOwner, operatorAddress } = - await loadFixture(setup); - - const proof = ethers.toUtf8Bytes("Some proof"); - - await expect( - slashingManager - .connect(notTheOwner) - .proposeSlash(operatorAddress, REASON_MISBEHAVIOR, proof), - ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); - }); - - it("should revert if operator is zero address", async function () { - const { slashingManager, slasher } = await loadFixture(setup); - - const proof = ethers.toUtf8Bytes("Some proof"); - - await expect( - slashingManager - .connect(slasher) - .proposeSlash(ethers.ZeroAddress, REASON_MISBEHAVIOR, proof), - ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); - }); - - it("should revert if slash reason is disabled", async function () { - const { slashingManager, slasher, operatorAddress } = - await loadFixture(setup); - - const proof = ethers.toUtf8Bytes("Some proof"); - - await expect( - slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_DOUBLE_SIGN, proof), - ).to.be.revertedWithCustomError(slashingManager, "SlashReasonDisabled"); - }); - - it("should revert if proof required but not provided", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - - const emptyProof = ethers.toUtf8Bytes(""); - - await expect( - slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_MISBEHAVIOR, emptyProof), - ).to.be.revertedWithCustomError(slashingManager, "ProofRequired"); - }); - - it("should increment totalProposals", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - }; - const evidencePolicy = { - ticketPenalty: ethers.parseUnits("20", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - await slashingManager.setSlashPolicy(REASON_INACTIVITY, evidencePolicy); - - expect(await slashingManager.totalProposals()).to.equal(0); - - const proof = ethers.toUtf8Bytes("Valid proof"); - await slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_MISBEHAVIOR, proof); - - expect(await slashingManager.totalProposals()).to.equal(1); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - - expect(await slashingManager.totalProposals()).to.equal(2); - }); - }); - - describe("executeSlash()", function () { - it("should execute slash with proof immediately", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - - const proof = ethers.toUtf8Bytes("Valid proof"); - await slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_MISBEHAVIOR, proof); - - await expect(slashingManager.connect(slasher).executeSlash(0)) - .to.emit(slashingManager, "SlashExecuted") - .withArgs( - 0, - operatorAddress, - REASON_MISBEHAVIOR, - ethers.parseUnits("50", 6), - ethers.parseEther("100"), - true, - ); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.executed).to.be.true; - }); - - it("should execute slash after appeal window expires", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - - await expect( - slashingManager.connect(slasher).executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AppealWindowActive"); - - await time.increase(APPEAL_WINDOW + 1); - - await expect(slashingManager.connect(slasher).executeSlash(0)).to.emit( - slashingManager, - "SlashExecuted", - ); - }); - - it("should ban node when policy requires it", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - const proof = ethers.toUtf8Bytes("Serious violation proof"); - await slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_DOUBLE_SIGN, proof); - - expect(await slashingManager.isBanned(operatorAddress)).to.be.false; - - await expect(slashingManager.connect(slasher).executeSlash(0)) - .to.emit(slashingManager, "NodeBanUpdated") - .withArgs(operatorAddress, true, REASON_DOUBLE_SIGN, slasher); - - expect(await slashingManager.isBanned(operatorAddress)).to.be.true; - }); - - it("should revert if proposal doesn't exist", async function () { - const { slashingManager, slasher } = await loadFixture(setup); - - await expect( - slashingManager.connect(slasher).executeSlash(999), - ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); - }); - - it("should revert if already executed", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - const proof = ethers.toUtf8Bytes("Valid proof"); - await slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_MISBEHAVIOR, proof); - await slashingManager.connect(slasher).executeSlash(0); - - await expect( - slashingManager.connect(slasher).executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AlreadyExecuted"); - }); - }); - - describe("appeal system", function () { - it("should allow operator to file appeal", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - - const evidence = "I was not inactive, here's the proof..."; - - await expect(slashingManager.connect(operator).fileAppeal(0, evidence)) - .to.emit(slashingManager, "AppealFiled") - .withArgs(0, operatorAddress, REASON_INACTIVITY, evidence); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.appealed).to.be.true; - }); - - it("should revert if non-operator tries to appeal", async function () { - const { - slashingManager, - slasher, - notTheOwner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - - await expect( - slashingManager.connect(notTheOwner).fileAppeal(0, "Not my appeal"), - ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); - }); - - it("should revert if appeal window expired", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - - await time.increase(APPEAL_WINDOW + 1); - - await expect( - slashingManager.connect(operator).fileAppeal(0, "Too late"), - ).to.be.revertedWithCustomError(slashingManager, "AppealWindowExpired"); - }); - - it("should revert if already appealed", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - - await slashingManager.connect(operator).fileAppeal(0, "First appeal"); - - await expect( - slashingManager.connect(operator).fileAppeal(0, "Second appeal"), - ).to.be.revertedWithCustomError(slashingManager, "AlreadyAppealed"); - }); - - it("should allow governance to resolve appeal (approve)", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - - const resolution = "Appeal approved after review"; - - await expect( - slashingManager.connect(owner).resolveAppeal(0, true, resolution), - ) - .to.emit(slashingManager, "AppealResolved") - .withArgs( - 0, - operatorAddress, - true, - await owner.getAddress(), - resolution, - ); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.resolved).to.be.true; - expect(proposal.appealUpheld).to.be.true; - }); - - it("should allow governance to resolve appeal (deny)", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - - await slashingManager - .connect(owner) - .resolveAppeal(0, false, "Appeal denied"); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.resolved).to.be.true; - expect(proposal.appealUpheld).to.be.false; - }); - - it("should block execution if appeal is pending", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - - await time.increase(APPEAL_WINDOW + 1); - - await expect( - slashingManager.connect(slasher).executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AppealPending"); - }); - - it("should block execution if appeal was approved", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - await slashingManager.connect(owner).resolveAppeal(0, true, "Approved"); - - await time.increase(APPEAL_WINDOW + 1); - - await expect( - slashingManager.connect(slasher).executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AppealUpheld"); - }); - - it("should allow execution if appeal was denied", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlash( - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - await slashingManager.connect(owner).resolveAppeal(0, false, "Denied"); - - await time.increase(APPEAL_WINDOW + 1); - - await expect(slashingManager.connect(slasher).executeSlash(0)).to.emit( - slashingManager, - "SlashExecuted", - ); - }); - }); - - describe("ban management", function () { - it("should allow governance to ban node", async function () { - const { slashingManager, owner, operatorAddress } = - await loadFixture(setup); - - const reason = ethers.encodeBytes32String("manual_ban"); - - await expect( - slashingManager - .connect(owner) - .updateBanStatus(operatorAddress, true, reason), - ) - .to.emit(slashingManager, "NodeBanUpdated") - .withArgs(operatorAddress, true, reason, await owner.getAddress()); - - expect(await slashingManager.isBanned(operatorAddress)).to.be.true; - }); - - it("should allow governance to unban node", async function () { - const { slashingManager, owner, operatorAddress } = - await loadFixture(setup); - - await slashingManager - .connect(owner) - .updateBanStatus( - operatorAddress, - true, - ethers.encodeBytes32String("test"), - ); - expect(await slashingManager.isBanned(operatorAddress)).to.be.true; - - await expect( - slashingManager - .connect(owner) - .updateBanStatus( - operatorAddress, - false, - ethers.encodeBytes32String("test"), - ), - ) - .to.emit(slashingManager, "NodeBanUpdated") - .withArgs( - operatorAddress, - false, - ethers.encodeBytes32String("test"), - await owner.getAddress(), - ); - - expect(await slashingManager.isBanned(operatorAddress)).to.be.false; - }); - - it("should revert if non-governance tries to ban", async function () { - const { slashingManager, notTheOwner, operatorAddress } = - await loadFixture(setup); - - await expect( - slashingManager - .connect(notTheOwner) - .updateBanStatus( - operatorAddress, - false, - ethers.encodeBytes32String("test"), - ), - ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); - }); - }); - - describe("view functions", function () { - it("should return correct slash policy", async function () { - const { slashingManager, mockVerifier } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: true, - appealWindow: 0, - enabled: true, - }; - - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy); - - const retrieved = - await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); - expect(retrieved.ticketPenalty).to.equal(policy.ticketPenalty); - expect(retrieved.licensePenalty).to.equal(policy.licensePenalty); - expect(retrieved.requiresProof).to.equal(policy.requiresProof); - expect(retrieved.proofVerifier).to.equal(policy.proofVerifier); - expect(retrieved.banNode).to.equal(policy.banNode); - expect(retrieved.appealWindow).to.equal(policy.appealWindow); - expect(retrieved.enabled).to.equal(policy.enabled); - }); - - it("should return correct slash proposal", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - const proof = ethers.toUtf8Bytes("test proof"); - await slashingManager - .connect(slasher) - .proposeSlash(operatorAddress, REASON_MISBEHAVIOR, proof); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.operator).to.equal(operatorAddress); - expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); - expect(proposal.ticketAmount).to.equal(ethers.parseUnits("50", 6)); - expect(proposal.licenseAmount).to.equal(ethers.parseEther("100")); - expect(proposal.proposer).to.equal(await slasher.getAddress()); - expect(proposal.proofHash).to.equal(ethers.keccak256(proof)); - expect(proposal.proofVerified).to.be.true; - }); - - it("should revert for invalid proposal ID", async function () { - const { slashingManager } = await loadFixture(setup); - - await expect( - slashingManager.getSlashProposal(999), - ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); - }); - }); -}); +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. +import { expect } from "chai"; +import { network } from "hardhat"; + +import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; +import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; +import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; +import MockCircuitVerifierModule from "../../ignition/modules/mockSlashingVerifier"; +import MockStableTokenModule from "../../ignition/modules/mockStableToken"; +import SlashingManagerModule from "../../ignition/modules/slashingManager"; +import { + BondingRegistry__factory as BondingRegistryFactory, + EnclaveTicketToken__factory as EnclaveTicketTokenFactory, + EnclaveToken__factory as EnclaveTokenFactory, + MockCircuitVerifier__factory as MockCircuitVerifierFactory, + MockUSDC__factory as MockUSDCFactory, + SlashingManager__factory as SlashingManagerFactory, +} from "../../types"; +import type { SlashingManager } from "../../types/contracts/slashing/SlashingManager"; +import type { MockCircuitVerifier } from "../../types/contracts/test/MockSlashingVerifier"; + +const { ethers, networkHelpers, ignition } = await network.connect(); +const { loadFixture, time } = networkHelpers; + +describe("SlashingManager", function () { + const REASON_MISBEHAVIOR = ethers.encodeBytes32String("misbehavior"); + const REASON_INACTIVITY = ethers.encodeBytes32String("inactivity"); + const REASON_DOUBLE_SIGN = ethers.encodeBytes32String("doubleSign"); + + const SLASHER_ROLE = ethers.keccak256(ethers.toUtf8Bytes("SLASHER_ROLE")); + const GOVERNANCE_ROLE = ethers.keccak256( + ethers.toUtf8Bytes("GOVERNANCE_ROLE"), + ); + const DEFAULT_ADMIN_ROLE = ethers.ZeroHash; + + const APPEAL_WINDOW = 7 * 24 * 60 * 60; + + // Placeholder address for contracts not under test + const addressOne = "0x0000000000000000000000000000000000000001"; + + const abiCoder = ethers.AbiCoder.defaultAbiCoder(); + + /** + * Helper to encode proof data as (bytes zkProof, bytes32[] publicInputs) + * for the circuit verifier inverted-logic path. + */ + function encodeProof( + zkProof: string = "0x1234", + publicInputs: string[] = [ethers.ZeroHash], + ): string { + return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); + } + + async function setupPolicies( + slashingManager: SlashingManager, + mockVerifier: MockCircuitVerifier, + ) { + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + const evidencePolicy = { + ticketPenalty: ethers.parseUnits("20", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + const banPolicy = { + ticketPenalty: ethers.parseUnits("100", 6), + licensePenalty: ethers.parseEther("500"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: true, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + await slashingManager.setSlashPolicy(REASON_INACTIVITY, evidencePolicy); + await slashingManager.setSlashPolicy(REASON_DOUBLE_SIGN, banPolicy); + } + + async function setup() { + const [owner, slasher, proposer, operator, notTheOwner] = + await ethers.getSigners(); + const ownerAddress = await owner.getAddress(); + const operatorAddress = await operator.getAddress(); + + const usdcContract = await ignition.deploy(MockStableTokenModule, { + parameters: { + MockUSDC: { + initialSupply: 1000000, + }, + }, + }); + + const enclTokenContract = await ignition.deploy(EnclaveTokenModule, { + parameters: { + EnclaveToken: { + owner: ownerAddress, + }, + }, + }); + + const ticketTokenContract = await ignition.deploy( + EnclaveTicketTokenModule, + { + parameters: { + EnclaveTicketToken: { + baseToken: await usdcContract.mockUSDC.getAddress(), + registry: ownerAddress, + owner: ownerAddress, + }, + }, + }, + ); + + const mockVerifierContract = await ignition.deploy( + MockCircuitVerifierModule, + ); + + const slashingManagerContract = await ignition.deploy( + SlashingManagerModule, + { + parameters: { + SlashingManager: { + admin: ownerAddress, + bondingRegistry: ownerAddress, + ciphernodeRegistry: addressOne, + enclave: addressOne, + }, + }, + }, + ); + + const bondingRegistryContract = await ignition.deploy( + BondingRegistryModule, + { + parameters: { + BondingRegistry: { + owner: ownerAddress, + ticketToken: + await ticketTokenContract.enclaveTicketToken.getAddress(), + licenseToken: await enclTokenContract.enclaveToken.getAddress(), + registry: ethers.ZeroAddress, + slashedFundsTreasury: ownerAddress, + ticketPrice: ethers.parseUnits("10", 6), + licenseRequiredBond: ethers.parseEther("1000"), + minTicketBalance: 5, + exitDelay: APPEAL_WINDOW, + }, + }, + }, + ); + + const usdcToken = MockUSDCFactory.connect( + await usdcContract.mockUSDC.getAddress(), + owner, + ); + const enclaveToken = EnclaveTokenFactory.connect( + await enclTokenContract.enclaveToken.getAddress(), + owner, + ); + const ticketToken = EnclaveTicketTokenFactory.connect( + await ticketTokenContract.enclaveTicketToken.getAddress(), + owner, + ); + const mockVerifier = MockCircuitVerifierFactory.connect( + await mockVerifierContract.mockCircuitVerifier.getAddress(), + owner, + ); + const slashingManager = SlashingManagerFactory.connect( + await slashingManagerContract.slashingManager.getAddress(), + owner, + ); + const bondingRegistry = BondingRegistryFactory.connect( + await bondingRegistryContract.bondingRegistry.getAddress(), + owner, + ); + + await ticketToken.setRegistry(await bondingRegistry.getAddress()); + await slashingManager.setBondingRegistry( + await bondingRegistry.getAddress(), + ); + await bondingRegistry.setSlashingManager( + await slashingManager.getAddress(), + ); + + await enclaveToken.setTransferRestriction(false); + + await enclaveToken.mintAllocation( + operatorAddress, + ethers.parseEther("2000"), + "Test allocation", + ); + + await slashingManager.addSlasher(await slasher.getAddress()); + + return { + owner, + slasher, + proposer, + operator, + operatorAddress, + notTheOwner, + slashingManager, + bondingRegistry, + enclaveToken, + ticketToken, + usdcToken, + mockVerifier, + }; + } + + describe("constructor / initialization", function () { + it("should set the admin role correctly", async function () { + const { slashingManager, owner } = await loadFixture(setup); + + expect( + await slashingManager.hasRole( + DEFAULT_ADMIN_ROLE, + await owner.getAddress(), + ), + ).to.be.true; + expect( + await slashingManager.hasRole( + GOVERNANCE_ROLE, + await owner.getAddress(), + ), + ).to.be.true; + }); + + it("should set the bonding registry correctly", async function () { + const { slashingManager, bondingRegistry } = await loadFixture(setup); + + expect(await slashingManager.bondingRegistry()).to.equal( + await bondingRegistry.getAddress(), + ); + }); + + it("should revert if admin is zero address", async function () { + await expect( + ignition.deploy(SlashingManagerModule, { + parameters: { + SlashingManager: { + admin: ethers.ZeroAddress, + bondingRegistry: ethers.ZeroAddress, + ciphernodeRegistry: ethers.ZeroAddress, + enclave: ethers.ZeroAddress, + }, + }, + }), + ).to.be.rejected; + }); + }); + + describe("setSlashPolicy()", function () { + it("should set a valid proof-based slash policy", async function () { + const { slashingManager, mockVerifier } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect(slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy)) + .to.emit(slashingManager, "SlashPolicyUpdated") + .withArgs(REASON_MISBEHAVIOR, Object.values(policy)); + + const storedPolicy = + await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); + expect(storedPolicy.ticketPenalty).to.equal(policy.ticketPenalty); + expect(storedPolicy.licensePenalty).to.equal(policy.licensePenalty); + expect(storedPolicy.requiresProof).to.equal(policy.requiresProof); + expect(storedPolicy.enabled).to.equal(policy.enabled); + }); + + it("should set an evidence-based policy (no proof required)", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("20", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect(slashingManager.setSlashPolicy(REASON_INACTIVITY, policy)) + .to.emit(slashingManager, "SlashPolicyUpdated") + .withArgs(REASON_INACTIVITY, Object.values(policy)); + }); + + it("should revert if caller is not governance", async function () { + const { slashingManager, notTheOwner } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager + .connect(notTheOwner) + .setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError( + slashingManager, + "AccessControlUnauthorizedAccount", + ); + }); + + it("should revert if reason is zero", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(ethers.ZeroHash, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if policy is disabled", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: false, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if no penalties are set", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: 0, + licensePenalty: 0, + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if proof required but no verifier set", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "VerifierNotSet"); + }); + + it("should revert if proof required but appeal window set", async function () { + const { slashingManager, mockVerifier } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if no proof required but no appeal window", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + }); + + describe("role management", function () { + it("should add and remove slasher role", async function () { + const { slashingManager, notTheOwner } = await loadFixture(setup); + + await slashingManager.addSlasher(await notTheOwner.getAddress()); + expect( + await slashingManager.hasRole( + SLASHER_ROLE, + await notTheOwner.getAddress(), + ), + ).to.be.true; + + await slashingManager.removeSlasher(await notTheOwner.getAddress()); + expect( + await slashingManager.hasRole( + SLASHER_ROLE, + await notTheOwner.getAddress(), + ), + ).to.be.false; + }); + + it("should revert if non-admin tries to add slasher", async function () { + const { slashingManager, notTheOwner } = await loadFixture(setup); + + await expect( + slashingManager + .connect(notTheOwner) + .addSlasher(await notTheOwner.getAddress()), + ).to.be.revertedWithCustomError( + slashingManager, + "AccessControlUnauthorizedAccount", + ); + }); + + it("should revert if zero address is added as slasher", async function () { + const { slashingManager } = await loadFixture(setup); + + await expect( + slashingManager.addSlasher(ethers.ZeroAddress), + ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); + }); + }); + + describe("proposeSlash() — Lane A (proof-based, permissionless)", function () { + it("should propose and auto-execute slash with proof", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + // MockCircuitVerifier default returnValue=false → proof invalid → fault confirmed + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + const proof = encodeProof(); + const e3Id = 0; + + // Anyone can call proposeSlash (permissionless for Lane A) + await expect( + slashingManager + .connect(proposer) + .proposeSlash(e3Id, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.emit(slashingManager, "SlashProposed"); + + // Proof-based slashes auto-execute + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.operator).to.equal(operatorAddress); + expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); + expect(proposal.proofVerified).to.be.true; + expect(proposal.executed).to.be.true; + expect(proposal.proposer).to.equal(await proposer.getAddress()); + }); + + it("should revert if circuit verifier says proof is valid (no fault)", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + // Set mock verifier to return true → proof is valid → NOT a fault + await mockVerifier.setReturnValue(true); + + const proof = encodeProof(); + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError(slashingManager, "ProofIsValid"); + }); + + it("should revert if operator is zero address", async function () { + const { slashingManager, proposer, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const proof = encodeProof(); + + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, ethers.ZeroAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); + }); + + it("should revert if slash reason is disabled", async function () { + const { slashingManager, proposer, operatorAddress } = + await loadFixture(setup); + + const proof = encodeProof(); + + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_DOUBLE_SIGN, proof), + ).to.be.revertedWithCustomError(slashingManager, "SlashReasonDisabled"); + }); + + it("should revert if proof is empty", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, "0x"), + ).to.be.revertedWithCustomError(slashingManager, "ProofRequired"); + }); + + it("should reject duplicate evidence", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + const proof = encodeProof(); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + // Same proof for same e3Id/operator/reason should be rejected + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError(slashingManager, "DuplicateEvidence"); + }); + + it("should increment totalProposals", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + expect(await slashingManager.totalProposals()).to.equal(0); + + const proof1 = encodeProof("0x1111"); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof1); + + expect(await slashingManager.totalProposals()).to.equal(1); + + const proof2 = encodeProof("0x2222"); + await slashingManager + .connect(proposer) + .proposeSlash(1, operatorAddress, REASON_MISBEHAVIOR, proof2); + + expect(await slashingManager.totalProposals()).to.equal(2); + }); + + it("should ban node when policy requires it", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + expect(await slashingManager.isBanned(operatorAddress)).to.be.false; + + const proof = encodeProof("0x3333"); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_DOUBLE_SIGN, proof); + + // banNode=true → auto-executed → node is now banned + expect(await slashingManager.isBanned(operatorAddress)).to.be.true; + }); + }); + + describe("proposeSlashEvidence() — Lane B (evidence-based, SLASHER_ROLE)", function () { + it("should propose evidence-based slash with appeal window", async function () { + const { slashingManager, slasher, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const evidence = ethers.toUtf8Bytes("operator was inactive during E3"); + const e3Id = 0; + + await expect( + slashingManager + .connect(slasher) + .proposeSlashEvidence( + e3Id, + operatorAddress, + REASON_INACTIVITY, + evidence, + ), + ).to.emit(slashingManager, "SlashProposed"); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.operator).to.equal(operatorAddress); + expect(proposal.reason).to.equal(REASON_INACTIVITY); + expect(proposal.proofVerified).to.be.false; + expect(proposal.executed).to.be.false; + expect(proposal.proposer).to.equal(await slasher.getAddress()); + expect(proposal.executableAt).to.be.gt(proposal.proposedAt); + }); + + it("should revert if caller is not slasher", async function () { + const { slashingManager, notTheOwner, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const evidence = ethers.toUtf8Bytes("evidence"); + + await expect( + slashingManager + .connect(notTheOwner) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + evidence, + ), + ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); + }); + + it("should revert if operator is zero address", async function () { + const { slashingManager, slasher, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await expect( + slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + ethers.ZeroAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes(""), + ), + ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); + }); + }); + + describe("executeSlash() — Lane B execution", function () { + it("should execute evidence-based slash after appeal window", async function () { + const { slashingManager, slasher, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + // Should revert before appeal window expires + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AppealWindowActive"); + + // Fast forward past appeal window + await time.increase(APPEAL_WINDOW + 1); + + await expect(slashingManager.executeSlash(0)).to.emit( + slashingManager, + "SlashExecuted", + ); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.executed).to.be.true; + }); + + it("should revert if proof-based slash tries to executeSlash separately", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + // Proof-based slash auto-executes in proposeSlash + const proof = encodeProof(); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + // Should revert because already executed + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AlreadyExecuted"); + }); + + it("should revert if proposal doesn't exist", async function () { + const { slashingManager } = await loadFixture(setup); + + await expect( + slashingManager.executeSlash(999), + ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); + }); + + it("should revert if already executed", async function () { + const { slashingManager, slasher, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await time.increase(APPEAL_WINDOW + 1); + await slashingManager.executeSlash(0); + + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AlreadyExecuted"); + }); + }); + + describe("appeal system", function () { + it("should allow operator to file appeal on evidence-based slash", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + const evidence = "I was not inactive, here's the proof..."; + + await expect(slashingManager.connect(operator).fileAppeal(0, evidence)) + .to.emit(slashingManager, "AppealFiled") + .withArgs(0, operatorAddress, REASON_INACTIVITY, evidence); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.appealed).to.be.true; + }); + + it("should revert if non-operator tries to appeal", async function () { + const { + slashingManager, + slasher, + notTheOwner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await expect( + slashingManager.connect(notTheOwner).fileAppeal(0, "Not my appeal"), + ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); + }); + + it("should revert if appeal window expired", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await time.increase(APPEAL_WINDOW + 1); + + await expect( + slashingManager.connect(operator).fileAppeal(0, "Too late"), + ).to.be.revertedWithCustomError(slashingManager, "AppealWindowExpired"); + }); + + it("should revert if already appealed", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await slashingManager.connect(operator).fileAppeal(0, "First appeal"); + + await expect( + slashingManager.connect(operator).fileAppeal(0, "Second appeal"), + ).to.be.revertedWithCustomError(slashingManager, "AlreadyAppealed"); + }); + + it("should revert if appealing proof-verified slash", async function () { + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + // Proof-based slash auto-executes with proofVerified=true + const proof = encodeProof(); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + // Cannot appeal proof-verified slashes — appeal window is 0 so it's already expired + await expect( + slashingManager.connect(operator).fileAppeal(0, "Cannot appeal proof"), + ).to.be.revertedWithCustomError(slashingManager, "AppealWindowExpired"); + }); + + it("should allow governance to resolve appeal (approve)", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + + const resolution = "Appeal approved after review"; + + await expect( + slashingManager.connect(owner).resolveAppeal(0, true, resolution), + ) + .to.emit(slashingManager, "AppealResolved") + .withArgs( + 0, + operatorAddress, + true, + await owner.getAddress(), + resolution, + ); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.resolved).to.be.true; + expect(proposal.appealUpheld).to.be.true; + }); + + it("should allow governance to resolve appeal (deny)", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + + await slashingManager + .connect(owner) + .resolveAppeal(0, false, "Appeal denied"); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.resolved).to.be.true; + expect(proposal.appealUpheld).to.be.false; + }); + + it("should block execution if appeal is pending", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + + await time.increase(APPEAL_WINDOW + 1); + + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AppealPending"); + }); + + it("should block execution if appeal was approved", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + await slashingManager.connect(owner).resolveAppeal(0, true, "Approved"); + + await time.increase(APPEAL_WINDOW + 1); + + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AppealUpheld"); + }); + + it("should allow execution if appeal was denied", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + await slashingManager.connect(owner).resolveAppeal(0, false, "Denied"); + + await time.increase(APPEAL_WINDOW + 1); + + await expect(slashingManager.executeSlash(0)).to.emit( + slashingManager, + "SlashExecuted", + ); + }); + }); + + describe("ban management", function () { + it("should allow governance to ban node", async function () { + const { slashingManager, owner, operatorAddress } = + await loadFixture(setup); + + const reason = ethers.encodeBytes32String("manual_ban"); + + await expect( + slashingManager + .connect(owner) + .updateBanStatus(operatorAddress, true, reason), + ) + .to.emit(slashingManager, "NodeBanUpdated") + .withArgs(operatorAddress, true, reason, await owner.getAddress()); + + expect(await slashingManager.isBanned(operatorAddress)).to.be.true; + }); + + it("should allow governance to unban node", async function () { + const { slashingManager, owner, operatorAddress } = + await loadFixture(setup); + + await slashingManager + .connect(owner) + .updateBanStatus( + operatorAddress, + true, + ethers.encodeBytes32String("test"), + ); + expect(await slashingManager.isBanned(operatorAddress)).to.be.true; + + await expect( + slashingManager + .connect(owner) + .updateBanStatus( + operatorAddress, + false, + ethers.encodeBytes32String("test"), + ), + ) + .to.emit(slashingManager, "NodeBanUpdated") + .withArgs( + operatorAddress, + false, + ethers.encodeBytes32String("test"), + await owner.getAddress(), + ); + + expect(await slashingManager.isBanned(operatorAddress)).to.be.false; + }); + + it("should revert if non-governance tries to ban", async function () { + const { slashingManager, notTheOwner, operatorAddress } = + await loadFixture(setup); + + await expect( + slashingManager + .connect(notTheOwner) + .updateBanStatus( + operatorAddress, + false, + ethers.encodeBytes32String("test"), + ), + ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); + }); + }); + + describe("view functions", function () { + it("should return correct slash policy", async function () { + const { slashingManager, mockVerifier } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: true, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy); + + const retrieved = + await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); + expect(retrieved.ticketPenalty).to.equal(policy.ticketPenalty); + expect(retrieved.licensePenalty).to.equal(policy.licensePenalty); + expect(retrieved.requiresProof).to.equal(policy.requiresProof); + expect(retrieved.proofVerifier).to.equal(policy.proofVerifier); + expect(retrieved.banNode).to.equal(policy.banNode); + expect(retrieved.appealWindow).to.equal(policy.appealWindow); + expect(retrieved.enabled).to.equal(policy.enabled); + expect(retrieved.affectsCommittee).to.equal(policy.affectsCommittee); + expect(retrieved.failureReason).to.equal(policy.failureReason); + }); + + it("should return correct slash proposal", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const proof = encodeProof("0x4444"); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.operator).to.equal(operatorAddress); + expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); + expect(proposal.ticketAmount).to.equal(ethers.parseUnits("50", 6)); + expect(proposal.licenseAmount).to.equal(ethers.parseEther("100")); + expect(proposal.proposer).to.equal(await proposer.getAddress()); + expect(proposal.proofHash).to.equal(ethers.keccak256(proof)); + expect(proposal.proofVerified).to.be.true; + expect(proposal.executed).to.be.true; + }); + + it("should revert for invalid proposal ID", async function () { + const { slashingManager } = await loadFixture(setup); + + await expect( + slashingManager.getSlashProposal(999), + ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); + }); + }); +}); From f27a5fe489e704612cdd60f75e2d89c75684763c Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 15 Feb 2026 14:18:54 +0500 Subject: [PATCH 06/32] feat: slashing manager in cn --- .../src/ciphernode_builder.rs | 40 +- crates/config/src/contract.rs | 2 + .../entrypoint/src/start/aggregator_start.rs | 1 + crates/entrypoint/src/start/start.rs | 1 + crates/events/src/enclave_event/mod.rs | 8 + .../src/enclave_event/slash_executed.rs | 72 ++ crates/evm/src/ciphernode_registry_sol.rs | 33 + crates/evm/src/lib.rs | 4 + crates/evm/src/slashing_manager_sol_reader.rs | 54 ++ crates/evm/src/slashing_manager_sol_writer.rs | 189 ++++ .../test/Slashing/CommitteeExpulsion.spec.ts | 909 ++++++++++++++++++ 11 files changed, 1312 insertions(+), 1 deletion(-) create mode 100644 crates/events/src/enclave_event/slash_executed.rs create mode 100644 crates/evm/src/slashing_manager_sol_reader.rs create mode 100644 crates/evm/src/slashing_manager_sol_writer.rs create mode 100644 packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts diff --git a/crates/ciphernode-builder/src/ciphernode_builder.rs b/crates/ciphernode-builder/src/ciphernode_builder.rs index 4c0dc5ecd7..d4d1e14f58 100644 --- a/crates/ciphernode-builder/src/ciphernode_builder.rs +++ b/crates/ciphernode-builder/src/ciphernode_builder.rs @@ -17,7 +17,9 @@ use e3_crypto::Cipher; use e3_data::{InMemStore, RepositoriesFactory}; use e3_events::{AggregateId, BusHandle, EnclaveEvent, EventBus, EventBusConfig, EvmEventConfig}; use e3_evm::{BondingRegistrySolReader, CiphernodeRegistrySolReader, EnclaveSolWriter}; -use e3_evm::{CiphernodeRegistrySol, EnclaveSolReader}; +use e3_evm::{ + CiphernodeRegistrySol, EnclaveSolReader, SlashingManagerSolReader, SlashingManagerSolWriter, +}; use e3_fhe::ext::FheExtension; use e3_fhe_params::BfvPreset; use e3_keyshare::ext::ThresholdKeyshareExtension; @@ -93,6 +95,7 @@ pub struct ContractComponents { enclave: bool, ciphernode_registry: bool, bonding_registry: bool, + slashing_manager: bool, } #[derive(Clone, Debug)] @@ -300,6 +303,13 @@ impl CiphernodeBuilder { self } + /// Setup a SlashingManager writer for submitting slash proposals on-chain. + /// Requires the `slashing_manager` contract address to be configured. + pub fn with_contract_slashing_manager(mut self) -> Self { + self.contract_components.slashing_manager = true; + self + } + /// Setup net package components. pub fn with_net(mut self, peers: Vec, quic_port: u16) -> Self { self.net_config = Some(NetConfig::new(peers, quic_port)); @@ -666,6 +676,34 @@ async fn setup_evm_system( ) } } + + if contract_components.slashing_manager { + if let Some(contract) = &chain.contracts.slashing_manager { + // Reader: read SlashExecuted events from chain + let contract_addr = contract.address()?; + system.with_contract(contract_addr, move |next| { + SlashingManagerSolReader::setup(&next).recipient() + }); + + // Writer: submit proposeSlash transactions + match provider_cache.ensure_write_provider(&chain).await { + Ok(write_provider) => { + SlashingManagerSolWriter::attach( + &bus, + write_provider.clone(), + contract_addr, + ) + .await?; + info!("SlashingManagerSolWriter attached for fault submission"); + } + Err(e) => error!( + "Failed to create write provider for SlashingManager, skipping: {}", + e + ), + } + } + } + system.build(); } diff --git a/crates/config/src/contract.rs b/crates/config/src/contract.rs index 420d3c953c..32c856d2ad 100644 --- a/crates/config/src/contract.rs +++ b/crates/config/src/contract.rs @@ -48,6 +48,7 @@ pub struct ContractAddresses { pub bonding_registry: Contract, pub e3_program: Option, pub fee_token: Option, + pub slashing_manager: Option, } impl ContractAddresses { @@ -58,6 +59,7 @@ impl ContractAddresses { Some(&self.bonding_registry), self.e3_program.as_ref(), self.fee_token.as_ref(), + self.slashing_manager.as_ref(), ] .into_iter() .flatten() diff --git a/crates/entrypoint/src/start/aggregator_start.rs b/crates/entrypoint/src/start/aggregator_start.rs index 3032e43d0c..f94a5f871f 100644 --- a/crates/entrypoint/src/start/aggregator_start.rs +++ b/crates/entrypoint/src/start/aggregator_start.rs @@ -33,6 +33,7 @@ pub async fn execute( .with_contract_enclave_full() .with_contract_bonding_registry() .with_contract_ciphernode_registry() + .with_contract_slashing_manager() .with_max_threads() .with_pubkey_aggregation() .with_threshold_plaintext_aggregation() diff --git a/crates/entrypoint/src/start/start.rs b/crates/entrypoint/src/start/start.rs index b541a38d16..17f44c2d84 100644 --- a/crates/entrypoint/src/start/start.rs +++ b/crates/entrypoint/src/start/start.rs @@ -37,6 +37,7 @@ pub async fn execute(config: &AppConfig, address: Address) -> Result Some(data.e3_id.clone()), EnclaveEventData::ComputeResponse(ref data) => Some(data.e3_id.clone()), EnclaveEventData::SignedProofFailed(ref data) => Some(data.e3_id.clone()), + EnclaveEventData::SlashExecuted(ref data) => Some(data.e3_id.clone()), + EnclaveEventData::CommitteeMemberExpelled(ref data) => Some(data.e3_id.clone()), EnclaveEventData::E3Failed(ref data) => Some(data.e3_id.clone()), EnclaveEventData::E3StageChanged(ref data) => Some(data.e3_id.clone()), _ => None, @@ -510,6 +516,8 @@ impl_event_types!( ComputeResponse, ComputeRequestError, SignedProofFailed, + SlashExecuted, + CommitteeMemberExpelled, OutgoingSyncRequested, NetSyncEventsReceived, EvmSyncEventsReceived, diff --git a/crates/events/src/enclave_event/slash_executed.rs b/crates/events/src/enclave_event/slash_executed.rs new file mode 100644 index 0000000000..f19e1bc13b --- /dev/null +++ b/crates/events/src/enclave_event/slash_executed.rs @@ -0,0 +1,72 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! Events emitted by the SlashingManager contract and received on-chain. + +use crate::E3id; +use actix::Message; +use alloy::primitives::Address; +use serde::{Deserialize, Serialize}; +use std::fmt::{self, Display}; + +/// Emitted when a slash proposal is executed on-chain. +/// +/// This event is read from the SlashingManager contract logs. +/// The `CommitteeExpulsionHandler` reacts to this to update local committee state. +#[derive(Message, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[rtype(result = "()")] +pub struct SlashExecuted { + /// The E3 computation this slash relates to. + pub e3_id: E3id, + /// On-chain proposal ID. + pub proposal_id: u64, + /// Address of the slashed operator. + pub operator: Address, + /// Hash of the slash reason. + pub reason: [u8; 32], + /// Amount of ticket collateral slashed. + pub ticket_amount: u64, + /// Amount of license bond slashed. + pub license_amount: u64, +} + +impl Display for SlashExecuted { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "SlashExecuted {{ e3_id: {}, proposal_id: {}, operator: {} }}", + self.e3_id, self.proposal_id, self.operator + ) + } +} + +/// Emitted when a committee member is expelled from an E3 committee. +/// +/// Read from the CiphernodeRegistry contract logs after slashing triggers expulsion. +/// The `CommitteeExpulsionHandler` uses this to update the local committee view +/// and check viability (whether remaining active members >= threshold M). +#[derive(Message, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[rtype(result = "()")] +pub struct CommitteeMemberExpelled { + /// The E3 computation from which the member was expelled. + pub e3_id: E3id, + /// Address of the expelled committee member. + pub node: Address, + /// Hash of the slash reason that caused the expulsion. + pub reason: [u8; 32], + /// Number of active committee members remaining after expulsion. + pub active_count_after: u64, +} + +impl Display for CommitteeMemberExpelled { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "CommitteeMemberExpelled {{ e3_id: {}, node: {}, active_count_after: {} }}", + self.e3_id, self.node, self.active_count_after + ) + } +} diff --git a/crates/evm/src/ciphernode_registry_sol.rs b/crates/evm/src/ciphernode_registry_sol.rs index 456b63fd96..56e1f19ad3 100644 --- a/crates/evm/src/ciphernode_registry_sol.rs +++ b/crates/evm/src/ciphernode_registry_sol.rs @@ -157,6 +157,29 @@ impl From for EnclaveEventData { } } +struct CommitteeMemberExpelledWithChainId( + pub ICiphernodeRegistry::CommitteeMemberExpelled, + pub u64, +); + +impl From for e3_events::CommitteeMemberExpelled { + fn from(value: CommitteeMemberExpelledWithChainId) -> Self { + e3_events::CommitteeMemberExpelled { + e3_id: E3id::new(value.0.e3Id.to_string(), value.1), + node: value.0.node, + reason: value.0.reason.into(), + active_count_after: value.0.activeCountAfter.to(), + } + } +} + +impl From for EnclaveEventData { + fn from(value: CommitteeMemberExpelledWithChainId) -> Self { + let payload: e3_events::CommitteeMemberExpelled = value.into(); + EnclaveEventData::from(payload) + } +} + pub fn extractor(data: &LogData, topic: Option<&B256>, chain_id: u64) -> Option { match topic { Some(&ICiphernodeRegistry::CiphernodeAdded::SIGNATURE_HASH) => { @@ -204,6 +227,16 @@ pub fn extractor(data: &LogData, topic: Option<&B256>, chain_id: u64) -> Option< event, chain_id, ))) } + Some(&ICiphernodeRegistry::CommitteeMemberExpelled::SIGNATURE_HASH) => { + let Ok(event) = ICiphernodeRegistry::CommitteeMemberExpelled::decode_log_data(data) + else { + error!("Error parsing event CommitteeMemberExpelled after topic was matched!"); + return None; + }; + Some(EnclaveEventData::from(CommitteeMemberExpelledWithChainId( + event, chain_id, + ))) + } _topic => { trace!( topic=?_topic, diff --git a/crates/evm/src/lib.rs b/crates/evm/src/lib.rs index 47f8b45f31..9b9b5d4823 100644 --- a/crates/evm/src/lib.rs +++ b/crates/evm/src/lib.rs @@ -19,6 +19,8 @@ mod fix_historical_order; pub mod helpers; mod one_shot_runnner; mod repo; +mod slashing_manager_sol_reader; +mod slashing_manager_sol_writer; mod sync_start_extractor; pub use bonding_registry_sol::BondingRegistrySolReader; @@ -38,4 +40,6 @@ pub use fix_historical_order::*; pub use helpers::*; pub use one_shot_runnner::*; pub use repo::*; +pub use slashing_manager_sol_reader::SlashingManagerSolReader; +pub use slashing_manager_sol_writer::SlashingManagerSolWriter; pub use sync_start_extractor::*; diff --git a/crates/evm/src/slashing_manager_sol_reader.rs b/crates/evm/src/slashing_manager_sol_reader.rs new file mode 100644 index 0000000000..5d91d71e5e --- /dev/null +++ b/crates/evm/src/slashing_manager_sol_reader.rs @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! Reads `SlashExecuted` events from the SlashingManager contract on-chain +//! and converts them into `EnclaveEventData::SlashExecuted` events on the bus. + +use crate::{ + events::EvmEventProcessor, evm_parser::EvmParser, slashing_manager_sol_writer::ISlashingManager, +}; +use actix::{Actor, Addr}; +use alloy::{ + primitives::{LogData, B256}, + sol_types::SolEvent, +}; +use e3_events::{E3id, EnclaveEventData}; +use tracing::{error, trace}; + +pub fn extractor(data: &LogData, topic: Option<&B256>, chain_id: u64) -> Option { + match topic { + Some(&ISlashingManager::SlashExecuted::SIGNATURE_HASH) => { + let Ok(event) = ISlashingManager::SlashExecuted::decode_log_data(data) else { + error!("Error parsing event SlashExecuted after topic was matched!"); + return None; + }; + Some(EnclaveEventData::from(e3_events::SlashExecuted { + e3_id: E3id::new("0", chain_id), // SlashExecuted doesn't carry e3Id directly + proposal_id: event.proposalId.to(), + operator: event.operator, + reason: event.reason.into(), + ticket_amount: event.ticketAmount.to(), + license_amount: event.licenseAmount.to(), + })) + } + _topic => { + trace!( + topic=?_topic, + "Unknown event was received by SlashingManager.sol parser but was ignored" + ); + None + } + } +} + +/// Connects to SlashingManager.sol converting EVM events to EnclaveEvents +pub struct SlashingManagerSolReader; + +impl SlashingManagerSolReader { + pub fn setup(next: &EvmEventProcessor) -> Addr { + EvmParser::new(next, extractor).start() + } +} diff --git a/crates/evm/src/slashing_manager_sol_writer.rs b/crates/evm/src/slashing_manager_sol_writer.rs new file mode 100644 index 0000000000..f0a9428831 --- /dev/null +++ b/crates/evm/src/slashing_manager_sol_writer.rs @@ -0,0 +1,189 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! FaultSubmitter actor — subscribes to `SignedProofFailed` events and submits +//! `proposeSlash` transactions on the SlashingManager contract. +//! +//! When a ciphernode broadcasts a ZK proof that fails local verification, +//! the `ProofVerificationActor` emits a `SignedProofFailed` event carrying the +//! self-authenticating evidence (the signed proof payload). This actor consumes +//! that event, ABI-encodes the proof data, and calls `proposeSlash(e3Id, operator, +//! reason, proof)` on-chain. + +use crate::helpers::EthProvider; +use crate::send_tx_with_retry; +use actix::prelude::*; +use actix::Addr; +use alloy::{ + primitives::{keccak256, Address, Bytes, U256}, + providers::{Provider, WalletProvider}, + rpc::types::TransactionReceipt, + sol, + sol_types::SolValue, +}; +use anyhow::Result; +use e3_events::prelude::*; +use e3_events::BusHandle; +use e3_events::EnclaveEvent; +use e3_events::EnclaveEventData; +use e3_events::EventType; +use e3_events::Shutdown; +use e3_events::{EType, SignedProofFailed}; +use e3_utils::NotifySync; +use tracing::info; + +sol!( + #[sol(rpc)] + ISlashingManager, + "../../packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json" +); + +/// Consumes `SignedProofFailed` events and submits slash proposals on-chain. +pub struct SlashingManagerSolWriter

{ + provider: EthProvider

, + contract_address: Address, + bus: BusHandle, +} + +impl SlashingManagerSolWriter

{ + pub fn new( + bus: &BusHandle, + provider: EthProvider

, + contract_address: Address, + ) -> Result { + Ok(Self { + provider, + contract_address, + bus: bus.clone(), + }) + } + + pub async fn attach( + bus: &BusHandle, + provider: EthProvider

, + contract_address: Address, + ) -> Result>> { + let addr = SlashingManagerSolWriter::new(bus, provider, contract_address)?.start(); + bus.subscribe_all( + &[EventType::SignedProofFailed, EventType::Shutdown], + addr.clone().into(), + ); + Ok(addr) + } +} + +impl Actor for SlashingManagerSolWriter

{ + type Context = actix::Context; +} + +impl Handler + for SlashingManagerSolWriter

+{ + type Result = (); + + fn handle(&mut self, msg: EnclaveEvent, ctx: &mut Self::Context) -> Self::Result { + match msg.into_data() { + EnclaveEventData::SignedProofFailed(data) => { + // Only submit if the chain matches + if self.provider.chain_id() == data.e3_id.chain_id() { + ctx.notify(data); + } + } + EnclaveEventData::Shutdown(data) => self.notify_sync(ctx, data), + _ => (), + } + } +} + +impl Handler + for SlashingManagerSolWriter

+{ + type Result = ResponseFuture<()>; + + fn handle(&mut self, msg: SignedProofFailed, _: &mut Self::Context) -> Self::Result { + Box::pin({ + let contract_address = self.contract_address; + let provider = self.provider.clone(); + let bus = self.bus.clone(); + async move { + let result = submit_slash_proposal(provider, contract_address, msg).await; + match result { + Ok(receipt) => { + info!(tx=%receipt.transaction_hash, "Submitted slash proposal on-chain"); + } + Err(err) => { + bus.err( + EType::Evm, + anyhow::anyhow!("Error submitting slash proposal: {:?}", err), + ); + } + } + } + }) + } +} + +impl Handler + for SlashingManagerSolWriter

+{ + type Result = (); + + fn handle(&mut self, _: Shutdown, ctx: &mut Self::Context) -> Self::Result { + ctx.stop(); + } +} + +async fn submit_slash_proposal( + provider: EthProvider

, + contract_address: Address, + data: SignedProofFailed, +) -> Result { + let e3_id: U256 = data.e3_id.clone().try_into()?; + let operator = data.faulting_node; + let reason = keccak256(data.proof_type.slash_reason().as_bytes()); + + // Encode the proof as (bytes zkProof, bytes32[] publicInputs) per SlashingManager.proposeSlash + let zk_proof = Bytes::copy_from_slice(&data.signed_payload.payload.proof.data); + let public_inputs_bytes = &data.signed_payload.payload.proof.public_signals; + + // Convert public signals to bytes32[] — each 32-byte chunk is one element + let mut public_inputs: Vec<[u8; 32]> = Vec::new(); + for chunk in public_inputs_bytes.chunks(32) { + let mut padded = [0u8; 32]; + let start = 32 - chunk.len(); + padded[start..].copy_from_slice(chunk); + public_inputs.push(padded); + } + + // abi.encode(bytes, bytes32[]) + let proof_data = (zk_proof, public_inputs).abi_encode(); + + let from_address = provider.provider().default_signer_address(); + let current_nonce = provider + .provider() + .get_transaction_count(from_address) + .pending() + .await?; + + // DuplicateEvidence() = keccak256("DuplicateEvidence()")[:4] – retry if not yet on-chain + send_tx_with_retry("proposeSlash", &[], || { + info!( + "proposeSlash() e3_id={:?} operator={:?} reason={:?}", + e3_id, operator, reason + ); + let proof = Bytes::from(proof_data.clone()); + let contract = ISlashingManager::new(contract_address, provider.provider()); + + async move { + let builder = contract + .proposeSlash(e3_id, operator, reason.into(), proof) + .nonce(current_nonce); + let receipt = builder.send().await?.get_receipt().await?; + Ok(receipt) + } + }) + .await +} diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts new file mode 100644 index 0000000000..ca98e296f6 --- /dev/null +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -0,0 +1,909 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +/** + * Tests for committee expulsion, viability checks, and E3 failure on threshold breach. + * + * Verifies: + * - Committee members are expelled via proposeSlash when affectsCommittee=true + * - The E3 continues as long as active members >= threshold M + * - The E3 fails when active members drop below threshold M + * - Rewards exclude expelled members + * - Idempotent expulsion (re-slashing same node doesn't double-count) + */ +import { expect } from "chai"; +import type { Signer } from "ethers"; +import { network } from "hardhat"; + +import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; +import CiphernodeRegistryModule from "../../ignition/modules/ciphernodeRegistry"; +import EnclaveModule from "../../ignition/modules/enclave"; +import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; +import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; +import MockCircuitVerifierModule from "../../ignition/modules/mockSlashingVerifier"; +import MockE3ProgramModule from "../../ignition/modules/mockE3Program"; +import MockDecryptionVerifierModule from "../../ignition/modules/mockDecryptionVerifier"; +import MockStableTokenModule from "../../ignition/modules/mockStableToken"; +import SlashingManagerModule from "../../ignition/modules/slashingManager"; +import { + BondingRegistry__factory as BondingRegistryFactory, + CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnableFactory, + Enclave__factory as EnclaveFactory, + EnclaveTicketToken__factory as EnclaveTicketTokenFactory, + EnclaveToken__factory as EnclaveTokenFactory, + MockCircuitVerifier__factory as MockCircuitVerifierFactory, + MockUSDC__factory as MockUSDCFactory, + MockE3Program__factory as MockE3ProgramFactory, + MockDecryptionVerifier__factory as MockDecryptionVerifierFactory, + SlashingManager__factory as SlashingManagerFactory, +} from "../../types"; + +const { ethers, ignition, networkHelpers } = await network.connect(); +const { loadFixture, time } = networkHelpers; + +describe("Committee Expulsion & Fault Tolerance", function () { + const ONE_HOUR = 60 * 60; + const ONE_DAY = 24 * ONE_HOUR; + const THREE_DAYS = 3 * ONE_DAY; + const SEVEN_DAYS = 7 * ONE_DAY; + const THIRTY_DAYS = 30 * ONE_DAY; + const SORTITION_SUBMISSION_WINDOW = 10; + const addressOne = "0x0000000000000000000000000000000000000001"; + + const REASON_BAD_DKG = ethers.keccak256( + ethers.toUtf8Bytes("E3_BAD_DKG_PROOF"), + ); + const REASON_BAD_DECRYPTION = ethers.keccak256( + ethers.toUtf8Bytes("E3_BAD_DECRYPTION_PROOF"), + ); + + const abiCoder = ethers.AbiCoder.defaultAbiCoder(); + const polynomial_degree = ethers.toBigInt(2048); + const plaintext_modulus = ethers.toBigInt(1032193); + const moduli = [ethers.toBigInt("18014398492704769")]; + + const encodedE3ProgramParams = abiCoder.encode( + ["uint256", "uint256", "uint256[]"], + [polynomial_degree, plaintext_modulus, moduli], + ); + + const encryptionSchemeId = + "0x2c2a814a0495f913a3a312fc4771e37552bc14f8a2d4075a08122d356f0849c6"; + + const defaultTimeoutConfig = { + committeeFormationWindow: ONE_DAY, + dkgWindow: ONE_DAY, + computeWindow: THREE_DAYS, + decryptionWindow: ONE_DAY, + gracePeriod: ONE_HOUR, + }; + + function encodeProof( + zkProof: string = "0x1234", + publicInputs: string[] = [ethers.ZeroHash], + ): string { + return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); + } + + const setup = async () => { + const [ + owner, + requester, + treasury, + operator1, + operator2, + operator3, + operator4, + ] = await ethers.getSigners(); + + const ownerAddress = await owner.getAddress(); + const treasuryAddress = await treasury.getAddress(); + const requesterAddress = await requester.getAddress(); + + // Deploy tokens + const usdcContract = await ignition.deploy(MockStableTokenModule, { + parameters: { MockUSDC: { initialSupply: 10000000 } }, + }); + const usdcToken = MockUSDCFactory.connect( + await usdcContract.mockUSDC.getAddress(), + owner, + ); + + const enclTokenContract = await ignition.deploy(EnclaveTokenModule, { + parameters: { EnclaveToken: { owner: ownerAddress } }, + }); + const enclToken = EnclaveTokenFactory.connect( + await enclTokenContract.enclaveToken.getAddress(), + owner, + ); + await enclToken.setTransferRestriction(false); + + const ticketTokenContract = await ignition.deploy( + EnclaveTicketTokenModule, + { + parameters: { + EnclaveTicketToken: { + baseToken: await usdcToken.getAddress(), + registry: addressOne, + owner: ownerAddress, + }, + }, + }, + ); + + const mockVerifierContract = await ignition.deploy( + MockCircuitVerifierModule, + ); + const mockVerifier = MockCircuitVerifierFactory.connect( + await mockVerifierContract.mockCircuitVerifier.getAddress(), + owner, + ); + + // Deploy slashing manager + const slashingManagerContract = await ignition.deploy( + SlashingManagerModule, + { + parameters: { + SlashingManager: { + admin: ownerAddress, + bondingRegistry: addressOne, + ciphernodeRegistry: addressOne, + enclave: addressOne, + }, + }, + }, + ); + const slashingManager = SlashingManagerFactory.connect( + await slashingManagerContract.slashingManager.getAddress(), + owner, + ); + + // Deploy bonding registry + const bondingRegistryContract = await ignition.deploy( + BondingRegistryModule, + { + parameters: { + BondingRegistry: { + owner: ownerAddress, + ticketToken: + await ticketTokenContract.enclaveTicketToken.getAddress(), + licenseToken: await enclToken.getAddress(), + registry: addressOne, + slashedFundsTreasury: treasuryAddress, + ticketPrice: ethers.parseUnits("10", 6), + licenseRequiredBond: ethers.parseEther("1000"), + minTicketBalance: 1, + exitDelay: SEVEN_DAYS, + }, + }, + }, + ); + const bondingRegistry = BondingRegistryFactory.connect( + await bondingRegistryContract.bondingRegistry.getAddress(), + owner, + ); + + // Deploy Enclave + const enclaveContract = await ignition.deploy(EnclaveModule, { + parameters: { + Enclave: { + params: encodedE3ProgramParams, + owner: ownerAddress, + maxDuration: THIRTY_DAYS, + registry: addressOne, + e3RefundManager: addressOne, + bondingRegistry: await bondingRegistry.getAddress(), + feeToken: await usdcToken.getAddress(), + timeoutConfig: defaultTimeoutConfig, + }, + }, + }); + const enclaveAddress = await enclaveContract.enclave.getAddress(); + const enclave = EnclaveFactory.connect(enclaveAddress, owner); + + // Deploy CiphernodeRegistry + const ciphernodeRegistryContract = await ignition.deploy( + CiphernodeRegistryModule, + { + parameters: { + CiphernodeRegistry: { + enclaveAddress: enclaveAddress, + owner: ownerAddress, + submissionWindow: SORTITION_SUBMISSION_WINDOW, + }, + }, + }, + ); + const registryAddress = + await ciphernodeRegistryContract.cipherNodeRegistry.getAddress(); + const registry = CiphernodeRegistryOwnableFactory.connect( + registryAddress, + owner, + ); + + // Deploy mock E3 program + const e3ProgramContract = await ignition.deploy(MockE3ProgramModule, { + parameters: { + MockE3Program: { + encryptionSchemeId: encryptionSchemeId, + }, + }, + }); + const e3Program = MockE3ProgramFactory.connect( + await e3ProgramContract.mockE3Program.getAddress(), + owner, + ); + + // Deploy mock decryption verifier + const decryptionVerifierContract = await ignition.deploy( + MockDecryptionVerifierModule, + ); + const decryptionVerifier = MockDecryptionVerifierFactory.connect( + await decryptionVerifierContract.mockDecryptionVerifier.getAddress(), + owner, + ); + + // Wire everything together + await enclave.setCiphernodeRegistry(registryAddress); + await enclave.enableE3Program(await e3Program.getAddress()); + await enclave.setDecryptionVerifier( + encryptionSchemeId, + await decryptionVerifier.getAddress(), + ); + await enclave.setSlashingManager(await slashingManager.getAddress()); + + await bondingRegistry.setRewardDistributor(enclaveAddress); + await bondingRegistry.setRegistry(registryAddress); + await bondingRegistry.setSlashingManager( + await slashingManager.getAddress(), + ); + + await slashingManager.setBondingRegistry( + await bondingRegistry.getAddress(), + ); + await slashingManager.setCiphernodeRegistry(registryAddress); + await slashingManager.setEnclave(enclaveAddress); + + await registry.setBondingRegistry(await bondingRegistry.getAddress()); + await registry.setSlashingManager(await slashingManager.getAddress()); + + await ticketTokenContract.enclaveTicketToken.setRegistry( + await bondingRegistry.getAddress(), + ); + + // Mint tokens to requester for E3 requests + await usdcToken.mint(requesterAddress, ethers.parseUnits("100000", 6)); + + // Helper: setup an operator (bond license, register, add tickets) + async function setupOperator(operator: Signer) { + const operatorAddress = await operator.getAddress(); + await enclToken.mintAllocation( + operatorAddress, + ethers.parseEther("10000"), + "Test allocation", + ); + await usdcToken.mint(operatorAddress, ethers.parseUnits("100000", 6)); + + await enclToken + .connect(operator) + .approve(await bondingRegistry.getAddress(), ethers.parseEther("2000")); + await bondingRegistry + .connect(operator) + .bondLicense(ethers.parseEther("1000")); + await bondingRegistry.connect(operator).registerOperator(); + + const ticketTokenAddress = await bondingRegistry.ticketToken(); + const ticketAmount = ethers.parseUnits("100", 6); + await usdcToken + .connect(operator) + .approve(ticketTokenAddress, ticketAmount); + await bondingRegistry.connect(operator).addTicketBalance(ticketAmount); + } + + // Helper: make an E3 request + async function makeRequest(threshold: [number, number] = [2, 3]) { + const startTime = (await time.latest()) + 100; + const requestParams = { + threshold: threshold, + inputWindow: [startTime + 100, startTime + ONE_DAY] as [ + number, + number, + ], + e3Program: await e3Program.getAddress(), + e3ProgramParams: encodedE3ProgramParams, + computeProviderParams: abiCoder.encode( + ["address"], + [await decryptionVerifier.getAddress()], + ), + customParams: abiCoder.encode( + ["address"], + ["0x1234567890123456789012345678901234567890"], + ), + }; + + const fee = await enclave.getE3Quote(requestParams); + await usdcToken.connect(requester).approve(enclaveAddress, fee); + await enclave.connect(requester).request(requestParams); + } + + // Helper: finalize a committee after sortition + async function finalizeCommitteeWithOperators( + e3Id: number, + operators: Signer[], + ) { + for (const op of operators) { + await registry.connect(op).submitTicket(e3Id, 1); + } + await time.increase(SORTITION_SUBMISSION_WINDOW + 1); + await registry.finalizeCommittee(e3Id); + } + + // Set up committee-affecting slash policy + // MockCircuitVerifier returns false by default → proof invalid → fault confirmed + const committeeSlashPolicy = { + ticketPenalty: ethers.parseUnits("10", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: true, + failureReason: 4, // FailureReason.DKGInvalidShares + }; + await slashingManager.setSlashPolicy(REASON_BAD_DKG, committeeSlashPolicy); + + const decryptionSlashPolicy = { + ticketPenalty: ethers.parseUnits("10", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: true, + failureReason: 11, // FailureReason.DecryptionInvalidShares + }; + await slashingManager.setSlashPolicy( + REASON_BAD_DECRYPTION, + decryptionSlashPolicy, + ); + + return { + enclave, + registry, + slashingManager, + bondingRegistry, + mockVerifier, + usdcToken, + enclToken, + owner, + requester, + treasury, + operator1, + operator2, + operator3, + operator4, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + }; + }; + + describe("committee expulsion via proposeSlash", function () { + it("should expel a committee member and emit CommitteeMemberExpelled", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + // threshold [2, 3] means M=2, N=3 + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + const op1Address = await operator1.getAddress(); + + // Verify member is active before slash + expect(await registry.isCommitteeMemberActive(0, op1Address)).to.be.true; + expect(await registry.getActiveCommitteeCount(0)).to.equal(3); + + // Submit slash proposal — MockCircuitVerifier returns false by default + // so fault is confirmed and slash is auto-executed + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + op1Address, + REASON_BAD_DKG, + proof, + ); + + // Should emit CommitteeMemberExpelled + await expect(tx) + .to.emit(registry, "CommitteeMemberExpelled") + .withArgs(0, op1Address, REASON_BAD_DKG, 2); + + // Should emit CommitteeViabilityUpdated + await expect(tx) + .to.emit(registry, "CommitteeViabilityUpdated") + .withArgs(0, 2, 2, true); // 2 >= 2 → viable + + // Verify member is no longer active + expect(await registry.isCommitteeMemberActive(0, op1Address)).to.be.false; + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + }); + + it("should keep E3 alive when active members >= threshold", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + // Slash one member — 3 active → 2 active, threshold is 2, still viable + const proof = encodeProof(); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // E3 should NOT be failed — stage should still be Requested (1) + // or whatever stage it was at, not Failed + const stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); // 6 = E3Stage.Failed + }); + + it("should fail E3 when active members drop below threshold", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + // Slash first member — 3 → 2 active, still >= 2 + const proof1 = encodeProof("0x1111"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + + let stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); // Not failed yet + + // Slash second member — 2 → 1 active, below threshold M=2 + const proof2 = encodeProof("0x2222"); + const tx = await slashingManager.proposeSlash( + 0, + await operator2.getAddress(), + REASON_BAD_DKG, + proof2, + ); + + // Should emit E3Failed event + await expect(tx).to.emit(enclave, "E3Failed"); + + // E3 should now be Failed + stage = await enclave.getE3Stage(0); + expect(stage).to.equal(6); // E3Stage.Failed + + // Failure reason should be DKGInvalidShares (4) + const reason = await enclave.getFailureReason(0); + expect(reason).to.equal(4); + }); + + it("should handle idempotent expulsion (re-slashing same node)", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + // Slash operator1 once + const proof1 = encodeProof("0xaaaa"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + + // Slash operator1 again with different proof (different evidence key) + const proof2 = encodeProof("0xbbbb"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof2, + ); + + // Active count should still be 2 (idempotent expulsion) + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + }); + + it("should exclude expelled members from getActiveCommitteeNodes", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + // Before expulsion: all 3 should be in active nodes + const nodesBefore = await registry.getActiveCommitteeNodes(0); + expect(nodesBefore.length).to.equal(3); + expect(nodesBefore).to.include(await operator1.getAddress()); + + // Expel operator1 + const proof = encodeProof(); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // After expulsion: only 2 should be active + const nodesAfter = await registry.getActiveCommitteeNodes(0); + expect(nodesAfter.length).to.equal(2); + expect(nodesAfter).to.not.include(await operator1.getAddress()); + expect(nodesAfter).to.include(await operator2.getAddress()); + expect(nodesAfter).to.include(await operator3.getAddress()); + }); + }); + + describe("E3 continues above threshold", function () { + it("should allow the E3 lifecycle to progress despite expelled member", async function () { + const { + enclave, + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + // Expel one member + const proof = encodeProof(); + await slashingManager.proposeSlash( + 0, + await operator3.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // E3 should still be alive (not failed) + const stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); // Not E3Stage.Failed + + // Active committee still has enough members + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + const threshold = await registry.getCommitteeThreshold(0); + expect(threshold[0]).to.equal(2); // M=2 + }); + + it("should allow multiple expulsions while staying above threshold", async function () { + const { + enclave, + registry, + slashingManager, + operator1, + operator2, + operator3, + operator4, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + await setupOperator(operator4); + + await makeRequest([2, 4]); // M=2, N=4 + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + operator4, + ]); + + expect(await registry.getActiveCommitteeCount(0)).to.equal(4); + + // Expel 2 out of 4 — still have 2 >= M=2 + const proof1 = encodeProof("0x1111"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + expect(await registry.getActiveCommitteeCount(0)).to.equal(3); + + const proof2 = encodeProof("0x2222"); + await slashingManager.proposeSlash( + 0, + await operator2.getAddress(), + REASON_BAD_DKG, + proof2, + ); + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + + // E3 should NOT be failed + const stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); + }); + }); + + describe("E3 fails below threshold", function () { + it("should fail E3 exactly at the threshold breach", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + + await makeRequest([2, 2]); // M=2, N=2 — no room for error + await finalizeCommitteeWithOperators(0, [operator1, operator2]); + + // Expel one member: 2 → 1 < M=2 → E3 fails immediately + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + await expect(tx).to.emit(enclave, "E3Failed"); + + const stage = await enclave.getE3Stage(0); + expect(stage).to.equal(6); // Failed + }); + + it("should not fail E3 twice on multiple sub-threshold expulsions", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + // Expel operator1 — still viable (2 >= 2) + const proof1 = encodeProof("0x1111"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + + // Expel operator2 — now below threshold (1 < 2), E3 fails + const proof2 = encodeProof("0x2222"); + await slashingManager.proposeSlash( + 0, + await operator2.getAddress(), + REASON_BAD_DKG, + proof2, + ); + + // E3 is now Failed + const stage = await enclave.getE3Stage(0); + expect(stage).to.equal(6); + + // Try to expel operator3 — E3 already failed so onE3Failed should revert + // but expelCommitteeMember itself should still work (idempotent-ish) + const proof3 = encodeProof("0x3333"); + + // This should revert because the E3 is already in Failed state + // and onE3Failed will revert with E3AlreadyFailed + await expect( + slashingManager.proposeSlash( + 0, + await operator3.getAddress(), + REASON_BAD_DKG, + proof3, + ), + ).to.be.revertedWithCustomError(enclave, "E3AlreadyFailed"); + }); + }); + + describe("viability events", function () { + it("should emit CommitteeViabilityUpdated(viable=true) when still above threshold", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // 3 → 2 active, M=2 → viable + await expect(tx) + .to.emit(registry, "CommitteeViabilityUpdated") + .withArgs(0, 2, 2, true); + }); + + it("should emit CommitteeViabilityUpdated(viable=false) when below threshold", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + + await makeRequest([2, 2]); + await finalizeCommitteeWithOperators(0, [operator1, operator2]); + + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // 2 → 1 active, M=2 → not viable + await expect(tx) + .to.emit(registry, "CommitteeViabilityUpdated") + .withArgs(0, 1, 2, false); + }); + }); + + describe("slash execution events", function () { + it("should emit SlashExecuted on proof-based committee slash", async function () { + const { + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); + + const proof = encodeProof(); + const op1Addr = await operator1.getAddress(); + const tx = await slashingManager.proposeSlash( + 0, + op1Addr, + REASON_BAD_DKG, + proof, + ); + + await expect(tx) + .to.emit(slashingManager, "SlashExecuted") + .withArgs( + 0, // proposalId + op1Addr, + REASON_BAD_DKG, + ethers.parseUnits("10", 6), // ticketPenalty + ethers.parseEther("50"), // licensePenalty + true, // executed + ); + }); + }); +}); From 1377debea219f5f96d5d34326da51b527a3b0b2a Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 15 Feb 2026 15:19:18 +0500 Subject: [PATCH 07/32] feat: expel node from committee after slashing --- .../src/keyshare_created_filter_buffer.rs | 10 ++ crates/aggregator/src/publickey_aggregator.rs | 69 ++++++++++++ .../keyshare/src/encryption_key_collector.rs | 70 +++++++++++- crates/keyshare/src/lib.rs | 4 +- crates/keyshare/src/threshold_keyshare.rs | 100 ++++++++++++++++-- .../keyshare/src/threshold_share_collector.rs | 68 +++++++++++- .../src/actors/proof_verification.rs | 32 +++--- 7 files changed, 324 insertions(+), 29 deletions(-) diff --git a/crates/aggregator/src/keyshare_created_filter_buffer.rs b/crates/aggregator/src/keyshare_created_filter_buffer.rs index eea8edd67c..f6cef6fe01 100644 --- a/crates/aggregator/src/keyshare_created_filter_buffer.rs +++ b/crates/aggregator/src/keyshare_created_filter_buffer.rs @@ -69,6 +69,16 @@ impl Handler for KeyshareCreatedFilterBuffer { self.committee = Some(data.committee.iter().cloned().collect()); self.process_buffered_events(); } + EnclaveEventData::CommitteeMemberExpelled(data) => { + // Remove the expelled node from our committee set so we don't + // forward any late KeyshareCreated events from them + if let Some(ref mut committee) = self.committee { + let node_addr = format!("{:?}", data.node); + committee.remove(&node_addr); + } + // Forward to PublicKeyAggregator for threshold_n adjustment + self.dest.do_send(msg); + } _ => { // forward all other events self.dest.do_send(msg); diff --git a/crates/aggregator/src/publickey_aggregator.rs b/crates/aggregator/src/publickey_aggregator.rs index 1b36c91ad3..f456b62c64 100644 --- a/crates/aggregator/src/publickey_aggregator.rs +++ b/crates/aggregator/src/publickey_aggregator.rs @@ -137,6 +137,48 @@ impl PublicKeyAggregator { }) }) } + + /// Handle a committee member being expelled by reducing the expected + /// keyshare count. If enough keyshares have already been collected, + /// transition to the Computing state. + pub fn handle_member_expelled( + &mut self, + node: &str, + ec: &EventContext, + ) -> Result<()> { + self.state.try_mutate(ec, |mut state| { + let PublicKeyAggregatorState::Collecting { + threshold_n, + keyshares, + nodes, + .. + } = &mut state + else { + // Not in collecting state — nothing to adjust + return Ok(state); + }; + + // Reduce expected count + if *threshold_n > 0 { + *threshold_n -= 1; + info!( + "PublicKeyAggregator: reduced threshold_n to {} after expelling {}", + threshold_n, node + ); + } + + // Check if we now have enough keyshares + if keyshares.len() == *threshold_n && *threshold_n > 0 { + info!("PublicKeyAggregator: enough keyshares after expulsion, computing aggregate"); + return Ok(PublicKeyAggregatorState::Computing { + keyshares: std::mem::take(keyshares), + nodes: std::mem::take(nodes), + }); + } + + Ok(state) + }) + } } impl Actor for PublicKeyAggregator { @@ -155,6 +197,33 @@ impl Handler for PublicKeyAggregator { self.notify_sync(ctx, TypedEvent::new(data, ec)) } EnclaveEventData::E3RequestComplete(_) => self.notify_sync(ctx, Die), + EnclaveEventData::CommitteeMemberExpelled(data) => { + let node_addr = format!("{:?}", data.node); + info!( + "PublicKeyAggregator: committee member expelled: {} for e3_id={}", + node_addr, data.e3_id + ); + trap(EType::PublickeyAggregation, &self.bus.with_ec(&ec), || { + self.handle_member_expelled(&node_addr, &ec)?; + + // If the state transitioned to Computing, trigger aggregation + if let Some(PublicKeyAggregatorState::Computing { keyshares, .. }) = + &self.state.get() + { + self.notify_sync( + ctx, + TypedEvent::new( + ComputeAggregate { + keyshares: keyshares.clone(), + e3_id: data.e3_id, + }, + ec.clone(), + ), + ); + } + Ok(()) + }); + } _ => (), }; } diff --git a/crates/keyshare/src/encryption_key_collector.rs b/crates/keyshare/src/encryption_key_collector.rs index 15d5ef5d81..76f19aa04e 100644 --- a/crates/keyshare/src/encryption_key_collector.rs +++ b/crates/keyshare/src/encryption_key_collector.rs @@ -12,7 +12,8 @@ use std::{ use actix::{Actor, ActorContext, Addr, AsyncContext, Handler, Message, SpawnHandle}; use e3_events::{ - E3id, EncryptionKey, EncryptionKeyCollectionFailed, EncryptionKeyCreated, TypedEvent, + E3id, EncryptionKey, EncryptionKeyCollectionFailed, EncryptionKeyCreated, EventContext, + Sequenced, TypedEvent, }; use e3_trbfv::PartyId; use e3_utils::MAILBOX_LIMIT; @@ -57,10 +58,23 @@ impl From>> for AllEncryptionKeysCollected { #[rtype(result = "()")] pub struct EncryptionKeyCollectionTimeout; +/// Message sent when a committee member has been expelled (slashed on-chain). +/// +/// The collector removes this party from its `todo` set so the DKG can +/// complete with N-1 keys instead of waiting for a key that will never arrive. +#[derive(Message, Clone, Debug)] +#[rtype(result = "()")] +pub struct ExpelPartyFromKeyCollection { + pub party_id: PartyId, + pub ec: EventContext, +} + /// Actor that collects BFV encryption keys from all parties. /// /// Once all keys are collected, it sends `AllEncryptionKeysCollected` to the parent /// `ThresholdKeyshare` actor. If collection times out, it sends `EncryptionKeyCollectionFailed`. +/// If a party is expelled (slashed), it is removed from the expected set so the +/// collection can complete with N-1 parties. pub struct EncryptionKeyCollector { e3_id: E3id, todo: HashSet, @@ -198,3 +212,57 @@ impl Handler for EncryptionKeyCollector { ctx.stop(); } } + +impl Handler for EncryptionKeyCollector { + type Result = (); + fn handle( + &mut self, + msg: ExpelPartyFromKeyCollection, + ctx: &mut Self::Context, + ) -> Self::Result { + // Only handle if we're still collecting + if !matches!(self.state, CollectorState::Collecting) { + return; + } + + let party_id = msg.party_id; + + // Remove expelled party from the todo set + if !self.todo.remove(&party_id) { + info!( + e3_id = %self.e3_id, + party_id = party_id, + "Expelled party {} was not in todo set (already received or unknown)", + party_id + ); + return; + } + + info!( + e3_id = %self.e3_id, + party_id = party_id, + remaining = self.todo.len(), + "Removed expelled party {} from encryption key collection, {} remaining", + party_id, + self.todo.len() + ); + + // Check if all remaining keys have been collected + if self.todo.is_empty() { + info!( + e3_id = %self.e3_id, + "All remaining encryption keys collected after party expulsion!" + ); + self.state = CollectorState::Finished; + + // Cancel the timeout since we're done + if let Some(handle) = self.timeout_handle.take() { + ctx.cancel_future(handle); + } + + let event: TypedEvent = + TypedEvent::new(self.keys.clone().into(), msg.ec.clone()); + self.parent.do_send(event); + } + } +} diff --git a/crates/keyshare/src/lib.rs b/crates/keyshare/src/lib.rs index c9d9c80cd9..50bf3dac03 100644 --- a/crates/keyshare/src/lib.rs +++ b/crates/keyshare/src/lib.rs @@ -9,6 +9,8 @@ pub mod ext; mod repo; mod threshold_keyshare; mod threshold_share_collector; -pub use encryption_key_collector::{AllEncryptionKeysCollected, EncryptionKeyCollector}; +pub use encryption_key_collector::{ + AllEncryptionKeysCollected, EncryptionKeyCollector, ExpelPartyFromKeyCollection, +}; pub use repo::*; pub use threshold_keyshare::*; diff --git a/crates/keyshare/src/threshold_keyshare.rs b/crates/keyshare/src/threshold_keyshare.rs index cca0bc00e3..8d9f7d827b 100644 --- a/crates/keyshare/src/threshold_keyshare.rs +++ b/crates/keyshare/src/threshold_keyshare.rs @@ -9,12 +9,12 @@ use anyhow::{anyhow, bail, Context, Result}; use e3_crypto::{Cipher, SensitiveBytes}; use e3_data::Persistable; use e3_events::{ - prelude::*, trap, BusHandle, CiphernodeSelected, CiphertextOutputPublished, ComputeRequest, - ComputeResponse, ComputeResponseKind, CorrelationId, DecryptionshareCreated, Die, - E3RequestComplete, E3id, EType, EnclaveEvent, EnclaveEventData, EncryptionKey, - EncryptionKeyCollectionFailed, EncryptionKeyCreated, EncryptionKeyPending, EventContext, - KeyshareCreated, PartyId, Sequenced, ThresholdShare, ThresholdShareCollectionFailed, - ThresholdShareCreated, TypedEvent, + prelude::*, trap, BusHandle, CiphernodeSelected, CiphertextOutputPublished, + CommitteeMemberExpelled, ComputeRequest, ComputeResponse, ComputeResponseKind, CorrelationId, + DecryptionshareCreated, Die, E3RequestComplete, E3id, EType, EnclaveEvent, EnclaveEventData, + EncryptionKey, EncryptionKeyCollectionFailed, EncryptionKeyCreated, EncryptionKeyPending, + EventContext, KeyshareCreated, PartyId, Sequenced, ThresholdShare, + ThresholdShareCollectionFailed, ThresholdShareCreated, TypedEvent, }; use e3_fhe::create_crp; use e3_fhe_params::{BfvParamSet, BfvPreset}; @@ -40,10 +40,12 @@ use std::{ mem, sync::{Arc, Mutex}, }; -use tracing::{info, trace, warn}; +use tracing::{error, info, trace, warn}; -use crate::encryption_key_collector::{AllEncryptionKeysCollected, EncryptionKeyCollector}; -use crate::threshold_share_collector::ThresholdShareCollector; +use crate::encryption_key_collector::{ + AllEncryptionKeysCollected, EncryptionKeyCollector, ExpelPartyFromKeyCollection, +}; +use crate::threshold_share_collector::{ExpelPartyFromShareCollection, ThresholdShareCollector}; #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] #[rtype(result = "()")] @@ -306,6 +308,10 @@ pub struct ThresholdKeyshare { encryption_key_collector: Option>, state: Persistable, share_enc_preset: BfvPreset, + /// Committee member addresses, ordered by party_id (index = party_id). + /// Populated when `CommitteeFinalized` is received. Used to resolve + /// `CommitteeMemberExpelled.node` (Address) → `party_id` (u64). + committee: Option>, } impl ThresholdKeyshare { @@ -317,6 +323,7 @@ impl ThresholdKeyshare { encryption_key_collector: None, state: params.state, share_enc_preset: params.share_enc_preset, + committee: None, } } } @@ -369,6 +376,70 @@ impl ThresholdKeyshare { Ok(addr.clone()) } + /// Handle a committee member being expelled (slashed on-chain). + /// + /// Resolves the expelled node's address to a party_id using the stored + /// committee list, then forwards expulsion messages to the encryption key + /// and threshold share collectors so they can remove the party from their + /// `todo` sets. This allows the DKG to complete with N-1 parties. + fn handle_committee_member_expelled( + &mut self, + data: CommitteeMemberExpelled, + ec: EventContext, + ) { + let node_addr = format!("{:?}", data.node); + info!( + "CommitteeMemberExpelled received: node={} for e3_id={}, active_count_after={}", + node_addr, data.e3_id, data.active_count_after + ); + + // Resolve Address → party_id using stored committee list + let party_id = match &self.committee { + Some(committee) => { + // The committee list is ordered by party_id (index = party_id) + // Normalize both to lowercase checksummed for comparison + let node_lower = node_addr.to_lowercase(); + committee + .iter() + .position(|addr| addr.to_lowercase() == node_lower) + .map(|idx| idx as u64) + } + None => { + error!( + "Cannot resolve expelled node {} to party_id: committee list not available", + node_addr + ); + None + } + }; + + let Some(party_id) = party_id else { + error!( + "Expelled node {} not found in committee list, cannot remove from collectors", + node_addr + ); + return; + }; + + info!( + "Resolved expelled node {} to party_id={}, forwarding to collectors", + node_addr, party_id + ); + + // Forward expulsion to encryption key collector + if let Some(ref collector) = self.encryption_key_collector { + collector.do_send(ExpelPartyFromKeyCollection { + party_id, + ec: ec.clone(), + }); + } + + // Forward expulsion to threshold share collector + if let Some(ref collector) = self.decryption_key_collector { + collector.do_send(ExpelPartyFromShareCollection { party_id, ec }); + } + } + pub fn handle_threshold_share_created( &mut self, msg: TypedEvent, @@ -1021,6 +1092,17 @@ impl Handler for ThresholdKeyshare { EnclaveEventData::ComputeResponse(data) => { self.notify_sync(ctx, TypedEvent::new(data, ec)) } + EnclaveEventData::CommitteeFinalized(data) => { + info!( + "ThresholdKeyshare received CommitteeFinalized with {} committee members for e3_id={}", + data.committee.len(), + data.e3_id + ); + self.committee = Some(data.committee); + } + EnclaveEventData::CommitteeMemberExpelled(data) => { + self.handle_committee_member_expelled(data, ec); + } _ => (), } } diff --git a/crates/keyshare/src/threshold_share_collector.rs b/crates/keyshare/src/threshold_share_collector.rs index ae1167352f..7925e98226 100644 --- a/crates/keyshare/src/threshold_share_collector.rs +++ b/crates/keyshare/src/threshold_share_collector.rs @@ -12,7 +12,8 @@ use std::{ use actix::{Actor, ActorContext, Addr, AsyncContext, Handler, Message, SpawnHandle}; use e3_events::{ - E3id, ThresholdShare, ThresholdShareCollectionFailed, ThresholdShareCreated, TypedEvent, + E3id, EventContext, Sequenced, ThresholdShare, ThresholdShareCollectionFailed, + ThresholdShareCreated, TypedEvent, }; use e3_trbfv::PartyId; use e3_utils::MAILBOX_LIMIT; @@ -33,6 +34,17 @@ pub(crate) enum CollectorState { #[rtype(result = "()")] pub struct ThresholdShareCollectionTimeout; +/// Message sent when a committee member has been expelled (slashed on-chain). +/// +/// The collector removes this party from its `todo` set so the DKG can +/// complete with N-1 shares instead of waiting for a share that will never arrive. +#[derive(Message, Clone, Debug)] +#[rtype(result = "()")] +pub struct ExpelPartyFromShareCollection { + pub party_id: PartyId, + pub ec: EventContext, +} + pub struct ThresholdShareCollector { /// The E3id for the round e3_id: E3id, @@ -170,3 +182,57 @@ impl Handler for ThresholdShareCollector { ctx.stop(); } } + +impl Handler for ThresholdShareCollector { + type Result = (); + fn handle( + &mut self, + msg: ExpelPartyFromShareCollection, + ctx: &mut Self::Context, + ) -> Self::Result { + // Only handle if we're still collecting + if !matches!(self.state, CollectorState::Collecting) { + return; + } + + let party_id = msg.party_id; + + // Remove expelled party from the todo set + if !self.todo.remove(&party_id) { + info!( + e3_id = %self.e3_id, + party_id = party_id, + "Expelled party {} was not in share collection todo set (already received or unknown)", + party_id + ); + return; + } + + info!( + e3_id = %self.e3_id, + party_id = party_id, + remaining = self.todo.len(), + "Removed expelled party {} from threshold share collection, {} remaining", + party_id, + self.todo.len() + ); + + // Check if all remaining shares have been collected + if self.todo.is_empty() { + info!( + e3_id = %self.e3_id, + "All remaining threshold shares collected after party expulsion!" + ); + self.state = CollectorState::Finished; + + // Cancel the timeout since we're done + if let Some(handle) = self.timeout_handle.take() { + ctx.cancel_future(handle); + } + + let event: TypedEvent = + TypedEvent::new(self.shares.clone().into(), msg.ec); + self.parent.do_send(event); + } + } +} diff --git a/crates/zk-prover/src/actors/proof_verification.rs b/crates/zk-prover/src/actors/proof_verification.rs index c0fe9ae3c4..4e13e055b9 100644 --- a/crates/zk-prover/src/actors/proof_verification.rs +++ b/crates/zk-prover/src/actors/proof_verification.rs @@ -15,7 +15,9 @@ //! 1. Recovers the address from the ECDSA signature. //! 2. Delegates the ZK proof to `ZkActor` for verification. //! 3. On ZK failure, emits [`SignedProofFailed`] with the full evidence bundle -//! and [`E3Failed`] to stop the E3 computation. +//! so fault attribution can submit a slash on-chain. The E3 is NOT killed +//! locally — the on-chain `SlashingManager` decides whether to fail the E3 +//! based on whether the committee drops below threshold after expulsion. //! //! Keys without a signed proof are rejected outright. @@ -25,9 +27,9 @@ use std::sync::Arc; use actix::{Actor, Addr, AsyncContext, Context, Handler, Message, Recipient}; use alloy::primitives::Address; use e3_events::{ - BusHandle, E3Failed, E3Stage, E3id, EnclaveEvent, EnclaveEventData, EncryptionKey, - EncryptionKeyCreated, EncryptionKeyReceived, EventContext, EventPublisher, EventSubscriber, - EventType, FailureReason, Proof, Sequenced, SignedProofFailed, SignedProofPayload, TypedEvent, + BusHandle, E3id, EnclaveEvent, EnclaveEventData, EncryptionKey, EncryptionKeyCreated, + EncryptionKeyReceived, EventContext, EventPublisher, EventSubscriber, EventType, Proof, + Sequenced, SignedProofFailed, SignedProofPayload, TypedEvent, }; use e3_utils::NotifySync; use tracing::{error, info, warn}; @@ -62,8 +64,10 @@ struct PendingVerification { /// Core actor that handles encryption key verification. /// /// Requires every received key to carry a [`SignedProofPayload`]. -/// On ZK verification failure, emits both [`SignedProofFailed`] (for fault -/// attribution) and [`E3Failed`] (to stop the E3 computation). +/// On ZK verification failure, emits [`SignedProofFailed`] so the +/// `FaultSubmitter` can submit a slash on-chain. The on-chain +/// `SlashingManager` then decides whether to fail the E3 based on +/// whether the committee drops below threshold after expulsion. pub struct ProofVerificationActor { bus: BusHandle, verifier: Recipient>, @@ -253,17 +257,11 @@ impl Handler> for ProofVerificationActor { } } - // Stop the E3 computation — proof verification failure is fatal - if let Err(err) = self.bus.publish( - E3Failed { - e3_id: msg.e3_id, - failed_at_stage: E3Stage::CommitteeFinalized, - reason: FailureReason::VerificationFailed, - }, - ec, - ) { - error!("Failed to publish E3Failed: {err}"); - } + // NOTE: We do NOT emit E3Failed here. The on-chain SlashingManager + // will expel the faulting node and check if the committee drops below + // threshold. If it does, the contract emits E3Failed on-chain, which + // the EVM reader picks up and propagates to all actors. If the committee + // is still above threshold, the DKG continues with N-1 nodes. } } } From 829b142941bce910c3c1505896de7e4621a486bc Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 15 Feb 2026 17:42:42 +0500 Subject: [PATCH 08/32] feat: slash execution --- .../src/keyshare_created_filter_buffer.rs | 13 +- crates/aggregator/src/publickey_aggregator.rs | 8 - crates/entrypoint/src/config_set/mod.rs | 5 + .../src/enclave_event/slash_executed.rs | 2 - crates/evm/src/ciphernode_registry_sol.rs | 4 + crates/evm/src/slashing_manager_sol_reader.rs | 11 +- crates/evm/src/slashing_manager_sol_writer.rs | 18 +- .../keyshare/src/encryption_key_collector.rs | 7 +- crates/keyshare/src/threshold_keyshare.rs | 14 - .../keyshare/src/threshold_share_collector.rs | 7 +- .../src/actors/proof_verification.rs | 35 +- packages/enclave-contracts/.gitignore | 2 + .../IBondingRegistry.json | 2 +- .../ICiphernodeRegistry.json | 2 +- .../interfaces/IEnclave.sol/IEnclave.json | 2 +- .../ISlashingManager.json | 824 ++++++++++++++++++ .../EnclaveTicketToken.json | 36 +- .../DkgPkVerifier.sol/DkgPkVerifier.json | 8 +- .../DkgPkVerifier.sol/ZKTranscriptLib.json | 2 +- .../scripts/deployEnclave.ts | 9 + .../enclave-contracts/test/Enclave.spec.ts | 2 + .../test/Registry/BondingRegistry.spec.ts | 2 + .../CiphernodeRegistryOwnable.spec.ts | 2 + .../test/Slashing/CommitteeExpulsion.spec.ts | 1 + templates/default/enclave.config.yaml | 3 + 25 files changed, 902 insertions(+), 119 deletions(-) create mode 100644 packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json diff --git a/crates/aggregator/src/keyshare_created_filter_buffer.rs b/crates/aggregator/src/keyshare_created_filter_buffer.rs index f6cef6fe01..fdcf272f51 100644 --- a/crates/aggregator/src/keyshare_created_filter_buffer.rs +++ b/crates/aggregator/src/keyshare_created_filter_buffer.rs @@ -9,10 +9,11 @@ use actix::prelude::*; use e3_events::{prelude::*, EnclaveEvent, EnclaveEventData}; use e3_utils::MAILBOX_LIMIT; use std::collections::HashSet; +use tracing::info; use crate::PublicKeyAggregator; -/// Buffer KeyshareCreated events until CommitteeFinalized has been published +/// Buffers `KeyshareCreated` events until `CommitteeFinalized` arrives. pub struct KeyshareCreatedFilterBuffer { dest: Addr, committee: Option>, @@ -65,22 +66,24 @@ impl Handler for KeyshareCreatedFilterBuffer { _ => {} }, EnclaveEventData::CommitteeFinalized(data) => { - self.dest.do_send(msg.clone()); // forward committee first + self.dest.do_send(msg.clone()); self.committee = Some(data.committee.iter().cloned().collect()); self.process_buffered_events(); } EnclaveEventData::CommitteeMemberExpelled(data) => { - // Remove the expelled node from our committee set so we don't - // forward any late KeyshareCreated events from them + // Remove expelled node so we don't forward late KeyshareCreated events from them if let Some(ref mut committee) = self.committee { let node_addr = format!("{:?}", data.node); + info!( + "KeyshareCreatedFilterBuffer: removing expelled node {} from committee filter (e3_id={})", + node_addr, data.e3_id + ); committee.remove(&node_addr); } // Forward to PublicKeyAggregator for threshold_n adjustment self.dest.do_send(msg); } _ => { - // forward all other events self.dest.do_send(msg); } } diff --git a/crates/aggregator/src/publickey_aggregator.rs b/crates/aggregator/src/publickey_aggregator.rs index f456b62c64..e61e3b557e 100644 --- a/crates/aggregator/src/publickey_aggregator.rs +++ b/crates/aggregator/src/publickey_aggregator.rs @@ -138,9 +138,6 @@ impl PublicKeyAggregator { }) } - /// Handle a committee member being expelled by reducing the expected - /// keyshare count. If enough keyshares have already been collected, - /// transition to the Computing state. pub fn handle_member_expelled( &mut self, node: &str, @@ -154,11 +151,9 @@ impl PublicKeyAggregator { .. } = &mut state else { - // Not in collecting state — nothing to adjust return Ok(state); }; - // Reduce expected count if *threshold_n > 0 { *threshold_n -= 1; info!( @@ -167,7 +162,6 @@ impl PublicKeyAggregator { ); } - // Check if we now have enough keyshares if keyshares.len() == *threshold_n && *threshold_n > 0 { info!("PublicKeyAggregator: enough keyshares after expulsion, computing aggregate"); return Ok(PublicKeyAggregatorState::Computing { @@ -206,7 +200,6 @@ impl Handler for PublicKeyAggregator { trap(EType::PublickeyAggregation, &self.bus.with_ec(&ec), || { self.handle_member_expelled(&node_addr, &ec)?; - // If the state transitioned to Computing, trigger aggregation if let Some(PublicKeyAggregatorState::Computing { keyshares, .. }) = &self.state.get() { @@ -286,7 +279,6 @@ impl Handler> for PublicKeyAggregator { self.fhe.params.moduli().to_vec(), )?; - // Update the local state self.set_pubkey(pubkey, &ec)?; if let Some(PublicKeyAggregatorState::Complete { diff --git a/crates/entrypoint/src/config_set/mod.rs b/crates/entrypoint/src/config_set/mod.rs index a2ba685379..0883bfe4b6 100644 --- a/crates/entrypoint/src/config_set/mod.rs +++ b/crates/entrypoint/src/config_set/mod.rs @@ -63,6 +63,9 @@ chains: bonding_registry: address: "{}" deploy_block: {} + slashing_manager: + address: "{}" + deploy_block: {} "#, eth_address.map_or(String::new(), |addr| format!( "# Ethereum Account Configuration\naddress: \"{}\"", @@ -75,6 +78,8 @@ chains: get_contract_info("CiphernodeRegistryOwnable")?.deploy_block, get_contract_info("BondingRegistry")?.address, get_contract_info("BondingRegistry")?.deploy_block, + get_contract_info("SlashingManager")?.address, + get_contract_info("SlashingManager")?.deploy_block, ); fs::write(config_path.clone(), config_content)?; diff --git a/crates/events/src/enclave_event/slash_executed.rs b/crates/events/src/enclave_event/slash_executed.rs index f19e1bc13b..d75f2ed338 100644 --- a/crates/events/src/enclave_event/slash_executed.rs +++ b/crates/events/src/enclave_event/slash_executed.rs @@ -4,8 +4,6 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -//! Events emitted by the SlashingManager contract and received on-chain. - use crate::E3id; use actix::Message; use alloy::primitives::Address; diff --git a/crates/evm/src/ciphernode_registry_sol.rs b/crates/evm/src/ciphernode_registry_sol.rs index 69daa0281e..13591a492d 100644 --- a/crates/evm/src/ciphernode_registry_sol.rs +++ b/crates/evm/src/ciphernode_registry_sol.rs @@ -233,6 +233,10 @@ pub fn extractor(data: &LogData, topic: Option<&B256>, chain_id: u64) -> Option< error!("Error parsing event CommitteeMemberExpelled after topic was matched!"); return None; }; + info!( + "CommitteeMemberExpelled event received: e3_id={}, node={}, reason={:?}, active_count_after={}", + event.e3Id, event.node, event.reason, event.activeCountAfter + ); Some(EnclaveEventData::from(CommitteeMemberExpelledWithChainId( event, chain_id, ))) diff --git a/crates/evm/src/slashing_manager_sol_reader.rs b/crates/evm/src/slashing_manager_sol_reader.rs index 5d91d71e5e..8aad006bcd 100644 --- a/crates/evm/src/slashing_manager_sol_reader.rs +++ b/crates/evm/src/slashing_manager_sol_reader.rs @@ -4,9 +4,6 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -//! Reads `SlashExecuted` events from the SlashingManager contract on-chain -//! and converts them into `EnclaveEventData::SlashExecuted` events on the bus. - use crate::{ events::EvmEventProcessor, evm_parser::EvmParser, slashing_manager_sol_writer::ISlashingManager, }; @@ -16,7 +13,7 @@ use alloy::{ sol_types::SolEvent, }; use e3_events::{E3id, EnclaveEventData}; -use tracing::{error, trace}; +use tracing::{error, info, trace}; pub fn extractor(data: &LogData, topic: Option<&B256>, chain_id: u64) -> Option { match topic { @@ -25,8 +22,12 @@ pub fn extractor(data: &LogData, topic: Option<&B256>, chain_id: u64) -> Option< error!("Error parsing event SlashExecuted after topic was matched!"); return None; }; + info!( + "SlashExecuted event received: proposal_id={}, e3_id={}, operator={}, reason={:?}, ticket={}, license={}", + event.proposalId, event.e3Id, event.operator, event.reason, event.ticketAmount, event.licenseAmount + ); Some(EnclaveEventData::from(e3_events::SlashExecuted { - e3_id: E3id::new("0", chain_id), // SlashExecuted doesn't carry e3Id directly + e3_id: E3id::new(event.e3Id.to_string(), chain_id), proposal_id: event.proposalId.to(), operator: event.operator, reason: event.reason.into(), diff --git a/crates/evm/src/slashing_manager_sol_writer.rs b/crates/evm/src/slashing_manager_sol_writer.rs index f0a9428831..dc992afe8b 100644 --- a/crates/evm/src/slashing_manager_sol_writer.rs +++ b/crates/evm/src/slashing_manager_sol_writer.rs @@ -4,14 +4,8 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -//! FaultSubmitter actor — subscribes to `SignedProofFailed` events and submits -//! `proposeSlash` transactions on the SlashingManager contract. -//! -//! When a ciphernode broadcasts a ZK proof that fails local verification, -//! the `ProofVerificationActor` emits a `SignedProofFailed` event carrying the -//! self-authenticating evidence (the signed proof payload). This actor consumes -//! that event, ABI-encodes the proof data, and calls `proposeSlash(e3Id, operator, -//! reason, proof)` on-chain. +//! Subscribes to `SignedProofFailed` events and submits `proposeSlash` +//! transactions on the SlashingManager contract. use crate::helpers::EthProvider; use crate::send_tx_with_retry; @@ -41,7 +35,7 @@ sol!( "../../packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json" ); -/// Consumes `SignedProofFailed` events and submits slash proposals on-chain. +/// Submits `SignedProofFailed` events as slash proposals on-chain. pub struct SlashingManagerSolWriter

{ provider: EthProvider

, contract_address: Address, @@ -87,7 +81,6 @@ impl Handler fn handle(&mut self, msg: EnclaveEvent, ctx: &mut Self::Context) -> Self::Result { match msg.into_data() { EnclaveEventData::SignedProofFailed(data) => { - // Only submit if the chain matches if self.provider.chain_id() == data.e3_id.chain_id() { ctx.notify(data); } @@ -145,11 +138,11 @@ async fn submit_slash_proposal( let operator = data.faulting_node; let reason = keccak256(data.proof_type.slash_reason().as_bytes()); - // Encode the proof as (bytes zkProof, bytes32[] publicInputs) per SlashingManager.proposeSlash + // Encode as (bytes zkProof, bytes32[] publicInputs) let zk_proof = Bytes::copy_from_slice(&data.signed_payload.payload.proof.data); let public_inputs_bytes = &data.signed_payload.payload.proof.public_signals; - // Convert public signals to bytes32[] — each 32-byte chunk is one element + // Each 32-byte chunk of public_signals becomes one bytes32 element let mut public_inputs: Vec<[u8; 32]> = Vec::new(); for chunk in public_inputs_bytes.chunks(32) { let mut padded = [0u8; 32]; @@ -158,7 +151,6 @@ async fn submit_slash_proposal( public_inputs.push(padded); } - // abi.encode(bytes, bytes32[]) let proof_data = (zk_proof, public_inputs).abi_encode(); let from_address = provider.provider().default_signer_address(); diff --git a/crates/keyshare/src/encryption_key_collector.rs b/crates/keyshare/src/encryption_key_collector.rs index 76f19aa04e..bdfb86adc8 100644 --- a/crates/keyshare/src/encryption_key_collector.rs +++ b/crates/keyshare/src/encryption_key_collector.rs @@ -58,10 +58,8 @@ impl From>> for AllEncryptionKeysCollected { #[rtype(result = "()")] pub struct EncryptionKeyCollectionTimeout; -/// Message sent when a committee member has been expelled (slashed on-chain). -/// -/// The collector removes this party from its `todo` set so the DKG can -/// complete with N-1 keys instead of waiting for a key that will never arrive. +/// Removes this party from the `todo` set so the DKG can complete with +/// N-1 keys instead of waiting for a key that will never arrive. #[derive(Message, Clone, Debug)] #[rtype(result = "()")] pub struct ExpelPartyFromKeyCollection { @@ -208,7 +206,6 @@ impl Handler for EncryptionKeyCollector { missing_parties, }); - // Stop the actor ctx.stop(); } } diff --git a/crates/keyshare/src/threshold_keyshare.rs b/crates/keyshare/src/threshold_keyshare.rs index 8d9f7d827b..f5f0f8196f 100644 --- a/crates/keyshare/src/threshold_keyshare.rs +++ b/crates/keyshare/src/threshold_keyshare.rs @@ -308,9 +308,6 @@ pub struct ThresholdKeyshare { encryption_key_collector: Option>, state: Persistable, share_enc_preset: BfvPreset, - /// Committee member addresses, ordered by party_id (index = party_id). - /// Populated when `CommitteeFinalized` is received. Used to resolve - /// `CommitteeMemberExpelled.node` (Address) → `party_id` (u64). committee: Option>, } @@ -376,12 +373,6 @@ impl ThresholdKeyshare { Ok(addr.clone()) } - /// Handle a committee member being expelled (slashed on-chain). - /// - /// Resolves the expelled node's address to a party_id using the stored - /// committee list, then forwards expulsion messages to the encryption key - /// and threshold share collectors so they can remove the party from their - /// `todo` sets. This allows the DKG to complete with N-1 parties. fn handle_committee_member_expelled( &mut self, data: CommitteeMemberExpelled, @@ -393,11 +384,8 @@ impl ThresholdKeyshare { node_addr, data.e3_id, data.active_count_after ); - // Resolve Address → party_id using stored committee list let party_id = match &self.committee { Some(committee) => { - // The committee list is ordered by party_id (index = party_id) - // Normalize both to lowercase checksummed for comparison let node_lower = node_addr.to_lowercase(); committee .iter() @@ -426,7 +414,6 @@ impl ThresholdKeyshare { node_addr, party_id ); - // Forward expulsion to encryption key collector if let Some(ref collector) = self.encryption_key_collector { collector.do_send(ExpelPartyFromKeyCollection { party_id, @@ -434,7 +421,6 @@ impl ThresholdKeyshare { }); } - // Forward expulsion to threshold share collector if let Some(ref collector) = self.decryption_key_collector { collector.do_send(ExpelPartyFromShareCollection { party_id, ec }); } diff --git a/crates/keyshare/src/threshold_share_collector.rs b/crates/keyshare/src/threshold_share_collector.rs index 7925e98226..0c4772eb05 100644 --- a/crates/keyshare/src/threshold_share_collector.rs +++ b/crates/keyshare/src/threshold_share_collector.rs @@ -34,10 +34,8 @@ pub(crate) enum CollectorState { #[rtype(result = "()")] pub struct ThresholdShareCollectionTimeout; -/// Message sent when a committee member has been expelled (slashed on-chain). -/// -/// The collector removes this party from its `todo` set so the DKG can -/// complete with N-1 shares instead of waiting for a share that will never arrive. +/// Removes this party from the `todo` set so the DKG can complete with +/// N-1 shares instead of waiting for a share that will never arrive. #[derive(Message, Clone, Debug)] #[rtype(result = "()")] pub struct ExpelPartyFromShareCollection { @@ -178,7 +176,6 @@ impl Handler for ThresholdShareCollector { missing_parties, }); - // Stop the actor ctx.stop(); } } diff --git a/crates/zk-prover/src/actors/proof_verification.rs b/crates/zk-prover/src/actors/proof_verification.rs index 4e13e055b9..ee3b7f8e10 100644 --- a/crates/zk-prover/src/actors/proof_verification.rs +++ b/crates/zk-prover/src/actors/proof_verification.rs @@ -4,22 +4,9 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -//! Core business logic actor for verifying received encryption keys. -//! -//! This actor verifies `EncryptionKeyReceived` events and converts them -//! to `EncryptionKeyCreated` events after validation. -//! -//! ## Signature Verification -//! -//! Every received key must carry a [`SignedProofPayload`]. This actor: -//! 1. Recovers the address from the ECDSA signature. -//! 2. Delegates the ZK proof to `ZkActor` for verification. -//! 3. On ZK failure, emits [`SignedProofFailed`] with the full evidence bundle -//! so fault attribution can submit a slash on-chain. The E3 is NOT killed -//! locally — the on-chain `SlashingManager` decides whether to fail the E3 -//! based on whether the committee drops below threshold after expulsion. -//! -//! Keys without a signed proof are rejected outright. +//! Verifies `EncryptionKeyReceived` events: recovers ECDSA address, delegates +//! ZK proof to `ZkActor`, and on failure emits [`SignedProofFailed`] for +//! on-chain fault attribution. use std::collections::HashMap; use std::sync::Arc; @@ -34,7 +21,6 @@ use e3_events::{ use e3_utils::NotifySync; use tracing::{error, info, warn}; -/// Request to verify a ZK proof. #[derive(Debug, Message)] #[rtype(result = "()")] pub struct ZkVerificationRequest { @@ -44,7 +30,6 @@ pub struct ZkVerificationRequest { pub sender: Recipient>, } -/// Response from ZK proof verification with context. #[derive(Debug, Clone, Message)] #[rtype(result = "()")] pub struct ZkVerificationResponse { @@ -54,25 +39,15 @@ pub struct ZkVerificationResponse { pub key: Arc, } -/// Tracks a pending verification including the signed payload for fault evidence. #[derive(Clone, Debug)] struct PendingVerification { signed_payload: SignedProofPayload, recovered_signer: Address, } -/// Core actor that handles encryption key verification. -/// -/// Requires every received key to carry a [`SignedProofPayload`]. -/// On ZK verification failure, emits [`SignedProofFailed`] so the -/// `FaultSubmitter` can submit a slash on-chain. The on-chain -/// `SlashingManager` then decides whether to fail the E3 based on -/// whether the committee drops below threshold after expulsion. pub struct ProofVerificationActor { bus: BusHandle, verifier: Recipient>, - /// Tracks signed payloads for keys currently being verified, - /// keyed by `(e3_id, party_id)`. pending: HashMap<(E3id, u64), PendingVerification>, } @@ -108,7 +83,6 @@ impl ProofVerificationActor { return; }; - // Signed proofs are mandatory — reject keys without a signed payload let signed = match &msg.key.signed_payload { Some(signed) => signed.clone(), None => { @@ -120,7 +94,6 @@ impl ProofVerificationActor { } }; - // Recover the address from the signature let recovered_address = match signed.recover_address() { Ok(addr) => { info!( @@ -138,7 +111,6 @@ impl ProofVerificationActor { } }; - // Store the signed payload so we can reference it in the verification response self.pending.insert( (msg.e3_id.clone(), msg.key.party_id), PendingVerification { @@ -234,7 +206,6 @@ impl Handler> for ProofVerificationActor { msg.key.party_id, error_msg ); - // Emit SignedProofFailed for fault attribution if let Some(PendingVerification { signed_payload, recovered_signer, diff --git a/packages/enclave-contracts/.gitignore b/packages/enclave-contracts/.gitignore index 919a65a056..7660aa1688 100644 --- a/packages/enclave-contracts/.gitignore +++ b/packages/enclave-contracts/.gitignore @@ -14,9 +14,11 @@ !/artifacts/contracts/interfaces/IEnclave.sol/ !/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ !/artifacts/contracts/interfaces/IBondingRegistry.sol/ +!/artifacts/contracts/interfaces/ISlashingManager.sol/ !/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json !/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json !/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json +!/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json # Registry !/artifacts/contracts/registry/ diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json index 8b274a77bd..097e448144 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json @@ -890,5 +890,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IBondingRegistry.sol", - "buildInfoId": "solc-0_8_28-9c1ebc56a4c13150b3adbadeabc6f1b966156894" + "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json index c25e0a55f8..86ebdfa7e4 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json @@ -767,5 +767,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ICiphernodeRegistry.sol", - "buildInfoId": "solc-0_8_28-9c1ebc56a4c13150b3adbadeabc6f1b966156894" + "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json index 0c10882495..7b8e3cfbaf 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json @@ -1202,5 +1202,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IEnclave.sol", - "buildInfoId": "solc-0_8_28-9c1ebc56a4c13150b3adbadeabc6f1b966156894" + "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json new file mode 100644 index 0000000000..0426c7fef1 --- /dev/null +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json @@ -0,0 +1,824 @@ +{ + "_format": "hh3-artifact-1", + "contractName": "ISlashingManager", + "sourceName": "contracts/interfaces/ISlashingManager.sol", + "abi": [ + { + "inputs": [], + "name": "AlreadyAppealed", + "type": "error" + }, + { + "inputs": [], + "name": "AlreadyExecuted", + "type": "error" + }, + { + "inputs": [], + "name": "AlreadyResolved", + "type": "error" + }, + { + "inputs": [], + "name": "AppealPending", + "type": "error" + }, + { + "inputs": [], + "name": "AppealUpheld", + "type": "error" + }, + { + "inputs": [], + "name": "AppealWindowActive", + "type": "error" + }, + { + "inputs": [], + "name": "AppealWindowExpired", + "type": "error" + }, + { + "inputs": [], + "name": "CiphernodeBanned", + "type": "error" + }, + { + "inputs": [], + "name": "DuplicateEvidence", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidPolicy", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidProof", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidProposal", + "type": "error" + }, + { + "inputs": [], + "name": "ProofRequired", + "type": "error" + }, + { + "inputs": [], + "name": "SlashReasonDisabled", + "type": "error" + }, + { + "inputs": [], + "name": "SlashReasonNotFound", + "type": "error" + }, + { + "inputs": [], + "name": "Unauthorized", + "type": "error" + }, + { + "inputs": [], + "name": "VerifierNotSet", + "type": "error" + }, + { + "inputs": [], + "name": "ZeroAddress", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "string", + "name": "evidence", + "type": "string" + } + ], + "name": "AppealFiled", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "appealUpheld", + "type": "bool" + }, + { + "indexed": false, + "internalType": "address", + "name": "resolver", + "type": "address" + }, + { + "indexed": false, + "internalType": "string", + "name": "resolution", + "type": "string" + } + ], + "name": "AppealResolved", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "node", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "status", + "type": "bool" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "updater", + "type": "address" + } + ], + "name": "NodeBanUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "ticketAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "licenseAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "executed", + "type": "bool" + } + ], + "name": "SlashExecuted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "ticketPenalty", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "licensePenalty", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "requiresProof", + "type": "bool" + }, + { + "internalType": "address", + "name": "proofVerifier", + "type": "address" + }, + { + "internalType": "bool", + "name": "banNode", + "type": "bool" + }, + { + "internalType": "uint256", + "name": "appealWindow", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "enabled", + "type": "bool" + }, + { + "internalType": "bool", + "name": "affectsCommittee", + "type": "bool" + }, + { + "internalType": "uint8", + "name": "failureReason", + "type": "uint8" + } + ], + "indexed": false, + "internalType": "struct ISlashingManager.SlashPolicy", + "name": "policy", + "type": "tuple" + } + ], + "name": "SlashPolicyUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "ticketAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "licenseAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "executableAt", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "proposer", + "type": "address" + } + ], + "name": "SlashProposed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "slasher", + "type": "address" + } + ], + "name": "addSlasher", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "bondingRegistry", + "outputs": [ + { + "internalType": "contract IBondingRegistry", + "name": "registry", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + } + ], + "name": "executeSlash", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "internalType": "string", + "name": "evidence", + "type": "string" + } + ], + "name": "fileAppeal", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + } + ], + "name": "getSlashPolicy", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "ticketPenalty", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "licensePenalty", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "requiresProof", + "type": "bool" + }, + { + "internalType": "address", + "name": "proofVerifier", + "type": "address" + }, + { + "internalType": "bool", + "name": "banNode", + "type": "bool" + }, + { + "internalType": "uint256", + "name": "appealWindow", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "enabled", + "type": "bool" + }, + { + "internalType": "bool", + "name": "affectsCommittee", + "type": "bool" + }, + { + "internalType": "uint8", + "name": "failureReason", + "type": "uint8" + } + ], + "internalType": "struct ISlashingManager.SlashPolicy", + "name": "policy", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + } + ], + "name": "getSlashProposal", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "ticketAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "licenseAmount", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "executed", + "type": "bool" + }, + { + "internalType": "bool", + "name": "appealed", + "type": "bool" + }, + { + "internalType": "bool", + "name": "resolved", + "type": "bool" + }, + { + "internalType": "bool", + "name": "appealUpheld", + "type": "bool" + }, + { + "internalType": "uint256", + "name": "proposedAt", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "executableAt", + "type": "uint256" + }, + { + "internalType": "address", + "name": "proposer", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "proofHash", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "proofVerified", + "type": "bool" + } + ], + "internalType": "struct ISlashingManager.SlashProposal", + "name": "proposal", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "node", + "type": "address" + } + ], + "name": "isBanned", + "outputs": [ + { + "internalType": "bool", + "name": "isBanned", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "proof", + "type": "bytes" + } + ], + "name": "proposeSlash", + "outputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "e3Id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "evidence", + "type": "bytes" + } + ], + "name": "proposeSlashEvidence", + "outputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "slasher", + "type": "address" + } + ], + "name": "removeSlasher", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "appealUpheld", + "type": "bool" + }, + { + "internalType": "string", + "name": "resolution", + "type": "string" + } + ], + "name": "resolveAppeal", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newBondingRegistry", + "type": "address" + } + ], + "name": "setBondingRegistry", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "ticketPenalty", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "licensePenalty", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "requiresProof", + "type": "bool" + }, + { + "internalType": "address", + "name": "proofVerifier", + "type": "address" + }, + { + "internalType": "bool", + "name": "banNode", + "type": "bool" + }, + { + "internalType": "uint256", + "name": "appealWindow", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "enabled", + "type": "bool" + }, + { + "internalType": "bool", + "name": "affectsCommittee", + "type": "bool" + }, + { + "internalType": "uint8", + "name": "failureReason", + "type": "uint8" + } + ], + "internalType": "struct ISlashingManager.SlashPolicy", + "name": "policy", + "type": "tuple" + } + ], + "name": "setSlashPolicy", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "totalProposals", + "outputs": [ + { + "internalType": "uint256", + "name": "count", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "node", + "type": "address" + }, + { + "internalType": "bool", + "name": "status", + "type": "bool" + }, + { + "internalType": "bytes32", + "name": "reason", + "type": "bytes32" + } + ], + "name": "updateBanStatus", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "bytecode": "0x", + "deployedBytecode": "0x", + "linkReferences": {}, + "deployedLinkReferences": {}, + "immutableReferences": {}, + "inputSourceName": "project/contracts/interfaces/ISlashingManager.sol", + "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" +} \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json index 1cfee6a53d..43493030cc 100644 --- a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json +++ b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json @@ -1143,80 +1143,72 @@ "type": "function" } ], - "bytecode": "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", - "deployedBytecode": "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", + "bytecode": "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", + "deployedBytecode": "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", "linkReferences": {}, "deployedLinkReferences": {}, "immutableReferences": { "3415": [ { "length": 32, - "start": 872 + "start": 1988 }, { "length": 32, - "start": 1600 + "start": 2985 }, { "length": 32, - "start": 2113 + "start": 3290 }, { "length": 32, - "start": 3176 - }, - { - "length": 32, - "start": 3533 - }, - { - "length": 32, - "start": 3711 + "start": 3463 } ], "6684": [ { "length": 32, - "start": 3942 + "start": 3694 } ], "6686": [ { "length": 32, - "start": 3900 + "start": 3652 } ], "6688": [ { "length": 32, - "start": 3858 + "start": 3610 } ], "6690": [ { "length": 32, - "start": 4023 + "start": 3775 } ], "6692": [ { "length": 32, - "start": 4063 + "start": 3815 } ], "6695": [ { "length": 32, - "start": 4727 + "start": 4463 } ], "6698": [ { "length": 32, - "start": 4772 + "start": 4508 } ] }, "inputSourceName": "project/contracts/token/EnclaveTicketToken.sol", - "buildInfoId": "solc-0_8_28-15112a5a277d7846347c8e3a91ba0ec7bb3521bd" + "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json index 272ae5f3f1..96ca48277a 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json @@ -102,7 +102,7 @@ } }, "immutableReferences": { - "32281": [ + "33263": [ { "length": 32, "start": 91 @@ -164,13 +164,13 @@ "start": 11964 } ], - "32283": [ + "33265": [ { "length": 32, "start": 398 } ], - "32285": [ + "33267": [ { "length": 32, "start": 432 @@ -182,5 +182,5 @@ ] }, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-e60a5d7c133605edcf61acdd5ba43ab44ee0928e" + "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json index 4bc1877086..06119e9770 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json @@ -396,5 +396,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-e60a5d7c133605edcf61acdd5ba43ab44ee0928e" + "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" } \ No newline at end of file diff --git a/packages/enclave-contracts/scripts/deployEnclave.ts b/packages/enclave-contracts/scripts/deployEnclave.ts index 6dfb6c5240..1b39ab2882 100644 --- a/packages/enclave-contracts/scripts/deployEnclave.ts +++ b/packages/enclave-contracts/scripts/deployEnclave.ts @@ -189,9 +189,18 @@ export const deployEnclave = async (withMocks?: boolean) => { console.log("Setting BondingRegistry address in SlashingManager..."); await slashingManager.setBondingRegistry(bondingRegistryAddress); + console.log("Setting CiphernodeRegistry address in SlashingManager..."); + await slashingManager.setCiphernodeRegistry(ciphernodeRegistryAddress); + + console.log("Setting Enclave address in SlashingManager..."); + await slashingManager.setEnclave(enclaveAddress); + console.log("Setting SlashingManager address in BondingRegistry..."); await bondingRegistry.setSlashingManager(slashingManagerAddress); + console.log("Setting SlashingManager address in CiphernodeRegistry..."); + await ciphernodeRegistry.setSlashingManager(slashingManagerAddress); + console.log("Setting Enclave as reward distributor in BondingRegistry..."); await bondingRegistry.setRewardDistributor(enclaveAddress); diff --git a/packages/enclave-contracts/test/Enclave.spec.ts b/packages/enclave-contracts/test/Enclave.spec.ts index 4b6ac074e5..2534b89074 100644 --- a/packages/enclave-contracts/test/Enclave.spec.ts +++ b/packages/enclave-contracts/test/Enclave.spec.ts @@ -185,6 +185,8 @@ describe("Enclave", function () { SlashingManager: { admin: ownerAddress, bondingRegistry: addressOne, + ciphernodeRegistry: addressOne, + enclave: addressOne, }, }, }, diff --git a/packages/enclave-contracts/test/Registry/BondingRegistry.spec.ts b/packages/enclave-contracts/test/Registry/BondingRegistry.spec.ts index b53d785db1..479f1e7269 100644 --- a/packages/enclave-contracts/test/Registry/BondingRegistry.spec.ts +++ b/packages/enclave-contracts/test/Registry/BondingRegistry.spec.ts @@ -97,6 +97,8 @@ describe("BondingRegistry", function () { SlashingManager: { admin: ownerAddress, bondingRegistry: AddressOne, + ciphernodeRegistry: AddressOne, + enclave: AddressOne, }, }, }, diff --git a/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts b/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts index 9a2db8f877..dacd5637f4 100644 --- a/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts +++ b/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts @@ -134,6 +134,8 @@ describe("CiphernodeRegistryOwnable", function () { SlashingManager: { admin: ownerAddress, bondingRegistry: AddressOne, + ciphernodeRegistry: AddressOne, + enclave: AddressOne, }, }, }, diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts index ca98e296f6..47c0a88ed1 100644 --- a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -898,6 +898,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { .to.emit(slashingManager, "SlashExecuted") .withArgs( 0, // proposalId + 0, // e3Id op1Addr, REASON_BAD_DKG, ethers.parseUnits("10", 6), // ticketPenalty diff --git a/templates/default/enclave.config.yaml b/templates/default/enclave.config.yaml index aaa84e54db..1ab0ad3071 100644 --- a/templates/default/enclave.config.yaml +++ b/templates/default/enclave.config.yaml @@ -14,6 +14,9 @@ chains: bonding_registry: address: "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6" deploy_block: 1 # Set to actual deploy block + slashing_manager: + address: "0x0000000000000000000000000000000000000000" + deploy_block: 1 # Set to actual deploy block fee_token: address: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0" deploy_block: 1 # Set to actual deploy block From e8eaa1e4b7fc4e56738bf4ac70ad04bf3dac4978 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 15 Feb 2026 17:47:29 +0500 Subject: [PATCH 09/32] feat: add e3id to slash executed --- .../benchmarks/results_insecure/report.md | 325 ++- .../ISlashingManager.json | 6 +- .../contracts/interfaces/ICircuitVerifier.sol | 46 +- .../contracts/interfaces/ISlashingManager.sol | 2 + .../contracts/slashing/SlashingManager.sol | 1 + .../test/Slashing/CommitteeExpulsion.spec.ts | 1851 ++++++------ .../test/Slashing/SlashingManager.spec.ts | 2556 ++++++++--------- 7 files changed, 2410 insertions(+), 2377 deletions(-) diff --git a/circuits/benchmarks/results_insecure/report.md b/circuits/benchmarks/results_insecure/report.md index 3b7e19d687..a0b18a30cb 100644 --- a/circuits/benchmarks/results_insecure/report.md +++ b/circuits/benchmarks/results_insecure/report.md @@ -13,45 +13,45 @@ #### Timing Metrics -| Circuit | Compile | Execute | Prove | Verify | -|---------|---------|---------|-------|--------| -| e_sm_share_computation | 0.31 s | 0.52 s | 1.55 s | 0.02 s | -| pk | 0.25 s | 0.27 s | 0.12 s | 0.03 s | -| share_decryption | 0.25 s | 0.29 s | 0.23 s | 0.02 s | -| share_encryption | 0.29 s | 0.44 s | 0.61 s | 0.03 s | -| sk_share_computation | 0.30 s | 0.51 s | 1.54 s | 0.03 s | +| Circuit | Compile | Execute | Prove | Verify | +| ---------------------- | ------- | ------- | ------ | ------ | +| e_sm_share_computation | 0.31 s | 0.52 s | 1.55 s | 0.02 s | +| pk | 0.25 s | 0.27 s | 0.12 s | 0.03 s | +| share_decryption | 0.25 s | 0.29 s | 0.23 s | 0.02 s | +| share_encryption | 0.29 s | 0.44 s | 0.61 s | 0.03 s | +| sk_share_computation | 0.30 s | 0.51 s | 1.54 s | 0.03 s | #### Size & Circuit Metrics -| Circuit | Opcodes | Gates | Circuit Size | Witness | VK Size | Proof Size | -|---------|---------|-------|--------------|---------|---------|------------| -| e_sm_share_computation | 90956 | 328.74K | 1.39 MB | 477.72 KB | 3.59 KB | 15.88 KB | -| pk | 344 | 6.85K | 87.84 KB | 29.07 KB | 3.59 KB | 15.88 KB | -| share_decryption | 3093 | 28.72K | 158.27 KB | 148.91 KB | 3.59 KB | 15.88 KB | -| share_encryption | 47758 | 127.69K | 798.14 KB | 512.11 KB | 3.59 KB | 15.88 KB | -| sk_share_computation | 90827 | 326.14K | 1.38 MB | 463.68 KB | 3.59 KB | 15.88 KB | +| Circuit | Opcodes | Gates | Circuit Size | Witness | VK Size | Proof Size | +| ---------------------- | ------- | ------- | ------------ | --------- | ------- | ---------- | +| e_sm_share_computation | 90956 | 328.74K | 1.39 MB | 477.72 KB | 3.59 KB | 15.88 KB | +| pk | 344 | 6.85K | 87.84 KB | 29.07 KB | 3.59 KB | 15.88 KB | +| share_decryption | 3093 | 28.72K | 158.27 KB | 148.91 KB | 3.59 KB | 15.88 KB | +| share_encryption | 47758 | 127.69K | 798.14 KB | 512.11 KB | 3.59 KB | 15.88 KB | +| sk_share_computation | 90827 | 326.14K | 1.38 MB | 463.68 KB | 3.59 KB | 15.88 KB | ### Threshold #### Timing Metrics -| Circuit | Compile | Execute | Prove | Verify | -|---------|---------|---------|-------|--------| -| decrypted_shares_aggregation_mod | 0.27 s | 0.33 s | 0.46 s | 0.02 s | -| pk_aggregation | 0.29 s | 0.45 s | 0.87 s | 0.02 s | -| pk_generation | 0.28 s | 0.38 s | 0.48 s | 0.03 s | -| share_decryption | 0.28 s | 0.40 s | 0.53 s | 0.03 s | -| user_data_encryption | 0.30 s | 0.47 s | 0.58 s | 0.02 s | +| Circuit | Compile | Execute | Prove | Verify | +| -------------------------------- | ------- | ------- | ------ | ------ | +| decrypted_shares_aggregation_mod | 0.27 s | 0.33 s | 0.46 s | 0.02 s | +| pk_aggregation | 0.29 s | 0.45 s | 0.87 s | 0.02 s | +| pk_generation | 0.28 s | 0.38 s | 0.48 s | 0.03 s | +| share_decryption | 0.28 s | 0.40 s | 0.53 s | 0.03 s | +| user_data_encryption | 0.30 s | 0.47 s | 0.58 s | 0.02 s | #### Size & Circuit Metrics -| Circuit | Opcodes | Gates | Circuit Size | Witness | VK Size | Proof Size | -|---------|---------|-------|--------------|---------|---------|------------| -| decrypted_shares_aggregation_mod | 31544 | 80.74K | 509.84 KB | 77.56 KB | 3.59 KB | 15.88 KB | -| pk_aggregation | 47817 | 169.89K | 884.11 KB | 360.86 KB | 3.59 KB | 15.88 KB | -| pk_generation | 30019 | 65.61K | 542.16 KB | 447.05 KB | 3.59 KB | 15.88 KB | -| share_decryption | 30570 | 85.48K | 541.56 KB | 522.86 KB | 3.59 KB | 15.88 KB | -| user_data_encryption | 56601 | 106.72K | 847.64 KB | 691.13 KB | 3.59 KB | 15.88 KB | +| Circuit | Opcodes | Gates | Circuit Size | Witness | VK Size | Proof Size | +| -------------------------------- | ------- | ------- | ------------ | --------- | ------- | ---------- | +| decrypted_shares_aggregation_mod | 31544 | 80.74K | 509.84 KB | 77.56 KB | 3.59 KB | 15.88 KB | +| pk_aggregation | 47817 | 169.89K | 884.11 KB | 360.86 KB | 3.59 KB | 15.88 KB | +| pk_generation | 30019 | 65.61K | 542.16 KB | 447.05 KB | 3.59 KB | 15.88 KB | +| share_decryption | 30570 | 85.48K | 541.56 KB | 522.86 KB | 3.59 KB | 15.88 KB | +| user_data_encryption | 56601 | 106.72K | 847.64 KB | 691.13 KB | 3.59 KB | 15.88 KB | ## Circuit Details @@ -59,167 +59,165 @@ #### e_sm_share_computation -| Metric | Value | -|--------|-------| -| **Compilation** | 0.31 s | -| **Execution** | 0.52 s | -| **VK Generation** | 0.59 s | -| **Proof Generation** | 1.55 s | -| **Verification** | 0.02 s | -| **ACIR Opcodes** | "90956" | -| **Total Gates** | "328743" | -| **Circuit Size** | 1.39 MB | -| **Witness Size** | 477.72 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.31 s | +| **Execution** | 0.52 s | +| **VK Generation** | 0.59 s | +| **Proof Generation** | 1.55 s | +| **Verification** | 0.02 s | +| **ACIR Opcodes** | "90956" | +| **Total Gates** | "328743" | +| **Circuit Size** | 1.39 MB | +| **Witness Size** | 477.72 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### pk -| Metric | Value | -|--------|-------| -| **Compilation** | 0.25 s | -| **Execution** | 0.27 s | -| **VK Generation** | 0.05 s | -| **Proof Generation** | 0.12 s | -| **Verification** | 0.03 s | -| **ACIR Opcodes** | "344" | -| **Total Gates** | "6846" | -| **Circuit Size** | 87.84 KB | -| **Witness Size** | 29.07 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | -------- | +| **Compilation** | 0.25 s | +| **Execution** | 0.27 s | +| **VK Generation** | 0.05 s | +| **Proof Generation** | 0.12 s | +| **Verification** | 0.03 s | +| **ACIR Opcodes** | "344" | +| **Total Gates** | "6846" | +| **Circuit Size** | 87.84 KB | +| **Witness Size** | 29.07 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### share_decryption -| Metric | Value | -|--------|-------| -| **Compilation** | 0.25 s | -| **Execution** | 0.29 s | -| **VK Generation** | 0.09 s | -| **Proof Generation** | 0.23 s | -| **Verification** | 0.02 s | -| **ACIR Opcodes** | "3093" | -| **Total Gates** | "28720" | -| **Circuit Size** | 158.27 KB | -| **Witness Size** | 148.91 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.25 s | +| **Execution** | 0.29 s | +| **VK Generation** | 0.09 s | +| **Proof Generation** | 0.23 s | +| **Verification** | 0.02 s | +| **ACIR Opcodes** | "3093" | +| **Total Gates** | "28720" | +| **Circuit Size** | 158.27 KB | +| **Witness Size** | 148.91 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### share_encryption -| Metric | Value | -|--------|-------| -| **Compilation** | 0.29 s | -| **Execution** | 0.44 s | -| **VK Generation** | 0.26 s | -| **Proof Generation** | 0.61 s | -| **Verification** | 0.03 s | -| **ACIR Opcodes** | "47758" | -| **Total Gates** | "127691" | -| **Circuit Size** | 798.14 KB | -| **Witness Size** | 512.11 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.29 s | +| **Execution** | 0.44 s | +| **VK Generation** | 0.26 s | +| **Proof Generation** | 0.61 s | +| **Verification** | 0.03 s | +| **ACIR Opcodes** | "47758" | +| **Total Gates** | "127691" | +| **Circuit Size** | 798.14 KB | +| **Witness Size** | 512.11 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### sk_share_computation -| Metric | Value | -|--------|-------| -| **Compilation** | 0.30 s | -| **Execution** | 0.51 s | -| **VK Generation** | 0.66 s | -| **Proof Generation** | 1.54 s | -| **Verification** | 0.03 s | -| **ACIR Opcodes** | "90827" | -| **Total Gates** | "326138" | -| **Circuit Size** | 1.38 MB | -| **Witness Size** | 463.68 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | - +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.30 s | +| **Execution** | 0.51 s | +| **VK Generation** | 0.66 s | +| **Proof Generation** | 1.54 s | +| **Verification** | 0.03 s | +| **ACIR Opcodes** | "90827" | +| **Total Gates** | "326138" | +| **Circuit Size** | 1.38 MB | +| **Witness Size** | 463.68 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | ### Threshold #### decrypted_shares_aggregation_mod -| Metric | Value | -|--------|-------| -| **Compilation** | 0.27 s | -| **Execution** | 0.33 s | -| **VK Generation** | 0.18 s | -| **Proof Generation** | 0.46 s | -| **Verification** | 0.02 s | -| **ACIR Opcodes** | "31544" | -| **Total Gates** | "80740" | -| **Circuit Size** | 509.84 KB | -| **Witness Size** | 77.56 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.27 s | +| **Execution** | 0.33 s | +| **VK Generation** | 0.18 s | +| **Proof Generation** | 0.46 s | +| **Verification** | 0.02 s | +| **ACIR Opcodes** | "31544" | +| **Total Gates** | "80740" | +| **Circuit Size** | 509.84 KB | +| **Witness Size** | 77.56 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### pk_aggregation -| Metric | Value | -|--------|-------| -| **Compilation** | 0.29 s | -| **Execution** | 0.45 s | -| **VK Generation** | 0.35 s | -| **Proof Generation** | 0.87 s | -| **Verification** | 0.02 s | -| **ACIR Opcodes** | "47817" | -| **Total Gates** | "169890" | -| **Circuit Size** | 884.11 KB | -| **Witness Size** | 360.86 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.29 s | +| **Execution** | 0.45 s | +| **VK Generation** | 0.35 s | +| **Proof Generation** | 0.87 s | +| **Verification** | 0.02 s | +| **ACIR Opcodes** | "47817" | +| **Total Gates** | "169890" | +| **Circuit Size** | 884.11 KB | +| **Witness Size** | 360.86 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### pk_generation -| Metric | Value | -|--------|-------| -| **Compilation** | 0.28 s | -| **Execution** | 0.38 s | -| **VK Generation** | 0.16 s | -| **Proof Generation** | 0.48 s | -| **Verification** | 0.03 s | -| **ACIR Opcodes** | "30019" | -| **Total Gates** | "65606" | -| **Circuit Size** | 542.16 KB | -| **Witness Size** | 447.05 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.28 s | +| **Execution** | 0.38 s | +| **VK Generation** | 0.16 s | +| **Proof Generation** | 0.48 s | +| **Verification** | 0.03 s | +| **ACIR Opcodes** | "30019" | +| **Total Gates** | "65606" | +| **Circuit Size** | 542.16 KB | +| **Witness Size** | 447.05 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### share_decryption -| Metric | Value | -|--------|-------| -| **Compilation** | 0.28 s | -| **Execution** | 0.40 s | -| **VK Generation** | 0.19 s | -| **Proof Generation** | 0.53 s | -| **Verification** | 0.03 s | -| **ACIR Opcodes** | "30570" | -| **Total Gates** | "85478" | -| **Circuit Size** | 541.56 KB | -| **Witness Size** | 522.86 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.28 s | +| **Execution** | 0.40 s | +| **VK Generation** | 0.19 s | +| **Proof Generation** | 0.53 s | +| **Verification** | 0.03 s | +| **ACIR Opcodes** | "30570" | +| **Total Gates** | "85478" | +| **Circuit Size** | 541.56 KB | +| **Witness Size** | 522.86 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | #### user_data_encryption -| Metric | Value | -|--------|-------| -| **Compilation** | 0.30 s | -| **Execution** | 0.47 s | -| **VK Generation** | 0.23 s | -| **Proof Generation** | 0.58 s | -| **Verification** | 0.02 s | -| **ACIR Opcodes** | "56601" | -| **Total Gates** | "106725" | -| **Circuit Size** | 847.64 KB | -| **Witness Size** | 691.13 KB | -| **VK Size** | 3.59 KB | -| **Proof Size** | 15.88 KB | - +| Metric | Value | +| -------------------- | --------- | +| **Compilation** | 0.30 s | +| **Execution** | 0.47 s | +| **VK Generation** | 0.23 s | +| **Proof Generation** | 0.58 s | +| **Verification** | 0.02 s | +| **ACIR Opcodes** | "56601" | +| **Total Gates** | "106725" | +| **Circuit Size** | 847.64 KB | +| **Witness Size** | 691.13 KB | +| **VK Size** | 3.59 KB | +| **Proof Size** | 15.88 KB | ## System Information @@ -233,6 +231,7 @@ ### Software -- **Nargo Version:** nargo version = 1.0.0-beta.15 noirc version = 1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663 (git version hash: 83245db91dcf63420ef4bcbbd85b98f397fee663, is dirty: false) -- **Barretenberg Version:** 3.0.0-nightly.20251104 - +- **Nargo Version:** nargo version = 1.0.0-beta.15 noirc version = + 1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663 (git version hash: + 83245db91dcf63420ef4bcbbd85b98f397fee663, is dirty: false) +- **Barretenberg Version:** 3.0.0-nightly.20251104 diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json index 0426c7fef1..b319c58b6d 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json @@ -202,7 +202,7 @@ "type": "uint256" }, { - "indexed": true, + "indexed": false, "internalType": "uint256", "name": "e3Id", "type": "uint256" @@ -214,7 +214,7 @@ "type": "address" }, { - "indexed": false, + "indexed": true, "internalType": "bytes32", "name": "reason", "type": "bytes32" @@ -820,5 +820,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ISlashingManager.sol", - "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" + "buildInfoId": "solc-0_8_28-0871e0e155b06f51b6fb81507908de5a4ecc60f9" } \ No newline at end of file diff --git a/packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol b/packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol index ae43283b90..ffca72f19b 100644 --- a/packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol +++ b/packages/enclave-contracts/contracts/interfaces/ICircuitVerifier.sol @@ -1,23 +1,23 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. -pragma solidity >=0.8.27; - -/** - * @title ICircuitVerifier - * @notice Interface for on-chain ZK circuit verifiers (e.g., DkgPkVerifier, Honk verifiers) - * @dev Standard interface matching the verification pattern used by Honk-generated verifiers. - * Set the circuit verifier address directly as the proofVerifier in a SlashPolicy. - */ -interface ICircuitVerifier { - /// @notice Verify a ZK proof against public inputs - /// @param _proof The raw proof bytes - /// @param _publicInputs The public inputs to verify against - /// @return True if the proof is valid - function verify( - bytes calldata _proof, - bytes32[] calldata _publicInputs - ) external returns (bool); -} +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. +pragma solidity >=0.8.27; + +/** + * @title ICircuitVerifier + * @notice Interface for on-chain ZK circuit verifiers (e.g., DkgPkVerifier, Honk verifiers) + * @dev Standard interface matching the verification pattern used by Honk-generated verifiers. + * Set the circuit verifier address directly as the proofVerifier in a SlashPolicy. + */ +interface ICircuitVerifier { + /// @notice Verify a ZK proof against public inputs + /// @param _proof The raw proof bytes + /// @param _publicInputs The public inputs to verify against + /// @return True if the proof is valid + function verify( + bytes calldata _proof, + bytes32[] calldata _publicInputs + ) external returns (bool); +} diff --git a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol index a8ddf370fe..2ba0978ab1 100644 --- a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol +++ b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol @@ -174,6 +174,7 @@ interface ISlashingManager { /** * @notice Emitted when a slash proposal is executed and penalties are applied * @param proposalId ID of the executed proposal + * @param e3Id ID of the E3 committee associated with this slash * @param operator Address of the slashed operator * @param reason Hash of the slash reason * @param ticketAmount Amount of ticket collateral slashed @@ -182,6 +183,7 @@ interface ISlashingManager { */ event SlashExecuted( uint256 indexed proposalId, + uint256 e3Id, address indexed operator, bytes32 indexed reason, uint256 ticketAmount, diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index 11f17a89fb..051cfab593 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -406,6 +406,7 @@ contract SlashingManager is ISlashingManager, AccessControl { emit SlashExecuted( proposalId, + p.e3Id, p.operator, p.reason, p.ticketAmount, diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts index 47c0a88ed1..7d65dc3134 100644 --- a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -1,910 +1,941 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. - -/** - * Tests for committee expulsion, viability checks, and E3 failure on threshold breach. - * - * Verifies: - * - Committee members are expelled via proposeSlash when affectsCommittee=true - * - The E3 continues as long as active members >= threshold M - * - The E3 fails when active members drop below threshold M - * - Rewards exclude expelled members - * - Idempotent expulsion (re-slashing same node doesn't double-count) - */ -import { expect } from "chai"; -import type { Signer } from "ethers"; -import { network } from "hardhat"; - -import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; -import CiphernodeRegistryModule from "../../ignition/modules/ciphernodeRegistry"; -import EnclaveModule from "../../ignition/modules/enclave"; -import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; -import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; -import MockCircuitVerifierModule from "../../ignition/modules/mockSlashingVerifier"; -import MockE3ProgramModule from "../../ignition/modules/mockE3Program"; -import MockDecryptionVerifierModule from "../../ignition/modules/mockDecryptionVerifier"; -import MockStableTokenModule from "../../ignition/modules/mockStableToken"; -import SlashingManagerModule from "../../ignition/modules/slashingManager"; -import { - BondingRegistry__factory as BondingRegistryFactory, - CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnableFactory, - Enclave__factory as EnclaveFactory, - EnclaveTicketToken__factory as EnclaveTicketTokenFactory, - EnclaveToken__factory as EnclaveTokenFactory, - MockCircuitVerifier__factory as MockCircuitVerifierFactory, - MockUSDC__factory as MockUSDCFactory, - MockE3Program__factory as MockE3ProgramFactory, - MockDecryptionVerifier__factory as MockDecryptionVerifierFactory, - SlashingManager__factory as SlashingManagerFactory, -} from "../../types"; - -const { ethers, ignition, networkHelpers } = await network.connect(); -const { loadFixture, time } = networkHelpers; - -describe("Committee Expulsion & Fault Tolerance", function () { - const ONE_HOUR = 60 * 60; - const ONE_DAY = 24 * ONE_HOUR; - const THREE_DAYS = 3 * ONE_DAY; - const SEVEN_DAYS = 7 * ONE_DAY; - const THIRTY_DAYS = 30 * ONE_DAY; - const SORTITION_SUBMISSION_WINDOW = 10; - const addressOne = "0x0000000000000000000000000000000000000001"; - - const REASON_BAD_DKG = ethers.keccak256( - ethers.toUtf8Bytes("E3_BAD_DKG_PROOF"), - ); - const REASON_BAD_DECRYPTION = ethers.keccak256( - ethers.toUtf8Bytes("E3_BAD_DECRYPTION_PROOF"), - ); - - const abiCoder = ethers.AbiCoder.defaultAbiCoder(); - const polynomial_degree = ethers.toBigInt(2048); - const plaintext_modulus = ethers.toBigInt(1032193); - const moduli = [ethers.toBigInt("18014398492704769")]; - - const encodedE3ProgramParams = abiCoder.encode( - ["uint256", "uint256", "uint256[]"], - [polynomial_degree, plaintext_modulus, moduli], - ); - - const encryptionSchemeId = - "0x2c2a814a0495f913a3a312fc4771e37552bc14f8a2d4075a08122d356f0849c6"; - - const defaultTimeoutConfig = { - committeeFormationWindow: ONE_DAY, - dkgWindow: ONE_DAY, - computeWindow: THREE_DAYS, - decryptionWindow: ONE_DAY, - gracePeriod: ONE_HOUR, - }; - - function encodeProof( - zkProof: string = "0x1234", - publicInputs: string[] = [ethers.ZeroHash], - ): string { - return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); - } - - const setup = async () => { - const [ - owner, - requester, - treasury, - operator1, - operator2, - operator3, - operator4, - ] = await ethers.getSigners(); - - const ownerAddress = await owner.getAddress(); - const treasuryAddress = await treasury.getAddress(); - const requesterAddress = await requester.getAddress(); - - // Deploy tokens - const usdcContract = await ignition.deploy(MockStableTokenModule, { - parameters: { MockUSDC: { initialSupply: 10000000 } }, - }); - const usdcToken = MockUSDCFactory.connect( - await usdcContract.mockUSDC.getAddress(), - owner, - ); - - const enclTokenContract = await ignition.deploy(EnclaveTokenModule, { - parameters: { EnclaveToken: { owner: ownerAddress } }, - }); - const enclToken = EnclaveTokenFactory.connect( - await enclTokenContract.enclaveToken.getAddress(), - owner, - ); - await enclToken.setTransferRestriction(false); - - const ticketTokenContract = await ignition.deploy( - EnclaveTicketTokenModule, - { - parameters: { - EnclaveTicketToken: { - baseToken: await usdcToken.getAddress(), - registry: addressOne, - owner: ownerAddress, - }, - }, - }, - ); - - const mockVerifierContract = await ignition.deploy( - MockCircuitVerifierModule, - ); - const mockVerifier = MockCircuitVerifierFactory.connect( - await mockVerifierContract.mockCircuitVerifier.getAddress(), - owner, - ); - - // Deploy slashing manager - const slashingManagerContract = await ignition.deploy( - SlashingManagerModule, - { - parameters: { - SlashingManager: { - admin: ownerAddress, - bondingRegistry: addressOne, - ciphernodeRegistry: addressOne, - enclave: addressOne, - }, - }, - }, - ); - const slashingManager = SlashingManagerFactory.connect( - await slashingManagerContract.slashingManager.getAddress(), - owner, - ); - - // Deploy bonding registry - const bondingRegistryContract = await ignition.deploy( - BondingRegistryModule, - { - parameters: { - BondingRegistry: { - owner: ownerAddress, - ticketToken: - await ticketTokenContract.enclaveTicketToken.getAddress(), - licenseToken: await enclToken.getAddress(), - registry: addressOne, - slashedFundsTreasury: treasuryAddress, - ticketPrice: ethers.parseUnits("10", 6), - licenseRequiredBond: ethers.parseEther("1000"), - minTicketBalance: 1, - exitDelay: SEVEN_DAYS, - }, - }, - }, - ); - const bondingRegistry = BondingRegistryFactory.connect( - await bondingRegistryContract.bondingRegistry.getAddress(), - owner, - ); - - // Deploy Enclave - const enclaveContract = await ignition.deploy(EnclaveModule, { - parameters: { - Enclave: { - params: encodedE3ProgramParams, - owner: ownerAddress, - maxDuration: THIRTY_DAYS, - registry: addressOne, - e3RefundManager: addressOne, - bondingRegistry: await bondingRegistry.getAddress(), - feeToken: await usdcToken.getAddress(), - timeoutConfig: defaultTimeoutConfig, - }, - }, - }); - const enclaveAddress = await enclaveContract.enclave.getAddress(); - const enclave = EnclaveFactory.connect(enclaveAddress, owner); - - // Deploy CiphernodeRegistry - const ciphernodeRegistryContract = await ignition.deploy( - CiphernodeRegistryModule, - { - parameters: { - CiphernodeRegistry: { - enclaveAddress: enclaveAddress, - owner: ownerAddress, - submissionWindow: SORTITION_SUBMISSION_WINDOW, - }, - }, - }, - ); - const registryAddress = - await ciphernodeRegistryContract.cipherNodeRegistry.getAddress(); - const registry = CiphernodeRegistryOwnableFactory.connect( - registryAddress, - owner, - ); - - // Deploy mock E3 program - const e3ProgramContract = await ignition.deploy(MockE3ProgramModule, { - parameters: { - MockE3Program: { - encryptionSchemeId: encryptionSchemeId, - }, - }, - }); - const e3Program = MockE3ProgramFactory.connect( - await e3ProgramContract.mockE3Program.getAddress(), - owner, - ); - - // Deploy mock decryption verifier - const decryptionVerifierContract = await ignition.deploy( - MockDecryptionVerifierModule, - ); - const decryptionVerifier = MockDecryptionVerifierFactory.connect( - await decryptionVerifierContract.mockDecryptionVerifier.getAddress(), - owner, - ); - - // Wire everything together - await enclave.setCiphernodeRegistry(registryAddress); - await enclave.enableE3Program(await e3Program.getAddress()); - await enclave.setDecryptionVerifier( - encryptionSchemeId, - await decryptionVerifier.getAddress(), - ); - await enclave.setSlashingManager(await slashingManager.getAddress()); - - await bondingRegistry.setRewardDistributor(enclaveAddress); - await bondingRegistry.setRegistry(registryAddress); - await bondingRegistry.setSlashingManager( - await slashingManager.getAddress(), - ); - - await slashingManager.setBondingRegistry( - await bondingRegistry.getAddress(), - ); - await slashingManager.setCiphernodeRegistry(registryAddress); - await slashingManager.setEnclave(enclaveAddress); - - await registry.setBondingRegistry(await bondingRegistry.getAddress()); - await registry.setSlashingManager(await slashingManager.getAddress()); - - await ticketTokenContract.enclaveTicketToken.setRegistry( - await bondingRegistry.getAddress(), - ); - - // Mint tokens to requester for E3 requests - await usdcToken.mint(requesterAddress, ethers.parseUnits("100000", 6)); - - // Helper: setup an operator (bond license, register, add tickets) - async function setupOperator(operator: Signer) { - const operatorAddress = await operator.getAddress(); - await enclToken.mintAllocation( - operatorAddress, - ethers.parseEther("10000"), - "Test allocation", - ); - await usdcToken.mint(operatorAddress, ethers.parseUnits("100000", 6)); - - await enclToken - .connect(operator) - .approve(await bondingRegistry.getAddress(), ethers.parseEther("2000")); - await bondingRegistry - .connect(operator) - .bondLicense(ethers.parseEther("1000")); - await bondingRegistry.connect(operator).registerOperator(); - - const ticketTokenAddress = await bondingRegistry.ticketToken(); - const ticketAmount = ethers.parseUnits("100", 6); - await usdcToken - .connect(operator) - .approve(ticketTokenAddress, ticketAmount); - await bondingRegistry.connect(operator).addTicketBalance(ticketAmount); - } - - // Helper: make an E3 request - async function makeRequest(threshold: [number, number] = [2, 3]) { - const startTime = (await time.latest()) + 100; - const requestParams = { - threshold: threshold, - inputWindow: [startTime + 100, startTime + ONE_DAY] as [ - number, - number, - ], - e3Program: await e3Program.getAddress(), - e3ProgramParams: encodedE3ProgramParams, - computeProviderParams: abiCoder.encode( - ["address"], - [await decryptionVerifier.getAddress()], - ), - customParams: abiCoder.encode( - ["address"], - ["0x1234567890123456789012345678901234567890"], - ), - }; - - const fee = await enclave.getE3Quote(requestParams); - await usdcToken.connect(requester).approve(enclaveAddress, fee); - await enclave.connect(requester).request(requestParams); - } - - // Helper: finalize a committee after sortition - async function finalizeCommitteeWithOperators( - e3Id: number, - operators: Signer[], - ) { - for (const op of operators) { - await registry.connect(op).submitTicket(e3Id, 1); - } - await time.increase(SORTITION_SUBMISSION_WINDOW + 1); - await registry.finalizeCommittee(e3Id); - } - - // Set up committee-affecting slash policy - // MockCircuitVerifier returns false by default → proof invalid → fault confirmed - const committeeSlashPolicy = { - ticketPenalty: ethers.parseUnits("10", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: true, - failureReason: 4, // FailureReason.DKGInvalidShares - }; - await slashingManager.setSlashPolicy(REASON_BAD_DKG, committeeSlashPolicy); - - const decryptionSlashPolicy = { - ticketPenalty: ethers.parseUnits("10", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: true, - failureReason: 11, // FailureReason.DecryptionInvalidShares - }; - await slashingManager.setSlashPolicy( - REASON_BAD_DECRYPTION, - decryptionSlashPolicy, - ); - - return { - enclave, - registry, - slashingManager, - bondingRegistry, - mockVerifier, - usdcToken, - enclToken, - owner, - requester, - treasury, - operator1, - operator2, - operator3, - operator4, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - }; - }; - - describe("committee expulsion via proposeSlash", function () { - it("should expel a committee member and emit CommitteeMemberExpelled", async function () { - const { - registry, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - // threshold [2, 3] means M=2, N=3 - await makeRequest([2, 3]); - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - const op1Address = await operator1.getAddress(); - - // Verify member is active before slash - expect(await registry.isCommitteeMemberActive(0, op1Address)).to.be.true; - expect(await registry.getActiveCommitteeCount(0)).to.equal(3); - - // Submit slash proposal — MockCircuitVerifier returns false by default - // so fault is confirmed and slash is auto-executed - const proof = encodeProof(); - const tx = await slashingManager.proposeSlash( - 0, - op1Address, - REASON_BAD_DKG, - proof, - ); - - // Should emit CommitteeMemberExpelled - await expect(tx) - .to.emit(registry, "CommitteeMemberExpelled") - .withArgs(0, op1Address, REASON_BAD_DKG, 2); - - // Should emit CommitteeViabilityUpdated - await expect(tx) - .to.emit(registry, "CommitteeViabilityUpdated") - .withArgs(0, 2, 2, true); // 2 >= 2 → viable - - // Verify member is no longer active - expect(await registry.isCommitteeMemberActive(0, op1Address)).to.be.false; - expect(await registry.getActiveCommitteeCount(0)).to.equal(2); - }); - - it("should keep E3 alive when active members >= threshold", async function () { - const { - enclave, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); // M=2, N=3 - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - // Slash one member — 3 active → 2 active, threshold is 2, still viable - const proof = encodeProof(); - await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // E3 should NOT be failed — stage should still be Requested (1) - // or whatever stage it was at, not Failed - const stage = await enclave.getE3Stage(0); - expect(stage).to.not.equal(6); // 6 = E3Stage.Failed - }); - - it("should fail E3 when active members drop below threshold", async function () { - const { - enclave, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); // M=2, N=3 - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - // Slash first member — 3 → 2 active, still >= 2 - const proof1 = encodeProof("0x1111"); - await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof1, - ); - - let stage = await enclave.getE3Stage(0); - expect(stage).to.not.equal(6); // Not failed yet - - // Slash second member — 2 → 1 active, below threshold M=2 - const proof2 = encodeProof("0x2222"); - const tx = await slashingManager.proposeSlash( - 0, - await operator2.getAddress(), - REASON_BAD_DKG, - proof2, - ); - - // Should emit E3Failed event - await expect(tx).to.emit(enclave, "E3Failed"); - - // E3 should now be Failed - stage = await enclave.getE3Stage(0); - expect(stage).to.equal(6); // E3Stage.Failed - - // Failure reason should be DKGInvalidShares (4) - const reason = await enclave.getFailureReason(0); - expect(reason).to.equal(4); - }); - - it("should handle idempotent expulsion (re-slashing same node)", async function () { - const { - registry, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - // Slash operator1 once - const proof1 = encodeProof("0xaaaa"); - await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof1, - ); - expect(await registry.getActiveCommitteeCount(0)).to.equal(2); - - // Slash operator1 again with different proof (different evidence key) - const proof2 = encodeProof("0xbbbb"); - await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof2, - ); - - // Active count should still be 2 (idempotent expulsion) - expect(await registry.getActiveCommitteeCount(0)).to.equal(2); - }); - - it("should exclude expelled members from getActiveCommitteeNodes", async function () { - const { - registry, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - // Before expulsion: all 3 should be in active nodes - const nodesBefore = await registry.getActiveCommitteeNodes(0); - expect(nodesBefore.length).to.equal(3); - expect(nodesBefore).to.include(await operator1.getAddress()); - - // Expel operator1 - const proof = encodeProof(); - await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // After expulsion: only 2 should be active - const nodesAfter = await registry.getActiveCommitteeNodes(0); - expect(nodesAfter.length).to.equal(2); - expect(nodesAfter).to.not.include(await operator1.getAddress()); - expect(nodesAfter).to.include(await operator2.getAddress()); - expect(nodesAfter).to.include(await operator3.getAddress()); - }); - }); - - describe("E3 continues above threshold", function () { - it("should allow the E3 lifecycle to progress despite expelled member", async function () { - const { - enclave, - registry, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); // M=2, N=3 - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - // Expel one member - const proof = encodeProof(); - await slashingManager.proposeSlash( - 0, - await operator3.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // E3 should still be alive (not failed) - const stage = await enclave.getE3Stage(0); - expect(stage).to.not.equal(6); // Not E3Stage.Failed - - // Active committee still has enough members - expect(await registry.getActiveCommitteeCount(0)).to.equal(2); - const threshold = await registry.getCommitteeThreshold(0); - expect(threshold[0]).to.equal(2); // M=2 - }); - - it("should allow multiple expulsions while staying above threshold", async function () { - const { - enclave, - registry, - slashingManager, - operator1, - operator2, - operator3, - operator4, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - await setupOperator(operator4); - - await makeRequest([2, 4]); // M=2, N=4 - await finalizeCommitteeWithOperators(0, [ - operator1, - operator2, - operator3, - operator4, - ]); - - expect(await registry.getActiveCommitteeCount(0)).to.equal(4); - - // Expel 2 out of 4 — still have 2 >= M=2 - const proof1 = encodeProof("0x1111"); - await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof1, - ); - expect(await registry.getActiveCommitteeCount(0)).to.equal(3); - - const proof2 = encodeProof("0x2222"); - await slashingManager.proposeSlash( - 0, - await operator2.getAddress(), - REASON_BAD_DKG, - proof2, - ); - expect(await registry.getActiveCommitteeCount(0)).to.equal(2); - - // E3 should NOT be failed - const stage = await enclave.getE3Stage(0); - expect(stage).to.not.equal(6); - }); - }); - - describe("E3 fails below threshold", function () { - it("should fail E3 exactly at the threshold breach", async function () { - const { - enclave, - slashingManager, - operator1, - operator2, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - - await makeRequest([2, 2]); // M=2, N=2 — no room for error - await finalizeCommitteeWithOperators(0, [operator1, operator2]); - - // Expel one member: 2 → 1 < M=2 → E3 fails immediately - const proof = encodeProof(); - const tx = await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof, - ); - - await expect(tx).to.emit(enclave, "E3Failed"); - - const stage = await enclave.getE3Stage(0); - expect(stage).to.equal(6); // Failed - }); - - it("should not fail E3 twice on multiple sub-threshold expulsions", async function () { - const { - enclave, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); // M=2, N=3 - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - // Expel operator1 — still viable (2 >= 2) - const proof1 = encodeProof("0x1111"); - await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof1, - ); - - // Expel operator2 — now below threshold (1 < 2), E3 fails - const proof2 = encodeProof("0x2222"); - await slashingManager.proposeSlash( - 0, - await operator2.getAddress(), - REASON_BAD_DKG, - proof2, - ); - - // E3 is now Failed - const stage = await enclave.getE3Stage(0); - expect(stage).to.equal(6); - - // Try to expel operator3 — E3 already failed so onE3Failed should revert - // but expelCommitteeMember itself should still work (idempotent-ish) - const proof3 = encodeProof("0x3333"); - - // This should revert because the E3 is already in Failed state - // and onE3Failed will revert with E3AlreadyFailed - await expect( - slashingManager.proposeSlash( - 0, - await operator3.getAddress(), - REASON_BAD_DKG, - proof3, - ), - ).to.be.revertedWithCustomError(enclave, "E3AlreadyFailed"); - }); - }); - - describe("viability events", function () { - it("should emit CommitteeViabilityUpdated(viable=true) when still above threshold", async function () { - const { - registry, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - const proof = encodeProof(); - const tx = await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // 3 → 2 active, M=2 → viable - await expect(tx) - .to.emit(registry, "CommitteeViabilityUpdated") - .withArgs(0, 2, 2, true); - }); - - it("should emit CommitteeViabilityUpdated(viable=false) when below threshold", async function () { - const { - registry, - slashingManager, - operator1, - operator2, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - - await makeRequest([2, 2]); - await finalizeCommitteeWithOperators(0, [operator1, operator2]); - - const proof = encodeProof(); - const tx = await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // 2 → 1 active, M=2 → not viable - await expect(tx) - .to.emit(registry, "CommitteeViabilityUpdated") - .withArgs(0, 1, 2, false); - }); - }); - - describe("slash execution events", function () { - it("should emit SlashExecuted on proof-based committee slash", async function () { - const { - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); - await finalizeCommitteeWithOperators(0, [operator1, operator2, operator3]); - - const proof = encodeProof(); - const op1Addr = await operator1.getAddress(); - const tx = await slashingManager.proposeSlash( - 0, - op1Addr, - REASON_BAD_DKG, - proof, - ); - - await expect(tx) - .to.emit(slashingManager, "SlashExecuted") - .withArgs( - 0, // proposalId - 0, // e3Id - op1Addr, - REASON_BAD_DKG, - ethers.parseUnits("10", 6), // ticketPenalty - ethers.parseEther("50"), // licensePenalty - true, // executed - ); - }); - }); -}); +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +/** + * Tests for committee expulsion, viability checks, and E3 failure on threshold breach. + * + * Verifies: + * - Committee members are expelled via proposeSlash when affectsCommittee=true + * - The E3 continues as long as active members >= threshold M + * - The E3 fails when active members drop below threshold M + * - Rewards exclude expelled members + * - Idempotent expulsion (re-slashing same node doesn't double-count) + */ +import { expect } from "chai"; +import type { Signer } from "ethers"; +import { network } from "hardhat"; + +import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; +import CiphernodeRegistryModule from "../../ignition/modules/ciphernodeRegistry"; +import EnclaveModule from "../../ignition/modules/enclave"; +import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; +import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; +import MockDecryptionVerifierModule from "../../ignition/modules/mockDecryptionVerifier"; +import MockE3ProgramModule from "../../ignition/modules/mockE3Program"; +import MockCircuitVerifierModule from "../../ignition/modules/mockSlashingVerifier"; +import MockStableTokenModule from "../../ignition/modules/mockStableToken"; +import SlashingManagerModule from "../../ignition/modules/slashingManager"; +import { + BondingRegistry__factory as BondingRegistryFactory, + CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnableFactory, + Enclave__factory as EnclaveFactory, + EnclaveTicketToken__factory as EnclaveTicketTokenFactory, + EnclaveToken__factory as EnclaveTokenFactory, + MockCircuitVerifier__factory as MockCircuitVerifierFactory, + MockDecryptionVerifier__factory as MockDecryptionVerifierFactory, + MockE3Program__factory as MockE3ProgramFactory, + MockUSDC__factory as MockUSDCFactory, + SlashingManager__factory as SlashingManagerFactory, +} from "../../types"; + +const { ethers, ignition, networkHelpers } = await network.connect(); +const { loadFixture, time } = networkHelpers; + +describe("Committee Expulsion & Fault Tolerance", function () { + const ONE_HOUR = 60 * 60; + const ONE_DAY = 24 * ONE_HOUR; + const THREE_DAYS = 3 * ONE_DAY; + const SEVEN_DAYS = 7 * ONE_DAY; + const THIRTY_DAYS = 30 * ONE_DAY; + const SORTITION_SUBMISSION_WINDOW = 10; + const addressOne = "0x0000000000000000000000000000000000000001"; + + const REASON_BAD_DKG = ethers.keccak256( + ethers.toUtf8Bytes("E3_BAD_DKG_PROOF"), + ); + const REASON_BAD_DECRYPTION = ethers.keccak256( + ethers.toUtf8Bytes("E3_BAD_DECRYPTION_PROOF"), + ); + + const abiCoder = ethers.AbiCoder.defaultAbiCoder(); + const polynomial_degree = ethers.toBigInt(2048); + const plaintext_modulus = ethers.toBigInt(1032193); + const moduli = [ethers.toBigInt("18014398492704769")]; + + const encodedE3ProgramParams = abiCoder.encode( + ["uint256", "uint256", "uint256[]"], + [polynomial_degree, plaintext_modulus, moduli], + ); + + const encryptionSchemeId = + "0x2c2a814a0495f913a3a312fc4771e37552bc14f8a2d4075a08122d356f0849c6"; + + const defaultTimeoutConfig = { + committeeFormationWindow: ONE_DAY, + dkgWindow: ONE_DAY, + computeWindow: THREE_DAYS, + decryptionWindow: ONE_DAY, + gracePeriod: ONE_HOUR, + }; + + function encodeProof( + zkProof: string = "0x1234", + publicInputs: string[] = [ethers.ZeroHash], + ): string { + return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); + } + + const setup = async () => { + const [ + owner, + requester, + treasury, + operator1, + operator2, + operator3, + operator4, + ] = await ethers.getSigners(); + + const ownerAddress = await owner.getAddress(); + const treasuryAddress = await treasury.getAddress(); + const requesterAddress = await requester.getAddress(); + + // Deploy tokens + const usdcContract = await ignition.deploy(MockStableTokenModule, { + parameters: { MockUSDC: { initialSupply: 10000000 } }, + }); + const usdcToken = MockUSDCFactory.connect( + await usdcContract.mockUSDC.getAddress(), + owner, + ); + + const enclTokenContract = await ignition.deploy(EnclaveTokenModule, { + parameters: { EnclaveToken: { owner: ownerAddress } }, + }); + const enclToken = EnclaveTokenFactory.connect( + await enclTokenContract.enclaveToken.getAddress(), + owner, + ); + await enclToken.setTransferRestriction(false); + + const ticketTokenContract = await ignition.deploy( + EnclaveTicketTokenModule, + { + parameters: { + EnclaveTicketToken: { + baseToken: await usdcToken.getAddress(), + registry: addressOne, + owner: ownerAddress, + }, + }, + }, + ); + + const mockVerifierContract = await ignition.deploy( + MockCircuitVerifierModule, + ); + const mockVerifier = MockCircuitVerifierFactory.connect( + await mockVerifierContract.mockCircuitVerifier.getAddress(), + owner, + ); + + // Deploy slashing manager + const slashingManagerContract = await ignition.deploy( + SlashingManagerModule, + { + parameters: { + SlashingManager: { + admin: ownerAddress, + bondingRegistry: addressOne, + ciphernodeRegistry: addressOne, + enclave: addressOne, + }, + }, + }, + ); + const slashingManager = SlashingManagerFactory.connect( + await slashingManagerContract.slashingManager.getAddress(), + owner, + ); + + // Deploy bonding registry + const bondingRegistryContract = await ignition.deploy( + BondingRegistryModule, + { + parameters: { + BondingRegistry: { + owner: ownerAddress, + ticketToken: + await ticketTokenContract.enclaveTicketToken.getAddress(), + licenseToken: await enclToken.getAddress(), + registry: addressOne, + slashedFundsTreasury: treasuryAddress, + ticketPrice: ethers.parseUnits("10", 6), + licenseRequiredBond: ethers.parseEther("1000"), + minTicketBalance: 1, + exitDelay: SEVEN_DAYS, + }, + }, + }, + ); + const bondingRegistry = BondingRegistryFactory.connect( + await bondingRegistryContract.bondingRegistry.getAddress(), + owner, + ); + + // Deploy Enclave + const enclaveContract = await ignition.deploy(EnclaveModule, { + parameters: { + Enclave: { + params: encodedE3ProgramParams, + owner: ownerAddress, + maxDuration: THIRTY_DAYS, + registry: addressOne, + e3RefundManager: addressOne, + bondingRegistry: await bondingRegistry.getAddress(), + feeToken: await usdcToken.getAddress(), + timeoutConfig: defaultTimeoutConfig, + }, + }, + }); + const enclaveAddress = await enclaveContract.enclave.getAddress(); + const enclave = EnclaveFactory.connect(enclaveAddress, owner); + + // Deploy CiphernodeRegistry + const ciphernodeRegistryContract = await ignition.deploy( + CiphernodeRegistryModule, + { + parameters: { + CiphernodeRegistry: { + enclaveAddress: enclaveAddress, + owner: ownerAddress, + submissionWindow: SORTITION_SUBMISSION_WINDOW, + }, + }, + }, + ); + const registryAddress = + await ciphernodeRegistryContract.cipherNodeRegistry.getAddress(); + const registry = CiphernodeRegistryOwnableFactory.connect( + registryAddress, + owner, + ); + + // Deploy mock E3 program + const e3ProgramContract = await ignition.deploy(MockE3ProgramModule, { + parameters: { + MockE3Program: { + encryptionSchemeId: encryptionSchemeId, + }, + }, + }); + const e3Program = MockE3ProgramFactory.connect( + await e3ProgramContract.mockE3Program.getAddress(), + owner, + ); + + // Deploy mock decryption verifier + const decryptionVerifierContract = await ignition.deploy( + MockDecryptionVerifierModule, + ); + const decryptionVerifier = MockDecryptionVerifierFactory.connect( + await decryptionVerifierContract.mockDecryptionVerifier.getAddress(), + owner, + ); + + // Wire everything together + await enclave.setCiphernodeRegistry(registryAddress); + await enclave.enableE3Program(await e3Program.getAddress()); + await enclave.setDecryptionVerifier( + encryptionSchemeId, + await decryptionVerifier.getAddress(), + ); + await enclave.setSlashingManager(await slashingManager.getAddress()); + + await bondingRegistry.setRewardDistributor(enclaveAddress); + await bondingRegistry.setRegistry(registryAddress); + await bondingRegistry.setSlashingManager( + await slashingManager.getAddress(), + ); + + await slashingManager.setBondingRegistry( + await bondingRegistry.getAddress(), + ); + await slashingManager.setCiphernodeRegistry(registryAddress); + await slashingManager.setEnclave(enclaveAddress); + + await registry.setBondingRegistry(await bondingRegistry.getAddress()); + await registry.setSlashingManager(await slashingManager.getAddress()); + + await ticketTokenContract.enclaveTicketToken.setRegistry( + await bondingRegistry.getAddress(), + ); + + // Mint tokens to requester for E3 requests + await usdcToken.mint(requesterAddress, ethers.parseUnits("100000", 6)); + + // Helper: setup an operator (bond license, register, add tickets) + async function setupOperator(operator: Signer) { + const operatorAddress = await operator.getAddress(); + await enclToken.mintAllocation( + operatorAddress, + ethers.parseEther("10000"), + "Test allocation", + ); + await usdcToken.mint(operatorAddress, ethers.parseUnits("100000", 6)); + + await enclToken + .connect(operator) + .approve(await bondingRegistry.getAddress(), ethers.parseEther("2000")); + await bondingRegistry + .connect(operator) + .bondLicense(ethers.parseEther("1000")); + await bondingRegistry.connect(operator).registerOperator(); + + const ticketTokenAddress = await bondingRegistry.ticketToken(); + const ticketAmount = ethers.parseUnits("100", 6); + await usdcToken + .connect(operator) + .approve(ticketTokenAddress, ticketAmount); + await bondingRegistry.connect(operator).addTicketBalance(ticketAmount); + } + + // Helper: make an E3 request + async function makeRequest(threshold: [number, number] = [2, 3]) { + const startTime = (await time.latest()) + 100; + const requestParams = { + threshold: threshold, + inputWindow: [startTime + 100, startTime + ONE_DAY] as [number, number], + e3Program: await e3Program.getAddress(), + e3ProgramParams: encodedE3ProgramParams, + computeProviderParams: abiCoder.encode( + ["address"], + [await decryptionVerifier.getAddress()], + ), + customParams: abiCoder.encode( + ["address"], + ["0x1234567890123456789012345678901234567890"], + ), + }; + + const fee = await enclave.getE3Quote(requestParams); + await usdcToken.connect(requester).approve(enclaveAddress, fee); + await enclave.connect(requester).request(requestParams); + } + + // Helper: finalize a committee after sortition + async function finalizeCommitteeWithOperators( + e3Id: number, + operators: Signer[], + ) { + for (const op of operators) { + await registry.connect(op).submitTicket(e3Id, 1); + } + await time.increase(SORTITION_SUBMISSION_WINDOW + 1); + await registry.finalizeCommittee(e3Id); + } + + // Set up committee-affecting slash policy + // MockCircuitVerifier returns false by default → proof invalid → fault confirmed + const committeeSlashPolicy = { + ticketPenalty: ethers.parseUnits("10", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: true, + failureReason: 4, // FailureReason.DKGInvalidShares + }; + await slashingManager.setSlashPolicy(REASON_BAD_DKG, committeeSlashPolicy); + + const decryptionSlashPolicy = { + ticketPenalty: ethers.parseUnits("10", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: true, + failureReason: 11, // FailureReason.DecryptionInvalidShares + }; + await slashingManager.setSlashPolicy( + REASON_BAD_DECRYPTION, + decryptionSlashPolicy, + ); + + return { + enclave, + registry, + slashingManager, + bondingRegistry, + mockVerifier, + usdcToken, + enclToken, + owner, + requester, + treasury, + operator1, + operator2, + operator3, + operator4, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + }; + }; + + describe("committee expulsion via proposeSlash", function () { + it("should expel a committee member and emit CommitteeMemberExpelled", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + // threshold [2, 3] means M=2, N=3 + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + const op1Address = await operator1.getAddress(); + + // Verify member is active before slash + expect(await registry.isCommitteeMemberActive(0, op1Address)).to.be.true; + expect(await registry.getActiveCommitteeCount(0)).to.equal(3); + + // Submit slash proposal — MockCircuitVerifier returns false by default + // so fault is confirmed and slash is auto-executed + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + op1Address, + REASON_BAD_DKG, + proof, + ); + + // Should emit CommitteeMemberExpelled + await expect(tx) + .to.emit(registry, "CommitteeMemberExpelled") + .withArgs(0, op1Address, REASON_BAD_DKG, 2); + + // Should emit CommitteeViabilityUpdated + await expect(tx) + .to.emit(registry, "CommitteeViabilityUpdated") + .withArgs(0, 2, 2, true); // 2 >= 2 → viable + + // Verify member is no longer active + expect(await registry.isCommitteeMemberActive(0, op1Address)).to.be.false; + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + }); + + it("should keep E3 alive when active members >= threshold", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + // Slash one member — 3 active → 2 active, threshold is 2, still viable + const proof = encodeProof(); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // E3 should NOT be failed — stage should still be Requested (1) + // or whatever stage it was at, not Failed + const stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); // 6 = E3Stage.Failed + }); + + it("should fail E3 when active members drop below threshold", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + // Slash first member — 3 → 2 active, still >= 2 + const proof1 = encodeProof("0x1111"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + + let stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); // Not failed yet + + // Slash second member — 2 → 1 active, below threshold M=2 + const proof2 = encodeProof("0x2222"); + const tx = await slashingManager.proposeSlash( + 0, + await operator2.getAddress(), + REASON_BAD_DKG, + proof2, + ); + + // Should emit E3Failed event + await expect(tx).to.emit(enclave, "E3Failed"); + + // E3 should now be Failed + stage = await enclave.getE3Stage(0); + expect(stage).to.equal(6); // E3Stage.Failed + + // Failure reason should be DKGInvalidShares (4) + const reason = await enclave.getFailureReason(0); + expect(reason).to.equal(4); + }); + + it("should handle idempotent expulsion (re-slashing same node)", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + // Slash operator1 once + const proof1 = encodeProof("0xaaaa"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + + // Slash operator1 again with different proof (different evidence key) + const proof2 = encodeProof("0xbbbb"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof2, + ); + + // Active count should still be 2 (idempotent expulsion) + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + }); + + it("should exclude expelled members from getActiveCommitteeNodes", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + // Before expulsion: all 3 should be in active nodes + const nodesBefore = await registry.getActiveCommitteeNodes(0); + expect(nodesBefore.length).to.equal(3); + expect(nodesBefore).to.include(await operator1.getAddress()); + + // Expel operator1 + const proof = encodeProof(); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // After expulsion: only 2 should be active + const nodesAfter = await registry.getActiveCommitteeNodes(0); + expect(nodesAfter.length).to.equal(2); + expect(nodesAfter).to.not.include(await operator1.getAddress()); + expect(nodesAfter).to.include(await operator2.getAddress()); + expect(nodesAfter).to.include(await operator3.getAddress()); + }); + }); + + describe("E3 continues above threshold", function () { + it("should allow the E3 lifecycle to progress despite expelled member", async function () { + const { + enclave, + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + // Expel one member + const proof = encodeProof(); + await slashingManager.proposeSlash( + 0, + await operator3.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // E3 should still be alive (not failed) + const stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); // Not E3Stage.Failed + + // Active committee still has enough members + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + const threshold = await registry.getCommitteeThreshold(0); + expect(threshold[0]).to.equal(2); // M=2 + }); + + it("should allow multiple expulsions while staying above threshold", async function () { + const { + enclave, + registry, + slashingManager, + operator1, + operator2, + operator3, + operator4, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + await setupOperator(operator4); + + await makeRequest([2, 4]); // M=2, N=4 + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + operator4, + ]); + + expect(await registry.getActiveCommitteeCount(0)).to.equal(4); + + // Expel 2 out of 4 — still have 2 >= M=2 + const proof1 = encodeProof("0x1111"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + expect(await registry.getActiveCommitteeCount(0)).to.equal(3); + + const proof2 = encodeProof("0x2222"); + await slashingManager.proposeSlash( + 0, + await operator2.getAddress(), + REASON_BAD_DKG, + proof2, + ); + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + + // E3 should NOT be failed + const stage = await enclave.getE3Stage(0); + expect(stage).to.not.equal(6); + }); + }); + + describe("E3 fails below threshold", function () { + it("should fail E3 exactly at the threshold breach", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + + await makeRequest([2, 2]); // M=2, N=2 — no room for error + await finalizeCommitteeWithOperators(0, [operator1, operator2]); + + // Expel one member: 2 → 1 < M=2 → E3 fails immediately + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + await expect(tx).to.emit(enclave, "E3Failed"); + + const stage = await enclave.getE3Stage(0); + expect(stage).to.equal(6); // Failed + }); + + it("should not fail E3 twice on multiple sub-threshold expulsions", async function () { + const { + enclave, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); // M=2, N=3 + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + // Expel operator1 — still viable (2 >= 2) + const proof1 = encodeProof("0x1111"); + await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof1, + ); + + // Expel operator2 — now below threshold (1 < 2), E3 fails + const proof2 = encodeProof("0x2222"); + await slashingManager.proposeSlash( + 0, + await operator2.getAddress(), + REASON_BAD_DKG, + proof2, + ); + + // E3 is now Failed + const stage = await enclave.getE3Stage(0); + expect(stage).to.equal(6); + + // Try to expel operator3 — E3 already failed so onE3Failed should revert + // but expelCommitteeMember itself should still work (idempotent-ish) + const proof3 = encodeProof("0x3333"); + + // This should revert because the E3 is already in Failed state + // and onE3Failed will revert with E3AlreadyFailed + await expect( + slashingManager.proposeSlash( + 0, + await operator3.getAddress(), + REASON_BAD_DKG, + proof3, + ), + ).to.be.revertedWithCustomError(enclave, "E3AlreadyFailed"); + }); + }); + + describe("viability events", function () { + it("should emit CommitteeViabilityUpdated(viable=true) when still above threshold", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // 3 → 2 active, M=2 → viable + await expect(tx) + .to.emit(registry, "CommitteeViabilityUpdated") + .withArgs(0, 2, 2, true); + }); + + it("should emit CommitteeViabilityUpdated(viable=false) when below threshold", async function () { + const { + registry, + slashingManager, + operator1, + operator2, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + + await makeRequest([2, 2]); + await finalizeCommitteeWithOperators(0, [operator1, operator2]); + + const proof = encodeProof(); + const tx = await slashingManager.proposeSlash( + 0, + await operator1.getAddress(), + REASON_BAD_DKG, + proof, + ); + + // 2 → 1 active, M=2 → not viable + await expect(tx) + .to.emit(registry, "CommitteeViabilityUpdated") + .withArgs(0, 1, 2, false); + }); + }); + + describe("slash execution events", function () { + it("should emit SlashExecuted on proof-based committee slash", async function () { + const { + slashingManager, + operator1, + operator2, + operator3, + setupOperator, + makeRequest, + finalizeCommitteeWithOperators, + } = await loadFixture(setup); + + await setupOperator(operator1); + await setupOperator(operator2); + await setupOperator(operator3); + + await makeRequest([2, 3]); + await finalizeCommitteeWithOperators(0, [ + operator1, + operator2, + operator3, + ]); + + const proof = encodeProof(); + const op1Addr = await operator1.getAddress(); + const tx = await slashingManager.proposeSlash( + 0, + op1Addr, + REASON_BAD_DKG, + proof, + ); + + await expect(tx).to.emit(slashingManager, "SlashExecuted").withArgs( + 0, // proposalId + 0, // e3Id + op1Addr, + REASON_BAD_DKG, + ethers.parseUnits("10", 6), // ticketPenalty + ethers.parseEther("50"), // licensePenalty + true, // executed + ); + }); + }); +}); diff --git a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts index 5c9b6e8563..16ce2efb63 100644 --- a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts +++ b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts @@ -1,1278 +1,1278 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. -import { expect } from "chai"; -import { network } from "hardhat"; - -import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; -import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; -import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; -import MockCircuitVerifierModule from "../../ignition/modules/mockSlashingVerifier"; -import MockStableTokenModule from "../../ignition/modules/mockStableToken"; -import SlashingManagerModule from "../../ignition/modules/slashingManager"; -import { - BondingRegistry__factory as BondingRegistryFactory, - EnclaveTicketToken__factory as EnclaveTicketTokenFactory, - EnclaveToken__factory as EnclaveTokenFactory, - MockCircuitVerifier__factory as MockCircuitVerifierFactory, - MockUSDC__factory as MockUSDCFactory, - SlashingManager__factory as SlashingManagerFactory, -} from "../../types"; -import type { SlashingManager } from "../../types/contracts/slashing/SlashingManager"; -import type { MockCircuitVerifier } from "../../types/contracts/test/MockSlashingVerifier"; - -const { ethers, networkHelpers, ignition } = await network.connect(); -const { loadFixture, time } = networkHelpers; - -describe("SlashingManager", function () { - const REASON_MISBEHAVIOR = ethers.encodeBytes32String("misbehavior"); - const REASON_INACTIVITY = ethers.encodeBytes32String("inactivity"); - const REASON_DOUBLE_SIGN = ethers.encodeBytes32String("doubleSign"); - - const SLASHER_ROLE = ethers.keccak256(ethers.toUtf8Bytes("SLASHER_ROLE")); - const GOVERNANCE_ROLE = ethers.keccak256( - ethers.toUtf8Bytes("GOVERNANCE_ROLE"), - ); - const DEFAULT_ADMIN_ROLE = ethers.ZeroHash; - - const APPEAL_WINDOW = 7 * 24 * 60 * 60; - - // Placeholder address for contracts not under test - const addressOne = "0x0000000000000000000000000000000000000001"; - - const abiCoder = ethers.AbiCoder.defaultAbiCoder(); - - /** - * Helper to encode proof data as (bytes zkProof, bytes32[] publicInputs) - * for the circuit verifier inverted-logic path. - */ - function encodeProof( - zkProof: string = "0x1234", - publicInputs: string[] = [ethers.ZeroHash], - ): string { - return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); - } - - async function setupPolicies( - slashingManager: SlashingManager, - mockVerifier: MockCircuitVerifier, - ) { - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - const evidencePolicy = { - ticketPenalty: ethers.parseUnits("20", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - const banPolicy = { - ticketPenalty: ethers.parseUnits("100", 6), - licensePenalty: ethers.parseEther("500"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: true, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - await slashingManager.setSlashPolicy(REASON_INACTIVITY, evidencePolicy); - await slashingManager.setSlashPolicy(REASON_DOUBLE_SIGN, banPolicy); - } - - async function setup() { - const [owner, slasher, proposer, operator, notTheOwner] = - await ethers.getSigners(); - const ownerAddress = await owner.getAddress(); - const operatorAddress = await operator.getAddress(); - - const usdcContract = await ignition.deploy(MockStableTokenModule, { - parameters: { - MockUSDC: { - initialSupply: 1000000, - }, - }, - }); - - const enclTokenContract = await ignition.deploy(EnclaveTokenModule, { - parameters: { - EnclaveToken: { - owner: ownerAddress, - }, - }, - }); - - const ticketTokenContract = await ignition.deploy( - EnclaveTicketTokenModule, - { - parameters: { - EnclaveTicketToken: { - baseToken: await usdcContract.mockUSDC.getAddress(), - registry: ownerAddress, - owner: ownerAddress, - }, - }, - }, - ); - - const mockVerifierContract = await ignition.deploy( - MockCircuitVerifierModule, - ); - - const slashingManagerContract = await ignition.deploy( - SlashingManagerModule, - { - parameters: { - SlashingManager: { - admin: ownerAddress, - bondingRegistry: ownerAddress, - ciphernodeRegistry: addressOne, - enclave: addressOne, - }, - }, - }, - ); - - const bondingRegistryContract = await ignition.deploy( - BondingRegistryModule, - { - parameters: { - BondingRegistry: { - owner: ownerAddress, - ticketToken: - await ticketTokenContract.enclaveTicketToken.getAddress(), - licenseToken: await enclTokenContract.enclaveToken.getAddress(), - registry: ethers.ZeroAddress, - slashedFundsTreasury: ownerAddress, - ticketPrice: ethers.parseUnits("10", 6), - licenseRequiredBond: ethers.parseEther("1000"), - minTicketBalance: 5, - exitDelay: APPEAL_WINDOW, - }, - }, - }, - ); - - const usdcToken = MockUSDCFactory.connect( - await usdcContract.mockUSDC.getAddress(), - owner, - ); - const enclaveToken = EnclaveTokenFactory.connect( - await enclTokenContract.enclaveToken.getAddress(), - owner, - ); - const ticketToken = EnclaveTicketTokenFactory.connect( - await ticketTokenContract.enclaveTicketToken.getAddress(), - owner, - ); - const mockVerifier = MockCircuitVerifierFactory.connect( - await mockVerifierContract.mockCircuitVerifier.getAddress(), - owner, - ); - const slashingManager = SlashingManagerFactory.connect( - await slashingManagerContract.slashingManager.getAddress(), - owner, - ); - const bondingRegistry = BondingRegistryFactory.connect( - await bondingRegistryContract.bondingRegistry.getAddress(), - owner, - ); - - await ticketToken.setRegistry(await bondingRegistry.getAddress()); - await slashingManager.setBondingRegistry( - await bondingRegistry.getAddress(), - ); - await bondingRegistry.setSlashingManager( - await slashingManager.getAddress(), - ); - - await enclaveToken.setTransferRestriction(false); - - await enclaveToken.mintAllocation( - operatorAddress, - ethers.parseEther("2000"), - "Test allocation", - ); - - await slashingManager.addSlasher(await slasher.getAddress()); - - return { - owner, - slasher, - proposer, - operator, - operatorAddress, - notTheOwner, - slashingManager, - bondingRegistry, - enclaveToken, - ticketToken, - usdcToken, - mockVerifier, - }; - } - - describe("constructor / initialization", function () { - it("should set the admin role correctly", async function () { - const { slashingManager, owner } = await loadFixture(setup); - - expect( - await slashingManager.hasRole( - DEFAULT_ADMIN_ROLE, - await owner.getAddress(), - ), - ).to.be.true; - expect( - await slashingManager.hasRole( - GOVERNANCE_ROLE, - await owner.getAddress(), - ), - ).to.be.true; - }); - - it("should set the bonding registry correctly", async function () { - const { slashingManager, bondingRegistry } = await loadFixture(setup); - - expect(await slashingManager.bondingRegistry()).to.equal( - await bondingRegistry.getAddress(), - ); - }); - - it("should revert if admin is zero address", async function () { - await expect( - ignition.deploy(SlashingManagerModule, { - parameters: { - SlashingManager: { - admin: ethers.ZeroAddress, - bondingRegistry: ethers.ZeroAddress, - ciphernodeRegistry: ethers.ZeroAddress, - enclave: ethers.ZeroAddress, - }, - }, - }), - ).to.be.rejected; - }); - }); - - describe("setSlashPolicy()", function () { - it("should set a valid proof-based slash policy", async function () { - const { slashingManager, mockVerifier } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect(slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy)) - .to.emit(slashingManager, "SlashPolicyUpdated") - .withArgs(REASON_MISBEHAVIOR, Object.values(policy)); - - const storedPolicy = - await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); - expect(storedPolicy.ticketPenalty).to.equal(policy.ticketPenalty); - expect(storedPolicy.licensePenalty).to.equal(policy.licensePenalty); - expect(storedPolicy.requiresProof).to.equal(policy.requiresProof); - expect(storedPolicy.enabled).to.equal(policy.enabled); - }); - - it("should set an evidence-based policy (no proof required)", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("20", 6), - licensePenalty: ethers.parseEther("50"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect(slashingManager.setSlashPolicy(REASON_INACTIVITY, policy)) - .to.emit(slashingManager, "SlashPolicyUpdated") - .withArgs(REASON_INACTIVITY, Object.values(policy)); - }); - - it("should revert if caller is not governance", async function () { - const { slashingManager, notTheOwner } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect( - slashingManager - .connect(notTheOwner) - .setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError( - slashingManager, - "AccessControlUnauthorizedAccount", - ); - }); - - it("should revert if reason is zero", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect( - slashingManager.setSlashPolicy(ethers.ZeroHash, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if policy is disabled", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: false, - affectsCommittee: false, - failureReason: 0, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if no penalties are set", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: 0, - licensePenalty: 0, - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if proof required but no verifier set", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "VerifierNotSet"); - }); - - it("should revert if proof required but appeal window set", async function () { - const { slashingManager, mockVerifier } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: APPEAL_WINDOW, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - - it("should revert if no proof required but no appeal window", async function () { - const { slashingManager } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: false, - proofVerifier: ethers.ZeroAddress, - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await expect( - slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), - ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); - }); - }); - - describe("role management", function () { - it("should add and remove slasher role", async function () { - const { slashingManager, notTheOwner } = await loadFixture(setup); - - await slashingManager.addSlasher(await notTheOwner.getAddress()); - expect( - await slashingManager.hasRole( - SLASHER_ROLE, - await notTheOwner.getAddress(), - ), - ).to.be.true; - - await slashingManager.removeSlasher(await notTheOwner.getAddress()); - expect( - await slashingManager.hasRole( - SLASHER_ROLE, - await notTheOwner.getAddress(), - ), - ).to.be.false; - }); - - it("should revert if non-admin tries to add slasher", async function () { - const { slashingManager, notTheOwner } = await loadFixture(setup); - - await expect( - slashingManager - .connect(notTheOwner) - .addSlasher(await notTheOwner.getAddress()), - ).to.be.revertedWithCustomError( - slashingManager, - "AccessControlUnauthorizedAccount", - ); - }); - - it("should revert if zero address is added as slasher", async function () { - const { slashingManager } = await loadFixture(setup); - - await expect( - slashingManager.addSlasher(ethers.ZeroAddress), - ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); - }); - }); - - describe("proposeSlash() — Lane A (proof-based, permissionless)", function () { - it("should propose and auto-execute slash with proof", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - // MockCircuitVerifier default returnValue=false → proof invalid → fault confirmed - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - - const proof = encodeProof(); - const e3Id = 0; - - // Anyone can call proposeSlash (permissionless for Lane A) - await expect( - slashingManager - .connect(proposer) - .proposeSlash(e3Id, operatorAddress, REASON_MISBEHAVIOR, proof), - ).to.emit(slashingManager, "SlashProposed"); - - // Proof-based slashes auto-execute - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.operator).to.equal(operatorAddress); - expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); - expect(proposal.proofVerified).to.be.true; - expect(proposal.executed).to.be.true; - expect(proposal.proposer).to.equal(await proposer.getAddress()); - }); - - it("should revert if circuit verifier says proof is valid (no fault)", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - - // Set mock verifier to return true → proof is valid → NOT a fault - await mockVerifier.setReturnValue(true); - - const proof = encodeProof(); - await expect( - slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), - ).to.be.revertedWithCustomError(slashingManager, "ProofIsValid"); - }); - - it("should revert if operator is zero address", async function () { - const { slashingManager, proposer, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - const proof = encodeProof(); - - await expect( - slashingManager - .connect(proposer) - .proposeSlash(0, ethers.ZeroAddress, REASON_MISBEHAVIOR, proof), - ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); - }); - - it("should revert if slash reason is disabled", async function () { - const { slashingManager, proposer, operatorAddress } = - await loadFixture(setup); - - const proof = encodeProof(); - - await expect( - slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_DOUBLE_SIGN, proof), - ).to.be.revertedWithCustomError(slashingManager, "SlashReasonDisabled"); - }); - - it("should revert if proof is empty", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - - await expect( - slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, "0x"), - ).to.be.revertedWithCustomError(slashingManager, "ProofRequired"); - }); - - it("should reject duplicate evidence", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - const proofPolicy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: false, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - - const proof = encodeProof(); - await slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); - - // Same proof for same e3Id/operator/reason should be rejected - await expect( - slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), - ).to.be.revertedWithCustomError(slashingManager, "DuplicateEvidence"); - }); - - it("should increment totalProposals", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - expect(await slashingManager.totalProposals()).to.equal(0); - - const proof1 = encodeProof("0x1111"); - await slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof1); - - expect(await slashingManager.totalProposals()).to.equal(1); - - const proof2 = encodeProof("0x2222"); - await slashingManager - .connect(proposer) - .proposeSlash(1, operatorAddress, REASON_MISBEHAVIOR, proof2); - - expect(await slashingManager.totalProposals()).to.equal(2); - }); - - it("should ban node when policy requires it", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - expect(await slashingManager.isBanned(operatorAddress)).to.be.false; - - const proof = encodeProof("0x3333"); - await slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_DOUBLE_SIGN, proof); - - // banNode=true → auto-executed → node is now banned - expect(await slashingManager.isBanned(operatorAddress)).to.be.true; - }); - }); - - describe("proposeSlashEvidence() — Lane B (evidence-based, SLASHER_ROLE)", function () { - it("should propose evidence-based slash with appeal window", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - const evidence = ethers.toUtf8Bytes("operator was inactive during E3"); - const e3Id = 0; - - await expect( - slashingManager - .connect(slasher) - .proposeSlashEvidence( - e3Id, - operatorAddress, - REASON_INACTIVITY, - evidence, - ), - ).to.emit(slashingManager, "SlashProposed"); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.operator).to.equal(operatorAddress); - expect(proposal.reason).to.equal(REASON_INACTIVITY); - expect(proposal.proofVerified).to.be.false; - expect(proposal.executed).to.be.false; - expect(proposal.proposer).to.equal(await slasher.getAddress()); - expect(proposal.executableAt).to.be.gt(proposal.proposedAt); - }); - - it("should revert if caller is not slasher", async function () { - const { slashingManager, notTheOwner, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - const evidence = ethers.toUtf8Bytes("evidence"); - - await expect( - slashingManager - .connect(notTheOwner) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - evidence, - ), - ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); - }); - - it("should revert if operator is zero address", async function () { - const { slashingManager, slasher, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await expect( - slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - ethers.ZeroAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes(""), - ), - ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); - }); - }); - - describe("executeSlash() — Lane B execution", function () { - it("should execute evidence-based slash after appeal window", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - - // Should revert before appeal window expires - await expect( - slashingManager.executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AppealWindowActive"); - - // Fast forward past appeal window - await time.increase(APPEAL_WINDOW + 1); - - await expect(slashingManager.executeSlash(0)).to.emit( - slashingManager, - "SlashExecuted", - ); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.executed).to.be.true; - }); - - it("should revert if proof-based slash tries to executeSlash separately", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - // Proof-based slash auto-executes in proposeSlash - const proof = encodeProof(); - await slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); - - // Should revert because already executed - await expect( - slashingManager.executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AlreadyExecuted"); - }); - - it("should revert if proposal doesn't exist", async function () { - const { slashingManager } = await loadFixture(setup); - - await expect( - slashingManager.executeSlash(999), - ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); - }); - - it("should revert if already executed", async function () { - const { slashingManager, slasher, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - - await time.increase(APPEAL_WINDOW + 1); - await slashingManager.executeSlash(0); - - await expect( - slashingManager.executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AlreadyExecuted"); - }); - }); - - describe("appeal system", function () { - it("should allow operator to file appeal on evidence-based slash", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - - const evidence = "I was not inactive, here's the proof..."; - - await expect(slashingManager.connect(operator).fileAppeal(0, evidence)) - .to.emit(slashingManager, "AppealFiled") - .withArgs(0, operatorAddress, REASON_INACTIVITY, evidence); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.appealed).to.be.true; - }); - - it("should revert if non-operator tries to appeal", async function () { - const { - slashingManager, - slasher, - notTheOwner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - - await expect( - slashingManager.connect(notTheOwner).fileAppeal(0, "Not my appeal"), - ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); - }); - - it("should revert if appeal window expired", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - - await time.increase(APPEAL_WINDOW + 1); - - await expect( - slashingManager.connect(operator).fileAppeal(0, "Too late"), - ).to.be.revertedWithCustomError(slashingManager, "AppealWindowExpired"); - }); - - it("should revert if already appealed", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - - await slashingManager.connect(operator).fileAppeal(0, "First appeal"); - - await expect( - slashingManager.connect(operator).fileAppeal(0, "Second appeal"), - ).to.be.revertedWithCustomError(slashingManager, "AlreadyAppealed"); - }); - - it("should revert if appealing proof-verified slash", async function () { - const { - slashingManager, - proposer, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - // Proof-based slash auto-executes with proofVerified=true - const proof = encodeProof(); - await slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); - - // Cannot appeal proof-verified slashes — appeal window is 0 so it's already expired - await expect( - slashingManager.connect(operator).fileAppeal(0, "Cannot appeal proof"), - ).to.be.revertedWithCustomError(slashingManager, "AppealWindowExpired"); - }); - - it("should allow governance to resolve appeal (approve)", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - - const resolution = "Appeal approved after review"; - - await expect( - slashingManager.connect(owner).resolveAppeal(0, true, resolution), - ) - .to.emit(slashingManager, "AppealResolved") - .withArgs( - 0, - operatorAddress, - true, - await owner.getAddress(), - resolution, - ); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.resolved).to.be.true; - expect(proposal.appealUpheld).to.be.true; - }); - - it("should allow governance to resolve appeal (deny)", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - - await slashingManager - .connect(owner) - .resolveAppeal(0, false, "Appeal denied"); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.resolved).to.be.true; - expect(proposal.appealUpheld).to.be.false; - }); - - it("should block execution if appeal is pending", async function () { - const { - slashingManager, - slasher, - operator, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - - await time.increase(APPEAL_WINDOW + 1); - - await expect( - slashingManager.executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AppealPending"); - }); - - it("should block execution if appeal was approved", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - await slashingManager.connect(owner).resolveAppeal(0, true, "Approved"); - - await time.increase(APPEAL_WINDOW + 1); - - await expect( - slashingManager.executeSlash(0), - ).to.be.revertedWithCustomError(slashingManager, "AppealUpheld"); - }); - - it("should allow execution if appeal was denied", async function () { - const { - slashingManager, - slasher, - operator, - owner, - operatorAddress, - mockVerifier, - } = await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - await slashingManager - .connect(slasher) - .proposeSlashEvidence( - 0, - operatorAddress, - REASON_INACTIVITY, - ethers.toUtf8Bytes("evidence"), - ); - await slashingManager.connect(operator).fileAppeal(0, "Evidence"); - await slashingManager.connect(owner).resolveAppeal(0, false, "Denied"); - - await time.increase(APPEAL_WINDOW + 1); - - await expect(slashingManager.executeSlash(0)).to.emit( - slashingManager, - "SlashExecuted", - ); - }); - }); - - describe("ban management", function () { - it("should allow governance to ban node", async function () { - const { slashingManager, owner, operatorAddress } = - await loadFixture(setup); - - const reason = ethers.encodeBytes32String("manual_ban"); - - await expect( - slashingManager - .connect(owner) - .updateBanStatus(operatorAddress, true, reason), - ) - .to.emit(slashingManager, "NodeBanUpdated") - .withArgs(operatorAddress, true, reason, await owner.getAddress()); - - expect(await slashingManager.isBanned(operatorAddress)).to.be.true; - }); - - it("should allow governance to unban node", async function () { - const { slashingManager, owner, operatorAddress } = - await loadFixture(setup); - - await slashingManager - .connect(owner) - .updateBanStatus( - operatorAddress, - true, - ethers.encodeBytes32String("test"), - ); - expect(await slashingManager.isBanned(operatorAddress)).to.be.true; - - await expect( - slashingManager - .connect(owner) - .updateBanStatus( - operatorAddress, - false, - ethers.encodeBytes32String("test"), - ), - ) - .to.emit(slashingManager, "NodeBanUpdated") - .withArgs( - operatorAddress, - false, - ethers.encodeBytes32String("test"), - await owner.getAddress(), - ); - - expect(await slashingManager.isBanned(operatorAddress)).to.be.false; - }); - - it("should revert if non-governance tries to ban", async function () { - const { slashingManager, notTheOwner, operatorAddress } = - await loadFixture(setup); - - await expect( - slashingManager - .connect(notTheOwner) - .updateBanStatus( - operatorAddress, - false, - ethers.encodeBytes32String("test"), - ), - ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); - }); - }); - - describe("view functions", function () { - it("should return correct slash policy", async function () { - const { slashingManager, mockVerifier } = await loadFixture(setup); - - const policy = { - ticketPenalty: ethers.parseUnits("50", 6), - licensePenalty: ethers.parseEther("100"), - requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), - banNode: true, - appealWindow: 0, - enabled: true, - affectsCommittee: false, - failureReason: 0, - }; - - await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy); - - const retrieved = - await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); - expect(retrieved.ticketPenalty).to.equal(policy.ticketPenalty); - expect(retrieved.licensePenalty).to.equal(policy.licensePenalty); - expect(retrieved.requiresProof).to.equal(policy.requiresProof); - expect(retrieved.proofVerifier).to.equal(policy.proofVerifier); - expect(retrieved.banNode).to.equal(policy.banNode); - expect(retrieved.appealWindow).to.equal(policy.appealWindow); - expect(retrieved.enabled).to.equal(policy.enabled); - expect(retrieved.affectsCommittee).to.equal(policy.affectsCommittee); - expect(retrieved.failureReason).to.equal(policy.failureReason); - }); - - it("should return correct slash proposal", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); - - await setupPolicies(slashingManager, mockVerifier); - - const proof = encodeProof("0x4444"); - await slashingManager - .connect(proposer) - .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); - - const proposal = await slashingManager.getSlashProposal(0); - expect(proposal.operator).to.equal(operatorAddress); - expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); - expect(proposal.ticketAmount).to.equal(ethers.parseUnits("50", 6)); - expect(proposal.licenseAmount).to.equal(ethers.parseEther("100")); - expect(proposal.proposer).to.equal(await proposer.getAddress()); - expect(proposal.proofHash).to.equal(ethers.keccak256(proof)); - expect(proposal.proofVerified).to.be.true; - expect(proposal.executed).to.be.true; - }); - - it("should revert for invalid proposal ID", async function () { - const { slashingManager } = await loadFixture(setup); - - await expect( - slashingManager.getSlashProposal(999), - ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); - }); - }); -}); +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. +import { expect } from "chai"; +import { network } from "hardhat"; + +import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; +import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; +import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; +import MockCircuitVerifierModule from "../../ignition/modules/mockSlashingVerifier"; +import MockStableTokenModule from "../../ignition/modules/mockStableToken"; +import SlashingManagerModule from "../../ignition/modules/slashingManager"; +import { + BondingRegistry__factory as BondingRegistryFactory, + EnclaveTicketToken__factory as EnclaveTicketTokenFactory, + EnclaveToken__factory as EnclaveTokenFactory, + MockCircuitVerifier__factory as MockCircuitVerifierFactory, + MockUSDC__factory as MockUSDCFactory, + SlashingManager__factory as SlashingManagerFactory, +} from "../../types"; +import type { SlashingManager } from "../../types/contracts/slashing/SlashingManager"; +import type { MockCircuitVerifier } from "../../types/contracts/test/MockSlashingVerifier"; + +const { ethers, networkHelpers, ignition } = await network.connect(); +const { loadFixture, time } = networkHelpers; + +describe("SlashingManager", function () { + const REASON_MISBEHAVIOR = ethers.encodeBytes32String("misbehavior"); + const REASON_INACTIVITY = ethers.encodeBytes32String("inactivity"); + const REASON_DOUBLE_SIGN = ethers.encodeBytes32String("doubleSign"); + + const SLASHER_ROLE = ethers.keccak256(ethers.toUtf8Bytes("SLASHER_ROLE")); + const GOVERNANCE_ROLE = ethers.keccak256( + ethers.toUtf8Bytes("GOVERNANCE_ROLE"), + ); + const DEFAULT_ADMIN_ROLE = ethers.ZeroHash; + + const APPEAL_WINDOW = 7 * 24 * 60 * 60; + + // Placeholder address for contracts not under test + const addressOne = "0x0000000000000000000000000000000000000001"; + + const abiCoder = ethers.AbiCoder.defaultAbiCoder(); + + /** + * Helper to encode proof data as (bytes zkProof, bytes32[] publicInputs) + * for the circuit verifier inverted-logic path. + */ + function encodeProof( + zkProof: string = "0x1234", + publicInputs: string[] = [ethers.ZeroHash], + ): string { + return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); + } + + async function setupPolicies( + slashingManager: SlashingManager, + mockVerifier: MockCircuitVerifier, + ) { + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + const evidencePolicy = { + ticketPenalty: ethers.parseUnits("20", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + const banPolicy = { + ticketPenalty: ethers.parseUnits("100", 6), + licensePenalty: ethers.parseEther("500"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: true, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + await slashingManager.setSlashPolicy(REASON_INACTIVITY, evidencePolicy); + await slashingManager.setSlashPolicy(REASON_DOUBLE_SIGN, banPolicy); + } + + async function setup() { + const [owner, slasher, proposer, operator, notTheOwner] = + await ethers.getSigners(); + const ownerAddress = await owner.getAddress(); + const operatorAddress = await operator.getAddress(); + + const usdcContract = await ignition.deploy(MockStableTokenModule, { + parameters: { + MockUSDC: { + initialSupply: 1000000, + }, + }, + }); + + const enclTokenContract = await ignition.deploy(EnclaveTokenModule, { + parameters: { + EnclaveToken: { + owner: ownerAddress, + }, + }, + }); + + const ticketTokenContract = await ignition.deploy( + EnclaveTicketTokenModule, + { + parameters: { + EnclaveTicketToken: { + baseToken: await usdcContract.mockUSDC.getAddress(), + registry: ownerAddress, + owner: ownerAddress, + }, + }, + }, + ); + + const mockVerifierContract = await ignition.deploy( + MockCircuitVerifierModule, + ); + + const slashingManagerContract = await ignition.deploy( + SlashingManagerModule, + { + parameters: { + SlashingManager: { + admin: ownerAddress, + bondingRegistry: ownerAddress, + ciphernodeRegistry: addressOne, + enclave: addressOne, + }, + }, + }, + ); + + const bondingRegistryContract = await ignition.deploy( + BondingRegistryModule, + { + parameters: { + BondingRegistry: { + owner: ownerAddress, + ticketToken: + await ticketTokenContract.enclaveTicketToken.getAddress(), + licenseToken: await enclTokenContract.enclaveToken.getAddress(), + registry: ethers.ZeroAddress, + slashedFundsTreasury: ownerAddress, + ticketPrice: ethers.parseUnits("10", 6), + licenseRequiredBond: ethers.parseEther("1000"), + minTicketBalance: 5, + exitDelay: APPEAL_WINDOW, + }, + }, + }, + ); + + const usdcToken = MockUSDCFactory.connect( + await usdcContract.mockUSDC.getAddress(), + owner, + ); + const enclaveToken = EnclaveTokenFactory.connect( + await enclTokenContract.enclaveToken.getAddress(), + owner, + ); + const ticketToken = EnclaveTicketTokenFactory.connect( + await ticketTokenContract.enclaveTicketToken.getAddress(), + owner, + ); + const mockVerifier = MockCircuitVerifierFactory.connect( + await mockVerifierContract.mockCircuitVerifier.getAddress(), + owner, + ); + const slashingManager = SlashingManagerFactory.connect( + await slashingManagerContract.slashingManager.getAddress(), + owner, + ); + const bondingRegistry = BondingRegistryFactory.connect( + await bondingRegistryContract.bondingRegistry.getAddress(), + owner, + ); + + await ticketToken.setRegistry(await bondingRegistry.getAddress()); + await slashingManager.setBondingRegistry( + await bondingRegistry.getAddress(), + ); + await bondingRegistry.setSlashingManager( + await slashingManager.getAddress(), + ); + + await enclaveToken.setTransferRestriction(false); + + await enclaveToken.mintAllocation( + operatorAddress, + ethers.parseEther("2000"), + "Test allocation", + ); + + await slashingManager.addSlasher(await slasher.getAddress()); + + return { + owner, + slasher, + proposer, + operator, + operatorAddress, + notTheOwner, + slashingManager, + bondingRegistry, + enclaveToken, + ticketToken, + usdcToken, + mockVerifier, + }; + } + + describe("constructor / initialization", function () { + it("should set the admin role correctly", async function () { + const { slashingManager, owner } = await loadFixture(setup); + + expect( + await slashingManager.hasRole( + DEFAULT_ADMIN_ROLE, + await owner.getAddress(), + ), + ).to.be.true; + expect( + await slashingManager.hasRole( + GOVERNANCE_ROLE, + await owner.getAddress(), + ), + ).to.be.true; + }); + + it("should set the bonding registry correctly", async function () { + const { slashingManager, bondingRegistry } = await loadFixture(setup); + + expect(await slashingManager.bondingRegistry()).to.equal( + await bondingRegistry.getAddress(), + ); + }); + + it("should revert if admin is zero address", async function () { + await expect( + ignition.deploy(SlashingManagerModule, { + parameters: { + SlashingManager: { + admin: ethers.ZeroAddress, + bondingRegistry: ethers.ZeroAddress, + ciphernodeRegistry: ethers.ZeroAddress, + enclave: ethers.ZeroAddress, + }, + }, + }), + ).to.be.rejected; + }); + }); + + describe("setSlashPolicy()", function () { + it("should set a valid proof-based slash policy", async function () { + const { slashingManager, mockVerifier } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect(slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy)) + .to.emit(slashingManager, "SlashPolicyUpdated") + .withArgs(REASON_MISBEHAVIOR, Object.values(policy)); + + const storedPolicy = + await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); + expect(storedPolicy.ticketPenalty).to.equal(policy.ticketPenalty); + expect(storedPolicy.licensePenalty).to.equal(policy.licensePenalty); + expect(storedPolicy.requiresProof).to.equal(policy.requiresProof); + expect(storedPolicy.enabled).to.equal(policy.enabled); + }); + + it("should set an evidence-based policy (no proof required)", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("20", 6), + licensePenalty: ethers.parseEther("50"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect(slashingManager.setSlashPolicy(REASON_INACTIVITY, policy)) + .to.emit(slashingManager, "SlashPolicyUpdated") + .withArgs(REASON_INACTIVITY, Object.values(policy)); + }); + + it("should revert if caller is not governance", async function () { + const { slashingManager, notTheOwner } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager + .connect(notTheOwner) + .setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError( + slashingManager, + "AccessControlUnauthorizedAccount", + ); + }); + + it("should revert if reason is zero", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(ethers.ZeroHash, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if policy is disabled", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: false, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if no penalties are set", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: 0, + licensePenalty: 0, + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if proof required but no verifier set", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "VerifierNotSet"); + }); + + it("should revert if proof required but appeal window set", async function () { + const { slashingManager, mockVerifier } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: APPEAL_WINDOW, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + + it("should revert if no proof required but no appeal window", async function () { + const { slashingManager } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: false, + proofVerifier: ethers.ZeroAddress, + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await expect( + slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy), + ).to.be.revertedWithCustomError(slashingManager, "InvalidPolicy"); + }); + }); + + describe("role management", function () { + it("should add and remove slasher role", async function () { + const { slashingManager, notTheOwner } = await loadFixture(setup); + + await slashingManager.addSlasher(await notTheOwner.getAddress()); + expect( + await slashingManager.hasRole( + SLASHER_ROLE, + await notTheOwner.getAddress(), + ), + ).to.be.true; + + await slashingManager.removeSlasher(await notTheOwner.getAddress()); + expect( + await slashingManager.hasRole( + SLASHER_ROLE, + await notTheOwner.getAddress(), + ), + ).to.be.false; + }); + + it("should revert if non-admin tries to add slasher", async function () { + const { slashingManager, notTheOwner } = await loadFixture(setup); + + await expect( + slashingManager + .connect(notTheOwner) + .addSlasher(await notTheOwner.getAddress()), + ).to.be.revertedWithCustomError( + slashingManager, + "AccessControlUnauthorizedAccount", + ); + }); + + it("should revert if zero address is added as slasher", async function () { + const { slashingManager } = await loadFixture(setup); + + await expect( + slashingManager.addSlasher(ethers.ZeroAddress), + ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); + }); + }); + + describe("proposeSlash() — Lane A (proof-based, permissionless)", function () { + it("should propose and auto-execute slash with proof", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + // MockCircuitVerifier default returnValue=false → proof invalid → fault confirmed + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + const proof = encodeProof(); + const e3Id = 0; + + // Anyone can call proposeSlash (permissionless for Lane A) + await expect( + slashingManager + .connect(proposer) + .proposeSlash(e3Id, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.emit(slashingManager, "SlashProposed"); + + // Proof-based slashes auto-execute + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.operator).to.equal(operatorAddress); + expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); + expect(proposal.proofVerified).to.be.true; + expect(proposal.executed).to.be.true; + expect(proposal.proposer).to.equal(await proposer.getAddress()); + }); + + it("should revert if circuit verifier says proof is valid (no fault)", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + // Set mock verifier to return true → proof is valid → NOT a fault + await mockVerifier.setReturnValue(true); + + const proof = encodeProof(); + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError(slashingManager, "ProofIsValid"); + }); + + it("should revert if operator is zero address", async function () { + const { slashingManager, proposer, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const proof = encodeProof(); + + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, ethers.ZeroAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); + }); + + it("should revert if slash reason is disabled", async function () { + const { slashingManager, proposer, operatorAddress } = + await loadFixture(setup); + + const proof = encodeProof(); + + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_DOUBLE_SIGN, proof), + ).to.be.revertedWithCustomError(slashingManager, "SlashReasonDisabled"); + }); + + it("should revert if proof is empty", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, "0x"), + ).to.be.revertedWithCustomError(slashingManager, "ProofRequired"); + }); + + it("should reject duplicate evidence", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + const proof = encodeProof(); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + // Same proof for same e3Id/operator/reason should be rejected + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError(slashingManager, "DuplicateEvidence"); + }); + + it("should increment totalProposals", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + expect(await slashingManager.totalProposals()).to.equal(0); + + const proof1 = encodeProof("0x1111"); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof1); + + expect(await slashingManager.totalProposals()).to.equal(1); + + const proof2 = encodeProof("0x2222"); + await slashingManager + .connect(proposer) + .proposeSlash(1, operatorAddress, REASON_MISBEHAVIOR, proof2); + + expect(await slashingManager.totalProposals()).to.equal(2); + }); + + it("should ban node when policy requires it", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + expect(await slashingManager.isBanned(operatorAddress)).to.be.false; + + const proof = encodeProof("0x3333"); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_DOUBLE_SIGN, proof); + + // banNode=true → auto-executed → node is now banned + expect(await slashingManager.isBanned(operatorAddress)).to.be.true; + }); + }); + + describe("proposeSlashEvidence() — Lane B (evidence-based, SLASHER_ROLE)", function () { + it("should propose evidence-based slash with appeal window", async function () { + const { slashingManager, slasher, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const evidence = ethers.toUtf8Bytes("operator was inactive during E3"); + const e3Id = 0; + + await expect( + slashingManager + .connect(slasher) + .proposeSlashEvidence( + e3Id, + operatorAddress, + REASON_INACTIVITY, + evidence, + ), + ).to.emit(slashingManager, "SlashProposed"); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.operator).to.equal(operatorAddress); + expect(proposal.reason).to.equal(REASON_INACTIVITY); + expect(proposal.proofVerified).to.be.false; + expect(proposal.executed).to.be.false; + expect(proposal.proposer).to.equal(await slasher.getAddress()); + expect(proposal.executableAt).to.be.gt(proposal.proposedAt); + }); + + it("should revert if caller is not slasher", async function () { + const { slashingManager, notTheOwner, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const evidence = ethers.toUtf8Bytes("evidence"); + + await expect( + slashingManager + .connect(notTheOwner) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + evidence, + ), + ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); + }); + + it("should revert if operator is zero address", async function () { + const { slashingManager, slasher, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await expect( + slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + ethers.ZeroAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes(""), + ), + ).to.be.revertedWithCustomError(slashingManager, "ZeroAddress"); + }); + }); + + describe("executeSlash() — Lane B execution", function () { + it("should execute evidence-based slash after appeal window", async function () { + const { slashingManager, slasher, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + // Should revert before appeal window expires + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AppealWindowActive"); + + // Fast forward past appeal window + await time.increase(APPEAL_WINDOW + 1); + + await expect(slashingManager.executeSlash(0)).to.emit( + slashingManager, + "SlashExecuted", + ); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.executed).to.be.true; + }); + + it("should revert if proof-based slash tries to executeSlash separately", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + // Proof-based slash auto-executes in proposeSlash + const proof = encodeProof(); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + // Should revert because already executed + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AlreadyExecuted"); + }); + + it("should revert if proposal doesn't exist", async function () { + const { slashingManager } = await loadFixture(setup); + + await expect( + slashingManager.executeSlash(999), + ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); + }); + + it("should revert if already executed", async function () { + const { slashingManager, slasher, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await time.increase(APPEAL_WINDOW + 1); + await slashingManager.executeSlash(0); + + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AlreadyExecuted"); + }); + }); + + describe("appeal system", function () { + it("should allow operator to file appeal on evidence-based slash", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + const evidence = "I was not inactive, here's the proof..."; + + await expect(slashingManager.connect(operator).fileAppeal(0, evidence)) + .to.emit(slashingManager, "AppealFiled") + .withArgs(0, operatorAddress, REASON_INACTIVITY, evidence); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.appealed).to.be.true; + }); + + it("should revert if non-operator tries to appeal", async function () { + const { + slashingManager, + slasher, + notTheOwner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await expect( + slashingManager.connect(notTheOwner).fileAppeal(0, "Not my appeal"), + ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); + }); + + it("should revert if appeal window expired", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await time.increase(APPEAL_WINDOW + 1); + + await expect( + slashingManager.connect(operator).fileAppeal(0, "Too late"), + ).to.be.revertedWithCustomError(slashingManager, "AppealWindowExpired"); + }); + + it("should revert if already appealed", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + + await slashingManager.connect(operator).fileAppeal(0, "First appeal"); + + await expect( + slashingManager.connect(operator).fileAppeal(0, "Second appeal"), + ).to.be.revertedWithCustomError(slashingManager, "AlreadyAppealed"); + }); + + it("should revert if appealing proof-verified slash", async function () { + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + // Proof-based slash auto-executes with proofVerified=true + const proof = encodeProof(); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + // Cannot appeal proof-verified slashes — appeal window is 0 so it's already expired + await expect( + slashingManager.connect(operator).fileAppeal(0, "Cannot appeal proof"), + ).to.be.revertedWithCustomError(slashingManager, "AppealWindowExpired"); + }); + + it("should allow governance to resolve appeal (approve)", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + + const resolution = "Appeal approved after review"; + + await expect( + slashingManager.connect(owner).resolveAppeal(0, true, resolution), + ) + .to.emit(slashingManager, "AppealResolved") + .withArgs( + 0, + operatorAddress, + true, + await owner.getAddress(), + resolution, + ); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.resolved).to.be.true; + expect(proposal.appealUpheld).to.be.true; + }); + + it("should allow governance to resolve appeal (deny)", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + + await slashingManager + .connect(owner) + .resolveAppeal(0, false, "Appeal denied"); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.resolved).to.be.true; + expect(proposal.appealUpheld).to.be.false; + }); + + it("should block execution if appeal is pending", async function () { + const { + slashingManager, + slasher, + operator, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + + await time.increase(APPEAL_WINDOW + 1); + + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AppealPending"); + }); + + it("should block execution if appeal was approved", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + await slashingManager.connect(owner).resolveAppeal(0, true, "Approved"); + + await time.increase(APPEAL_WINDOW + 1); + + await expect( + slashingManager.executeSlash(0), + ).to.be.revertedWithCustomError(slashingManager, "AppealUpheld"); + }); + + it("should allow execution if appeal was denied", async function () { + const { + slashingManager, + slasher, + operator, + owner, + operatorAddress, + mockVerifier, + } = await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + await slashingManager + .connect(slasher) + .proposeSlashEvidence( + 0, + operatorAddress, + REASON_INACTIVITY, + ethers.toUtf8Bytes("evidence"), + ); + await slashingManager.connect(operator).fileAppeal(0, "Evidence"); + await slashingManager.connect(owner).resolveAppeal(0, false, "Denied"); + + await time.increase(APPEAL_WINDOW + 1); + + await expect(slashingManager.executeSlash(0)).to.emit( + slashingManager, + "SlashExecuted", + ); + }); + }); + + describe("ban management", function () { + it("should allow governance to ban node", async function () { + const { slashingManager, owner, operatorAddress } = + await loadFixture(setup); + + const reason = ethers.encodeBytes32String("manual_ban"); + + await expect( + slashingManager + .connect(owner) + .updateBanStatus(operatorAddress, true, reason), + ) + .to.emit(slashingManager, "NodeBanUpdated") + .withArgs(operatorAddress, true, reason, await owner.getAddress()); + + expect(await slashingManager.isBanned(operatorAddress)).to.be.true; + }); + + it("should allow governance to unban node", async function () { + const { slashingManager, owner, operatorAddress } = + await loadFixture(setup); + + await slashingManager + .connect(owner) + .updateBanStatus( + operatorAddress, + true, + ethers.encodeBytes32String("test"), + ); + expect(await slashingManager.isBanned(operatorAddress)).to.be.true; + + await expect( + slashingManager + .connect(owner) + .updateBanStatus( + operatorAddress, + false, + ethers.encodeBytes32String("test"), + ), + ) + .to.emit(slashingManager, "NodeBanUpdated") + .withArgs( + operatorAddress, + false, + ethers.encodeBytes32String("test"), + await owner.getAddress(), + ); + + expect(await slashingManager.isBanned(operatorAddress)).to.be.false; + }); + + it("should revert if non-governance tries to ban", async function () { + const { slashingManager, notTheOwner, operatorAddress } = + await loadFixture(setup); + + await expect( + slashingManager + .connect(notTheOwner) + .updateBanStatus( + operatorAddress, + false, + ethers.encodeBytes32String("test"), + ), + ).to.be.revertedWithCustomError(slashingManager, "Unauthorized"); + }); + }); + + describe("view functions", function () { + it("should return correct slash policy", async function () { + const { slashingManager, mockVerifier } = await loadFixture(setup); + + const policy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: await mockVerifier.getAddress(), + banNode: true, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, policy); + + const retrieved = + await slashingManager.getSlashPolicy(REASON_MISBEHAVIOR); + expect(retrieved.ticketPenalty).to.equal(policy.ticketPenalty); + expect(retrieved.licensePenalty).to.equal(policy.licensePenalty); + expect(retrieved.requiresProof).to.equal(policy.requiresProof); + expect(retrieved.proofVerifier).to.equal(policy.proofVerifier); + expect(retrieved.banNode).to.equal(policy.banNode); + expect(retrieved.appealWindow).to.equal(policy.appealWindow); + expect(retrieved.enabled).to.equal(policy.enabled); + expect(retrieved.affectsCommittee).to.equal(policy.affectsCommittee); + expect(retrieved.failureReason).to.equal(policy.failureReason); + }); + + it("should return correct slash proposal", async function () { + const { slashingManager, proposer, operatorAddress, mockVerifier } = + await loadFixture(setup); + + await setupPolicies(slashingManager, mockVerifier); + + const proof = encodeProof("0x4444"); + await slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); + + const proposal = await slashingManager.getSlashProposal(0); + expect(proposal.operator).to.equal(operatorAddress); + expect(proposal.reason).to.equal(REASON_MISBEHAVIOR); + expect(proposal.ticketAmount).to.equal(ethers.parseUnits("50", 6)); + expect(proposal.licenseAmount).to.equal(ethers.parseEther("100")); + expect(proposal.proposer).to.equal(await proposer.getAddress()); + expect(proposal.proofHash).to.equal(ethers.keccak256(proof)); + expect(proposal.proofVerified).to.be.true; + expect(proposal.executed).to.be.true; + }); + + it("should revert for invalid proposal ID", async function () { + const { slashingManager } = await loadFixture(setup); + + await expect( + slashingManager.getSlashProposal(999), + ).to.be.revertedWithCustomError(slashingManager, "InvalidProposal"); + }); + }); +}); From f2016ddce26d364b276d017560506a7220fbf763 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 15 Feb 2026 17:48:20 +0500 Subject: [PATCH 10/32] fix: remove unused var --- .../enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts index 7d65dc3134..88e71b16fc 100644 --- a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -32,7 +32,6 @@ import { BondingRegistry__factory as BondingRegistryFactory, CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnableFactory, Enclave__factory as EnclaveFactory, - EnclaveTicketToken__factory as EnclaveTicketTokenFactory, EnclaveToken__factory as EnclaveTokenFactory, MockCircuitVerifier__factory as MockCircuitVerifierFactory, MockDecryptionVerifier__factory as MockDecryptionVerifierFactory, From a93bc5e62ad13c87b0f1dd3b38aae9a0f805ba33 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Tue, 17 Feb 2026 10:54:55 +0500 Subject: [PATCH 11/32] fix: fixtures for zk circuits --- crates/events/src/enclave_event/proof.rs | 42 +- .../events/src/enclave_event/signed_proof.rs | 40 +- .../src/circuits/dkg/share_decryption.rs | 17 +- .../src/circuits/dkg/share_encryption.rs | 17 +- .../threshold/decrypted_shares_aggregation.rs | 9 +- crates/zk-prover/src/circuits/utils.rs | 10 + .../decrypted_shares_aggregation.json | 84 - .../fixtures/decrypted_shares_aggregation.vk | Bin 3680 -> 0 bytes .../decrypted_shares_aggregation_bn.json | 1 + .../decrypted_shares_aggregation_bn.vk | Bin 0 -> 1888 bytes .../decrypted_shares_aggregation_mod.json | 1 + .../decrypted_shares_aggregation_mod.vk | Bin 0 -> 1888 bytes .../fixtures/dkg_e_sm_share_decryption.json | 61 - .../fixtures/dkg_e_sm_share_decryption.vk | Bin 3680 -> 0 bytes .../fixtures/dkg_sk_share_decryption.json | 61 - .../tests/fixtures/dkg_sk_share_decryption.vk | Bin 3680 -> 0 bytes .../fixtures/e_sm_share_computation.json | 88 +- .../tests/fixtures/e_sm_share_computation.vk | Bin 3680 -> 1888 bytes .../tests/fixtures/e_sm_share_encryption.json | 228 --- .../tests/fixtures/e_sm_share_encryption.vk | Bin 3680 -> 0 bytes crates/zk-prover/tests/fixtures/pk.json | 66 +- .../tests/fixtures/pk_aggregation.json | 117 +- .../tests/fixtures/pk_aggregation.vk | Bin 3680 -> 1888 bytes .../tests/fixtures/pk_generation.json | 155 +- .../zk-prover/tests/fixtures/pk_generation.vk | Bin 3680 -> 1888 bytes .../tests/fixtures/share_decryption.json | 1 + .../tests/fixtures/share_decryption.vk | Bin 0 -> 1888 bytes .../tests/fixtures/share_encryption.json | 1 + .../tests/fixtures/share_encryption.vk | Bin 0 -> 1888 bytes .../tests/fixtures/sk_share_computation.json | 83 +- .../tests/fixtures/sk_share_computation.vk | Bin 3680 -> 1888 bytes .../tests/fixtures/sk_share_encryption.json | 228 --- .../tests/fixtures/sk_share_encryption.vk | Bin 3680 -> 0 bytes .../fixtures/threshold_share_decryption.json | 145 -- .../fixtures/threshold_share_decryption.vk | Bin 3680 -> 0 bytes .../tests/fixtures/user_data_encryption.json | 1 + .../tests/fixtures/user_data_encryption.vk | Bin 0 -> 1888 bytes crates/zk-prover/tests/local_e2e_tests.rs | 160 +- .../contracts/verifier/DkgPkVerifier.sol | 1635 +++++------------ 39 files changed, 549 insertions(+), 2702 deletions(-) delete mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.json delete mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.vk create mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.json create mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.vk create mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json create mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.vk delete mode 100644 crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.json delete mode 100644 crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.vk delete mode 100644 crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.json delete mode 100644 crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.vk delete mode 100644 crates/zk-prover/tests/fixtures/e_sm_share_encryption.json delete mode 100644 crates/zk-prover/tests/fixtures/e_sm_share_encryption.vk create mode 100644 crates/zk-prover/tests/fixtures/share_decryption.json create mode 100644 crates/zk-prover/tests/fixtures/share_decryption.vk create mode 100644 crates/zk-prover/tests/fixtures/share_encryption.json create mode 100644 crates/zk-prover/tests/fixtures/share_encryption.vk delete mode 100644 crates/zk-prover/tests/fixtures/sk_share_encryption.json delete mode 100644 crates/zk-prover/tests/fixtures/sk_share_encryption.vk delete mode 100644 crates/zk-prover/tests/fixtures/threshold_share_decryption.json delete mode 100644 crates/zk-prover/tests/fixtures/threshold_share_decryption.vk create mode 100644 crates/zk-prover/tests/fixtures/user_data_encryption.json create mode 100644 crates/zk-prover/tests/fixtures/user_data_encryption.vk diff --git a/crates/events/src/enclave_event/proof.rs b/crates/events/src/enclave_event/proof.rs index 48cc967cee..625cd09a38 100644 --- a/crates/events/src/enclave_event/proof.rs +++ b/crates/events/src/enclave_event/proof.rs @@ -44,20 +44,20 @@ pub enum CircuitName { SkShareComputation, /// E_SM share computation proof (C2b). ESmShareComputation, - /// Encrypted sk share proof (C3a). - SkShareEncryption, - /// Encrypted E_SM share proof (C3b). - ESmShareEncryption, - /// Sk share decryption proof (C4a). - DkgSkShareDecryption, - /// E_SM share decryption proof (C4b). - DkgESmShareDecryption, + /// Share encryption proof (C3). + ShareEncryption, + /// DKG share decryption proof (C4). + DkgShareDecryption, /// Public key aggregation proof (C5). PkAggregation, /// Decryption share proof (C6). ThresholdShareDecryption, - /// Decrypted shares aggregation proof (C7). - DecryptedSharesAggregation, + /// Decrypted shares aggregation proof — BigNum variant (C7a). + DecryptedSharesAggregationBn, + /// Decrypted shares aggregation proof — Modular variant (C7b). + DecryptedSharesAggregationMod, + /// User data encryption proof. + UserDataEncryption, } impl CircuitName { @@ -67,13 +67,13 @@ impl CircuitName { CircuitName::PkGeneration => "pk_generation", CircuitName::SkShareComputation => "sk_share_computation", CircuitName::ESmShareComputation => "e_sm_share_computation", - CircuitName::SkShareEncryption => "sk_share_encryption", - CircuitName::ESmShareEncryption => "e_sm_share_encryption", - CircuitName::DkgSkShareDecryption => "dkg_sk_share_decryption", - CircuitName::DkgESmShareDecryption => "dkg_e_sm_share_decryption", + CircuitName::ShareEncryption => "share_encryption", + CircuitName::DkgShareDecryption => "share_decryption", CircuitName::PkAggregation => "pk_aggregation", - CircuitName::ThresholdShareDecryption => "threshold_share_decryption", - CircuitName::DecryptedSharesAggregation => "decrypted_shares_aggregation", + CircuitName::ThresholdShareDecryption => "share_decryption", + CircuitName::DecryptedSharesAggregationBn => "decrypted_shares_aggregation_bn", + CircuitName::DecryptedSharesAggregationMod => "decrypted_shares_aggregation_mod", + CircuitName::UserDataEncryption => "user_data_encryption", } } @@ -82,14 +82,14 @@ impl CircuitName { CircuitName::PkBfv => "dkg", CircuitName::SkShareComputation => "dkg", CircuitName::ESmShareComputation => "dkg", - CircuitName::SkShareEncryption => "dkg", - CircuitName::ESmShareEncryption => "dkg", - CircuitName::DkgSkShareDecryption => "dkg", - CircuitName::DkgESmShareDecryption => "dkg", + CircuitName::ShareEncryption => "dkg", + CircuitName::DkgShareDecryption => "dkg", CircuitName::PkGeneration => "threshold", CircuitName::ThresholdShareDecryption => "threshold", CircuitName::PkAggregation => "threshold", - CircuitName::DecryptedSharesAggregation => "threshold", + CircuitName::DecryptedSharesAggregationBn => "threshold", + CircuitName::DecryptedSharesAggregationMod => "threshold", + CircuitName::UserDataEncryption => "threshold", } } diff --git a/crates/events/src/enclave_event/signed_proof.rs b/crates/events/src/enclave_event/signed_proof.rs index 554b98e0cd..6748429bac 100644 --- a/crates/events/src/enclave_event/signed_proof.rs +++ b/crates/events/src/enclave_event/signed_proof.rs @@ -37,18 +37,14 @@ pub enum ProofType { T1SkShareComputation = 2, /// T1 — Smudging noise share computation proof (Proof 2b). T1ESmShareComputation = 3, - /// T1 — Secret key share encryption proof (Proof 3a). - T1SkShareEncryption = 4, - /// T1 — Smudging noise share encryption proof (Proof 3b). - T1ESmShareEncryption = 5, - /// T2 — Secret key share decryption proof (Proof 4a). - T2SkShareDecryption = 6, - /// T2 — Smudging noise share decryption proof (Proof 4b). - T2ESmShareDecryption = 7, - /// T5 — Share decryption proof (Proof 6). - T5ShareDecryption = 8, + /// T1 — Share encryption proof (Proof 3). + T1ShareEncryption = 4, + /// T2 — DKG share decryption proof (Proof 4). + T2DkgShareDecryption = 5, + /// T5 — Threshold share decryption proof (Proof 6). + T5ShareDecryption = 6, /// T6 — Decrypted shares aggregation proof (Proof 7). - T6DecryptedSharesAggregation = 9, + T6DecryptedSharesAggregation = 7, } impl ProofType { @@ -59,12 +55,10 @@ impl ProofType { ProofType::T1PkGeneration => CircuitName::PkGeneration, ProofType::T1SkShareComputation => CircuitName::SkShareComputation, ProofType::T1ESmShareComputation => CircuitName::ESmShareComputation, - ProofType::T1SkShareEncryption => CircuitName::SkShareEncryption, - ProofType::T1ESmShareEncryption => CircuitName::ESmShareEncryption, - ProofType::T2SkShareDecryption => CircuitName::DkgSkShareDecryption, - ProofType::T2ESmShareDecryption => CircuitName::DkgESmShareDecryption, + ProofType::T1ShareEncryption => CircuitName::ShareEncryption, + ProofType::T2DkgShareDecryption => CircuitName::DkgShareDecryption, ProofType::T5ShareDecryption => CircuitName::ThresholdShareDecryption, - ProofType::T6DecryptedSharesAggregation => CircuitName::DecryptedSharesAggregation, + ProofType::T6DecryptedSharesAggregation => CircuitName::DecryptedSharesAggregationBn, } } @@ -75,10 +69,8 @@ impl ProofType { | ProofType::T1PkGeneration | ProofType::T1SkShareComputation | ProofType::T1ESmShareComputation - | ProofType::T1SkShareEncryption - | ProofType::T1ESmShareEncryption - | ProofType::T2SkShareDecryption - | ProofType::T2ESmShareDecryption => "E3_BAD_DKG_PROOF", + | ProofType::T1ShareEncryption + | ProofType::T2DkgShareDecryption => "E3_BAD_DKG_PROOF", ProofType::T5ShareDecryption => "E3_BAD_DECRYPTION_PROOF", ProofType::T6DecryptedSharesAggregation => "E3_BAD_AGGREGATION_PROOF", } @@ -307,12 +299,12 @@ mod tests { CircuitName::PkGeneration ); assert_eq!( - ProofType::T1SkShareEncryption.circuit_name(), - CircuitName::SkShareEncryption + ProofType::T1ShareEncryption.circuit_name(), + CircuitName::ShareEncryption ); assert_eq!( - ProofType::T2SkShareDecryption.circuit_name(), - CircuitName::DkgSkShareDecryption + ProofType::T2DkgShareDecryption.circuit_name(), + CircuitName::DkgShareDecryption ); assert_eq!( ProofType::T5ShareDecryption.circuit_name(), diff --git a/crates/zk-prover/src/circuits/dkg/share_decryption.rs b/crates/zk-prover/src/circuits/dkg/share_decryption.rs index 3778385085..8641aa9147 100644 --- a/crates/zk-prover/src/circuits/dkg/share_decryption.rs +++ b/crates/zk-prover/src/circuits/dkg/share_decryption.rs @@ -7,7 +7,6 @@ use crate::traits::Provable; use e3_events::CircuitName; use e3_fhe_params::BfvPreset; -use e3_zk_helpers::computation::DkgInputType; use e3_zk_helpers::dkg::share_decryption::{ Inputs, ShareDecryptionCircuit, ShareDecryptionCircuitData, }; @@ -17,21 +16,7 @@ impl Provable for ShareDecryptionCircuit { type Input = ShareDecryptionCircuitData; type Inputs = Inputs; - fn resolve_circuit_name(&self, input: &Self::Input) -> CircuitName { - match input.dkg_input_type { - DkgInputType::SecretKey => CircuitName::DkgSkShareDecryption, - DkgInputType::SmudgingNoise => CircuitName::DkgESmShareDecryption, - } - } - - fn valid_circuits(&self) -> Vec { - vec![ - CircuitName::DkgSkShareDecryption, - CircuitName::DkgESmShareDecryption, - ] - } - fn circuit(&self) -> CircuitName { - CircuitName::DkgSkShareDecryption + CircuitName::DkgShareDecryption } } diff --git a/crates/zk-prover/src/circuits/dkg/share_encryption.rs b/crates/zk-prover/src/circuits/dkg/share_encryption.rs index 1608a9d4df..ad206b8d87 100644 --- a/crates/zk-prover/src/circuits/dkg/share_encryption.rs +++ b/crates/zk-prover/src/circuits/dkg/share_encryption.rs @@ -7,7 +7,6 @@ use crate::traits::Provable; use e3_events::CircuitName; use e3_fhe_params::BfvPreset; -use e3_zk_helpers::computation::DkgInputType; use e3_zk_helpers::dkg::share_encryption::{ Inputs, ShareEncryptionCircuit, ShareEncryptionCircuitData, }; @@ -17,21 +16,7 @@ impl Provable for ShareEncryptionCircuit { type Input = ShareEncryptionCircuitData; type Inputs = Inputs; - fn resolve_circuit_name(&self, _input: &Self::Input) -> CircuitName { - match _input.dkg_input_type { - DkgInputType::SecretKey => CircuitName::SkShareEncryption, - DkgInputType::SmudgingNoise => CircuitName::ESmShareEncryption, - } - } - - fn valid_circuits(&self) -> Vec { - vec![ - CircuitName::SkShareEncryption, - CircuitName::ESmShareEncryption, - ] - } - fn circuit(&self) -> CircuitName { - CircuitName::SkShareEncryption + CircuitName::ShareEncryption } } diff --git a/crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs b/crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs index 6cf3e3d2f8..189d3baa6c 100644 --- a/crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs +++ b/crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs @@ -18,6 +18,13 @@ impl Provable for DecryptedSharesAggregationCircuit { type Inputs = Inputs; fn circuit(&self) -> CircuitName { - CircuitName::DecryptedSharesAggregation + CircuitName::DecryptedSharesAggregationBn + } + + fn valid_circuits(&self) -> Vec { + vec![ + CircuitName::DecryptedSharesAggregationBn, + CircuitName::DecryptedSharesAggregationMod, + ] } } diff --git a/crates/zk-prover/src/circuits/utils.rs b/crates/zk-prover/src/circuits/utils.rs index 2464a52cc1..e19828d95c 100644 --- a/crates/zk-prover/src/circuits/utils.rs +++ b/crates/zk-prover/src/circuits/utils.rs @@ -32,6 +32,16 @@ fn json_value_to_input_value(v: &serde_json::Value) -> Result; L]; T + 1],\n party_ids: pub [Field; T + 1],\n message: pub Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n) {\n let decrypted_shares_aggregation: DecryptedSharesAggregationModular = DecryptedSharesAggregationModular::new(\n DECRYPTED_SHARES_AGGREGATION_CONFIGS,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n );\n\n decrypted_shares_aggregation.execute();\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/decrypted_shares_aggregation_mod/src/main.nr" - }, - "67": { - "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::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\nuse dep::bignum::BigNum;\nuse dep::bignum::bignum::to_field;\nuse dep::bignum::SecureThreshold8192;\n\n/// Cryptographic parameters for decryption share aggregation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Plaintext modulus (typically denoted as `t`)\n pub plaintext_modulus: Field,\n /// Precomputed value: `-Q^(-1) mod t` where Q is the product of all CRT moduli\n pub q_inverse_mod_t: Field,\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], plaintext_modulus: Field, q_inverse_mod_t: Field) -> Self {\n Configs { qis, plaintext_modulus, q_inverse_mod_t }\n }\n}\n\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using BigNum\n/// for large Q values.\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationBigNum {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using modular arithmetic\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationModular {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n\nimpl DecryptedSharesAggregationBigNum {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationBigNum {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Verifies decoding using BigNum for large Q values\n fn verify_decoding(self) {\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1 as Field;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_bn = SecureThreshold8192::from(q_modulus);\n\n let q_half_bn = q_bn.udiv(SecureThreshold8192::from(2));\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let u_bn = SecureThreshold8192::from(self.u_global.coefficients[coeff_idx]);\n let t_bn = SecureThreshold8192::from(self.configs.plaintext_modulus);\n let u_bn_mod_q = u_bn.umod(q_bn);\n let t_bn_mod_q = t_bn.umod(q_bn);\n let t_times_u_bn_q = (t_bn_mod_q * u_bn_mod_q).umod(q_bn);\n\n let m = ModU128::new(self.configs.plaintext_modulus);\n\n // Check if centering is needed\n let needs_centering = t_times_u_bn_q > q_half_bn;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_bn - t_times_u_bn_q;\n let centered_positive_mod_t = centered_positive.umod(t_bn);\n let centered_field = to_field(centered_positive_mod_t);\n m.mul_mod(self.configs.q_inverse_mod_t, centered_field)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_bn_t = t_times_u_bn_q.umod(t_bn);\n let t_times_u_field = to_field(t_times_u_bn_t);\n let product = m.mul_mod(self.configs.q_inverse_mod_t, t_times_u_field);\n if product == 0 {\n 0\n } else {\n self.configs.plaintext_modulus - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\nimpl DecryptedSharesAggregationModular {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationModular {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Alternative verification function using efficient modular arithmetic without BigNum.\n ///\n /// Uses `ModU128` for decoding verification instead of BigNum. More efficient when\n /// Q (the product of all CRT moduli) fits within u128 (e.g., 72 bits for insecure parameter sets).\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Alternative decoding verification using the formula:\n /// message = -Q^{-1} * (t * u_global)_Q mod t\n fn verify_decoding(self) {\n let t: Field = self.configs.plaintext_modulus;\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_half = q_modulus as u128 / 2;\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let q_mod = ModU128::new(q_modulus);\n let t_mod = ModU128::new(t);\n\n // Compute (t * u_global) mod Q using modular arithmetic functions\n let t_times_u_mod_q = q_mod.mul_mod(t, self.u_global.coefficients[coeff_idx]);\n let needs_centering = (t_times_u_mod_q as u128) > q_half;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_modulus - t_times_u_mod_q;\n let centered_positive_mod_t = t_mod.reduce_mod(centered_positive);\n\n t_mod.mul_mod(self.configs.q_inverse_mod_t, centered_positive_mod_t)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_mod_t = t_mod.reduce_mod(t_times_u_mod_q);\n let product = t_mod.mul_mod(self.configs.q_inverse_mod_t, t_times_u_mod_t);\n if product == 0 {\n 0\n } else {\n t - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\n/// Computes all Lagrange coefficients using optimized modular arithmetic\npub fn compute_all_lagrange_coeffs(\n qis: [Field; L],\n party_ids: [Field; T + 1],\n) -> [[Field; T + 1]; L] {\n let mut lagrange_coeffs = [[0 as Field; T + 1]; L];\n\n // Step 1: Cache |x_i - x_j| factors for all party pairs\n let mut diffs = [[0 as Field; T + 1]; T + 1];\n for i in 0..(T + 1) {\n for j in (i + 1)..(T + 1) {\n let diff = party_ids[j] - party_ids[i];\n diffs[i][j] = diff;\n diffs[j][i] = diff;\n }\n }\n\n // Step 2: Determine signs (same for all parties within a basis)\n let numerator_sign_negative = (T % 2) == 1;\n\n // Step 3: For each CRT basis, compute Lagrange coefficients\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n\n // Compute product of all party IDs: PRODUCT(j=0..T) x_j mod q_l\n let mut product_x = 1 as Field;\n for j in 0..(T + 1) {\n product_x = m.mul_mod(product_x, party_ids[j]);\n }\n\n // For each party i, compute L_i(0) mod q_l\n for party_idx in 0..(T + 1) {\n // Numerator (absolute value): PRODUCT(j!=party_idx) x_j\n let numerator_abs = m.div_mod(product_x, party_ids[party_idx]);\n\n // Denominator (absolute value): PRODUCT(j!=party_idx) |x_party_idx - x_j|\n let mut denominator_abs = 1 as Field;\n for j in 0..(T + 1) {\n if j != party_idx {\n denominator_abs = m.mul_mod(denominator_abs, diffs[party_idx][j]);\n }\n }\n\n // Determine denominator sign\n let num_greater = T - party_idx;\n let denom_sign_negative = (num_greater % 2) == 1;\n\n // Compute unsigned result: |numerator| / |denominator| mod q_l\n let result_abs = m.div_mod(numerator_abs, denominator_abs);\n\n // Apply combined sign\n let should_negate = numerator_sign_negative != denom_sign_negative;\n let result = if should_negate {\n m.reduce_mod(q_l - result_abs)\n } else {\n result_abs\n };\n\n lagrange_coeffs[basis_idx][party_idx] = result;\n }\n }\n\n lagrange_coeffs\n}\n\n/// Computes u^{(l)} for each CRT basis via Lagrange interpolation\npub fn compute_crt_components(\n qis: [Field; L],\n decryption_shares: [[Polynomial; L]; T + 1],\n lagrange_coeffs: [[Field; T + 1]; L],\n) -> [Polynomial; L] {\n let mut u_crts: [Polynomial; L] =\n [Polynomial::new([0; MAX_MSG_NON_ZERO_COEFFS]); L];\n\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n let mut u_coeffs = [0 as Field; MAX_MSG_NON_ZERO_COEFFS];\n\n // For each coefficient position\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n let mut u_coeff = 0 as Field;\n\n // Sum all contributions: u = SUM(i=0..T) [d_i * L_i(0)] mod q_l\n for party_idx in 0..(T + 1) {\n let d_coeff = decryption_shares[party_idx][basis_idx].coefficients[coeff_idx];\n let l_i_0 = lagrange_coeffs[basis_idx][party_idx];\n\n let term = m.mul_mod(d_coeff, l_i_0);\n u_coeff = m.reduce_mod(u_coeff + term);\n }\n\n u_coeffs[coeff_idx] = u_coeff;\n }\n\n u_crts[basis_idx] = Polynomial::new(u_coeffs);\n }\n\n u_crts\n}\n\n/// Verifies CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global for all bases l\npub fn verify_crt_reconstruction(\n qis: [Field; L],\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n u_crts: [Polynomial; L],\n) {\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n\n // Compute r^{(l)} * q_l\n let r_times_q = crt_quotients[basis_idx].mul_scalar(q_l);\n\n // Compute u^{(l)} + r^{(l)} * q_l\n let reconstructed = u_crts[basis_idx].add(r_times_q);\n\n // Verify: u^{(l)} + r^{(l)} * q_l = u_global\n // Must hold for every coefficient\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n assert(\n reconstructed.coefficients[coeff_idx] == u_global.coefficients[coeff_idx],\n \"CRT reconstruction verification failed\",\n );\n }\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/decrypted_shares_aggregation.nr" - }, - "77": { - "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" - }, - "79": { - "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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.vk b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.vk deleted file mode 100644 index 562dea5f7fc7c41527c18fc92d822b70762bc7c1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3680 zcmajic|26>9|!PfESaIPjhSmrc7{T^vS(@JQlez55u+rRl(Ah!Ws4|c#zkn-q9|Tt zrYy<5SF($lqE&AAT}zf0y67i&?w@_<_3EDg&UrtdbI$8I=lP!RLFl`i+;za(r@o&~hzsgp{^7M$grDb$TlfF`PF<0iWbw3qKrp%~a~F4L8Ut zj9dy_uq)QOJR7PiL3ud$Y)wHRaEYkipqv$#_EvI`c9~hUcQ|l_4`tg1j$Zb?elBJaxNB+qu1V#lt4}u^ zSy)WDtGpXHLO70(Sd^(xviH>JJaxzexP;we@)yx9A^yImPt9)SYaarRkW})B%0fWC zZ*fKU8L{bWz%MyRTxrukIO*1B?|j{{E=m_TLL&CZ@cg->y-s0jPjJJhfMX`!dQ(*k z_441~#PmMO(29X0wBFCu$gspwc|~UCgeOS{`1yc&`K}7lY1z`(^aNsWvjK2~jP5pz zow^{U*)T!Hw9MB4Z=r=$UJ&oFsmnTNtQnh$$cY|8`t1&x;6LRJ-gK$)NLDRBO~ zQ;jyLKI>RJ<;v`TM=|j^CX_c;Z!F9;Z*`ryhwFc0rV2bZyCZ)7B;GKMwqPA1_wa{y z;0O`zto(yKOz4OAy)3O?JpsJ6s@-ClL2b;W*5ZS6WRHmfM@VO|YUiqb9-n&d{N5*r zB!DLmZK|DkCUWm6YoT+Y>bKqdfFq;1<{@ElD`}M_e*ke)%GN9UHi6m}gRf zd6$UVI?I&)6zc=<{DSL0usHu|w}xFmuaX)0;WWr=efh&+@}k^qt zx#t7Rj7O6e0=FkW^GX9=-pnzyY#KRJD6_APgz|fgfD6`tfp%%z&C9C{x^$n!C28Qk zs_up}50xajr49>ppGlH7aD=3%l*kmc&Y6Tn{8vS}HYUp-rV_wsIw3DL+ zaD*g|q<3`Dm&0!FA+X;wxWFTLpL9Q*IG9|Sn&KxG$;;Ub93dH^ed0;UkI&T$9>pX^ zrUTzEZDStOl}NJ*%nnSf9?0kfE~q~;p^n5FG}iftFoSBfj9 zk|Krjdb%FGZf8T$>T&ko?ye%>buW9DsY5k6T`oL=1h;TD7|gC6ASClICbmPU;6RI_jGl) zZq(8W#|q^oxg*%)G}`H^rc&vQ{CePKwDp!=HW#UrH}miN{k)|IejgChwqI99z0as z$jW)oojHJ6DlZ3~(5hfJYVV*qx?|pt5N{%y3|z2&QyL!pSu*VVcwo&ogC$4c$M;5D zC9reuam`2yvgG&YgzGO#PGe4Blx#bF+1!M*9*~zA&P-nD4*pZ&;qSrizAINJOW}Lyk*5OrBq@~Jdu75i$wL%wxOEzS8__GEX7_ zzW+Bca$I|RDZ{QUBW!Fyo@<;?p5UEieR2O8jMYn`*3Z}bfWKS`?wZPVb8?T)`IYb{ z`{6U-g8t2guanuJj?Zz9uJPIS2DttVuVO4b6<@;GI!xKEdhjuD!S93Z8f${&Fo*6~ zL+K~_1J5^MlE-)W*pkv;bh{$Dg%@yybcvd+*nE?NVXFo7AO=IozdZo|kG|Fa-V^!n zA>WKRePety>q@;thP;Mo9B)UkaQ~&!HA8)Wi&e~#+J`lkTmMZOp-mTRr&zh(ZT$-- cHEtq0Bt_r|=?_j1=zZ [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str {}\n}\n\nimpl From> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n","path":"std/array/mod.nr"},"5":{"source":"use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let self_len = self.len();\n let other_len = other.len();\n let min_len = if self_len < other_len {\n self_len\n } else {\n other_len\n };\n\n let mut result = Ordering::equal();\n for i in 0..min_len {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n\n if result != Ordering::equal() {\n result\n } else {\n self_len.cmp(other_len)\n }\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min, Ord};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n\n #[test]\n fn lexicographic_ordering_for_slices() {\n assert(&[2_u32].cmp(&[1_u32, 1_u32, 1_u32]) == super::Ordering::greater());\n assert(&[1_u32, 2_u32].cmp(&[1_u32, 2_u32, 3_u32]) == super::Ordering::less());\n }\n}\n","path":"std/cmp.nr"},"17":{"source":"use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n\n #[test]\n fn check_decompose_edge_cases() {\n assert_eq(decompose(0), (0, 0));\n assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n }\n\n #[test]\n fn check_decompose_large_values() {\n let large_field = 0xffffffffffffffff;\n let (lo, hi) = decompose(large_field);\n assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n let large_value = large_field - TWO_POW_128;\n let (lo2, hi2) = decompose(large_value);\n assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n }\n\n #[test]\n fn check_lt_comprehensive() {\n assert(lt(0, 1));\n assert(!lt(1, 0));\n assert(!lt(0, 0));\n assert(!lt(42, 42));\n\n assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n }\n}\n","path":"std/field/bn254.nr"},"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"39":{"source":"use crate::convert::AsPrimitive;\n\n// docs:start:add-trait\npub trait Add {\n fn add(self, other: Self) -> Self;\n}\n// docs:end:add-trait\n\nimpl Add for Field {\n fn add(self, other: Field) -> Field {\n self + other\n }\n}\n\nimpl Add for u128 {\n fn add(self, other: u128) -> u128 {\n self + other\n }\n}\nimpl Add for u64 {\n fn add(self, other: u64) -> u64 {\n self + other\n }\n}\nimpl Add for u32 {\n fn add(self, other: u32) -> u32 {\n self + other\n }\n}\nimpl Add for u16 {\n fn add(self, other: u16) -> u16 {\n self + other\n }\n}\nimpl Add for u8 {\n fn add(self, other: u8) -> u8 {\n self + other\n }\n}\nimpl Add for u1 {\n fn add(self, other: u1) -> u1 {\n self + other\n }\n}\n\nimpl Add for i8 {\n fn add(self, other: i8) -> i8 {\n self + other\n }\n}\nimpl Add for i16 {\n fn add(self, other: i16) -> i16 {\n self + other\n }\n}\nimpl Add for i32 {\n fn add(self, other: i32) -> i32 {\n self + other\n }\n}\nimpl Add for i64 {\n fn add(self, other: i64) -> i64 {\n self + other\n }\n}\n\n// docs:start:sub-trait\npub trait Sub {\n fn sub(self, other: Self) -> Self;\n}\n// docs:end:sub-trait\n\nimpl Sub for Field {\n fn sub(self, other: Field) -> Field {\n self - other\n }\n}\n\nimpl Sub for u128 {\n fn sub(self, other: u128) -> u128 {\n self - other\n }\n}\nimpl Sub for u64 {\n fn sub(self, other: u64) -> u64 {\n self - other\n }\n}\nimpl Sub for u32 {\n fn sub(self, other: u32) -> u32 {\n self - other\n }\n}\nimpl Sub for u16 {\n fn sub(self, other: u16) -> u16 {\n self - other\n }\n}\nimpl Sub for u8 {\n fn sub(self, other: u8) -> u8 {\n self - other\n }\n}\nimpl Sub for u1 {\n fn sub(self, other: u1) -> u1 {\n self - other\n }\n}\n\nimpl Sub for i8 {\n fn sub(self, other: i8) -> i8 {\n self - other\n }\n}\nimpl Sub for i16 {\n fn sub(self, other: i16) -> i16 {\n self - other\n }\n}\nimpl Sub for i32 {\n fn sub(self, other: i32) -> i32 {\n self - other\n }\n}\nimpl Sub for i64 {\n fn sub(self, other: i64) -> i64 {\n self - other\n }\n}\n\n// docs:start:mul-trait\npub trait Mul {\n fn mul(self, other: Self) -> Self;\n}\n// docs:end:mul-trait\n\nimpl Mul for Field {\n fn mul(self, other: Field) -> Field {\n self * other\n }\n}\n\nimpl Mul for u128 {\n fn mul(self, other: u128) -> u128 {\n self * other\n }\n}\nimpl Mul for u64 {\n fn mul(self, other: u64) -> u64 {\n self * other\n }\n}\nimpl Mul for u32 {\n fn mul(self, other: u32) -> u32 {\n self * other\n }\n}\nimpl Mul for u16 {\n fn mul(self, other: u16) -> u16 {\n self * other\n }\n}\nimpl Mul for u8 {\n fn mul(self, other: u8) -> u8 {\n self * other\n }\n}\nimpl Mul for u1 {\n fn mul(self, other: u1) -> u1 {\n self * other\n }\n}\n\nimpl Mul for i8 {\n fn mul(self, other: i8) -> i8 {\n self * other\n }\n}\nimpl Mul for i16 {\n fn mul(self, other: i16) -> i16 {\n self * other\n }\n}\nimpl Mul for i32 {\n fn mul(self, other: i32) -> i32 {\n self * other\n }\n}\nimpl Mul for i64 {\n fn mul(self, other: i64) -> i64 {\n self * other\n }\n}\n\n// docs:start:div-trait\npub trait Div {\n fn div(self, other: Self) -> Self;\n}\n// docs:end:div-trait\n\nimpl Div for Field {\n fn div(self, other: Field) -> Field {\n self / other\n }\n}\n\nimpl Div for u128 {\n fn div(self, other: u128) -> u128 {\n self / other\n }\n}\nimpl Div for u64 {\n fn div(self, other: u64) -> u64 {\n self / other\n }\n}\nimpl Div for u32 {\n fn div(self, other: u32) -> u32 {\n self / other\n }\n}\nimpl Div for u16 {\n fn div(self, other: u16) -> u16 {\n self / other\n }\n}\nimpl Div for u8 {\n fn div(self, other: u8) -> u8 {\n self / other\n }\n}\nimpl Div for u1 {\n fn div(self, other: u1) -> u1 {\n self / other\n }\n}\n\nimpl Div for i8 {\n fn div(self, other: i8) -> i8 {\n self / other\n }\n}\nimpl Div for i16 {\n fn div(self, other: i16) -> i16 {\n self / other\n }\n}\nimpl Div for i32 {\n fn div(self, other: i32) -> i32 {\n self / other\n }\n}\nimpl Div for i64 {\n fn div(self, other: i64) -> i64 {\n self / other\n }\n}\n\n// docs:start:rem-trait\npub trait Rem {\n fn rem(self, other: Self) -> Self;\n}\n// docs:end:rem-trait\n\nimpl Rem for u128 {\n fn rem(self, other: u128) -> u128 {\n self % other\n }\n}\nimpl Rem for u64 {\n fn rem(self, other: u64) -> u64 {\n self % other\n }\n}\nimpl Rem for u32 {\n fn rem(self, other: u32) -> u32 {\n self % other\n }\n}\nimpl Rem for u16 {\n fn rem(self, other: u16) -> u16 {\n self % other\n }\n}\nimpl Rem for u8 {\n fn rem(self, other: u8) -> u8 {\n self % other\n }\n}\nimpl Rem for u1 {\n fn rem(self, other: u1) -> u1 {\n self % other\n }\n}\n\nimpl Rem for i8 {\n fn rem(self, other: i8) -> i8 {\n self % other\n }\n}\nimpl Rem for i16 {\n fn rem(self, other: i16) -> i16 {\n self % other\n }\n}\nimpl Rem for i32 {\n fn rem(self, other: i32) -> i32 {\n self % other\n }\n}\nimpl Rem for i64 {\n fn rem(self, other: i64) -> i64 {\n self % other\n }\n}\n\n// docs:start:neg-trait\npub trait Neg {\n fn neg(self) -> Self;\n}\n// docs:end:neg-trait\n\n// docs:start:neg-trait-impls\nimpl Neg for Field {\n fn neg(self) -> Field {\n -self\n }\n}\n\nimpl Neg for i8 {\n fn neg(self) -> i8 {\n -self\n }\n}\nimpl Neg for i16 {\n fn neg(self) -> i16 {\n -self\n }\n}\nimpl Neg for i32 {\n fn neg(self) -> i32 {\n -self\n }\n}\nimpl Neg for i64 {\n fn neg(self) -> i64 {\n -self\n }\n}\n// docs:end:neg-trait-impls\n\n// docs:start:wrapping-add-trait\npub trait WrappingAdd {\n fn wrapping_add(self, y: Self) -> Self;\n}\n// docs:end:wrapping-add-trait\n\nimpl WrappingAdd for u1 {\n fn wrapping_add(self: u1, y: u1) -> u1 {\n self ^ y\n }\n}\n\nimpl WrappingAdd for u8 {\n fn wrapping_add(self: u8, y: u8) -> u8 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u16 {\n fn wrapping_add(self: u16, y: u16) -> u16 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u32 {\n fn wrapping_add(self: u32, y: u32) -> u32 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u64 {\n fn wrapping_add(self: u64, y: u64) -> u64 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u128 {\n fn wrapping_add(self: u128, y: u128) -> u128 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for i8 {\n fn wrapping_add(self: i8, y: i8) -> i8 {\n let x = self as u8;\n x.wrapping_add(y as u8) as i8\n }\n}\n\nimpl WrappingAdd for i16 {\n fn wrapping_add(self: i16, y: i16) -> i16 {\n let x = self as u16;\n x.wrapping_add(y as u16) as i16\n }\n}\n\nimpl WrappingAdd for i32 {\n fn wrapping_add(self: i32, y: i32) -> i32 {\n let x = self as u32;\n x.wrapping_add(y as u32) as i32\n }\n}\n\nimpl WrappingAdd for i64 {\n fn wrapping_add(self: i64, y: i64) -> i64 {\n let x = self as u64;\n x.wrapping_add(y as u64) as i64\n }\n}\nimpl WrappingAdd for Field {\n fn wrapping_add(self: Field, y: Field) -> Field {\n self + y\n }\n}\n\n// docs:start:wrapping-sub-trait\npub trait WrappingSub {\n fn wrapping_sub(self, y: Self) -> Self;\n}\n// docs:start:wrapping-sub-trait\n\nimpl WrappingSub for u1 {\n fn wrapping_sub(self: u1, y: u1) -> u1 {\n self ^ y\n }\n}\n\nimpl WrappingSub for u8 {\n fn wrapping_sub(self: u8, y: u8) -> u8 {\n wrapping_sub_hlp(self, y) as u8\n }\n}\n\nimpl WrappingSub for u16 {\n fn wrapping_sub(self: u16, y: u16) -> u16 {\n wrapping_sub_hlp(self, y) as u16\n }\n}\n\nimpl WrappingSub for u32 {\n fn wrapping_sub(self: u32, y: u32) -> u32 {\n wrapping_sub_hlp(self, y) as u32\n }\n}\nimpl WrappingSub for u64 {\n fn wrapping_sub(self: u64, y: u64) -> u64 {\n wrapping_sub_hlp(self, y) as u64\n }\n}\nimpl WrappingSub for u128 {\n fn wrapping_sub(self: u128, y: u128) -> u128 {\n wrapping_sub_hlp(self, y) as u128\n }\n}\n\nimpl WrappingSub for i8 {\n fn wrapping_sub(self: i8, y: i8) -> i8 {\n let x = self as u8;\n x.wrapping_sub(y as u8) as i8\n }\n}\n\nimpl WrappingSub for i16 {\n fn wrapping_sub(self: i16, y: i16) -> i16 {\n let x = self as u16;\n x.wrapping_sub(y as u16) as i16\n }\n}\n\nimpl WrappingSub for i32 {\n fn wrapping_sub(self: i32, y: i32) -> i32 {\n let x = self as u32;\n x.wrapping_sub(y as u32) as i32\n }\n}\nimpl WrappingSub for i64 {\n fn wrapping_sub(self: i64, y: i64) -> i64 {\n let x = self as u64;\n x.wrapping_sub(y as u64) as i64\n }\n}\nimpl WrappingSub for Field {\n fn wrapping_sub(self: Field, y: Field) -> Field {\n self - y\n }\n}\n\n// docs:start:wrapping-mul-trait\npub trait WrappingMul {\n fn wrapping_mul(self, y: Self) -> Self;\n}\n// docs:start:wrapping-mul-trait\n\nimpl WrappingMul for u1 {\n fn wrapping_mul(self: u1, y: u1) -> u1 {\n self & y\n }\n}\n\nimpl WrappingMul for u8 {\n fn wrapping_mul(self: u8, y: u8) -> u8 {\n wrapping_mul_hlp(self, y)\n }\n}\n\nimpl WrappingMul for u16 {\n fn wrapping_mul(self: u16, y: u16) -> u16 {\n wrapping_mul_hlp(self, y)\n }\n}\n\nimpl WrappingMul for u32 {\n fn wrapping_mul(self: u32, y: u32) -> u32 {\n wrapping_mul_hlp(self, y)\n }\n}\nimpl WrappingMul for u64 {\n fn wrapping_mul(self: u64, y: u64) -> u64 {\n wrapping_mul_hlp(self, y)\n }\n}\n\nimpl WrappingMul for i8 {\n fn wrapping_mul(self: i8, y: i8) -> i8 {\n let x = self as u8;\n x.wrapping_mul(y as u8) as i8\n }\n}\n\nimpl WrappingMul for i16 {\n fn wrapping_mul(self: i16, y: i16) -> i16 {\n let x = self as u16;\n x.wrapping_mul(y as u16) as i16\n }\n}\n\nimpl WrappingMul for i32 {\n fn wrapping_mul(self: i32, y: i32) -> i32 {\n let x = self as u32;\n x.wrapping_mul(y as u32) as i32\n }\n}\n\nimpl WrappingMul for i64 {\n fn wrapping_mul(self: i64, y: i64) -> i64 {\n let x = self as u64;\n x.wrapping_mul(y as u64) as i64\n }\n}\n\nimpl WrappingMul for u128 {\n fn wrapping_mul(self: u128, y: u128) -> u128 {\n wrapping_mul128_hlp(self, y)\n }\n}\nimpl WrappingMul for Field {\n fn wrapping_mul(self: Field, y: Field) -> Field {\n self * y\n }\n}\n\nfn wrapping_add_hlp(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n\nfn wrapping_sub_hlp(x: T, y: T) -> Field\nwhere\n T: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n x.as_() + 340282366920938463463374607431768211456 - y.as_()\n}\n\nfn wrapping_mul_hlp(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\nglobal two_pow_64: u128 = 0x10000000000000000;\n/// Splits a 128 bits number into two 64 bits limbs\nunconstrained fn split64(x: u128) -> (u64, u64) {\n let lo = x as u64;\n let hi = (x / two_pow_64) as u64;\n (lo, hi)\n}\n\n/// Split a 128 bits number into two 64 bits limbs\n/// It will fail if the number is more than 128 bits\nfn split_into_64_bit_limbs(x: u128) -> (u64, u64) {\n // Safety: the limbs are constrained below\n let (x_lo, x_hi) = unsafe { split64(x) };\n assert(x as Field == x_lo as Field + x_hi as Field * two_pow_64 as Field);\n (x_lo, x_hi)\n}\n\n#[field(bn254)]\nfn wrapping_mul128_hlp(x: u128, y: u128) -> u128 {\n let (x_lo, x_hi) = split_into_64_bit_limbs(x);\n let (y_lo, y_hi) = split_into_64_bit_limbs(y);\n // Multiplication using the limbs:(x_lo + 2**64*x_hi)*(y_lo + 2**64*y_hi)=x_lo*y_lo+...\n // and skipping the terms over 2**128\n // Working with u64 limbs ensures that we cannot overflow the field modulus.\n let low = x_lo as Field * y_lo as Field;\n let lo = low as u64 as Field;\n let carry = (low - lo) / two_pow_64 as Field;\n let high = x_lo as Field * y_hi as Field + x_hi as Field * y_lo as Field + carry;\n let hi = high as u64 as Field;\n (lo + two_pow_64 as Field * hi) as u128\n}\n\nmod tests {\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n crate::static_assert(1 == 2, \"custom message\");\n }\n\n mod arithmetic {\n use crate::ops::arith::{Add, Div, Mul, Neg, Rem, Sub};\n #[test]\n fn test_basic_arithmetic_traits() {\n // add\n assert_eq(5.add(3), 8);\n assert_eq(0u8.add(255u8), 255u8);\n assert_eq(42.add(58), 100);\n\n // sub\n assert_eq(10.sub(3), 7);\n assert_eq(100.sub(42), 58);\n\n // mul\n assert_eq(6.mul(7), 42);\n\n // div\n assert_eq(15.div(3), 5);\n assert_eq(10u8.div(3u8), 3u8);\n assert_eq(15.div(3), 5);\n\n // rem\n assert_eq(17.rem(5), 2);\n assert_eq(10u8.rem(3u8), 1u8);\n\n // neg\n assert_eq(42.neg(), -42);\n assert_eq((-10).neg(), 10);\n assert_eq(42.neg(), -42);\n }\n\n #[test]\n fn test_division() {\n // test division by one\n assert_eq(42.div(1), 42);\n assert_eq(0.div(1), 0);\n assert_eq(255u8.div(1u8), 255u8);\n\n // test division by self\n assert_eq(42.div(42), 1);\n assert_eq(1.div(1), 1);\n\n // test remainder\n assert_eq(42.rem(42), 0);\n assert_eq(0.rem(42), 0);\n assert_eq(1.rem(42), 1);\n }\n\n #[test(should_fail)]\n fn test_u8_sub_overflow_failure() {\n let _ = 0u8.sub(1u8);\n }\n\n #[test(should_fail)]\n fn test_u8_add_overflow_failure() {\n let _ = 255u8.add(1u8);\n }\n\n #[test(should_fail)]\n fn test_u8_mul_overflow_failure() {\n let _ = 255u8.mul(2u8);\n }\n\n #[test(should_fail)]\n fn test_u16_sub_overflow_failure() {\n let _ = 0u16.sub(1u16);\n }\n\n #[test(should_fail)]\n fn test_u16_add_overflow_failure() {\n let _ = 65535u16.add(1u16);\n }\n\n #[test(should_fail)]\n fn test_u16_mul_overflow_failure() {\n let _ = 65535u16.mul(2u16);\n }\n\n #[test(should_fail)]\n fn test_signed_sub_overflow_failure() {\n let val: i8 = -128;\n let _ = val.sub(1i8);\n }\n\n #[test(should_fail)]\n fn test_signed_overflow_failure() {\n let _ = 127i8.add(1i8);\n }\n\n #[test]\n fn test_field() {\n let zero: Field = 0;\n let one: Field = 1;\n\n // test Field basic operations\n assert_eq(zero.add(one), one);\n assert_eq(one.add(zero), one);\n assert_eq(one.sub(one), zero);\n assert_eq(one.mul(one), one);\n assert_eq(one.div(one), one);\n assert_eq(zero.neg(), zero);\n assert_eq(one.neg(), -one);\n }\n\n }\n\n mod wrapping_arithmetic {\n use crate::ops::arith::{Add, Div, Mul, Neg, Sub, WrappingAdd, WrappingMul, WrappingSub};\n #[test]\n fn test_wrapping_add() {\n assert_eq(255u8.wrapping_add(1u8), 0u8);\n assert_eq(255u8.wrapping_add(255u8), 254u8);\n assert_eq(0u8.wrapping_add(0u8), 0u8);\n assert_eq(128u8.wrapping_add(128u8), 0u8);\n\n // test u16 wrapping add\n assert_eq(65535u16.wrapping_add(1u16), 0u16);\n assert_eq(65535u16.wrapping_add(65535u16), 65534u16);\n\n // test u32 wrapping add\n assert_eq(0xffffffffu32.wrapping_add(1u32), 0u32);\n assert_eq(0xffffffffu32.wrapping_add(0xffffffffu32), 0xfffffffeu32);\n\n // test u64 wrapping add\n assert_eq(0xffffffffffffffffu64.wrapping_add(1u64), 0u64);\n assert_eq(\n 0xffffffffffffffffu64.wrapping_add(0xffffffffffffffffu64),\n 0xfffffffffffffffeu64,\n );\n\n // test u128 wrapping add\n assert_eq(0xffffffffffffffffffffffffffffffffu128.wrapping_add(1u128), 0u128);\n\n // test signed types\n assert_eq(127i8.wrapping_add(1i8), -128i8);\n let val: i8 = -128;\n assert_eq(val.wrapping_add(-1i8), 127i8);\n\n // test Field wrapping add\n let forty_two: Field = 42;\n let fifty_eight: Field = 58;\n let hundred: Field = 100;\n let neg_two: Field = -2;\n let two: Field = 2;\n let zero: Field = 0;\n let neg_two_hundred: Field = -200;\n let neg_one_ninety_eight: Field = -198;\n assert_eq(forty_two.wrapping_add(fifty_eight), hundred);\n assert_eq(neg_two.wrapping_add(two), zero);\n assert_eq(neg_two_hundred.wrapping_add(two), neg_one_ninety_eight);\n }\n\n #[test]\n fn test_wrapping_sub() {\n assert_eq(0u8.wrapping_sub(1u8), 255u8);\n assert_eq(255u8.wrapping_sub(255u8), 0u8);\n assert_eq(0u8.wrapping_sub(0u8), 0u8);\n assert_eq(1u8.wrapping_sub(2u8), 255u8);\n\n // test u16 wrapping sub\n assert_eq(0u16.wrapping_sub(1u16), 65535u16);\n assert_eq(65535u16.wrapping_sub(65535u16), 0u16);\n\n // test u32 wrapping sub\n assert_eq(0u32.wrapping_sub(1u32), 0xffffffffu32);\n assert_eq(0xffffffffu32.wrapping_sub(0xffffffffu32), 0u32);\n\n // test u64 wrapping sub\n assert_eq(0u64.wrapping_sub(1u64), 0xffffffffffffffffu64);\n assert_eq(0xffffffffffffffffu64.wrapping_sub(0xffffffffffffffffu64), 0u64);\n\n // test u128 wrapping sub\n assert_eq(0u128.wrapping_sub(1u128), 0xffffffffffffffffffffffffffffffffu128);\n\n // test signed types\n let val: i8 = -128;\n assert_eq(val.wrapping_sub(1i8), 127i8);\n assert_eq(127i8.wrapping_sub(-1i8), -128i8);\n\n // test Field wrapping sub\n let forty_two: Field = 42;\n let fifty_eight: Field = 58;\n let neg_sixteen: Field = -16;\n assert_eq(forty_two.wrapping_sub(fifty_eight), neg_sixteen);\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n assert_eq(zero, zero.wrapping_mul(one));\n assert_eq(zero, one.wrapping_mul(zero));\n assert_eq(one, one.wrapping_mul(one));\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n\n // test u8 wrapping mul\n assert_eq(255u8.wrapping_mul(2u8), 254u8);\n assert_eq(255u8.wrapping_mul(255u8), 1u8);\n assert_eq(128u8.wrapping_mul(2u8), 0u8);\n\n // test u16 wrapping mul\n assert_eq(65535u16.wrapping_mul(2u16), 65534u16);\n assert_eq(65535u16.wrapping_mul(65535u16), 1u16);\n\n // test u32 wrapping mul\n assert_eq(0xffffffffu32.wrapping_mul(2u32), 0xfffffffeu32);\n assert_eq(0xffffffffu32.wrapping_mul(0xffffffffu32), 1u32);\n\n // test u64 wrapping mul\n // 0xffffffffffffffffu64 is 2^64 - 1\n assert_eq(0xffffffffffffffffu64.wrapping_mul(2u64), 0xfffffffffffffffeu64);\n assert_eq(0xffffffffffffffffu64.wrapping_mul(0xffffffffffffffffu64), 1u64);\n\n // test signed types\n assert_eq(127i8.wrapping_mul(2i8), -2i8);\n let val: i8 = -128;\n assert_eq(val.wrapping_mul(-1i8), -128i8);\n\n // test Field wrapping mul\n let six: Field = 6;\n let seven: Field = 7;\n let forty_two: Field = 42;\n let neg_two: Field = -2;\n let two: Field = 2;\n let neg_four: Field = -4;\n assert_eq(six.wrapping_mul(seven), forty_two);\n assert_eq(neg_two.wrapping_mul(two), neg_four);\n }\n\n #[test]\n fn test_u1_behavior() {\n // u1 wrapping add is XOR\n assert_eq(0u1.wrapping_add(0u1), 0u1);\n assert_eq(0u1.wrapping_add(1u1), 1u1);\n assert_eq(1u1.wrapping_add(0u1), 1u1);\n assert_eq(1u1.wrapping_add(1u1), 0u1);\n\n // u1 wrapping sub is XOR\n assert_eq(0u1.wrapping_sub(0u1), 0u1);\n assert_eq(0u1.wrapping_sub(1u1), 1u1);\n assert_eq(1u1.wrapping_sub(0u1), 1u1);\n assert_eq(1u1.wrapping_sub(1u1), 0u1);\n\n // u1 wrapping mul is AND\n assert_eq(0u1.wrapping_mul(0u1), 0u1);\n assert_eq(0u1.wrapping_mul(1u1), 0u1);\n assert_eq(1u1.wrapping_mul(0u1), 0u1);\n assert_eq(1u1.wrapping_mul(1u1), 1u1);\n }\n\n // test wrapping operations is the same as the regular operations\n #[test]\n fn test_wrapping_vs_regular() {\n let u64_large = 0x123456789abcdef0u64;\n let u128_large = 0x123456789abcdef0123456789abcdef0u128;\n\n assert_eq(u64_large.wrapping_add(1u64), u64_large + 1u64);\n assert_eq(u64_large.wrapping_sub(1u64), u64_large - 1u64);\n assert_eq(u64_large.wrapping_mul(2u64), u64_large * 2u64);\n\n assert_eq(u128_large.wrapping_add(1u128), u128_large + 1u128);\n assert_eq(u128_large.wrapping_sub(1u128), u128_large - 1u128);\n assert_eq(u128_large.wrapping_mul(2u128), u128_large * 2u128);\n }\n\n #[test]\n fn test_field_wrapping_operations() {\n let zero: Field = 0;\n let one: Field = 1;\n let large_val = 0xffffffffffffffff;\n\n // test Field wrapping operations\n assert_eq(zero.wrapping_add(one), one);\n assert_eq(one.wrapping_add(large_val), one + large_val);\n assert_eq(zero.wrapping_sub(one), -one);\n assert_eq(one.wrapping_sub(large_val), one - large_val);\n assert_eq(zero.wrapping_mul(one), zero);\n assert_eq(one.wrapping_mul(large_val), large_val);\n\n // test Field basic operations\n assert_eq(zero.add(one), one);\n assert_eq(one.add(zero), one);\n assert_eq(one.sub(one), zero);\n assert_eq(one.mul(one), one);\n assert_eq(one.div(one), one);\n assert_eq(zero.neg(), zero);\n assert_eq(one.neg(), -one);\n }\n\n }\n\n mod split_functions {\n\n use crate::ops::arith::{split64, split_into_64_bit_limbs};\n\n // test split64 and split_into_64_bit_limbs functions\n #[test]\n fn test_split_functions() {\n let small_val = 0x123456789abcdefu128;\n let large_val = 0x123456789abcdef0123456789abcdef0u128;\n let max_val = 0xffffffffffffffffffffffffffffffffu128;\n\n // test split64 (unconstrained)\n // Safety: testing\n unsafe {\n let (lo, hi) = split64(small_val);\n assert_eq(lo, 0x123456789abcdefu64);\n assert_eq(hi, 0u64);\n\n let (lo2, hi2) = split64(large_val);\n assert_eq(lo2, 0x123456789abcdef0u64);\n assert_eq(hi2, 0x123456789abcdef0u64);\n }\n\n // test split_into_64_bit_limbs (constrained)\n let (lo3, hi3) = split_into_64_bit_limbs(small_val);\n assert_eq(lo3, 0x123456789abcdefu64);\n assert_eq(hi3, 0u64);\n\n let (lo4, hi4) = split_into_64_bit_limbs(large_val);\n assert_eq(lo4, 0x123456789abcdef0u64);\n assert_eq(hi4, 0x123456789abcdef0u64);\n\n let (lo5, hi5) = split_into_64_bit_limbs(max_val);\n assert_eq(lo5, 0xffffffffffffffffu64);\n assert_eq(hi5, 0xffffffffffffffffu64);\n }\n }\n}\n","path":"std/ops/arith.nr"},"50":{"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::{MAX_MSG_NON_ZERO_COEFFS, T};\nuse lib::configs::default::threshold::{\n DECRYPTED_SHARES_AGGREGATION_BIT_NOISE, DECRYPTED_SHARES_AGGREGATION_CONFIGS, L,\n};\nuse lib::core::threshold::decrypted_shares_aggregation::DecryptedSharesAggregationBigNum;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n decryption_shares: pub [[Polynomial; L]; T + 1],\n party_ids: pub [Field; T + 1],\n message: pub Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n) {\n let decrypted_shares_aggregation: DecryptedSharesAggregationBigNum = DecryptedSharesAggregationBigNum::new(\n DECRYPTED_SHARES_AGGREGATION_CONFIGS,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n );\n\n decrypted_shares_aggregation.execute();\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/decrypted_shares_aggregation_bn/src/main.nr"},"67":{"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::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\nuse dep::bignum::BigNum;\nuse dep::bignum::bignum::to_field;\nuse dep::bignum::SecureThreshold8192;\n\n/// Cryptographic parameters for decryption share aggregation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Plaintext modulus (typically denoted as `t`)\n pub plaintext_modulus: Field,\n /// Precomputed value: `-Q^(-1) mod t` where Q is the product of all CRT moduli\n pub q_inverse_mod_t: Field,\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], plaintext_modulus: Field, q_inverse_mod_t: Field) -> Self {\n Configs { qis, plaintext_modulus, q_inverse_mod_t }\n }\n}\n\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using BigNum\n/// for large Q values.\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationBigNum {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using modular arithmetic\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationModular {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n\nimpl DecryptedSharesAggregationBigNum {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationBigNum {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Verifies decoding using BigNum for large Q values\n fn verify_decoding(self) {\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1 as Field;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_bn = SecureThreshold8192::from(q_modulus);\n\n let q_half_bn = q_bn.udiv(SecureThreshold8192::from(2));\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let u_bn = SecureThreshold8192::from(self.u_global.coefficients[coeff_idx]);\n let t_bn = SecureThreshold8192::from(self.configs.plaintext_modulus);\n let u_bn_mod_q = u_bn.umod(q_bn);\n let t_bn_mod_q = t_bn.umod(q_bn);\n let t_times_u_bn_q = (t_bn_mod_q * u_bn_mod_q).umod(q_bn);\n\n let m = ModU128::new(self.configs.plaintext_modulus);\n\n // Check if centering is needed\n let needs_centering = t_times_u_bn_q > q_half_bn;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_bn - t_times_u_bn_q;\n let centered_positive_mod_t = centered_positive.umod(t_bn);\n let centered_field = to_field(centered_positive_mod_t);\n m.mul_mod(self.configs.q_inverse_mod_t, centered_field)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_bn_t = t_times_u_bn_q.umod(t_bn);\n let t_times_u_field = to_field(t_times_u_bn_t);\n let product = m.mul_mod(self.configs.q_inverse_mod_t, t_times_u_field);\n if product == 0 {\n 0\n } else {\n self.configs.plaintext_modulus - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\nimpl DecryptedSharesAggregationModular {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationModular {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Alternative verification function using efficient modular arithmetic without BigNum.\n ///\n /// Uses `ModU128` for decoding verification instead of BigNum. More efficient when\n /// Q (the product of all CRT moduli) fits within u128 (e.g., 72 bits for insecure parameter sets).\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Alternative decoding verification using the formula:\n /// message = -Q^{-1} * (t * u_global)_Q mod t\n fn verify_decoding(self) {\n let t: Field = self.configs.plaintext_modulus;\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_half = q_modulus as u128 / 2;\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let q_mod = ModU128::new(q_modulus);\n let t_mod = ModU128::new(t);\n\n // Compute (t * u_global) mod Q using modular arithmetic functions\n let t_times_u_mod_q = q_mod.mul_mod(t, self.u_global.coefficients[coeff_idx]);\n let needs_centering = (t_times_u_mod_q as u128) > q_half;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_modulus - t_times_u_mod_q;\n let centered_positive_mod_t = t_mod.reduce_mod(centered_positive);\n\n t_mod.mul_mod(self.configs.q_inverse_mod_t, centered_positive_mod_t)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_mod_t = t_mod.reduce_mod(t_times_u_mod_q);\n let product = t_mod.mul_mod(self.configs.q_inverse_mod_t, t_times_u_mod_t);\n if product == 0 {\n 0\n } else {\n t - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\n/// Computes all Lagrange coefficients using optimized modular arithmetic\npub fn compute_all_lagrange_coeffs(\n qis: [Field; L],\n party_ids: [Field; T + 1],\n) -> [[Field; T + 1]; L] {\n let mut lagrange_coeffs = [[0 as Field; T + 1]; L];\n\n // Step 1: Cache |x_i - x_j| factors for all party pairs\n let mut diffs = [[0 as Field; T + 1]; T + 1];\n for i in 0..(T + 1) {\n for j in (i + 1)..(T + 1) {\n let diff = party_ids[j] - party_ids[i];\n diffs[i][j] = diff;\n diffs[j][i] = diff;\n }\n }\n\n // Step 2: Determine signs (same for all parties within a basis)\n let numerator_sign_negative = (T % 2) == 1;\n\n // Step 3: For each CRT basis, compute Lagrange coefficients\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n\n // Compute product of all party IDs: PRODUCT(j=0..T) x_j mod q_l\n let mut product_x = 1 as Field;\n for j in 0..(T + 1) {\n product_x = m.mul_mod(product_x, party_ids[j]);\n }\n\n // For each party i, compute L_i(0) mod q_l\n for party_idx in 0..(T + 1) {\n // Numerator (absolute value): PRODUCT(j!=party_idx) x_j\n let numerator_abs = m.div_mod(product_x, party_ids[party_idx]);\n\n // Denominator (absolute value): PRODUCT(j!=party_idx) |x_party_idx - x_j|\n let mut denominator_abs = 1 as Field;\n for j in 0..(T + 1) {\n if j != party_idx {\n denominator_abs = m.mul_mod(denominator_abs, diffs[party_idx][j]);\n }\n }\n\n // Determine denominator sign\n let num_greater = T - party_idx;\n let denom_sign_negative = (num_greater % 2) == 1;\n\n // Compute unsigned result: |numerator| / |denominator| mod q_l\n let result_abs = m.div_mod(numerator_abs, denominator_abs);\n\n // Apply combined sign\n let should_negate = numerator_sign_negative != denom_sign_negative;\n let result = if should_negate {\n m.reduce_mod(q_l - result_abs)\n } else {\n result_abs\n };\n\n lagrange_coeffs[basis_idx][party_idx] = result;\n }\n }\n\n lagrange_coeffs\n}\n\n/// Computes u^{(l)} for each CRT basis via Lagrange interpolation\npub fn compute_crt_components(\n qis: [Field; L],\n decryption_shares: [[Polynomial; L]; T + 1],\n lagrange_coeffs: [[Field; T + 1]; L],\n) -> [Polynomial; L] {\n let mut u_crts: [Polynomial; L] =\n [Polynomial::new([0; MAX_MSG_NON_ZERO_COEFFS]); L];\n\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n let mut u_coeffs = [0 as Field; MAX_MSG_NON_ZERO_COEFFS];\n\n // For each coefficient position\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n let mut u_coeff = 0 as Field;\n\n // Sum all contributions: u = SUM(i=0..T) [d_i * L_i(0)] mod q_l\n for party_idx in 0..(T + 1) {\n let d_coeff = decryption_shares[party_idx][basis_idx].coefficients[coeff_idx];\n let l_i_0 = lagrange_coeffs[basis_idx][party_idx];\n\n let term = m.mul_mod(d_coeff, l_i_0);\n u_coeff = m.reduce_mod(u_coeff + term);\n }\n\n u_coeffs[coeff_idx] = u_coeff;\n }\n\n u_crts[basis_idx] = Polynomial::new(u_coeffs);\n }\n\n u_crts\n}\n\n/// Verifies CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global for all bases l\npub fn verify_crt_reconstruction(\n qis: [Field; L],\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n u_crts: [Polynomial; L],\n) {\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n\n // Compute r^{(l)} * q_l\n let r_times_q = crt_quotients[basis_idx].mul_scalar(q_l);\n\n // Compute u^{(l)} + r^{(l)} * q_l\n let reconstructed = u_crts[basis_idx].add(r_times_q);\n\n // Verify: u^{(l)} + r^{(l)} * q_l = u_global\n // Must hold for every coefficient\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n assert(\n reconstructed.coefficients[coeff_idx] == u_global.coefficients[coeff_idx],\n \"CRT reconstruction verification failed\",\n );\n }\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/decrypted_shares_aggregation.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"84":{"source":"use crate::fns::constrained_ops::limbs_to_field;\nuse crate::params::BigNumParams;\nuse std::ops::{Add, Div, Mul, Neg, Sub};\n\npub trait BigNum: Neg + Add + Sub + Mul + Div + Eq {\n let N: u32;\n let MOD_BITS: u32;\n\n fn params() -> BigNumParams;\n fn modulus_bits(_: Self) -> u32;\n fn num_limbs(_: Self) -> u32;\n fn modulus() -> Self;\n\n fn new() -> Self;\n fn zero() -> Self;\n fn one() -> Self;\n fn from_limbs(limbs: [u128; N]) -> Self;\n fn get_limbs(self) -> [u128; N];\n fn set_limb(self: &mut Self, idx: u32, value: u128);\n fn derive_from_seed(seed: [u8; SeedBytes]) -> Self;\n unconstrained fn __derive_from_seed(seed: [u8; SeedBytes]) -> Self;\n fn from_be_bytes(x: [u8; (MOD_BITS + 7) / 8]) -> Self;\n fn to_be_bytes(self) -> [u8; (MOD_BITS + 7) / 8];\n fn from_le_bytes(x: [u8; (MOD_BITS + 7) / 8]) -> Self;\n fn to_le_bytes(self) -> [u8; (MOD_BITS + 7) / 8];\n\n fn get_limb(self: Self, idx: u32) -> u128 {\n self.get_limbs()[idx]\n }\n\n unconstrained fn __eq(self: Self, other: Self) -> bool;\n\n unconstrained fn __is_zero(self: Self) -> bool;\n\n unconstrained fn __neg(self) -> Self;\n unconstrained fn __add(self, other: Self) -> Self;\n unconstrained fn __sub(self, other: Self) -> Self;\n unconstrained fn __mul(self, other: Self) -> Self;\n unconstrained fn __sqr(self) -> Self;\n unconstrained fn __div(self, other: Self) -> Self;\n unconstrained fn __udiv_mod(self, divisor: Self) -> (Self, Self);\n unconstrained fn __invmod(self) -> Self;\n unconstrained fn __pow(self, exponent: Self) -> Self;\n\n unconstrained fn __tonelli_shanks_sqrt(self) -> std::option::Option;\n unconstrained fn __sqrt(self) -> std::option::Option;\n\n fn assert_is_not_equal(self: Self, other: Self);\n\n fn validate_in_range(self);\n fn validate_in_field(self);\n\n fn sqr(self) -> Self;\n\n fn udiv_mod(self, divisor: Self) -> (Self, Self);\n fn udiv(self, divisor: Self) -> Self;\n fn umod(self, divisor: Self) -> Self;\n\n fn is_zero(self) -> bool;\n fn is_zero_integer(self) -> bool;\n fn assert_is_not_zero(self);\n fn assert_is_not_zero_integer(self);\n}\n\n// we need macros that implement the BigNum, Default, From, Neg, Add, Sub, Mul, Div, Eq, Ord traits for each bignum type\npub comptime fn derive_bignum(\n strukt: TypeDefinition,\n N: u32,\n MOD_BITS: u32,\n params: Quoted,\n) -> Quoted {\n let constrained_ops = quote { $crate::fns::constrained_ops };\n let unconstrained_ops = quote { $crate::fns::unconstrained_ops };\n let typ = strukt.as_type();\n let serialization = quote { $crate::fns::serialization };\n quote {\n\n // implement BigNum for BigNum \n impl $crate::BigNum for $typ {\n let N: u32 = $N; \n let MOD_BITS: u32 = $MOD_BITS;\n \n fn modulus_bits(_: Self) -> u32 {\n $MOD_BITS\n }\n \n fn num_limbs(_: Self) -> u32 {\n $N\n }\n\n fn modulus() -> Self {\n Self { limbs: Self::params().modulus }\n }\n\n fn new() -> Self {\n Self {limbs: [0; $N]}\n }\n\n fn params() -> $crate::params::BigNumParams<$N, $MOD_BITS> {\n $params\n }\n\n fn from_limbs(limbs: [u128; $N]) -> Self {\n Self { limbs }\n }\n\n fn get_limbs(self: Self) -> [u128; $N] {\n self.limbs\n }\n\n fn set_limb(self: &mut Self, idx: u32, value: u128) {\n self.limbs[idx] = value;\n }\n\n fn zero() -> Self {\n Self { limbs: [0; $N] }\n }\n\n fn one() -> Self {\n let mut limbs = [0; $N];\n limbs[0] = 1;\n Self { limbs }\n }\n\n fn derive_from_seed(seed: [u8; SeedBytes]) -> Self {\n let params = Self::params();\n $typ::from_limbs($constrained_ops::derive_from_seed::<_, $MOD_BITS, _>(params, seed))\n }\n\n unconstrained fn __derive_from_seed(seed: [u8; SeedBytes]) -> Self {\n let params = Self::params();\n Self { limbs: $unconstrained_ops::__derive_from_seed::<_, $MOD_BITS, _>(params, seed) }\n }\n\n fn from_be_bytes(x: [u8; ($MOD_BITS + 7) / 8]) -> Self {\n Self { limbs: $serialization::from_be_bytes::<_, $MOD_BITS>(x) }\n }\n \n fn to_be_bytes(self) -> [u8; ($MOD_BITS + 7) / 8] {\n $serialization::to_be_bytes::<_, $MOD_BITS>(self.limbs)\n }\n\n fn from_le_bytes(x: [u8; ($MOD_BITS + 7) / 8]) -> Self {\n Self { limbs: $serialization::from_le_bytes::<_, $MOD_BITS>(x) }\n }\n\n fn to_le_bytes(self) -> [u8; ($MOD_BITS + 7) / 8] {\n $serialization::to_le_bytes::<_, $MOD_BITS>(self.limbs)\n }\n\n unconstrained fn __eq(self: Self, other: Self) -> bool {\n $crate::fns::unconstrained_ops::__eq(self.get_limbs(), other.get_limbs())\n }\n\n unconstrained fn __is_zero(self: Self) -> bool {\n $crate::fns::unconstrained_ops::__is_zero(self.get_limbs())\n }\n\n unconstrained fn __neg(self: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__neg(params.modulus, self.get_limbs())}\n }\n\n unconstrained fn __add(self: Self, other: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__add(params.modulus, self.get_limbs(), other.get_limbs())}\n }\n\n unconstrained fn __sub(self: Self, other: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__sub(params.modulus, self.get_limbs(), other.get_limbs())}\n }\n\n unconstrained fn __mul(self: Self, other: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__mul(params, self.get_limbs(), other.get_limbs())}\n }\n\n unconstrained fn __sqr(self: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__sqr(params, self.get_limbs()) }\n }\n\n unconstrained fn __div(self: Self, divisor: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__div(params, self.get_limbs(), divisor.get_limbs())}\n }\n\n unconstrained fn __udiv_mod(self: Self, divisor: Self) -> (Self, Self) {\n let (q, r) = $unconstrained_ops::__udiv_mod(self.get_limbs(), divisor.get_limbs());\n (Self{limbs: q}, Self{limbs: r})\n }\n\n unconstrained fn __invmod(self: Self) -> Self {\n let params = Self::params();\n assert(params.has_multiplicative_inverse);\n Self {limbs: $unconstrained_ops::__invmod(params, self.get_limbs())}\n }\n\n unconstrained fn __pow(self: Self, exponent: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__pow(params, self.get_limbs(), exponent.get_limbs())}\n }\n\n #[deprecated(\"use __sqrt\")]\n unconstrained fn __tonelli_shanks_sqrt(self: Self) -> std::option::Option {\n let params = Self::params();\n let maybe_limbs = $unconstrained_ops::__sqrt(params, self.get_limbs());\n maybe_limbs.map(|limbs| Self {limbs: limbs})\n }\n\n unconstrained fn __sqrt(self: Self) -> std::option::Option {\n let params = Self::params();\n let maybe_limbs = $unconstrained_ops::__sqrt(params, self.get_limbs());\n maybe_limbs.map(|limbs| Self {limbs: limbs })\n }\n\n fn assert_is_not_equal(self: Self, other: Self) {\n let params = Self::params();\n $crate::fns::constrained_ops::assert_is_not_equal(\n params,\n self.get_limbs(),\n other.get_limbs(),\n );\n }\n\n fn validate_in_field(self: Self) {\n let params = Self::params();\n $constrained_ops::validate_in_field::<_, $MOD_BITS>(params, self.get_limbs());\n }\n\n fn validate_in_range(self: Self) {\n $constrained_ops::validate_in_range::<_, _, $MOD_BITS>(self.get_limbs());\n }\n\n fn sqr(self: Self) -> Self {\n let params = Self::params();\n Self { limbs: $constrained_ops::sqr::<$N, $MOD_BITS>(params, self.get_limbs()) }\n }\n\n fn udiv_mod(self: Self, divisor: Self) -> (Self, Self) {\n let (q, r) = $constrained_ops::udiv_mod::<$N, $MOD_BITS>(self.get_limbs(), divisor.get_limbs());\n (Self {limbs: q}, Self {limbs: r})\n }\n\n fn udiv(self: Self, divisor: Self) -> Self {\n let params = Self::params();\n Self {limbs: $constrained_ops::udiv::<$N, $MOD_BITS>(self.get_limbs(), divisor.get_limbs())}\n }\n\n fn umod(self: Self, divisor: Self) -> Self {\n let params = Self::params();\n Self {limbs: $constrained_ops::umod::<$N, $MOD_BITS>(self.get_limbs(), divisor.get_limbs())}\n }\n\n fn is_zero(self: Self) -> bool {\n let params = Self::params();\n $constrained_ops::is_zero::<$N, $MOD_BITS>(params, self.get_limbs())\n }\n\n fn is_zero_integer(self: Self) -> bool {\n $constrained_ops::is_zero_integer(self.get_limbs())\n }\n\n fn assert_is_not_zero(self: Self) {\n let params = Self::params();\n $constrained_ops::assert_is_not_zero::<$N, $MOD_BITS>(params, self.get_limbs());\n }\n\n fn assert_is_not_zero_integer(self: Self) {\n $constrained_ops::assert_is_not_zero_integer(self.get_limbs());\n }\n }\n\n // implement Default for BigNum\n impl Default for $typ {\n fn default() -> Self {\n $typ::from_limbs([0; $N])\n }\n }\n\n impl std::convert::From for $typ {\n fn from(input: Field) -> Self {\n $typ { limbs: $constrained_ops::from_field::<$N, $MOD_BITS>($params, input) }\n }\n }\n\n impl std::ops::Neg for $typ {\n fn neg(self) -> Self {\n $typ { limbs: $constrained_ops::neg::<$N, $MOD_BITS>($params, self.limbs) }\n }\n }\n\n impl std::ops::Add for $typ {\n fn add(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::add::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::ops::Sub for $typ {\n fn sub(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::sub::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::ops::Mul for $typ {\n fn mul(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::mul::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::ops::Div for $typ {\n fn div(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::div::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::cmp::Eq for $typ {\n fn eq(self, other: Self) -> bool {\n $constrained_ops::eq::<$N, $MOD_BITS>($params, self.limbs, other.limbs)\n }\n }\n\n impl std::cmp::Ord for $typ {\n fn cmp(self, other: Self) -> std::cmp::Ordering {\n $constrained_ops::cmp::<$N, $MOD_BITS>(self.limbs, other.limbs)\n }\n }\n\n }\n}\n\npub fn conditional_select(lhs: T, rhs: T, predicate: bool) -> T {\n if predicate {\n lhs\n } else {\n rhs\n }\n}\n\npub unconstrained fn compute_quadratic_expression(\n lhs_terms: [[T; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[T; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [T; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> (T, T) {\n let params = T::params();\n let (q_limbs, r_limbs) = crate::fns::expressions::__compute_quadratic_expression(\n params,\n crate::utils::map::map(\n lhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n lhs_flags,\n crate::utils::map::map(\n rhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n rhs_flags,\n crate::utils::map::map(linear_terms, |bn: T| bn.get_limbs()),\n linear_flags,\n );\n (T::from_limbs(q_limbs), T::from_limbs(r_limbs))\n}\n\npub fn evaluate_quadratic_expression(\n lhs_terms: [[T; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[T; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [T; ADD_N],\n linear_flags: [bool; ADD_N],\n) {\n let params = T::params();\n crate::fns::expressions::evaluate_quadratic_expression(\n params,\n crate::utils::map::map(\n lhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n lhs_flags,\n crate::utils::map::map(\n rhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n rhs_flags,\n crate::utils::map::map(linear_terms, |bn: T| bn.get_limbs()),\n linear_flags,\n )\n}\n\npub unconstrained fn batch_invert(x: [T; M]) -> [T; M] {\n let params = T::params();\n assert(params.has_multiplicative_inverse);\n crate::fns::unconstrained_ops::batch_invert(params, x.map(|bn: T| bn.get_limbs())).map(|limbs| {\n T::from_limbs(limbs)\n })\n}\n\npub unconstrained fn batch_invert_slice(x: [T]) -> [T] {\n let params = T::params();\n assert(params.has_multiplicative_inverse);\n crate::fns::unconstrained_ops::batch_invert_slice(params, x.map(|bn: T| bn.get_limbs()))\n .map(|limbs| T::from_limbs(limbs))\n}\n\npub fn to_field(bn: T) -> Field {\n let params = T::params();\n limbs_to_field(params, bn.get_limbs())\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/bignum.nr"},"120":{"source":"use crate::constants::{GRUMPKIN_MODULUS, TWO_POW_120, TWO_POW_240};\n\nuse crate::fns::{\n expressions::{evaluate_quadratic_expression, validate_udiv_mod_expression},\n unconstrained_helpers::{\n __add_with_flags, __from_field, __neg_with_flags, __sub_with_flags,\n __validate_gte_with_flags, __validate_in_field_compute_borrow_flags,\n },\n unconstrained_ops::{__add, __div, __mul, __neg, __sqr, __sub, __udiv_mod},\n};\n\nuse crate::params::BigNumParams;\n\nuse std::cmp::Ordering;\n\n/// Lift the limbs of a `BigNum` value onto the circuit `Field`\n///\n/// Descent the `BigNum` value back into the `Field` and\n/// - check that it's a proper `BigNum` value\n/// - validate the limbs sum up to a `Field` value\npub(crate) fn limbs_to_field(\n _params: BigNumParams,\n limbs: [u128; N],\n) -> Field {\n validate_in_range::(limbs);\n if N > 2 {\n // validate that the `BigNum` is less than the Grumpkin modulus\n let mut grumpkin_modulus: [u128; N] = [0; N];\n grumpkin_modulus[0] = GRUMPKIN_MODULUS[0];\n grumpkin_modulus[1] = GRUMPKIN_MODULUS[1];\n grumpkin_modulus[2] = GRUMPKIN_MODULUS[2];\n validate_gt::(grumpkin_modulus, limbs);\n }\n\n if N < 2 {\n limbs[0] as Field\n } else if N == 2 {\n (limbs[0] as Field) + (limbs[1] as Field) * (TWO_POW_120 as Field)\n } else {\n (limbs[0] as Field)\n + (limbs[1] as Field) * (TWO_POW_120 as Field)\n + (limbs[2] as Field) * TWO_POW_240\n }\n}\n\n/// Construct a `BigNum` value from a native `Field`\n///\n/// Decomposes the `Field` value into 120-bit limbs\n/// then we have three cases:\n/// - MOD_BITS < 253 (grumpkin_mod_bits - 1): it is enough to call for `validate_in_field`, which is basically `val <= MOD`\n/// - MOD_BITS > 253: we need to verify that the obtained `BigNum` `val < GRUMPKIN_MODULUS`\n/// - MOD_BITS = 253: verify that `val < min(MOD, GRUMPKIN_MODULUS)`\n/// Next we verify that all the limbs are properly ranged\n/// and that the accumulated limbs are equal to the input `Field` value\npub(crate) fn from_field(\n _params: BigNumParams,\n val: Field,\n) -> [u128; N] {\n // Safety: we check that the resulting limbs represent the intended field element\n // we check the bit length, the limbs being max 120 bits, and the value in total is less than the field modulus\n let result: [u128; N] = unsafe { __from_field::(val) };\n\n if !std::runtime::is_unconstrained() {\n // validate the limbs are in range and the value in total is less than 2^254\n if MOD_BITS < 253 {\n // this means that the field modulus is smaller than grumpkin modulus so we have to check if the element fields in the field size\n validate_in_field(_params, result);\n } else {\n let mut grumpkin_modulus: [u128; N] = [0; N];\n grumpkin_modulus[0] = GRUMPKIN_MODULUS[0];\n grumpkin_modulus[1] = GRUMPKIN_MODULUS[1];\n grumpkin_modulus[2] = GRUMPKIN_MODULUS[2];\n\n if MOD_BITS > 253 {\n // this means that the field modulus is larger than grumpkin modulus so we have to check if the element fields in the field size are less than the grumpkin modulus.\n // also for correct params N is always larger than 3 here\n validate_gt::(grumpkin_modulus, result);\n } else {\n // this is the tricky part, when MOD_BITS = 253, we have to compare the limbs of the modulus to the grumpkin modulus limbs\n // any `BigNum` with 253 bits will have 3 limbs\n\n // if MOD is less than grumpkin modulus, this will be true\n let mut mod_lt_grumpkin: bool = false;\n for i in 0..3 {\n if !mod_lt_grumpkin & (_params.modulus[2 - i] < grumpkin_modulus[2 - i]) {\n mod_lt_grumpkin = true;\n }\n }\n let min_modulus: [u128; N] = if mod_lt_grumpkin {\n _params.modulus\n } else {\n grumpkin_modulus\n };\n validate_gt::(min_modulus, result);\n }\n }\n validate_in_range::(result);\n\n // validate the limbs sum up to the field value\n let field_val: Field = if N < 2 {\n result[0] as Field\n } else if N == 2 {\n (result[0] as Field) + (result[1] as Field) * (TWO_POW_120 as Field)\n } else {\n (result[0] as Field)\n + (result[1] as Field) * (TWO_POW_120 as Field)\n + (result[2] as Field) * TWO_POW_240\n };\n assert_eq(field_val, val);\n }\n\n result\n}\n\n/// Given an input seed, generate a pseudorandom `BigNum` value\n///\n/// This function *should* produce a uniformly randomly distributed value modulo `MOD`\n///\n/// First we take the seed and pack it's 31-byte chunks into `Field`s\n/// We use a hash function that can be modelled as a random oracle\n/// We hash the packed seed using Poseidon2 to produce `MOD_BITS * 2` bits of entropy\n///\n/// From these bits we construct 4(in case N = 2) or 3(N > 2) `BigNum` values:\n/// - We fill first `N - 1` limbs and leave the top limb empty\n///\n/// Then we accumulate the resulting BigNum values using:\n/// B = 2^{120 * (N - 1)}\n/// res = x3 + B * x2 + B^2 * x1 + B^3 * x0\n///\n/// ## Note\n/// This function will always produce an `x3` `BigNum`\n/// If `MOD = 2^{120 * (N - 1)}`\n/// It will use only `MOD_BITS - 1` bits of entropy\npub(crate) fn derive_from_seed(\n params: BigNumParams,\n seed: [u8; SeedBytes],\n) -> [u128; N] {\n // Pack seed bytes into Fields.\n // For the seed of length M, we construct a rolling_hash_field of size ceil(M / 31).\n // i.e. 31 bytes per Field\n // NOTE: the Fields produced are 248 bits in size\n let mut rolling_hash_fields: [Field; (SeedBytes + 30) / 31] = [0; (SeedBytes + 30) / 31];\n let mut seed_ptr: u32 = 0;\n for i in 0..(SeedBytes + 30) / 31 {\n let mut packed: Field = 0;\n for _ in 0..31 {\n if (seed_ptr < SeedBytes) {\n packed *= 256;\n packed += seed[seed_ptr] as Field;\n seed_ptr += 1;\n }\n }\n rolling_hash_fields[i] = packed;\n }\n\n let compressed: Field =\n poseidon::poseidon2::Poseidon2::hash(rolling_hash_fields, (SeedBytes + 30) / 31);\n let mut rolling_hash: [Field; 2] = [compressed, 0];\n\n // 120 bit limb has 15 bytes in it\n // we buffer (N * 15) * 2 bytes for 2N limbs\n let mut hash_buffer: [u8; N * 15 * 2] = [0; N * 15 * 2];\n\n // We produce 32 bytes (254 bits) per hash iteration\n // We take only 30 bytes, so we need ceil(N * 2 * 15 / 30) hashes to fill them up\n for i in 0..N {\n let hash: Field = poseidon::poseidon2::Poseidon2::hash(rolling_hash, 2);\n let hash: [u8; 32] = hash.to_le_bytes();\n for j in 0..30 {\n hash_buffer[i * 30 + j] = hash[j];\n }\n rolling_hash[1] += 1;\n }\n\n let num_bits: u32 = MOD_BITS * 2;\n let num_bytes: u32 = (num_bits + 7) / 8;\n\n // Truncate the final byte that will be used in `BigNum` creation\n let bits_in_last_byte: u8 = (num_bits as u8) % 8;\n if bits_in_last_byte != 0 {\n let last_byte_mask: u8 = ((1 as u8) << bits_in_last_byte) - 1;\n hash_buffer[num_bytes - 1] &= last_byte_mask;\n }\n\n let num_bigfield_chunks: u32 = if N == 2 { 4 } else { 3 };\n let mut byte_ptr: u32 = 0;\n\n // We want to convert our hash_buffer into bigfield chunks, with each `BigNum` having at most N - 1 limbs filled\n // We sample only N - 1 limbs mostly because we do not wont to deal with accidental overflows in the top limb\n // In any case the security is preserved\n //\n // For all integer values N > 1, the number of chunks is either 4(for N = 2) or 3(for N > 2) (ceil(2*N / (N - 1)))\n //\n // To determine the exact number of chunks, we need the `!=` or `>` operator which is not available when defining array sizes\n // so we overestimate at 4\n // e.g. if N = 20, then we have 40 limbs we want to reduce, but each bigfield chunk is 19 limbs, so we need 3\n // if N = 2, we have 4 limbs we want to reduce but each bigfield chunk is only 1 limb, so we need 4\n let mut bigfield_chunks: [[u128; N]; 4] = [[0; N]; 4];\n\n for k in 0..num_bigfield_chunks {\n let mut bigfield_limbs: [u128; N] = [0; N];\n\n // Before the current limb, we filled out (N - 1) limbs, k times\n // 15 bytes per limb\n // resulting in total of 15 * k * (N - 1)\n let mut num_filled_bytes: u32 = 15 * k * (N - 1);\n if num_bytes > num_filled_bytes {\n // Static assert for completeness\n assert(num_filled_bytes == byte_ptr);\n\n let mut num_remaining_bytes_to_sample: u32 = num_bytes - num_filled_bytes;\n let mut num_remaining_limbs_to_sample: u32 = (num_remaining_bytes_to_sample + 14) / 15;\n\n // Sample at most (N - 1) limbs from hash_buffer\n let mut num_limbs_to_sample: u32 = if num_remaining_limbs_to_sample > (N - 1) {\n N - 1\n } else {\n num_remaining_limbs_to_sample\n };\n\n for j in 0..num_limbs_to_sample {\n let mut limb: Field = 0;\n // Construct a 120 bit limb\n for _ in 0..15 {\n if byte_ptr < num_bytes {\n let mut byte: u8 = hash_buffer[byte_ptr];\n limb *= 256;\n limb += byte as Field;\n byte_ptr += 1;\n }\n }\n // crucial for performance\n limb.assert_max_bit_size::<120>();\n // Accumulate limbs from top to bottom\n bigfield_limbs[num_limbs_to_sample - 1 - j] = limb as u128;\n }\n // Accumulate `BigNum` values from top to bottom\n bigfield_chunks[num_bigfield_chunks - 1 - k] = bigfield_limbs;\n }\n }\n\n // B = 2^{120 * (N - 1)}, we know it is \\leq `MOD`, since the top limb\n // have to be at least one\n let mut bigfield_rhs_limbs: [u128; N] = [0; N];\n bigfield_rhs_limbs[N - 1] = 1;\n\n let mut result: [u128; N] = bigfield_chunks[0];\n\n for i in 1..num_bigfield_chunks {\n result = mul(params, result, bigfield_rhs_limbs);\n result = add(params, result, bigfield_chunks[i]);\n }\n\n result\n}\n\n// ------------------------------ COMPARISON FUNCTIONS ------------------------------\n\n/// Validate lhs != rhs\n///\n/// We compare `A` and `B` via their encodings in the circuit `Field`\n///\n/// Under our range assumptions, equality in `Field` implies equality of the underlying\n/// `BigNum` values, hence equality (mod `MOD`)\n///\n/// In this library it is possible that A or B is a little bit greater than `MOD`\n/// So A == B (mod `MOD`) implies that A == B, A == B + MOD or A == B - MOD over the integers\n/// Hence we can compute everything (mod p) and constrain that\n/// (A - B) * (A - B + MOD) * (A - B - MOD) != 0 (mod p)\n///\n/// ## Soundness\n/// This method is *sound* for checking `A != B (mod MOD)`\n///\n/// If `A == B (mod MOD)`, then `A - B` is in `{0, +-MOD}` as an integer,\n/// so one of the factors `A-B`, `A-B+MOD`, `A-B-MOD` is zero in `Field`, and the product is zero\n/// Therefore, whenever the assertion `target != 0` holds, we must have `A != B (mod MOD)`\n/// under our range assumptions\n///\n/// ## Completeness\n/// In general, this method is not *complete*: if the admissible range of `A` and `B`\n/// is large enough relative to the circuit `Field` prime `p`, an honest prover with\n/// `A != B (mod MOD)` can still hit an alias where\n/// (A - B) * (A - B + MOD) * (A - B - MOD) == 0 (mod p),\n/// i.e.\n/// - A = B (mod p), or\n/// - A = B + MOD (mod p), or\n/// - A = B - MOD (mod p).\n///\n/// For random `A, B` in such a wide range, the probability of this collision is\n/// roughly 3/p.\n///\n/// In case `MOD` < `p` this function becomes *complete*\npub(crate) fn assert_is_not_equal(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) {\n let mut l: Field = 0;\n let mut r: Field = 0;\n let mut modulus_mod_p: Field = 0;\n for i in 0..N {\n l *= TWO_POW_120 as Field;\n r *= TWO_POW_120 as Field;\n modulus_mod_p *= TWO_POW_120 as Field;\n\n l += lhs[N - i - 1] as Field;\n r += rhs[N - i - 1] as Field;\n modulus_mod_p += params.modulus[N - i - 1] as Field;\n }\n\n let diff: Field = l - r;\n let target: Field = diff * (diff + modulus_mod_p) * (diff - modulus_mod_p);\n assert(target != 0, \"assert_is_not_equal fail\");\n}\n\n/// Compute equality flag\n///\n/// A == B (mod MOD)\n/// We compute A - B and check whether it is `0` or `MOD`\n/// This is due to subtract constrains the diff value to be < 2^MOD_BITS, not < `MOD`\n///\n/// ## Soundness\n/// This function is conditionally *sound*. See `sub` for details\n///\n/// ## Completeness\n/// This function is *complete*. An honest prover will always be able to execute it.\n///\n/// ## TODO\n/// can do this more efficiently via witngen in unconstrained functions?\npub(crate) fn eq(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> bool {\n let diff: [u128; N] = sub::(params, lhs, rhs);\n is_zero::(params, diff)\n}\n\n/// Validate that `val` is not equal to zero when interpreted as an integer.\n///\n/// This enforces that at least one limb of `val` is non-zero.\n/// It does *not* check \"BigNum zero\" in the modular sense (e.g. it\n/// treats `MOD` as non-zero).\n///\n/// ## Assumptions\n/// * Each limb of `val` is range-constrained to be a 120-bit value:\n/// `0 <= val[i] < 2^120`.\n/// * For our concrete fields and limb counts we have `N * 2^120 < p`,\n/// so the sum of all limbs fits strictly inside the field modulus.\n///\n/// ## Completeness\n/// If `val` is non-zero as an integer, then at least one limb is non-zero,\n/// so the integer sum of the limbs satisfies `0 < limb_sum < p`. In this\n/// case `limb_sum != 0` in the `Field`, and the assertion passes.\n///\n/// ## Soundness\n/// If all limbs of `val` are zero, then `limb_sum` is zero as an integer\n/// and as a field element, so the assertion fails. A witness representing\n/// the zero integer can never satisfy this check.\n///\n/// ## Note\n/// This is slightly cheaper than doing `val != [0; N]`, as we avoid\n/// creating per-limb boolean equalities and chaining them with `and`s.\npub(crate) fn assert_is_not_zero_integer(val: [u128; N]) {\n let mut limb_sum: Field = 0;\n for i in 0..N {\n limb_sum += val[i] as Field;\n }\n assert(limb_sum != 0, \"assert_is_not_zero_integer fail\");\n}\n\n/// Check whether `val` is the zero `BigNum` in the integer sense.\n///\n/// This returns `true` iff all limbs of `val` are zero. It does *not*\n/// treat `MOD` as zero; for modular `BigNum` zero use `is_zero`.\n///\n/// See `assert_is_not_zero_integer` for the underlying assumptions.\n///\n/// ## Note\n/// This is slightly cheaper than testing `val == [0; N]`, as we avoid\n/// creating per-limb boolean equalities and chaining them with `and`s.\npub(crate) fn is_zero_integer(val: [u128; N]) -> bool {\n let mut limb_sum: Field = 0;\n for i in 0..N {\n limb_sum += val[i] as Field;\n }\n limb_sum == 0\n}\n\n/// Validate that a `BigNum` value is not zero modulo `MOD`.\n///\n/// Convenience wrapper around `assert_is_not_equal`.\npub(crate) fn assert_is_not_zero(\n params: BigNumParams,\n val: [u128; N],\n) {\n assert_is_not_equal::(params, val, [0; N]);\n}\n\n/// Check whether a `BigNum` value is zero modulo `MOD`.\n///\n/// This treats both the all-zero limb vector and `params.modulus` as\n/// representing zero. It assumes that all valid `BigNum` values are\n/// range-constrained so that no other representatives of `0 (mod MOD)`\n/// can appear.\n///\n/// ## Note\n/// This is cheaper than calling `eq(val, [0; N])`\npub(crate) fn is_zero(\n params: BigNumParams,\n val: [u128; N],\n) -> bool {\n is_zero_integer(val) | (val == params.modulus)\n}\n\n/// Validate a `BigNum` instance is correctly range constrained to contain no more than `MOD_BITS` bits\n///\n/// Constrain the `BigNum` instance to be < 2^MOD_BITS by:\n/// - Constraining each limb(0..N-2) to be 120-bit limb\n/// - Constraining the last limb to be `MOD_BITS - 120 * (N - 1)`\n///\n/// ## Note\n/// This can be a very expensive function, when the `TOP_LIMB_BITS` is uncommon\n///\n/// For example: BLS12_377Fr, with `TOP_LIMB_BITS`=13\n/// It creates a new 13-bit range table, which consists of roughly 3k variables\n/// And ~2k circuit gates\n///\n/// Compare this to BLS12_377Fq, with `TOP_LIMB_BITS`=17\n/// It is nicely decomposed into\n/// 14-bit range check and 3-bit range check - much much cheaper, since 14-bit range checks\n/// are already pretty common for 120-bit range checks\npub(crate) fn validate_in_range(limbs: [T; N])\nwhere\n T: Into,\n{\n for i in 0..(N - 1) {\n limbs[i].into().assert_max_bit_size::<120>();\n }\n\n limbs[N - 1].into().assert_max_bit_size::();\n}\n\n/// Validate quotient produced from `evaluate_quadratic_expression` is well-formed\n///\n/// Because the inputs into `evaluate_quadratic_expression` may cause the quotient to extend beyond `Params::modulus_bits`.\n/// We allow the quotient to extend `6` bits beyond `Params::modulus_bits()`\n/// Why is this?\n/// several factors: 1. quotient * modulus , limbs cannot overflow `Field` boundary (254 bits)\n/// 2. in `evaluate_quadratic_expression`, we require that for `expression - quotient * modulus`,\n/// limbs cannot exceed `246` bits (246 magic number due to a higher number adding extra range check gates)\n/// because of factor 2 and the fact that modulus limbs are 120 bits, quotient limbs cannot be > 126 bits\npub(crate) fn validate_quotient_in_range(limbs: [u128; N]) {\n for i in 0..(N - 1) {\n (limbs[i] as Field).assert_max_bit_size::<120>();\n }\n (limbs[N - 1] as Field).assert_max_bit_size::();\n}\n\n/// Validate that `lhs - rhs` does not underflow i.e. that lhs > rhs over the integers\n///\n/// Compute `result = lhs - rhs` along with `borrow_flags`,\n/// then constrain `result` to be a valid `BigNum` value.\n///\n/// ## Completeness\n/// This function is complete and will work only if `lhs > rhs` over the integers.\n///\n/// ## Soundness\n/// This function is sound:\n/// result[0] = lhs[0] - rhs[0] + bf[0] * 2^{120} < 2^{120}\n/// result[i] = lhs[i] - rhs[i] + bf[i] * 2^{120} - bf[i - 1] < 2^{120}, i = 1..N-2\n/// result[N - 1] = lhs[N - 1] - rhs[N - 1] - bf[N - 2] < 2^{TOP_LIMB_BITS}\n/// result != 0\n///\n/// If `lhs < rhs`, then some limb of `result` would have to borrow from a higher limb,\n/// which is impossible because the top limb cannot borrow\n/// Without the extra borrow, the resulting difference will be wrapped around the `Field` modulus\n/// And won't satisfy the range constraint, since all the limbs are < 2^120\n///\n/// ## Note\n/// `assert_is_not_zero_integer(result)` is crucial. Without it, we could always provide\n/// two identical inputs `x`, `x` and set `borrow_flags = [false; N]`,\n/// which would satisfy the limb constraints.\n///\n/// Also note that `underflow` is not properly constrained, so it just hangs there for\n/// completeness\npub(crate) fn validate_gt(lhs: [u128; N], rhs: [u128; N]) {\n // Safety: compute borrow flags out-of-circuit\n let (underflow, result, borrow_flags): (bool, [u128; N], [bool; N - 1]) =\n unsafe { __validate_gte_with_flags(lhs, rhs) };\n\n // Completeness: require that no underflow occurred\n assert(!underflow, \"validate_gt fail\");\n\n // Constrain the `result` to be a valid `BigNum` value\n validate_in_range::(result);\n // Constrain it to be strict inequality\n assert_is_not_zero_integer(result);\n\n // Constrain `result` and `borrow_flags` to match the expected arithmetic\n check_gte_with_flags(lhs, rhs, result, borrow_flags);\n}\n\n/// Constraining function for the results of `__validate_gte_with_flags`,\n/// used by both `cmp` and `validate gt`\n///\n/// This function checks the relations between `lhs`, `rhs`, `result` adn `borrow_flags`:\n/// lhs[0] - rhs[0] - result[0] + bf[0] * 2^{120} = 0\n/// lhs[i] - rhs[i] - result[i] + bf[i] * 2^{120} - bf[i - 1] = 0, i = 1..N-2\n/// lhs[N - 1] - rhs[N - 1] - result[N - 1] - bf[N - 2] = 0\npub(crate) fn check_gte_with_flags(\n lhs: [u128; N],\n rhs: [u128; N],\n result: [u128; N],\n borrow_flags: [bool; N - 1],\n) {\n let result_limb: Field = (lhs[0] as Field) - (rhs[0] as Field) - (result[0] as Field)\n + (borrow_flags[0] as Field) * TWO_POW_120 as Field;\n assert(result_limb == 0);\n\n for i in 1..N - 1 {\n let result_limb: Field = (lhs[i] as Field) - (rhs[i] as Field) - (result[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field);\n assert(result_limb == 0);\n }\n\n let result_limb: Field = (lhs[N - 1] as Field)\n - (rhs[N - 1] as Field)\n - (result[N - 1] as Field)\n - (borrow_flags[N - 2] as Field);\n assert(result_limb == 0);\n}\n\n/// Validate that `val` <= `MOD`\n///\n/// Compute `result = MOD - val` along with `borrow_flags`,\n/// then constrain `result` to be a valid `BigNum` value.\n///\n/// Basically the same as `validate_gt` but we compute the result on the fly\n/// It is just a bit more optimized as we expect each `BigNum` value to be \\leq `MOD`\n///\n/// ## Note\n/// In contrast to `validate_gt`, we allow the value to be `MOD`\n/// Since it is consistent with the rest of the library\npub(crate) fn validate_in_field(\n params: BigNumParams,\n val: [u128; N],\n) {\n let modulus: [u128; N] = params.modulus;\n\n // Safety: compute borrow flags out-of-circuit\n let borrow_flags: [bool; (N - 1)] =\n unsafe { __validate_in_field_compute_borrow_flags(params, val) };\n\n let mut p_minus_self: [Field; N] = [0; N];\n p_minus_self[0] = (modulus[0] as Field) - (val[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field);\n for i in 1..N - 1 {\n p_minus_self[i] = (modulus[i] as Field) - (val[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field);\n }\n p_minus_self[N - 1] =\n (modulus[N - 1] as Field) - (val[N - 1] as Field) - (borrow_flags[N - 2] as Field);\n validate_in_range::(p_minus_self);\n}\n\n/// Compare two `BigNum` values\n///\n/// Returns `lhs > rhs`\n///\n/// ## Note\n/// This is a strict value comparison over the integers,\n/// the values do not have to be reduced modulo `MOD`.\npub(crate) fn cmp(lhs: [u128; N], rhs: [u128; N]) -> Ordering {\n // Safety: we constrain:\n // - `result` and `borrow_flags` with `check_gte_with_flags`\n // - `borrow_flags` are also booleans\n // - `underflow` with the following swap and (bool)\n let (underflow, result, borrow_flags): (bool, [u128; N], [bool; N - 1]) =\n unsafe { __validate_gte_with_flags(lhs, rhs) };\n\n // if underflow is true, swap lhs and rhs\n let (lhs, rhs): ([u128; N], [u128; N]) = if underflow { (rhs, lhs) } else { (lhs, rhs) };\n\n // Constrain the `result` to be a valid `BigNum` value\n validate_in_range::(result);\n\n // Constrain subtraction: result = lhs - rhs with borrow_flags\n check_gte_with_flags(lhs, rhs, result, borrow_flags);\n\n if lhs == rhs {\n Ordering::equal()\n } else if underflow {\n Ordering::less()\n } else {\n Ordering::greater()\n }\n}\n\n// ------------------------------ ARITHMETIC FUNCTIONS ------------------------------\n\n/// Negate a `BigNum` value\n///\n/// Computes `result = MOD - val` using limb-wise subtraction with borrow flags,\n/// then constrains:\n/// - all `result` limbs to be a valid `BigNum` value, and\n/// - the subtraction relation with the borrow flags\n///\n/// ## Assumptions\n/// - `val` is a valid `BigNum` in the range `0 <= val <= MOD`.\n///\n/// ## Soundness\n/// This function constrains the following relations:\n/// result[0] = MOD[0] - val[0] + bf[0] * 2^{120} < 2^{120}\n/// result[i] = MOD[i] - val[i] + bf[i] * 2^{120} - bf[i - 1] < 2^{120}, i = 1..N-2\n/// result[N - 1] = MOD[N - 1] - val[N - 1] - bf[N - 2] < 2^{TOP_LIMB_BITS}\n///\n/// If all `MOD` and `val` limbs are valid `BigNum` limbs, these constraints\n/// ensure that:\n/// - the borrow flags `bf[i]` form a valid limb-wise subtraction chain, and\n/// - no underflow can occur in the subtraction `MOD - val`.\n///\n/// ## Completeness\n/// This function is complete for inputs in the range `0 <= val <= MOD`.\n/// If a value `val > MOD` is passed in (while still `< 2^{MOD_BITS}`), the\n/// constraints above will fail, since there is no valid borrow chain making\n/// `MOD - val` a well-formed `BigNum`.\n///\n/// In practice, honest provers should not hit this case: all functions in this\n/// module are expected to return values `< MOD`.\n///\n/// ## Note\n/// This function returns `MOD` when `val` is zero.\npub(crate) fn neg(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n if std::runtime::is_unconstrained() {\n // Safety: no need to constrain in an unconstrained runtime\n unsafe {\n __neg(params.modulus, val)\n }\n } else {\n // Safety: compute borrow flags out-of-circuit\n let (result, borrow_flags): ([u128; N], [bool; N - 1]) =\n unsafe { __neg_with_flags(params.modulus, val) };\n validate_in_range::(result);\n\n let result_limb: Field = (params.modulus[0] as Field)\n - (val[0] as Field)\n - (result[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n\n for i in 1..N - 1 {\n let result_limb: Field = (params.modulus[i] as Field)\n - (val[i] as Field)\n - (result[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field);\n assert(result_limb == 0);\n }\n\n let result_limb: Field = (params.modulus[N - 1] as Field)\n - (val[N - 1] as Field)\n - (result[N - 1] as Field)\n - (borrow_flags[N - 2] as Field);\n assert(result_limb == 0);\n result\n }\n}\n\n/// Add two `BigNum` values\n///\n/// Computes `result = lhs + rhs` using limb-wise addition with carry flags,\n/// and an optional subtraction of `MOD` using borrow flags. The function then\n/// constrains:\n/// - all `result` limbs to be a valid `BigNum` value, and\n/// - the addition/subtraction relation with the carry/borrow flags and the\n/// `overflow_modulus` bit.\n///\n/// ## Assumptions\n/// - All limbs of `lhs`, `rhs` and `MOD` are valid `BigNum` limbs\n/// (120-bit for non-top limbs, `TOP_LIMB_BITS` for the top limb).\n/// - Semantically, we intend to use this only with `0 <= lhs, rhs < MOD`,\n/// even though the limb/range constraints allow values up to `< 2^{MOD_BITS}`.\n///\n/// ## Soundness (intended relation)\n/// This function constrains the following equations:\n///\n/// result[0] = lhs[0] + rhs[0]\n/// - sub[0]\n/// + bf[0] * 2^{120}\n/// - cf[0] < 2^{120}\n///\n/// result[i] = lhs[i] + rhs[i]\n/// - sub[i]\n/// + bf[i] * 2^{120} - bf[i - 1]\n/// - cf[i] * 2^{120} + cf[i - 1] < 2^{120},\n/// for i = 1..N-2\n///\n/// result[N - 1] = lhs[N - 1] + rhs[N - 1]\n/// - sub[N - 1]\n/// - bf[N - 2]\n/// + cf[N - 2] < 2^{TOP_LIMB_BITS}\n///\n/// where:\n/// - `bf[i]` are the borrow flags of the optional subtraction,\n/// - `cf[i]` are the carry flags of the addition, and\n/// - `sub` is either the zero vector or `MOD`, depending on the\n/// `overflow_modulus` flag:\n/// * `overflow_modulus = 0` => `sub = 0`\n/// * `overflow_modulus = 1` => `sub = MOD`\n///\n/// If `lhs`, `rhs` and `MOD` are valid `BigNum` limbs and the witness for\n/// `(bf, cf, overflow_modulus)` is the honest one produced by `__add_with_flags`,\n/// these constraints enforce:\n/// - a valid limb-wise carry chain for `lhs + rhs`, and\n/// - a valid limb-wise subtraction chain for either `lhs + rhs` or\n/// `lhs + rhs - MOD`, with no underflow in any limb.\n///\n/// Under these assumptions the constrained result equals:\n///\n/// result = lhs + rhs (mod MOD)\n///\n/// in the intended arithmetic.\n///\n/// ## Limitations / extra satisfying witnesses\n///\n/// The constraint system itself does **not** uniquely determine the carry/borrow\n/// flags nor the `overflow_modulus` bit:\n///\n/// - For each limb `i`, `bf[i]` and `cf[i]` only appear in the combination\n/// `bf[i] * 2^{120} - cf[i] * 2^{120}`. This means that both\n///\n/// (bf[i], cf[i]) = (0, 0) and (bf[i], cf[i]) = (1, 1)\n///\n/// give the same contribution to the equation. As a result, there are multiple\n/// valid flag assignments for the *same* `lhs`, `rhs`, `sub` and `result`.\n///\n/// - More importantly, if `lhs + rhs` is greater than `MOD` but still strictly\n/// less than `2^{MOD_BITS}`, there exist *spurious* witnesses where:\n/// * `overflow_modulus` is set inconsistently with the true arithmetic\n/// overflow, and\n/// * the `(bf, cf)` flags are adjusted accordingly,\n///\n/// such that all equations above still hold and all `result` limbs remain\n/// within range. In particular, when\n///\n/// lhs + rhs + MOD < 2^{MOD_BITS},\n///\n/// a malicious prover can \"hide\" an extra `MOD` inside the choice of\n/// `overflow_modulus`, `bf` and `cf`, so that the circuit is satisfied by a\n/// witness\n///\n/// Consequently, this function is only *conditionally* sound: we rely on the\n/// out-of-circuit implementation of `__add_with_flags` to provide the honest\n/// `(borrow_flags, carry_flags, overflow_modulus)` witness. Under that\n/// assumption, the constrained `result` matches `lhs + rhs (mod MOD)`.\n///\n/// ## Completeness\n///\n/// For inputs in the range `0 <= lhs, rhs < MOD` and honest flags from\n/// `__add_with_flags`, the constraints are complete: every valid `BigNum` sum\n/// `lhs + rhs (mod MOD)` admits a satisfying assignment.\n///\n/// Inputs with `lhs` or `rhs` in `[MOD, 2^{MOD_BITS})` are still representable\n/// as limb arrays and may admit satisfying witnesses, but then the operation\n/// no longer corresponds to a unique, well-defined addition in the field\n/// `Z / MOD Z`. Such uses are outside the intended semantics of this function.\npub(crate) fn add(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n if std::runtime::is_unconstrained() {\n // Safety: no need to constrain in unconstrained runtime\n unsafe {\n __add(params.modulus, lhs, rhs)\n }\n } else {\n // Safety: compute borrow/carry flags out-of-circuit\n let (result, carry_flags, borrow_flags, overflow_modulus): ([u128; N], [bool; N - 1], [bool; N - 1], bool) =\n unsafe { __add_with_flags(params.modulus, lhs, rhs) };\n validate_in_range::(result);\n\n let mut subtrahend: [u128; N] = if overflow_modulus {\n params.modulus\n } else {\n [0; N]\n };\n\n let result_limb: Field = (lhs[0] as Field) + (rhs[0] as Field)\n - (result[0] as Field)\n - (subtrahend[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[0] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n for i in 1..N - 1 {\n let result_limb: Field = (lhs[i] as Field) + (rhs[i] as Field)\n - (result[i] as Field)\n - (subtrahend[i] as Field)\n - (borrow_flags[i - 1] as Field)\n + (carry_flags[i - 1] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[i] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n }\n let result_limb: Field = (lhs[N - 1] as Field) + (rhs[N - 1] as Field)\n - (result[N - 1] as Field)\n - (subtrahend[N - 1] as Field)\n - (borrow_flags[N - 2] as Field)\n + (carry_flags[N - 2] as Field);\n assert(result_limb == 0);\n result\n }\n}\n\n/// Subtract two `BigNum` values\n///\n/// Computes `result = lhs - rhs` using limb-wise subtraction with borrow flags,\n/// and an optional addition of `MOD` using carry flags. The function then\n/// constrains:\n/// - all `result` limbs to be a valid `BigNum` value, and\n/// - the subtraction/addition relation with the carry/borrow flags and the\n/// `underflow_modulus` bit.\n///\n/// ## Assumptions\n/// - All limbs of `lhs`, `rhs` and `MOD` are valid `BigNum` limbs\n/// (120-bit for non-top limbs, `TOP_LIMB_BITS` for the top limb).\n/// - Semantically, we intend to use this only with `0 <= lhs, rhs < MOD`,\n/// even though the limb/range constraints allow values up to `< 2^{MOD_BITS}`.\n///\n/// ## Soundness (intended relation)\n/// This function constrains the following equations:\n///\n/// result[0] = lhs[0] - rhs[0]\n/// + add[0]\n/// + bf[0] * 2^{120}\n/// - cf[0] < 2^{120}\n///\n/// result[i] = lhs[i] - rhs[i]\n/// + add[i]\n/// + bf[i] * 2^{120} - bf[i - 1]\n/// - cf[i] * 2^{120} + cf[i - 1] < 2^{120},\n/// for i = 1..N-2\n///\n/// result[N - 1] = lhs[N - 1] - rhs[N - 1]\n/// + add[N - 1]\n/// - bf[N - 2]\n/// + cf[N - 2] < 2^{TOP_LIMB_BITS}\n///\n/// where:\n/// - `bf[i]` are the borrow flags of the subtraction,\n/// - `cf[i]` are the carry flags of the optional addition, and\n/// - `add` is either the zero vector or `MOD`, depending on the\n/// `underflow_modulus` flag:\n/// * `underflow_modulus = 0` => `add = 0`\n/// * `underflow_modulus = 1` => `add = MOD`\n///\n/// If `lhs`, `rhs` and `MOD` are valid `BigNum` limbs and the witness for\n/// `(bf, cf, underflow_modulus)` is the honest one produced by `__sub_with_flags`,\n/// these constraints enforce:\n/// - a valid limb-wise borrow chain for `lhs - rhs`, and\n/// - a valid limb-wise addition chain for either `lhs - rhs` or\n/// `lhs - rhs + MOD`, with no underflow in any limb.\n///\n/// Under these assumptions the constrained result equals:\n///\n/// result = lhs - rhs (mod MOD)\n///\n/// in the intended arithmetic.\n///\n/// ## Limitations / extra satisfying witnesses\n///\n/// The constraint system itself does **not** uniquely determine the carry/borrow\n/// flags nor the `underflow_modulus` bit:\n///\n/// - For each limb `i`, `bf[i]` and `cf[i]` only appear in the combination\n/// `bf[i] * 2^{120} - cf[i] * 2^{120}`. This means that both\n///\n/// (bf[i], cf[i]) = (0, 0) and (bf[i], cf[i]) = (1, 1)\n///\n/// give the same contribution to the equation. As a result, there are multiple\n/// valid flag assignments for the *same* `lhs`, `rhs`, `add` and `result`.\n///\n/// - More importantly, when `lhs < rhs`, the true field result is\n///\n/// lhs - rhs + MOD,\n///\n/// and as long as\n///\n/// lhs - rhs + MOD < 2^{MOD_BITS},\n///\n/// a malicious prover can:\n/// * set `underflow_modulus` inconsistently with the true underflow, and\n/// * adjust the `(bf, cf)` flags accordingly,\n///\n/// such that all equations above still hold and all `result` limbs remain\n/// within range. In other words, the circuit can be satisfied by a witness\n/// that does **not** correspond to the unique intended subtraction modulo\n/// `MOD` for some inputs with `lhs < rhs`.\n///\n/// Consequently, this function is only *conditionally* sound: we rely on the\n/// out-of-circuit implementation of `__sub_with_flags` to provide the honest\n/// `(borrow_flags, carry_flags, underflow_modulus)` witness. Under that\n/// assumption, the constrained `result` matches `lhs - rhs (mod MOD)`.\n///\n/// ## Completeness\n///\n/// For inputs in the range `0 <= lhs, rhs < MOD` and honest flags from\n/// `__sub_with_flags`, the constraints are complete: every valid `BigNum`\n/// difference `lhs - rhs (mod MOD)` admits a satisfying assignment.\n///\n/// Inputs with `lhs` or `rhs` in `[MOD, 2^{MOD_BITS})` are still representable\n/// as limb arrays and may admit satisfying witnesses, but then the operation\n/// no longer corresponds to a unique, well-defined subtraction in the field\n/// `Z / MOD Z`. Such uses are outside the intended semantics of this function.\npub(crate) fn sub(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n if std::runtime::is_unconstrained() {\n // Safety: no need to constrain in unconstrained runtime\n unsafe {\n __sub(params.modulus, lhs, rhs)\n }\n } else {\n // Safety: we constrain carry, borrow, underflow and result immediately\n let (result, carry_flags, borrow_flags, underflow_modulus): ([u128; N], [bool; N - 1], [bool; N - 1], bool) =\n unsafe { __sub_with_flags(params.modulus, lhs, rhs) };\n validate_in_range::(result);\n\n let mut addend: [u128; N] = if underflow_modulus {\n params.modulus\n } else {\n [0; N]\n };\n\n let result_limb: Field = (lhs[0] as Field) - (rhs[0] as Field) - (result[0] as Field)\n + (addend[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[0] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n\n for i in 1..N - 1 {\n let result_limb: Field = (lhs[i] as Field) - (rhs[i] as Field) - (result[i] as Field)\n + (addend[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field)\n + (carry_flags[i - 1] as Field);\n assert(result_limb == 0);\n }\n let result_limb: Field = (lhs[N - 1] as Field)\n - (rhs[N - 1] as Field)\n - (result[N - 1] as Field)\n + (addend[N - 1] as Field)\n - (borrow_flags[N - 2] as Field)\n + (carry_flags[N - 2] as Field);\n assert(result_limb == 0);\n result\n }\n}\n\n/// Compute the `BigNum` multiplication\n///\n/// Computes `result = lhs * rhs (mod MOD)` by:\n/// 1. Computing `result` out of circuit via `__mul`.\n/// 2. Constraining the quadratic relation `lhs * rhs - result = 0` with\n/// `evaluate_quadratic_expression`.\n///\n/// ## Soundness\n/// Soundness reduces to `evaluate_quadratic_expression` for the relation\n/// `lhs * rhs - result = 0`\n///\n/// ## Note\n/// When possible, prefer expressing your computation directly as a quadratic\n/// relation and calling `evaluate_quadratic_expression` instead of using `mul`\npub(crate) fn mul(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n // Safety: we constrain the multiplication result immediately after\n let result: [u128; N] = unsafe { __mul::(params, lhs, rhs) };\n if !std::runtime::is_unconstrained() {\n // lhs * rhs - result = 0\n evaluate_quadratic_expression(\n params,\n [[lhs]],\n [[false]],\n [[rhs]],\n [[false]],\n [result],\n [true],\n );\n }\n result\n}\n\n/// Compute the `BigNum` squaring\n///\n/// Computes `result = val * val (mod MOD)` by:\n/// 1. Computing `result` out of circuit via `__sqr`.\n/// 2. Constraining the quadratic relation `val * val - result = 0` with\n/// `evaluate_quadratic_expression`.\n///\n/// ## Soundness\n/// Soundness reduces to `evaluate_quadratic_expression` for the relation\n/// `val * val - result = 0`\n///\n/// ## Note\n/// When possible, prefer expressing your computation directly as a quadratic\n/// relation and calling `evaluate_quadratic_expression` instead of using `sqr`\npub(crate) fn sqr(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n // Safety: we constrain the multiplication result immediately after\n let result: [u128; N] = unsafe { __sqr::<_, MOD_BITS>(params, val) };\n if !std::runtime::is_unconstrained() {\n // val * val - result = 0\n evaluate_quadratic_expression(\n params,\n [[val]],\n [[false]],\n [[val]],\n [[false]],\n [result],\n [true],\n );\n }\n result\n}\n\n/// Compute the `BigNum` division\n///\n/// Computes `result = lhs * rhs^{-1} (mod MOD)` by:\n/// 1. Computing `result` out of circuit via `__div`.\n/// 2. Constraining the quadratic relation `result * rhs - lhs = 0` with\n/// `evaluate_quadratic_expression`.\n/// 3. Enforcing `rhs != 0 (mod MOD)`.\n///\n/// ## Soundness\n/// Soundness reduces to `evaluate_quadratic_expression` for the relation\n/// `result * rhs - lhs = 0`, together with the non-zero check on `rhs` and the\n/// assumption that `MOD` has multiplicative inverses for all non-zero elements\n/// (`params.has_multiplicative_inverse = true`).\n///\n/// ## Note\n/// - This is **expensive** in witness time due to modular inversion.\n/// - When possible, prefer expressing your computation directly as a quadratic\n/// relation and calling `evaluate_quadratic_expression` instead of using `div`.\n/// - In the unconstrained runtime, the behavior of `__div` on zero divisors is\n/// not constrained by this function.\npub(crate) fn div(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n assert(\n params.has_multiplicative_inverse,\n \"BigNum has no multiplicative inverse. Use udiv for unsigned integer division\",\n );\n // Safety: We constrain the result of division immediately after\n let result: [u128; N] = unsafe { __div::<_, MOD_BITS>(params, lhs, rhs) };\n if !std::runtime::is_unconstrained() {\n // result * rhs - lhs = 0\n evaluate_quadratic_expression(\n params,\n [[result]],\n [[false]],\n [[rhs]],\n [[false]],\n [lhs],\n [true],\n );\n assert_is_not_zero(params, rhs);\n }\n result\n}\n\n/// Compute the `BigNum` integer division with remainder\n///\n/// Computes `quotient = floor(numerator / divisor)` and\n/// `remainder = numerator % divisor` by:\n/// 1. Computing `(quotient, remainder)` out of circuit via `__udiv_mod`.\n/// 2. Constraining the quadratic relation\n/// quotient * divisor + remainder - numerator = 0\n/// with `validate_udiv_mod_expression`.\n/// 3. Enforcing `remainder < divisor`.\n///\n/// ## Soundness\n/// Soundness reduces to `validate_udiv_mod_expression` for the relation\n/// quotient * divisor + remainder - numerator = 0,\n/// together with `remainder < divisor` check enforced via `validate_gt`.\n///\n/// Under these checks, any satisfying assignment corresponds to a valid\n/// integer division `numerator = quotient * divisor + remainder` with\n/// `0 <= remainder < divisor`\n///\n/// ## Note\n/// Enforcing `divisor != 0` is not necessary. `remainder < divisor`\n/// Already enforces this.\npub(crate) fn udiv_mod(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> ([u128; N], [u128; N]) {\n // Safety: We constrain the result of __udiv_mod immediately after\n let (quotient, remainder): ([u128; N], [u128; N]) = unsafe { __udiv_mod(numerator, divisor) };\n if !std::runtime::is_unconstrained() {\n // quotient * divisor + remainder - numerator = 0\n validate_udiv_mod_expression::(numerator, divisor, quotient, remainder);\n // remainder < divisor\n validate_gt::(divisor, remainder);\n }\n (quotient, remainder)\n}\n\n/// Compute the `BigNum` integer division\n///\n/// Returns `floor(numerator / divisor)`.\n/// All constraints and soundness details are handled inside `udiv_mod`.\npub(crate) fn udiv(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> [u128; N] {\n udiv_mod::(numerator, divisor).0\n}\n\n/// Compute the `BigNum` remainder\n///\n/// Returns `numerator % divisor`.\n/// All constraints and soundness details are handled inside `udiv_mod`.\npub(crate) fn umod(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> [u128; N] {\n udiv_mod::(numerator, divisor).1\n}","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/constrained_ops.nr"},"121":{"source":"use crate::utils::split_bits;\n\nuse crate::constants::{TWO_POW_120, TWO_POW_126, TWO_POW_246};\n\nuse crate::fns::constrained_ops::{validate_in_range, validate_quotient_in_range};\nuse crate::fns::unconstrained_helpers::__barrett_reduction;\nuse crate::fns::unconstrained_ops::__is_zero;\n\nuse crate::params::BigNumParams;\n\n// ------------------------------ UNCONSTRAINED EXPRESSIONS ------------------------------\n\n/// Compute the result of a linear combination of (possibly negative) `BigNum` values (unconstrained)\n///\n/// ## Note\n/// 1. `modulus2` is structured such that all limbs will be greater than `0`, even when subtracting.\n/// To do this, when computing `p - x`, we ensure that each limb in `p` is greater than each limb in `x`.\n/// We know that, for a valid bignum element, the limbs in `x` will be < 2^{120}\n/// Therefore each of the limbs in `p` (except the most significant) will borrow 2^{120} from the more significant limb.\n/// Finally, to ensure we do not underflow in the most significant limb, we use `2p` instead of `p`\n///\n/// 2. Returns the `Field` values that are not normalized to be 120-bit\nunconstrained fn __add_linear_expression(\n params: BigNumParams,\n vals: [[u128; N]; M],\n flags: [bool; M],\n) -> ([Field; N]) {\n let mut sum: [Field; N] = [0; N];\n let modulus2: [u128; N] = params.double_modulus;\n for i in 0..M {\n if (flags[i]) {\n for j in 0..N {\n sum[j] = sum[j] + (modulus2[j] as Field) - (vals[i][j] as Field);\n }\n } else {\n for j in 0..N {\n sum[j] = sum[j] + (vals[i][j] as Field);\n }\n }\n }\n sum\n}\n\n/// Compute the limb products of a quadratic expression (unconstrained)\n///\n/// See `__compute_quadratic_expression_with_borrow_flags` for full description\n///\n/// ## Note\n/// Returns the `Field` values that are not normalized to be 120-bit\nunconstrained fn __compute_quadratic_expression_product(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> [Field; 2 * N] {\n let mut lhs: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n let mut rhs: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n\n for i in 0..NUM_PRODUCTS {\n lhs[i] = __add_linear_expression(params, lhs_terms[i], lhs_flags[i]);\n rhs[i] = __add_linear_expression(params, rhs_terms[i], rhs_flags[i]);\n }\n let add: [Field; N] = __add_linear_expression(params, linear_terms, linear_flags);\n\n let mut mulout: [Field; 2 * N] = [0; 2 * N];\n for i in 0..N {\n for j in 0..N {\n for k in 0..NUM_PRODUCTS {\n mulout[i + j] += lhs[k][i] * rhs[k][j];\n }\n }\n mulout[i] += add[i];\n }\n mulout\n}\n\n/// Compute the borrow flags for a limb-wise subtraction `lhs - rhs` (unconstrained).\n///\n/// This helper operates on `N`-limb values where each limb is interpreted as a\n/// 120-bit chunk (base `B = 2^{120}`), but where intermediate limbs may exceed\n/// `2^{120}` due to sums of products.\n///\n/// Conceptually, we want to model the integer subtraction\n///\n/// lhs - rhs\n///\n/// as a base-`B` subtraction with borrows, without allowing any intermediate\n/// values to go negative in the circuit field. We achieve this by:\n///\n/// 1. Working with widened 246-bit ranges per limb.\n/// 2. Encoding a borrow from limb `i+1` into limb `i` by:\n/// - adding `2^{246}` into limb `i`,\n/// - subtracting `2^{126}` (= 2^{246 - 120}) from limb `i+1` after\n/// scaling by `2^{-120}`.\n///\n/// The returned `borrow_flags[i]` indicate whether the canonical integer\n/// subtraction would borrow from limb `i+1` into limb `i`. These flags are\n/// later re-applied in-circuit via `apply_borrow_flags`, and the resulting\n/// limbs are checked by `validate_expression_is_zero`.\nunconstrained fn __compute_borrow_flags(\n mut lhs_limbs: [Field; N],\n rhs_limbs: [Field; N],\n) -> [bool; N - 1] {\n // compute borrow flags from mulout_p and mulout_n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n let borrow_shift: Field = TWO_POW_246; // 2^{246}\n let borrow_carry: Field = TWO_POW_126; // 2^{126} = 2^{246 - 120}\n let downshift_120: Field = 1 / (TWO_POW_120 as Field);\n\n // determine whether we need to borrow from more significant limbs.\n // initial limb is \"simple\" comparison operation\n borrow_flags[0] = lhs_limbs[0].lt(rhs_limbs[0]);\n\n // we have N - 1 borrow flags. The number of limbs is N\n // and there is nothing to borrow against for the final limb.\n let mut hi_bits: Field =\n (lhs_limbs[0] - rhs_limbs[0] + ((borrow_flags[0] as Field) * borrow_shift)) * downshift_120;\n\n for i in 1..(N - 1) {\n // compute the contribution from limb `i-1` that gets added into limb `i`, and add into limb `i`\n lhs_limbs[i] += hi_bits;\n\n let subtrahend: Field = rhs_limbs[i] + (borrow_flags[i - 1] as Field) * borrow_carry;\n\n // determine whether negative limb values are greater than positive limb values\n borrow_flags[i] = lhs_limbs[i].lt(subtrahend);\n let minuend: Field = lhs_limbs[i] + (borrow_flags[i] as Field) * borrow_shift;\n\n hi_bits = (minuend - subtrahend) * downshift_120;\n }\n borrow_flags\n}\n\n/// Given a degree-2 `BigNum` expression that is equal to `0 mod MOD`, compute\n/// the quotient and the borrow flags (unconstrained).\n///\n/// The expression has the form:\n///\n/// sum_{k=0}^{NUM_PRODUCTS-1} (L_k * R_k) + sum_{i=0}^{ADD_N-1} A_i = quotient * MOD\n///\n/// where each `L_k`, `R_k`, `A_i` is an `N`-limb `BigNum` assembled from the\n/// `(terms, flags)` arrays.\n///\n/// This helper:\n/// 1. Evaluates the quadratic expression into `mulout_p` as a `2N`-limb\n/// non-normalized value.\n/// 2. Normalizes `mulout_p` into 120-bit limbs and applies Barrett\n/// reduction to obtain `(quotient, remainder)`.\n/// 3. Asserts that the integer remainder is zero (debugging aid; range\n/// checks enforce this later).\n/// 4. Reconstructs `mulout_n = quotient * MOD`.\n/// 5. Computes `borrow_flags` for the limb-wise subtraction\n/// `mulout_p - mulout_n`,\n/// using the 2^{246}/2^{126} encoding described in\n/// `evaluate_quadratic_expression`.\n///\n/// The returned `quotient` and `borrow_flags` are later constrained\n/// in-circuit by `compute_quadratic_expression_with_modulus` and\n/// `evaluate_quadratic_expression`.\nunconstrained fn __compute_quadratic_expression_with_borrow_flags(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> ([u128; N], [bool; 2 * N - 2]) {\n let mulout_p: [Field; 2 * N] = __compute_quadratic_expression_product(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n\n // `__normalize_limbs` will validate that we do not overflow 2N, normally we should not overflow 2N-1\n let mut relation_result: [u128; 2 * N] = split_bits::__normalize_limbs(mulout_p);\n let (quotient, remainder): ([u128; N], [u128; N]) =\n __barrett_reduction(relation_result, params.redc_param, MOD_BITS, params.modulus);\n\n // This is verified later by the range checks but left for debugging purposes\n assert(__is_zero(remainder));\n\n // We do not normalize `mulout_n` so we won't fill the `2 * N - 1`\n let mut mulout_n: [Field; 2 * N] = [0; 2 * N];\n for i in 0..N {\n for j in 0..N {\n mulout_n[i + j] += (quotient[i] as Field) * (params.modulus[j] as Field);\n }\n }\n\n let borrow_flags: [bool; 2 * N - 1] = __compute_borrow_flags(mulout_p, mulout_n);\n\n // We have to copy it because we know that borrow_flags[2 * N - 1] is always 0\n // But we also have to provide 2 * N limbs to `__barrett_reduction`.\n // And keep `__compute_borrow_flags` generic enough\n let mut borrow_flags_real: [bool; 2 * N - 2] = [false; 2 * N - 2];\n for i in 0..2 * N - 2 {\n borrow_flags_real[i] = borrow_flags[i];\n }\n\n (quotient, borrow_flags_real)\n}\n\n/// Computes the quotient/remainder of a quadratic expression (unconstrained)\n///\n/// See `__compute_quadratic_expression_with_borrow_flags` for full description\npub(crate) unconstrained fn __compute_quadratic_expression(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> ([u128; N], [u128; N]) {\n let mulout: [Field; 2 * N] = __compute_quadratic_expression_product(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n // __normalize_limbs will validate that we do not overflow 2N, normally we should not overflow 2N-1\n let mut relation_result: [u128; 2 * N] = split_bits::__normalize_limbs(mulout);\n\n let (quotient, remainder): ([u128; N], [u128; N]) =\n __barrett_reduction(relation_result, params.redc_param, MOD_BITS, params.modulus);\n\n (quotient, remainder)\n}\n\n// ------------------------------ CONSTRAINED EXPRESSIONS ------------------------------\n\n/// Constrained version of `__add_linear_expression`\n///\n/// Computes all the linear parts of an expression in-circuit\n///\n/// ## Note\n/// 1. Negative terms are implemented by adding `double_modulus`\n/// `double_modulus` is chosen so that all limbs except the top one\n/// are > 2^{120}, which prevents underflows in intermediate computations.\n///\n/// 2. For the most significant limb we slightly reduce the padding (to keep the\n/// overall value equal to `2 * MOD`), so in principle there is a narrow edge\n/// case where that limb could underflow if enough negative contributions are\n/// accumulated and the top limb of `MOD` is very small. In practice, the\n/// global `BigNum` range and operand-count assumptions in\n/// `evaluate_quadratic_expression` rule out such patterns.\nfn compute_linear_expressions(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> ([[Field; N]; NUM_PRODUCTS], [[Field; N]; NUM_PRODUCTS], [Field; N]) {\n // lhs linear terms\n let mut lhs_linear: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n // rhs linear terms\n let mut rhs_linear: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n // linear terms\n let mut lin_expr: [Field; N] = [0; N];\n\n for k in 0..NUM_PRODUCTS {\n for i in 0..N {\n for j in 0..LHS_N {\n // Note: if lhs_flags[k][j] - `is_negative` is not known at comptime this is very expensive\n if (lhs_flags[k][j]) {\n lhs_linear[k][i] -= lhs_terms[k][j][i] as Field;\n lhs_linear[k][i] += params.double_modulus[i] as Field;\n } else {\n lhs_linear[k][i] += lhs_terms[k][j][i] as Field;\n }\n }\n for j in 0..RHS_N {\n // Note: if rhs_flags[k][j] - `is_negative` is not known at comptime this is very expensive\n if (rhs_flags[k][j]) {\n rhs_linear[k][i] -= rhs_terms[k][j][i] as Field;\n rhs_linear[k][i] += params.double_modulus[i] as Field;\n } else {\n rhs_linear[k][i] += rhs_terms[k][j][i] as Field;\n }\n }\n }\n }\n\n for i in 0..N {\n for j in 0..ADD_N {\n // Note: if linear_flags[j] - `is_negative` is not known at comptime this is very expensive\n if (linear_flags[j]) {\n lin_expr[i] -= linear_terms[j][i] as Field;\n lin_expr[i] += params.double_modulus[i] as Field;\n } else {\n lin_expr[i] += linear_terms[j][i] as Field;\n }\n }\n }\n\n (lhs_linear, rhs_linear, lin_expr)\n}\n\n/// Constrained version of `__compute_quadratic_expression_product`\n///\n/// Computes the following expression in-circuit:\n/// \\sum (L_i * R_i) + \\sum (A_i) - QUOTIENT * MOD\n///\n/// Because of the subtraction of `QUOTIENT * MODULUS`, the resulting limbs may\n/// underflow and represent *negative* values. To account for this, we allow the\n/// prover to choose a sequence of borrow flags and interpret the limbs with\n/// additional terms:\n///\n/// - for each limb `i` we may add `2^{246}` (via a flag at position `i`);\n/// - for each limb `i` we may subtract `2^{126 = 246 - 120}` (via the flag\n/// at position `i - 1`).\n///\n/// This corresponds to borrowing `2^{126}` from limb `i + 1` and adding\n/// `2^{246}` into limb `i`. After this adjustment, an honest prover can ensure\n/// that every limb lies in `[0, 2^{246})` and that the adjusted limbs encode\n/// the correct integer value.\n///\n/// Additionally, we constrain the quotient limbs via `validate_quotient_in_range`:\n/// - limbs `0..N-2` of `quotient` are < 2^{120};\n/// - the top limb is < 2^{TOP_LIMB_BITS + 6}.\n/// Which validates `quotient < 2^{MOD_BITS + 6}`\n///\n/// ## TODO\n/// Apply static or runtime checks in this method to validate that the effective\n/// `twiddle_factor` does not exceed 6 under the chosen parameters.\nfn compute_quadratic_expression_with_modulus(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> [Field; 2 * N - 1] {\n // Safety: use an unconstrained function to compute the value of the quotient and borrow_flags out-of-circuit\n let (quotient, borrow_flags): ([u128; N], [bool; 2 * N - 2]) = unsafe {\n __compute_quadratic_expression_with_borrow_flags::(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n )\n };\n\n // Constrain the `quotient < 2^{MOD_BITS + 6}`\n // By constraining limbs(0..N-2) to be < 2^120 and the the top limb < 2^{TOP_LIMB_BITS + 6}\n validate_quotient_in_range::(quotient);\n\n // Compute the linear sums that represent L_i, R_i, A\n let (lhs_linear, rhs_linear, lin_expr): ([[Field; N]; NUM_PRODUCTS], [[Field; N]; NUM_PRODUCTS], [Field; N]) = compute_linear_expressions::(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n\n // We want to evaluate that L * R + A - Quotient * MOD = 0, evaluated over the integers\n // For this we need to be able to borrow values from more-significant limbs into less-significant limbs,\n // so that we can ensure that no limbs will underflow\n let mut expression_limbs: [Field; 2 * N - 1] = [0; 2 * N - 1];\n\n // Compute the product t0 * t1 + t4 - Quotient * MOD\n // TODO: this is super nasty as it requires a multiplication\n for i in 0..N {\n for j in 0..N {\n for k in 0..NUM_PRODUCTS {\n if k == 0 {\n let new_term: Field = lhs_linear[k][i] * rhs_linear[k][j]\n - (quotient[i] as Field) * (params.modulus[j] as Field);\n // width-4 optimization\n std::as_witness(new_term);\n expression_limbs[i + j] += new_term;\n } else {\n expression_limbs[i + j] += lhs_linear[k][i] * rhs_linear[k][j];\n }\n }\n // This is the fallback for pure linear expression\n if (NUM_PRODUCTS == 0) {\n expression_limbs[i + j] -= (quotient[i] as Field) * (params.modulus[j] as Field);\n }\n }\n expression_limbs[i] += lin_expr[i];\n }\n\n apply_borrow_flags(expression_limbs, borrow_flags)\n}\n\n/// Apply a precomputed borrow chain to a limb array.\n///\n/// Given:\n///\n/// - `expression_limbs`: an `N`-limb array of `Field` values representing a\n/// (possibly non-normalized) degree-2-style expression, and\n/// - `borrow_flags[i]` indicating that we \"borrow\" from limb `i+1` into limb `i`,\n///\n/// this function applies the same 2^{246}/2^{126} encoding used in\n/// `__compute_borrow_flags` to produce an adjusted limb array\n///\n/// This matches the behavior of `__compute_borrow_flags`, which conceptually:\n///\n/// 1. Adds `2^{246}` into a limb when a borrow is taken at that limb;\n/// 2. After scaling by `2^{-120}`, contributes `2^{126}` into the next limb.\n///\n/// The resulting `expression_limbs` can then be passed to\n/// `validate_expression_is_zero`, which:\n///\n/// - right-shifts by 120 bits per limb,\n/// - enforces a 126-bit bound,\n/// - and propagates carries forward, finally checking that the most\n/// significant limb is zero.\n///\n/// ## Assumptions\n///\n/// - `borrow_flags` was computed consistently with the original construction\n/// of `expression_limbs` (e.g. via `__compute_borrow_flags` on the\n/// corresponding unconstrained expression).\n/// - The caller has ensured that each adjusted limb remains < 2^{246} for\n/// honest witnesses (e.g. via `NUM_PRODUCTS < 64`).\n///\n/// ## Note\n///\n/// This function does not itself enforce any bit-size bounds; it only applies\n/// the borrow encoding. The actual range checks happen later in\n/// `validate_expression_is_zero`.\n///\n/// ## TODO\n/// define trade-offs regarding the value of borrow_shift\n/// (the larger the value, the greater the range check that is required on product_limbs)\n/// (126-bit range check is a sweet spot for the barretenberg backend as it decomposes into 9 14-bit range checks)\n/// (the barretenberg backend can evaluate these in 5.25 gates. 127 bits costs 6.5 gates)\nfn apply_borrow_flags(\n mut expression_limbs: [Field; N],\n borrow_flags: [bool; N - 1],\n) -> [Field; N] {\n let borrow_shift: Field = TWO_POW_246; // 2^{246}\n let borrow_carry: Field = TWO_POW_126; // 2^{246 - 120} = 2^{126}\n\n // Get the product_limbs into the form where each entry is a 246-bit value\n expression_limbs[0] += (borrow_flags[0] as Field) * borrow_shift;\n for i in 1..(N - 1) {\n expression_limbs[i] += (borrow_flags[i] as Field) * borrow_shift\n - (borrow_flags[i - 1] as Field) * borrow_carry;\n }\n expression_limbs[N - 1] -= (borrow_flags[N - 2] as Field) * borrow_carry;\n expression_limbs\n}\n\n/// Validate that `limbs` represent the integer value `0`\n///\n/// ## Assumptions\n/// - `limbs` is an array of `Field` values that was derived arithmetically as\n/// a degree-2 expression\n/// - each limb satisfies `limbs[i] < 2^{246}`, as ensured by\n/// `compute_quadratic_expression_with_modulus` under its parameter bounds.\n///\n/// ## Details\n/// Each element `i` in `limbs` overlaps in bit-range with element `i+1`, EXCEPT for the low 120 bits\n/// i.e. we need to do the following for each limb `i`:\n/// 1. validate the limb's low-120 bits equals zero\n/// 2. compute the limb \"carry\" by right-shifting by 2^{120}\n/// 3. propagate the \"carry\" into limb `i+1`\n/// We can efficiently do all of the above by multiplying the limb by 2^{-120} and constraining the result to be <2^{126}\n///\n/// If the low 120 bits are nonzero, there is no value in `[0, 2^{126})` that\n/// could have produced this limb after multiplying by `2^{120}`. Since\n/// multiplication by `2^{120}` is a bijection on the Field, any limb with\n/// non-zero low 120 bits must map outside the `[0, 2^{126})` range after\n/// scaling by `2^{-120}`.\n///\n/// The most significant limb has no limb to \"carry\" values into - the entire limb must equal zero\n///\n/// ## Note\n/// The constant 126 is not arbitrary. We use 120-bit limbs and allow up to 64\n/// products per limb, which contributes at most `log2(64) = 6` bits of headroom.\n/// After scaling by `2^{-120}`, honest witnesses fit in 126 bits. We could in\n/// principle go higher (up to roughly `CircuitModulusBits - 121`), but 126 is\n/// the minimal bound consistent with `NUM_PRODUCTS < 64` and is significantly\n/// cheaper than larger bounds for the barretenberg backend.\nfn validate_expression_is_zero(mut limbs: [Field; N]) {\n let hi_shift: Field = TWO_POW_120 as Field;\n let hi_downshift: Field = 1 / hi_shift;\n for i in 0..N - 1 {\n limbs[i] *= hi_downshift;\n std::as_witness(limbs[i]);\n limbs[i].assert_max_bit_size::<126>(); // N.B. is this sufficient? going beyond 126 costs us 1 gate per limb\n limbs[i + 1] += limbs[i];\n }\n assert(limbs[N - 1] == 0);\n}\n\n/// Constrain a degree-2 `BigNum` expression to be equal to 0 (mod `MOD`)\n///\n//\n/// This method is intended for relations where the remainder term of the\n/// degree-2 expression is exactly zero as an integer relation. In other words,\n/// we use it only when we expect:\n///\n/// \\sum (L_i * R_i) + \\sum (A_i) - QUOTIENT * MOD = 0\n///\n/// as integers, not just modulo the circuit field or `BigNum` field.\n///\n/// ## Details\n///\n/// The constrained expression, viewed over the integers, is:\n///\n/// \\sum_{i=0}^{NUM_PRODUCTS-1} (L_i * R_i)\n/// + \\sum_{i=0}^{ADD_N-1} (A_i)\n/// - QUOTIENT * MOD\n/// = 0\n///\n/// Each `L_i`, `R_i`, `A_i` is an `N`-limb `BigNum` assembled from the\n/// `(terms, flags)` arrays. For example, for `i = 0`:\n///\n/// L_0 = \\sum_{j=0}^{LHS_N-1} lhs[0][j] as a `BigNum`\n/// R_0 = \\sum_{j=0}^{RHS_N-1} rhs[0][j] as a `BigNum`\n///\n/// The intent is to capture a generic degree-2 expression within Noir's\n/// limitations (no efficient dynamically sized vectors).\n///\n/// The expensive parts of this algorithm are:\n/// 1. evaluating the limb products required to compute the `L_i * R_i` values;\n/// 2. applying range constraints to validate that the result encodes 0.\n///\n/// ## Note\n/// When the expression is evaluated over `N`-limb `BigNum` values, the product\n/// has up to `2N - 1` significant limbs. Each limb is a sum of at most\n/// `NUM_PRODUCTS` products of `linear` 120-bit limbs and `quadratic` 240-bit-ish limbs\n///\n/// Note that:\n/// * limb-wise multiplication is not uniform across indices. For example:\n///\n/// [x0, x1, x2] * [y0, y1, y2] =\n/// [\n/// x0*y0, // 1 term\n/// x0*y1 + x1*y0, // 2 terms\n/// x0*y2 + x1*y1 + x2*y0, // 3 terms\n/// x1*y2 + x2*y1, // 2 terms\n/// x2*y2 // 1 term\n/// ]\n/// The number of partial products per limb grows linearly from 1 to N,\n/// then decreases linearly back to 1.\n///\n/// * we also allow linear combinations inside the products, which further increases the bound\n/// on a `quadratic` limb\n///\n/// * finally, when `is_negative` flag is set, we effectively add 2 * MOD to each limb, where\n/// 2 * MOD limbs are structured in such a way that they all are > 2**120\n///\n/// We allow `NUM_PRODUCTS < 64` completeness-wise, but it certainly can overflow the 2^{240 + `twiddle_factor=6`} bound\n/// in edge cases. See completeness section for an example.\n///\n/// ## Assumptions\n///\n/// Each `BigNum` value used in this gadget is already range constrained:\n/// - limbs `0..N-2` satisfy `limb_i < 2^{120}`\n/// - limb `N-1` satisfies `limb_{N-1} < 2^{TOP_LIMB_BITS}`\n///\n/// ## Completeness\n/// If an honest prover supplies inputs that satisfy the assumptions above,\n/// it can always find a `quotient` and `borrow_flags` such that the integer\n/// relation holds and all constraints are satisfied.\n///\n/// The only possibility to break completeness is by providing too many inputs, for example:\n///\n/// (a0 + a1 + a2) * (b0 + b1 + b2) + ... (60 times), with each a_i having its limbs at maximum value of 2^{120} - 1\n/// The middle limb will contain a value that will definitely overflow the 2^{246} bound.\n///\n/// ## Soundness\n/// This function is conditionally sound: it enforces that the degree-2 relation\n/// holds modulo `MOD`, but it does not, by itself, enforce that any particular\n/// term (for example a result `z`) is a *canonical* representative in\n/// `[0, MOD)`.\n///\n/// In other words, if the surrounding relation is invariant under adding a\n/// multiple of `MOD` to one of its terms, then a dishonest prover can exploit\n/// this. For example, consider a multiplication relation:\n///\n/// x * y - z = 0 (mod MOD)\n///\n/// Internally we encode this as:\n///\n/// x * y + 2 * MOD - z - quotient * MOD = 0\n///\n/// which is equivalent to:\n///\n/// x * y - z = (quotient - 2) * MOD\n///\n/// Suppose the honest witness uses some `z` satisfying\n/// `0 <= z < MOD` and some `quotient`. If the `BigNum` encoding allows\n/// `z' = z + MOD` (i.e. `z' < 2^{MOD_BITS}` still holds), then a dishonest\n/// prover can instead provide:\n///\n/// z' = z + MOD\n/// quotient' = quotient - 1\n///\n/// and still satisfy:\n///\n/// x * y + 2 * MOD - z' - quotient' * MOD = 0\n///\n/// even though `z'` is no longer the canonical representative of `x * y mod MOD`.\n///\n/// The same consideration applies to almost every constrained `BigNum` relation:\n/// whenever a value participates *only* through a modular equality, and no\n/// separate range constraint is imposed on that value, the prover is free to\n/// shift it by an extra `MOD` as long as the resulting limb\n/// encoding still satisfies its bit-bounds. This is inherent in working with\n/// modular constraints; the responsibility for enforcing canonical\n/// representatives lies with the caller when it is required.\n///\n/// This is the same \"extra modulus\" phenomenon as in the `add`/`sub` functions:\n/// the constraints are sound for modular arithmetic, but any caller that\n/// requires canonical outputs in `[0, MOD)` must additionally enforce a\n/// range check (for example via `validate_in_field`) on the relevant terms.\npub(crate) fn evaluate_quadratic_expression(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) {\n assert(NUM_PRODUCTS < 64, f\"evaluate_quadratic_expression overflow in operands count\");\n // NUM_PRODUCTS < 64 is a light bound that tries to ensure each limb sum < 2^{246} so that the 126-bit bound is valid.\n\n lhs_terms.for_each(|lhs_limbs: [[u128; N]; LHS_N]| {\n lhs_limbs.for_each(|term: [u128; N]| validate_in_range::(term))\n });\n rhs_terms.for_each(|rhs_limbs: [[u128; N]; RHS_N]| {\n rhs_limbs.for_each(|term: [u128; N]| validate_in_range::(term))\n });\n linear_terms.for_each(|term: [u128; N]| validate_in_range::(term));\n\n let expression_limbs: [Field; 2 * N - 1] = compute_quadratic_expression_with_modulus::(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n validate_expression_is_zero(expression_limbs);\n}\n\n// ------------------------------ UDIV MOD EXPRESSION ------------------------------\n\n/// Given a `udiv_mod` `BigNum` expression that is equal to `0` over integers, compute the borrow flags (unconstrained)\n///\n/// Mirror function of `__compute_quadratic_expression_with_borrow_flags` optimized to compute borrow flags of an expression:\n/// divisor * quotient + remainder - numerator = 0\n/// see `__compute_quadratic_expression_with_borrow_flags` for details\n///\n/// The main differences from it are:\n/// 1. `product_limbs` stores only the least-significant `N` limbs of\n/// `quotient * divisor + remainder`. This is sufficient to compute the\n/// borrow flags for the first `N` limbs of\n/// quotient * divisor + remainder - numerator.\n///\n/// For an honest `udiv_mod` relation we also have\n/// quotient * divisor <= numerator < B^N,\n/// so the true product fits into `N` limbs as an integer.\n/// 2. Instead of subtracting `quotient * MOD` we subtract `numerator`. This is due to the fact that\n/// we no longer work over `MOD`, and we can't really do subtractions as we did previously: `double_modulus - x`\n///\n/// ## Note\n/// We leave the borrow values at 2^{246}, even though we should never reach this bound with just 3 terms\n/// The cases where it can happen are: N >= 64 (middle limb will have 64 additions). And it is a pure completeness issue\n/// But the rest of the library will probably not work with that massive number anyway\nunconstrained fn __compute_udiv_mod_expression_with_borrow_flags(\n numerator: [u128; N],\n divisor: [u128; N],\n quotient: [u128; N],\n remainder: [u128; N],\n) -> [bool; N - 1] {\n let mut product_limbs: [Field; N] = [0; N];\n let mut numerator_field: [Field; N] = [0; N];\n for i in 0..N {\n for j in 0..N - i {\n product_limbs[i + j] += (quotient[i] as Field) * (divisor[j] as Field);\n }\n product_limbs[i] += (remainder[i] as Field);\n\n numerator_field[i] = numerator[i] as Field;\n }\n\n __compute_borrow_flags(product_limbs, numerator_field)\n}\n\n/// Constrained version of `__compute_udiv_mod_expression_with_borrow_flags`\n///\n/// Computes the following expression in-circuit:\n/// quotient * divisor + remainder - numerator = 0\n///\n/// Mirror function of `compute_quadratic_expression_with_modulus`. See it for details.\n///\n/// ## Soundness note\n/// We compute the full convolution `quotient * divisor` into `2N - 1` limbs\n/// and then constrain all limbs with index `i >= N` to be zero. For `i >= N`\n/// the value `expression_limbs_full[i]` is a sum of products\n/// sum_{j+k=i} quotient[j] * divisor[k]\n/// with no contribution from `numerator` or `remainder`.\n///\n/// Every limb of `quotient` and `divisor` is range-constrained to be a 120-bit\n/// integer, so each product term is < 2^{240} and each coefficient of the\n/// convolution is strictly smaller than the field modulus. In this regime,\n/// the constraint `expression_limbs_full[i] == 0` in `Field` coincides with\n/// the same equality over the integers.\n///\n/// Vanishing of all high limbs `i >= N` is therefore an integer statement that\n/// the product has degree < N, i.e.\n/// quotient * divisor < 2^{120 * N},\n/// so `quotient * divisor` fits into `N` 120-bit limbs and does not overflow.\nfn compute_udiv_mod_expression(\n numerator: [u128; N],\n divisor: [u128; N],\n quotient: [u128; N],\n remainder: [u128; N],\n) -> [Field; N] {\n // Safety: use an unconstrained function to compute the value of the quotient and borrow_flags out-of-circuit\n let borrow_flags: [bool; N - 1] = unsafe {\n __compute_udiv_mod_expression_with_borrow_flags::(\n numerator,\n divisor,\n quotient,\n remainder,\n )\n };\n\n let mut expression_limbs_full: [Field; 2 * N - 1] = [0; 2 * N - 1];\n for i in 0..N {\n for j in 0..N {\n expression_limbs_full[i + j] += (quotient[i] as Field) * (divisor[j] as Field);\n }\n expression_limbs_full[i] += (remainder[i] as Field) - (numerator[i] as Field);\n }\n\n let mut expression_limbs: [Field; N] = [0; N];\n for i in 0..N {\n expression_limbs[i] = expression_limbs_full[i];\n }\n for i in N..2 * N - 1 {\n assert(expression_limbs_full[i] == 0);\n }\n\n apply_borrow_flags(expression_limbs, borrow_flags)\n}\n\n/// Constrain a `udiv_mod` `BigNum` expression to be equal to 0\n///\n/// Mirror function of `evaluate_quadratic_expression`\n///\n/// ## Details\n///\n/// The constrained expression, viewed over the integers, is:\n///\n/// quotient * divisor + remainder - numerator = 0\n///\n/// ## Completeness\n/// If an honest prover supplies valid `BigNum` inputs that satisfy the equation,\n/// it can always find `borrow_flags` such that the integer\n/// relation holds and all constraints are satisfied.\n///\n/// The only possibility to break completeness is by providing a `BigNum` with `N >= 64`\n/// See `__compute_udiv_mod_expression_with_borrow_flags` for details\n///\n/// ## Soundness\n/// This function is conditionally sound: it enforces that the degree-2 relation\n/// holds over the integers, but it does not, by itself, enforce that\n/// this relation is unique for given `numerator` and `divisor`\n///\n/// For example, if the true relation is\n/// quotient * divisor + remainder - numerator = 0\n///\n/// then we can set quotient' = quotient - 1, remainder' = remainder + divisor\npub(crate) fn validate_udiv_mod_expression(\n numerator: [u128; N],\n divisor: [u128; N],\n quotient: [u128; N],\n remainder: [u128; N],\n) {\n validate_in_range::(numerator);\n validate_in_range::(divisor);\n validate_in_range::(quotient);\n validate_in_range::(remainder);\n\n let expression_limbs: [Field; N] =\n compute_udiv_mod_expression::(numerator, divisor, quotient, remainder);\n validate_expression_is_zero(expression_limbs);\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/expressions.nr"},"124":{"source":"// This file contains the unconstrained helpers that are mostly used by unconstrained ops\n\nuse crate::constants::TWO_POW_120;\n\nuse crate::fns::unconstrained_ops::{__add, __eq, __gte, __mul, __neg, __pow, __sqr};\n\nuse crate::utils::msb::get_msb;\nuse crate::utils::split_bits::{__normalize_limbs, __split_120_bits};\n\nuse crate::params::BigNumParams;\n\n// ------------------------------ DERIVATION HELPER FUNCTIONS ------------------------------\n\n/// Construct a `1` BigNum value (unconstrained)\npub(crate) unconstrained fn __one() -> [u128; N] {\n let mut limbs: [u128; N] = [0; N];\n limbs[0] = 1;\n limbs\n}\n\n/// Construct a BigNum value from Field (unconstrained)\n///\n/// Split the native `Field` value into `N` 120-bit limbs\npub(crate) unconstrained fn __from_field(val: Field) -> [u128; N] {\n let mut x: Field = val;\n let mut result: [u128; N] = [0; N];\n\n if (N == 1) {\n let (first_limb, _): (u128, Field) = __split_120_bits(x);\n result[0] = first_limb;\n }\n\n if (N == 2) {\n let (first_limb, x): (u128, Field) = __split_120_bits(x);\n let (second_limb, _): (u128, Field) = __split_120_bits(x);\n result[0] = first_limb;\n result[1] = second_limb;\n }\n\n if (N > 2) {\n let (first_limb, x): (u128, Field) = __split_120_bits(x);\n let (second_limb, x): (u128, Field) = __split_120_bits(x);\n let (third_limb, _): (u128, Field) = __split_120_bits(x);\n result[0] = first_limb;\n result[1] = second_limb;\n result[2] = third_limb;\n }\n result\n}\n\n// ------------------------------ ARITHMETIC WITH FLAGS HELPER FUNCTIONS ------------------------------\n// These are the functions that compute modular operations results as well as borrow and carry flags for constraints\n\n/// Compute the `MOD - val` and the corresponding borrow flags (unconstrained)\n///\n/// Negate the value and compute the flags indicating whether we need\n/// to borrow a `bit` from the upper limb when subtracting the value from modulus\n///\n/// ## Note\n/// The `borrow_in` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __neg_with_flags(\n modulus: [u128; N],\n val: [u128; N],\n) -> ([u128; N], [bool; N - 1]) {\n let mut result: [u128; N] = [0; N];\n let mut borrow_in: u128 = 0;\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n for i in 0..N {\n let sub_term: u128 = val[i] + borrow_in;\n borrow_in = (sub_term > modulus[i]) as u128;\n result[i] = borrow_in * TWO_POW_120 + modulus[i] - sub_term;\n if (i < N - 1) {\n borrow_flags[i] = (borrow_in != 0);\n }\n }\n (result, borrow_flags)\n}\n\n/// Compute modular addition and the corresponding borrow and carry flags (unconstrained)\n///\n/// Given `x, y, MOD` compute x + y or x + y - MOD in case it overflows\n/// Additionally compute all the carries from addition (x + y)\n/// and borrows from subtraction (- MOD)\n///\n/// ## Note\n/// The `borrow` must be equal to `carry` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __add_with_flags(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> ([u128; N], [bool; N - 1], [bool; N - 1], bool) {\n let mask: u128 = TWO_POW_120 - 1;\n\n let add_res: [u128; N] = __helper_add(lhs, rhs);\n let overflow: bool = __gte(add_res, modulus);\n\n let mut subtrahend: [u128; N] = if overflow { modulus } else { [0; N] };\n let mut result: [u128; N] = [0; N];\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n let mut carry_flags: [bool; N - 1] = [false; N - 1];\n\n let mut carry: u128 = 0;\n let mut borrow: u128 = 0;\n for i in 0..N {\n let mut add_term: u128 = lhs[i] + rhs[i] + carry;\n carry = add_term >> 120;\n add_term &= mask;\n\n let sub_term: u128 = subtrahend[i] + borrow;\n borrow = (sub_term > add_term) as u128;\n\n result[i] = borrow * TWO_POW_120 + add_term - sub_term;\n\n // Only set `borrow` and `carry` if they differ\n // And if it's not the last limb\n if (carry != borrow) & (i < N - 1) {\n carry_flags[i] = carry != 0;\n borrow_flags[i] = borrow != 0;\n }\n }\n (result, carry_flags, borrow_flags, overflow)\n}\n\n/// Compute modular subtraction and the corresponding borrow and carry flags (unconstrained)\n///\n/// Given `x, y, MOD` compute x - y or x - y + MOD in case it overflows\n/// Additionally compute all the carries from addition (x + MOD)\n/// and borrows from subtraction (- y)\n///\n/// ## Note\n/// The `borrow` must be equal to `carry` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __sub_with_flags(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> ([u128; N], [bool; N - 1], [bool; N - 1], bool) {\n let mask: u128 = TWO_POW_120 - 1;\n\n let underflow: bool = !__gte(lhs, rhs);\n\n let addend: [u128; N] = if underflow { modulus } else { [0; N] };\n let mut result: [u128; N] = [0; N];\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n let mut carry_flags: [bool; N - 1] = [false; N - 1];\n\n let mut carry: u128 = 0;\n let mut borrow: u128 = 0;\n for i in 0..N {\n let mut add_term: u128 = lhs[i] + addend[i] + carry;\n carry = add_term >> 120;\n add_term &= mask;\n\n let sub_term: u128 = rhs[i] + borrow;\n borrow = (sub_term > add_term) as u128;\n\n result[i] = borrow * TWO_POW_120 + add_term - sub_term;\n\n // Only set `borrow` and `carry` if they differ\n // And if it's not the last limb\n if (carry != borrow) & (i < N - 1) {\n carry_flags[i] = carry != 0;\n borrow_flags[i] = borrow != 0;\n }\n }\n (result, carry_flags, borrow_flags, underflow)\n}\n\n/// Validate that lhs - rhs does not underflow (unconstrained)\n///\n/// Same as `__validate_gte_with_flags`, but we don't compute the\n/// result of a subtraction\npub(crate) unconstrained fn __validate_in_field_compute_borrow_flags(\n params: BigNumParams,\n val: [u128; N],\n) -> [bool; N - 1] {\n let modulus: [u128; N] = params.modulus;\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n borrow_flags[0] = modulus[0] < val[0];\n for i in 1..N - 1 {\n borrow_flags[i] = modulus[i] < val[i] + (borrow_flags[i - 1] as u128);\n }\n borrow_flags\n}\n\n/// Validate that lhs - rhs does not underflow (unconstrained)\n///\n/// Compute underflow flag (lhs < rhs)\n/// then perform subtraction with borrow flags\n///\n/// ## Note\n/// The `borrow` must be equal to 0 at the end of the loop.\n/// And it can't be nonzero, since we swap the terms at the beginning\npub(crate) unconstrained fn __validate_gte_with_flags(\n lhs: [u128; N],\n rhs: [u128; N],\n) -> (bool, [u128; N], [bool; N - 1]) {\n let mut a: [u128; N] = lhs;\n let mut b: [u128; N] = rhs;\n\n let underflow: bool = !__gte(lhs, rhs);\n // swap a and b if there's an underflow\n let (a, b): ([u128; N], [u128; N]) = if underflow { (b, a) } else { (a, b) };\n\n let mut result: [u128; N] = [0; N];\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n\n let mut borrow: u128 = 0;\n for i in 0..N {\n let mut add_term: u128 = a[i];\n\n let sub_term: u128 = b[i] + borrow;\n borrow = (sub_term > add_term) as u128;\n\n result[i] = borrow * TWO_POW_120 + add_term - sub_term;\n\n if (i < N - 1) {\n borrow_flags[i] = borrow != 0;\n }\n }\n (underflow, result, borrow_flags)\n}\n\n// ------------------------------ BARRETT REDUCTION ------------------------------\n\n/// `BARRETT_REDUCTION_OVERFLOW_BITS` defines how large an input to barrett reduction can be\n///\n/// maximum value = modulus^2 << BARRETT_REDUCTION_OVERFLOW_BITS\n/// see __barrett_reduction for more details\ncomptime global BARRETT_REDUCTION_OVERFLOW_BITS: u32 = 4;\n\n/// Optimized modular multiplication (unconstrained)\n///\n/// The trick is to approximate 1/p with m/2**r, because division by 2**r is much cheaper\n/// In our case m = redc_param = floor(2^{MOD_BITS * 2 + BARRET_REDUCTION_OVERFLOW_BITS} / p)\n/// r = MOD_BITS * 2 + BARRET_REDUCTION_OVERFLOW_BITS\n///\n/// When we apply the barrett reduction, the maximum value of the output will be <= p * (1 + x/2^{2k})\n/// where p = modulus,\n/// x = reduction input\n///\n/// If x > p * p, we need k to be larger than modulus_bits()\n/// We hardcode k = 4, which means that the maximum value of x is approx. 16 * p * p\n/// This should be larger than most values put into `evaluate_quadratic_expression`\n///\n/// ## TODO\n/// Detect cases where x might be too large at comptime\n///\n/// ## Note\n/// very niche edge case error that we need to be aware of:\n/// N must be large enough to cover the modulus *plus* BARRETT_REDUCTION_OVERFLOW_BITS\n/// i.e. a 359-bit prime needs (I think) 4 limbs to represent or we may overflow\n/// when calling __barrett_reduction\n///\n/// ## Note on final reduction\n///\n/// Assumptions:\n/// - k = ceil(log2 p), so p <= 2^k\n/// - s = 4, m = redc_param = floor(2^{2*k + s}/p)\n/// - x < 16 * p^2 (x < 2^{2 * k + s})\n///\n/// Let m' = 2^{2*k + s} / p, and write m = m' - \\epsilon, \\epsilon \\in [0, 1)\n//\n/// quo = floor(x * m / 2^{2 * k + s}) = floor(x * m' / 2^{2 * k + s} - x * \\epsilon / 2^{2 * k + s}) =\n/// floor(x / p - x * \\epsilon / 2^{2 * k + s})\n///\n/// Bounds:\n/// quo <= floor(x / p)\n///\n/// floor(a - b) >= floor(a) - ceil(b) (known identity) =>\n/// quo >= floor(x / p) - ceil(x * \\epsilon / 2^{2 * k + s})\n/// >= floor(x / p) - ceil(x / 2^{2 * k + s}) (epsilon < 1)\n///\n/// x / 2^{2 * k + s} < C * p^2 / 2^{2 * k + s} <= C * 2^{2 * k} / 2^{2 * k + s} = C / 2^s\n///\n/// When the assumption holds (C = 16), ceil(x / 2^{2 * k + s}) = 1, for x > 0\n/// Therefore quo = {floor(x/p), floor(x/p) - 1}\n///\n/// In first case: rem = x - quo * p = x - floor(x/p) * p < p\n/// In second case: rem = x - (floor(x/p) - 1) * p = (x - floor(x/p) * p) + p -> need 1 subtraction\n///\n/// ### Note\n/// We allow 64 products to be summed inside the `evaluate_quadratic_expression`\n/// In that case x / 2^{2 * k + s} < 64 / 2^4 = 4 => hence we need to subtract modulus at most 4 times\n/// We can leave it 2 for now as it is unlikely to reach beyond 32 * p^2\n///\n/// In the worst case though, we will have the input > 64 * p^2\n/// (for example (a1 + b1) * (c1 + d1) + ... 64 times)\n/// This is highly unlikely though.\n///\n/// ### TODO:\n/// Possibly change the `BARRETT_REDUCTION_OVERFLOW_BITS` to 6, so that we need only 1 reduction here\n/// However we will have to recompute all the fields `redc_param`s and fix paramgen\npub(crate) unconstrained fn __barrett_reduction(\n x: [u128; 2 * N],\n redc_param: [u128; N],\n k: u32,\n modulus: [u128; N],\n) -> ([u128; N], [u128; N]) {\n // TODO: switch to __helper_mul, once the compiler is smart enough to handle this\n let mut mulout_field: [Field; 3 * N] = [0; 3 * N];\n for i in 0..(2 * N) {\n for j in 0..N {\n mulout_field[i + j] += (x[i] as Field) * (redc_param[j] as Field);\n }\n }\n let mulout: [u128; 3 * N] = __normalize_limbs(mulout_field);\n\n let quotient: [u128; 3 * N] = __shr(mulout, (k + k + BARRETT_REDUCTION_OVERFLOW_BITS));\n\n // Remove a bunch of zeros from the end\n let mut smaller_quotient: [u128; N] = [0; N];\n for i in 0..N {\n smaller_quotient[i] = quotient[i] as u128;\n }\n\n // long_quotient_mul_modulus can never exceed input value `x` so can fit into size-2 array\n let long_quotient_mul_modulus: [u128; 2 * N] = __helper_mul(smaller_quotient, modulus);\n let long_remainder: [u128; 2 * N] = __helper_sub(x, long_quotient_mul_modulus);\n\n // Remove a bunch of zeros from the end\n let mut remainder: [u128; N] = [0; N];\n for i in 0..N {\n remainder[i] = long_remainder[i];\n }\n\n for _ in 0..2 {\n if (__gte(remainder, modulus)) {\n remainder = __helper_sub(remainder, modulus);\n smaller_quotient = __increment(smaller_quotient);\n }\n }\n\n (smaller_quotient, remainder)\n}\n\n// ------------------------------ ARITHMETIC HELPER FUNCTIONS ------------------------------\n// These are the functions that operate on limbs as if they were just big integers\n\n/// Adds `1` to the BigNum value without modular reduction (unconstrained)\n///\n/// ## Note\n/// The `carry` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __increment(val: [u128; N]) -> [u128; N] {\n let mask: u128 = TWO_POW_120 - 1;\n\n let mut result: [u128; N] = [0; N];\n let mut carry: u128 = 1;\n for i in 0..N {\n let add_term: u128 = val[i] + carry;\n carry = add_term >> 120;\n result[i] = add_term & mask;\n }\n result\n}\n\n/// Adds two `BigNum` values without modular reduction (unconstrained).\n///\n/// ## Note\n/// The `carry` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __helper_add(lhs: [u128; N], rhs: [u128; N]) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let mut carry: u128 = 0;\n let mask: u128 = TWO_POW_120 - 1;\n\n for i in 0..N {\n let add_term: u128 = lhs[i] + rhs[i] + carry;\n carry = add_term >> 120;\n result[i] = add_term & mask;\n }\n result\n}\n\n/// Subtracts two `BigNum` values without modular reduction (unconstrained).\n///\n/// ## Note\n/// The `borrow` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __helper_sub(lhs: [u128; N], rhs: [u128; N]) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let mut borrow: u128 = 0;\n for i in 0..N {\n let subtrahend: u128 = rhs[i] + borrow;\n borrow = (subtrahend > lhs[i]) as u128;\n result[i] = (borrow << 120) + lhs[i] - subtrahend;\n }\n result\n}\n\n/// Multiplies two `BigNum` values without modular reduction (unconstrained).\n///\n/// Computes the full schoolbook product of two N-limb little-endian arrays\n///\n/// ## Note\n/// The mathematical product fits in `2 * N - 1` limbs, but we keep `2 * N`\n/// limbs intentionally as the extra high limb safely absorbs a possible single limb overflow\n/// for moduli close to `120 * N` bits.\npub(crate) unconstrained fn __helper_mul(\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; 2 * N] {\n let mut result: [Field; 2 * N] = [0; 2 * N];\n for i in 0..N {\n for j in 0..N {\n result[i + j] += (lhs[i] as Field) * (rhs[j] as Field);\n }\n }\n __normalize_limbs(result)\n}\n\n// ------------------------------ LOGIC HELPER FUNCTIONS ------------------------------\n// These are the functions that operate on limbs as if they were just big integers\n\n/// Left-shifts a `BigNum` value by `shift` bits (unconstrained).\n///\n/// Performs a bitwise left shift across limbs.\n///\n/// ## Note\n/// The most significant limb is truncated to 120 bits after the shift.\n///\n/// No bounds check is performed on `num_shifted_limbs`.\n/// However, we use it only in `__udiv_mod`, where it is not possible to reach\n/// `num_shifted_limbs` > `N`\npub(crate) unconstrained fn __shl(input: [u128; N], shift: u32) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let num_shifted_limbs: u32 = shift / 120;\n let limb_shift: u128 = (shift % 120) as u128;\n let remainder_shift: u128 = 120 - limb_shift;\n\n let mask: u128 = TWO_POW_120 - 1;\n let mut remainder: u128 = input[0] >> remainder_shift;\n\n result[num_shifted_limbs] = (input[0] << limb_shift) & mask;\n\n for i in 1..(N - num_shifted_limbs) {\n let value: u128 = input[i];\n let upshift: u128 = ((value << limb_shift) | remainder) & mask;\n result[i + num_shifted_limbs] = upshift;\n remainder = value >> remainder_shift;\n }\n result\n}\n\n/// Right-shifts a `BigNum` value by `shift` bits (unconstrained).\n///\n/// Performs a bitwise right shift across limbs.\n///\n/// # Note\n/// No bounds check is performed on `num_shifted_limbs`.\n/// However, we use it only in `__tonelli_shanks_sqrt`, where it is not possible to reach\n/// `num_shifted_limbs` > `N`\npub(crate) unconstrained fn __shr(input: [u128; N], shift: u32) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let num_shifted_limbs: u32 = shift / 120;\n let limb_shift: u128 = (shift % 120) as u128;\n\n let remainder_shift: u128 = 120 - limb_shift;\n let low_mask: u128 = (1 as u128 << limb_shift) - 1;\n\n result[0] = input[num_shifted_limbs] >> limb_shift;\n for i in 1..(N - num_shifted_limbs) {\n let value: u128 = input[i + num_shifted_limbs];\n\n let carry: u128 = (value & low_mask) << remainder_shift;\n result[i - 1] |= carry;\n\n result[i] = value >> limb_shift;\n }\n result\n}\n\n/// Right-shifts a `BigNum` value by `1` bit (unconstrained)\n///\n/// # Note\n/// All the operations on limbs are executed in place\n/// to save opcodes\npub(crate) unconstrained fn __shr1(mut input: [u128; N]) -> [u128; N] {\n let value: u128 = input[N - 1];\n let mut remainder: u128 = (value & 1) << 119;\n input[N - 1] >>= 1;\n\n for i in 1..N {\n let value: u128 = input[N - 1 - i];\n input[N - 1 - i] = (value >> 1) | remainder;\n remainder = (value & 1) << 119;\n }\n input\n}\n\n/// Returns the index of the most significant set bit in a `BigNum` value (unconstrained).\npub(crate) unconstrained fn __get_msb(val: [u128; N]) -> u32 {\n let mut count: u32 = 0;\n for i in 0..N {\n let idx: u32 = N - 1 - i;\n let v: u128 = val[idx];\n if (v > 0) {\n count = 120 * idx + get_msb(v);\n break;\n }\n }\n count\n}\n\n/// Returns `true` if the bit at position `bit` is set in the `BigNum` (unconstrained).\n///\n/// ## Note\n/// No bounds check is performed on `bit`\npub(crate) fn __get_bit(input: [u128; N], bit: u32) -> bool {\n let segment_index: u32 = bit / 120;\n let uint_index: u128 = (bit % 120) as u128;\n\n let limb: u128 = input[segment_index];\n let value: u128 = (limb >> uint_index) & 1;\n value == 1\n}\n\n// ------------------------------ SQRT HELPER FUNCTIONS ------------------------------\n// These are the functions that are used during taking a square root\n\n/// Compute the maximal power of 2 that divides the group order (unconstrained)\n///\n/// Find the maximum value s such that `MOD = 2^s * q + 1`, where `q` is odd\n/// This is needed for our Tonelli-Shanks sqrt algorithm\npub(crate) unconstrained fn __primitive_root_log_size(\n params: BigNumParams,\n) -> u32 {\n let mut target: [u128; N] = __helper_sub(params.modulus, __one());\n let mut result: u32 = 0;\n while !__get_bit(target, result) {\n result += 1;\n }\n result\n}\n\n/// Find a quadratic non-residue `g` where `g` is the smallest such value (unconstrained)\n/// i.e. smallest `g` such that `g^{(p - 1)/2} = -1 (mod MOD)`\n/// or smallest `g`, such that `x^2 - g = 0 (mod MOD)` has no solutions\n///\n/// ## Note\n/// WARNING If the field is not prime, this function will enter an infinite loop!\npub(crate) unconstrained fn __quadratic_non_residue(\n params: BigNumParams,\n) -> [u128; N] {\n let one: [u128; N] = __one();\n let neg_one: [u128; N] = __neg(params.modulus, one);\n\n let p_minus_one_over_two: [u128; N] = __shr1(__helper_sub(params.modulus, __one()));\n\n // We start with 2\n let mut target: [u128; N] = __increment(one);\n let mut expd: [u128; N] = __pow(params, target, p_minus_one_over_two);\n while !__eq(expd, neg_one) {\n target = __increment(target);\n expd = __pow(params, target, p_minus_one_over_two);\n }\n target\n}\n\n/// Compute the smallest `i`, such that `t^{2^i} = 1, t^{2^{i-1}} = -1 (mod MOD)` (unconstrained)\n///\n/// ## Note\n/// Multiplicative order of t must divide 2^v2(MOD-1), otherwise you'll end up in an infinite loop!\npub(crate) unconstrained fn __tonelli_shanks_sqrt_find_i(\n params: BigNumParams,\n t: [u128; N],\n) -> u32 {\n let one: [u128; N] = __one();\n let mut c: [u128; N] = t;\n\n let mut i: u32 = 0;\n // Compute t^{2^k} until it hits 1 for the first time\n while !__eq(c, one) {\n c = __sqr::(params, c);\n i += 1;\n }\n i\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/unconstrained_helpers.nr"},"125":{"source":"// This file contains the unconstrained operations that are used directly by BigNum class\n\nuse crate::fns::constrained_ops::derive_from_seed;\n\nuse crate::fns::unconstrained_helpers::{\n __barrett_reduction, __get_bit, __get_msb, __helper_add, __helper_mul, __helper_sub,\n __increment, __one, __primitive_root_log_size, __quadratic_non_residue, __shl, __shr, __shr1,\n __tonelli_shanks_sqrt_find_i,\n};\n\nuse crate::constants::TWO_POW_120;\n\nuse crate::params::BigNumParams;\n\n// ------------------------------ DERIVATION FUNCTIONS ------------------------------\n\n/// Deterministically derives a `BigNum` from a seed value (unconstrained)\n///\n/// Takes a seed byte array and generates a `BigNum` in the range [0, modulus-1].\n///\n/// See more information in `constrained_ops.nr`: `derive_from_seed`\npub(crate) unconstrained fn __derive_from_seed(\n params: BigNumParams,\n seed: [u8; SeedBytes],\n) -> [u128; N] {\n derive_from_seed::(params, seed)\n}\n\n// ------------------------------ COMPARISON FUNCTIONS ------------------------------\n\n/// Compare two limb arrays for equality (unconstrained)\npub(crate) unconstrained fn __eq(lhs: [u128; N], rhs: [u128; N]) -> bool {\n lhs == rhs\n}\n\n/// Compare a limb array to a zero array (unconstrained)\npub(crate) unconstrained fn __is_zero(limbs: [u128; N]) -> bool {\n limbs == [0; N]\n}\n\n/// Compare two little-endian limb arrays for `lhs >= rhs` over integers (unconstrained)\n///\n/// Starts from the most significant limb (`N - 1`) and returns true\n/// if `lhs` is greater or equal to `rhs`\npub(crate) unconstrained fn __gte(lhs: [u128; N], rhs: [u128; N]) -> bool {\n let mut result: bool = true;\n for i in 0..N {\n let idx: u32 = N - 1 - i;\n if (lhs[idx] != rhs[idx]) {\n result = lhs[idx] > rhs[idx];\n break;\n }\n }\n result\n}\n\n// ------------------------------ ARITHMETIC FUNCTIONS ------------------------------\n\n/// Negates a `BigNum` value, returning `m - x` (unconstrained)\n///\n/// ## Note\n/// The input is assumed to be less than modulus\npub(crate) unconstrained fn __neg(modulus: [u128; N], limbs: [u128; N]) -> [u128; N] {\n __helper_sub(modulus, limbs)\n}\n\n/// Adds two `BigNum` values with modular reduction (unconstrained)\n///\n/// Sums the limbs one by one, keeping the carry.\n/// In case the result overflows the modulus, the modulus is subtracted once\n///\n/// ## Note\n/// The `carry` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __add(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n let mut carry: u128 = 0;\n let mask: u128 = TWO_POW_120 - 1;\n\n for i in 0..N {\n let add_term: u128 = (lhs[i] + rhs[i] + carry);\n carry = add_term >> 120;\n result[i] = add_term & mask;\n }\n\n // check if the result is greater than the modulus\n if __gte(result, modulus) {\n __helper_sub(result, modulus)\n } else {\n result\n }\n}\n\n/// Subtracts two `BigNum` values with modular reduction (unconstrained).\n///\n/// Computes `x + (m - y)` (mod m)\npub(crate) unconstrained fn __sub(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n __add(modulus, lhs, __neg(modulus, rhs))\n}\n\n/// Multiply `x` and `y` and reduce via Barrett, returning (Q, R) (unconstrained).\n///\n/// For `BigNum` values `x` and `y` compute (`Q`, `R`) such that:\n/// x * y = R + Q * m, 0 <= R < m\n/// See `__barrett_reduction` for details.\npub(crate) unconstrained fn __mul_with_quotient(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> ([u128; N], [u128; N]) {\n let to_reduce: [u128; N * 2] = __helper_mul(lhs, rhs);\n let (q, r): ([u128; N], [u128; N]) =\n __barrett_reduction(to_reduce, params.redc_param, MOD_BITS, params.modulus);\n (q, r)\n}\n\n/// Multiplies two `BigNum` values with modular reduction (unconstrained).\npub(crate) unconstrained fn __mul(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n __mul_with_quotient::(params, lhs, rhs).1\n}\n\n/// Squares a `BigNum` value with modular reduction (unconstrained).\npub(crate) unconstrained fn __sqr(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n __mul_with_quotient::(params, val, val).1\n}\n\n/// Modular exponentiation via square-and-multiply. LSB-first (unconstrained).\n///\n/// Computes `x^e mod m`\n///\n/// ## Note\n/// For the loop, we are using `MOD_BITS` instead of `__get_msb`\n/// because it is much much cheaper\npub(crate) unconstrained fn __pow(\n params: BigNumParams,\n val: [u128; N],\n exponent: [u128; N],\n) -> [u128; N] {\n let mut accumulator: [u128; N] = __one();\n let mut x: [u128; N] = val;\n let num_bits: u32 = MOD_BITS + 1;\n\n for i in 0..num_bits {\n if __get_bit(exponent, i) {\n accumulator = __mul::(params, accumulator, x);\n }\n x = __sqr::(params, x);\n }\n accumulator\n}\n\n/// Given a `BigNum` value `x` compute x^{-1} (mod m) (unconstrained)\n///\n/// x^{p-1} = 1 (mod p) (Fermat's little theorem)\n/// x^{p-2} = x^{-1} (mod p)\n///\n/// ## Note\n/// The input value must be nonzero and modulus has to be prime\n/// No explicit assertion is made, as this condition is validated during evaluation\npub(crate) unconstrained fn __invmod(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n let one: [u128; N] = __one();\n let exp: [u128; N] = __helper_sub(params.modulus, __helper_add(one, one));\n __pow::(params, val, exp)\n}\n\n/// Divides two `BigNum` values with modular reduction (unconstrained).\n///\n/// Computes `x * y^{-1}` (mod m)\n///\n/// ## Note\n/// The divisor must be nonzero\n/// No explicit assertion is made, as this condition is validated during evaluation\npub(crate) unconstrained fn __div(\n params: BigNumParams,\n numerator: [u128; N],\n divisor: [u128; N],\n) -> [u128; N] {\n let inv_divisor: [u128; N] = __invmod::(params, divisor);\n __mul::(params, numerator, inv_divisor)\n}\n\n/// Given the `BigNum` inputs `x, y`, compute integer division x / y (unconstrained)\n///\n/// This function implements binary long division and outputs (`quotient`, `remainder`) such that:\n/// 1. floor(numerator / divisor) = quotient\n/// 2. numerator % divisor = remainder\n/// 3. divisor * quotient + remainder = numerator\n///\n/// ## Note\n/// The divisor must be nonzero\n/// No explicit assertion is made, as this condition is validated during evaluation\npub(crate) unconstrained fn __udiv_mod(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> ([u128; N], [u128; N]) {\n let mut quotient: [u128; N] = [0; N];\n let mut remainder: [u128; N] = numerator;\n let b: [u128; N] = divisor;\n\n let numerator_msb: u32 = __get_msb(numerator);\n let divisor_msb: u32 = __get_msb(divisor);\n if divisor_msb > numerator_msb {\n ([0; N], numerator)\n } else {\n let mut bit_difference: u32 = __get_msb(remainder) - __get_msb(divisor);\n let mut divisor: [u128; N] = __shl(divisor, bit_difference);\n let mut accumulator: [u128; N] = __shl(__one(), bit_difference);\n\n // The same as divisor > remainder\n if (__gte(divisor, __increment(remainder))) {\n divisor = __shr1(divisor);\n accumulator = __shr1(accumulator);\n }\n\n for _ in 0..(N * 120) {\n if (__gte(remainder, b) == false) {\n break;\n }\n // we've shunted 'divisor' up to have the same bit length as our remainder.\n // If remainder >= divisor, then a is at least '1 << bit_difference' multiples of b\n if (__gte(remainder, divisor)) {\n remainder = __helper_sub(remainder, divisor);\n // we can use OR here instead of +, as\n // accumulator is always a nice power of two\n quotient = __helper_add(quotient, accumulator);\n }\n divisor = __shr1(divisor);\n accumulator = __shr1(accumulator);\n }\n\n (quotient, remainder)\n }\n}\n\n/// Batch modular inversion of `BigNum` values in an array (unconstrained)\n///\n/// Given values v[0..M), returns inv[0...M) with inv[i] = v[i]^{-1} (mod m)\n///\n/// We use the Montgomery trick:\n/// First we compute the partial products:\n/// T0 = 1\n/// T1 = v1,\n/// T2 = v1 * v2,\n/// ...\n/// T_{m - 1} = T_{m - 2} * v_{m - 1} = v1 * ... * v_{m - 1}\n///\n/// P = T_{m-1} * v_m = v1 * v2 * ... * v_m\n///\n/// Then we calculate a single inverse P^-1 = v1^-1 * v2^-1 * ... * v_m^-1\n/// Finally we compute\n/// v_m^-1 = (P^-1 * T_{m-1})\n/// v_{m - 1}^-1 = (P^-1 * v_m * T_{m - 2})\n/// ....\n/// v_2^-1 = (P^-1 * v_m * ... * v_3 * T_1)\n/// v_1^-1 = (P^-1 * v_m * ... * v_2 * T_0)\n///\n/// ## Note\n/// Zero elements are allowed and are left unchanged in the resulting array\n///\n/// This interacts poorly with `neg(zero)`:\n/// Calling `neg` on `zero` yields `modulus` rather than `0`.\n/// A value in this form will **not** satisfy\n/// the `__is_zero` check and will lead to incorrect results.\n///\n/// This edge case should be rare, but it's worth keeping in mind when\n/// composing operations or debugging unexpected behavior\npub(crate) unconstrained fn batch_invert(\n params: BigNumParams,\n vals: [[u128; N]; M],\n) -> [[u128; N]; M] {\n let mut accumulator: [u128; N] = __one();\n let mut temporaries: [[u128; N]; M] = [[0; N]; M];\n\n for i in 0..M {\n temporaries[i] = accumulator;\n if (!__is_zero(vals[i])) {\n accumulator = __mul::(params, accumulator, vals[i]);\n }\n }\n\n let mut result: [[u128; N]; M] = [[0; N]; M];\n accumulator = __invmod::(params, accumulator);\n for i in 0..M {\n let idx: u32 = M - 1 - i;\n if (!__is_zero(vals[idx])) {\n let T0: [u128; N] = __mul::(params, accumulator, temporaries[idx]);\n accumulator = __mul::(params, accumulator, vals[idx]);\n result[idx] = T0;\n }\n }\n result\n}\n\n/// Batch modular inversion of `BigNum` values in a slice (unconstrained)\n///\n/// See `batch_invert` for details\npub(crate) unconstrained fn batch_invert_slice(\n params: BigNumParams,\n vals: [[u128; N]],\n) -> [[u128; N]] {\n let mut accumulator: [u128; N] = __one();\n let mut temporaries: [[u128; N]] = &[];\n\n let M: u32 = vals.len();\n\n for i in 0..M {\n temporaries = temporaries.push_back(accumulator);\n if (!__is_zero(vals[i])) {\n accumulator = __mul::(params, accumulator, vals[i]);\n }\n }\n\n let mut result: [[u128; N]] = [];\n accumulator = __invmod::(params, accumulator);\n for i in 0..M {\n let idx: u32 = M - 1 - i;\n if (!__is_zero(vals[idx])) {\n let T0: [u128; N] = __mul::(params, accumulator, temporaries[idx]);\n accumulator = __mul::(params, accumulator, vals[idx]);\n result = result.push_front(T0);\n } else {\n result = result.push_front([0; N]);\n }\n }\n\n result\n}\n\n/// Compute a modular square root in a prime field (unconstrained)\npub(crate) unconstrained fn __sqrt(\n params: BigNumParams,\n input: [u128; N],\n) -> std::option::Option<[u128; N]> {\n assert(\n params.has_multiplicative_inverse,\n \"BigNum::__sqrt: Must be a field to take square roots\",\n );\n\n if (__is_zero(input)) {\n Option::some(input)\n } else if (params.modulus[0] % 4 == 3) {\n __easy_sqrt(params, input)\n } else {\n __tonelli_shanks_sqrt(params, input)\n }\n}\n\n/// Compute a modular square root using the Tonelli-Shanks algorithm (unconstrained)\n///\n/// Solves `x^2 = a (mod MOD)` for odd prime MOD\n///\n/// ## Algorithm\n///\n/// Here p = MOD\n///\n/// Tonelli-Shanks setup\n///\n/// Write `p - 1 = 2^s * Q`, `Q` - odd\n/// Define:\n/// `R = a^{(Q+1)/2}`\n/// `t = a^Q`\n///\n/// so that `R^2 = a^{Q + 1} = a * a^Q = a * t`\n/// If t = 1, we are done\n///\n/// By Euler's criterion, `a` is a quadratic reside iff `a^{(p - 1)/2} = 1`\n/// Since `t = a^Q` and `(p - 1) / 2 = Q * 2^{s-1}` we have:\n/// `t^{2^{s-1}} = a^{Q * 2^{s-1}} = a^{(p-1)/2} = 1`, assuming `a` is a q.r.\n///\n/// To proceed with computing our square root, we want to transfer `t` into a smaller subgroup,\n/// specifically, the `2^(s-2)`'th roots of unity or lower.\n///\n/// We do this by finding some value `b`, such that\n/// `(t * b^2)^{2^{s-2}} = 1` and `R' = R * b`\n/// Finding such a `b` is trivial, because from Euler's criterion, we know that,\n/// for any quadratic non-residue `z`, `z^{(p - 1) / 2} = -1`\n/// i.e. `z^{Q * 2^{s-1}} = -1`\n/// => `z^Q` is a `2^{s-1}`'th root of `-1`\n/// => `z^{2 * Q}` is a `2^{s-2}`'th root of `-1`\n///\n/// Since `t^{2^{s-1}} = 1`, we know that for some `i`, `i <= s - 2: t^{2^{i-1}} = -1`\n/// => `t * z^{2 * Q}` is a `2^{s - 2}`'th root of unity.\n/// We can iteratively transform `t` into ever smaller subgroups, until `t = 1`.\n/// At each iteration, we need to find a new value for `b`, which we can obtain\n/// by repeatedly squaring `z^Q`\n///\n/// ## Note\n/// Only use for prime fields! Function may infinite loop if used for non-prime fields\n///\n/// The input is assumed to be a nonzero value\npub(crate) unconstrained fn __tonelli_shanks_sqrt(\n params: BigNumParams,\n input: [u128; N],\n) -> std::option::Option<[u128; N]> {\n let mut result: Option<[u128; N]> = Option::none();\n\n let one: [u128; N] = __one();\n let s: u32 = __primitive_root_log_size::(params); // p - 1 = 2^s * Q, where Q is odd\n let Q: [u128; N] = __shr(__helper_sub(params.modulus, one), s);\n let Q_minus_one_over_two: [u128; N] = __shr1(__helper_sub(Q, one)); // (Q - 1) / 2\n\n let z: [u128; N] = __quadratic_non_residue::(params);\n\n // Initialize:\n // b = a^{(Q - 1)/2}\n // R = a * b = a^{(Q + 1) / 2} => R^2 = a * a^Q\n // t = R * b = a^Q\n let mut b: [u128; N] = __pow::<_, MOD_BITS>(params, input, Q_minus_one_over_two);\n let mut r: [u128; N] = __mul::<_, MOD_BITS>(params, input, b);\n let mut t: [u128; N] = __mul::<_, MOD_BITS>(params, r, b);\n\n let mut check: [u128; N] = t;\n // Assure t^{2^{s - 1}} = a^{(p -1)/2} = 1, otherwise we have met a non-residue\n for _ in 0..s - 1 {\n check = __sqr::(params, check);\n }\n if (__eq(check, one)) {\n let mut m: u32 = s;\n let mut c: [u128; N] = __pow::(params, z, Q); // z^Q - proper 2^{M}'th root of unity\n\n // Tonelli-Shanks main loop\n\n // At the beginning of each iteration we have:\n // M - current exponent such that t lies in the subgroup of order 2^m\n // t - element, whose order divides 2^m\n // c - the proper 2^M'th root of unity\n // R - accumulator with R^2 = a * t\n\n // If t == 1, we are done and R is a square root\n //\n // Otherwise\n // 1. We compute 1 <= i < M, such that t^{2^i} = 1, t^{2^{i - 1}} = -1\n // 2. Set b = c^{2^{M - i - 1}}, so it becomes a proper 2^(i+1)'th root of unity\n // Then b^2 has order 2^i which matches the order of t\n //\n // 3. Update the state values:\n // R <- R * b\n // t <- t * b^2\n // c <- b^2 = c^{2^{M - i}}\n // M <- i\n // reduces the order of t from 2^i to at most 2^{i - 1} and preserves R^2 = a * t\n //\n // The loop runs at most s times because M strictly decreases\n for _ in 0..s {\n if (__eq(t, one)) {\n result = Option::some(r);\n break;\n }\n let i: u32 = __tonelli_shanks_sqrt_find_i::(params, t);\n let mut j: u32 = m - i - 1;\n b = c;\n for _ in 0..j {\n b = __sqr(params, b);\n }\n\n let b2: [u128; N] = __sqr::(params, b);\n c = b2;\n t = __mul::(params, t, b2);\n r = __mul::(params, r, b);\n m = i;\n }\n }\n result\n}\n\n/// Compute a modular square root for MOD = 3 (mod 4) (unconstrained)\n///\n/// In case MOD = 3 (mod 4), the square root can be computed using the formula:\n/// `R = a^{(MOD + 1) / 4} (mod MOD)`\n///\n/// Then R^2 = a^{(MOD + 1)/ 4 * 2} = a^{(MOD + 1) / 2} = a^{(MOD - 1) / 2 + 1} = a\n///\n/// ## Note\n/// The input is assumed to be a nonzero value\n///\n/// This is much cheaper than `__tonelli_shanks_sqrt`\npub(crate) unconstrained fn __easy_sqrt(\n params: BigNumParams,\n input: [u128; N],\n) -> std::option::Option<[u128; N]> {\n let mut result: Option<[u128; N]> = Option::none();\n\n let one: [u128; N] = __one();\n let p_minus_one_over_two: [u128; N] = __shr1(__helper_sub(params.modulus, one));\n let mut check: [u128; N] = __pow(params, input, p_minus_one_over_two);\n if (__eq(check, one)) {\n // a = (MOD - 1) / 2\n // b = (a + 1) / 2 = ((MOD - 1) / 2 + 1) / 2 = (MOD + 1) / 4\n let p_plus_one_over_four: [u128; N] = __shr1(__increment(p_minus_one_over_two));\n result = Option::some(__pow(params, input, p_plus_one_over_four));\n }\n result\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/unconstrained_ops.nr"},"134":{"source":"use std::ops::WrappingMul;\n\nglobal MUL_DE_BRUIJN_BIT: [u32; 128] = [\n 1, 14, 2, 15, 26, 20, 3, 16, 68, 80, 27, 21, 56, 50, 4, 17, 65, 96, 69, 81, 105, 99, 28, 22, 86,\n 90, 57, 51, 72, 42, 5, 126, 18, 66, 48, 94, 97, 84, 70, 124, 82, 122, 106, 100, 114, 108, 29,\n 23, 77, 102, 87, 91, 119, 116, 58, 52, 61, 110, 73, 37, 43, 31, 6, 127, 13, 25, 19, 67, 79, 55,\n 49, 64, 95, 104, 98, 85, 89, 71, 41, 125, 47, 93, 83, 123, 121, 113, 107, 76, 101, 118, 115, 60,\n 109, 36, 30, 12, 24, 78, 54, 63, 103, 88, 40, 46, 92, 120, 112, 75, 117, 59, 35, 11, 53, 62, 39,\n 45, 111, 74, 34, 10, 38, 44, 33, 9, 32, 8, 7, 128,\n];\n\n/// Get the most significant bit position of a `val` (unconstrained)\n///\n/// Bit hack that uses De Bruijn sequence to calculate msb position in log(N)\n/// See [IntegerLog2DeBruijn](https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn)\npub(crate) unconstrained fn get_msb(x: u128) -> u32 {\n let result: u32 = if x == 0 {\n 0\n } else {\n let mut v: u128 = x;\n v |= v >> 1;\n v |= v >> 2;\n v |= v >> 4;\n v |= v >> 8;\n v |= v >> 16;\n v |= v >> 32;\n v |= v >> 64;\n let index: u128 = (v.wrapping_mul(0x1FC10C2FBCF471B913B14CD2595D6D5)) >> 121;\n MUL_DE_BRUIJN_BIT[index as u32]\n };\n result\n}\n\nmod tests {\n use crate::constants::{TWO_POW_120, TWO_POW_60};\n use crate::fns::unconstrained_helpers::__get_msb;\n use super::get_msb as get_msb128;\n use std::ops::WrappingMul;\n\n fn assert_msb_equal(x: u64) {\n // Safety: test code\n let msb64 = unsafe { get_msb64(x) };\n // Safety: test code\n let msb128 = unsafe { get_msb128(x as u128) };\n assert_eq(msb64, msb128);\n }\n\n #[test]\n /// Check that the msb functions are equivalent with de bruijn sequence for 64 bits and 128 bits\n fn test_get_msb() {\n // Test case 1: MSB at position 7\n let x: u64 = 0x80; // binary: 10000000\n assert_msb_equal(x);\n\n // Test case 2: MSB at position 0\n let x: u64 = 0x1; // binary: 00000001\n assert_msb_equal(x);\n\n // Test case 3: MSB at position 63\n let x: u64 = 0x8000000000000000; // binary: 1000...0000 (63 zeros)\n assert_msb_equal(x);\n\n // Test case 4: Zero input\n let x: u64 = 0x0;\n assert_msb_equal(x);\n\n // Test case 5: All bits set\n let x: u64 = 0xFFFFFFFFFFFFFFFF;\n assert_msb_equal(x);\n }\n\n /// Multiple entires in the `MUL_DE_BRUIJN_BIT` list do not map to a valid output of `v * 0x6c04f118e9966f6b`.\n /// This is a dummy value to fill the gaps in the map.\n global n1: u32 = 0xffffffff;\n\n global MUL_DE_BRUIJN_BIT_64: [u32; 128] = [\n 0, // change to 1 if you want bitSize(0) = 1\n 48, n1, n1, 31, n1, 15, 51, n1, 63, 5, n1, n1, n1, 19, n1, 23, 28, n1, n1, n1, 40, 36, 46,\n n1, 13, n1, n1, n1, 34, n1, 58, n1, 60, 2, 43, 55, n1, n1, n1, 50, 62, 4, n1, 18, 27, n1,\n 39, 45, n1, n1, 33, 57, n1, 1, 54, n1, 49, n1, 17, n1, n1, 32, n1, 53, n1, 16, n1, n1, 52,\n n1, n1, n1, 64, 6, 7, 8, n1, 9, n1, n1, n1, 20, 10, n1, n1, 24, n1, 29, n1, n1, 21, n1, 11,\n n1, n1, 41, n1, 25, 37, n1, 47, n1, 30, 14, n1, n1, n1, n1, 22, n1, n1, 35, 12, n1, n1, n1,\n 59, 42, n1, n1, 61, 3, 26, 38, 44, n1, 56,\n ];\n\n pub(crate) unconstrained fn get_msb64(x: u64) -> u32 {\n let mut v: u64 = x;\n v |= v >> 1;\n v |= v >> 2;\n v |= v >> 4;\n v |= v >> 8;\n v |= v >> 16;\n v |= v >> 32;\n let index: u64 = (v.wrapping_mul(0x6c04f118e9966f6b)) >> 57;\n (index as Field).assert_max_bit_size::<32>();\n MUL_DE_BRUIJN_BIT_64[index as u32]\n }\n\n unconstrained fn __get_msb64(val: [u128; N]) -> u32 {\n let mut count: u32 = 0;\n for i in 0..N {\n let v: u128 = val[((N) - 1 - i)];\n let v_low: u64 = v as u64 % TWO_POW_60 as u64;\n let v_high: u64 = ((v - v_low as u128) / TWO_POW_60) as u64;\n if (v_high > 0) {\n count = 60 * ((2 * N) - 1 - (i * 2)) + get_msb64(v_high);\n break;\n }\n if (v_low > 0) {\n count = 60 * ((2 * N) - 1 - (i * 2 + 1)) + get_msb64(v_low);\n break;\n }\n }\n count\n }\n\n #[test]\n // Check that the msb functions are equivalent with De Bruijn sequence for 64 bits and 128 bits\n unconstrained fn test_get_msb_equivalence() {\n // Test single limb (64-bit number)\n let x: Field = 0x8000000000000000;\n let arr: [u128; 4] = [0, 0, x as u128, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test multiple limbs (120-bit number)\n let x: Field = 0x800000000000000000000000000000; // 120 bits number, 2^119\n let arr: [u128; 4] = [0, 0, x as u128, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test zero\n let arr: [u128; 4] = [0, 0, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test all bits set (120 bits)\n let x: Field = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // 120 bits, 2^120 - 1\n let arr: [u128; 4] = [0, x as u128, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test systematic bit positions\n for i in 0..120 {\n let x: u128 = 1;\n let shifted: u128 = x << i;\n let arr: [u128; 4] = [0, shifted, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n }\n\n // Test random-like patterns (multiple bits set)\n let patterns: [Field; 7] = [\n 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, // alternating bits\n 0x555555555555555555555555555555, // alternating bits (opposite)\n 0x1234567890ABCDEF1234567890ABCD, // some pattern\n 0xFEDCBA0987654321FEDCBA09876543, // some pattern\n 0x800000000000000000000000000001, // highest and lowest bits\n 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE, // all bits except lowest\n 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFF, // all bits except highest\n ];\n for i in 0..patterns.len() {\n let arr: [u128; 4] = [0, patterns[i] as u128, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n }\n\n // Test with MSB in different array positions (120 bits)\n let x: Field = 0x800000000000000000000000000000; // 120 bits\n let arr1: [u128; 4] = [x as u128, 0, 0, 0];\n let arr2: [u128; 4] = [0, x as u128, 0, 0];\n let arr3: [u128; 4] = [0, 0, x as u128, 0];\n let arr4: [u128; 4] = [0, 0, 0, x as u128];\n let msb1_1: u32 = __get_msb64(arr1);\n let msb2_1: u32 = __get_msb(arr1);\n assert_eq(msb1_1, msb2_1);\n\n let msb1_2: u32 = __get_msb64(arr2);\n let msb2_2: u32 = __get_msb(arr2);\n assert_eq(msb1_2, msb2_2);\n\n let msb1_3: u32 = __get_msb64(arr3);\n let msb2_3: u32 = __get_msb(arr3);\n assert_eq(msb1_3, msb2_3);\n\n let msb1_4: u32 = __get_msb64(arr4);\n let msb2_4: u32 = __get_msb(arr4);\n assert_eq(msb1_4, msb2_4);\n }\n\n #[test]\n unconstrained fn fuzz_get_msb(seed: [u128; 5]) {\n let mut seed_copy: [u128; 5] = seed;\n for i in 0..5 {\n seed_copy[i] = seed_copy[i] & (TWO_POW_120 - 1);\n }\n let msb1: u32 = __get_msb64(seed_copy);\n let msb2: u32 = __get_msb(seed_copy);\n assert_eq(msb1, msb2);\n }\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/utils/msb.nr"},"135":{"source":"use crate::constants::TWO_POW_120;\n\n/// Split the Field value into two 120-bit limbs (unconstrained)\n///\n/// Here we're taking advantage of truncating 120 bit limbs from the input field\n/// and then subtracting them from the input such that the field division is equivalent\n/// to integer division.\n///\n/// We return the lower 120-bit limb as a `u128` value,\n/// and the upper limbs as a `Field`, to avoid unnecessary conversions\n/// and potential overflows\npub(crate) unconstrained fn __split_120_bits(mut x: Field) -> (u128, Field) {\n let low: u128 = (x as u128) % TWO_POW_120;\n let high: Field = ((x - low as Field) / TWO_POW_120 as Field);\n (low, high)\n}\n\n/// Normalize an array of Field values into 120-bit limbs (unconstrained)\n///\n/// Each Field element is split into two parts modulo 2^{120}\n/// The overflow from the lower limbs is carried into the higher limbs\npub(crate) unconstrained fn __normalize_limbs(input: [Field; N]) -> [u128; N] {\n let mut normalized: [u128; N] = [0; N];\n let mut next: Field = input[0];\n for i in 0..(N - 1) {\n let (lo, hi): (u128, Field) = __split_120_bits(next);\n normalized[i] = lo;\n next = input[i + 1] + hi;\n }\n let (lo, hi): (u128, Field) = __split_120_bits(next);\n normalized[N - 1] = lo;\n\n // non-zero final carry <=> normalized value overflows the array length\n assert(hi == 0);\n\n normalized\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/utils/split_bits.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.vk b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.vk new file mode 100644 index 0000000000000000000000000000000000000000..08f48fd083b6b6c83bcd5e870c96cd4108f5f0a0 GIT binary patch literal 1888 zcmajg`9Bkk1Hf@(wlTvn=iD}$^DDXUA=f;v9EEb#_f>Oct{lsgBUg^Ob0df`p_(CGucOJ|i2hl930gAWUJwBsWd?#%x;+4n=|cg73_FC$e)LNKY- zIclkU^04u(MReaE^0__c!zEq z;<`NlirX%`$mx_LEl$xem92*3R}ygCDN?%~^Sx3eEUr4ud(xSuajSJE+tM2iR+p^P zHq*nW+kO>N6>!E%eYsC5%outCjt@$H{2$Jrr0goKd}r5P za>vbvk-CrPD!mP8@H>Rx!e0F0W=R9_N$|i)&4TI*|EQnKMqScqvj-HrIz@4n<2pOY8E1F)JM0#pHnM1fU=0zy( z_%qMyxZWQx?+BR=?Il@r!~nf*&8}!Ns7pMpqrWQrc)Zw@*Z-7XUcHL^6Txd4J!V2Al*=;v4!!`K@gbfaSTLmu69!42Y3A`+F|$K0(dhza^ZX< zxk|O~ zCqvH%(i|T)QI3tbM`SoLL!OXRwE7})MHgzTJ;C^Ha7~l_=qeo=nxTwu8&Vp+X zjELa1`&C#Z)5EP4)X<|kglT?JL~wB^Y?06EL8N+86e^7)q#H=nlM*Z9YJnL(kQj-X z1=AI>8JRSBW_Fkrk2^a;xc!McdhJz5`me!Y+qM^h#T~lG!8l@GsYy8@#AE(kG zoXDH`|MJTi!r}yBJ1aJNF(ai0zR11ytmB!vXuog&)`jFXHR*B?iMs9wAfzPJZ)Dd6 zC0p$Ji;lDsPz+LVmHpz4ZY=8Jh0bUpO+v6nv&vIEXwNalDdd&1=AJHoPAF!=eOtgy zDFWOi%Sml+d5S?551PpVyN-~^R)#vg*&X6~gR8<|vZ{)kb}kA8aK54xP-kczbq1WQ zKxG*Jj!+Pq4beI7A@x98E-@N9zFa4pUR8@}SOA8^kBiHVR-pj!Jta4a>G7klig7=Fa>FH*)N- z4utF?!G%ovG|&iSAjr+4gqxEs8HnpjTVwSr_#{|az6s0H85uBwM##N~kTe4BUKED= z=I4_%3NYX7-Hn7(W`}Iq!gXE$?N9&W>`Leqw|QC3CNsO^=CJVz*iKIv>f8greeX>K pUqbSRf$YAgnR`8jQ>|%vi+7ROaIe@*Qp1JEo_`4XI5_!f(Lb|$Eq(w1 literal 0 HcmV?d00001 diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json new file mode 100644 index 0000000000..0726b9a65b --- /dev/null +++ b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json @@ -0,0 +1 @@ +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"1413289141083555426","abi":{"parameters":[{"name":"decryption_shares","type":{"kind":"array","length":3,"type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]}}},"visibility":"public"},{"name":"party_ids","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"public"},{"name":"message","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]},"visibility":"public"},{"name":"u_global","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"crt_quotients","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":null,"error_types":{"991688543994151927":{"error_kind":"string","string":"Division verification failed: result * rhs ≠ lhs (mod m)"},"6347439466827421235":{"error_kind":"string","string":"CRT reconstruction verification failed"},"15764276373176857197":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"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","debug_symbols":"tP3LjmzZtl0H/sstq7DmHG/+SiIhUBIlECAogZKyIujfc7u7rdG6lIjNrYiTLNAHee5d08K7m/ts/bQY9n/82//wH/67//1/+m//43/+H//n//Xf/t3/6//4t//uv/zH//Sf/uP/9N/+p//5v//3/9t//J//86//3//j356v/+vUv/2789/82+mfL/P95f76j+6vL+fny/35Yv/27+zXF/+3f+e/vsTPl/z58usp8evLr6fk//nrMe+T++fJ/Xny8/Po76/n8/V+vv56+jk/j//+Gp+v+flan6/9+To/X+35fD2fr/fz9fM8+zzPvp7365/C8vO1Pl/783V+vvrz+fr5n/ev//lf/9j+9Z//+ieNr/+8fn39Ou/XP1fcz1f7fPXP1/h8zc/X+nztz9f5+Zpf//vz66t9vv7637+/vh9Zn6/9+frrf/7+eh31Fc2v11Hn8/V+vtrnq3++xudrfr7W52t/vn4979f3pc/n69dzfv1z9ddzfr2u9s/X+HzNz9f6fO3P1/n5Os/n6/l8/Xrerx+JsZ/v2/jP1/PYz0/a45+v8fma3z9l56nP1/58ne8fu3Oe75+0c87n6/18te8fvXP862fv1w/f+zP+3/5v/+U//IevH0T5of/1Vvhf/v1/+Q//+X/7t3/3n//3//Sf/pt/+//8+//0v3//D/2v/8u//8/fX/+3f/9ffv2nv77j/+E//w+/vv564P/4H//Tf/ia/s//hv/t56//V89p+/xvnzO5D6j54yfcE+8T7vW/9YQ4+4R6/tYTpt4n2Plb/xT29XP2eYL/vSd47xPq/I0nZMWbRdZffx/qN084834n8zdp/vYJle8T7vOXr2H++gll+f5TlJX9rSfMvE9wO3/nCd65T5j6O0+I876rfo3xd56Q/f48VI79rZ8Hsujn/tUTvt5+f/WIvvf9x+gbf/2I/OtHhOX7zojf5Pn7R9QbaPjxvxWHEYf9rTji7g/Vrxfxt56QsU+Y+asnfP19+odx3PuP4/j9I/5xHGm+P9v1l0+4//wn8/7zn8z7z38yf/sH1PcPx2l+Ycb/9U/wnd99K/avV1vyWzvr//II++2riNy/oSfkm/H/7CGePCT6X/CQv/lK7q8b114Jft2a/vIh/tcP8RvvT5jflN8Z/7dH/OaH9PJDem/433qE7fXo2v3nj9BfXf8PHuHP+yN2/dQ/fsT9u6/i/skjfhtq5oZafx3qb3+4zO/+cFmcv/rhcvvNL44n32fE0/NXr+O3jzj1xhqn/zITj3/83fj9I/7oXeL1j98lv33En71L/vgRf/0u+e0j/uxd8sePuH/3VfzJu+S3P1p3f33GPX/50xn+j0P97SP+LNQ/fsRfh/rbR/xZqH/8iPt3X8U/DlV+X9zf/CX57a++NH71pf/lr768//g3Rto//uH67SP+7Ifrjx/x1z9cv33En/1w/fEj7t99FX/yw/X7UP8Ff1cnZ3+4pv7y+ljnH/9d/e0j/uzvatk//m78/hF/9C6pf377rH9++6x/fvusf377rH9++6x/fvv87Y/Wn/1d7fuPQ/3tI/4s1D9+xF+H+ttH/Fmof/yI+3dfxT8O9V/wd9Xus/htV74b/0+g107TIGv5+n97yJx//OP120f82Y/XHz/ir3+8fvuIP/vx+uNH3L/7Kv7kx+u37Y7X+6PRv25ffxlq/+Ynw+824sft1r/gIdb/gofk3/zH8eAhnn/5Ss7zz28s/5Vn/NEf6e8y6h++437/jD97y/35M/76Pff7Z/zZm+7Pn3H/9uv4k7fd73/I4izqeMg39f/+Q3b++a/T3z/jD8M9//wX6u+f8Yfhnn/+K/W/9ox/Qbg3CNfmr8L97S/m2v/Kt3vmr38+fvOME2d55dfc+a94yvzl7/fzu/9y6Ua/v1VvPvzz9PM3n3H6L5/x+3+au/+95a/5d/80v/kVcHL/a+RTT/3NV/LrR2NfSdT5m+n49J885bc/bLP/NVFP/vUvo/ubn/qp/S9B59d/Mf7Xz5h//lfz98/4s7+a9i/4xWr/gl+s9i/4xWr/gl+s9i/4xWr//Bfr73/G+r631emIv/Vzep5T+959fgMy/5WnXISa5/7mPePPP/85++0z/vDn7I+f8Zufs98+4w9/zv74Gfdvv45//HN2HtuH/JrPX/+k/e6/KvnT32a/f8af/Tbz+Rf8lM2/4Kds/gU/ZfMv+Cmbf8FP2fz/+6csuIo8MX+Jqyfyn6f722f8Ybp//IzfpPvbZ/xhun/8jPu3X8e/IN1f/w3Wppvx138h8p93/f+VZ/zZ75D8523/75/xhz9l+c/7/t8/4w9/yvKfN/7/tWf8C37K6vKXquzv3d3P0xhNT5+/e7Oay0/8RP0rnvLXJd5/7SnU1b/anP/r9+X//ev/9e//+//4X/5//iUOy+9/48J+ZXt/vtjPF//5Ej9f8udL/Xzpny/z8+VLrv/++nnO+TzofJ70Jdfb17/FEZ+v+flan6/9+To/X7/+LY+vXyRf/5bH18u7n+fdz/Pu56Xdz2u7nxd3P6/ufl7e/bw++7w++7w+e/9BP8+zz/Ps8/rs8/rs8/rs8/rs8/q+/i2P76/n53X6/Xmd/n7nPs/zz+vzz+vzz+vzz+vzz+uLz+uLz+uLz+uLz/PijeLzvPi8vvi8vvi8vvi8vvy8vjyfr/fndX79WyJf1Pv1b4l8XeXz69/C+fq3RvLztT5f+/N1fr5+/Vsj31/P5+v9fLXPV/98/TyvPs+rz/O+/q2Rr9/HX//WyNfXfj5fz+fr/Xy1z1f/EkF//u2RiJ9/e+Trb9fXvz3y/bU/X+fn69e/PfL99Xy+3s9X+3z1z9f4fP08bz7Pm8/z5ut53z/Pzzucd7jvYO/g7/Drqfl8/h2UPJ9/CSX982+hfP06/P7XUL6Hr7fKz3De4b6DvYO/Q7xDvkO9w/vk8z75vk/+etd8/QU9X2+bn8Hewd8h3iHf4evJ8zX058Xf98n2Ptne12zva7b3Ndv7mu19zfa+Zntfs72v2d4n+/tkf5/s72v29zX7+5r9fc3+vuav99PP0J8X//WO+h6+3lL19S8Afb2nvq6c5+tNVV95fb2rfgZ/h3iHfId6h36H+Qxfb66f4bzD++R8n5zvk7/eYfX9Gy/fod6h32E+w9fb7Gf49eT++kH6eqN9/etA5+ud1l+hfL3VfoZ4h3yHeod+h/kMX2+4n+G8w32H98n9PrnfJ3+97forlK/33c/Q7zCf4eut9zOcd/h68vcv868nf2Xx9fb7+rVzvt5//v0ffX5BnKl36Hf4/M65z/MO5x3uO9g7+DvEO+Q71Dv0O3x++9zzvMN5h/sO9g7+DvHzu+iez7v7ns+7+77vwfu+B+/7Hrz3vMN9B3sHf4d4h3yHeof3ye978L7vwWufd/e1+w72Dv4O8Q75Dp939/16D9b3v445P++L65+f5+vnHe472Dv4O8Q75DvUO/Q7fN4pN94nx/vk9z14v9+DX3/pv9+D30O8Q75DvUO/w/y8L+7Xe/DrfXHz8/N8876DvYO/Q7xDvkO9Q7/D551y63mH98n1Pvl9D97v9+BXFt/vwe8h36Heod/h80653+/Br3+K7/fgVxZf78H5yuLrPThf/zhf78GfId4h36Heod9hPsPXe/BnOO9w3+F98rxPnvfJX+/B+frH+XoP/gz9DvMz2Nd78Gc47/D15O8r1ecuYc/nMmHve9De96C970F734P2fN7ddp53OO9w38Hewd/hffJ5n3zeJ5/P1cLO591t93mH8w73HewdPhcM+34Pfv97v/nzprb3PWjve9De96C970F7/w7a+3fQ3r+D9v4dtPfvoL1/B+39O2jv30F7/w7a99/B/BrOO9x3sHfwd4h3yJ83tfnnN5L5+2R/nxzva473Ncf7muN9zfG+5nhfc7yvOd7XHO+T431yvk/O9zXn+5rzfc35vuZ8X3PmO3x+I1l+fiNZfn4jWX1+b1idd7jvYO/g7xDvkO9Q79Dv8PmNZP0+ud8n9/vk/vxGsvZ3iHfId6h36Hf4/Eay+fxGsvn83rC572Dv4O8Q75DvUO/Q7/D5jeTP8w7nHe472Dt8fiP5E++Q71Dv0O/w+Y3k5/Mbyc/nN5KfF2RecvPzosx5Wea8MHNemjkvzpwPz/h93uG8w32H98kvxPlLcX4/WOO33qHf4SUve9HLzjt84Ma/ae6bwt4n2/tke1+zva/Z3tds72v29zX7+5r9fc1w3fvkJbtFO39fs7+v2d/XHO9rjvc1fwPe92CfF/+NeF8v/mU8j/fJ8b7meF9zvK8539ec72vO9zXn+5rzfc25NPo+Od8n5/ua833N9b7mel9zva/56z34M/jnxX9z39fP4Tf4ff9Hn9/PXv0On9/83s87nHe472Dv4O8Q75Dv8D653yf3++T5/Ob3Oe9w38Hewd8h3iF//hb4Nw1+vS9eHPT58GU8zzucd7jvYO/g7xDvkO9Q79Dv8D75vE8+H9KMc9/B3sHfId4h36F+2DO+76Lna5ifvwXx3kXjvYvGexeN9y4a71003rtovHfReP8Oxvt3MN6/g/H+HYz372C8fwfjvYvGexeN9y4a7100rN6h3+FDbfH9d/Drxb88GP4+2d/X7O9r9vc1+/ua/X3N79/BeP8Oxvt3MN6/g/H+HYz372DE+5rjfc3xvuZ4X3O8r/n77+DX8P138OvFf/8d/B7uz1+0+ObB7/+Zz1+ryHiHfId6h36Hz1+reP8Oxvt3MN6/g/H+HYz372C8fwfj/TsY9flrFdXv8CHN6Ocdzjvcd7Cfv2jxzYP2NXz+WkXnO9Q79Dt8/lrFPO9w3uG+g72Dv8P75PfvYLx/B2M+f61iPn+t8nne4bzDfQd7B//5i5bffwe/Gqzvu+hX5fV9F/3+j95y672L5nsXzfcumu9dNN+7aL530XzvovneRfO9i+Z5n3zeJ9/3ye9dNN+7aL530bz+DvEO+Q7186sp7+fdnffz7s73PZjvezDf92C+d9F876L53kXzvYvmexfN9y6a7100304m3/dgvu/BfO+i+d5F872L5tvJ5NvJpPc7fN7d+XYy+XYy+fJgvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvu/BfDuZfDuZfDuZfDuZfDuZfDuZfDuZfDuZfHkw304m304m304m304m304m304m304m304m304m304m304m3/dgvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvp1Mvp1MfvPgVxYvD+bkO9Q79Dt8SLOe5x3OO9x3sHfwd4h3yHeod/iQZj0f0qzzvMN5h/sO9g7+w551PveNOp/7Rr3vwXrfg/W+B+t9D9bd9vqtr+/bX9+3wL5vg33fCvu+T77vk+/7ZPvcN8rOO9x3sHfwd4h3+Nw36vs9eL6GT+Na73uw3vdgve/Bet+D9f4drPfvYL1/B+v9O1jv38F6/w7W+3ew3r+D9f4drPhQW4W9g79DvEO+Q73Dp3Gt+PxGqpcHK98n5/ua833N+b7mfF9zvq8539ec72vO9zXX++R6n1zvk+t9zfW+5npfc72vud7XXP0On99I1Z/fSNWf30j18mC1vYO/Q7xDvkO9Q7/D5zdSzfMO5x3eJ8/75HmfPJ/fSDX5DvUO/Q6f30j9PO/w+Y3Uz+c3Ur882I+/Q7xDvkO9Q7/D5zdSn+cdzjvcd3iffN4nn/fJ5/MbqU+9Q7/D5zdS3+cdzjt8fiP1/fxG6u/Vbc/3fxbf+sDXlDvVTr3TvNP3Gref6ex0d7KdfKc9w/YM2zO+17p9/bfd/b3Y7Xv6Xu32M52d7k62k3//169f0/cSuvs1fa+h+4rIa6fead7pez3cz3R2ujvZTr5T7LRnxJ4Re8b3wrivDWqdz05np7uT7eQ7fZ/x9c+W+WaU+73KzSM3j9o8avOozaM2j9o8avOozaP2jNozas/ozaM3j948evNo3yl2yjejrjej3u9Vbx6zeczmMZvHbB6zeczmMZvHbB6zZ8x7xjzPTm8e89ydbCffKXbKneqT0Tz9yWie93s159np7HR3sp18p9gpd6qdeqc94+4Zd8+4bx5zbSffKXbKnWqn/mQ0P8sa79d/n7vfKzs73Z1sJ98pdsqdaqfeafPwPcP3DN8zfPPwzcM3D988ft7n31PvNG9G3+/z74xiv1execTmEZtHbB6xecTmEZtHbB65eeSekXtG7hm5eeTmkZtHbh7ZO72/E+f7ff6d0ff7/Duj2u9VbR61edTmUZtHbR61edTm0ZtHbx69Z/Se0XtGbx69efTm0ZtHv78TZ56dzpvR9/v8O6PZ79VsHrN5zOYxm8dsHvPmcZ7nYTyMl9EYnTEY31h+jcXYjLPjeRgP4/0E9mu0T2K/xvdb92sMxmQsxmacHe/DeBgvozFy2uW0y2n3zerX2Iyzoz2Mh/Ey2ifFX+N7rfg18p3cP/q/xmJsRnJzcnNyc3JzcnNyc05zTnNOc3JzcgtyC3KLy2iMvmlGbJrBdzLILcgtyC3JLcktyS3JLcktyS05LTktOS3JrcityK3IrYzRGWPTrNw0i+9kkVuRW5Nbk1uTW5Nbk1uTW5Nbc1pzWnPakNuQ25DbkNs4YzDmpjm1aQ7fyb0znLOXhnOew3gZjdEZgzEZi7EZOe1w2tnczrmMxuiMwZiM703lnPNeVc7Ze8Q5e5E4Z28S59zLaIzOGIzJWIzNyGnGacZptrkdM0ZnDMZkLMb3+nKOvfeXc5zvpJObk5uTm5Obk5uTm5Obk5uTW3BacFpwWpBbkFuQW5BbFGMzzqaZz6aZfCeT3JLcktyS3JLcktyS3JLcityK04rTitOK3IrcityK3KoZ97fy6WfT7LNpNt/JJrcmtya3Jrcmtya3JrchtyG34bThtOG0IbchtyG3IbfZ38r3eRjf28+5z3v9OZd7yeVecrmX3CcZi7EZN7e7KHLussi5CyPnHk47nHY47Wxu9xRjM25u9z6Mh3FvQffuLehyL7ncSy73knuLsRk3t7t4cu7yybkLKOcuoZxrnGacZpxmm9u1ZiQ3Jzc/jJdxb0HX9xZ0uZdc7iWXe8l1cnNyC3ILcgtyC3ILcgtOC04LTgtyC3JLcktyy8tojHsLurm3oMu95HIvudxLbpJbkVuRW5FbkVuRW5FbcVpxWnFakVuTW5Nbk1sbozPuLej23oIu95LLveRyL7lDbkNuQ25DbkNuQ25DbsNpw2kwjj2bmz2H8TIaozMG496C7NlbkHEvMe4lxr3EzmG8jMbojMGYjMXIaTCOwTh2Nze7l9EYnTEYk3FvQXb3FmTcS4x7iXEvsS01j22reWxrzWMwjsE4BuMYjGMwjsE4BuOYk5uTm5Obk5snYzHuLch8b0HGvcS4lxj3EgtyC3ILcoNxDMYxGMdgHINxDMYxGMeS3JLcktyS3LIYm3FvQVZ7CzLuJca9xLiXWJFbkVuRG4xjMI7BOAbjGIxjMI7BONbk1uTW5Nbk1s24v5Vt9hZks7cg415i3EuMe4kNuQ25DbnBOAbjOIzjMI7DOA7jOIzj244e33r0+FOMzbi/lf08jHsL8rO3IOde4txLnHuJb1F6fJvS41uVHodxHMZxGMdhHIdxHMZxGMe3Mj2+nenx24ybm9vDeBj3FuS2tyDnXuLcS5x7iW97enzr0+NGbjCOwzgO4ziM4zCOwzgO47iTm5Obk1uQWxzGy7i3II+9BTn3Eude4txLPMgtyC3JDcZxGMdhHIdxHMZxGMdhHE9yS3Ircityq8tojHsL8tpbkHMvce4lzr3Ei9ya3JrcYByHcRzGcRjHYRyHcRzG8Sa3IbchtyG3MUZn3FuQz96CnHuJcy9x7iVB9xp0r0H3GjBOwDgB4wSMEzBOwDgB4wTda9C9xrmMxuiMwbi3oDh7CwruJcG9JLiXBN1r0L0G3WvAOAHjBIwTME7AOAHjBIwTdK9B9xpmjM4YjMm4t6CwvQUF95LgXhLcS4LuNeheg+41YJyAcQLGCRgnYJyAcQLGCbrXoHuNILcgt0jGYtxbUMTegoJ7SXAvCe4lQfcadK9B9xowTsA4AeMEjBMwTsA4AeME3WvQvUaRW5FbFWMz7i0oem9Bwb0kuJcE95Kgew2616B7DRgnYJyAcQLGCRgnYJyAcYLuNeheY8htyG2acX8r57O3oHz2FpTcS5J7SXIvSbrXpHtNuteEcRLGSRgnYZyEcRLGSRgn6V6T7jVPMTbj/lbO+zDuLSjv3oKSe0lyL0nuJUn3mnSvSfeaME7COAnjJIyTME7COAnjJN1r0r3m6hsnjdxW4Di5BsdJ31tQ+t6CkntJci9J7iVJ95p0r0n3mjBOwjgJ4ySMkzBOwjgJ4yTda9K9ZpBbkttaHSdX6ziZewvK3FtQci9J7iXJvSTpXpPuNeleE8ZJGCdhnIRxEsZJGCdhnKR7TbrXbHJrclvV4+S6Hid7b0HZewtK7iXJvSS5lyTda9K9Jt1rwjgJ4ySMkzBOwjgJ4ySMk3SvRfdaa3+cWv3j1Pofp1YAOfXsLaievQUV95LiXlLcS4rutehei+61YJyCcQrGKRinYJyCcQrGKbrXonutVUJOrRNyaqWQU2uFnLp7C6q7t6DiXlLcS4p7SdG9Ft1r0b0WjFMwTsE4BeMUjFMwTsE4RfdadK/l5ObktqbIqVVFTvnegsr3FlTcS4p7SXEvKbrXonstuteCcQrGKRinYJyCcQrGKRin6F6L7rWS3JLcVh85tf7IqdxbUOXegop7SXEvKe4lRfdadK9F91owTsE4BeMUjFMwTsE4BeMU3WvRvVaTW5PbOiWnVio51XsLqtlbUHEvKe4lxb2k6F6L7rXoXgvGKRinYJyGcRrGaRinYZyme22618YvafySxi9p/JI+ewvqs7eg5l7S3Euae0nTvTbda9O9NozTME7DOA3jNIzTME7DOE332nSvjV/S+CWNX9L4JT8+6XeaH6E0vke+k9xLcEoPUunBKj1N99owTsM4DeM0jNMwTsM4DeM03WvTvTZ+SeOXNH5J45d8JNPvNGNvQWimB8/0IJoeTNODanqa7rVhnIZxGsZpGKdhnIZxGsZputeme238ksYvafySxi/5MU9/0qy9BeGeHuTTg3160E8P/ulputeGcRrGaRinYZyGcRrGaRin6V6b7rXxSxq/pPFLGr/ko6N+pzl7C0JIPRipByX14KQepNQzdK8D4wyMMzDOwDgD4wyMMzDO0L0O3evglwx+yeCXDH7Jj6P6neZHUo3vcb+TaKoHT/Ugqh5M1TN0rwPjDIwzMM7AOAPjDIwzMM7QvQ7d6+CXDH7J4JcMfslHXH2+x70Foa4e3NWDvHqwVw/66hm614FxBsYZGGdgnIFxBsYZGGfoXofudfBLBr9k8EsGv+THZv1JM/YWhM96EFoPRutBaT04rWfoXgfGGRhnYJyBcQbGGRhnYJyhex2618EvGfySwS8Z/JKP4vqdZu0tCMn1YLkeNNeD53oQXc/QvQ6MMzDOwDgD4wyMMzDOwDhD9zp0r4NfMvglg18y+CU/3utXmvfjvcb3+H4nL97rxXu9eK8X7/U+273eZxnnPss491nGuc8yzn0Opx1OO5y23et9tnu9z/ol91m/5D7rl9xn/ZL78V6f7/G9BV2814v3evFeL97rxXu9z3av91nGuc8yzn2Wce6zjHMf4zTjNOO07V7vs93rfdYvuc/6JfdZv+Q+65fcH+/1J02/m6bznXRyc3JzcnNyc3JzcgtyC3ILcgtOC04LTgtyC3ILcgtyW7/kPuuX3I/3+p1m2qaZfCeT3JLcktyS3JLcityK3IrcityK04rTitOK3Ircitya3NYvuc/6JffHe/1Js33TbL6TTW5Nbk1uTW5DbkNuQ25DbkNuw2nDacNpQ27bvd6zfsk965fcs37JPeuX3I/3+rPw670F/Rr3O3n2XnLxXi/e68V7vWe713uWcb4+B5nRGYOR0w6nHU7b7vWe7V7vWb/knvVL7lm/5J71S+6P9/qd5sd7je9xv5N4rxfv9eK9XrzXe7Z7vWcZ555lnHuWce5ZxrnHOM04zTjNyc3JzcnNyW39knvWL7kf7/VnNVttms530sktyC3ILcgtyC3ILcgtyC3ILTgtOC05LcktyS3JLclt/ZJ71i+5P97rT5rZm2bynSxyK3IrcityK3IrcityK3IrcitOa05rTmtya3JrcmtyW7/knvVL7sd7/U6zZ9McvpNDbkNuQ25DbkNuQ25DbkNuyzj3LuPcu4xz7zLOvdu93rvd673rl9y7fsm965fcu37J/fFev9P8eK/xPe53Eu/14r1evNeL93rvdq/3LuPcu4xz7zLOvcs4915Ou5x2OW2713u3e713/ZJ71y+5d/2Se9cvuR/v9fke9xaE93rxXi/e68V7vXiv9273eu8yzr1Gbk5uTm7Oac5pzmlObk5uTm5ObuuX3Lt+yf3xXn/SjL0F4b1evNeL93rxXi/e671BbkFuSW5JbkluyWnJaclpSW5JbkluSW7rl9y7fsn9eK/fadbegvBeL97rxXu9eK8X7/XeIrcmtya3Jrcmt+a05rTmtCa3JrcmtyG39UvuXb/k/nivP2nO3oLwXi/e68V7vXivF+/12nav12Acg3EMxjEYx2Acg3EMxrHtXq9t93pt/ZJr65dcW7/k2vol9+O9Pt/j3oLwXi/e68V7vXivF+/12nav12Acg3EMxjEYx2Acg3EMxrHtXq9t93pt/ZJr65dcW7/k2vol98d7/U7z473G98h3knsJ3uvFe714r9ec3GAcg3EMxjEYx2Acg3EMxrEgtyC3ILcgt/VLrq1fcj/e63easbcgvNeL93rxXi/e68V7vZbkBuMYjGMwjsE4BuMYjGMwjhW5FbkVuRW5rV9ybf2S++O9/qRZewvCe714rxfv9eK9XrzXa01uMI7BOAbjGIxjMI7BOAbj2JDbkNuQ25Db+iXX1i+5H+/1O83ZWxDe68V7vXivF+/14r1e3+71OozjMI7DOA7jOIzjMI7DOL7d6/XtXq+vX3J9/ZLr65dcX7/k/niv32l+vNf4Hvc7ifd68V4v3uvFe72+3et1GMdhHIdxHMZxGMdhHIdxfLvX69u9Xl+/5Pr6JdfXL7m+fsn9eK/P97i3ILzXi/d68V4v3uvFe73u5AbjOIzjMI7DOA7jOIzjMI4HuQW5BbkFua1fcn39kvvjvf6kmXsLwnu9eK8X7/XivV681+tJbjCOwzgO4ziM4zCOwzgO43iRW5FbkVuR2/ol19cvuR/v9TvN3lsQ3uvFe714rxfv9eK9Xm9yg3EcxnEYx2Ech3EcxnEYx4fchtzWL7mxfsmN9UturF9yf7zX7zQ/3mt8j/udxHu9eK8X7/Xivd6gew0YJ2CcgHECxgkYJ2CcgHGC7jXoXmP9khvrl9xYv+TG+iX3470+3+PegvBeL97rxXu9eK8X7/UG3WvAOAHjBIwTME7AOAHjBIwTdK9B9xpObk5u65fcWL/k/nivP2n63oLwXi/e68V7vXivF+/1Bt1rwDgB4wSMEzBOwDgB4wSME3SvQfcaSW5JbuuX3Fi/5H681+80c29BeK8X7/XivV6814v3eoPuNWCcgHECxgkYJ2CcgHECxgm616B7jSa3Jrf1S26sX3J/vNefNHtvQXivF+/14r1evNeL93qD7jVgnIBxAsYJGCdgnIRxEsZJuteke831S26uX3Jz/ZKb65fcj/f6fI97C8J7vXivF+/14r1evNebdK8J4ySMkzBOwjgJ4ySMkzBO0r0m3WuuX3Jz/ZKb65fcXL/k/niv32l+vNf4HvlOci/Be714rxfv9Sbda8I4CeMkjJMwTsI4CeMkjJN0r0n3mk5uTm7rl9xcv+R+vNfvNGNvQXivF+/14r1evNeL93qT7jVhnIRxEsZJGCdhnIRxEsZJuteke80ktyS39Uturl9yf7zXnzRrb0F4rxfv9eK9XrzXi/d6k+41YZyEcRLGSRgnYZyEcRLGSbrXpHvNJrcmt/VLbq5fcj/e63eas7cgvNeL93rxXi/e68V7vUn3WjBOwTgF4xSMUzBOwTgF4xTda9G91volt9YvubV+ya31S+6P9/qd5sd7je9xv5N4rxfv9eK9XrzXW3SvBeMUjFMwTsE4BeMUjFMwTtG9Ft1rrV9ya/2SW+uX3Fq/5H681+d73FsQ3uvFe714rxfv9eK93qJ7LRinYJyCcQrGKRinYJyCcYruteheK8gtyG39klvrl9wf7/UnzdhbEN7rxXu9eK8X7/Xivd6iey0Yp2CcgnEKxikYp2CcgnGK7rXoXqvIrcht/ZJb65fcj/f6nWbtLQjv9eK9XrzXi/d68V5v0b0WjFMwTsE4BeMUjFMwTsE4RfdadK815Dbktn7JrfVL7o/3+pPm7C0I7/XivV6814v3evFeb9O9NozTME7DOA3jNIzTME7DOE332nSvjV/S+CWNX9L4JR/v9fke9xaE93rxXi/e68V7vXivt+leG8ZpGKdhnIZxGsZpGKdhnKZ7bbrXxi9p/JLGL2n8kh/v9TvNj/ca3yPfSe4leK8X7/Xivd6me20Yp2GchnEaxmkYp2GchnGa7rXpXhu/pPFLGr+k8Us+3ut3mrm3ILzXi/d68V4v3uvFe71N99owTsM4DeM0jNMwTsM4DeM03WvTvTZ+SeOXNH5J45f8eK8/afbegvBeL97rxXu9eK8X7/U23WvDOA3jNIzTME7DOA3jNIzTdK9N99r4JY1fMvglg1/y8V6f73FvQXivF+/14r1evNeL93qH7nVgnIFxBsYZGGdgnIFxBsYZutehex38ksEvGfySwS/58V6/05xdxnzxXi/e68V7vXivF+/1Dt3rwDgD4wyMMzDOwDgD4wyMM3SvQ/c6+CWDXzL4JYNfMrug+c5uaL54rxfv9eK9XrzXi/d6h+51YJyBcQbGGRhnYJyBcQbGGbrXoXsd/JLBLxn8ksEvmd3afGfXNl+814v3evFeL97rxXu9Q/c6MM7AOAPjDIwzMM7AOAPjDN3r0L0Ofsnglwx+yeCXzK5yvrO7nC/e68V7vXivF+/14r3eoXsdGGdgnIFxBsYZGGeWcexZxrFnu1d7tnu1Z/0Se9YvsWf9EnvWL7Fn9zvbswueDe/V8F4N79XwXg3v1Z7tXu1ZxrFnGceeZRx7lnHsOZx2Oe1y2nav9mz3as/6JfasX2LP+iX2rF9izy59tme3Phveq+G9Gt6r4b0a3qs9273as4xjzzKOPcs49hi5Oac5pzmnObk5uTm5ObmtX2LP+iX27CZoe3YVtOG9Gt6r4b0a3qvhvdoT5BbkFuQW5JbklpyWnJacluSW5JbkluS2fok965fYs+uh7dn90Ib3anivhvdqeK+G92pPkVuRW5Fbk1uTW3Nac1pzWpNbk1uTW5Pb+iX2rF9iz+6MtmeXRhveq+G9Gt6r4b0a3qs9Q27LOHaWcews49hZxrGzjGNnGcfOMs6vcXM7273aWb/EzvoldtYvsbN+iZ3dHf1rfG9Bv8b9TuK9Gt6r4b0a3qud7V7tLOPYWcaxs4xjZxnHzuW0y2mX07Z7tbPdq531S+ysX2Jn/RI765fY2d3RdnZ3tOG9Gt6r4b0a3qvhvdpxcnNyc3JzcnNyc05zTnNOc3JzcgtyC3Jbv8TO+iV2dne0nd0dbXivhvdqeK+G92p4r3aS3JLcktyS3JLcktOS05LTktyK3IrcitzWL7Gzfomd3R1tZ3dHG96r4b0a3qvhvRreq50mtya3Jrcmtya35rTmtOa0IbchtyG3Ibf1S+ysX2Jnd0fb2d3RhvdqeK+G92p4r4b3ane7V7vLOHaXcewu49hdxrG7jGP34bTDadu92t3u1e76JXbXL7G7fond9Uvs7u5ou7s72vBeDe/V8F4N79XwXu1u92p3GcfuMo7dZRy7yzh2L6cZpxmnbfdqd7tXu+uX2F2/xO76JXbXL7G7u6Pt7u5ow3s1vFfDezW8V8N7tevk5uTm5Obk5uQWnBacFpwW5BbkFuQW5LZ+id31S+zu7mi7uzva8F4N79XwXg3v1fBe7Sa5JbkluSW5FbkVpxWnFacVuRW5FbkVua1fYnf9Eru7O9ru7o42vFfDezW8V8N7NbxXu01uTW5NbkNuQ27DacNpw2lDbkNuQ25DbuuXmK1fYra7o812d7ThvRreq+G9Gt6r4b2abfdqBuMYjGMwjsE4BuMYjGMwjm33arbdq9n6JWbrl5itX2K2fonZ7o42293RhvdqeK+G92p4r4b3arbdqxmMYzCOwTgG4xiMYzCOwTi23avZdq9mRm5ObuuXmK1fYra7o812d7ThvRreq+G9Gt6r4b2aBbnBOAbjGIxjMI7BOAbjGIxjQW5BbkluSW7rl5itX2K2u6PNdne04b0a3qvhvRreq+G9mhW5wTgG4xiMYzCOwTgG4xiMY0VuTW5Nbk1u65eYrV9itrujzXZ3tOG9Gt6r4b0a3qvhvZoNucE4BuMYjGMwjsE4BuMYjOPbvZpv92q+fon5+iXm65eYr19ivrujzXd3tOG9Gt6r4b0a3qvhvZpv92oO4ziM4zCOwzgO4ziM4zCOb/dqvt2r+fol5uuXmK9fYr5+ifnujjbf3dGG92p4r4b3anivhvdqvt2rOYzjMI7DOA7jOIzjMI7DOO7k5uTm5Obktn6J+fol5rs72nx3Rxveq+G9Gt6r4b0a3qt5kBuM4zCOwzgO4ziM4zCOwzie5JbkluSW5LZ+ifn6Jea7O9p8d0cb3qvhvRreq+G9Gt6reZEbjOMwjsM4DuM4jOMwjsM43uTW5Nbk1uS2fon5+iXmuzvafHdHG96r4b0a3qvhvRreq/mQG4zjME7AOAHjBIwTME7AOEH3GnSvsX6JxfolFuuXWKxfYrG7oy12d7ThvRreq+G9Gt6r4b1a0L0GjBMwTsA4AeMEjBMwTsA4QfcadK+xfonF+iUW65dYrF9isbujLXZ3tOG9Gt6r4b0a3qvhvVrQvQaMEzBOwDgB4wSMEzBOwDhB9xp0r+HkFuS2fonF+iUWuzvaYndHG96r4b0a3qvhvRreqwXda8A4AeMEjBMwTsA4AeMEjBN0r0H3GkVuRW7rl1isX2Kxu6Mtdne04b0a3qvhvRreq+G9WtC9BowTME7AOAHjBIwTME7AOEH3GnSvMeQ25LZ+icX6JRa7O9pid0cb3qvhvRreq+G9Gt6rJd1rwjgJ4ySMkzBOwjgJ4ySMk3SvSfea65dYrl9iuX6J5follrs72nJ3Rxveq+G9Gt6r4b0a3qsl3WvCOAnjJIyTME7COAnjJIyTdK9J95rrl1iuX2K5fonl+iWWuzvacndHG96r4b0a3qvhvRreqyXda8I4CeMkjJMwTsI4CeMkjJN0r0n3mkFuQW7rl1iuX2K5u6Mtd3e04b0a3qvhvRreq+G9WtK9JoyTME7COAnjJIyTME7COEn3mnSvWeRW5LZ+ieX6JZa7O9pyd0cb3qvhvRreq+G9Gt6rJd1rwjgJ4ySMkzBOwjgJ4ySMk3SvSfeaQ25DbuuXWK5fYrW7o612d7ThvRreq+G9Gt6r4b1a0b0WjFMwTsE4BeMUjFMwTsE4RfdadK+1fonV+iVW65dYrV9itbujrXZ3tOG9Gt6r4b0a3qvhvVrRvRaMUzBOwTgF4xSMUzBOwThF91p0r7V+iZWR2/olVuuXWO3uaKvdHW14r4b3anivhvdqeK9WdK8F4xSMUzBOwTgF4xSMUzBO0b0W3WsFuSW5rV9itX6J1e6Ottrd0Yb3anivhvdqeK+G92pF91owTsE4BeMUjFMwTsE4BeMU3WvRvVaTW5Pb+iVW65dY7e5oq90dbXivhvdqeK+G92p4r1Z0rwXjFIxTME7BOAXjFIxTME7RvTbda+OXNH5J45c0fknv7mjr3R1teK+G92p4r4b3aniv1nSvDeM0jNMwTsM4DeM0jNMwTtO9Nt1r45c0fknjlzR+Se/uaOvdHW14r4b3anivhvdqeK/WdK8N4zSM0zBOwzgN4zSM0zBO07023WvjlzR+SeOXNH5J7+5o690dbXivhvdqeK+G92p4r9Z0rw3jNIzTME7DOA3jNIzTME7TvTbda+OXNH5J45c0fknv7mjr3R1teK+G92p4r4b3aniv1nSvDeM0jNMwTsM4DeM0jNMwTtO9Nt1r45c0fknjlzR+Se/uaOvdHW14r4b3anivhvdqeK/WdK8N4zSM0zDOwDgD4wyMMzDO0L0O3evglwx+yeCXDH7J7O5om90dbXivhvdqeK+G92p4rzZ0rwPjDIwzMM7AOAPjDIwzMM7QvQ7d6+CXDH7J4JcMfsns7mib3R1teK+G92p4r4b3anivNnSvA+MMjDMwzsA4A+MMjDMwztC9Dt3r4JcMfsnglwx+yezuaJvdHW14r4b3anivhvdqeK82dK8D4wyMMzDOwDgD4wyMMzDO0L0O3evglwx+yeCXDH7J7O5om90dbXivhvdqeK+G92p4rzZ0rwPjDIwzMM7AOAPjDIwzMM7QvQ7d6+CXDH7J4JcMfsns7mib3R1teK+G92p4r4b36niv/mz36s8yjj/LOP4s4/izjOPPMo4/yzj+LOP4s92rP9u9+rN+iT/rl/izfok/65f4s7uj/dnd0Y736nivjvfqeK+O9+rPdq/+LOP4s4zjzzKOP8s4/lxOu5x2OW27V3+2e/Vn/RJ/1i/xZ/0Sf9Yv8Wd3R/uzu6Md79XxXh3v1fFeHe/VHyc3JzcnNyc3JzfnNOe04LQgtyC3ILcgt/VL/Fm/xJ/dHe3P7o52vFfHe3W8V8d7dbxXf5LcktyS3JLcktyS04rTitOK3IrcityK3NYv8Wf9En92d7Q/uzva8V4d79XxXh3v1fFe/Wlya3Jrcmtya3IbThtOG04bchtyG3Ibclu/xJ/1S/zZ3dF+dne047063qvjvTreq+O9/hqTsRibcXM7yzh+DqcdTjuctt2rn+1e/axf4mf9Ej/rl/hZv8TP7o72s7ujHe/V8V4d79XxXh3v1c92r36Wcfws4/hZxvGzjOPHOM04zThtu1c/2736Wb/Ez/olftYv8bN+iZ/dHe1nd0c73qvjvTreq+O9Ot6rHyc3J7cgtyC3ILfgtOC04LQgtyC3ILcgt/VL/Kxf4md3R/vZ3dGO9+p4r4736nivjvfqJ8mtyK3IrcityK04rTitOK3IrcityK3Jbf0SP+uX+Nnd0X52d7TjvTreq+O9Ot6r4736GXIbchtyG3IbchtOG04bThty2+7V7/olftcv8bt+id/1S/zu7mi/uzva8V4d79XxXh3v1fFe/W736ncZx+8yjt9lHL/LOH4Ppx1OO5y23avf7V79rl/id/0Sv+uX+F2/xO/ujva7u6Md79XxXh3v1fFeHe/V73avfpdx/C7j+F3G8buM49c4zTjNOM3JzcnNyc3Jbf0Sv+uX+N3d0X53d7TjvTreq+O9Ot6r4736DXILcgtyC3ILcgtOC05LTktyS3JLcktyW7/E7/olfnd3tN/dHe14r4736nivjvfqeK9+i9yK3IrcityK3IrTmtOa05rcmtya3Jrc1i/xu36J390d7Xd3Rzveq+O9Ot6r47063qvfIbchtyG3ITcYx2Acg3EMxrHtXt22e3Vbv8Rt/RK39Uvc1i9x293Rbrs72vFeHe/V8V4d79XxXt22e3WDcQzGMRjHYByDcQzGMRjHtnt12+7Vbf0St/VL3NYvcVu/xG13R7vt7mjHe3W8V8d7dbxXx3t12+7VDcYxGMdgHINxDMYxGMdgHHNyc3JzcnNyW7/Ebf0St90d7ba7ox3v1fFeHe/V8V4d79UtyA3GMRjHYByDcQzGMRjHYBxLcktyS3JLclu/xG39ErfdHe22u6Md79XxXh3v1fFeHe/VrcgNxjEYx2Acg3EMxjEYx2Aca3JrcmtyG3Jbv8Rt/RK33R3ttrujHe/V8V4d79XxXh3v1X27V3cYx2Ech3EcxnEYx2Ech3F8u1f37V7d1y9xX7/Eff0S9/VL3Hd3tPvujna8V8d7dbxXx3t1vFf37V7dYRyHcRzGcRjHYRyHcRzG8e1e3bd7dV+/xH39Evf1S9zXL3Hf3dHuuzva8V4d79XxXh3v1fFe3Z3cYByHcRzGcRjHYRyHcRzG8SC3ILcgtyC39Uvc1y9x393R7rs72vFeHe/V8V4d79XxXt2T3GAch3EcxnEYx2Ech3EcxvEityK3Ircit/VL3Ncvcd/d0e67O9rxXh3v1fFeHe/V8V7dm9xgHIdxHMZxGMdhHIdxHMbxIbchtyG3Ibf1S9zXL3Hf3dHuuzva8V4d79XxXh3v1fFePeheA8YJGCdgnIBxAsYJGCdgnKB7DbrXWL/EY/0Sj/VLPNYv8djd0R67O9rxXh3v1fFeHe/V8V496F4DxgkYJ2CcgHECxgkYJ2CcoHsNutdYv8Rj/RKP9Us81i/x2N3RHrs72vFeHe/V8V4d79XxXj3oXgPGCRgnYJyAcQLGCRgnYJygew261whyC3Jbv8Rj/RKP3R3tsbujHe/V8V4d79XxXh3v1YPuNWCcgHECxgkYJ2CcgHECxgm616B7jSK3Irf1SzzWL/HY3dEeuzva8V4d79XxXh3v1fFePeheA8YJGCdgnIBxAsYJGCdgnKB7DbrXWL/Ec/0Sz/VLPNcv8dzd0Z67O9rxXh3v1fFeHe/V8V496V4TxkkYJ2GchHESxkkYJ2GcpHtNutdcv8Rz/RLP9Us81y/x3N3Rnrs72vFeHe/V8V4d79XxXj3pXhPGSRgnYZyEcRLGSRgnYZyke02613Ryc3Jbv8Rz/RLP3R3tubujHe/V8V4d79XxXh3v1ZPuNWGchHESxkkYJ2GchHESxkm616R7zSS3JLf1SzzXL/Hc3dGeuzva8V4d79XxXh3v1fFePeleE8ZJGCdhnIRxEsZJGCdhnKR7TbrXbHJrclu/xHP9Es/dHe25u6Md79XxXh3v1fFeHe/Vk+41YZyEcRLGSRgnYZyCcQrGKbrXonut9Uu81i/xWr/Ea/0Sr90d7bW7ox3v1fFeHe/V8V4d79WL7rVgnIJxCsYpGKdgnIJxCsYputeie631S7zWL/Fav8Rr/RKv3R3ttbujHe/V8V4d79XxXh3v1YvutWCcgnEKxikYp2CcgnEKxim616J7LSc3J7f1S7zWL/Ha3dFeuzva8V4d79XxXh3v1fFeveheC8YpGKdgnIJxCsYpGKdgnKJ7LbrXSnJLclu/xGv9Eq/dHe21u6Md79XxXh3v1fFeHe/Vi+61YJyCcQrGKRinYJyCcQrGKbrXonutJrcmt/VLvNYv8drd0V67O9rxXh3v1fFeHe/V8V696F4bxmkYp2GchnEaxmkYp2GcpnttutfGL2n8ksYvafyS3t3R3rs72vFeHe/V8V4d79XxXr3pXhvGaRinYZyGcRrGaRinYZyme22618YvafySxi9p/JLe3dHeuzva8V4d79XxXh3v1fFeveleG8ZpGKdhnIZxGsZpGKdhnKZ7bbrXxi9p/JLGL2n8kt7d0d67O9rxXh3v1fFeHe/V8V696V4bxmkYp2GchnEaxmkYp2GcpnttutfGL2n8ksYvafyS3t3R3rs72vFeHe/V8V4d79XxXr3pXhvGaRinYZyGcRrGaRinYZyme22618YvafySxi9p/JLe3dHeuzva8V4d79XxXh3v1fFefeheB8YZGGdgnIFxBsYZGGdgnKF7HbrXwS8Z/JLBLxn8ktnd0T67O9rxXh3v1fFeHe/V8V596F4HxhkYZ2CcgXEGxhkYZ2CcoXsdutfBLxn8ksEvGfyS2d3RPrs72vFeHe/V8V4d79XxXn3oXgfGGRhnYJyBcQbGGRhnYJyhex2618EvGfySwS8Z/JLZ3dE+uzva8V4d79XxXh3v1fFefeheB8YZGGdgnIFxBsYZGGdgnKF7HbrXwS8Z/JLBLxn8ktnd0T67O9rxXh3v1fFeHe/V8V596F4HxhkYZ2CcgXEGxhkYZ2CcoXsdutfBL5n1S+JZvySe9Uvi2d3R8ezu6MB7DbzXwHsNvNfAe41nu9d4lnHiWcaJZxknnmWceA6nHU47nLbdazzbvcazfkk865fEs35JPOuXxLO7o+PZ3dGB9xp4r4H3Gnivgfcaz3av8SzjxLOME88yTjzLOPEYpxmnGadt9xqPkZuTm5Pb+iXxrF8Sz+6Ojmd3Rwfea+C9Bt5r4L0G3ms8QW5BbkFuQW5BbsFpwWnBaUFuSW5Jbklu65fEs35JPLs7Op7dHR14r4H3GnivgfcaeK/xFLkVuRW5FbkVuRWnFacVpzW5Nbk1uTW5rV8Sz/ol8ezu6Hh2d3TgvQbea+C9Bt5r4L3GM+Q25DbkNuQ25DactowTZxknznavcbZ7jbN+SZz1S+KsX/JrTMb3FhRnd0cH3mvgvQbea+C9/hqN0RmDMRmLsRk57XLa5bTtXuNs9xpn/ZI465fEWb8kzvolcXZ3dJzdHR14r4H3GnivgfcaeK9xtnuNs4wTZxknzjJOHCM35zTnNOc0JzcnNyc3J7f1S+KsXxJnd0fH2d3RgfcaeK+B9xp4r4H3GifILcgtyC3ILcktOS05LTktyS3JLcktyW39kjjrl8TZ3dFxdnd04L0G3mvgvQbea+C9xilyK3Ircmtya3JrTmtOa05rcmtya3Jrclu/JM76JXF2d3Sc3R0deK+B9xp4r4H3GnivcYbclnHiLuPEXcaJu4wTdxkn7jJO3GWcuNu9xt3uNe76JXHXL4m7fknc9Uvi7u7ouLs7OvBeA+818F4D7zXwXuNu9xp3GSfuMk7cZZy4yzhxL6ddTructt1r3O1e465fEnf9krjrl8RdvyTu7o6Ou7ujA+818F4D7zXwXgPvNa6Tm5Obk5uTm5Obc5pzmnOak5uTW5BbkNv6JXHXL4m7u6Pj7u7owHsNvNfAew2818B7jZvkluSW5JbkluSWnJaclpyW5FbkVuRW5LZ+Sdz1S+Lu7ui4uzs68F4D7zXwXgPvNfBe4za5Nbk1uTW5Nbk1pzWnNacNuQ25DbkNua1fEnf9kri7Ozru7o4OvNfAew2818B7DbzXsO1ew2Acg3EMxjEYx2Acg3EMxrHtXsO2ew1bvyRs/ZKw9UvC1i8J293RYbs7OvBeA+818F4D7zXwXsO2ew2DcQzGMRjHYByDcQzGMRjHtnsN2+41bP2SsPVLwtYvCVu/JGx3R4ft7ujAew2818B7DbzXwHsNc3KDcQzGMRjHYByDcQzGMRjHgtyC3ILcgtzWLwlbvyRsd0eH7e7owHsNvNfAew2818B7DUtyg3EMxjEYx2Acg3EMxjEYx4rcityK3Irc1i8JW78kbHdHh+3u6MB7DbzXwHsNvNfAew1rcoNxDMYxGMdgHINxDMYxGMeG3IbchtyG3NYvCV+/JHx3R4fv7ujAew2818B7DbzXwHsN3+41HMZxGMdhHIdxHMZxGMdhHN/uNXy71/D1S8LXLwlfvyR8/ZLw3R0dvrujA+818F4D7zXwXgPvNXy713AYx2Ech3EcxnEYx2Ech3F8u9fw7V7Djdyc3NYvCV+/JHx3R4fv7ujAew2818B7DbzXwHsND3KDcRzGcRjHYRyHcRzGcRjHg9yC3JLcktzWLwlfvyR8d0eH7+7owHsNvNfAew2818B7DS9yg3EcxnEYx2Ech3EcxnEYx4vcmtya3Jrc1i8JX78kfHdHh+/u6MB7DbzXwHsNvNfAew0fcoNxHMZxGMdhHIdxHMZxGCfoXoPuNdYviVi/JGL9koj1SyJ2d3TE7o4OvNfAew2818B7DbzXCLrXgHECxgkYJ2CcgHECxgkYJ+heg+411i+JWL8kYv2SiPVLInZ3dMTujg6818B7DbzXwHsNvNcIuteAcQLGCRgnYJyAcQLGCRgn6F6D7jWc3Jzc1i+JWL8kYndHR+zu6MB7DbzXwHsNvNfAe42gew0YJ2CcgHECxgkYJ2CcgHGC7jXoXiPJLclt/ZKI9Usidnd0xO6ODrzXwHsNvNfAew281wi614BxAsYJGCdgnIBxAsYJGCfoXoPuNZrcmtzWL4lYvyRid0dH7O7owHsNvNfAew2818B7jaB7DRgnYJyEcRLGSRgnYZyEcZLuNelec/2SyPVLItcviVy/JHJ3R0fu7ujAew2818B7DbzXwHuNpHtNGCdhnIRxEsZJGCdhnIRxku416V5z/ZLI9Usi1y+JXL8kcndHR+7u6MB7DbzXwHsNvNfAe42ke00YJ2GchHESxkkYJ2GchHGS7jXpXtPJLcht/ZLI9Usid3d05O6ODrzXwHsNvNfAew2810i614RxEsZJGCdhnIRxEsZJGCfpXpPuNYvcitzWL4lcvyRyd0dH7u7owHsNvNfAew2818B7jaR7TRgnYZyEcRLGSRgnYZyEcZLuNelec8htyG39ksj1SyJ3d3Tk7o4OvNfAew2818B7DbzXKLrXgnEKxikYp2CcgnEKxikYp+hei+611i+JWr8kav2SqPVLonZ3dNTujg6818B7DbzXwHsNvNcouteCcQrGKRinYJyCcQrGKRin6F6L7rXWL4lavyRq/ZKo9Uuidnd01O6ODrzXwHsNvNfAew281yi614JxCsYpGKdgnIJxCsYpGKfoXovutYLcgtzWL4lavyRqd0dH7e7owHsNvNfAew2818B7jaJ7LRinYJyCcQrGKRinYJyCcYruteheq8ityG39kqj1S6J2d3TU7o4OvNfAew2818B7DbzXKLrXgnEKxikYp2CcgnEKxikYp+hei+61htyG3NYvicIv6d0dHb27owPvNfBeA+818F4D7zWa7rVhnIZxGsZpGKdhnIZxGsZputeme238ksYvafySxi/p3R0dvbujA+818F4D7zXwXgPvNZrutWGchnEaxmkYp2GchnEaxmm616Z7bfySxi9p/JLGL+ndHR29u6MD7zXwXgPvNfBeA+81mu61YZyGcRrGaRinYZyGcRrGabrXpntt/JLGL2n8ksYv6d0dHb27owPvNfBeA+818F4D7zWa7rVhnIZxGsZpGKdhnIZxGsZputeme238ksYvafySxi/p3R0dvbujA+818F4D7zXwXgPvNZrutWGchnEaxmkYp2GchnEaxmm616F7HfySwS8Z/JLBL5ndHR2zu6MD7zXwXgPvNfBeA+81hu51YJyBcQbGGRhnYJyBcQbGGbrXoXsd/JLBLxn8ksEvmd0dHbO7owPvNfBeA+818F4D7zWG7nVgnIFxBsYZGGdgnIFxBsYZutehex38ksEvGfySwS+Z3R0ds7ujA+818F4D7zXwXgPvNYbudWCcgXEGxhkYZ2CcgXEGxhm616F7HfySwS8Z/JLBL5ndHR2zu6MD7zXwXgPvNfBeA+81hu51YJyBcQbGGRhnYJyBcQbGGbrXoXsd/JLBLxn8ksEvmd0dHbO7owPvNfBeA+818F4D7zWG7nVgnIFxZhknn2WcfJZx8lnGyWcZJ5/tXvPZ7jWf9UvyWb8kn/VL8lm/JJ/dHZ3P7o5OvNfEe02818R7TbzXfLZ7zWcZJ59lnHyWcfJZxsnnctrltMtp273ms91rPuuX5LN+ST7rl+Szfkk+uzs6n90dnXivifeaeK+J95p4r/ls95qPkZuTm5Obk5tzmnOac5qTm5Obk5uT2/ol+axfks/ujs5nd0cn3mvivSbea+K9Jt5rPkFuSW5JbkluSW7JaclpyWlJbkluSW5FbuuX5LN+ST67Ozqf3R2deK+J95p4r4n3mniv+TS5Nbk1uTW5Nbk1pzWnNac1uTW5DbkNua1fks/6Jfns7uh8dnd04r0m3mvivSbea+K95tnuNc8yTp5lnDzLOHmWcX6NyViMzbi5ne1e86xfkmf9kl+jMTrjewvKs7ujE+818V4T7zXxXhPvNc92r3mWcfIs4+RZxsmzjJPnctrltMtp273m2e41z/oledYvybN+SZ71S/Ls7ug8uzs68V4T7zXxXhPvNfFe8zi5Obk5uTm5Obk5pzmnBacFuQW5BbkFua1fkmf9kjy7OzrP7o5OvNfEe02818R7TbzXPEluSW5JbkluSW7JacVpxWlFbkVuRW5FbuuX5Fm/JM/ujs6zu6MT7zXxXhPvNfFeE+81T5Nbk1uTW5Nbk9tw2nDacNqQ25DbkNuQ2/oledYvybO7o/Pu7ujEe02818R7TbzXxHvNu91r3mWcvMs4eZdx8i7j5D2cdjjtcNp2r3m3e827fkne9Uvyrl+Sd/2SvLs7Ou/ujk6818R7TbzXxHtNvNe8273mXcbJu4yTdxkn7zJOXuM04zTjtO1e8273mnf9krzrl+RdvyTv+iV5d3d03t0dnXivifeaeK+J95p4r3md3JzcgtyC3ILcgtOC04LTgtyC3ILcgtzWL8m7fkne3R2dd3dHJ95r4r0m3mvivSbea94ktyK3IrcityK34rTitOK0IrcityK3Jrf1S/KuX5J3d0fn3d3RifeaeK+J95p4r4n3mnfIbchtyG3IbchtOG04bThtyG2717T1S9LWL0lbvyRt/ZK03R2dtrujE+818V4T7zXxXhPvNW271zQYx2Acg3EMxjEYx2Acg3Fsu9e07V7T1i9JW78kbf2StPVL0nZ3dNrujk6818R7TbzXxHtNvNe07V7TYByDcQzGMRjHYByDcQzGMSc3JzcnNye39UvS1i9J293Rabs7OvFeE+818V4T7zXxXtOC3GAcg3EMxjEYx2Acg3EMxrEktyS3JLckt/VL0tYvSdvd0Wm7OzrxXhPvNfFeE+818V7TitxgHINxDMYxGMdgHINxDMaxJrcmtya3Jrf1S9LWL0nb3dFpuzs68V4T7zXxXhPvNfFe04bcYByDcQzGMRjHYRyHcRzG8e1e07d7TV+/JH39kvT1S9LXL0nf3dHpuzs68V4T7zXxXhPvNfFe07d7TYdxHMZxGMdhHIdxHMZxGMe3e03f7jV9/ZL09UvS1y9JX78kfXdHp+/u6MR7TbzXxHtNvNfEe03f7jUdxnEYx2Ech3EcxnEYx2Ecd3JzcnNyc3JbvyR9/ZL03R2dvrujE+818V4T7zXxXhPvNT3IDcZxGMdhHIdxHMZxGMdhHE9yS3JLcktyW78kff2S9N0dnb67oxPvNfFeE+818V4T7zW9yA3GcRjHYRyHcRzGcRjHYRxvcmtya3Ibclu/JH39kvTdHZ2+u6MT7zXxXhPvNfFeE+81g+41YJyAcQLGCRgnYJyAcQLGCbrXoHuN9Usy1i/JWL8kY/2SjN0dnbG7oxPvNfFeE+818V4T7zWD7jVgnIBxAsYJGCdgnIBxAsYJutege431SzLWL8lYvyRj/ZKM3R2dsbujE+818V4T7zXxXhPvNYPuNWCcgHECxgkYJ2CcgHECxgm616B7jSC3ILf1SzLWL8nY3dEZuzs68V4T7zXxXhPvNfFeM+heA8YJGCdgnIBxAsYJGCdgnKB7DbrXKHIrclu/JGP9kozdHZ2xu6MT7zXxXhPvNfFeE+81g+41YJyAcQLGCRgnYJyAcQLGCbrXoHuNIbcht/VLMtYvydjd0Rm7OzrxXhPvNfFeE+818V4z6V4TxkkYJ2GchHESxkkYJ2GcpHtNutdcvyRz/ZLM9Usy1y/J3N3Rmbs7OvFeE+818V4T7zXxXjPpXhPGSRgnYZyEcRLGSRgnYZyke02611y/JHP9ksz1SzLXL8nc3dGZuzs68V4T7zXxXhPvNfFeM+leE8ZJGCdhnIRxEsZJGCdhnKR7TbrXDHILclu/JHP9kszdHZ25u6MT7zXxXhPvNfFeE+81k+41YZyEcRLGSRgnYZyEcRLGSbrXpHvNIrcit/VLMtcvydzd0Zm7OzrxXhPvNfFeE+818V4z6V4TxkkYJ2GchHESxkkYJ2GcpHtNutdcvyRr/ZKs9Uuy1i/J2t3RWbs7OvFeE+818V4T7zXxXrPoXgvGKRinYJyCcQrGKRinYJyiey2611q/JGv9kqz1S7LWL8na3dFZuzs68V4T7zXxXhPvNfFes+heC8YpGKdgnIJxCsYpGKdgnKJ7LbrXcnJzclu/JGv9kqzdHZ21u6MT7zXxXhPvNfFeE+81i+61YJyCcQrGKRinYJyCcQrGKbrXonutJLckt/VLstYvydrd0Vm7OzrxXhPvNfFeE+818V6z6F4LxikYp2CcgnEKxikYp2CconstutdqcmtyW78ka/2SrN0dnbW7oxPvNfFeE+818V4T7zWL7rVgnIJxCsYpGKdgnIZxGsZputeme238ksYvafySxi/p3R2dvbujE+818V4T7zXxXhPvNZvutWGchnEaxmkYp2GchnEaxmm616Z7bfySxi9p/JLGL+ndHZ29u6MT7zXxXhPvNfFeE+81m+61YZyGcRrGaRinYZyGcRrGabrXpntt/JLGL2n8ksYv6d0dnb27oxPvNfFeE+818V4T7zWb7rVhnIZxGsZpGKdhnIZxGsZputeme238ksYvafySxi/p3R2dvbujE+818V4T7zXxXhPvNZvutWGchnEaxmkYp2GchnEaxmm616Z7bfySxi9p/JLGL+ndHZ29u6MT7zXxXhPvNfFeE+81m+51YJyBcQbGGRhnYJyBcQbGGbrXoXsd/JLBLxn8ksEvmd0dnbO7oxPvNfFeE+818V4T7zWH7nVgnIFxBsYZGGdgnIFxBsYZutehex38ksEvGfySwS+Z3R2ds7ujE+818V4T7zXxXhPvNYfudWCcgXEGxhkYZ2CcgXEGxhm616F7HfySwS8Z/JLBL5ndHZ2zu6MT7zXxXhPvNfFeE+81h+51YJyBcQbGGRhnYJyBcQbGGbrXoXsd/JLBLxn8ksEvmd0dnbO7oxPvNfFeE+818V4T7zWH7nVgnIFxBsYZGGdgnIFxBsYZutehex38ksEvGfySwS+Z3R2ds7ujE++18F4L77XwXgvvtZ7tXutZxqlnGaeeZZx6lnHqeTjtcNrhtO1e69nutZ71S+pZv6Se9UvqWb+knt0dXc/uji6818J7LbzXwnstvNd6tnutZxmnnmWcepZx6lnGqcc4zTjNOG2713q2e61n/ZJ61i+pZ/2SetYvqWd3R9ezu6ML77XwXgvvtfBeC++1Hic3JzcnNye3ILfgtOC04LQgtyC3ILcgt/VL6lm/pJ7dHV3P7o4uvNfCey2818J7LbzXepLcktyS3IrcityK04rTitOK3IrcityK3NYvqWf9knp2d3Q9uzu68F4L77XwXgvvtfBe62lya3IbchtyG3IbThtOG04bchtyG3Jbv6TO+iV11i+ps7uj6+zu6MJ7LbzXX2MyFmMzbm5nGafOMk6dZZxfozFy2uG0w2nbvdbZ7rXO+iV11i+ps35JnfVL6uzu6Dq7O7rwXgvvtfBeC++18F7rbPdaZxmnzjJOnWWcOss4dYzTjNOM07Z7rWPk5uTm5LZ+SZ31S+rs7ug6uzu68F4L77XwXgvvtfBe6wS5BbkFuQW5BbkFpwWnBacFuSW5Jbklua1fUmf9kjq7O7rO7o4uvNfCey2818J7LbzXOkVuRW5FbkVuRW7FacVpxWlNbk1uTW5NbuuX1Fm/pM7ujq6zu6ML77XwXgvvtfBeC++1zpDbkNuQ25DbkNtw2jJO3WWcutu91t3ute76JXXXL6m7fknd9Uvq7u7ours7uvBeC++18F4L77XwXutu91p3GafuMk7dZZy6yzh1D6ddTructt1r3e1e665fUnf9krrrl9Rdv6Tu7o6uu7ujC++18F4L77XwXgvvte52r3WXceou49Rdxqlr5Oac5pzmnObk5uTm5Obktn5J3fVL6u7u6Lq7O7rwXgvvtfBeC++18F7rBrkFuQW5BbkluSWnJaclpyW5JbkluSW5rV9Sd/2Surs7uu7uji6818J7LbzXwnstvNe6RW5FbkVuTW5Nbs1pzWnNaU1uTW5Nbk1u65fUXb+k7u6Orru7owvvtfBeC++18F4L77XukBuMYzCOwTgG4xiMYzCOwTi23WvZdq9l65eUrV9Stn5J2folZbs7umx3Rxfea+G9Ft5r4b0W3mvZdq9lMI7BOAbjGIxjMI7BOAbj2HavZdu9lq1fUrZ+Sdn6JWXrl5Tt7uiy3R1deK+F91p4r4X3WnivZU5uMI7BOAbjGIxjMI7BOAbjmJObk1uQW5Db+iVl65eU7e7ost0dXXivhfdaeK+F91p4r2VJbjCOwTgG4xiMYzCOwTgG41iSW5FbkVuR2/olZeuXlO3u6LLdHV14r4X3WnivhfdaeK9lTW4wjsE4BuMYjGMwjsE4BuPYkNuQ25DbkNv6JWXrl5Tt7uiy3R1deK+F91p4r4X3Wniv5du9lsM4DuM4jOMwjsM4DuM4jOPbvZZv91q+fkn5+iXl65eUr19Svrujy3d3dOG9Ft5r4b0W3mvhvZZv91oO4ziM4zCOwzgO4ziM4zCOb/davt1r+fol5euXlK9fUr5+Sfnuji7f3dGF91p4r4X3Wnivhfda7uQG4ziM4zCOwzgO4ziM4zCOB7kFuQW5BbmtX1K+fkn57o4u393RhfdaeK+F91p4r4X3Wp7kBuM4jOMwjsM4DuM4jOMwjhe5FbkVuRW5rV9Svn5J+e6OLt/d0YX3WnivhfdaeK+F91re5AbjOIzjMI7DOA7jOIzjMI4PuQ25DbkNua1fUrF+ScXujq7Y3dGF91p4r4X3WnivhfdaQfcaME7AOAHjBIwTME7AOAHjBN1r0L3G+iUV65dUrF9SsX5Jxe6Ortjd0YX3WnivhfdaeK+F91pB9xowTsA4AeMEjBMwTsA4AeME3WvQvYaRm5Pb+iUV65dU7O7oit0dXXivhfdaeK+F91p4rxV0rwHjBIwTME7AOAHjBIwTME7QvQbdayS5JbmtX1KxfknF7o6u2N3RhfdaeK+F91p4r4X3WkH3GjBOwDgB4wSMEzBOwDgB4wTda9C9RpNbk9v6JRXrl1Ts7uiK3R1deK+F91p4r4X3WnivFXSvAeMEjBMwTsA4AeMEjBMwTtK9Jt1rrl9SuX5J5folleuXVO7u6MrdHV14r4X3WnivhfdaeK+VdK8J4ySMkzBOwjgJ4ySMkzBO0r0m3WuuX1K5fknl+iWV65dU7u7oyt0dXXivhfdaeK+F91p4r5V0rwnjJIyTME7COAnjJIyTME7SvSbdazq5ObmtX1K5fknl7o6u3N3RhfdaeK+F91p4r4X3Wkn3mjBOwjgJ4ySMkzBOwjgJ4yTda9K9ZpJbktv6JZXrl1Tu7ujK3R1deK+F91p4r4X3WnivlXSvCeMkjJMwTsI4CeMkjJMwTtK9Jt1rNrk1ua1fUrl+SeXujq7c3dGF91p4r4X3WnivhfdaSfeaME7COAXjFIxTME7BOAXjFN1r0b3W+iVV65dUrV9StX5J1e6Ortrd0YX3WnivhfdaeK+F91pF91owTsE4BeMUjFMwTsE4BeMU3WvRvdb6JVXrl1StX1K1fknV7o6u2t3RhfdaeK+F91p4r4X3WkX3WjBOwTgF4xSMUzBOwTgF4xTda9G9lpNbkNv6JVXrl1Tt7uiq3R1deK+F91p4r4X3WnivVXSvBeMUjFMwTsE4BeMUjFMwTtG9Ft1rFbkVua1fUrV+SdXujq7a3dGF91p4r4X3WnivhfdaRfdaME7BOAXjFIxTME7BOAXjFN1r0b3WkNuQ2/olVeuXVO3u6KrdHV14r4X3WnivhfdaeK/VdK8N4zSM0zBOwzgN4zSM0zBO07023WvjlzR+SeOXNH5J7+7o6t0dXXivhfdaeK+F91p4r9V0rw3jNIzTME7DOA3jNIzTME7TvTbda+OXNH5J45c0fknv7ujq3R1deK+F91p4r4X3Wniv1XSvDeM0jNMwTsM4DeM0jNMwTtO9Nt1r45c0fknjlzR+Se/u6OrdHV14r4X3WnivhfdaeK/VdK8N4zSM0zBOwzgN4zSM0zBO07023WvjlzR+SeOXNH5J7+7o6t0dXXivhfdaeK+F91p4r9V0rw3jNIzTME7DOA3jNIzTME7TvTbda+OXNH5J45c0fsns7uia3R1deK+F91p4r4X3WnivNXSvA+MMjDMwzsA4A+MMjDMwztC9Dt3r4JcMfsnglwx+yezu6JrdHV14r4X3WnivhfdaeK81dK8D4wyMMzDOwDgD4wyMMzDO0L0O3evglwx+yeCXDH7J7O7omt0dXXivhfdaeK+F91p4rzV0rwPjDIwzMM7AOAPjDIwzMM7QvQ7d6+CXDH7J4JcMfsns7uia3R1deK+F91p4r4X3WnivNXSvA+MMjDMwzsA4A+MMjDMwztC9Dt3r4JcMfsnglwx+yezu6JrdHV14r4X3WnivhfdaeK81dK8D4wyMMzDOwDgD4wyMMzDObPfaz3av/axf0s/6Jf2sX9LP+iX97O7ofnZ3dOO9Nt5r47023mvjvfaz3Ws/yzj9LOP0s4zTzzJOP4fTDqcdTtvutZ/tXvtZv6Sf9Uv6Wb+kn/VL+tnd0f3s7ujGe22818Z7bbzXxnvtZ7vXfpZx+lnG6WcZp59lnH6M04zTnNOc3JzcnNyc3NYv6Wf9kn52d3Q/uzu68V4b77XxXhvvtfFe+wlyC3ILcgtyC3ILTktOS05LcktyS3JLclu/pJ/1S/rZ3dH97O7oxnttvNfGe22818Z77afIrcityK3IrcitOa05rTmtya3JrcmtyW39kn7WL+lnd0f3s7ujG++18V4b77XxXhvvtZ8htyG3IbdlnD7LOH2Wcfos4/RZxumz3Wuf7V5/jclYjM04O+7u6D67O7rxXn+NxuiMwZiMxdiMm9tZxumzjNPnctrltMtp27322e61z/olfdYv6bN+SZ/1S/rs7ug+uzu68V4b77XxXhvvtfFe+2z32sfIzcnNyc3JzTnNOc05zcnNyc3Jzclt/ZI+65f02d3RfXZ3dOO9Nt5r47023mvjvfYJcktyS3JLcktyS05LTktOS3JLcktyK3Jbv6TP+iV9dnd0n90d3XivjffaeK+N99p4r32a3Jrcmtya3JrcmtOa05rTmtya3IbchtzWL+mzfkmf3R3dZ3dHN95r47023mvjvTbea9/tXvsu4/Rdxum7jNN3GafvMk7fZZy+yzh9t3vtu91r3/VL+q5f0nf9kr7rl/Td3dF9d3d047023mvjvTbea+O99t3ute8yTt9lnL7LOH2XcfpeTrucdjltu9e+2732Xb+k7/olfdcv6bt+Sd/dHd13d0c33mvjvTbea+O9Nt5rXyc3JzcnNyc3JzfnNOe04LQgtyC3ILcgt/VL+q5f0nd3R/fd3dGN99p4r4332nivjffaN8ktyS3JLcktyS05rTitOK3IrcityK3Ibf2SvuuX9N3d0X13d3TjvTbea+O9Nt5r4732bXJrcmtya3JrchtOG04bThtyG3IbchtyW7+k7/olfXd3dNvujm6818Z7bbzXxnttvNe27V7bYByDcQzGMRjHYByDcQzGse1e27Z7bVu/pG39krb1S9rWL2nb3dFtuzu68V4b77XxXhvvtfFe27Z7bYNxDMYxGMdgHINxDMYxGMe2e23b7rVt/ZK29Uva1i9pW7+kbXdHt+3u6MZ7bbzXxnttvNfGe21zcoNxDMYxGMdgHINxDMYxGMeC3ILcgtyC3NYvaVu/pG13R7ft7ujGe22818Z7bbzXxnttS3KDcQzGMRjHYByDcQzGMRjHityK3IrcmtzWL2lbv6Rtd0e37e7oxnttvNfGe22818Z7bRtyg3EMxjEYx2Acg3EMxjEYx4bctnttX7+kff2S9vVL2tcvad/d0e27O7rxXhvvtfFeG++18V7bt3tth3EcxnEYx2Ech3EcxnEYx7d7bd/utX39kvb1S9rXL2lfv6R9d0e37+7oxnttvNfGe22818Z7bd/utR3GcRjHYRyHcRzGcRjHYRx3cnNyc3Jzclu/pH39kvbdHd2+u6Mb77XxXhvvtfFeG++1PcgNxnEYx2Ech3EcxnEYx2EcT3JLcktyS3Jbv6R9/ZL23R3dvrujG++18V4b77XxXhvvtb3IDcZxGMdhHIdxHMZxGMdhHG9ya3JrcmtyW7+kff2S9t0d3b67oxvvtfFeG++18V4b77V9yA3GcRjHYRyHcQLGCRgnYJygew2611i/pGP9ko71SzrWL+nY3dEduzu68V4b77XxXhvvtfFeO+heA8YJGCdgnIBxAsYJGCdgnKB7DbrXWL+kY/2SjvVLOtYv6djd0R27O7rxXhvvtfFeG++18V476F4DxgkYJ2CcgHECxgkYJ2CcoHsNutdwcnNyW7+kY/2Sjt0d3bG7oxvvtfFeG++18V4b77WD7jVgnIBxAsYJGCdgnIBxAsYJutege40ktyS39Us61i/p2N3RHbs7uvFeG++18V4b77XxXjvoXgPGCRgnYJyAcQLGCRgnYJygew2612hyG3Jbv6Rj/ZKO3R3dsbujG++18V4b77XxXhvvtZPuNWGchHESxkkYJ2GchHESxkm616R7zfVLOtcv6Vy/pHP9ks7dHd25u6Mb77XxXhvvtfFeG++1k+41YZyEcRLGSRgnYZyEcRLGSbrXpHvN9Us61y/pXL+kc/2Szt0d3bm7oxvvtfFeG++18V4b77WT7jVhnIRxEsZJGCdhnIRxEsZJuteke80gtyC39Us61y/p3N3Rnbs7uvFeG++18V4b77XxXjvpXhPGSRgnYZyEcRLGSRgnYZyke0261yxyK3Jbv6Rz/ZLO3R3dubujG++18V4b77XxXhvvtZPuNWGchHESxkkYJ2GchHESxkm616R7zSG3Ibf1SzrXL+nc3dGduzu68V4b77XxXhvvtfFeu+heC8YpGKdgnIJxCsYpGKdgnKJ7LbrXWr+ka/2SrvVLutYv6drd0V27O7rxXhvvtfFeG++18V676F4LxikYp2CcgnEKxikYp2Cconstutdav6Rr/ZKu9Uu61i/p2t3RXbs7uvFeG++18V4b77XxXrvoXgvGKRinYJyCcQrGKRinYJyiey261wpyC3Jbv6Rr/ZKu3R3dtbujG++18V4b77XxXhvvtYvutWCcgnEKxikYp2CcgnEKxim616J7rSK3Irf1S7rWL+na3dFduzu68V4b77XxXhvvtfFeu+heC8YpGKdgnIJxCsYpGKdgnKJ7LbrXwi9p/JLGL2n8kt7d0d27O7rxXhvvtfFeG++18V676V4bxmkYp2GchnEaxmkYp2GcpnttutfGL2n8ksYvafyS3t3R3bs7uvFeG++18V4b77XxXrvpXhvGaRinYZyGcRrGaRinYZyme22618YvafySxi9p/JLe3dHduzu68V4b77XxXhvvtfFeu+leG8ZpGKdhnIZxGsZpGKdhnKZ7bbrXxi9p/JLGL2n8kt7d0d27O7rxXhvvtfFeG++18V676V4bxmkYp2GchnEaxmkYp2GcpnttutfGL2n8ksYvafyS3t3R3bs7uvFeG++18V4b77XxXrvpXhvGaRinYZyGcRrGGRhnYJyhex2618EvGfySwS8Z/JLZ3dE9uzu68V4b77XxXhvvtfFee+heB8YZGGdgnIFxBsYZGGdgnKF7HbrXwS8Z/JLBLxn8ktnd0T27O7rxXhvvtfFeG++18V576F4HxhkYZ2CcgXEGxhkYZ2CcoXsdutfBLxn8ksEvGfyS2d3RPbs7uvFeG++18V4b77XxXnvoXgfGGRhnYJyBcQbGGRhnYJyhex2618EvGfySwS8Z/JLZ3dE9uzu68V4b77XxXhvvtfFee+heB8YZGGdgnIFxBsYZGGdgnKF7HbrXwS8Z/JLBLxn8ktnd0T27O7rxXhvvtfFeG++18V57tnudZxlnnmWceZZx5lnGmWcZZ55lnHmWcebZ7nWe7V7nWb9knvVL5lm/ZJ71S+bZ3dHz7O7owXsdvNfBex2818F7nWe713mWceZZxplnGWeeZZx5LqddTructt3rPNu9zrN+yTzrl8yzfsk865fMs7uj59nd0YP3Onivg/c6eK+D9zqPk5uTm5Obk5uTm3Oac5pzmpNbkFuQW5Db+iXzrF8yz+6Onmd3Rw/e6+C9Dt7r4L0O3us8SW5JbkluSW5JbslpyWnJaUVuRW5FbkVu65fMs37JPLs7ep7dHT14r4P3Onivg/c6eK/zNLk1uTW5Nbk1uTWnNacNpw25DbkNuQ25rV8yz/ol8+zu6Hl2d/TgvQ7e6+C9Dt7r4L3O2e51zjLOrzEZi7EZOe1w2uG07V5/jcbojMGYjMX43oLm7O7owXsdvNfBex2818F7nbPd65xlnDnLOHOWceYs48wxTjNOM07b7nXOdq9z1i+Zs37JnPVL5qxfMmd3R8/Z3dGD9zp4r4P3Onivg/c6x8nNyc3JzcktyC04LTgtOC3ILcgtyC3Ibf2SOeuXzNnd0XN2d/TgvQ7e6+C9Dt7r4L3OSXJLcktyK3IrcitOK04rTityK3IrcityW79kzvolc3Z39JzdHT14r4P3Onivg/c6eK9zmtya3IbchtyG3IbThtOG04bchtyG3NYvmbt+ydz1S+bu7ui5uzt68F4H73XwXgfvdfBe5273OncZZ+4yztxlnLnLOHMPpx1OO5y23evc7V7nrl8yd/2SueuXzF2/ZO7ujp67u6MH73XwXgfvdfBeB+917navc5dx5i7jzF3GmbuMM9c4zTjNOG2717lGbk5uTm7rl8xdv2Tu7o6eu7ujB+918F4H73XwXgfvdW6QW5BbkFuQW5BbcFpwWnBakFuSW5Jbktv6JXPXL5m7u6Pn7u7owXsdvNfBex2818F7nVvkVuRW5FbkVuRWnFacVpzW5Nbk1uTW5LZ+ydz1S+bu7ui5uzt68F4H73XwXgfvdfBe5w65DbkNuQ25DbkNp8E4BuPYdq9j272OrV8ytn7J2PolY+uXjO3u6LHdHT14r4P3Onivg/c6eK9j272OwTgG4xiMYzCOwTgG4xiMY9u9jm33OrZ+ydj6JWPrl4ytXzK2u6PHdnf04L0O3uvgvQ7e6+C9jm33OgbjGIxjMI7BOAbjGIxjMI45uTm5Obk5ua1fMrZ+ydjujh7b3dGD9zp4r4P3Onivg/c6FuQG4xiMYzCOwTgG4xiMYzCOJbkluSW5JbmtXzK2fsnY7o4e293Rg/c6eK+D9zp4r4P3OlbkBuMYjGMwjsE4BuMYjGMwjjW5Nbk1uTW5rV8ytn7J2O6OHtvd0YP3Onivg/c6eK+D9zo25AbjOIzjMI7DOA7jOIzjMI5v9zq+3ev4+iXj65eMr18yvn7J+O6OHt/d0YP3Onivg/c6eK+D9zq+3es4jOMwjsM4DuM4jOMwjsM4vt3r+Hav4+uXjK9fMr5+yfj6JeO7O3p8d0cP3uvgvQ7e6+C9Dt7ruJMbjOMwjsM4DuM4jOMwjsM47uTm5BbkFuS2fsn4+iXjuzt6fHdHD97r4L0O3uvgvQ7e63iSG4zjMI7DOA7jOIzjMI7DOJ7kVuRW5Fbktn7J+Pol47s7enx3Rw/e6+C9Dt7r4L0O3ut4kxuM4zCOwzgO4ziM4zCOwzg+5DbkNuQ25LZ+yfj6JeO7O3p8d0cP3uvgvQ7e6+C9Dt7rBN1rwDgB4wSMEzBOwDgB4wSME3SvQfca65dMrF8ysX7JxPolE7s7emJ3Rw/e6+C9Dt7r4L0O3usE3WvAOAHjBIwTME7AOAHjBIwTdK9B9xrrl0ysXzKxfsnE+iUTuzt6YndHD97r4L0O3uvgvQ7e6wTda8A4AeMEjBMwTsA4AeMEjBN0r0H3GkFuQW7rl0ysXzKxu6Mndnf04L0O3uvgvQ7e6+C9TtC9BowTME7AOAHjBIwTME7AOEH3GnSvUeRW5LZ+ycT6JRO7O3pid0cP3uvgvQ7e6+C9Dt7rBN1rwDgB4wSMEzBOwDgB4wSME3SvQfcaQ25DbuuXTK5fMrm7oyd3d/TgvQ7e6+C9Dt7r4L1O0r0mjJMwTsI4CeMkjJMwTsI4SfeadK+5fsnk+iWT65dMrl8yubujJ3d39OC9Dt7r4L0O3uvgvU7SvSaMkzBOwjgJ4ySMkzBOwjhJ95p0r2nk5uS2fsnk+iWTuzt6cndHD97r4L0O3uvgvQ7e6yTda8I4CeMkjJMwTsI4CeMkjJN0r0n3mkluSW7rl0yuXzK5u6Mnd3f04L0O3uvgvQ7e6+C9TtK9JoyTME7COAnjJIyTME7COEn3mnSv2eTW5LZ+yeT6JZO7O3pyd0cP3uvgvQ7e6+C9Dt7rJN1rwjgJ4ySMkzBOwjgJ4ySMU3SvRfda65dMrV8ytX7J1PolU7s7emp3Rw/e6+C9Dt7r4L0O3usU3WvBOAXjFIxTME7BOAXjFIxTdK9F91rrl0ytXzK1fsnU+iVTuzt6andHD97r4L0O3uvgvQ7e6xTda8E4BeMUjFMwTsE4BeMUjFN0r0X3Wk5uTm7rl0ytXzK1u6Ondnf04L0O3uvgvQ7e6+C9TtG9FoxTME7BOAXjFIxTME7BOEX3WnSvleSW5LZ+ydT6JVO7O3pqd0cP3uvgvQ7e6+C9Dt7rFN1rwTgF4xSMUzBOwTgF4xSMU3SvRfdaTW5NbuuXTK1fMrW7o6d2d/TgvQ7e6+C9Dt7r4L1O0b0WjFMwTsM4DeM0jNMwTsM4TffadK+NX9L4JY1f0vglvbujp3d39OC9Dt7r4L0O3uvgvU7TvTaM0zBOwzgN4zSM0zBOwzhN99p0r41f0vgljV/S+CW9u6Ond3f04L0O3uvgvQ7e6+C9TtO9NozTME7DOA3jNIzTME7DOE332nSvjV/S+CWNX9L4Jb27o6d3d/TgvQ7e6+C9Dt7r4L1O0702jNMwTsM4DeM0jNMwTsM4TffadK+NX9L4JY1f0vglvbujp3d39OC9Dt7r4L0O3uvgvU7TvTaM0zBOwzgN4zSM0zBOwzhN99p0r41f0vgljV/S+CW9u6Ond3f04L0O3uvgvQ7e6+C9ztC9DowzMM7AOAPjDIwzMM7AOEP3OnSvg18y+CWDXzL4JbO7o2d2d/TgvQ7e6+C9Dt7r4L3O0L0OjDMwzsA4A+MMjDMwzsA4Q/c6dK+DXzL4JYNfMvgls7ujZ3Z39OC9Dt7r4L0O3uvgvc7QvQ6MMzDOwDgD4wyMMzDOwDhD9zp0r4NfMvglg18y+CWzu6Nndnf04L0O3uvgvQ7e6+C9ztC9DowzMM7AOAPjDIwzMM7AOEP3OnSvg18y+CWDXzL4JbO7o2d2d/TgvQ7e6+C9Dt7r4L3O0L0OjDMwzsA4A+MMjDMwzsA4Q/c6dK+DXzL4JYNfMuuXnOfZ5dFf83sP+prfb+bXbDK7zCFzylwyt8zDvLjzNR+Z5dwj5x45d7vYrzllLplb5mFe6eRrfu9GX/N7Ofqa3+/w1+wyh8wpc8ncMg/zItDXfGS+Msu5JueanLsF7ddcMrfMku+KKF/zkfmS++6Z/prl++ySr0u+Lvm65OuSb0i+IfmG5BuSb8i5IeeGnBuSb0i+Ifmm5Lt2ytd8ZTZy3+XTX7N8n1PyTck3Jd+UfEvyLcm3JN+SfEvyLTm35NySc0vyLcm3Jd+WfFdZ+ZpNZif33Uj9Ncv3uSXflnxb8h3JdyTfkXxH8h3JdyTfkXNHzh05d8j3PI/MR+Yrs8nsMsfmfnZN9dfM9xnJ9msmXzTbr/nIfGU2mV3mkDlllnOPnHvk3Eu+5x6Zr8wms8scMufmfnZ39dfM9xnz9tdsj8xH5iuzyewyh8wpc8ks55qc63KuS74u+brk65Kvh8wpc5H7LrT+muX7HJJvSL4h+YbkG5JvSL4h+YbkG5JvyLkp56acm5JvSr4p+abkmylzydzkvluuf80l3+eSfEvyLcm3JN+SfEvyLcm3JN+SfFvObTm35dyWfFvybcm3Jd8umVvmIfddff01y/d5JN+RfEfyHcl3JN+RfEfyHfK9zyPzkfnKbDKT731C5pS5ZG6Z+btwD/e6e7jXXblfXblfXblf4fN+zSlzydwyk++9j8xHZjn3yrlXzr3ke2/KXDK3zPxduPbIzL3uGve6K/erK/erK/crJN+vuWRumSVfl3xd8nXJ1+Vcl3NdznXJ1yVfl3xd8o1H5iMz97ob3Ouu3K+u3K+u3K8wf79myTck35R8U/JNyTcl35RzU85NOTcl35R8U/ItybeOzFdm7nW3uNdduV9duV9duV+hA3/Nkm9Lvi35tuTbkm9Lvi3ntpzbcm5Lvi35juQ7ku9cmU1m7nV3uNdduV9duV9duV/hCP+6OT2PzEfmK7PJ7DKHzClzydwyk6+dR+Yj85XZZHaZudfZ4V5ncr8yuV+Z3K8Qh7/mI/OV2WR2mUPmlFnOFR404UEz8jU7Ml+ZTWaXOWTmXmfGvc7kfmVyvzK5X2ETf82Sr0u+woMmPGjCgyY8aMKDJjxowoMWkm9IviH5huQbIXPKzL3Ognudyf3K5H5lcr9CMf6aJd+UfIUHTXjQhAdNeNCEB0140IQHrSTfknxL8i3Jt1Lmkpl7nRX3OpP7lcn9yuR+hXf8NUu+LfkKD5rwoAkPmvCgCQ+a8KAJD9pIviP5juQ7ku+UzC0z9zp/uNe53K9c7lcu9ytk5K85ZE6ZS+aWmXxdeNCFB1140IUH/ZCvn5A5ZS6ZW2b+LvjlXueXe53L/crlfuVyv8JQ/ppT5pK5ZSZfFx504UEXHnThQRcedCNft5S5ZG6Z+bvg/sjMvc6de53L/crlfuVyv0Jb/polX5d8hQddeNCFB1140IUHXXjQhQc9JN+QfEPyDck3H5mPzNzrPLnXudyvXO5XLvcrXOavWfJNyVd40IUHXXjQhQddeNCFB1140EvyLcm3JN+WfPvIfGXmXufNvc7lfuVyv3K5XyE4f82S70i+woMuPOjCgy486MKDLjzowoM+kq/07fE8Mh+Zr8wmM/e6eLjXhdyvQu5XIferkL49pG8P6dtDeDCEB0N4MIQHQ3gwhAdDeDCkbw/p2+Mema/MJrPLzL0uLve6kPtVyP0q5H4V0reH9O0hfXsID4bwYAgPhvBgCA+G8GAID4b07SF9e7jk65Kvu8whM/e6cO51IferkPtVyP0qpG8P6dtD+vYQHgzhwRAeDOHBEB4M4cEQHgzp20P69kjJNyXfDJlTZu51kdzrQu5XIferkPtVSN8e0reH9O0hPBjCgyE8GMKDITwYwoMhPBjSt4f07dGSb0u+nTKXzNzrornXhdyvQu5XIferkL49pG8P6dtDeDCEB0N4MIQHU3gwhQdTeDClb0/p2/MJmVPmkrll5l6Xh3tdyv0q5X6Vcr9K6dtT+vaUvj2FB1N4MIUHU3gwhQdTeDCFB1P69pS+PW/KXDK3zPxdSONel8a9LuV+lXK/SrlfpfTtKX17St+ewoMpPJjCgyk8mMKDKTyYwoMpfXtK354u+brk6/xdyHhk5l6Xwb0u5X6Vcr9KuV+l9O0pfXtK357Cgyk8mMKDKTyYwoMpPJjCgyl9e0rfnin5puRbj8xHZu51WdzrUu5XKferlPtVSt+e0ren9O0pPJjCgyk8mMKDKTyYwoMpPJjSt6f07dmS70i+c2S+MnOvy+Fel3K/SrlfpdyvUvr2lL69pG8v4cESHizhwRIeLOHBEh4s4cGSvr2kb6/zyHxkvjKbzNzr6nCvK7lfldyvSu5XJX17Sd9e0reX8GAJD5bwYAkPlvBgCQ+W8GBJ317St5cdma/MJrPLzL2ujHtdyf2q5H5Vcr8q6dtL+vaSvr2EB0t4sIQHS3iwhAdLeLCEB0v69pK+vULyDck3XOaQmXtdBfe6kvtVyf2q5H5V0reX9O0lfXsJD5bwYAkPlvBgCQ+W8GAJD5b07SV9e5XkW5JvhcwpM/e6Ku51JferkvtVyf2qpG8v6dtL+vYSHizhwRIeLOHBEh4s4cESHizp20v69hrJdyTfSZlLZu51NdzrWu5XLferlvtVS9/e0re39O0tPNjCgy082MKDLTzYwoMtPNjSt7f07S3+VYt/1eJftfhXfbjX9eVe13K/arlftdyvWvr2lr69pW9v4cEWHmzhwRYebOHBFh5s4cGWvr2lb2/xr1r8qxb/qsW/aude1869ruV+1XK/arlftfTtLX17S9/ewoMtPNjCgy082MKDLTzYwoMtfXtL397iX7X4Vy3+VYt/1cm9rpN7Xcv9quV+1XK/aunbW/r2lr69hQdbeLCFB1t4sIUHW3iwhQdb+vaWvr3Fv2rxr1r8qxb/qpt7XTf3upb7Vcv9quV+1dK3t/TtLX17Cw+28GALD7bwYAsPtvBgCw+29O0tfXuLfzXiX434VyP+1Tzc6+bhXjdyvxq5X43cr0b69pG+faRvH+HBER4c4cERHhzhwREeHOHBkb59pG8f8a9G/KsR/2rEv5rLvW4u97qR+9XI/WrkfjXSt4/07SN9+wgPjvDgCA+O8OAID47w4AgPjvTtI337iH814l+N+Fcj/tU497px7nUj96uR+9XI/Wqkbx/p20f69hEeHOHBER4c4cERHhzhwREeHOnbR/r2Ef9qxL8a8a9G/KtJ7nWT3OtG7lcj96uR+9VI3z7St4/07SM8OMKDIzw4woMjPDjCgyM8ONK3j/TtI/7ViH814l+N+FfT3OumudeN3K9G7lcj96uRvn2kbx/p20d4cIQHR3hwhAcHHjwPPHgeePA89O3noW8/D/7VefCvzoN/dR78q/Pssvivee91R/z2I377Eb/9iN9+xG8/D337eeDB88CD54EHzwMPnufKuVfOvXIufft56NvPg391Hvyr8+BfnQf/6jy7Qf6cZ1fIf83yfeZ+dcRvP+K3H/Hbz0Pffh548Dzw4HlM8nXJ1+Vcl3NdznXJ1yVfl3xd8sW/Og/+1Xl2rfzXfMg95Psckm9IviH5huQbkm9IviH5puSbkm/KuSnnppybkm9Kvin5puSLf3Ue/Kvz7K75r/mSe8n3uSTfknxL8i3JtyTfknxb8m3JtyXflnNbzm05tyXflnxb8m3JF//qPPhX59kF9F+zkfvI93kk35F8R/IdyZe+/Rx48Bx48Bx48Bx48Bx48OsHReaUmXwPffs5+Fdf/w+Zj8xX5r3X/fo/e6874rcf8duP+O1H/PYjfvs59O3nwIPnwIPnwIPnwIPnXDn3yrlXzqVvP4e+/Rz8q3Pwr87BvzoH/+qcXVX/Ne+97ojffsRvP+K3H/Hbj/jt57jk65KvS74u+brk63Kuy7ku57rkG5JvSL4h+eJfnYN/dc7ur/+ak9xDvs8h+Ybkm5JvSr4p+abkm5JvSr4p+aacm3Juyrkl+ZbkW5JvSb74V+fgX52zS+2/5iL3ku9zSb4t+bbk25JvS74t+bbk25JvS74t57acO3LuSL4j+Y7kO5Iv/tU5+Ffn7Kb7r7nJXe5X4rcf8duP+O1H/PZz6dvPhQfPhQfPhQfPhQfPfeTcI+ceOZe+/Vz69nPxr87FvzoX/+pc/KtzD/e6e7jXid9+xG8/4rcf8duP+O3n0refCw+eCw+eCw+eCw+ea3Kuybkm59K3n0vffi7+1bn4V+fiX52Lf3Wuca+7zr1O/PYjfvsRv/2I337Ebz/XJV+XfF3ydck3JN+Qc0PODTk3JN+QfEPyDckX/+pc/Ktzk3vdTe514rcf8duP+O1H/PYjfvu5Kfmm5JuSb0m+JfmWnFtybsm5JfmW5FuSb0m++Ffn4l+d29zrbnOvE7/9iN9+xG8/4rcf8dvPbcm3Jd+RfEfyHcl35NyRc0fOHcl3JN+RfPGvjuFfHcO/OvZwr7OHe5347Uf89iN++xG//Yjffoy+/ZjwoAkPmvCgCQ+a8KAJD5rwoNG3H6NvP4Z/dQz/6hj+1TH8q2OXe51d7nXitx/x24/47Uf89iN++zH69mPCgyY8aMKDJjxowoMmPGjCg0bffswkX5d8XfLFvzqGf3XMudeZc68Tv/2I337Ebz/itx/x24+F5Cs8aMKDJjxowoMmPGjCgyY8aCH5puSbkm9KvvhXx/CvjiX3OkvudeK3H/Hbj/jtR/z2I377sZJ8hQdNeNCEB0140IQHTXjQhAetJd+WfFvybckX/+oY/tWx5l5nzb1O/PYjfvsRv/2I337Ebz82kq/woAkPmvCgCQ+a8KAJD7rwoNO3H6dvP45/dRz/6jj+1XH8q+MP9zp/uNeJ337Ebz/itx/x24/47cfp248LD7rwoAsPuvCgCw+68KALDzp9+3H69uP4V8fxr47jXx3Hvzp+udf55V4nfvsRv/2I337Ebz/itx+nbz8uPOjCgy486MKDLjzowoMuPOgu+brk65KvS774V8fxr4479zoP7nXitx/x24/47Uf89iN++/GQfIUHXXjQhQddeNCFB1140IUHPSXflHxT8k3JF//qOP7V8eJe58W9Tvz2I377Eb/9iN9+xG8/XpKv8KALD7rwoAsPuvCgCw+68KC35NuSb0u+LfniXx3Hvzo+3Ot8uNeJ337Ebz/itx/x24/47cdH8hUeDOHBEB4M4cEQHgzhwRAeDOnbQ/r2wL86gX91Av/qBP7VicO9Lg73OvHbj/jtR/z2I377Eb/9hPTtITwYwoMhPBjCgyE8GMKDITwY0reH9O2Bf3UC/+oE/tUJ/KsTxr0ujHud+O1H/PYjfvsRv/2I335C+vYQHgzhwRAeDOHBEB4M4cEQHgzp20P69gjJNyRf/KsT+FcngntdBPc68duP+O1H/PYjfvsRv/2E9O0hPBjCgyE8GMKDITwYwoMhPBjSt4f07VGSb0m++Fcn8K9OFPe6KO514rcf8duP+O1H/PYjfvsJ6dtDeDCEB0N4MIQHQ3gwhAdDeDCkbw/p22Mk35F88a9O4F+dGO51MdzrxG8/4rcf8duP+O1H/PaT0ren8GAKD6bwYAoPpvBgCg+m8GBK357Styf+1Un8q5P4Vyfxr04e7nV5uNeJ337Ebz/itx/x24/47Selb0/hwRQeTOHBFB5M4cEUHkzhwZS+PaVvT/yrk/hXJ/GvTuJfnTTudWnc68RvP+K3H/Hbj/jtR/z2k9K3p/BgCg+m8GAKD6bwYAoPpvBgSt+e0rdnSL4h+eJfncS/Ohnc6zK514nffsRvP+K3H/Hbj/jtJ6VvT+HBFB5M4cEUHkzhwRQeTOHBlL49pW/PknxL8sW/Ool/dbK512VzrxO//YjffsRvP+K3H/HbT0rfnsKDKTyYwoMpPJjCgyk8mMKDKX17St+eI/mO5It/dQr/6tTDva4e7nXitx/x24/47Uf89iN++ynp20t4sIQHS3iwhAdLeLCEB0t4sKRvL+nbC//qFP7VKfyrU/hXpy73urrc68RvP+K3H/Hbj/jtR/z2U9K3l/BgCQ+W8GAJD5bwYAkPlvBgSd9e0reXSb4u+eJfncK/OuXc68q514nffsRvP+K3H/Hbj/jtp6RvL+HBEh4s4cESHizhwRIeLOHBkr69pG+vlHxT8sW/OoV/dSq511VyrxO//YjffsRvP+K3H/HbT0nfXsKDJTxYwoMlPFjCgyU8WMKDJX17Sd9eLfm25It/dQr/6lRzr6vmXid++xG//YjffsRvP+K3n5K+vYQHS3iwhAdLeLCEB0t4sIQHW/r2lr69xb9q8a9a/KsW/6of7nX9cK8Tv/2I337Ebz/itx/x209L397Cgy082MKDLTzYwoMtPNjCgy19e0vf3uJftfhXLf5Vi3/Vl3tdX+514rcf8duP+O1H/PYjfvtp6dtbeLCFB1t4sIUHW3iwhQdbeLClb2/p21v8qxb/qsW/avGv2rnXtXOvE7/9iN/+a5Z8pW8Xv/209O0tPNjCgy082MKDLTzYwoMtPNjSt7f07S3+VYt/1eJftfhXndzrurjXid9+xG8/4rcf8duP+O2npW9v4cEWHmzhwRYebOHBFh5s4cGWvr2lb2/xr1r8qxb/qsW/6uFe18O9Tvz2I377Eb/9iN9+xG8/LX17Cw+28OAID47w4AgPjvDgCA+O9O0jffuIfzXiX434VyP+1RzudXO414nffsRvP+K3H/Hbj/jtZ6RvH+HBER4c4cERHhzhwREeHOHBkb59pG8f8a9G/KsR/2rEvxrjXjfGvU789iN++xG//YjffsRvPyN9+wgPjvDgCA+O8OAID47w4AgPjvTtI337iH814l+N+Fcj/tUE97oJ7nXitx/x24/47Uf89iN++xnp20d4cIQHR3hwhAdHeHCEB0d4cKRvH+nbR/yrEf9qxL8a8a+muNdNca8Tv/2I337Ebz/itx/x289I3z7CgyM8OMKDIzw4woMjPDjCgyN9+0jfPuJfjfhXI/7ViH81w71uhnud+O1H/PYjfvsVv/2K334f+vb7wIP3gQfvAw/eBx68Dzx4H3jwPo+cS99+H/r2++Bf3Qf/6j74V/fBv7rPfjjE17z3uit++xW//YrffsVvv+K334e+/T7w4H3gwfvAg/eBB+9z5dwr55qcS99+H/r2++Bf3Qf/6j74V/fBv7rPfmLE17z3uit++xW//YrffsVvv+K338clX5d8XfJ1ydclX5dzQ84NOTck35B8Q/INyRf/6j74V/fZj5H4mofcU77PKfmm5JuSb0q+Kfmm5JuSb0q+KfmWnFtybsm5JfmW5FuSb0m++Ff3wb+6z362xJfe+JB7y/e5Jd+WfFvybcm3Jd+WfFvybcl3JN+Rc0fOHTl3JN+RfEfyHckX/+o++Ff38HkT9/B5E1f89it++xW//Yrf/mtOmUvmlpl8Dzx4Dzz4a5Zzj5x75Fz69nvo23/NJXPLPMz4V/fweRP38HkTV/z2K377Fb/9it9+xW+/h779HnjwHnjwHnjwHnjwHpNzTc41OZe+/R769nvwr+4xyRf/6h78q3v4vIl7+LyJK377Fb/9it9+xW+/4rff45JvSL4h+YbkG5JvyLkh54acG5JvSL4h+abki391D/7VPXzexD183sQVv/2K337Fb7/it1/x2+8pybck35J8S/Itybfk3JJzS84tybck35Z8W/LFv7oH/+oePm/iHj5v4orffsVvv+K3X/Hbr/jt94zkO5LvSL4j+Y7kO3LuyLkj59K330vffi/+1b34V/fiX92Lf3UvnzdxL583ccVvv+K3X/Hbr/jtV/z2e+nb74UH74UH74UH74UH7z1y7pFzj5xL334vffu9+Ff34l/di391L/7VvXzexL183sQVv/2K337Fb7/it1/x2++lb78XHrwXHrwXHrwXHrzX5FyTc13OdcnXJV+XfF3yxb+6F//qXj5v4l4+b+KK337Fb7/it1/x26/47feG5BuSb0i+IfmG5Btybsq5Keem5JuSb0q+KfniX92Lf3UvnzdxL583ccVvv+K3X/Hbr/jtV/z2e0vyLcm3JN+SfEvybTm35dyWc1vybcm3Jd+WfPGv7sW/upfPm7iXz5u44rdf8duv+O1X/PYrfvu9I/mO5DuSr/CgCQ+a8KAJD5rwoNG3X6Nvv4Z/dQ3/6hr+1TX8q2t83sQ1Pm/iit9+xW+/4rdf8duv+O3X6NuvCQ+a8KAJD5rwoAkPmvCgCQ8affs1+vZr+FfX8K+u4V9dw7+6xudNXOPzJq747Vf89it++xW//Yrffo2+/ZrwoAkPmvCgCQ+a8KAJD5rwoLnk65KvS74u+eJfXcO/usbnTVzj8yau+O1X/PYrfvsVv/2K334tJF/hQRMeNOFBEx404UETHjThQUvJNyXflHxL8sW/uoZ/dY3Pm7jG501c8duv+O1X/PYrfvsVv/1aS77CgyY8aMKDJjxowoMmPGjCg9aSb0u+I/mO5It/dQ3/6hqfN3GNz5u44rdf8duv+O1X/PYrfvt1+vbrwoMuPOjCgy486MKDLjzowoNO336dvv06/tV1/Kvr+FfX8a+u83kT1/m8iSt++xW//YrffsVvv+K3X6dvvy486MKDLjzowoMuPOjCgy486PTt1+nbr+NfXce/uo5/dR3/6jqfN3Gdz5u44rdf8duv+O1X/PYrfvt1l3yFB1140IUHXXjQhQddeNCFBz0k35B8Q/INyRf/6jr+1XU+b+I6nzdxxW+/4rdf8duv+O1X/PbrKfkKD7rwoAsPuvCgCw+68KALD3pJviX5luRbki/+1XX8q+t83sR1Pm/iit9+xW+/4rdf8duv+O3XW/IVHnThQRcedOFBFx504UEXHvSRfEfyHcl3JF/8q+v4V9f5vIkbfN7EFb/9it9+xW+/4rdf8dtvSN8ewoMhPBjCgyE8GMKDITwYwoMhfXtI3x74Vzfwr27gX93Av7rB503c4PMmrvjtV/z2K377Fb/9it9+Q/r2EB4M4cEQHgzhwRAeDOHBEB4M6dtD+vbAv7qBf3UD/+oG/tUNPm/iBp83ccVvv+K3X/Hbr/jtV/z2G9K3h/BgCA+G8GAID4bwYAgPhvBgSN8e0rdHSL4h+eJf3cC/usHnTdzg8yau+O1X/PYrfvsVv/2K335D+vYQHgzhwRAeDOHBEB4M4cEQHgzp20P69ijJtyVf/Ksb+Fc3+LyJG3zexBW//YrffsVvv+K3X/Hbb0jfHsKDITwYwoMhPBjCgyE8GMKDIX17SN+e+Fc38a9u4l/dxL+6yedN3OTzJq747Vf89it++xW//YrfflP69hQeTOHBFB5M4cEUHkzhwRQeTOnbU/r2xL+6iX91E//qJv7VTT5v4iafN3HFb7/it1/x26/47Vf89pvSt6fwYAoPpvBgCg+m8GAKD6bwYErfntK3p0u+LvniX93Ev7rJ503c5PMmrvjtV/z2K377Fb/9it9+U/r2FB5M4cEUHkzhwRQeTOHBFB5M6dtT+vZMyTclX/yrm/hXN/m8iZt83sQVv/2K337Fb7/it1/x229K357Cgyk8mMKDKTyYwoMpPJjCgyl9e0rfni35tuSLf3UT/+omnzdxk8+buOK3X/Hbr/jtV/z2K377TenbU3gwhQdTeDCFB0t4sIQHS3iwpG8v6dsL/+oW/tUt/Ktb+Fe3+LyJW3zexBW//YrffsVvv+K3X/Hbb0nfXsKDJTxYwoMlPFjCgyU8WMKDJX17Sd9e+Fe38K9u4V/dwr+6xedN3OLzJq747Vf89it++xW//Yrffkv69hIeLOHBEh4s4cESHizhwRIeLOnbS/r2csnXJV/8q1v4V7f4vIlbfN7EFb/9it9+xW+/4rdf8dtvSd9ewoMlPFjCgyU8WMKDJTxYwoMlfXtJ314p+abki391C//qFp83cYvPm7jit1/x26/47Vf89it++y3p20t4sIQHS3iwhAdLeLCEB0t4sKRvL+nbqyXfkXzxr27hX93i8yZu8XkTV/z2K377Fb/9it9+xW+/LX17Cw+28GALD7bwYAsPtvBgCw+29O0tfXuLf9XiX7X4Vy3+VfN5E7f5vIkrfvsVv/2K337Fb7/it9+Wvr2FB1t4sIUHW3iwhQdbeLCFB1v69pa+vcW/avGvWvyrFv+q+byJ23zexBW//YrffsVvv+K3X/Hbb0vf3sKDLTzYwoMtPNjCgy082MKDLX17S9/e4l+1+Fct/lWLf9V83sRtPm/iit9+xW+/4rdf8duv+O23pW9v4cEWHmzhwRYebOHBFh5s4cGWvr2lb2/xr1r8qxb/qsW/aj5v4jafN3HFb7/it1/x26/47Vf89tvSt7fwYAsPtvBgCw+28GALD7bwYEvf3tK3t/hXLf5Vi3/V4l81nzdxm8+buOK3X/Hbr/jtV/z2K377HenbR3hwhAdHeHCEB0d4cIQHR3hwpG8f6dtH/KsR/2rEvxrxr4bPm7jD501c8duv+O1X/PYrfvsVv/2O9O0jPDjCgyM8OMKDIzw4woMjPDjSt4/07SP+1Yh/NeJfjfhXw+dN3OHzJq747Vf89it++xW//Yrffkf69hEeHOHBER4c4cERHhzhwREeHOnbR/r2Ef9qxL8a8a9G/Kvh8ybu8HkTV/z2K377Fb/9it9+xW+/I337CA+O8OAID47w4AgPjvDgCA+O9O0jffuIfzXiX434VyP+1fB5E3f4vIkrfvsVv/2K337Fb7/it9+Rvn2EB0d4cIQHR3hwhAdHeHCEB0f69pG+ffCv7MG/sgf/yh78K3v4vAl7+LwJE7/dxG838dtN/HYTv90e+nZ74EF74EF74EF74EF7jpx75Nwj59K320Pfbg/+lT34V/bgX9mDf2UPnzdhD583YeK3m/jtJn67id9u4rfbQ99uDzxoDzxoDzxoDzxoj8m5JueanGuSr0u+Lvm65It/ZQ/+lT183oQ9fN6Eid9u4reb+O0mfruJ325PSL4h+YbkG5JvSL4h54acG3JuSr4p+abkm5Iv/pU9+Ff28HkT9vB5EyZ+u4nfbuK3m/jtJn67PSX5luRbkm9JviX5lpxbcm7LuS35tuTbkm9LvvhX9uBf2cPnTdjD502Y+O0mfruJ327it5v47faM5DuS70i+I/mO5AsP2oEH7cCDdujb7dC328G/soN/9WtOmUvmvdfZ4fMmTPx2E7/dxG//NZvMLnPInDKXzC0z+Z4r514598q59O126Nvt4F/Zwb+yg39lB//KDp83YYfPmzDx2038dhO/3cRvN/Hb7dC324EH7cCDdkzydcnX5VyXc13OdcnXJV+XfF3yxb+yg39lh8+bsMPnTZj47SZ+u4nfbuK3m/jtdkLyDck3JN+UfFPyTTk35dyUc1PyTck3Jd+UfPGv7OBf2eHzJuzweRMmfruJ327it5v47SZ+u52SfEvybcm3Jd+WfFvObTm35dyWfFvybcm3JV/8Kzv4V3b4vAk7fN6Eid9u4reb+O0mfruJ326Hvt0uPGgXHrQLD9qFB+3Cg3bhQbvwoF36drv07Xbxr+ziX9nFv7KLf2WXz5uwy+dNmPjtJn67id9u4reb+O126dvtwoN24UG78KBdeNDulXOvnHvlXPp2u/TtdvGv7OJf2cW/sot/ZZfPm7DL502Y+O0mfruJ327it5v47XZd8nXJ1yVfl3xd8nU51+Vcl3Nd8g3JNyTfkHzxr+ziX9nl8ybs8nkTJn67id9u4reb+O0mfrvdlHxT8k3JNyXflHxTzk05N+XcknxL8i3JtyRf/Cu7+Fd2+bwJu3zehInfbuK3m/jtJn67id9utyXflnxb8m3JtyXflnNbzh05dyTfkXxH8h3JF//KLv6VXT5vwi6fN2Hit5v47SZ+u4nfbuK3m9G3mwkPmvCgCQ+a8KAJD5rwoAkPGn27GX27Gf6VGf6VGf6VGf6VGZ83YcbnTZj47SZ+u4nfbuK3m/jtZvTtZsKDJjxowoMmPGjCgyY8aMKDRt9uRt9uhn9lhn9lhn9lhn9lxudNmPF5EyZ+u4nfbuK3m/jtJn67mUu+woMmPGjCgyY8aMKDJjxowoMWkm9IviH5huSLf2WGf2XG502Y8XkTJn67id9u4reb+O0mfrtZSr7CgyY8aMKDJjxowoMmPGjCg1aSb0m+JfmW5It/ZYZ/ZcbnTZjxeRMmfruJ327it5v47SZ+u1lLvsKDJjxowoMmPGjCgyY8aMKDNpLvSL4j+eJfmeNfmeNfmfN5E+Z83oSJ327it5v47SZ+u4nfbk7fbi486MKDLjzowoMuPOjCgy486PTt5vTt5vhX5vhX5vhX5vhX5nzehDmfN2Hit5v47SZ+u4nfbuK3m9O3mwsPuvCgCw+68KALD7rwoAsPOn27uUm+Lvm65It/ZY5/Zc7nTZjzeRMmfruJ327it5v47SZ+u3lIvsKDLjzowoMuPOjCgy486MKDHpJvSr4p+abki39ljn9lzudNmPN5EyZ+u4nfbuK3m/jtJn67eUm+woMuPOjCgy486MKDLjzowoPekm9Lvi35tuSLf2WOf2XO502Y83kTJn67id9u4reb+O0mfrv5SL7Cgy486MKDLjzowoMuPBjCgyF9e0jfHvhXFvhXFvhXFvhXFnzehAWfN2Hit5v47SZ+u4nfbuK3W0jfHsKDITwYwoMhPBjCgyE8GMKDIX17SN8e+FcW+FcW+FcW+FcWfN6EBZ83YeK3m/jtJn67id9u4rdbSN8ewoMhPBjCgyE8GMKDITwYwoMhfXtI3x4u+brki39lgX9lwedNWPB5EyZ+u4nfbuK3m/jtJn67hfTtITwYwoMhPBjCgyE8GMKDITwY0reH9O2Rkm9KvvhXFvhXFnzehAWfN2Hit5v47SZ+u4nfbuK3W0jfHsKDITwYwoMhPBjCgyE8GMKDIX17SN8eLfm25It/ZYF/ZcHnTVjweRMmfruJ327it5v47SZ+u4X07SE8mMKDKTyYwoMpPJjCgyk8mNK3p/TtiX9liX9liX9liX9lyedNWPJ5EyZ+u4nfbuK3m/jtJn67pfTtKTyYwoMpPJjCgyk8mMKDKTyY0ren9O2Jf2WJf2WJf2WJf2XJ501Y8nkTJn67id9u4reb+O0mfrul9O0pPJjCgyk8mMKDKTyYwoMpPJjSt6f07RmSb0i++FeW+FeWfN6EJZ83YeK3m/jtJn67id9u4rdbSt+ewoMpPJjCgyk8mMKDKTyYwoMpfXtK354l+Zbki39liX9lyedNWPJ5EyZ+u4nfbuK3m/jtJn67pfTtKTyYwoMpPJjCgyk8mMKDKTyY0ren9O05ku9IvvhXlvhXlnzehCWfN2Hit5v47SZ+u4nfbuK3W0nfXsKDJTxYwoMlPFjCgyU8WMKDJX17Sd9e+FdW+FdW+FdW+FdWfN6EFZ83YeK3m/jtJn67id9u4rdbSd9ewoMlPFjCgyU8WMKDJTxYwoMlfXtJ3174V1b4V1b4V1b4V1Z83oQVnzdh4reb+O0mfruJ327it1tJ317CgyU8WMKDJTxYwoMlPFjCgyV9e0nfXiH5huSLf2WFf2XF501Y8XkTJn67id9u4reb+O0mfruV9O0lPFjCgyU8WMKDJTxYwoMlPFjSt5f07VWSb0m++FdW+FdWfN6EFZ83YeK3m/jtJn67id9u4rdbSd9ewoMlPFjCgyU8WMKDJTxYwoMlfXtJ314j+Y7kK/5Vi3/VfN6ENZ83YeK3m/jtJn67id9u4rdbS9/ewoMtPNjCgy082MKDLTzYwoMtfXtL397iX7X4Vy3+VYt/1XzehDWfN2Hit5v47SZ+u4nfbuK3W0vf3sKDLTzYwoMtPNjCgy082MKDLX17S9/e4l+1+Fct/lWLf9V83oQ1nzdh4reb+O0mfruJ327it1tL397Cgy082MKDLTzYwoMtPNjCgy19e0vf3uJftfhXLf5Vi3/VfN6ENZ83YeK3m/jtJn67id9u4rdbS9/ewoMtPNjCgy082MKDLTzYwoMtfXtL397iX7X4Vy3+VYt/1XzehDWfN2Hit5v47SZ+u4nfbuK3W0vf3sKDLTzYwoMtPNjCgy082MKDI337SN8+4l+N+Fcj/tWIfzV83oQNnzdh4reb+O0mfruJ327it9tI3z7CgyM8OMKDIzw4woMjPDjCgyN9+0jfPuJfjfhXI/7ViH81fN6EDZ83YeK3m/jtJn67id9u4rfbSN8+woMjPDjCgyM8OMKDIzw4woMjfftI3z7iX434VyP+1Yh/NXzehA2fN2Hit5v47SZ+u4nfbuK320jfPsKDIzw4woMjPDjCgyM8OMKDI337SN8+4l+N+Fcj/tWIfzV83oQNnzdh4reb+O0mfruJ327it9tI3z7CgyM8OMKDIzw4woMjPDjCgyN9+0jfPuJfjfhXI/7ViH81fN6EDZ83YeK3m/jtJn67id9u4rfbSN8+woMDD/oDD/oDD/oDD/oDD/oDD/pD3+4Pfbs/+Ff+4F/5g3/lD/6VP3zehD983oSL3+7it7v47f9fps4lSZZbx4JbChJf7n9j3XqpkvsMM5gKV8k4MHdDim9P8e35sW/PjzyYH3kwP/JgfuTB/K76XvW96su+PT/27fnBX+UHf5Uf/FV+8Ff5cW8iP+5NpPj2FN+e4ttTfHuKb88vNN/UfFPzTc03Nd9U31TfVN/UfFPzTc23NF/4q/zgr/Lj3kR+3JtI8e0pvj3Ft6f49hTfnl9rvq35tubbmm9rvq2+rb6tvq35tuY7mu9ovvBX+cFf5ce9ify4N5Hi21N8e4pvT/HtKb49v9V8V/NdzXc139V8V31XfVd9V/N9mu/TfJ/mC3+VH/xVftybyI97Eym+PcW3p/j2FN+e4tvzsG/PQx7MQx7MQx78/7pVj+pVrb7s2/Owb88Df/X/dahO1aX6v++6PNybSPHtKb49xben+PYU356HfXse8mAe8mAe8mAe8mCeq75XfUN92bfnYd+eB/4qD/xVHvirPPBXebg3kYd7Eym+PcW3p/j2FN+e4tvzpOabmm9qvqn5puab6lvqW+pbmm9pvqX5luYLf5UH/ioP9ybycG8ixben+PYU357i21N8e57WfFvzbc23Nd/WfEd9R31HfUfzHc13NN/RfOGv8sBf5eHeRB7uTaT49hTfnuLbU3x7im/Ps5rvar6r+a7m+zTfp75PfZ/6Ps33ab5P832aL/xVHvirvNybyMu9iRTfnuLbU3x7im9P8e152bfnJQ/mJQ/mJQ/mJQ/mPep71PeoL/v2vOzb88Jf5YW/ygt/lRf+Ki/3JvJybyLFt6f49hTfnuLbU3x7XvbtecmDecmDecmDecmDeUN9Q31Dfdm352Xfnhf+Km9ovvBXeeGv8nJvIi/3JlJ8e4pvT/HtKb49xbfnTc23NN/SfEvzLc231LfUt9S3NN/SfEvzbc0X/iov/FVe7k3k5d5Eim9P8e0pvj3Ft6f49ryj+Y7mO5rvaL6j+Y76jvqO+o7mO5rvar6r+cJf5YW/ysu9ibzcm0jx7Sm+PcW3p/j2FN+e92m+T/N9mu/TfJ/m+9T3qe9TX/btGezbM+CvMuCvMuCvMuCvMrg3kcG9iRTfnuLbU3x7im9P8e0Z7NszlAdDeTCUB0N5MJQHQ3kwlAeDfXsG+/YM+KsM+KsM+KsM+KsM7k1kcG8ixben+PYU357i21N8ewb79gzlwVAeDOXBUB4M5cFQHgzlwUjNNzXf1HxT84W/yoC/yuDeRAb3JlJ8e4pvT/HtKb49xbdnlOarPBjKg6E8GMqDoTwYyoOhPBit+bbm25pva77wVxnwVxncm8jg3kSKb0/x7Sm+PcW3p/j2jNF8lQdDeTCUB0N5MJQHQ3kwlAdjNd/VfFfzXc0X/ioD/iqDexMZ3JtI8e0pvj3Ft6f49hTfnvE0X+XBUB4M5cFUHkzlwVQeTOXBZN+eyb49E/4qE/4qE/4qE/4qk3sTmdybSPHtKb49xben+PYU357Jvj1TeTCVB1N5MJUHU3kwlQdTeTDZt2eyb8+Ev8qEv8qEv8qEv8rk3kQm9yZSfHuKb0/x7Sm+PcW3Z7Jvz1QeTOXBVB5M5cFUHkzlwVQezNR8U/NNzTc1X/irTPirTO5NZHJvIsW3p/j2FN+e4ttTfHtmab7Kg6k8mMqDqTyYyoOpPJjKg9mab2u+rfmO5gt/lQl/lcm9iUzuTaT49hTfnuLbU3x7im/PXM1XeTCVB1N5MJUHU3kwlQdTeTBX813N92m+T/OFv8qEv8rk3kQm9yZSfHuKb0/x7Sm+PcW3Z2nfXsqDpTxYyoOlPFjKg6U8WMqDpX17ad9e8FdZ8FdZ8FdZ8FdZ3JvI4t5Eim9P8e0pvj3Ft6f49izt20t5sJQHS3mwlAdLebCUB0t5sLRvL+3bC/4qC/4qC/4qC/4qi3sTWdybSPHtKb49xben+PYU356lfXspD5byYCkPlvJgKQ+W8mApD5b27aV9e5XmW5ov/FUW/FUW9yayuDeR4ttTfHuKb0/x7Sm+PUv79lIeLOXBUh4s5cFSHizlwVIeLO3bS/v2Gs13NF/4qyz4qyzuTWRxbyLFt6f49hTfnuLbU3x7lvbtpTxYyoOlPFjKg6U8WMqDpTxY2reX9u31NN+n+cJfZcFfZXFvIpt7Eym+PcW3p/j2FN+e4tuztW9v5cFWHmzlwVYebOXBVh5s5cHWvr21b2/4q2z4q2z4q2z4q2zuTWRzbyLFt6f49hTfnuLbU3x7tvbtrTzYyoOtPNjKg6082MqDrTzY2re39u0Nf5UNf5UNf5UNf5XNvYls7k2k+PYU357i21N8e4pvz9a+vZUHW3mwlQdbebCVB1t5sJUHW/v21r69S/MtzRf+Khv+Kpt7E9ncm0jx7Sm+PcW3p/j2FN+erX17Kw+28mArD7byYCsPtvJgKw+29u2tfXuP5ruaL/xVNvxVNvcmsrk3keLbU3x7im9P8e0pvj1b+/ZWHmzlwVYebOXBVh5s5cFWHmzt21v79oG/yoG/yoG/yoG/yuHeRA73JlJ8e4pvT/HtKb49xbfnaN8+yoOjPDjKg6M8OMqDozw4yoOjffto3z7wVznwVznwVznwVzncm8jh3kSKb0/x7Sm+PcW3p/j2HO3bR3lwlAdHeXCUB0d5cJQHR3lwtG8f7dsnNd/UfOGvcuCvcrg3kcO9iRTfnuLbU3x7im9P8e052reP8uAoD47y4CgPjvLgKA+O8uBo3z7at09rvq35wl/lwF/lcG8ih3sTKb49xben+PYU357i23O0bx/lwVEeHOXBUR4c5cFRHhzlwdG+fbRvn9V8V/OFv8qBv8rh3kQO9yZSfHuKb0/x7Sm+PcW352jfPsqDozw4yoOjPLjKg6s8uMqDq337at++4q9W/NWKv1rxV8u9iVzuTaT49hTfnuLbU3x7im/P1b59lQdXeXCVB1d5cJUHV3lwlQdX+/bVvn3FX634qxV/teKvlnsTudybSPHtKb49xben+PYU356rffsqD67y4CoPrvLgKg+u8uAqD6727at9+4q/WvFXK/5qxV8t9yZyuTeR4ttTfHuKb0/x7Sm+PVf79lUeXOXBVR5c5cFVHlzlwVUeXO3bV/v2FX+14q9W/NWKv1ruTeRybyLFt6f49hTfnuLbU3x7rvbtqzy4yoOrPLjKg6s8uMqDqzy42rev9u0r/mrFX634qxV/tdybyOXeRIpvT/HtKb49xben+PZ82rc/5cGnPPiUB5/y4FMefMqDT3nwad/+tG9/4q+e+Ksn/uqJv3rcm8jHvYkU357i21N8e4pvT/Ht+bRvf8qDT3nwKQ8+5cGnPPiUB5/y4NO+/Wnf/sRfPfFXT/zVE3/1uDeRj3sTKb49xben+PYU357i2/Np3/6UB5/y4FMefMqDT3nwKQ8+5cGnffvTvv2Jv3rir574qyf+6nFvIh/3JlJ8e4pvT/HtKb49xbfn0779KQ8+5cGnPPiUB5/y4FMefMqDT/v2p337E3/1xF898VdP/NXj3kQ+7k2k+PYU357i21N8e4pvz6d9+1MefMqDT3nwKQ8+5cGnPPiUB5/27U/79if+6om/euKvnvirx72JfNybKPHtJb69xLeX+PYS314f+/b6yIP1kQfrIw/WRx6s76jvUd+jvuzb62PfXh/8VX3wV/XBX9UHf1Uf9ybq495EiW8v8e0lvr3Et5f49vrYt9dHHqyPPFgfebA+8mB9ob6hvqG+7NvrY99eH/xVffBX9cFf1Qd/VR/3Jurj3kSJby/x7SW+vcS3l/j2+lLzTc03Nd/SfEvzLfUt9S31Lc23NN/SfEvzhb+qD/6qPu5N1Me9iRLfXuLbS3x7iW8v8e31tebbmu9ovqP5juY76jvqO+o7mu9ovqP5juYLf1Uf/FV93Juoj3sTJb69xLeX+PYS317i2+tbzfdpvk/zfZrv03yf+j71fer7NN+n+cJf1YG/qgN/VQf+qg73Jupwb6LEt/9/3apH9apmvod9ex3yYB3y4P/XoTpVq+9R36O+7NvrsG+vA39VB/6qDvxVHfirOtybqMO9iRLfXuLbS3x7iW8v8e112LfXIQ/WIQ/WIQ/WIQ/WCfUN9Q31Dc03Nd/UfFPzhb+qA39Vh3sTdbg3UeLbS3x7iW8v8e0lvr1Oab6l+ZbmW5pvab6lvqW+pb6t+bbm25pva77wV3Xgr+pwb6IO9yZKfHuJby/x7SW+vcS31xnNdzTf0XxH8x3Nd9R31HfVdzXf1XxX813NF/6qDvxVHe5N1OHeRIlvL/HtJb69xLeX+PY6T/N9mu/TfJ/m+zRf8mBd8mBd8mBd9u112bfXhb+qC39VF/6qLvxVXe5N1OXeRIlvL/HtJb69xLeX+Pa67NvrkgfrkgfrkgfrkgfrXvW96nvVl317XfbtdeGv6sJf1YW/qgt/VZd7E3W5N1Hi20t8e4lvL/HtJb69Lvv2uuTBuuTBuqH5puab6pvqm+qbmm9qvqn5puYLf1UX/qou9ybqcm+ixLeX+PYS317i20t8e93SfEvzLc23Nd/WfFt9W31bfVvzbc23Nd/WfOGv6sJf1eXeRF3uTZT49hLfXuLbS3x7iW+vO5rvaL6r+a7mu5rvqu+q76rvar6r+a7mu5ov/FVd+Ku63Juoy72JEt9e4ttLfHuJby/x7XXZt1coD4byYCgPhvJgKA+G8mAoDwb79gr27RXwVxXwVxXwVxXwVxXcm6jg3kSJby/x7SW+vcS3l/j2CvbtFcqDoTwYyoOhPBjKg6E8GMqDwb69gn17BfxVBfxVBfxVBfxVBfcmKrg3UeLbS3x7iW8v8e0lvr0iNV/lwVAeDOXBUB4M5cFQHgzlwUjNtzTf0nxL84W/qoC/quDeRAX3Jkp8e4lvL/HtJb69xLdXtOarPBjKg6E8GMqDoTwYyoOhPBij+Y7mO5rvaL7wVxXwVxXcm6jg3kSJby/x7SW+vcS3l/j2itV8lQdDeTCUB0N5MJQHQ3kwlAfjab5P832a79N84a8q4K8quDdRwb2JEt9e4ttLfHuJby/x7ZXs2yuVB1N5MJUHU3kwlQdTeTCVB5N9eyX79kr4q0r4q0r4q0r4q0ruTVRyb6LEt5f49hLfXuLbS3x7Jfv2SuXBVB5M5cFUHkzlwVQeTOXBZN9eyb69Ev6qEv6qEv6qEv6qknsTldybKPHtJb69xLeX+PYS316Zmq/yYCoPpvJgKg+m8mAqD6byYJbmW5pvab6l+cJfVcJfVXJvopJ7EyW+vcS3l/j2Et9e4tsrW/NVHkzlwVQeTOXBVB5M5cFUHszRfEfzHc13NF/4q0r4q0ruTVRyb6LEt5f49hLfXuLbS3x75Wq+yoOpPJjKg6k8mMqDqTyYyoP5NN+n+T7NF/6qCv6qCv6qinsTVdybKPHtJb69xLeX+PYS316lfXspD5byYCkPlvJgKQ+W8mApD5b27aV9e8FfVcFfVcFfVcFfVXFvoop7EyW+vcS3l/j2Et9e4turtG8v5cFSHizlwVIeLOXBUh4s5cHSvr20b6/UfFPzhb+qgr+q4t5EFfcmSnx7iW8v8e0lvr3Et1dp317Kg6U8WMqDpTxYyoOlPFjKg6V9e2nfXq35tuYLf1UFf1XFvYkq7k2U+PYS317i20t8e4lvr9K+vZQHS3mwlAdLebCUB0t5sJQHS/v20r69VvNdzRf+qgr+qop7E1Xcmyjx7SW+vcS3l/j2Et9epX17KQ+W8mApD5byYCkPlvJgKw+29u2tfXvDX1XDX1XDX1XDX1Vzb6KaexMlvr3Et5f49hLfXuLbq7Vvb+XBVh5s5cFWHmzlwVYebOXB1r69tW9v+Ktq+Ktq+Ktq+Ktq7k1Uc2+ixLeX+PYS317i20t8e7X27a082MqDrTzYyoOtPNjKg6082Nq3t/btnZpvar7wV9XwV9Xcm6jm3kSJby/x7SW+vcS3l/j2au3bW3mwlQdbebCVB1t5sJUHW3mwtW9v7du7Nd/WfOGvquGvqrk3Uc29iRLfXuLbS3x7iW8v8e3V2re38mArD7byYCsPtvJgKw+28mBr397at/dqvqv5wl9Vw19Vc2+imnsTJb69xLeX+PYS317i26u1b2/lwVEeHOXBUR4c5cFRHhzlwdG+fbRvH/irGvirGvirGvirGu5N1HBvosS3l/j2Et9e4ttLfHuN9u2jPDjKg6M8OMqDozw4yoOjPDjat4/27QN/VQN/VQN/VQN/VcO9iRruTZT49hLfXuLbS3x7iW+v0b59lAdHeXCUB0d5cJQHR3lwlAdH+/bRvn1K8y3NF/6qBv6qhnsTNdybKPHtJb69xLeX+PYS316jffsoD47y4CgPjvLgKA+O8uAoD4727aN9+4zmO5ov/FUN/FUN9yZquDdR4ttLfHuJby/x7SW+vUb79lEeHOXBUR4c5cFRHhzlwVEeHO3bR/v2eZrv03zhr2rgr2q4N1HDvYkS317i20t8e4lvL/Httdq3r/LgKg+u8uAqD67y4CoPrvLgat++2rev+KsVf7Xir1b81XJvopZ7EyW+vcS3l/j2Et9e4ttrtW9f5cFVHlzlwVUeXOXBVR5c5cHVvn21b1/xVyv+asVfrfir5d5ELfcmSnx7iW8v8e0lvr3Et9dq377Kg6s8uMqDqzy4yoOrPLjKg6t9+2rfvuKvVvzVir9a8VfLvYla7k2U+PYS317i20t8e4lvr9W+fZUHV3lwlQdXeXCVB1d5cJUHV/v21b59xV+t+KsVf7Xir5Z7E7Xcmyjx7SW+vcS3l/j2Et9eq337Kg+u8uAqD67y4CoPrvLgKg+u9u2rffuKv1rxVyv+6om/etybqMe9iRLfXuLbS3x7iW8v8e31tG9/yoNPefApDz7lwac8+JQHn/Lg0779ad/+xF898VdP/NUTf/W4N1GPexMlvr3Et5f49hLfXuLb62nf/pQHn/LgUx58yoNPefApDz7lwad9+9O+/Ym/euKvnvirJ/7qcW+iHvcmSnx7iW8v8e0lvr3Et9fTvv0pDz7lwac8+JQHn/LgUx58yoNP+/anffsTf/XEXz3xV0/81ePeRD3uTZT49hLfXuLbS3x7iW+vp337Ux58yoNPefApDz7lwac8+JQHn/btT/v2J/7qib964q+e+KvHvYl63Jso8e0lvr3Et5f49hLfXk/79qc8+JQHn/LgUx58yoNPefCRB/tj394f+/b+4K/6g7/qD/6qP/ir/rg30R/3Jlp8e4tvb/HtLb69xbf3x769P/Jgf+TB/siD/ZEH+zvqe9T3qi/79v7Yt/cHf9Uf/FV/8Ff9wV/1x72J/rg30eLbW3x7i29v8e0tvr0/9u39kQf7Iw/2Rx7sjzzYX6hvqm+qb2q+qfmm5puaL/xVf/BX/XFvoj/uTbT49hbf3uLbW3x7i2/vrzTf0nxL8y3NtzTfVt9W31bf1nxb823NtzVf+Kv+4K/6495Ef9ybaPHtLb69xbe3+PYW397faL6j+Y7mO5rvar6rvqu+q76r+a7mu5rvar7wV/3BX/XHvYn+uDfR4ttbfHuLb2/x7S2+vb+n+T7NlzzYhzzYhzzYhzzYhzzYhzzYh337/9etelSv6kcNf9WHexN9uDfx/zV/58P3VYtvb/HtLb69D/v2PuTBPuTBPuTBPuTBPld9r/pe9WXf3od9ex/4qz7wV33gr/rAX/Xh3kQf7k20+PYW397i21t8e4tv7xOab2q+qfmm5puab6pvqm+qb2q+qfmm5luaL/xVH/irPtyb6MO9iRbf3uLbW3x7i29v8e19WvNtzbc139Z8W/Nt9W31bfVtzbc139F8R/OFv+oDf9WHexN9uDfR4ttbfHuLb2/x7S2+vc9qvqv5rua7mu9qvqu+q76rvqv5Ps33ab5P84W/6gN/1Yd7E324N9Hi21t8e4tvb/HtLb69L/v2vuTBvuTBvuTBvuTBvuTBvuTBvp/6sm/vy769L/xVX/irvvBXfeGv+nJvoi/3Jlp8e4tvb/HtLb69xbf3Zd/elzzYlzzYlzzYlzzY96rvVd9QX/btfdm394W/6gt/1Rf+qi/8VV/uTfTl3kSLb2/x7S2+vcW3t/j2vqn5puabmm9qvqn5pvqW+pb6luZbmm9pvqX5wl/1hb/qy72JvtybaPHtLb69xbe3+PYW3963Nd/WfFvzbc23Nd9R31HfUd/RfEfzHc13NF/4q77wV325N9GXexMtvr3Ft7f49hbf3uLb+67mu5rvar6r+T7N96nvU9+nvk/zfZrv03yf5gt/1Rf+qoN7Ex3cm2jx7S2+vcW3t/j2Ft/ewb69Q3kwlAdDeTCUB0N5MJQHQ3kw2Ld3sG/vgL/qgL/qgL/qgL/q4N5EB/cmWnx7i29v8e0tvr3Ft3ewb+9QHgzlwVAeDOXBUB4M5cFQHgz27R3s2zvgrzpC84W/6oC/6uDeRAf3Jlp8e4tvb/HtLb69xbd3pOarPBjKg6E8GMqDoTwYyoOhPBil+ZbmW5pva77wVx3wVx3cm+jg3kSLb2/x7S2+vcW3t/j2jtF8lQdDeTCUB0N5MJQHQ3kwlAdjNN/RfFfzXc0X/qoD/qqDexMd3Jto8e0tvr3Ft7f49hbf3vE0X+XBUB4M5cFQHgzlwVAeDOXBYN/eyb69E/6qE/6qE/6qE/6qk3sTndybaPHtLb69xbe3+PYW397Jvr1TeTCVB1N5MJUHU3kwlQdTeTDZt3eyb++Ev+qEv+qEv+qEv+rk3kQn9yZafHuLb2/x7S2+vcW3d7Jv71QeTOXBVB5M5cFUHkzlwVQezNR8U/NNzTc1X/irTvirTu5NdHJvosW3t/j2Ft/e4ttbfHtnab7Kg6k8mMqDqTyYyoOpPJjKg9mab2u+rfm25gt/1Ql/1cm9iU7uTbT49hbf3uLbW3x7i2/vHM1XeTCVB1N5MJUHU3kwlQdTeTBX813NdzXf1Xzhrzrhrzq5N9HJvYkW397i21t8e4tvb/HtnU/zVR5M5cFUHizlwVIeLOXBUh4s7dtL+/aCv+qCv+qCv+qCv+ri3kQX9yZafHuLb2/x7S2+vcW3d2nfXsqDpTxYyoOlPFjKg6U8WMqDpX17ad9e8Fdd8Fdd8Fdd8Fdd3Jvo4t5Ei29v8e0tvr3Ft7f49i7t20t5sJQHS3mwlAdLebCUB0t5sLRvL+3bKzXf1Hzhr7rgr7q4N9HFvYkW397i21t8e4tvb/HtXdq3l/JgKQ+W8mApD5byYCkPlvJgad9e2rdXa76j+cJfdcFfdXFvoot7Ey2+vcW3t/j2Ft/e4tu7tG8v5cFSHizlwVIeLOXBUh4s5cHSvr20b6+n+T7NF/6qC/6qi3sTXdybaPHtLb69xbe3+PYW396tfXsrD7byYCsPtvJgKw+28mArD7b27a19e8NfdcNfdcNfdcNfdXNvopt7Ey2+vcW3t/j2Ft/e4tu7tW9v5cFWHmzlwVYebOXBVh5s5cHWvr21b2/4q274q274q274q27uTXRzb6LFt7f49hbf3uLbW3x7t/btrTzYyoOtPNjKg6082MqDrTzY2re39u1dmm9pvvBX3fBX3dyb6ObeRItvb/HtLb69xbe3+PZu7dtbebCVB1t5sJUHW3mwlQdbebC1b2/t23s039F84a+64a+6uTfRzb2JFt/e4ttbfHuLb2/x7d3at7fyYCsPtvJgKw+28mArD7byYGvf3tq399N8n+YLf9UNf9XNvYke7k20+PYW397i21t8e4tv79G+fZQHR3lwlAdHeXCUB0d5cJQHR/v20b594K964K964K964K96uDfRw72JFt/e4ttbfHuLb2/x7T3at4/y4CgPjvLgKA+O8uAoD47y4GjfPtq3D/xVD/xVD/xVD/xVD/cmerg30eLbW3x7i29v8e0tvr1H+/ZRHhzlwVEeHOXBUR4c5cFRHhzt20f79inNtzRf+Kse+Kse7k30cG+ixbe3+PYW397i21t8e4/27aM8OMqDozw4yoOjPDjKg6M8ONq3j/btM5rvar7wVz3wVz3cm+jh3kSLb2/x7S2+vcW3t/j2Hu3bR3lwlAdHeXCUB0d5cJQHR3lwtG8f7dtX/NWKv1rxVyv+ark30cu9iRbf3uLbW3x7i29v8e292rev8uAqD67y4CoPrvLgKg+u8uBq377at6/4qxV/teKvVvzVcm+il3sTLb69xbe3+PYW397i23u1b1/lwVUeXOXBVR5c5cFVHlzlwdW+fbVvX/FXK/5qxV+t+Kvl3kQv9yZafHuLb2/x7S2+vcW392rfvsqDqzy4yoOrPLjKg6s8uMqDq337at++4q9W/NWKv1rxV8u9iV7uTbT49hbf3uLbW3x7i2/v1b59lQdXeXCVB1d5cJUHV3lwlQdX+/bVvn3FX634qxV/teKvlnsTvdybaPHtLb69xbe3+PYW396rffsqD67y4CoPrvLgUx58yoNPefBp3/60b3/ir574qyf+6om/etyb6Me9iRbf3uLbW3x7i29v8e39tG9/yoNPefApDz7lwac8+JQHn/Lg0779ad/+xF898VdP/NUTf/W4N9GPexMtvr3Ft7f49hbf3uLb+2nf/pQHn/LgUx58yoNPefApDz7lwad9+9O+/Ym/euKvnvirJ/7qcW+iH/cmWnx7i29v8e0tvr3Ft/fTvv0pDz7lwac8+JQHn/LgUx58yoNP+/anffsTf/XEXz3xV0/81ePeRD/uTbT49hbf3uLbW3x7i2/vp337Ux58yoNPefApDz7lwac8+JQHn/btT/v2J/7qib964q+e+KvHvYl+3Jto8e0tvr3Ft7f49hbfPh/79vnIg/ORB+cjD85HHpyPPDgfeXA+8uB87NvnY98+H/zVfPBX88FfzQd/NR/3Jubj3sSIbx/x7SO+fcS3j/j2+di3z0cenI88OB95cD7y4HxXfa/6XvVl3z4f+/b54K/mg7+aD/5qPvir+bg3MR/3JkZ8+4hvH/HtI759xLfPl5pvar6p+abmm5pvqm+qb6pvab6l+ZbmW5ov/NV88FfzcW9iPu5NjPj2Ed8+4ttHfPuIb5+vNd/WfFvzbc23Nd9W31bfUd/RfEfzHc13NF/4q/ngr+bj3sR83JsY8e0jvn3Et4/49hHfPt9qvqv5rua7mu9qvqu+T32f+j7N92m+T/N9mi/81XzwV/Nxb2I+7k2M+PYR3z7i20d8+4hvn8O+/f/rVj2qVzXzPUd9j/oe9WXf/v91qi7VrXpUr+r/vuvmcG9ixLeP+PYR3z7i20d8+xz27XPIg3PIg3PIg3PIg3NCfUN9Q33Zt89h3z4H/moO/NUc+Ks58FdzuDcxh3sTI759xLeP+PYR3z7i2+ek5puab2q+pfmW5lvqW+pb6luab2m+pfmW5gt/NQf+ag73JuZwb2LEt4/49hHfPuLbR3z7nNZ8W/MdzXc039F8R31HfUd9R/MdzXc039F84a/mwF/N4d7EHO5NjPj2Ed8+4ttHfPuIb5+zmu/TfJ/m+zTfp/k+9X3q+9T3ab5P84W/mgt/NRf+ai781VzuTczl3sSIbx/x7SO+fcS3j/j2uezb55IH55IH55IH55IH5x71Pep71Jd9+1z27XPhr+bCX82Fv5oLfzWXexNzuTcx4ttHfPuIbx/x7SO+fS779rnkwbnkwbnkwbnkwbmhvqG+ob6h+abmm5pvar7wV3Phr+Zyb2Iu9yZGfPuIbx/x7SO+fcS3zy3NtzTf0nxL8y3Nt9S31LfUtzXf1nxb823NF/5qLvzVXO5NzOXexIhvH/HtI759xLeP+Pa5o/mO5jua72i+o/mO+o76rvqu5rua72q+q/nCX82Fv5rLvYm53JsY8e0jvn3Et4/49hHfPvdpvk/zfZrv03yf5qs8GMqDoTwY7Nsn2LdPwF9NwF9NwF9NwF9NcG9ignsTI759xLeP+PYR3z7i2yfYt08oD4byYCgPhvJgKA+G8mAoDwb79gn27RPwVxPwVxPwVxPwVxPcm5jg3sSIbx/x7SO+fcS3j/j2CfbtE8qDoTwYyoOhPBjKg6E8GMqDkZpvar6p+abmC381AX81wb2JCe5NjPj2Ed8+4ttHfPuIb58ozVd5MJQHQ3kwlAdDeTCUB0N5MFrzbc23Nd/WfOGvJuCvJrg3McG9iRHfPuLbR3z7iG8f8e0To/kqD4byYCgPhvJgKA+G8mAoD8Zqvqv5rua7mi/81QT81QT3Jia4NzHi20d8+4hvH/HtI759gn37pPJgKg+m8mAqD6byYCoPpvJgsm+fZN8+CX81CX81CX81CX81yb2JSe5NjPj2Ed8+4ttHfPuIb59k3z6pPJjKg6k8mMqDqTyYyoOpPJjs2yfZt0/CX03CX03CX03CX01yb2KSexMjvn3Et4/49hHfPuLbJ1PzVR5M5cFUHkzlwVQeTOXBVB7M1HxL8y3NtzRf+KtJ+KtJ7k1Mcm9ixLeP+PYR3z7i20d8+2RrvsqDqTyYyoOpPJjKg6k8mMqDOZrvaL6j+Y7mC381CX81yb2JSe5NjPj2Ed8+4ttHfPuIb59czVd5MJUHU3kwlQdTeTCVB1N5MJ/m+zTfp/k+zRf+ahL+apJ7E5Pcmxjx7SO+fcS3j/j2Ed8+pX17KQ+W8mApD5byYCkPlvJgKQ+W9u2lfXvBX03BX03BX03BX01xb2KKexMjvn3Et4/49hHfPuLbp7RvL+XBUh4s5cFSHizlwVIeLOXB0r69tG8v+Ksp+Ksp+Ksp+Ksp7k1McW9ixLeP+PYR3z7i20d8+5T27aU8WMqDpTxYyoOlPFjKg6U8WNq3l/btVZpvab7wV1PwV1Pcm5ji3sSIbx/x7SO+fcS3j/j2Ke3bS3mwlAdLebCUB0t5sJQHS3mwtG8v7dtrNN/RfOGvpuCvprg3McW9iRHfPuLbR3z7iG8f8e1T2reX8mApD5byYCkPlvJgKQ+W8mBp317at9fTfOGvpuGvpuGvprk3Mc29iRHfPuLbR3z7iG8f8e3T2re38mArD7byYCsPtvJgKw+28mBr397atzf81TT81TT81TT81TT3Jqa5NzHi20d8+4hvH/HtI759Wvv2Vh5s5cFWHmzlwVYebOXBVh5s7dtb+/ZOzTc1X/irafirae5NTHNvYsS3j/j2Ed8+4ttHfPu09u2tPNjKg6082MqDrTzYyoOtPNjat7f27d2ab2u+8FfT8FfT3JuY5t7EiG8f8e0jvn3Et4/49mnt21t5sJUHW3mwlQdbebCVB1t5sLVvb+3bezXf1Xzhr6bhr6a5NzHNvYkR3z7i20d8+4hvH/Ht09q3t/JgKw+28mArD7byYCsPjvLgaN8+2rcP/NUM/NUM/NUM/NUM9yZmuDcx4ttHfPuIbx/x7SO+fUb79lEeHOXBUR4c5cFRHhzlwVEeHO3bR/v2gb+agb+agb+agb+a4d7EDPcmRnz7iG8f8e0jvn3Et89o3z7Kg6M8OMqDozw4yoOjPDjKg6N9+2jfPqn5puYLfzUDfzXDvYkZ7k2M+PYR3z7i20d8+4hvn9G+fZQHR3lwlAdHeXCUB0d5cJQHR/v20b59WvNtzRf+agb+aoZ7EzPcmxjx7SO+fcS3j/j2Ed8+o337KA+O8uAoD47y4CgPjvLgKA+O9u2jffus5ruaL/zVDPzVDPcmZrg3MeLbR3z7iG8f8e0jvn1G+/ZRHlzlwVUeXOXBVR5c5cFVHlzt21f79hV/teKvVvzVir9a7k3Mcm9ixLeP+PYR3z7i20d8+6z27as8uMqDqzy4yoOrPLjKg6s8uNq3r/btK/5qxV+t+KsVf7Xcm5jl3sSIbx/x7SO+fcS3j/j2We3bV3lwlQdXeXCVB1d5cJUHV3lwtW9f7dtX/NWKv1rxVyv+ark3Mcu9iRHfPuLbR3z7iG8f8e2z2rev8uAqD67y4CoPrvLgKg+u8uBq377at6/4qxV/teKvVvzVcm9ilnsTI759xLeP+PYR3z7i22e1b1/lwVUeXOXBVR5c5cFVHlzlwdW+fbVvX/FXK/5qxV+t+Kvl3sQs9yZGfPuIbx/x7SO+fcS3z9O+/SkPPuXBpzz4lAef8uBTHnzKg0/79qd9+xN/9cRfPfFXT/zV497EPO5NjPj2Ed8+4ttHfPuIb5+nfftTHnzKg0958CkPPuXBpzz4lAef9u1P+/Yn/uqJv3rir574q8e9iXncmxjx7SO+fcS3j/j2Ed8+T/v2pzz4lAef8uBTHnzKg0958CkPPu3bn/btT/zVE3/1xF898VePexPzuDcx4ttHfPuIbx/x7SO+fZ727U958CkPPuXBpzz4lAef8uBTHnzatz/t25/4qyf+6om/euKvHvcm5nFvYsS3j/j2Ed8+4ttHfPs87duf8uBTHnzKg0958CkPPuXBpzz4tG9/2rc/8VdP/NWDv9oP/mo/7k3sx72JFd++4ttXfPuKb1/x7fuxb9+PPLgfeXA/8uB+5MH9jvoe9T3qy759P/bt+8Ff7Qd/tR/81X7wV/txb2I/7k2s+PYV377i21d8+4pv3499+37kwf3Ig/uRB/cjD+4X6hvqG+rLvn0/9u37heabmi/81X7wV/txb2I/7k2s+PYV377i21d8+4pv368039J8S/Mtzbc031LfUt9S39J8S/Ntzbc1X/ir/eCv9uPexH7cm1jx7Su+fcW3r/j2Fd++32i+o/mO5jua72i+o76jvqO+o/mu5rua72q+8Ff7wV/tx72J/bg3seLbV3z7im9f8e0rvn2/p/k+zfdpvk/zfZrvU9+nvuTBPezb97Bv3wN/tQf+ag/81R74q/+v//uu+//6v++6Fd++4ttXfPuKb1/x7f9fh+pUXapb9ahW36O+V33Zt+9h374H/moP/NUe+Ks98Fd7uDexh3sTK759xbev+PYV377i2/ewb99DHtxDHtxDHtxDHtwT6pvqm+qbmm9qvqn5puYLf7UH/moP9yb2cG9ixbev+PYV377i21d8+57SfEvzLc23NN/SfFt9W31bfVvzbc23Nd/WfOGv9sBf7eHexB7uTaz49hXfvuLbV3z7im/fM5rvaL6j+Y7mu5rvqu+q76rvar6r+a7mu5ov/NUe+Ks93JvYw72JFd++4ttXfPuKb1/x7Xue5vs0X/LgXvLgXvLgXvLgXvLgXvLgXvbte9m374W/2gt/tRf+ai/81V7uTezl3sSKb1/x7Su+fcW3r/j2vezb95IH95IH95IH95IH9171vep71Zd9+1727Xvhr/bCX+2Fv9oLf7WXexN7uTex4ttXfPuKb1/x7Su+fW9ovqn5puabmm9qvqm+qb6pvqn5puabmm9pvvBXe+Gv9nJvYi/3JlZ8+4pvX/HtK759xbfvbc23Nd/WfFvzbc231bfVt9W3Nd/WfEfzHc0X/mov/NVe7k3s5d7Eim9f8e0rvn3Ft6/49r2r+a7mu5rvar6r+a76rvqu+q7m+zTfp/k+zRf+ai/81V7uTezl3sSKb1/x7Su+fcW3r/j2DfbtG8qDoTwYyoOhPBjKg6E8GMqDwb59g337BvzVBvzVBvzVBvzVBvcmNrg3seLbV3z7im9f8e0rvn2DffuG8mAoD4byYCgPhvJgKA+G8mCwb99g374Bf7UBf7UBf7UBf7XBvYkN7k2s+PYV377i21d8+4pv30jNV3kwlAdDeTCUB0N5MJQHQ3kwSvMtzbc039J84a824K82uDexwb2JFd++4ttXfPuKb1/x7Rut+SoPhvJgKA+G8mAoD4byYCgPxmi+o/mO5juaL/zVBvzVBvcmNrg3seLbV3z7im9f8e0rvn1jNV/lwVAeDOXBUB4M5cFQHgzlwXia79N8n+b7NF/4qw34q03uTWxyb2LFt6/49hXfvuLbV3z7Jvv2TeXBVB5M5cFUHkzlwVQeTOXBZN++yb59E/5qE/5qE/5qE/5qk3sTm9ybWPHtK759xbev+PYV377Jvn1TeTCVB1N5MJUHU3kwlQdTeTDZt2+yb9+Ev9oMzRf+ahP+apN7E5vcm1jx7Su+fcW3r/j2Fd++mZqv8mAqD6byYCoPpvJgKg+m8mCW5luab2m+rfnCX23CX21yb2KTexMrvn3Ft6/49hXfvuLbN0fzVR5M5cFUHkzlwVQeTOXBVB7M0XxH813NdzVf+KtN+KtN7k1scm9ixbev+PYV377i21d8++bTfJUHU3kwlQdTeTCVB1N5MJUHU/v20r694K+24K+24K+24K+2uDexxb2JFd++4ttXfPuKb1/x7Vvat5fyYCkPlvJgKQ+W8mApD5byYGnfXtq3F/zVFvzVFvzVFvzVFvcmtrg3seLbV3z7im9f8e0rvn1L+/ZSHizlwVIeLOXBUh4s5cFSHizt20v79krNNzVf+Kst+Kst7k1scW9ixbev+PYV377i21d8+5b27aU8WMqDpTxYyoOlPFjKg6U8WNq3l/bt1Zpva77wV1vwV1vcm9ji3sSKb1/x7Su+fcW3r/j2Le3bS3mwlAdLebCUB0t5sJQHS3mwtG8v7dtrNd/VfOGvtuCvtrg3scW9iRXfvuLbV3z7im9f8e1b2reX8mApD5byYCsPtvJgKw+28mBr397atzf81Tb81Tb81Tb81Tb3Jra5N7Hi21d8+4pvX/HtK759W/v2Vh5s5cFWHmzlwVYebOXBVh5s7dtb+/aGv9qGv9qGv9qGv9rm3sQ29yZWfPuKb1/x7Su+fcW3b2vf3sqDrTzYyoOtPNjKg6082MqDrX17a9/eqfmm5gt/tQ1/tc29iW3uTaz49hXfvuLbV3z7im/f1r69lQdbebCVB1t5sJUHW3mwlQdb+/bWvr1b8x3NF/5qG/5qm3sT29ybWPHtK759xbev+PYV376tfXsrD7byYCsPtvJgKw+28mArD7b27a19ez/N92m+8Ffb8Ffb3JvY5t7Eim9f8e0rvn3Ft6/49h3t20d5cJQHR3lwlAdHeXCUB0d5cLRvH+3bB/5qB/5qB/5qB/5qh3sTO9ybWPHtK759xbev+PYV376jffsoD47y4CgPjvLgKA+O8uAoD4727aN9+8Bf7cBf7cBf7cBf7XBvYod7Eyu+fcW3r/j2Fd++4tt3tG8f5cFRHhzlwVEeHOXBUR4c5cHRvn20b5/SfEvzhb/agb/a4d7EDvcmVnz7im9f8e0rvn3Ft+9o3z7Kg6M8OMqDozw4yoOjPDjKg6N9+2jfPqP5juYLf7UDf7XDvYkd7k2s+PYV377i21d8+4pv39G+fZQHR3lwlAdHeXCUB0d5cJQHR/v20b59nub7NF/4qx34qx3uTexyb2LFt6/49hXfvuLbV3z7rvbtqzy4yoOrPLjKg6s8uMqDqzy42rev9u0r/mrFX634qxV/tdyb2OXexIpvX/HtK759xbev+PZd7dtXeXCVB1d5cJUHV3lwlQdXeXC1b1/t21f81Yq/WvFXK/5quTexy72JFd++4ttXfPuKb1/x7bvat6/y4CoPrvLgKg+u8uAqD67y4Grfvtq3r/irFX+14q9W/NVyb2KXexMrvn3Ft6/49hXfvuLbd7VvX+XBVR5c5cFVHlzlwVUeXOXB1b59tW9f8Vcr/mrFX634q+XexC73JlZ8+4pvX/HtK759xbfvat++yoOrPLjKg6s8uMqDqzy4yoOrfftq3/7EXz3xV0/81RN/9bg3sY97Eyu+fcW3r/j2Fd++4tv3ad/+lAef8uBTHnzKg0958CkPPuXBp3370779ib964q+e+Ksn/upxb2If9yZWfPuKb1/x7Su+fcW379O+/SkPPuXBpzz4lAef8uBTHnzKg0/79qd9+xN/9cRfPfFXT/zV497EPu5NrPj2Fd++4ttXfPuKb9+nfftTHnzKg0958CkPPuXBpzz4lAef9u1P+/Yn/uqJv3rir574q8e9iX3cm1jx7Su+fcW3r/j2Fd++T/v2pzz4lAef8uBTHnzKg0958CkPPu3bn/btT/zVE3/1xF898VePexP7uDex4ttXfPuKb1/x7Su+fZ/27U958CkPPuXBRx58H3nwfeTB95EH38e+/X3s298Hf/U++Kv3wV+9D/7qfdybeB/3Jp749ie+/Ylvf+Lbn/j297Fvfx958H3kwfeRB99HHnzfVd+rvld92be/j337++Cv3gd/9T74q/fBX72PexPv497EE9/+xLc/8e1PfPsT3/4+9u3vIw++LzTf1HxT8031TfVN9U3NNzXf1HxT84W/eh/81fu4N/E+7k088e1PfPsT3/7Etz/x7e8rzbc039Z8W/NtzbfVt9W31bc139Z8W/NtzRf+6n3wV+/j3sT7uDfxxLc/8e1PfPsT3/7Et79vNN/VfFfzXc13Nd9V31XfVd/VfFfzXc33ab7wV++Dv3of9ybex72JJ779iW9/4tuf+PYnvv0d9u3vkAffIQ++Qx58hzz4Dnnw/+tWPaqZ72Hf/g781TvwV+/AX/1/Har/+657h3sTT3z7E9/+xLc/8e1PfPs77NvfIQ++Qx58hzz4Dnnwnau+V32v+rJvf4d9+zvwV+/AX70Df/UO/NU73Jt4h3sTT3z7E9/+xLc/8e1PfPs7qfmm5puab2q+qfmm+qb6pvqW5luab2m+pfnCX70Df/UO9ybe4d7EE9/+xLc/8e1PfPsT3/5Oa76t+bbm25pva76tvq2+o76j+Y7mO5rvaL7wV+/AX73DvYl3uDfxxLc/8e1PfPsT3/7Et7+zmu9qvqv5rua7mu+q71Pfp75P832a79N8n+YLf/UO/NU73Jt4h3sTT3z7E9/+xLc/8e1PfPu77NvfJQ++Sx58lzz4Lnnw3aO+R32P+rJvf5d9+7vwV+/CX70Lf/Uu/NW73Jt4l3sTT3z7E9/+xLc/8e1PfPu77NvfJQ++Sx58lzz4Lnnw3VDfUN9QX/bt77Jvfxf+6l34q3fhr96Fv3qXexPvcm/iiW9/4tuf+PYnvv2Jb383Nd/UfFPzLc23NN9S31LfUt/SfEvzLc23NF/4q3fhr97l3sS73Jt44tuf+PYnvv2Jb3/i299tzbc139F8R/MdzXfUd9R31Hc039F8R/MdzRf+6l34q3e5N/Eu9yae+PYnvv2Jb3/i25/49ndX832a79N8n+b7NN+nvk99n/o+zfdpvvBXL+CvXsBfvYC/esG9iRfcm3ji25/49ie+/Ylvf+LbX7Bvf6E8GMqDoTwYyoOhPBjKg6E8GOzbX7BvfwF/9QL+6gX81Qv4qxfcm3jBvYknvv2Jb3/i25/49ie+/QX79hfKg6E8GMqDoTwYyoOhPBjKgxGab2q+qfmm5gt/9QL+6gX3Jl5wb+KJb3/i25/49ie+/Ylvf1Gar/JgKA+G8mAoD4byYCgPhvJgtObbmm9rvq35wl+9gL96wb2JF9ybeOLbn/j2J779iW9/4ttfjOarPBjKg6E8GMqDoTwYyoOhPBir+a7mu5rvar7wVy/gr15wb+IF9yae+PYnvv2Jb3/i25/49hdP81UeDOXBUB4M5cFQHkzlwVQeTPbtL9m3v4S/egl/9RL+6iX81UvuTbzk3sQT3/7Etz/x7U98+xPf/pJ9+0vlwVQeTOXBVB5M5cFUHkzlwWTf/pJ9+0v4q5fwVy/hr17CX73k3sRL7k088e1PfPsT3/7Etz/x7S/Zt79UHkzlwVQeTOXBVB5M5cFUHszUfFPzTc03NV/4q5fwVy+5N/GSexNPfPsT3/7Etz/x7U98+8vSfJUHU3kwlQdTeTCVB1N5MJUHszXf1nxb823NF/7qJfzVS+5NvOTexBPf/sS3P/HtT3z7E9/+cjRf5cFUHkzlwVQeTOXBVB5M5cFczXc139V8V/OFv3oJf/WSexMvuTfxxLc/8e1PfPsT3/7Et7/Uvr2UB0t5sJQHS3mwlAdLebCUB0v79tK+veCvXsFfvYK/egV/9Yp7E6+4N/HEtz/x7U98+xPf/sS3v9K+vZQHS3mwlAdLebCUB0t5sJQHS/v20r694K9ewV+9gr96BX/1insTr7g38cS3P/HtT3z7E9/+xLe/0r69lAdLebCUB0t5sJQHS3mwlAdL+/bSvr1K8y3NF/7qFfzVK+5NvOLexBPf/sS3P/HtT3z7E9/+Svv2Uh4s5cFSHizlwVIeLOXBUh4s7dtL+/YazXc0X/irV/BXr7g38Yp7E098+xPf/sS3P/HtT3z7K+3bS3mwlAdLebCUB0t5sJQHS3mwtG8v7dvrab5P84W/egV/9Yp7E6+4N/HEtz/x7U98+xPf/sS3v9a+vZUHW3mwlQdbebCVB1t5sJUHW/v21r694a9ew1+9hr96DX/1mnsTr7k38cS3P/HtT3z7E9/+xLe/1r69lQdbebCVB1t5sJUHW3mwlQdb+/bWvr3hr17DX72Gv3oNf/WaexOvuTfxxLc/8e1PfPsT3/7Et7/Wvr2VB1t5sJUHW3mwlQdbebCVB1v79ta+vUvzLc0X/uo1/NVr7k285t7EE9/+xLc/8e1PfPsT3/5a+/ZWHmzlwVYebOXBVh5s5cFWHmzt21v79h7NdzRf+KvX8FevuTfxmnsTT3z7E9/+xLc/8e1PfPtr7dtbebCVB1t5sJUHW3mwlQdbebC1b2/t2/tpvvBXb+Cv3sBfveHexBvuTTzx7U98+xPf/sS3P/Htb7RvH+XBUR4c5cFRHhzlwVEeHOXB0b59tG8f+Ks38Fdv4K/ewF+94d7EG+5NPPHtT3z7E9/+xLc/8e1vtG8f5cFRHhzlwVEeHOXBUR4c5cHRvn20b5/UfFPzhb96A3/1hnsTb7g38cS3P/HtT3z7E9/+xLe/0b59lAdHeXCUB0d5cJQHR3lwlAdH+/bRvn1a823NF/7qDfzVG+5NvOHexBPf/sS3P/HtT3z7E9/+Rvv2UR4c5cFRHhzlwVEeHOXBUR4c7dtH+/ZZzXc1X/irN/BXb7g38YZ7E098+xPf/sS3P/HtT3z7G+3bR3lwlAdHeXCUB0d5cJQHV3lwtW9f7dtX/NWKv1rxVyv+ark38ZZ7E098+xPf/sS3P/HtT3z7W+3bV3lwlQdXeXCVB1d5cJUHV3lwtW9f7dtX/NWKv1rxVyv+ark38ZZ7E098+xPf/sS3P/HtT3z7W+3bV3lwlQdXeXCVB1d5cJUHV3lwtW9f7dtX/NWKv1rxVyv+ark38ZZ7E098+xPf/sS3P/HtT3z7W+3bV3lwlQdXeXCVB1d5cJUHV3lwtW9f7dtX/NWKv1rxVyv+ark38ZZ7E098+xPf/sS3P/HtT3z7W+3bV3lwlQdXeXCVB1d5cJUHV3lwtW9f7dtX/NWKv1rxVyv+ark38ZZ7E098+xPf/sS3P/HtT3z7W+3bV3nwKQ8+5cGnPPiUB5/y4FMefNq3P+3bn/irJ/7qib964q8e9ybe497EE9/+xLc/8e1PfPsT3/6e9u1PefApDz7lwac8+JQHn/LgUx582rc/7duf+Ksn/uqJv3rirx73Jt7j3sQT3/7Etz/x7U98+xPf/p727U958CkPPuXBpzz4lAef8uBTHnzatz/t25/4qyf+6om/euKvHvcm3uPexBPf/sS3P/HtT3z7E9/+nvbtT3nwKQ8+5cGnPPiUB5/y4FMefNq3P+3bn/irJ/7qib964q8e9ybe497EE9/+xLc/8e1PfPsT3/6e9u1PefApDz7lwac8+JQHn/LgUx582rc/7duf+Ksn/uqJv3rirx73Jt7j3sQT3/7g2+8H3/5PfVRf1aE6VZfqVj2qV7X6HvX9b9/+T31Vh+pUXapb9d933T/133fdP/Xf3/n/6/++r/6pj+qrOlSn6lLdqkf1qlbfUN9Q3//27f/UoTpVl+pWPar/vuv+qf++6/6/Tv2dU/NNzTc139R8U/NNzTc139R8U/Mt9S31LfUtzbc039J8S/P9j7/6p17Vj7n/d2/in1p/59Z8W/Ntzbc139Z8W/Ntzbc139F8R31HfUd9R/MdzXc039F8/+Ov/qkf9X/3Jv6pD3Nf/Z1X813NdzXf1XxX813NdzXfp/k+zfep71Pfp75P832a79N8n+b7H391v/Mff/VPff6b+/nv3sQ/NX9n+PZ/6lLdqkf1qma+53yqj+qrWn2P+h71Pcz3nFG9qpnv+Y+/+qc+qu9/cz//3Zv4p+bvDN/+T92qR/WqZr4nPtVH9VUdqtU31DfUN5jviVWt+abmm0f1VR3M/b97E//U+jun5puab2q+qfmW5luab2m+pfmW5lvqW+pb6luab2m+rfm25ttXdahO5v7fvYl/av2dW/Ntzbc139F8R/MdzXc039F8R/Md9R31HfUdzXc139V8V/PdUJ2qi7n/d2/in1p/59V8V/N9mu/TfJ/m+zTfp/k+zfdpvk99n/o++t6P+d7vqL6qQ3WqLtX939zvf/cm/qn5O199X119X8G3/1Nf1aE6VZfqVj2q1feo71Xfy3zvvapDdaou1a2a77p7+a67+r66+r66+r6Cb/+nDtWpulS36lG9qtU31TfVNzXf1HxT803NN1v1qOa77ibfdVffV1ffV1ffV/Dt/9Sab2m+pfmW5luab2m+rb6tvq2+rfm25tuab2u+PapXNd91d/iuu/q+uvq+uvq+gm//p9Z8R/MdzXc039F8V/Nd9V31XfVdzXc139V8V/PdVc27cB/fdffxXXf1fXX1fXX1fQXf/k+t+T7N92m+yoOhPBjKg6E8GMqDoTwYH/ONr1WP6lXNuxDnU813XRy+60LfV6Hvq9D3FXz7P/WoXtXMN5QHQ3kwlAdDeTCUB0N5MC7zjTuqVzXzjfhUH9V810XwXRf6vgp9X4W+r+Db/6lXtearPBjKg6E8GMqDoTwYyoOhPBip+abmm5pvab51VF/VfNdF8V0X+r4KfV+Fvq/g2/+pNd/WfJUHQ3kwlAdDeTCUB0N5MJQHozXf1nxH8x3Nd67qUM13XQzfdaHvq9D3Vej7Cr79/+vVfFfzVR4M5cFQHgzlwVAeDOXBUB6M1Xyf5vs036f5vlCdqvmui8d3Xej7KvR9Ffq+gm//pz6qr+pQnapLdase1atafQ/zzXNUX9WhOlWXar7r8vBdl/q+Sn1fpb6v4Nv/qa/qUJ2qS3WrHtXqqzyYyoMZzDfjqg7VqbpUt2q+6zL4rkt9X6W+r1LfV/Dt/9Sab2q+yoOpPJjKg6k8mMqDqTyYyoNZmm9pvqX5luZbrXpU812XxXdd6vsq9X2V+r6Cb/+n1nxb81UeTOXBVB5M5cFUHkzlwVQezNF8R/MdzXc03xnVq5rvuly+61LfV6nvq9T3FXz7P7Xmu5qv8mAqD6byYCoPpvJgKg+m8mA+zfdpvk/zfZrvW9W8C/XxXVcf33Wl76vS91Xp+6q0by/t20v79lIeLOXBUh4s5cFSHizlwVIeLO3bS/v2OqN6VfMu1P1U811Xl++60vdV6fuq9H1V2reX9u2lfXspD5byYCkPlvJgKQ+W8mApD5b27aV9e8Wq1nzzU31U811XyXdd6fuq9H1V+r4q7dtL+/bSvr2UB0t5sJQHS3mwlAdLebCUB0v79tK+vUrzbc23j+qrmu+6ar7rSt9Xpe+r0vdVad9e2reX9u2lPFjKg6U8WMqDpTxYyoOlPFjat5f27bWa72q+e1WHar7ravmuK31flb6vSt9XpX17ad9e2reX8mApD5byYCkPlvJgKQ+W8mBp397at/d3VF/VoTpV813XH991re+r1vdV6/uqtW9v7dtb+/ZWHmzlwVYebOXBVh5s5cFWHmzt21v79r5XdahO1aWa77q+fNe1vq9a31et76vWvr21b2/t21t5sJUHW3mwlQdbebCVB1t5sLVvb+3bOzXf1HyzVLdqvus6+a5rfV+1vq9a31etfXtr397at7fyYCsPtvJgKw+28mArD7byYGvf3tq3d2u+rfl2qx7VfNd1813X+r5qfV+1vq9a+/bWvr21b2/lwVYebOXBVh5s5cFWHmzlwda+vbVv79V8V/PdUb2q+a7rx3dd6/uq9X3V+r5q7dtb+/bWvr2VB1t5sJUHR3lwlAdHeXCUB0f79tG+fb5WPapXNe/CHL7r5vBdN/q+Gn1fjb6vRvv20b59tG8f5cFRHhzlwVEeHOXBUR4c5cHRvn20b587qlc178LEp5rvugm+60bfV6Pvq9H31WjfPtq3j/btozw4yoOjPDjKg6M8OMqDozw42reP9u2Tmm9qvvWpPqr5rpviu270fTX6vhp9X4327aN9+2jfPsqDozw4yoOjPDjKg6M8OMqDo337aN8+rfmO5jtH9VXNd90M33Wj76vR99Xo+2q0bx/t20f79lEeHOXBUR4c5cFRHhzlwVEeHO3bR/v2eZrv03zfVR2q+a6bx3fd6Ptq9H01+r4a7dtX+/bVvn2VB1d5cJUHV3lwlQdXeXCVB1f79tW+fcVfrfirFX+14q/28F23h++61ffV6vtq9X212rev9u2rffsqD67y4CoPrvLgKg+u8uAqD6727at9+4q/WvFXK/5qxV9t8F23wXfd6vtq9X21+r5a7dtX+/bVvn2VB1d5cJUHV3lwlQdXeXCVB1f79tW+fcVfrfirFX+14q+2+K7b4rtu9X21+r5afV+t9u2rfftq377Kg6s8uMqDqzy4yoOrPLjKg6t9+2rfvuKvVvzVir9a8Vc7fNft8F23+r5afV+tvq9W+/bVvn21b1/lwVUeXOXBVR5c5cFVHlzlwdW+fbVvX/FXK/5qxV+t+Kt9fNe9j++6p++rp++rp++rp3370779ad/+lAef8uBTHnzKg0958CkPPuXBp3370779ib964q+e+Ksn/updvuve5bvu6fvq6fvq6fvqad/+tG9/2rc/5cGnPPiUB5/y4FMefMqDT3nwad/+tG9/4q+e+Ksn/uqJv3rJd91Lvuuevq+evq+evq+e9u1P+/anfftTHnzKg0958CkPPuXBpzz4lAef9u1P+/Yn/uqJv3rir574q9d8173mu+7p++rp++rp++pp3/60b3/atz/lwac8+JQHn/LgUx58yoNPefBp3/60b3/ir574qyf+6om/est33Y9vv//WpbpVj+pV/aj/93v1Vx/VV3WoVt+nvk99n/o+9X3/9T0/vv2vPqqv6lCdqkt1qx7Vq1p9j/oe9T3qe9T3qO9R36O+R32P+h71vep71feq71Xfq75Xfa/6XvW96nvVN9Q31DfUN9Q31DfUN9Q31DfUN9Q31TfVN9U31TfVN9U31TfVN9U31bfUt9S31LfUt9S31LfUt9S31LfUt9W31bfVt9W31bfVt9W31bfVt9V31HfUd9R31HfUd9R31HfUd9R31HfVd9V31XfVd9V31XfVd9V31XfV96nvU9+nvk99n/o+9X3q+9T3qa9+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r45+r358e9xf/U/fiF/dqkf1qn7U//u9+quP6qs6VKdq9S31LfX93+9V5K9+1P/7vfqrj+qrOlT/r+/vv/1/v1exv7pVj+pV/aj/93v1V//TN8+v/qdv/v6e//u9+qtTdalu1aN6VT/q//1e/dVHtfqu+q76/u/3Kn9/z//9Xv3Vo3pVP+r//V791Uf1//r2rw7V//St71f/07d+f5///V791aN6Vb//6h/f/lcf1Vd1qE7VpbpVj+r/9b2/+lH/7/fqrz6qr+pQnar/17d+dav+X9/51f/ru7/6Uf/v9+qvPqqv6lCdqkt1qx7V6nvVN9T3f79X9X71VR2qU3WpbtWj+p++/fv7/O/36t/6f79X3b/6n779+/v87/fqrw7VqbpUt+pRvaof9f9+r/5q9S31LfX93+9V//4+//u9+qtb9ahe1Y/6f79Xf/U/fef37/B/v1fz+5v87/fqr07V//Sd+NWtev77f+3Ht8/v39v/fq/+rf/3e/VX/6/v72/+v9+rvzpU8y78+Pbf7/CPb/+rR/Wq5l348e1/9VF9VYfqVK2+q76rvsu78OPb/63fp/qovqpDNe/Cj2///bb/+Pa/elSvat6FH9/+V/Mu/Pj23+/wj2//q1N1qW7Vo3pV8y78+Pa/+qhW36O+R30P78KPb/+rR/Wq5l348e1/9VHNu/Dj2/9q3oUf3/77Hf7x7X/1qF7VvAs/vv2vPqqv6lCdqtU31DfUN3gXfnz7v3V+qo/qqzpUp2rehR/f/lfzLvz49t/v8I9v/7euT/VRfVWH6lRdqlv1qFbfUt9W3+Zd+PHtf3WoTtWlulWPat6FH9/+bz28Cz++/fc7/OPb/+pQnapLdase1auad+HHt//V6rvqu+q7vAs/vv2vbtWjelXzLvz49r+ad+HHt/9+/398+1+dqnkXfnz7X8278OPbf7//P779V//49r+ad+HHt//VoZp34ce3/36Hf3z7Xz2qVzXvwo9v/6uP6qs6VKdq9T3qe9T38C78+PZ/6/upPqqv6lDNu/Dj23+/7T++/a8e1auad+HHt//VvAs/vv33O/zj2//qVF2qW/WoXtW8Cz++/a8+qtU31TfVN3kXfnz7Xz2qVzXvwo9v/6uPat6FH9/+V/Mu/Pj23+/wj2//q0f1quZd+PHtf/VRfVWH6lStvq2+rb7Nu/Dj2/+t51N9VF/VoTpV8y78+Pa/mnfhx7f/fod/fPu/9X6qj+qrOlSn6lLdqke1+q76PvV9vAs/vv2vDtWpulS36lHNu/Dj23/1j2//vQs/vv33O/zj2//qUJ2qS3WrHtWrmnfhx7f/1ep71Peo7+Fd+PHtf3WrHtWrmnfhx7f/1bwLP7799/v/49v/6lTNu/Dj2/9q3oUf3/77/f/x7f/W8anmXfjx7X91qOZd+PHtv9/hH9/+V4/qVc278OPb/+qj+qoO1alafbW/Ku2vfnz777f9x7f/W9en+qi+qkM178KPb//9tv/49r96VK9q3oUf3/5X8y78+Pbf7/CPb/+rU3WpbtWjelXzLvz49r/6qFZf7a9K+6sf3/77Pf/x7X/1qF7VvAs/vv2vPqp5F358+1/Nu/Dj23+/wz++/a8e1auad+HHt//VR/VVHapTtfpqf1XaX/349t/v+Y9v/9U/vv2vPqqv6lCdqnkXfnz7X8278OPbf7/DP7793/p8qo/qqzpUp+pS3apHtfpqf9XaX/349t/v+Y9v/6tDdaou1a16VPMu/Pj2f+vgXfjx7b/f4R/f/leH6lRdqlv1qF7VvAs/vv2vVl/tr1r7qx/f/vs9//Htf3WrHtWrmnfhx7f/1bwLP7799/v/49v/6lTNu/Dj2/9q3oUf3/77/f/x7f/W/anmXfjx7X91qOZd+PHtv9/hH9/+V4/qVc278OPb/+qj+qoO1alafbW/au2vfnz777f9x7f/W++n+qi+qkM178KPb//9tv/49r96VK9q3oUf3/5X8y78+Pbf7/CPb/+rU3WpbtWjelXzLvz49r/6qL6qQ3Wq5l348e1/9ahe1bwLP779rz6qeRd+fPtfzbvw49t/v8M/vv2vHtWrmnfhx7f/1Uf1VR2qU7X6an812l/9+Pbf7/mPb/+3jk/1UX1Vh+pUzbvw49v/at6FH9/++x3+8e3/1vmpPqqv6lCdqkt1qx7V6qv91Wh/9ePbf7/nP779rw7VqbpUt+pRzbvw49v/rZt34ce3/36Hf3z7Xx2qU3WpbtWjelXzLvz49r9afbW/Gu2vfnz77/f8x7f/1a16VK9q3oUf3/5X8y78+Pbf7/+Pb/+rUzXvwo9v/6t5F358++/3/8e3/1u/TzXvwo9v/6tDNe/Cj2///Q7/+Pa/elSvat6FH9/+Vx/VV3WoTtWlulWPat6FH9/+b30+1Uf1VR2qeRd+fPvvt/3Ht//Vo3pV8y78+Pa/mnfhx7f/fod/fPtfnapLdase1auad+HHt//VR7X6an+12l/9+Pbf7/mPb/+rR/Wq5l348e1/9VHNu/Dj2/9q3oUf3/77Hf7x7X/1qF7VvAs/vv2vPqqv6lCdqtVX+6vV/urHt/9+z398+791f6qP6qs6VKdq3oUf3/5X8y78+Pbf7/CPb/+3nk/1UX1Vh+pUXapb9ahWX+2vVvurH9/++z3/8e1/dahO1aW6VY9q3oUf3/5v/XgXfnz773f4x7f/1aE6VZfqVj2qVzXvwo9v/6uP6qs6VPMu/Pj2v7pVj+pVzbvw49v/at6FH9/++/3/8e1/darmXfjx7X8178KPb//9/v/49n/r+6nmXfjx7X91qOZd+PHtv9/hH9/+V4/qVc278OPb/+qj+qoO1alafbW/etpf/fj232/7j2//t85P9VF9VYdq3oUf3/77bf/x7X/1qF7VvAs/vv2v5l348e2/3+Ef3/5Xp+pS3apH9armXfjx7X/1Ua2+2l897a9+fPvv9/zHt//Vo3pV8y78+Pa/+qjmXfjx7X8178KPb//9Dv/49r96VK9q3oUf3/5XH9VXdahO1eqr/dXT/urHt/9+z398+7/1+1Qf1Vd1qE7VvAs/vv2v5l348e2/3+Ef3/6/+v749r/6qL6qQ3WqLtWtelSvavU96nv+exfuj2//q0N1qi7VrXpU//cu3B/f/m99/3sX7o9v/9/v8P3x7X91qE7VpbpVj+pV/ajjU62+ob6hvvHfu3B/fPtf3apH9ap+1Pmp/u9duD++fX5/kwzVqfq/d+H++Pa/+r934f749v/9/t8f3/5vXZ/q/96F++Pb/+pQ/d+7cD940fvBi94PXvT++Pa/+lH3p/qovqpDdapW31bfVt/+7124P77933o+1Uf1VR2q/3sX7o9vj9+MplWP6lX9qPdT/d+7cD940fvBi94PXvT++Pa/ulWP6lX9qN+n+qhW36e+T33ff+/C/fHtf/WoXtX/vQv3x7f/1Uf1f+/C/fHtf/V/78I98KL3wIveAy96f3z7X/2oz6f6qL6qQ3WqVt+jvkd9z3/vwv3x7f/W91N9VF/VoTpV//cu3B/f/lf/9y7cAy96D7zoPfCi98e3/9VXdahO1aW6VY9q9Q31TfVN3oUf3/5Xh+pUXapb9ajmXfjx7f/Wxbtw4EXvgRe9B170/vj2v7pUt+pRvap5F358+1+tvq2+rb7Nu/Dj2//qVj2qVzXvwo9v/6t5F358++/3/8e3/9Wpmnfhx7f/1bwLP7799/v/49v/rfdTzbvw49v/6lDNu3DgRe+BF70HXvT++Pa/mnfhx7f/1Uf1VR2qU7X6PvV96vt4F358+6/+8e1/9VF9VYdq3oUf3/77bf/x7X/1qF7VvAs/vv2v5l248KL3woveCy96f3z7X92qR/Wq5l348e1/9VGtvld9r/pe3oUf3/5Xj+pVzbvw49v/6qOad+HHt//VvAsXXvReeNF74UXvj2//q3kXfnz7X31UX9WhOlWrb6pvqm/yLvz49n/r+lQf1Vd1qE7VvAs/vv2v5l248KL3woveCy96f3z7X31Vh+pUXapb9ahW31bfUd/hXfjx7X91qE7VpbpVj2rehR/f/m+9vAsXXvReeNF74UXvj2//q0t1qx7Vq5p34ce3/9Xq+9T3qe/jXfjx7X91qx7Vq5p34ce3/9W8Cz++/ff7/+Pb/+pUzbvw49v/at6FH9/++/3/8e3/1udTzbvw49v/6lDNuxDwojfgRW/Ai94f3/5X8y78+Pa/+qi+qkN1qlbfq75XfS/vwo9v/7eOT/VRfVWHat6FH9/++23/8e1/9ahe1bwLP779r+ZdCHjRG/CiN+BF749v/6tb9ahe1bwLP779rz6q1bfUt9S3eBd+fPtfPapXNe/Cj2//q49q3oUf3/5X8y4EvOgNeNEb8KL3x7f/1bwLP779rz6qr+pQnarVd9R31Hd4F358+7/1fqqP6qs6VKdq3oUf3/5X8y4EvOgNeNEb8KL3x7f/1Vd1qE7VpbpVj2r11f4qtb/68e2/3/Mf3/5Xh+pUXapb9ajmXfjx7f/Wh3ch4UVvwovehBe9P779ry7VrXpUr2rehR/f/lerr/ZXqf3Vj2///Z7/+Pa/ulWP6lXNu/Dj2/9q3oUf3/77/f/x7X91quZd+PHtfzXvwo9v//3+//j2f+v8VPMu/Pj2vzpU8y4kvOhNeNGb8KI38Z1v4jvfxHe+ie98E9/5Jr7zTXznm9pfpfZXqf1V4jvfxHe+ie98E9/5Jr7zTXznm/jON/Gdb+I738R3vonvfBPf+Sa+801855vwojfhRW/Ci97Ed76J73wT3/kmvvNNfOeb+M438Z1van+V2l+l9leJ73wT3/kmvvNNfOeb+M438Z1v4jvfxHe+ie98E9/5JrzoTXjRm/CiN/Gdb+I738J3voXvfAvf+Ra+8y1851vaX5X2V6X9VeE738J3voXvfAvf+Ra+8y1851v4zrfwnW/hO9/Cd74FL3oLXvQWvOgtfOdb+M638J1v4Tvfwne+he98C9/5lvZXpf1VaX9V+M638J1v4Tvfwne+he98C9/5Fr7zLXznW/jOt/Cdb8GL3oIXvQUvegvf+Ra+8y1851v4zrfwnW/hO9/Cd76l/VVpf1XaXxW+8y1851v4zrfwnW/hO9/Cd76F73wL3/kWvvMtfOdb+M638J1v4Tvfwne+he98C9/5Fr7zLXznW/jOt/Cdb+E734IXvQUvegte9Ba+8y1851v4zrfwnW/hO9/Cd76F73xL+6vS/qq0vyp851v4zrfwnW/hO9/Cd76F73wL3/kWvvMtfOdb+M638J1v4Tvfxne+je98G170NrzobXjR2/jOt/Gdb+M738Z3vo3vfBvf+Ta+823tr1r7q9b+qvGdb+M738Z3vo3vfBvf+Ta+821859v4zrfxnW/jO9+GF70NL3obXvQ2vvNtfOfb+M638Z1v4zvfxne+je98W/ur1v6qtb9qfOfb+M638Z1v4zvfxne+je98G9/5Nr7zbXzn2/jOt+FFb8OL3oYXvY3vfBvf+Ta+821859v4zrfxnW/jO9/W/qq1v2rtrxrf+Ta+821859v4zrfxnW/jO9/Gd76N73wb3/k2vvNteNHb8KK34UVv4zvfxne+je98G9/5Nr7zbXzn2/jOt7W/au2vWvurxne+je98G9/5Nr7zbXzn2/jOt/Gdb+M738Z3vo3vfBvf+Ta+821859v4zrfxnW/jO9/Bd76D73wH3/kOvvMdfOc78KJ34EXvwIvewXe+g+98B9/5Dr7zHXznO/jOd/Cd72h/NdpfjfZXg+98B9/5Dr7zHXznO/jOd/Cd7+A738F3voPvfAff+Q6+8x185zv4znfwne/Ai96BF70DL3oH3/kOvvMdfOc7+M538J3v4DvfwXe+o/3VaH812l8NvvMdfOc7+M538J3v4DvfwXe+g+98B9/5Dr7zHXznO/Cid+BF78CL3sF3voPvfAff+Q6+8x185zv4znfwne9ofzXaX432V4PvfAff+Q6+8x185zv4znfwne/gO9/Bd76D73wH3/kOvOgdeNE78KJ38J3v4DvfwXe+g+98B9/5Dr7zHXznO9pfjfZXo/3V4DvfwXe+g+98B9/5Dr7zHXznO/jOd/Cd7+A738V3vgsvehde9C686F1857v4znfxne/iO9/Fd76L73wX3/mu9ler/dVqf7X4znfxne/iO9/Fd76L73wX3/kuvvNdfOe7+M538Z3v4jvfxXe+i+98F9/5Lr7zXXznu/jOd/Gd7+I738V3vovvfBde9C686F140bv4znfxne/iO9/Fd76L73wX3/kuvvNd7a9W+6vV/mrxne/iO9/Fd76L73wX3/kuvvNdfOe7+M538Z3v4jvfxXe+i+98F9/5Lr7zXXjRu/Cid+FF7+I738V3vovvfBff+S6+811857v4zne1v1rtr1b7q8V3vovvfBff+S6+811857v4znfxne/iO9/Fd76L73wXXvQuvOhdeNG7+M538Z3v4jvfxXe+i+98F9/5Lr7zXe2vVvur1f5q8Z3v4jvfh+98H77zffjO9+E734fvfB++8334zvfhO98nXvSJF33iRR++8334zvfhO9+H73wfvvN9+M734Tvfp/3V0/7qaX/18J3vw3e+D9/5Pnzn+/Cd78N3vg/f+T585/vwne/Dd75PvOgTL/rEiz585/vwne/Dd74P3/k+fOf78J3vw3e+T/urp/3V0/7q4Tvfh+98H77zffjO9+E734fvfB++8334zvfhO9+H73wfvvN9+M734Tvfh+98H77zffjO9+E734fvfB++8334zvfhO98nXvSJF33iRR++8334zvfhO9+H73wfvvN9+M734Tvfp/3V0/7qaX/18J3vw3e+D9/5Pnzn+/Cd78N3vg/f+T585/vwne/Dd74P3/k+fOf78J3vw3e+T7zoEy/6xIs+fOf78J3vw3e+D9/5Pnzn+PCd48N3jo/9VXzsr+JjfxUfvnN8+M7x4TvHh+8cH75zfPjO8eE7x4fvHB++c3z4zvHBi8YHLxofvGh8+M7x4TvHh+8cH75zfPjO8eE7x4fvHN9V36u+V33xnePDd44P3zk+fOf48J3jw3eOD985Pnzn+PCd48N3jg9eND540fjgRePDd44P3zk+fOf48J3jw3eOD985Pnzn+FJ9U31LffGd48N3jg/fOT585/jwnePDd44P3zk+fOf48J3jw3eOD140PnjR+OBF48N3jg/fOT585/jwnePDd44P3zk+fOf4Rn1HfUd98Z3jw3eOD985Pnzn+PCd48N3jg/fOT585/jwnePDd44P3zk+fOf48J3jw3eOD985Pnzn+PCd48N3jg/fOT585/jwneODF40PXjQ+eNH48J3jw3eOg+8cB985Dr5zHHznOPjOcdhfxWF/FYf9VRx85zj4znHwnePgO8fBd46D7xwH3zkOvnMcfOc4+M5x8J3j4DvHwXeOg+8cB140DrxoHHjROPjOcfCd4+A7x8F3joPvHAffOQ6+c5xQ31DfUF985zj4znHwnePgO8fBd46D7xwH3zkOvnMcfOc4+M5x4EXjwIvGgReNg+8cB985Dr5zHHznOPjOcfCd4+A7xyn1LfUt9cV3joPvHAffOQ6+cxx85zj4znHwnePgO8fBd46D7xwHXjQOvGgceNE4+M5x8J3j4DvHwXeOg+8cB985Dr5znFHfUd9VX3znOPjOcfCd4+A7x8F3joPvHAffOQ6+cxx85zj4znHgRePAi8aBF42D7xwH3zkOvnMcfOc4+M5x8J3j4jvHZX8Vl/1VXPZXcfGd4+I7x8V3jovvHBffOS6+c1x857j4znHxnePiO8fFd46L7xwX3zkuvnNcfOe4+M5x8Z3j4jvHxXeOi+8cF985LrxoXHjRuPCicfGd4+I7x8V3jovvHBffOS6+c1x857ihvqG+ob74znHxnePiO8fFd46L7xwX3zkuvnNcfOe4+M5x8Z3j4jvHxXeOi+8cF985LrxoXHjRuPCicfGd4+I7x8V3jovvHBffOS6+c1x857itvq2+rb74znHxnePiO8fFd46L7xwX3zkuvnNcfOe4+M5x8Z3jwovGhReNCy8aF985Lr5zXHznuPjOcfGd4+I7x8V3jrvqu+q76ovvHBffOS6+c1x857j4znHxnePiO8fFd46L7xwX3zkuvGhceNEIeNEIfOcIfOcIfOcIfOcIfOcIfOcIfOcI9lcRn/oe9cV3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3joAXjYAXjYAXjcB3jsB3jsB3jsB3jsB3jsB3jsB3jgj1DfUN9cV3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3joAXjYAXjYAXjcB3jsB3jsB3jsB3jsB3jsB3jsB3jmj1bfVt9cV3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3jsB3joAXjYAXjYAXjcB3jsB3jsB3jsB3jsB3jsB3jsB3jnjq+9T3qS++cwS+cwS+cwS+cwS+cyS+cyS+cyS+cyS+cyS+cyS8aCS8aCS8aCS+cyS+cyS+cyS+cyS+cyS+cyS+c6T2V6n9VWp/lfjOkfjOkfjOkfjOkfjOkfjOkfjOkfjOkfjOkfjOkfCikfCikfCikfjOkfjOkfjOkfjOkfjOkfjOkfjOkdpfpfZXqf1V4jtH4jtH4jtH4jtH4jtH4jtH4jtH4jtH4jtH4jtHwotGwotGwotG4jtH4jtH4jtH4jtH4jtH4jtH4jtHan+V2l+l9leJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xwJLxoJLxoJLxqJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyJ7xyp/VVqf5XaXyW+cyS+cxS+cxS+cxS+cxS+cxS+cxS+cxS+cxS+cxS+cxS+cxS+cxS+cxS8aBS8aBS8aBS+cxS+cxS+cxS+cxS+cxS+cxS+c5T2V6X9VWl/VfjOUfjOUfjOUfjOUfjOUfjOUfjOUfjOUfjOUfjOUfCiUfCiUfCiUfjOUfjOUfjOUfjOUfjOUfjOUfjOUdpflfZXpf1V4TtH4TtH4TtH4TtH4TtH4TtH4TtH4TtH4TtH4TtHwYtGwYtGwYtG4TtH4TtH4TtH4TtH4TtH4TtH4TtHaX9V2l+V9leF7xyF7xyF7xyF7xyF7xyF7xyF7xyF7xyF7xyF7xwFLxoFLxoFLxqF7xyF7xyF7xyF7xyF7xyF7xyF7xyl/VVpf1XaXxW+cxS+cxS+cxS+cxS+cxS+czS+czS+czS+czS+czS+czS+czS+czS+czS+czS+czS+czS+czS+czS+czS+czS8aDS8aDS8aDS+czS+czS+czS+czS+czS+czS+c7T2V639VWt/1fjO0fjO0fjO0fjO0fjO0fjO0fjO0fjO0fjO0fjO0fjO0fjO0fjO0fjO0fCi0fCi0fCi0fjO0fjO0fjO0fjO0fjO0fjO0fjO0dpftfZXrf1V4ztH4ztH4ztH4ztH4ztH4ztH4ztH4ztH4ztH4ztHw4tGw4tGw4tG4ztH4ztH4ztH4ztH4ztH4ztH4ztHa3/V2l+19leN7xyN7xyN7xyN7xyN7xyN7xyN7xyN7xyN7xyN7xwNLxoNLxoNLxqN7xyN7xyN7xyN7xyN7xyN7xyN7xyt/VVrfzXaXw2+cwy+cwy+cwy+cwy+cwy+cwy+cwy+cwy+cwy+cwy8aAy8aAy8aAy+cwy+cwy+cwy+cwy+cwy+cwy+c4z2V6P91Wh/NfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfjOMfCiMfCiMfCiMfjOMfjOMfjOMfjOMfjOMfjOMfjOMdpfjfZXo/3V4DvH4DvH4DvH4DvH4DvH4DvH4DvH4DvH4DvH4DvH4DvH4DvH4DvH4DvHwIvGwIvGwIvG4DvH4DvH4DvH4DvH4DvH4DvH4DvHaH812l+N9leD7xyD7xyD7xyD7xyD7xyD7xyD7xyD7xyD7xyD7xwDLxoDLxoDLxqD7xyD7xyL7xyL7xyL7xyL7xyL7xyr/dVqf7XaXy2+cyy+cyy+cyy+cyy+cyy+cyy+cyy+cyy+cyy+cyy8aCy8aCy8aCy+cyy+cyy+cyy+cyy+cyy+cyy+c6z2V6v91Wp/tfjOsfjOsfjOsfjOsfjOsfjOsfjOsfjOsfjOsfjOsfCisfCisfCisfjOsfjOsfjOsfjOsfjOsfjOsfjOsdpfrfZXq/3V4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvH4jvHwovGwovGwovG4jvH4jvH4jvH4jvH4jvH4jvH4jvHan+12l+t9leL7xyL7xyL7xyL7xyL7xyL7xyL7xyL7xyL7xyL7xyL7xyL7xwP3zkevnM88aJPvOgTL/rwnePhO8fDd46H7xwP3zkevnM8fOd42l897a+e9lcP3zkevnM8fOd4+M7x8J3j4TvHw3eOh+8cD985Hr5zPPGiT7zoEy/68J3j4TvHw3eOh+8cD985Hr5zPHzneNpfPe2vnvZXD985Hr5zPHznePjO8fCd4+E7x8N3jofvHA/fOR6+czzxok+86BMv+vCd4+E7x8N3jofvHA/fOR6+czx853jaXz3tr572Vw/fOR6+czx853j4zvHwnePhO8fDd46H7xwP3zkevnM88aJPvOgTL/rwnePhO8fDd46H7xwP3zkevnM8fOd42l897a+e9lcP3zkevnM8fOd4+M7x8J3j4TvHw3eOh+8cD985Hr5zPHznePjO8fCd4+E7x8N3jofvnB++c374zvnhO+eH75wfvnN+8KL5wYvmBy+aH75zfvjO+eE754fvnB++c374zvnhO+d31Peo71FffOf88J3zw3fOD985P3zn/PCd88N3zg/fOT985/zwnfPDd84P3zk/fOf88J3zgxfND140P3jR/PCd88N3zg/fOT985/zwnfPDd84P3zm/VN9U31RffOf88J3zw3fOD985P3zn/PCd88N3zg/fOT985/zwnfODF80PXjQ/eNH88J3zw3fOD985P3zn/PCd88N3zg/fOb9W31bfVl985/zwnfPDd84P3zk/fOf88J3zw3fOD985P3zn/PCd84MXzQ9eND940fzwnfPDd84P3zk/fOf88J3zw3fOD985v1XfVd+nvvjO+eE754fvnB++c374zvnhO+eH75wfvnN++M558J3zwIvmgRfNAy+aB985D75zHnznPPjOefCd8+A758F3znPU96jvUV985zz4znnwnfPgO+fBd86D75wH3zkPvnMefOc8+M558J3z4DvnwXfOg++cB985D75zHnznPPjOefCd8+A758F3zgMvmgdeNA+8aB585zz4znnwnfPgO+fBd86D75wH3zlPqm+qb6ovvnMefOc8+M558J3z4DvnwXfOg++cB985D75zHnznPPjOefCd8+A758F3zgMvmgdeNA+8aB585zz4znnwnfPgO+fBd86D75wH3znPqO+o76gvvnMefOc8+M558J3z4DvnwXfOg++cB985D75zHnznPPCieeBF88CL5sF3zoPvnAffOQ++cx585zz4znnwnfM89X3q+9QX3zkPvnNefOe8+M558Z3z4jvnxXfOi++cF985L75zXnjRvPCieeFF8+I758V3zovvnBffOS++c15857z4znmP+h71veqL75wX3zkvvnNefOe8+M558Z3z4jvnxXfOi++cF985L7xoXnjRvPCiefGd8+I758V3zovvnBffOS++c15857ypvqm+qb74znnxnfPiO+fFd86L75wX3zkvvnNefOe8+M558Z3z4jvnxXfOi++cF985L75zXnznvPjOefGd8+I758V3zovvnBdeNC+8aF540bz4znnxnfPiO+fFd86L75wX3zkvvnPeUd9R31FffOe8+M558Z3z4jvnxXfOi++cF985L75zXnznvPjOefGd8+I758V3zovvnBdeNC+8aF540bz4znnxnfPiO+fFd86L75yB75yB75zB/iqD/VUG+6sMfOcMfOcMfOcMfOcMfOcMfOcMfOcMfOcMfOcMfOcMeNEMeNEMeNEMfOcMfOcMfOcMfOcMfOcMfOcMfOeMq75Xfa/64jtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4DtnwItmwItmwItm4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4DtnpPqm+pb64jtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4DtnwItmwItmwItm4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4DtnjPqO+o764jtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4Dtn4DtnwItmwItmwItm4Dtn4Dtn4jtn4jtn4jtn4jtn4jtnan+V2l+l9leJ75yJ75yJ75yJ75yJ75yJ75yJ75yJ75yJ75yJ75yJ75yJ75yJ75yJ75wJL5oJL5oJL5qJ75yJ75yJ75yJ75yJ75yJ75yJ75yp/VVqf5XaXyW+cya+cya+cya+cya+cya+cya+cya+cya+cya+cya8aCa8aCa8aCa+cya+cya+cya+cya+cya+cya+c6b2V6n9VWp/lfjOmfjOmfjOmfjOmfjOmfjOmfjOmfjOmfjOmfjOmfCimfCimfCimfjOmfjOmfjOmfjOmfjOmfjOmfjOmdpfpfZXqf1V4jtn4jtn4jtn4jtn4jtn4jtn4jtn4jtn4jtn4jtnwotmwotmwotm4jtn4jtn4jtn4jtn4jtn4jtn4TtnaX9V2l+V9leF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75yF75wFL5oFL5oFL5qF75yF75yF75yF75yF75yF75yF75yl/VVpf1XaXxW+cxa+cxa+cxa+cxa+cxa+cxa+cxa+cxa+cxa+cxa+cxa+cxa+cxa+cxa8aBa8aBa8aBa+cxa+cxa+cxa+cxa+cxa+cxa+c5b2V6X9VWl/VfjOWfjOWfjOWfjOWfjOWfjOWfjOWfjOWfjOWfjOWfCiWfCiWfCiWfjOWfjOWfjOWfjOWfjOWfjOWfjOWdpflfZXpf1V4Ttn4Ttn4Ttn4Ttn4Ttn4Ttn4Ttn4Ttn4Ttn4TtnwYtmwYtmw4tm4ztn4ztn4ztn4ztn4ztn4ztn4ztna3/V2l+19leN75yN75yN75yN75yN75yN75yN75yN75yN75yN75wNL5oNL5oNL5qN75yN75yN75yN75yN75yN75yN75yt/VVrf9XaXzW+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza+cza8aDa8aDa8aDa+cza+cza+cza+cza+cza+cza+c7b2V639VWt/1fjO2fjO2fjO2fjO2fjO2fjO2fjO2fjO2fjO2fjO2fjO2fjO2fjO2fjO2fCi2fCi2fCi2fjO2fjO2fjO2fjO2fjO2fjO2fjO2dpftfZXrf1V4ztn4ztn4ztn4ztn4zvn4Dvn4Dvn4Dvn4Dvn4DvnwIvmwIvmwIvm4Dvn4Dvn4Dvn4Dvn4Dvn4Dvn4DvnaH812l+N9leD75yD75yD75yD75yD75yD75yD75yD75yD75yD75wDL5oDL5oDL5qD75yD75yD75yD75yD75yD75yD75yj/dVofzXaXw2+cw6+cw6+cw6+cw6+cw6+cw6+cw6+cw6+cw6+cw68aA68aA68aA6+cw6+cw6+cw6+cw6+cw6+cw6+c472V6P91Wh/NfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfjOOfCiOfCiOfCiOfjOOfjOOfjOOfjOOfjOOfjOOfjOOdpfjfZXo/3V4Dvn4Dvn4jvn4jvn4jvn4jvn4jvn4jvn4jvn4jvn4jvn4jvn4jvn4jvnwovmwovmwovm4jvn4jvn4jvn4jvn4jvn4jvn4jvnan+12l+t9leL75yL75yL75yL75yL75yL75yL75yL75yL75yL75wLL5oLL5oLL5qL75yL75yL75yL75yL75yL75yL75yr/dVqf7XaXy2+cy6+cy6+cy6+cy6+cy6+cy6+cy6+cy6+cy6+cy68aC68aC68aC6+cy6+cy6+cy6+cy6+cy6+cy6+c672V6v91Wp/tfjOufjOufjOufjOufjOufjOufjOufjOufjOufjOufCiufCiufCiufjOufjOufjOufjOufjOufjOufjOudpfrfZXq/3V4jvn4jvn4jvn4jvn4jvn4jvnw3fOh++cD985H75zPnznfPjO+fCd8+E758N3zofvnA/fOR++cz5853z4zvnwnfOJF33iRZ940YfvnA/fOR++cz5853z4zvnwnfPhO+fT/uppf/W0v3r4zvnwnfPhO+fDd86H75wP3zkfvnM+fOd8+M758J3z4Tvnw3fOh++cD985n3jRJ170iRd9+M758J3z4Tvnw3fOh++cD985H75zPu2vnvZXT/urh++cD985H75zPnznfPjO+fCd8+E758N3zofvnA/fOZ940Sde9IkXffjO+fCd8+E758N3zofvnA/fOR++cz7tr572V0/7q4fvnA/fOR++cz5853z4zvnwnfPhO+fDd86H75wP3zmfeNEnXvSJF334zvnwnfPhO+fDd86H75wP3zkfvnM+7a8e+6v62F/Vh+9cH75zffjO9eE714fvXB++c334zvXhO9eH71wfvnN98KL1wYvWBy9aH75zffjO9eE714fvXB++c334zvXhO9d31feq71VffOf68J3rw3euD9+5Pnzn+vCd68N3rg/fuT585/rwnevDd64P37k+fOf68J3rw3euD9+5Pnzn+vCd68N3rg/fuT585/rgReuDF60PXrQ+fOf68J3rw3euD9+5Pnzn+vCd68N3rq/Ut9S31BffuT585/rwnevDd64P37k+fOf68J3rw3euD9+5Pnzn+vCd68N3rg/fuT585/rgReuDF60PXrQ+fOf68J3rw3euD9+5Pnzn+vCd68N3rm/Vd9V31RffuT585/rwnevDd64P37k+fOf68J3rw3euD9+5Pnzn+uBF64MXrQ9etD585/rwnevgO9fBd66D71wH37kOvnMd9ld12F/VYX9VB9+5Dr5zHXznOvjOdfCd6+A718F3roPvXAffuQ6+cx140TrwonXgRevgO9fBd66D71wH37kOvnMdfOc6+M51rvpe9Q31xXeug+9cB9+5Dr5zHXznOvjOdfCd6+A718F3roPvXAdetA68aB140Tr4znXwnevgO9fBd66D71wH37kOvnOdUt9S31JffOc6+M518J3r4DvXwXeug+9cB9+5Dr5zHXznOvjOdfCd6+A718F3roPvXAffuQ6+cx185zr4znXwnevgO9fBd64DL1oHXrQOvGgdfOc6+M518J3r4DvXwXeug+9cB9+5zqrvqu+qL75zHXznOvjOdfCd6+A718F3roPvXAffuQ6+cx185zr4znXwneviO9fFd64LL1oXXrQuvGhdfOe6+M518Z3r4jvXxXeui+9cF9+57lHfo75HffGd6+I718V3rovvXBffuS6+c11857r4znXxneviO9eFF60LL1oXXrQuvnNdfOe6+M518Z3r4jvXxXeui+9cN9Q31DfUF9+5Lr5zXXznuvjOdfGd6+I718V3rovvXBffuS6+c1140brwonXhReviO9fFd66L71wX37kuvnNdfOe6+M51S31LfVt98Z3r4jvXxXeui+9cF9+5Lr5zXXznuvjOdfGd6+I714UXrQsvWhdetC6+c11857r4znXxneviO9fFd66L71x31XfVd9UX37kuvnNdfOe6+M518Z3r4jvXxXeui+9cF9+5Lr5zXXznuvjOdfGd6+I718V3rovvXIHvXIHvXIHvXIHvXIHvXAEvWgEvWgEvWoHvXIHvXIHvXIHvXIHvXIHvXIHvXHHU96jvUV985wp85wp85wp85wp85wp85wp85wp85wp85wp85wp85wp85wp85wp85wp40Qp40Qp40Qp85wp85wp85wp85wp85wp85wp854pU31TfVF985wp85wp85wp85wp85wp85wp85wp85wp85wp85wp40Qp40Qp40Qp85wp85wp85wp85wp85wp85wp854pW31bfVl985wp85wp85wp85wp85wp85wp85wp85wp85wp85wp40Qp40Qp40Qp85wp85wp85wp85wp85wp85wp854pV31Xfp774zhX4zhX4zhX4zhX4zhX4zhX4zhX4zhX4zpX4zpXwopXwopXwopX4zpX4zpX4zpX4zpX4zpX4zpX4zpXaX6X2V6n9VeI7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V+I7V8KLVsKLVsKLVuI7V+I7V+I7V+I7V+I7V+I7V+I7V2p/ldpfpfZXie9cie9cie9cie9cie9cie9cie9cie9cie9cie9cie9cie9cie9cie9cCS9aCS9aCS9aie9cie9cie9cie9cie9cie9cie9cqf1Van+V2l8lvnMlvnMlvnMlvnMlvnMlvnMlvnMlvnMlvnMlvnMlvGglvGglvGglvnMlvnMlvnMlvnMlvnMlvnMlvnOl9lep/VVqf5X4zpX4zlX4zlX4zlX4zlX4zlX4zlX4zlX4zlX4zlXwolXwolXwolX4zlX4zlX4zlX4zlX4zlX4zlX4zlXaX5X2V6X9VeE7V+E7V+E7V+E7V+E7V+E7V+E7V+E7V+E7V+E7V8GLVsGLVsGLVuE7V+E7V+E7V+E7V+E7V+E7V+E7V2l/VdpflfZXhe9che9che9che9che9che9che9che9che9che9che9che9che9che9che9che9che9che9che9che9che9cBS9aBS9aBS9ahe9che9che9che9che9che9che9cpf1VaX9V2l8VvnMVvnMVvnMVvnMVvnMVvnMVvnMVvnMVvnMVvnMVvnMVvnMVvnMVvnMVvGgVvGgVvGgVvnMVvnMVvnMVvnMVvnM1vnM1vnO19let/VVrf9X4ztX4ztX4ztX4ztX4ztX4ztX4ztX4ztX4ztX4ztXwotXwotXwotX4ztX4ztX4ztX4ztX4ztX4ztX4ztXaX7X2V639VeM7V+M7V+M7V+M7V+M7V+M7V+M7V+M7V+M7V+M7V8OLVsOLVsOLVuM7V+M7V+M7V+M7V+M7V+M7V+M7V2t/1dpftfZXje9cje9cje9cje9cje9cje9cje9cje9cje9cje9cDS9aDS9aDS9aje9cje9cje9cje9cje9cje9cje9crf1Va3/V2l81vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vnM1vGg1vGg1vGg1vnM1vnMNvnMNvnMNvnMNvnMNvnON9lej/dVofzX4zjX4zjX4zjX4zjX4zjX4zjX4zjX4zjX4zjX4zjX4zjX4zjX4zjX4zjXwojXwojXwojX4zjX4zjX4zjX4zjX4zjX4zjX4zjXaX432V6P91eA71+A71+A71+A71+A71+A71+A71+A71+A71+A718CL1sCL1sCL1uA71+A71+A71+A71+A71+A71+A712h/NdpfjfZXg+9cg+9cg+9cg+9cg+9cg+9cg+9cg+9cg+9cg+9cAy9aAy9aAy9ag+9cg+9cg+9cg+9cg+9cg+9cg+9co/3VaH812l8NvnMNvnMNvnMNvnMNvnMNvnMNvnMNvnMNvnMNvnMNvGgNvGgNvGgNvnMNvnMNvnMNvnMNvnMNvnMtvnOt9ler/dVqf7X4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrX4zrXworXworXworX4zrX4zrX4zrX4zrX4zrX4zrX4zrXaX632V6v91eI71+I71+I71+I71+I71+I71+I71+I71+I71+I71+I71+I71+I71+I718KL1sKL1sKL1uI71+I71+I71+I71+I71+I71+I712p/tdpfrfZXi+9ci+9ci+9ci+9ci+9ci+9ci+9ci+9ci+9ci+9cCy9aCy9aCy9ai+9ci+9ci+9ci+9ci+9ci+9ci+9cq/3Van+12l8tvnMtvnMtvnMtvnMtvnMtvnMtvnMtvnMtvnMtvnMtvGiteNEnXvThO9fDd66H71wP37kevnM9fOd6+M71tL962l897a8evnM9fOd6+M718J3r4TvXw3euh+9cD9+5Hr5zPXzneuJFn3jRJ1704TvXw3euh+9cD9+5Hr5zPXznevjO9bS/etpfPe2vHr5zPXznevjO9fCd6+E718N3rofvXA/fuR6+cz1853r4zvXwnevhO9fDd66H71wP37kevnM9fOd6+M718J3r4TvXEy/6xIs+8aIP37kevnM9fOd6+M718J3r4TvXw3eup/3V0/7qaX/18J3r4TvXw3euh+9cD9+5Hr5zPXznevjO9fCd6+E718N3rofvXA/fuR6+cz3xok+86BMv+vCd6+E718N3rofvXA/fuR6+cz1853raXz3tr572Vw/fuR6+cz1853r4zvXwnfvDd+4P37k/fOf+8J37w3fuD160P3jR/uBF+8N37g/fuT985/7wnfvDd+4P37k/fOf+jvoe9T3qi+/cH75zf/jO/eE794fv3B++c3/4zv3hO/eH79wfvnN/8KL9wYv2By/aH75zf/jO/eE794fv3B++c3/4zv3hO/cX6hvqm+qL79wfvnN/+M794Tv3h+/cH75zf/jO/eE794fv3B++c3/wov3Bi/YHL9ofvnN/+M794Tv3h+/cH75zf/jO/eE799fq2+rb6ovv3B++c3/4zv3hO/eH79wfvnN/+M794Tv3h+/cH75zf/jO/eE794fv3B++c3/4zv3hO/eH79wfvnN/+M794Tv3h+/cH7xof/Ci/cGL9ofv3B++c3/4zv3hO/eH79wfvnN/+M79PfV96vvUF9+5P3znPvjOffCd++A798F37oPv3AffuQ++cx985z74zn3wnfvgO/fBd+4DL9oHXrQPvGgffOc++M598J374Dv3wXfug+/cB9+5z1Xfq75XffGd++A798F37oPv3AffuQ++cx985z74zn3wnfvgO/eBF+0DL9oHXrQPvnMffOc++M598J374Dv3wXfug+/cJ9U31TfVF9+5D75zH3znPvjOffCd++A798F37oPv3AffuQ++cx940T7won3gRfvgO/fBd+6D79wH37kPvnMffOc++M59Wn1bfUd98Z374Dv3wXfug+/cB9+5D75zH3znPvjOffCd++A794EX7QMv2gdetA++cx985z74zn3wnfvgO/fBd+6D79znqe9T36e++M598J374Dv3wXfug+/cB9+5L75zX3znvvjOffGd++I798V37ovv3BffuS++c1985774zn3xnfviO/fFd+6L79wXXrQvvGhfeNG++M598Z374jv3xXfui+/cF9+5L75z36u+V32v+uI798V37ovv3BffuS++c1985774zn3xnfviO/fFd+6L79wX37kvvnNffOe+8KJ94UX7wov2xXfui+/cF9+5L75zX3znvvjOffGd+5b6lvqW+uI798V37ovv3BffuS++c1985774zn3xnfviO/fFd+4LL9oXXrQvvGhffOe++M598Z374jv3xXfui+/cF9+576jvqO+oL75zX3znvvjOffGd++I798V37ovv3BffuS++c198577won3hRfvCi/bFd+6L79wX37kvvnNffOe++M598Z37PvVlf9XB/qoD37kD37kD37kD37kD37kD37kD37kD37kD37kD37kDXrQDXrQDXrQD37kD37kD37kD37kD37kD37kD37njqu9V36u++M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d8KId8KId8KId+M4d+M4d+M4d+M4d+M4d+M4d+M4dpb6lvqW++M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d8KId8KId8KId+M4d+M4d+M4d+M4d+M4d+M4d+M4dq76rvqu++M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d+M4d8KId8KId8KId+M4d+M6d+M6d+M6d+M6d+M6d+M6d2l+l9lep/VXiO3fiO3fiO3fiO3fiO3fiO3fiO3fiO3fiO3fiO3fCi3bCi3bCi3biO3fiO3fiO3fiO3fiO3fiO3fiO3dqf5XaX6X2V4nv3Inv3Inv3Inv3Inv3Inv3Inv3Inv3Inv3Inv3Akv2gkv2gkv2onv3Inv3Inv3Inv3Inv3Inv3Inv3Kn9VWp/ldpfJb5zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ75zJ7xoJ7xoJ7xoJ75zJ75zJ75zJ75zJ75zJ75zJ75zp/ZXqf1Van+V+M6d+M6d+M6d+M6d+M6d+M6d+M6d+M6d+M6d+M6d+M6d+M5d+M5d+M5d8KJd8KJd8KJd+M5d+M5d+M5d+M5d+M5d+M5d+M5d2l+V9lel/VXhO3fhO3fhO3fhO3fhO3fhO3fhO3fhO3fhO3fhO3fBi3bBi3bBi3bhO3fhO3fhO3fhO3fhO3fhO3fhO3dpf1XaX5X2V4Xv3IXv3IXv3IXv3IXv3IXv3IXv3IXv3IXv3IXv3AUv2gUv2gUv2oXv3IXv3IXv3IXv3IXv3IXv3IXv3KX9VWl/VdpfFb5zF75zF75zF75zF75zF75zF75zF75zF75zF75zF7xoF7xoF7xoF75zF75zF75zF75zF75zF75zF75zl/ZXpf1VaX9V+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M5d+M7d+M7d+M7d+M7d+M7d+M7d8KLd8KLd8KLd+M7d+M7d+M7d+M7d+M7d+M7d+M7d2l+19let/VXjO3fjO3fjO3fjO3fjO3fjO3fjO3fjO3fjO3fjO3fjO3fjO3fjO3fjO3fDi3bDi3bDi3bjO3fjO3fjO3fjO3fjO3fjO3fjO3drf9XaX7X2V43v3I3v3I3v3I3v3I3v3I3v3I3v3I3v3I3v3I3v3A0v2g0v2g0v2o3v3I3v3I3v3I3v3I3v3I3v3I3v3K39VWt/1dpfNb5zN75zN75zN75zN75zN75zN75zN75zN75zN75zN7xoN7xoN7xoN75zN75zN75zN75zN75zN75zN75zt/ZXrf1Va3/V+M7d+M7d+M7d+M7d+M7d+M7d+M7d+M7d+M49+M498KI98KI98KI9+M49+M49+M49+M49+M49+M49+M492l+N9lej/dXgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fgO/fAi/bAi/bAi/bgO/fgO/fgO/fgO/fgO/fgO/fgO/dofzXaX432V4Pv3IPv3IPv3IPv3IPv3IPv3IPv3IPv3IPv3IPv3IPv3IPv3IPv3IPv3AMv2gMv2gMv2oPv3IPv3IPv3IPv3IPv3IPv3IPv3KP91Wh/NdpfDb5zD75zD75zD75zD75zD75zD75zD75zD75zD75zD7xoD7xoD7xoD75zD75zD75zD75zD75zD75zD75zj/ZXo/3VaH81+M49+M69+M69+M69+M69+M69+M69+M69+M69+M698KK98KK98KK9+M69+M69+M69+M69+M69+M69+M692l+t9ler/dXiO/fiO/fiO/fiO/fiO/fiO/fiO/fiO/fiO/fiO/fCi/bCi/bCi/biO/fiO/fiO/fiO/fiO/fiO/fiO/dqf7XaX632V4vv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Asv2gsv2gsv2ovv3Ivv3Ivv3Ivv3Ivv3Ivv3Ivv3Kv91Wp/tdpfLb5zL75zL75zL75zL75zL75zL75zL75zL75zL75zL75zL75zL75zL75zL7xoL7xoL7xoL75zL75zL75zL75zL75zP3znfvjO/bS/etpfPe2vHr5zP3znfvjO/fCd++E798N37ofv3A/fuR++cz98537iRZ940Sde9OE798N37ofv3A/fuR++cz985374zv20v3raXz3trx6+cz985374zv3wnfvhO/fDd+6H79wP37kfvnM/fOd+4kWfeNEnXvThO/fDd+6H79wP37kfvnM/fOd++M79tL962l897a8evnM/fOd++M798J374Tv3w3fuh+/cD9+5H75zP3znfuJFn3jRJ1704Tv3w3fuh+/cD9+5H75zP3znfvjO/bS/etpfPe2vHr5zP3znfvjO/fCd++E798N37ofv3A/fuR++cz985374zv3wnfvhO/fDd+6H79wP37kfvnM/fOd++M798J374Tv3Ey/6xIs+8aIP37kfvvN8+M7z4TvPh+88H77zfPjO87G/mo/91Xzsr+bDd54P33k+fOf58J3nw3eeD995Pnzn+fCd58N3ng/feT585/nwnefDd54P33k+eNH54EXngxedD995Pnzn+fCd58N3ng/feT585/nwnecL9Q31DfXFd54P33k+fOf58J3nw3eeD995Pnzn+fCd58N3ng/feT540fngReeDF50P33k+fOf58J3nw3eeD995Pnzn+fCd5yv1LfUt9cV3ng/feT585/nwnefDd54P33k+fOf58J3nw3eeD995PnjR+eBF54MXnQ/feT585/nwnefDd54P33k+fOf58J3nG/Ud9V31xXeeD995Pnzn+fCd58N3ng/feT585/nwnefDd54P33k+eNH54EXngxedD995Pnzn+fCd58N3ng/feT585zn4znPYX81hfzWH/dUcfOc5+M5z8J3n4DvPwXeeg+88B995Dr7zHHznOfjOc/Cd5+A7z8F3noPvPAffeQ6+8xx85zn4znPwnefgO8/Bd54DLzoHXnQOvOgcfOc5+M5z8J3n4DvPwXeeg+88B995TqhvqG+oL77zHHznOfjOc/Cd5+A7z8F3noPvPAffeQ6+8xx85zn4znPwnefgO8/Bd54DLzoHXnQOvOgcfOc5+M5z8J3n4DvPwXeeg+88B995Tqtvq2+rL77zHHznOfjOc/Cd5+A7z8F3noPvPAffeQ6+8xx85znwonPgRefAi87Bd56D7zwH33kOvvMcfOc5+M5z8J3nrPqu+q764jvPwXeeg+88B995Dr7zHHznOfjOc/Cd5+A7z8F3ngMvOgdedC686Fx857n4znPxnefiO8/Fd56L7zwX33ku+6u5n/oe9cV3novvPBffeS6+81x857n4znPxnefiO8/Fd56L7zwXXnQuvOhceNG5+M5z8Z3n4jvPxXeei+88F995Lr7z3FDfUN9QX3znufjOc/Gd5+I7z8V3novvPBffeS6+81x857n4znPxnefiO8/Fd56L7zwX33kuvvNcfOe5+M5z8Z3n4jvPxXeeCy86F150LrzoXHznufjOc/Gd5+I7z8V3novvPBffeW6rb6tvqy++81x857n4znPxnefiO8/Fd56L7zwX33kuvvNcfOe5+M5z8Z3n4jvPxXeeCy86F150LrzoXHznufjOc/Gd5+I7z8V3novvPBffee5T36e+T33xnefiO8/Fd56L7zwX33kC33kC33kC33kC33kC33kCXnQCXnQCXnQC33kC33kC33kC33kC33kC33kC33niqO9R36O++M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T8KIT8KIT8KIT+M4T+M4T+M4T+M4T+M4T+M4T+M4Tob6hvqm++M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T8KIT8KIT8KIT+M4T+M4T+M4T+M4T+M4T+M4T+M4Trb6tvq2++M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T+M4T8KIT8KIT8KIT+M4T+M4T+M4T+M4T+M4T+M4T+M4TT32f+j71xXeewHeexHeexHeexHeexHeexHeexHeexHeexHeexHeexHeexHeexHeehBedhBedhBedxHeexHeexHeexHeexHeexHeexHee1P4qtb9K7a8S33kS33kS33kS33kS33kS33kS33kS33kS33kS33kSXnQSXnQSXnQS33kS33kS33kS33kS33kS33kS33lS+6vU/iq1v0p850l850l850l850l850l850l850l850l850l850l40Ul40Ul40Ul850l850l850l850l850l850l850ntr1L7q9T+KvGdJ/GdJ/GdJ/GdJ/GdJ/GdJ/GdJ/GdJ/GdJ/GdJ+FFJ+FFJ+FFJ/GdJ/GdJ/GdJ/GdJ/GdJ/GdJ/GdJ7W/Su2vUvurxHeexHeexHeexHeexHeexHeewneewneewneewneewneewneewneewneewneewneewneewneewneewneewneeghedghedghedwneewneewneewneewneewneewnee0v6qtL8q7a8K33kK33kK33kK33kK33kK33kK33kK33kK33kK33kK33kK33kK33kK33kKXnQKXnQKXnQK33kK33kK33kK33kK33kK33kK33lK+6vS/qq0vyp85yl85yl85yl85yl85yl85yl85yl85yl85yl85yl40Sl40Sl40Sl85yl85yl85yl85yl85yl85yl85yntr0r7q9L+qvCdp/Cdp/Cdp/Cdp/Cdp/Cdp/Cdp/Cdp/Cdp/Cdp+BFp+BFp+BFp/Cdp/Cdp/Cdp/Cdp/Cdp/Cdp/Cdp7S/Ku2vWvurxneexneexneexneexneexneexneexneexneexneehhedhhedhhedxneexneexneexneexneexneexnee1v6qtb9q7a8a33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33ka33kaXnQaXnQaXnQa33ka33ka33ka3/n/mraDVEuX44rCc1FbjYzMyIy9PRUjjC3LRiAsIUsGY97c/Q7onrU7xbp1C7JR8AcE8c3DO8/DO8/DO8+L/dWL/dWL/dXDO8/DO8/DO8/DO8/DO8/DO8/DO8/DO8/DO8/DO8/DO8/DO8/DO8/DO8/jXnQe96LzuBedh3eeh3eeh3eeh3eeh3eeh3eeh3eeF/urF/urF/urh3eeh3eeh3eeh3eeh3eeh3eeh3eeh3eeh3eeh3eex73oPO5F53EvOg/vPA/vPIN3nsE7z+CdZ/DOM3jnmdhfTeyvJvZXg3eewTvP4J1n8M4zeOcZvPMM3nkG7zyDd57BO89wLzrDvegM96IzeOcZvPMM3nkG7zyDd57BO8/gnWdifzWxv5rYXw3eeQbvPIN3nsE7z+CdZ/DOM3jnGbzzDN55Bu88w73oDPeiM9yLzuCdZ/DOM3jnGbzzDN55Bu88g3eeif3VxP5qYn81eOcZvPMM3nkG7zyDd57BO8/gnWfwzjN45xm88wzeeQbvPIN3nsE7z+CdZ/DOM3jnGbzzDN55Bu88g3ee4V50hnvRGe5FZ/DOM3jnGbzzDN55Bu88g3eewTvPxP5qYn81sb8avPMM3nkG7zyDd57BO8/gnWfwzjN45xm88wzeeQbvPIN3HuGdR3jnEfeiI+5FR9yLjvDOI7zzCO88wjuP8M4jvPMI7zyK/ZVif6XYXwnvPMI7j/DOI7zzCO88wjuP8M4jvPMI7zzCO4+4Fx1xLzriXnSEdx7hnUd45xHeeYR3HuGdR3jnUeyvFPsrxf5KeOcR3nmEdx7hnUd45xHeeYR3HuGdR3jnEd55xL3oiHvREfeiI7zzCO88wjuP8M4jvPMI7zzCO49if6XYXyn2V8I7j/DOI7zzCO88wjuP8M4jvPMI7zzCO4/wziPuRUfci464Fx3hnUd45xHeeYR3HuGdR3jnEd55FPsrxf5Ksb8S3nmEdx7hnUd45xHeeYR3HuGdR3jnEd55hHce4Z1HeOcR3nmEdx7hnUd45zHeeYx3HuOdx3jnMd55HPeijntRx72o8c5jvPMY7zzGO4/xzmO88xjvPI79lWN/5dhfGe88xjuP8c5jvPMY7zzGO4/xzmO88xjvPMY7j/HOY7zzGO88xjuP417UcS/quBc13nmMdx7jncd45zHeeYx3HuOdx7G/cuyvHPsr453HeOcx3nmMdx7jncd45zHeeYx3HuOdx3jncdyLOu5FHfeixjuP8c5jvPMY7zzGO4/xzmO88zj2V479lWN/ZbzzGO88xjuP8c5jvPMY7zzGO4/xzmO88xjvPI57Uce9qONe1HjnMd55jHce453HeOcx3nmMdx7H/sqxv3Lsr4x3HuOdx3jnMd55jHce453HeOcx3nmMd9bCO2txL6rFvagW96JaeGctvLMW3lkL76yFd9bCO2vhnbUq3q14t+JdvLMW3lkL76yFd9bCO2vhnbXwzlp4Zy28sxbeWQvvrIV31sI7a+GdtfDOWnhnLbyzFt5ZC++shXfWwjtrcS+qxb2oFveiWnhnLbyzFt5ZC++shXfWwjtr4Z21Ot7teLfjXbyzFt5ZC++shXfWwjtr4Z218M5aeGctvLMW3lkL76yFd9bCO2vhnbW4F9XiXlSLe1EtvLMW3lkL76yFd9bCO2vhnbXwzloT7068O/Eu3lkL76yFd9bCO2vhnbXwzlp4Zy28sxbeWQvvrMW9qBb3olrci2rhnbXwzlp4Zy28sxbeWQvvrIV31nK863jX8S7eWQvvrMI7q/DOKryzCu+swjur8M4qvLMK76ziXlTFvaiKe1EV3lmFd1bhnVV4ZxXeWYV3VuGdVRXvVry74128swrvrMI7q/DOKryzCu+swjur8M4qvLMK76ziXlTFvaiKe1EV3lmFd1bhnVV4ZxXeWYV3VuGdVR3vdrzb8S7eWYV3VuGdVXhnFd5ZhXdW4Z1VeGcV3lmFd1bhnVV4ZxXeWYV3VuGdVXhnFd5ZhXdW4Z1VeGcV3lnFvaiKe1EV96IqvLMK76zCO6vwziq8swrvrMI7qybenXh34l28swrvrMI7q/DOKryzCu+swjur8M4qvLMK76zCO6vwziq8swrvrOJeVMW9qIp7URXeWYV3VuGdVXhnFd5ZG++sjXfWZn+lzf5Km/2VNt5ZG++sjXfWxjtr45218c7aeGdtvLM23lkb76zNvag296La3Itq45218c7aeGdtvLM23lkb76yNd9be8e6Od3e8i3fWxjtr45218c7aeGdtvLM23lkb7/xrv2jmwuZeVJt7UW3uRbXxztp4Z228szbeWRvvrI131sY7a3e82/HujXfxztp4Z228szbeWRvvrI131sY7a+OdtfHO2nhnbe5FtbkX1eZeVBvvrI131sY7a+OdtfHO2nhnbbyz9sS7E+9OvIt31sY7a+OdtfHO2nhnbbyzNt5ZG++sjXfWxjtr45218c7aeGdtvLM23lkb76yNd9bGO2vjnbXxztp4Z23uRbW5F9XmXlQb76yNd9bBO+vgnXXwzjp4Zx28sw77Kx32Vzrsr3Twzjp4Zx28sw7eWQfvrIN31sE76+CddfDOOnhnHbyzDt5ZB++sg3fW4V5Uh3tRHe5FdfDOOnhnHbyzDt5ZB++sg3fWwTvrnHj3xLsn3sU76+CddfDOOnhnHbyzDt5ZB++sg3fWwTvr4J11uBfV4V5Uh3tRHbyzDt5ZB++sg3fWwTvr4J118M46N9698e6Nd/HOOnhnHbyzDt5ZB++sg3fWwTvr4J118M46eGcd7kV1uBfV4V5UB++sg3fWwTvr4J118M46eGcdvLPOxLsT7yrexTvr4J118M46eGcdvLMO3lkH76yDd9bBO+vgnXW4F9XhXlSHe1EdvLMO3lkH76yDd9bBO+vgndV4Z3Xsrzr2Vx37q8Y7q/HOaryzGu+sxjur8c5qvLMa76zGO6vxzmq8sxrvrMY7q/HOaryzGu+sxjur8c5qvLMa76zGO6u5F1VzL6rmXlSNd1bjndV4ZzXeWY13VuOd1XhndeyvOvZXHfurxjur8c5qvLMa76zGO6vxzmq8sxrvrMY7q/HOaryzGu+sxjur8c5q7kXV3IuquRdV453VeGc13lmNd1bjndV4ZzXeWR37q479Vcf+qvHOaryzGu+sxjur8c5qvLMa76zGO6vxzmq8s5p7UTX3omruRdV4ZzXeWY13VuOd1XhnNd5ZjXdWx/6qY3/Vsb9qvLMa76zGO6vxzmq8sxrvrMY7q/HOaryzGu+s5l5Uzb2oLveiunhnXbyzLt5ZF++si3fWxTvr4p11Y391Y391Y3918c66eGddvLMu3lkX76yLd9bFO+vinXXxzrp4Z13uRXW5F9XlXlQX76yLd9bFO+vinXXxzrp4Z128s27sr27sr27sry7eWRfvrIt31sU76+KddfHOunhnXbyzLt5ZF++si3fWxTvr4p118c66eGddvLMu3lkX76yLd9bFO+vinXW5F9XlXlSXe1FdvLMu3lkX76yLd9bFO+vinXXxzrqxv7qxv7qxv7p4Z128sy7eWRfvrIt31sU76+KddfHOunhnXbyzLt5ZF++si3fWxTvrci+qy72oLveiunhnXbyzLt5ZF++si3fWxTvr4p11Y391Y391Y3918c66eGddvLMu3lkX76yHd9bDO+vhnfXwznp4Zz3uRfW4F9XjXlQP76yHd9bDO+vhnfXwznp4Zz28s17sr17sr17srx7eWQ/vrId31sM76+Gd9fDOenhnPbyzHt5ZD++sx72oHveietyL6uGd9fDOenhnPbyzHt5ZD++sh3fWi/3Vi/3Vi/3Vwzvr4Z318M56eGc9vLMe3lkP76yHd9bDO+vhnfW4F9XjXlSPe1E9vLMe3lkP76yHd9bDO+vhnfXwznqxv3qxv3qxv3p4Zz28sx7eWQ/vrId31sM76+Gd9fDOenhnPbyzHt5ZD++sh3fWwzvr4Z318M56eGc9vLMe3lkP76yHd9bjXlSPe1E97kX18M56eGc9vLMe3lkP76yHd9bDO+vF/urF/urF/urhnfXwzhq8swbvrME7a/DOGryzBu+swTtr8M4avLMG76zBO2vwzhruRTXci2q4F9XgnTV4Zw3eWYN31uCdNXhnDd5ZE/urif3VxP5q8M4avLMG76zBO2vwzhq8swbvrME7a/DOGryzhntRDfeiGu5FNXhnDd5Zg3fW4J01eGcN3lmDd9bE/mpifzWxvxq8swbvrME7a/DOGryzBu+swTtr8M4avLMG76zhXlTDvaiGe1EN3lmDd9bgnTV4Zw3eWYN31uCdNbG/mthfTeyvBu+swTtr8M4avLMG76zBO2vwzhq8swbvrME7a7gX1XAvquFeVIN31uCdNXhnDd5Zg3fW4J01eGdN7K8m9lcT+6vBO2vwzhq8swbvrME7a/DOEt5ZwjtLeGcJ7yzhnSW8s4R3lvDOEt5ZwjtLeGcJ7yzhnSW8s4R3lrgXlbgXlbgXlfDOEt5ZwjtLeGcJ7yzhnSW8sxT7K8X+SrG/Et5ZwjtLeGcJ7yzhnSW8s4R3lvDOEt5ZwjtLeGcJ7yzhnSW8s8S9qMS9qMS9qIR3lvDOEt5ZwjtLeGcJ7yzhnaXYXyn2V4r9lfDOEt5ZwjtLeGcJ7yzhnSW8s4R3lvDOEt5Z4l5U4l5U4l5UwjtLeGcJ7yzhnSW8s4R3lvDOUuyvFPsrxf5KeGcJ7yzhnSW8s4R3lvDOEt5ZwjtLeGcJ7yxxLypxLypxLyrhnSW8s4R3lvDOEt5ZwjtLeGcp9leK/ZVjf2W8s4x3lvHOMt5ZxjvLeGcZ7yzjnWW8s4x3luNe1HEv6rgXNd5ZxjvLeGcZ7yzjnWW8s4x3lmN/5dhfOfZXxjvLeGcZ7yzjnWW8s4x3lvHOMt5ZxjvLeGcZ7yzjnWW8s4x3lvHOMt5ZxjvLeGcZ7yzjnWW8sxz3oo57Uce9qPHOMt5ZxjvLeGcZ7yzjnWW8sxz7K8f+yrG/Mt5ZxjvLeGcZ7yzjnWW8s4x3lvHOMt5ZxjvLeGcZ7yzjnWW8sxz3oo57Uce9qPHOMt5ZxjvLeGcZ7yzjnWW8sxz7K8f+yrG/Mt5ZxjvLeGcZ7yzjnWW8s4x3lvHOMt5ZxjvLcS/quBd13Isa7yzjnb3wzl54Zy+8sxfe2Qvv7MX+yov9lRf7Ky+8sxfe2Qvv7IV39sI7e+GdvfDOXnhnL7yzF97Zi3tRL+5FvbgX9cI7e+GdvfDOXnhnL7yzF97ZC+/stePdHe+eeBfv7IV39sI7e+GdvfDOXnhnL7yzF97ZC+/shXf24l7Ui3tRL+5FvfDOXnhnL7yzF97ZC+/shXf2wjt73Xj3xrs33sU7e+GdvfDOXnhnL7yzF97ZC+/shXf2wjt74Z298M5eeGcvvLMX3tkL7+yFd/bCO3vhnb3wzl54Zy+8sxf3ol7ci3pxL+qFd/bCO3vhnb3wzl54Zy+8sxfe2UvxruJdxbt4Zy+8sxfe2Qvv7IV39sI7e+GdvfDOXnhnL7yzF97ZC+/swju78M4u7kVd3Iu6uBd14Z1deGcX3tmFd3bhnV14Zxfe2VXxbsW7Fe/inV14Zxfe2YV3duGdXXhnF97ZhXd24Z1deGcX96Iu7kVd3Iu68M4uvLML7+zCO7vwzi68swvv7Drx7ol3T7yLd3bhnV14Zxfe2YV3duGdXXhnF97ZhXd24Z1d3Iu6uBd1cS/qwju78M4uvLML7+zCO7vwzi68s+vGuzfeffEu3tmFd3bhnV14Zxfe2YV3duGdXXhnF97ZhXd2cS/q4l7Uxb2oC+/swju78M4uvLML7+zCO7vwzi7Fu4p3Fe/inV14Zxfe2YV3duGdXXhnF97ZhXd24Z1deGcX3tmFd3bhnV14Zxfe2YV39sY7e+OdvfHO3nhnb7yzN/ei3tyLenMv6o139sY7e+OdvfHO3nhnb7yzN97Zu+Ldincr3sU7e+OdvfHO3nhnb7yzN97ZG+/sjXf2xjt745298c7eeGdvvLM33tmbe1Fv7kW9uRf1xjt745298c7eeGdvvLM33tkb7+zd8W7Hux3v4p298c7eeGdvvLM33tkb7+yNd/bGO3vjnb3xzt7ci3pzL+rNvag33tkb7+yNd/bGO3vjnb3xzt54Z+8X775498W7eGdvvLM33tkb7+yNd/bGO3vjnb3xzt54Z2+8szf3ot7ci3pzL+qNd/bGO3vjnb3xzt54Z2+8szfe2VvxruJdx7t4Z2+8szfe2Rvv7I139sY7e+OdvfHO3nhnH7yzD/eiPtyL+nAv6oN39sE7++CdffDOPnhnH7yzD97Zp+Ldincr3sU7++CdffDOPnhnH7yzD97ZB+/sg3f2wTv74J198M4+eGcfvLMP3tkH7+yDd/bBO/vgnX3wzj54Zx+8sw/3oj7ci/pwL+qDd/bBO/vgnX3wzj54Zx+8sw/e2afj3Y53O97FO/vgnX3wzj54Zx+8sw/e2Qfv7IN39sE7++CdffDOPnhnH7yzD97Zh3tRH+5FfbgX9cE7++CdffDOPnhnH7yzD97ZB+/sM/HuxLsT7+KdffDOPnhnH7yzD97ZB+/sg3f2wTv74J198M4+3Iv6cC/qw72oD97ZB+/sg3f2wTv74J198M4+eGcfx7uOdx3v4p198M5uvLMb7+zGO7vxzm68sxvv7MY7u/HObu5F3dyLurkXdeOd3XhnN97ZjXd2453deGc33tkd+6uO/VXH/qrxzm68sxvv7MY7u/HObryzG+/sxju78c5uvLObe1E396Ju7kXdeGc33tmNd3bjnd14Zzfe2Y13dsf+qmN/1bG/aryzG+/sxju78c5uvLMb7+zGO7vxzm68sxvv7MY7u/HObryzG+/sxju78c5uvLMb7+zGO7vxzm68s5t7UTf3om7uRd14Zzfe2Y13duOd3XhnN97ZjXd2x/6qY3/Vsb9qvLMb7+zGO7vxzm68sxvv7MY7u/HObryzG+/sxju78c5uvLMb7+zmXtTNvaibe1E33tmNd3bjnd14Zzfe2Rfv7It39o391Y391Y391cU7++KdffHOvnhnX7yzL97ZF+/si3f2xTv74p19uRf15V7Ul3tRX7yzL97ZF+/si3f2xTv74p198c6+sb+6sb+6sb+6eGdfvLMv3tkX7+yLd/bFO/vinX3xzr54Z1+8sy/3or7ci/pyL+qLd/bFO/vinX3xzr54Z1+8sy/e2Tf2Vzf2Vzf2Vxfv7It39sU7++KdffHOvnhnX7yzL97ZF+/si3f25V7Ul3tRX+5FffHOvnhnX7yzL97ZF+/si3f2xTv7xv7qxv7qxv7q4p198c6+eGdfvLMv3tkX7+yLd/bFO/vinX3xzr54Z1+8sy/e2Rfv7It39sU7++KdffHOvnhnX7yzL97Zl3tRX+5FfbkX9cU7++Kd/fDOfnhnP7yzH97ZD+/sF/urF/urF/urh3f2wzv74Z398M5+eGc/vLMf3tkP7+yHd/bDO/vhnf3wzn54Zz+8sx/3on7ci/pxL+qHd/bDO/vhnf3wzn54Zz+8sx/e2S/2Vy/2Vy/2Vw/v7Id39sM7++Gd/fDOfnhnP7yzH97ZD+/sh3f2417Uj3tRP+5F/fDOfnhnP7yzH97ZD+/sh3f2wzv7xf7qxf7qxf7q4Z398M5+eGc/vLMf3tkP7+yHd/bDO/vhnf3wzn7ci/pxL+rHvagf3tkP7+yHd/bDO/vhnf3wzn54Z7/YX73YX73YXz28sx/e2Q/v7Id39sM7++Gd/fDOfnhnP7yzH97Zj3tRP+5F/bgX9cM7++Gd/fDOfnhnP7yzH97Zg3f2xP5qYn81sb8avLMH7+zBO3vwzh68swfv7ME7e/DOHryzB+/swTt78M4evLMH7+zBO3vwzh68swfv7ME7e/DOHryzh3tRD/eiHu5FPXhnD97Zg3f24J09eGcP3tmDd/bE/mpifzWxvxq8swfv7ME7e/DOHryzB+/swTt78M4evLMH7+zBO3vwzh68swfv7OFe1MO9qId7UQ/e2YN39uCdPXhnD97Zg3f24J09sb+a2F9N7K8G7+zBO3vwzh68swfv7ME7e/DOHryzB+/swTt7uBf1cC/q4V7Ug3f24J09eGcP3tmDd/bgnT14Z0/sryb2VxP7q8E7e/DOHryzB+/swTt78M4evLMH7+zBO3vwzh7uRT3ci1rci1p4ZwvvbOGdLbyzhXe28M4W3tmK/ZVif6XYXwnvbOGdLbyzhXe28M4W3tnCO1t4ZwvvbOGdLe5FLe5FLe5FLbyzhXe28M4W3tnCO1t4ZwvvbMX+SrG/UuyvhHe28M4W3tnCO1t4ZwvvbOGdLbyzhXe28M4W3tnCO1t4ZwvvbOGdLbyzhXe28M4W3tnCO1t4Z4t7UYt7UYt7UQvvbOGdLbyzhXe28M4W3tnCO1uxv1LsrxT7K+GdLbyzhXe28M4W3tnCO1t4ZwvvbOGdLbyzhXe28M4W3tnCO1vci1rci1rci1p4ZwvvbOGdLbyzhXe28M4W3tmK/ZVif6XYXwnvbOGdLbyzhXe28M423tnGO9t4ZxvvbOOd7bgXddyLOu5FjXe28c423tnGO9t4ZxvvbOOd7dhfOfZXjv2V8c423tnGO9t4ZxvvbOOdbbyzjXe28c423tmOe1HHvajjXtR4ZxvvbOOdbbyzjXe28c423tmO/ZVjf+XYXxnvbOOdbbyzjXe28c423tnGO9t4ZxvvbOOd7bgXddyLOu5FjXe28c423tnGO9t4ZxvvbOOd7dhfOfZXjv2V8c423tnGO9t4ZxvvbOOdbbyzjXe28c423tnGO9t4ZxvvbOOdbbyzjXe28c423tnGO9t4ZxvvbMe9qONe1HEvaryzjXe28c423tnGO9t4ZxvvbMf+yrG/cuyvjHe2v975rPX1zp+u6B19on/mwqd/5sKnX/REK9r01zt/+mcufPrn+/zpE93RN/pFT7SiTX+986crOt7d8e6Od7/e+dMveqIVbfrrnT9d0T9z4dMn+mcufPrn+/zpFz3Rijb99c6frugdfaI7Ot7teLfj3a93/rTpr3f+dEXv6BPd0T9z4dMv+mcufPrn+/xp09970U9X9I4+0R19o1/0RMe7L96dePfrnT+9o090R9/oFz3RP3Ph06a/3vnTP9/nT+/oE93RN/pFT7SiTX+986fjXce7jne/3vnTN/pFT7Si/e36eudP/8yFT//MhU+f6I7+mQufftE/c+HTP3Ph06a/3vnTP3Ph0zv6RP/MhU//fJ8//aInWtGmv9750xW9o090R8e7O97d8e7XO3+auVBnRVf0jj7RzIU6zIU6L3qiFc1cqF7RzIVqvs/VJ7qjb/SLnmhFMxfqruiKjndvvHvj3ctcqPuiJ1rRzIV6K7qimQv1TjRzoR7f53oveqIVzVyoWdEVvaNPdEfHuxPvTrw7zIUa5kJpRVf0jj7RHc1cKL1o5kKJ73OJ73N5RVf0jj7RHX2jX/REx7vm3b1WNHNhrx19ojv6Rr/oiWYu7MVc2MVc2MX3edeOPtEdfaNf9EQrmrmw94qOd3e8u+PdzVzY+0a/6IlWNHNhnxXNXNiHubDPie5o5sI+L5q5sA9zYR/mwu4VzVzYvaNPNHNhN9/n3S96ohXNXNh3RVf0jj7RHR3v3nj3xruXubAvc2G/FV3RO/pEMxf2Yy7s96InWtHMhT0rmrmwh+/znhPd0Tf6RU+0opkLWyu6ouNdxbuKd8Vc2HrRE61o5sL2iq5o5sL2iWYubPN93n7RE61o5sJZK7qid/SJ7ugb/aInmrlwFnPh1Iqu6B19ojuauXDqRTMXTvF9PsX3+ewVXdE7+kR39I1+0RMd7+5498S7h7lwzo4+0R19o1/0RDMXzmEunGYunOb7fHpHn+iOvtEveqIVzVw4d0XHuzfevfHuZS6ce6Nf9EQrmrlw3opmLpzHXDjvRHc0c+G8F81cOI+5cB5z4cyKZi6c2dEnmrlwhu/zmRc90YpmLhyt6Ire0Se6o+NdxbuKd8VcOGIuHK/oit7RJ5q5cMxcOH7RE61o5kKvFc1c6MX3udeJ7ugb/aInWtHMha4VXdHxbuyvOvZXXcyFrhc90YpmLvRe0RXNXOh9opkLvfk+937RE61o5kKfFV3RO/pEd3S8G/urjv1VH+ZCH+ZC94qu6B19ojuaudD9opkL3Xyfu/k+913RFb2jT3RH3+gXPdHxbuyvOvZX/ZgL/Xb0ie7oG/2iJ5q50I+50MNc6OH73LOjT3RH3+gXPdGKZi60VnS8G/urjv1Vi7nQutEveqIVzVxor2jmQpu50D7RHc1caL9o5kKbudBmLty1opkLd+3oE81cuIvv810veqIVzVy4taIrekef6I6Od2N/dWN/dYu5cIu5cPeKrugdfaKZC3czF+5+0ROtaObCPSuauXAP3+d7TnRH3+gXPdGKZi7cXtEVHe/G/urG/uo2c+H2i55oRTMX7l3RFc1cuPdEMxfu5ft874ueaEUzF+5b0RW9o090R8e7sb+6sb+6j7lwH3Phzoqu6B19ojuauXDnRTMX7vB9vsP3+WpFV/SOPtEdfaNf9ETHu7G/urG/umYuXO/oE93RN/pFTzRz4Zq58BZz4S2+z2/t6BPd0Tf6RU+0opkLr1Z0vBv7qxf7q1fMhVc3+kVPtKKZC2+vaObC28yFt090RzMX3n7RzIW3mQtvMxfeWdHMhXd29IlmLrzD9/mdFz3RimYuvF7RFb2jT3RHx7uxv3qxv3rNXHjNXHh3RVf0jj7RzIV3mQvvvuiJVjRz4b0VzVx4j+/zeye6o2/0i55oRTMX3qzoio53Y3/1Yn/1hrnw5kVPtKKZC08ruqKZC08nmrnwxPf56UVPtKKZC88ruqJ39Inu6Hg39lcv9lfPzIVn5sKsFV3RO/pEdzRzYdaLZi7M4vs8i+/z1Iqu6B19ojv6Rr/oiY53Y381sb+azVyYvaNPdEff6Bc90cyF2cyFOcyFOXyf5+zoE93RN/pFT7SimQvTKzrejf3VxP5qmrkwfaNf9EQrmrkwd0UzF+YyF+ae6I5mLsx90cyFucyFucyFeSuauTBvR59o5sI8vs/zXvREK5q5MLOiK3pHn+iOjndjfzWxv5phLswwF0YruqJ39IlmLoyYC6MXPdGKZi6MVzRzYcz3eXyiO/pGv+iJVjRzQWtFV/SOPtEdzVzQetETrWjmgmpFVzRzQXWimQsqvs+qFz3RimYuaK/oit7RJ7qj493YXyn2V9rMBW3mgs6KrugdfaI7mrmg86KZCzp8n3X4PqtXdEXv6BPd0Tf6RU90vBv7K8X+Spe5oLujT3RH3+gXPdHMBV3mgh5zQY/vs96OPtEdfaNf9EQrmrmgWdHxbuyvFPsrDXNBc6Nf9EQrmrkgrWjmgsRckE50RzMXpBfNXJCYCxJzQV7RzAV5R59o5oLM91l+0ROtaOaC14qu6B19ojv6Rr/oiWYueDEXXCu6onf0iWYuuJgLrhc90YpmLnivaOaC417UcS/quBf1vtEveqIVzVzwWdEVHe/G/sqxv/JhLvi86IlWNHPBvaIrmrngPtHMBce9qONe1HEv6lY0c8F3RVf0jj7RHR3vxv7Ksb/yZS74Mhf8VnRF7+gT3dHMBb8XzVxw3Is67kUd96Keit7RJ7qjb/SLnuh4N/ZXjv2VxVywdvSJ7ugb/aInmrlgMRds5oLjXtRxL+q4F7U7+ka/6IlW9Hcu1Pp6509X9I4+0d+5UOvrnT/9oida0aa/3vnT37lQ6+udP32iO/o7F2p9vfOnv3Oh1tc7f9r01zt/+jsXan2986dP9Hcu1OJetBb3orW4F6319c6fNv31zp+u6B19ojs63j3x7ol3v97506a/3vnTFb2jT/R3LtT6eudPv+iJVrTpr3f+9Hcu1OJetBb3orW4F6319c6fftETrWjTX+/86YqOd1+8++Ldr3f+9IueaEWb/nrnT1f0dy7U+nrnT3/nQi3uRWtxL1qLe9FaX+/8adNf7/zpit7RJ7qj413Fu4p3v97506a/3vnTFb2jT3RHf+dCra93/vR3LtTiXrQW96JV3ItWfb3zp3f0ie7oG/2iJ1rR8W7Fu1/v/OkdfaI7+ka/6In+zoWqr3f+tb/e+dN8n4t70SruRau+3vnTN/pFT7SimQt1VnS8e+LdE+8e5kKdG/2iJ1rRzIXqFc1cqGYuVJ/ojmYuVL9o5kI1c6GauVB3RTMX6u7oE81cKO5Fq7gXreJetOoqmrlQb0VX9I4+0R0d775498W7j7lQj7lQs6IrekefaOZCDXOh5kVPtKKZC6UVzVwo7kWruBet4l60Sjf6RU+0opkL5RVd0fGu413Hu2YulF/0RCuaubDXiq5o5sJeJ5q5sLkXrc29aG3uRWsvRTMXdq3oit7RJ7qj492KdyveLebCLubC3iu6onf0ie5o5sLeL5q5sLkXrc29aG3uRWufit7RJ7qjb/SLnuh498S7He82c2H3jj7RHX2jX/REMxd2Mxf2ZS5s7kVrcy9am3vR2rejb/SLnmhFMxf2W9Hx7ot3X7z7mAv73egXPdGKZi7sWdHMhT3MhT0nuqOZC3teNHNhD3NhD3Nha0UzF7Z29IlmLmzuRWtzL1qbe9HaUjRzYXtFV/SOPtEdHe863nW8a+bCxjvXwTvXwTvXwTvXwTvXwTvXwTvXwTvXwTvXwTvXwTvXwTvXwTvX4V60DveidbgXrYN3roN3roN3roN3roN3roN3roN3rrPj3R3v7ngX71wH71wH71wH71wH71wH71wH71wH71wH71wH71yHe9E63IvW4V60Dt65Dt65Dt65Dt65Dt65Dt65Dt65Tse7He92vIt3roN3roN3roN3roN3roN3roN3roN3roN3roN3rsO9aB3uRetwL1oH71wH71wH71wH71wH71wH71wH71znxbsv3p14F+9cB+9cB+9cB+9cB+9cB+9cB+9cB+9cB+9cB+9ch3vROtyL1uFetA7euQ7euQ7euQ7euQ7euQ7euQ7euY7jXce7jnfxznXwznXwznXwznXwznXwztV452q8czXeuRrvXI13rsY7V+Odq/HO1XjnarxzNd65Gu9cjXeuxjtX452ruRet5l60mnvRarxzNd65Gu9cjXeuxjtX452r8c7Vsb/q2F917K8a71yNd67GO1fjnavxztV452q8czXeuRrvXI13rsY7V+Odq/HO1Xjnau5Fq7kXreZetBrvXI13rsY7V+Odq/HO1XjnarxzdeyvOvZXHfurxjtX452r8c7VeOdqvHM13rka71yNd67GO1fjnau5F63mXrSae9FqvHM13rka71yNd67GO1fjnavxztWxv+rYX3XsrxrvXI13rsY7V+Odq/HO1XjnarxzNd65Gu9cjXeu5l60mnvRau5Fq/HO1XjnarxzNd65Gu9cjXeuxjtXx/6qY391Y3918c518c518c518c518c518c518c518c518c518c51uRety71oXe5F6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd68b+6sb+6sb+6uKd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6+Kd6/7DO//y29/8z7/+9Y//+m9/+sN//+af/u/XH//j7//1+7/98c//9Y8f//a/f/n5zb/99Y9/+tMf//Nf/vLXP//+D//+97/+4V/+9Offf373m/X54/O/+89n/fbc3/36j+v7V36//XVL+rtffvnld7/8Pw==","file_map":{"50":{"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::{MAX_MSG_NON_ZERO_COEFFS, T};\nuse lib::configs::default::threshold::{\n DECRYPTED_SHARES_AGGREGATION_BIT_NOISE, DECRYPTED_SHARES_AGGREGATION_CONFIGS, L,\n};\nuse lib::core::threshold::decrypted_shares_aggregation::DecryptedSharesAggregationModular;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n decryption_shares: pub [[Polynomial; L]; T + 1],\n party_ids: pub [Field; T + 1],\n message: pub Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n) {\n let decrypted_shares_aggregation: DecryptedSharesAggregationModular = DecryptedSharesAggregationModular::new(\n DECRYPTED_SHARES_AGGREGATION_CONFIGS,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n );\n\n decrypted_shares_aggregation.execute();\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/decrypted_shares_aggregation_mod/src/main.nr"},"67":{"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::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\nuse dep::bignum::BigNum;\nuse dep::bignum::bignum::to_field;\nuse dep::bignum::SecureThreshold8192;\n\n/// Cryptographic parameters for decryption share aggregation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Plaintext modulus (typically denoted as `t`)\n pub plaintext_modulus: Field,\n /// Precomputed value: `-Q^(-1) mod t` where Q is the product of all CRT moduli\n pub q_inverse_mod_t: Field,\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], plaintext_modulus: Field, q_inverse_mod_t: Field) -> Self {\n Configs { qis, plaintext_modulus, q_inverse_mod_t }\n }\n}\n\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using BigNum\n/// for large Q values.\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationBigNum {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using modular arithmetic\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationModular {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n\nimpl DecryptedSharesAggregationBigNum {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationBigNum {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Verifies decoding using BigNum for large Q values\n fn verify_decoding(self) {\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1 as Field;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_bn = SecureThreshold8192::from(q_modulus);\n\n let q_half_bn = q_bn.udiv(SecureThreshold8192::from(2));\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let u_bn = SecureThreshold8192::from(self.u_global.coefficients[coeff_idx]);\n let t_bn = SecureThreshold8192::from(self.configs.plaintext_modulus);\n let u_bn_mod_q = u_bn.umod(q_bn);\n let t_bn_mod_q = t_bn.umod(q_bn);\n let t_times_u_bn_q = (t_bn_mod_q * u_bn_mod_q).umod(q_bn);\n\n let m = ModU128::new(self.configs.plaintext_modulus);\n\n // Check if centering is needed\n let needs_centering = t_times_u_bn_q > q_half_bn;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_bn - t_times_u_bn_q;\n let centered_positive_mod_t = centered_positive.umod(t_bn);\n let centered_field = to_field(centered_positive_mod_t);\n m.mul_mod(self.configs.q_inverse_mod_t, centered_field)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_bn_t = t_times_u_bn_q.umod(t_bn);\n let t_times_u_field = to_field(t_times_u_bn_t);\n let product = m.mul_mod(self.configs.q_inverse_mod_t, t_times_u_field);\n if product == 0 {\n 0\n } else {\n self.configs.plaintext_modulus - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\nimpl DecryptedSharesAggregationModular {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationModular {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Alternative verification function using efficient modular arithmetic without BigNum.\n ///\n /// Uses `ModU128` for decoding verification instead of BigNum. More efficient when\n /// Q (the product of all CRT moduli) fits within u128 (e.g., 72 bits for insecure parameter sets).\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Alternative decoding verification using the formula:\n /// message = -Q^{-1} * (t * u_global)_Q mod t\n fn verify_decoding(self) {\n let t: Field = self.configs.plaintext_modulus;\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_half = q_modulus as u128 / 2;\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let q_mod = ModU128::new(q_modulus);\n let t_mod = ModU128::new(t);\n\n // Compute (t * u_global) mod Q using modular arithmetic functions\n let t_times_u_mod_q = q_mod.mul_mod(t, self.u_global.coefficients[coeff_idx]);\n let needs_centering = (t_times_u_mod_q as u128) > q_half;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_modulus - t_times_u_mod_q;\n let centered_positive_mod_t = t_mod.reduce_mod(centered_positive);\n\n t_mod.mul_mod(self.configs.q_inverse_mod_t, centered_positive_mod_t)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_mod_t = t_mod.reduce_mod(t_times_u_mod_q);\n let product = t_mod.mul_mod(self.configs.q_inverse_mod_t, t_times_u_mod_t);\n if product == 0 {\n 0\n } else {\n t - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\n/// Computes all Lagrange coefficients using optimized modular arithmetic\npub fn compute_all_lagrange_coeffs(\n qis: [Field; L],\n party_ids: [Field; T + 1],\n) -> [[Field; T + 1]; L] {\n let mut lagrange_coeffs = [[0 as Field; T + 1]; L];\n\n // Step 1: Cache |x_i - x_j| factors for all party pairs\n let mut diffs = [[0 as Field; T + 1]; T + 1];\n for i in 0..(T + 1) {\n for j in (i + 1)..(T + 1) {\n let diff = party_ids[j] - party_ids[i];\n diffs[i][j] = diff;\n diffs[j][i] = diff;\n }\n }\n\n // Step 2: Determine signs (same for all parties within a basis)\n let numerator_sign_negative = (T % 2) == 1;\n\n // Step 3: For each CRT basis, compute Lagrange coefficients\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n\n // Compute product of all party IDs: PRODUCT(j=0..T) x_j mod q_l\n let mut product_x = 1 as Field;\n for j in 0..(T + 1) {\n product_x = m.mul_mod(product_x, party_ids[j]);\n }\n\n // For each party i, compute L_i(0) mod q_l\n for party_idx in 0..(T + 1) {\n // Numerator (absolute value): PRODUCT(j!=party_idx) x_j\n let numerator_abs = m.div_mod(product_x, party_ids[party_idx]);\n\n // Denominator (absolute value): PRODUCT(j!=party_idx) |x_party_idx - x_j|\n let mut denominator_abs = 1 as Field;\n for j in 0..(T + 1) {\n if j != party_idx {\n denominator_abs = m.mul_mod(denominator_abs, diffs[party_idx][j]);\n }\n }\n\n // Determine denominator sign\n let num_greater = T - party_idx;\n let denom_sign_negative = (num_greater % 2) == 1;\n\n // Compute unsigned result: |numerator| / |denominator| mod q_l\n let result_abs = m.div_mod(numerator_abs, denominator_abs);\n\n // Apply combined sign\n let should_negate = numerator_sign_negative != denom_sign_negative;\n let result = if should_negate {\n m.reduce_mod(q_l - result_abs)\n } else {\n result_abs\n };\n\n lagrange_coeffs[basis_idx][party_idx] = result;\n }\n }\n\n lagrange_coeffs\n}\n\n/// Computes u^{(l)} for each CRT basis via Lagrange interpolation\npub fn compute_crt_components(\n qis: [Field; L],\n decryption_shares: [[Polynomial; L]; T + 1],\n lagrange_coeffs: [[Field; T + 1]; L],\n) -> [Polynomial; L] {\n let mut u_crts: [Polynomial; L] =\n [Polynomial::new([0; MAX_MSG_NON_ZERO_COEFFS]); L];\n\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n let mut u_coeffs = [0 as Field; MAX_MSG_NON_ZERO_COEFFS];\n\n // For each coefficient position\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n let mut u_coeff = 0 as Field;\n\n // Sum all contributions: u = SUM(i=0..T) [d_i * L_i(0)] mod q_l\n for party_idx in 0..(T + 1) {\n let d_coeff = decryption_shares[party_idx][basis_idx].coefficients[coeff_idx];\n let l_i_0 = lagrange_coeffs[basis_idx][party_idx];\n\n let term = m.mul_mod(d_coeff, l_i_0);\n u_coeff = m.reduce_mod(u_coeff + term);\n }\n\n u_coeffs[coeff_idx] = u_coeff;\n }\n\n u_crts[basis_idx] = Polynomial::new(u_coeffs);\n }\n\n u_crts\n}\n\n/// Verifies CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global for all bases l\npub fn verify_crt_reconstruction(\n qis: [Field; L],\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n u_crts: [Polynomial; L],\n) {\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n\n // Compute r^{(l)} * q_l\n let r_times_q = crt_quotients[basis_idx].mul_scalar(q_l);\n\n // Compute u^{(l)} + r^{(l)} * q_l\n let reconstructed = u_crts[basis_idx].add(r_times_q);\n\n // Verify: u^{(l)} + r^{(l)} * q_l = u_global\n // Must hold for every coefficient\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n assert(\n reconstructed.coefficients[coeff_idx] == u_global.coefficients[coeff_idx],\n \"CRT reconstruction verification failed\",\n );\n }\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/decrypted_shares_aggregation.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.vk b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.vk new file mode 100644 index 0000000000000000000000000000000000000000..b3b83d01c2855ffba802a461022eb61b41a1156f GIT binary patch literal 1888 zcmajgcRw2l1HkdbOr$|Xa%Sz7Q1c-+(WpZewTTk5j#9CXS}{r~O5#w_6fLFrL}FIm zoh>MdqE+LH=Zsoy#i5US-a+s8@An1#0DvC``=J7OY<}zjpyajQxPx}qxQE0t*;XqS zztu3ek2G7Q+1p@eU(Op}0`Lu;?T5<<;sy^E1j+-pIrWiYiS@dW`)15QlL!1CqgZPv25UxLp*`uEB z_V)VC|2R(ZfEk{AvAUilkDc`+{Iat>b@axzRA1d&t=rs_tPUwx2x(24>tE(o)i9CC zw_7i0aYFjWYZU6^rTf<4MVWF4k5vqmb8u(MCPH==yqf;lHtOk!dhoWxw3Y2MY*(zR zytl3Z%+ee}S~RH&7$fcezEh!CnYJNo(3iy(?UTX^8WQQJfRBQaJ3 z@2)6yiI|L->erBMxafut6c_eyaPBfH3oP7WSb@)PcIiUZI zf=k$Li24S>{Frj@HnI5&KN0`ojjx&=1L4L&p5upAbxs#!HoVF;ze){9UIP~$ZQh|{ zN+V$X?L?{WY1==ZsfND7r8iu62y(W0<&j_KgW6ZFgk)&T^;VP^4%zQ@f@fw8WG1pT zwPY5?F74P;Wa#FMQZm&Nk}-rbjM8?t@EK=Ek~93mPx#RBDIkC&68qN z(CRdMranzipu7~c2iXb1O*IX7YQ%Z3JE5Ajn~>&>Nr9orur2+@wDzkQxt?7JXV21H zySjYR+0WLNhrO+BkY^p>R=jNvqYB?yxtXqzT|ASc#_LMU?nq3VgN8sYLsx(}!+Hl@ zY=MJXMFH}kE{RK|sK**-i|->Z)4!Z9pBLn*$|V5BPxe3dl^H3##ytG$s$en0ZlXkg z&X9?4Nh>#G@yK2_&YHLE_+=W}439Qv-s$v76Z={B~p6EAL;7 zCJi)zWN-hqPu2#a2eVhR1ZoZZnN*1kPnI?@OHEmL`r;z3(ez4OJJq z=^?IsW#7LWR+*msK^Vp#v|QCoD?ViI-2$H0)^bpo91FE8@q{FgHHZGhlgkQOJ+J?& zUiEr2Cva8c6q`IGZn17#WWvjzRy?juMs zT6X3(ZR2?VcP~Yy-aJtZ2Y%9MNE5I1Ifa%Ls^w+y!xlZ>=>vFN=u=Xef67r@(f3#Y z6E(H~A!2UFs^V9lgC`8n)}&mQ_n%V&c*HiP!8N9HG@4M?cL_cqe-DGw@ve*c+?0Pc z1Pv8E5RXy?Ai6m&_=L5|-O434*;_%Q%_Jz@hk(+%Dv}Gmj7pb&6#r8xq{Y184;cyt zj8a7BWrCJe*iATLh{J%`V49A9ekt8<|AXS++ogiZ*>(!nqn|e90Z-=&C*m-2QIc?v zG}A|ZnLv|8gwik1rk?|0Oe-r0nq{;`2l [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::dkg::{L_THRESHOLD, N, SHARE_DECRYPTION_BIT_MSG};\nuse lib::configs::default::H;\nuse lib::core::dkg::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_commitments: pub [[Field; L_THRESHOLD]; H],\n decrypted_shares: [[Polynomial; L_THRESHOLD]; H],\n) -> pub Field {\n let share_decryption: ShareDecryption =\n ShareDecryption::new(expected_commitments, decrypted_shares);\n\n share_decryption.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_decryption/src/main.nr" - }, - "64": { - "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::commitments::{\n compute_aggregated_shares_commitment, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::polynomial::Polynomial;\n\n/// Share Decryption Commitment Verification (Circuit 4).\n///\n/// Verifies:\n/// 1. Each decrypted share from H honest parties matches its commitment from Circuit 3\n/// 2. Computes sum of all shares\n/// 3. Returns commitment to aggregated shares\npub struct ShareDecryption {\n /// Expected commitments from Circuit 3 for H honest parties: [party_idx][mod_idx]\n /// (public witness)\n expected_commitments: [[Field; L]; H],\n\n /// Decrypted shares from H honest parties: [party_idx][mod_idx]\n /// (secret witnesses)\n decrypted_shares: [[Polynomial; L]; H],\n}\n\nimpl ShareDecryption {\n pub fn new(\n expected_commitments: [[Field; L]; H],\n decrypted_shares: [[Polynomial; L]; H],\n ) -> Self {\n ShareDecryption { expected_commitments, decrypted_shares }\n }\n\n /// Verifies all decrypted shares match their expected commitments\n fn verify_commitments(self) {\n for party_idx in 0..H {\n for mod_idx in 0..L {\n assert(\n compute_share_encryption_commitment_from_message::(\n self.decrypted_shares[party_idx][mod_idx],\n )\n == self.expected_commitments[party_idx][mod_idx],\n \"Commitment mismatch\",\n );\n }\n }\n }\n\n /// Computes sum of all decrypted shares\n fn compute_aggregated_shares(self) -> [Polynomial; L] {\n let mut sum: [Polynomial; L] = [Polynomial::new([0; N]); L];\n\n for mod_idx in 0..L {\n let mut coeffs = [0 as Field; N];\n for coeff_idx in 0..N {\n let mut total = 0 as Field;\n for party_idx in 0..H {\n total =\n total + self.decrypted_shares[party_idx][mod_idx].coefficients[coeff_idx];\n }\n coeffs[coeff_idx] = total;\n }\n sum[mod_idx] = Polynomial::new(coeffs);\n }\n\n sum\n }\n\n /// Main verification function\n /// Returns commitment to aggregated shares\n pub fn execute(self) -> Field {\n // Step 1: Verify all commitments match\n self.verify_commitments();\n\n // Step 2: Compute aggregated shares\n let aggregated = self.compute_aggregated_shares();\n\n // Step 3: Return commitment to aggregated shares\n compute_aggregated_shares_commitment::(aggregated)\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_decryption.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} diff --git a/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.vk b/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.vk deleted file mode 100644 index a9f3fd5ef3426dc772c2c684fd888d24624de5c8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3680 zcmajic{o)29|!QSqOnc3CRCV&GV&Wn3X?3Mv80F=Wg7{V;u1yI5{)HG!;B@%)xs1L z^-!`@x|K;NCbA1j$ab^dh~NC%XP)Oa|DEUceV=EZ^ZlInIR~Nt{7L+$BDC>0E&#k@ zk)zVA&4zqJytt?g8!+)6_iJ`htzS z79lBG=3znvj*yn?P~qA&8)>sEb^FsOb-=5Llt#SO_mKV30eJs)9z_`72oXi6hax&p zW}P8#Dd@Pb4m`+qQ|mf-0Jt41n3>Wn zL(-#0p8KL}c2o>FLds#3ZPysegsD5p9rMlUz{iX6cgu>^q#N6dj_0_L9CLvqB=??% z?fo+793|FjdwKd1@Q(Y}j_n=g1}gsiroAyrsICh*LaKt=CSUV$-j{tNny!+AfbZDX z=Tv4al3C|Rp)zcz$fdv$!X~<2l`&k?O0}%DFsRuA{PVy~4Ew});}b!FFYh<}h@1tE z&}u==$;-=3f^ysPQ^v6|;M>!mQt0O<+(o&>-lyFPKN5f=v|;??Q#(Ivmw+k#x!71Z zKXv+Sxd@ZukF_}2SfhG*2A(gE6^zVa&tI5p$#|g~d0Gqj8xglVHrN;o+Ff>TNk$7v z2slE5!xyJ?m4-AwEcI)5-pT+T^$$l)c%+v(qknU7^8{_)3plUQLhYq)yV)svFl-&^ z;o`tINX21%_MiWxm_%O)bO7sNNf!+&SBsmUaubOuJF#wWvVzu zIMr8_0O#%h^1s|%y8*6I(v(+EcPntAa$o)4#Ozba$AwnnIQ)%}>xc?t6koqhiphD$p4@a2^xoM%S& z)#bPa9rqFShy8jz)7}3@!_fZcuW7IHv!5rH^X0dZ1TuSGTyP4{A`yeVnZP3nZ-P?J z)vzVZL?)!047&<G}Natgaej7Vy-G4c%;mhi}^OSd|Nx{%WEE=iR>%rFXNH5_h_k3@>PALe{Nq z55R>DQ?c4TqjDl%ECO7B+IJMTEz;1`$P-SN1Mx&AG?27?y|&GUjUAf ziu;gGVMXX;DkgPhv9kd9EkeD!Gj}p?uC>om`+%u2|NFtl2bO8~*IK>azMW25!u$aF zoP<4zNf%>xH%`*zGV|`{N&!bm;t4stG`J|xC4Tlr1aT0!2$xZBC`@w@%sF%gD}URO z0i1XJR9~J;wLE2L9-L@xQ1u>o)}cRD2fd@i8Xss}uAVo}hyB3o{}zS(^h@sxrs8n5 z{f@dIFKOvN;j7?RJ7o5FY5!4&J9EH!`+q7n(r)YM!Ok{|flK^I|0FW zi8}e5Rj1W}3!kNPKYOfy@0&nL%c^fwR0huLPq&VEqvpv_1zq?0XVhK5eeON0EYMO& zeWc$>?N(T?4zDjl1W8Qz`LBB7il_7TDrDaU`9ncpcG?vkz!|r(qDDklI<5of&0h^x zBId))y<_^R7)xwEaL#U)^c!X(PUy-i-uIysIj-v!?~?*gvcuN|1Uy^Q21jcGmS4V z(Uc#Oj{WwS*3)uSnsf#@^HFO^R;5ue@nj% z1I~N?(J#oRh}}25RaK1W!db}OIZoStwFgabO zH{oR)UtWO1RgJ4q!X{e;mK-tb1-@;(nKgJe8k@~9`ebgu>Et`$y!kg=LzWT!R2pDf zV%~&v0-mbHBz(0wVz{2xQE!C;^c;XAq=r*|C7h~t^7KktfIEY~pMDL%@1tM!_eZOK zzvPz{W1r5|lozn$Zntwi-Lz^s{PU|WzI}d+f7-Pb>6?vc6by+r36<&p2O>yF1^@s6 diff --git a/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.json b/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.json deleted file mode 100644 index 0234543f66..0000000000 --- a/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.json +++ /dev/null @@ -1,61 +0,0 @@ -{ - "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "9828651845942763134", - "abi": { - "parameters": [ - { - "name": "expected_commitments", - "type": { "kind": "array", "length": 5, "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - "visibility": "public" - }, - { - "name": "decrypted_shares", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - } - }, - "visibility": "private" - } - ], - "return_type": { "abi_type": { "kind": "field" }, "visibility": "public" }, - "error_types": { "10481401461242010843": { "error_kind": "string", "string": "Commitment mismatch" } } - }, - "bytecode": "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", - "debug_symbols": "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", - "file_map": { - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::dkg::{L_THRESHOLD, N, SHARE_DECRYPTION_BIT_MSG};\nuse lib::configs::default::H;\nuse lib::core::dkg::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_commitments: pub [[Field; L_THRESHOLD]; H],\n decrypted_shares: [[Polynomial; L_THRESHOLD]; H],\n) -> pub Field {\n let share_decryption: ShareDecryption =\n ShareDecryption::new(expected_commitments, decrypted_shares);\n\n share_decryption.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_decryption/src/main.nr" - }, - "64": { - "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::commitments::{\n compute_aggregated_shares_commitment, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::polynomial::Polynomial;\n\n/// Share Decryption Commitment Verification (Circuit 4).\n///\n/// Verifies:\n/// 1. Each decrypted share from H honest parties matches its commitment from Circuit 3\n/// 2. Computes sum of all shares\n/// 3. Returns commitment to aggregated shares\npub struct ShareDecryption {\n /// Expected commitments from Circuit 3 for H honest parties: [party_idx][mod_idx]\n /// (public witness)\n expected_commitments: [[Field; L]; H],\n\n /// Decrypted shares from H honest parties: [party_idx][mod_idx]\n /// (secret witnesses)\n decrypted_shares: [[Polynomial; L]; H],\n}\n\nimpl ShareDecryption {\n pub fn new(\n expected_commitments: [[Field; L]; H],\n decrypted_shares: [[Polynomial; L]; H],\n ) -> Self {\n ShareDecryption { expected_commitments, decrypted_shares }\n }\n\n /// Verifies all decrypted shares match their expected commitments\n fn verify_commitments(self) {\n for party_idx in 0..H {\n for mod_idx in 0..L {\n assert(\n compute_share_encryption_commitment_from_message::(\n self.decrypted_shares[party_idx][mod_idx],\n )\n == self.expected_commitments[party_idx][mod_idx],\n \"Commitment mismatch\",\n );\n }\n }\n }\n\n /// Computes sum of all decrypted shares\n fn compute_aggregated_shares(self) -> [Polynomial; L] {\n let mut sum: [Polynomial; L] = [Polynomial::new([0; N]); L];\n\n for mod_idx in 0..L {\n let mut coeffs = [0 as Field; N];\n for coeff_idx in 0..N {\n let mut total = 0 as Field;\n for party_idx in 0..H {\n total =\n total + self.decrypted_shares[party_idx][mod_idx].coefficients[coeff_idx];\n }\n coeffs[coeff_idx] = total;\n }\n sum[mod_idx] = Polynomial::new(coeffs);\n }\n\n sum\n }\n\n /// Main verification function\n /// Returns commitment to aggregated shares\n pub fn execute(self) -> Field {\n // Step 1: Verify all commitments match\n self.verify_commitments();\n\n // Step 2: Compute aggregated shares\n let aggregated = self.compute_aggregated_shares();\n\n // Step 3: Return commitment to aggregated shares\n compute_aggregated_shares_commitment::(aggregated)\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_decryption.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} diff --git a/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.vk b/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.vk deleted file mode 100644 index a9f3fd5ef3426dc772c2c684fd888d24624de5c8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3680 zcmajic{o)29|!QSqOnc3CRCV&GV&Wn3X?3Mv80F=Wg7{V;u1yI5{)HG!;B@%)xs1L z^-!`@x|K;NCbA1j$ab^dh~NC%XP)Oa|DEUceV=EZ^ZlInIR~Nt{7L+$BDC>0E&#k@ zk)zVA&4zqJytt?g8!+)6_iJ`htzS z79lBG=3znvj*yn?P~qA&8)>sEb^FsOb-=5Llt#SO_mKV30eJs)9z_`72oXi6hax&p zW}P8#Dd@Pb4m`+qQ|mf-0Jt41n3>Wn zL(-#0p8KL}c2o>FLds#3ZPysegsD5p9rMlUz{iX6cgu>^q#N6dj_0_L9CLvqB=??% z?fo+793|FjdwKd1@Q(Y}j_n=g1}gsiroAyrsICh*LaKt=CSUV$-j{tNny!+AfbZDX z=Tv4al3C|Rp)zcz$fdv$!X~<2l`&k?O0}%DFsRuA{PVy~4Ew});}b!FFYh<}h@1tE z&}u==$;-=3f^ysPQ^v6|;M>!mQt0O<+(o&>-lyFPKN5f=v|;??Q#(Ivmw+k#x!71Z zKXv+Sxd@ZukF_}2SfhG*2A(gE6^zVa&tI5p$#|g~d0Gqj8xglVHrN;o+Ff>TNk$7v z2slE5!xyJ?m4-AwEcI)5-pT+T^$$l)c%+v(qknU7^8{_)3plUQLhYq)yV)svFl-&^ z;o`tINX21%_MiWxm_%O)bO7sNNf!+&SBsmUaubOuJF#wWvVzu zIMr8_0O#%h^1s|%y8*6I(v(+EcPntAa$o)4#Ozba$AwnnIQ)%}>xc?t6koqhiphD$p4@a2^xoM%S& z)#bPa9rqFShy8jz)7}3@!_fZcuW7IHv!5rH^X0dZ1TuSGTyP4{A`yeVnZP3nZ-P?J z)vzVZL?)!047&<G}Natgaej7Vy-G4c%;mhi}^OSd|Nx{%WEE=iR>%rFXNH5_h_k3@>PALe{Nq z55R>DQ?c4TqjDl%ECO7B+IJMTEz;1`$P-SN1Mx&AG?27?y|&GUjUAf ziu;gGVMXX;DkgPhv9kd9EkeD!Gj}p?uC>om`+%u2|NFtl2bO8~*IK>azMW25!u$aF zoP<4zNf%>xH%`*zGV|`{N&!bm;t4stG`J|xC4Tlr1aT0!2$xZBC`@w@%sF%gD}URO z0i1XJR9~J;wLE2L9-L@xQ1u>o)}cRD2fd@i8Xss}uAVo}hyB3o{}zS(^h@sxrs8n5 z{f@dIFKOvN;j7?RJ7o5FY5!4&J9EH!`+q7n(r)YM!Ok{|flK^I|0FW zi8}e5Rj1W}3!kNPKYOfy@0&nL%c^fwR0huLPq&VEqvpv_1zq?0XVhK5eeON0EYMO& zeWc$>?N(T?4zDjl1W8Qz`LBB7il_7TDrDaU`9ncpcG?vkz!|r(qDDklI<5of&0h^x zBId))y<_^R7)xwEaL#U)^c!X(PUy-i-uIysIj-v!?~?*gvcuN|1Uy^Q21jcGmS4V z(Uc#Oj{WwS*3)uSnsf#@^HFO^R;5ue@nj% z1I~N?(J#oRh}}25RaK1W!db}OIZoStwFgabO zH{oR)UtWO1RgJ4q!X{e;mK-tb1-@;(nKgJe8k@~9`ebgu>Et`$y!kg=LzWT!R2pDf zV%~&v0-mbHBz(0wVz{2xQE!C;^c;XAq=r*|C7h~t^7KktfIEY~pMDL%@1tM!_eZOK zzvPz{W1r5|lozn$Zntwi-Lz^s{PU|WzI}d+f7-Pb>6?vc6by+r36<&p2O>yF1^@s6 diff --git a/crates/zk-prover/tests/fixtures/e_sm_share_computation.json b/crates/zk-prover/tests/fixtures/e_sm_share_computation.json index e5ed627233..cb93d2f5fb 100644 --- a/crates/zk-prover/tests/fixtures/e_sm_share_computation.json +++ b/crates/zk-prover/tests/fixtures/e_sm_share_computation.json @@ -1,87 +1 @@ -{ - "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "12506177918275697276", - "abi": { - "parameters": [ - { "name": "expected_secret_commitment", "type": { "kind": "field" }, "visibility": "public" }, - { - "name": "e_sm_secret", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "y", - "type": { - "kind": "array", - "length": 512, - "type": { "kind": "array", "length": 2, "type": { "kind": "array", "length": 6, "type": { "kind": "field" } } } - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { "kind": "array", "length": 5, "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - "visibility": "public" - }, - "error_types": { - "6707344661594935864": { "error_kind": "string", "string": "ESM commitment mismatch" }, - "12469291177396340830": { "error_kind": "string", "string": "call to assert_max_bit_size" }, - "15598659011570841449": { "error_kind": "string", "string": "Secret consistency check failed" }, - "15757906049389710862": { "error_kind": "string", "string": "Parity check failed" }, - "15764276373176857197": { "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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n", - "path": "std/field/mod.nr" - }, - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_E_SM_BIT_SECRET,\n SHARE_COMPUTATION_E_SM_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SmudgingNoiseShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n e_sm_secret: [Polynomial; L_THRESHOLD],\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let share_computation_e_sm: SmudgingNoiseShareComputation = SmudgingNoiseShareComputation::new(\n SHARE_COMPUTATION_E_SM_CONFIGS,\n expected_secret_commitment,\n e_sm_secret,\n y,\n PARITY_MATRIX,\n );\n\n share_computation_e_sm.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/e_sm_share_computation/src/main.nr" - }, - "63": { - "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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_computation.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "77": { - "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" - }, - "79": { - "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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" - }, - "80": { - "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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/polynomial.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"17372510727995405395","abi":{"parameters":[{"name":"expected_secret_commitment","type":{"kind":"field"},"visibility":"public"},{"name":"e_sm_secret","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"y","type":{"kind":"array","length":512,"type":{"kind":"array","length":2,"type":{"kind":"array","length":6,"type":{"kind":"field"}}}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"array","length":5,"type":{"kind":"array","length":2,"type":{"kind":"field"}}},"visibility":"public"},"error_types":{"6707344661594935864":{"error_kind":"string","string":"ESM commitment mismatch"},"12469291177396340830":{"error_kind":"string","string":"call to assert_max_bit_size"},"15598659011570841449":{"error_kind":"string","string":"Secret consistency check failed"},"15757906049389710862":{"error_kind":"string","string":"Parity check failed"},"15764276373176857197":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"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","debug_symbols":"pP3drm5JcmUHvkte8+Jzt2l/fJVGo0BJlECAYAlUVd8U6t07vtzHx0xWI6KTmbpQLO0dtVa45zF3szpDY/6PP/0f//y//ff/67/8y7/9n//1//nTP/6//sef/rd//5d//dd/+b/+y7/+1//9n/7bv/zXf/vtp//jT5/v/+v0n/7x/MOfzvz8Y//8j/vbr+5v/zg//7g//4g//WP89g/96R/12z/y5x/184/f3pK//eO3t9T//J//8Kf3nf/y3/79n//5+5m/+PBv/zn/9z/9+z//23/70z/+23//13/9hz/9f/7pX//7n/+l/+f//qd/+/M//9s//ftvv/38w5/++d/+j9/++dsL/89/+dd//j79z3/w/+nP7/8fPWfi1//pc7Z4Qe9f/YZ78r3hXv1Nb8jDG/rzN71h+70hzt+0irjiDfrb3qDhDX3+ljd8VO8Nn/Z/Q/7H/zX7999Qv3341xtKH+9kxX94w/z+G/rk+2/oG/l7b9jff8N88u3D/PZnw/ug//CG8wcbUX3e/5zVub/7ivP7rwj/V8SnvI7O/8QrFLyi93dfEb//ivzt//n1isz5/E2vKMor68bf9orPh1ec83e/4i+L/D/xiu63ndnz979if3chf/SH87cD5v3hvPrdP5z3j/5wxtn3hzP+8rT6X17xB3+y+jNvN/uzv/u/6b1/8F9xzn3/FSf9XzHnr35Fzr5Sz/3M775Cv/+KPXp7sWf1u6/I33+FVO/Iktb/FWf/E3tR/C9yP/237MV/eMW9f9N2rryd+v3/ij/6c3Hu24s+8buHVvzBn86ueAvpyvN7/xVx/u7/UeP+3f+j/uFCJriIpvP3/iv+2qts6veusj+6TsUlUpr5vTd8/0N/98C5t3zgxN/9irx//yvy737FX7Q3/4ndzHind9VflOn/8gb90R9N93kbd/+2V3D2bvTv/g+i+KM/mpX80fyLPxbz+etf0XrHd3f1774i/+gyZDePz/8z/5llvJa397O/+9/Qf+d/wx/9kah0oxe/+0db+0dNc3mC+fztL+n++1/y2znFS2Z+9094/sHJ+dvl8/543pt/0SX1X/+KoGO8cf/+V/xlm/SfeIU+b0d/a7T6737F/Vv/K+5f8Yo//p91j/9s/HZ8/C1H33ze4Vnz++dv/eGgLo6Mc/Iv7uX/9SV/dPh9isPv/MXh97/0rnX/7va34u9uf0t/d/v7R6/4K9vfqr+7U6r+uzulP96Lv6r9/atf8fvt7x9u51/X/v7hn4u/rv3t+3e3vx1/9/+orb/7f9Q/XMhf1/7+/zkxPvzfSB3F/o3Hzn94yX/8v1P6f//2//VP//u//Pv/z/916bdXPD//uD//iJ9/6Ocf+fOP+vlH//xjfv6xv/6Pv9f8es/59aLz603n16vOr3edXy87v952fr3u/Hrf/fW++/67fr3v/nrf/fW+++t999f77q/33V/vu7/eF7/eF7/eF2+hv94Xv94Xv94Xv94Xv94Xv94Xv96nX+/Tr/fp1/v0du7X+/Trffr1Pv16n369T7/el7/el7/el7/el7/el+9/il/vy1/vy1/vy1/vy1/vq1/vq1/vq1/vq1/vq1/vq/e/7a/31a/31a/31a/39a/39a/39a/39a/39a/39a/39fvD8ut9/et9/et98+t98+t98+t98+t98+t98+t98+t98/70/Xrf/Hrf/nrf/nrf/nrf/nrf/nrf/nrf/nrf/nrfvj/O/Hl+f6A/70/05/2R/rw/05/3h/rz/lR/3h/rz/tz/Xl/sD/vzS6V92aKhWqhXKgXCoaKoWRezZxXNOdShe/Nr27OK5zzKue80jmvds4rnvOq57zyOa9+TlDg782vhM6rofOK6LwqOq+Mzquj8wrpvEo6r5SOODvem181nVdO59XTeQV1vhX1HV3Pt6R+Hs57uO/h+3c++X347c36fB/yPdR76Pcw72F/PXyL6+fhvIf7HuI9vDfXe3O9N9d7c70313tzvzf3e3O/N/d7c78393tzvzf3e3O/N/d787w3z3vzvDfPe/O8N89787w3z3vzvDfPe/O+N+97874373vzvjfve/O+N+978743768338/nPZz3cN9DvAe9h3wP9R76Pcx7eG8+783nvfm8N5/35vPefN6bz3vzeW8+783nvfm+N9/35vvefN+b73vzfW++7833vfm+N9/35nhvjvfmeG+O9+Z4b4735nhvjvfmeG+O92a9N+u9We/Nem/We7Pem/XerPdmvTfrvTnfm/O9Od+b87351eB9NXhfDd5Xg/fV4H01eF8N3leD99XgfTV4Xw3eV4P31eB9NXhfDd5Xg/fV4H01eF8N3leD99XgfTV4Xw3eV4P31eB9NXhfDd5Xg/fV4H01eF8N3leD99XgfTV4Xw3eV4P31eB9NXhfDd5Xg/fV4H01eF8N3leD99XgfTUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg/FqMF4NxqvBeDUYrwbj1WC8GoxXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4N6NahXg3o1qFeDejWoV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1mK8G89VgvhrMV4P5ajBfDearwXw1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P1arBeDdarwXo1WK8G69VgvRqsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX412K8G+9VgvxrsV4P9arBfDfarwX41OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4PzanBeDc6rwXk1OK8G59XgvBqcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01uK8G99XgvhrcV4P7anBfDe6rwX01+Nvf0X94OjxdnoIn8ZQ8FU/N0/DENw7fOHzj8I3DNw7fOHzj8I3DNw7fOHzj8o3LNy7fuHzj8o3LNy7fuHzj8o3LN4JvBN8IvhF8I/hG8I3gG8E3gm8E3xDfEN8Q3xDfEN8Q3xDfEN8Q3xDfSL6RfCP5RvIN/mr/w9/tf/jL/Q9/u//hr/c//P3+h7/g//A3/B/+iv/D3/F/+Ev+D3/L/+Gv+T/8Pf+Hv+j/8Df9H/6q/8Pf9X/4y/4Pf9v/4a/7P/x9/4e/8P/wN/4f/sr/w9/5f/hL/w9/6//hr/0//L3/h7/4//A3/x/+6v/D3/1/+Mv/D3/7/+Gv/z/8/f8HAOADAfABAfjAAHyAAD5QAB8wgA91fqjzQ50f6vxQ54c6P9T5oc4PdX6o80OdH+r8UOeHOj/U+aHOD3V+qPNDnR/q/FDnhzo/1Pmhzg91fqjzQ50f6vxQ54c6P9T5oc4PdX6o80OdH+r8UOeHOj/U+aHOD3V+qPNDnR/q/FDnhzo/1Pmhzg91fqjzQ50f6vxQ54c6P9S5ER4zPIZ4TPEY4zHHY5DHJI9RHrM8hnlM8xjnMc9joMdEj5EeMz2Gekz1GOsx12Owx2TPD9rzA4J9vzHfpz/X+c/Teb/9c53//Cx4Er9NflY8Nb8dfsY3/lznP7jZ4Wd84891/vNb8TO+8ec6//lt8zO+8ec6/+HX3jp+iJ+fp8tvg5+Jp+S3xc+ap+G3bx0/6M/P09urH/jn52d844jfJj/jG6f57fAzvnHfXv1QQD8/4xs3+C3ruHzjFr9lHZdvXPYqWEfwjWCvgnUE3wj2KlhH8I1gr4J1iG+IvRLrEN8QeyXWIb4h9kqsQ3wj2atkHck3kr1K1pF8I9mrZB3JN5K9KtZRfKPYq2IdxTeKvSrWUXyj2KtiHc03mr1q1tF8o9mrZh3NN5q9atZBnf8ARD+EJuugzn8Yop/fsg7q/Acj+vkt66DOf0iiH+STdVDnPzDRz29ZB3X+wxP9/JZ1UOc/SNHPb986gjr/oYp+CNPLz4In8dvkZ8VT89vhZ3zjvL364Yt+fsY3TvBb8TO+cYrfNj/jG+ft1Q9o9OefUec/qNHPb1kHdf5DG/38lnVQ5z/A0c9vWQd1/sMc/SC3rIM6/8GOfn7LOqjzH/Lo57esgzr/gY9+GF7WQZ3/8Ec/v2Ud1PkPgvTzW9ZBnf9QSD9QMOugzn9ApJ/fsg7q/IdF+vkt66DOf3Ckn9+yDur8h0j6YZBZB3X+AyX9/JZ1UOc/XNLPb1kHdf6DJv1AzayDOv+hk35+yzqo8x9A6ee3rIM6/2GUfihp1kGd/2BKP79lHdT5D6n081vWQZ3/wEo/v2Ud1PkPr/QDZbMO6vwHWfr5Leugzn+opZ/fsg7q/Adc+qG8Dz+7PAW/FT9LnorfNj8bnt5eiftc1PkPxPTz2+BnfOMkvy1+xjfO8FvWQZ3/0Ew/lDrroM5/gKaf37IO6vyHafr5Leugzn+wph/snXVQ5z9k089vWQd1/gM3/fyWdVDnP3zTD0fPOqjzH8Tp57esgzr/oZx+fss6qPMf0Onnt6yDOv9hnX6wfdZBnf/gTj+/ZR3U+Q/x9PNb1kGd/0BPP///AbAO6vyHe/r5Leugzn/Qp5/fsg7q/Id++vn/sYB1UOc/ANTPb1kHdf7DQP38lnVQ56JvF/e5qHPRt4v7XNS56NvFfS7qXPTt4j4XdS76dnGfizoXfbu4z0Wdi75d3OeizkXfntznSZ0nfXtynyd1nvTtyX2e1HnStyf3eVLnSd+e3OdJnSd9e3KfJ3We9O3JfZ7UedK3J/d5UudJ357c50mdJ317cp8ndZ707cl9ntR50rcn93lS50nfntznSZ0nfXtynyd1nvTtyX2e1HnStyf3eVLnSd+e3OdJnSd9e3KfJ3We9O3JfZ7UedK3J/d5UudJ357c50mdJ317cp8ndZ707cl9ntR50rcn93lS50nfntznSZ0nfXtynyd1nvTtyX2e1HnStyf3eVLnSd+e3OdJnSd9e3KfJ3We9O3JfZ7UedK3J/d5UudJ357c50mdJ317cp8XdV707cV9XtR50bcX93lR50XfXtznRZ0XfXtxnxd1XvTtxX1e1HnRtxf3eVHnRd9e3OdFnRd9e3GfF3Ve9O3FfV7UedG3F/d5UedF317c50WdF317cZ8XdV707cV9XtR50bcX93lR50XfXtznRZ0XfXtxnxd1XvTtxX1e1HnRtxf3eVHnRd9e3OdFnRd9e3GfF3Ve9O3FfV7UedG3F/d5UedF317c50WdF317cZ8XdV707cV9XtR50bcX93lR50XfXtznRZ0XfXtxnxd1XvTtxX1e1HnRtxf3eVHnRd9e3OdFnRd9e3GfF3Ve9O3FfV7UedO3N/d5U+dN397c502dN317c583dd707c193tR507c393lT503f3tznTZ03fXtznzd13vTtzX3e1HnTtzf3eVPnTd/e3OdNnTd9e3OfN3Xe9O3Nfd7UedO3N/d5U+dN397c502dN317c583dd707c193tR507c393lT503f3tznTZ03fXtznzd13vTtzX3e1HnTtzf3eVPnTd/e3OdNnTd9e3OfN3Xe9O3Nfd7UedO3N/d5U+dN397c502dN317c583dd707c193tR507c393lT503f3tznTZ03fXtznzd13vTtzX3e1HnTtzf3eVPnTd8+3OdDnQ99+3CfD3U+9O3DfT7U+dC3D/f5UOdD3z7c50OdD337cJ8PdT707cN9PtT50LcP9/lQ50PfPtznQ50Pfftwnw91PvTtw30+1PnQtw/3+VDnQ98+3OdDnQ99+3CfD3U+9O3DfT7U+dC3D/f5UOdD3z7c50OdD337cJ8PdT707cN9PtT50LcP9/lQ50PfPtznQ50Pfftwnw91PvTtw30+1PnQtw/3+VDnQ98+3OdDnQ99+3CfD3U+9O3DfT7U+dC3D/f5UOdD3z7c50OdD337cJ8PdT707cN9PtT50LcP9/lQ50PfPtznQ50Pfftwny91vvTty32+1PnSty/3+VLnS9++3OdLnS99+3KfL3W+9O3Lfb7U+dK3L/f5UudL377c50udL337cp8vdb707ct9vtT50rcv9/lS50vfvtznS50vfftyny91vvTty32+1PnSty/3+VLnS9++3OdLnS99+3KfL3W+9O3Lfb7U+dK3L/f5UudL377c50udL337cp8vdb707ct9vtT50rcv9/lS50vfvtznS50vfftyny91vvTty32+1PnSty/3+VLnS9++3OdLnS99+3KfL3W+9O3Lfb7U+dK3L/f5UudL377c50udL337cp8vdb707ct9vq/O7+f17ffz7vP7eXV+P69vv593n9/Pq/P7eX37/bz7/H5end/P69vv593n93P4xuvb7+fd5/dz+Mbr2+/n3ef3c/jG69vv57COyzde334/l3VcvvH69vu5rOPyjde3389lHZdvBHsVrCP4RrBXwTqCbwR7Fawj+EawV2Id4htir8Q6xDfEXol1iG+IvRLrSL6R7FWyjuQbyV4l60i+kexVso7kG8VeFesovlHsVbGO4hvFXhXrKL5R7FWzjuYbzV4162i+0exVs47mG81eNesYvjHs1bCO4RvDXg3rGL4x7NWwjuEby14t61i+sezVso7lG8teLetYvvH69nvefX4PdX5e337Pu8/voc7P69vveff5PdT5eX37Pe8+v4c6P69vv+fd5/dQ5+f17fe8+/we6vy8vv2ed5/fQ52f17ffc1kHdX5e337PZR3U+Xl9+z2XdVDn57JXwTqo8xPsVbAO6vwEexWsgzo/wV4F66DOj9grsQ7q/Ii9Euugzo/YK7EO6vwke5Wsgzo/yV4l66DOT7JXyTqo85PsVbEO6vwUe1Wsgzo/xV4V66DOT7FXxTqo89PsVbMO6vw0e9Wsgzo/zV4166DOz7BXwzqo8zPs1bAO6vwMezWsgzo/w14t66DOz7JXyzqo87Ps1bIO6vwse8V9Dg937+vb7+U+h4e79/Xt93Kfw8Pd+/r2e7nP4eHufX37vdzn8HD3vr79Xu5zeLh7X99+L/c5PNy9r2+/l/scHu7e17ffy30OD3fv69vv5T6Hh7v39e33cp/Dw90b7BX3OTzcvcFecZ/Dw90b7BX3OTzcvWKvuM/h4e4Ve8V9Dg93r9gr7nN4uHvFXnGfw8Pdm+wV9zk83L3JXnGfw8Pdm+wV9zk83L3FXnGfw8PdW+wV9zk83L3FXnGfw8Pd2+wV9zk83L3NXnGfw8Pd2+wV9zk83L3NXnGfw8PdO+wV9zk83L3DXnGfw8PdO+wV9zk83L3LXnGfw8Pdu+wV9zk83L3LXnGfw8PdoG8P7nN4uBv07cF9Dg93g749uM/h4W7Qtwf3OTzcDfr24D6Hh7tB3x7c5/BwN+jbg/scHu4GfXtwn8PD3aBvD+5zeLgb9O3BfQ4Pd4O+PbjP4eFu0LcH9zk83A369uA+h4e7Qd8e3OfwcDfo24P7HB7uBn17cJ/Dw92gbw/uc3i4G/TtwX0OD3eDvj24z+HhbtC3B/c5PNwN+vbgPoeHu0HfHtzn8HA36NuD+xwe7gZ9e3Cfw8PdoG8P7nN4uBv07cF9Dg93g749uM/h4W7Qtwf3OTzcDfr24D6Hh7tB3x7c5/BwN+jbg/scHu4GfXtwn8PD3aBvD+5zeLgb9O3iPoeHu6JvF/c5PNwVfbu4z+HhrujbxX0OD3dF3y7uc3i4K/p2cZ/Dw13Rt4v7HB7uir5d3OfwcFf07eI+h4e7om8X9zk83BV9u7jP4eGu6NvFfQ4Pd0XfLu5zeLgr+nZxn8PDXdG3i/scHu6Kvl3c5/BwV/Tt4j6Hh7uibxf3OTzcFX27uM/h4a7o28V9Dg93Rd8u7nN4uCv6dnGfw8Nd0beL+xwe7oq+Xdzn8HBX9O3iPoeHu6JvF/c5PNwVfbu4z+HhrujbxX0OD3dF3y7uc3i4K/p2cZ/Dw13Rt4v7HB7uir5d3OfwcFf07eI+h4e7om8X9zk83E369uQ+h4e7Sd+e3OfwcDfp25P7HB7uJn17cp/Dw92kb0/uc3i4m/TtyX0OD3eTvj25z+HhbtK3J/c5PNxN+vbkPoeHu0nfntzn8HA36duT+xwe7iZ9e3Kfw8PdpG9P7nN4uJv07cl9Dg93k749uc/h4W7Styf3OTzcTfr25D6Hh7tJ357c5/BwN+nbk/scHu4mfXtyn8PD3aRvT+5zeLib9O3JfQ4Pd5O+PbnP4eFu0rcn9zk83E369uQ+h4e7Sd+e3OfwcDfp25P7HB7uJn17cp/Dw92kb0/uc3i4m/TtyX0OD3eTvj25z+HhbtK3J/c5PNxN+vbkPoeHu0XfXtzn8HC36NuL+xwe7hZ9e3Gfw8Pdom8v7nN4uFv07cV9Dg93i769uM/h4W7Rtxf3OTzcLfr24j6Hh7tF317c5/Bwt+jbi/scHu4WfXtxn8PD3aJvL+5zeLhb9O3FfQ4Pd4u+vbjP4eFu0bcX9zk83C369uI+h4e7Rd9e3OfwcLfo24v7HB7uFn17cZ/Dw92iby/uc3i4W/TtxX0OD3eLvr24z+HhbtG3F/c5PNwt+vbiPoeHu0XfXtzn8HC36NuL+xwe7hZ9e3Gfw8Pdom8v7nN4uFv07cV9Dg93i769uM/h4W7Rtxf3OTzcLfr24j6Hh7tF317c5/Bwt+jbm/scHu42fXtzn8PD3aZvb+5zeLjb9O3NfQ4Pd5u+vbnP4eFu07c39zk83G369uY+h4e7Td/e3OfwcLfp25v7HB7uNn17c5/Dw92mb2/uc3i42/TtzX0OD3ebvr25z+HhbtO3N/c5PNxt+vbmPoeHu03f3tzn8HC36dub+xwe7jZ9e3Ofw8Pdpm9v7nN4uNv07c19Dg93m769uc/h4W7Ttzf3OTzcbfr25j6Hh7tN397c5/Bwt+nbm/scHu42fXtzn8PD3aZvb+5zeLjb9O3NfQ4Pd5u+vbnP4eFu07c39zk83G369uY+h4e7Td/e3OfwcLfp25v7HB7uNn17c5/Dw92hbx/uc3i4O/Ttw30OD3eHvn24z+Hh7tC3D/c5PNwd+vbhPoeHu0PfPtzn8HB36NuH+xwe7g59+3Cfw8PdoW8f7nN4uDv07cN9Dg93h759uM/h4e7Qtw/3OTzcHfr24T6Hh7tD3z7c5/Bwd+jbh/scHu4Offtwn8PD3aFvH+5zeLg79O3DfQ4Pd4e+fbjP4eHu0LcP9zk83B369uE+h4e7Q98+3OfwcHfo24f7HB7uDn37cJ/Dw92hbx/uc3i4O/Ttw30OD3eHvn24z+Hh7tC3D/c5PNwd+vbhPoeHu0PfPtzn8HB36NuH+xwe7g59+3Cfw8PdoW8f7nN4uLv07ct9Dg93l759uc/h4e7Sty/3OTzcXfr25T6Hh7tL377c5/Bwd+nbl/scHu4ufftyn8PD3aVvX+5zeLi79O3LfQ4Pd5e+fbnP4eHu0rcv9zk83F369uU+h4e7S9++3OfwcHfp25f7HB7uLn37cp/Dw92lb1/uc3i4u/Tty30OD3eXvn25z+Hh7tK3L/c5PNxd+vblPoeHu0vfvtzn8HB36duX+xwe7i59+3Kfw8PdpW9f7nN4uLv07ct9Dg93l759uc/h4e7Sty/3OTzcXfr25T6Hh7tL377c5/Bwd+nbl/scHu4ufftyn8PD3aVvX+5zeLi79O3LfQ4Pd/f17fF593nAw8Xn9e3xefd5wMPF5/Xt8Xn3ecDDxef17fF593nAw8Xn9e3xefd5wMPF5/Xt8Xn3ecDDxef17fF593nAw8Xn9e3xuazj8o3Xt8fnso7LN17fHp/LOi7fuOxVsI7gG8FeBesIvhHsVbCO4BvBXgXrEN8QeyXWIb4h9kqsQ3xD7JVYh/hGslfJOpJvJHuVrCP5RrJXyTqSbyR7Vayj+EaxV8U6im8Ue1Wso/hGsVfFOppvNHvVrKP5RrNXzTqabzR71ayj+cawV8M6hm8MezWsY/jGsFfDOoZvDHu1rGP5xrJXyzqWbyx7taxj+cayV+8+D3i4OK9vj/Pu84CHi/P69jjvPg94uDivb4/z7vOAh4vz+vY47z4PeLg4r2+P8+7zgIeL8/r2OO8+D3i4OK9vj3NZB3V+Xt8e57IO6vy8vj3OZR3U+Xl9e5zLOqjzE+xVsA7q/AR7FayDOj/BXgXroM6P2CuxDur8iL0S66DOj9grsQ7q/Ii9StZBnZ9kr5J1UOcn2atkHdT5SfYqWQd1foq9KtZBnZ9ir4p1UOen2KtiHdT5afaqWQd1fpq9atZBnZ9mr5p1UOen2athHdT5GfZqWAd1foa9GtZBnZ9hr4Z1UOdn2atlHdT5WfZqWQd1fpa9WtZBnd/Xtwd+uICHi/v69sAPF/BwcV/fHvjhAh4u7uvbAz9cwMPFfX174IcLeLi4r28P/HABDxf39e2BHy7g4eK+vj3wwwU8XNzXtwd+uICHi/v69sAPF/BwcYO94j6Hh4sb7BX3OTxc3GCvuM/h4eIGe8V9Dg8XV+wV9zk8XFyxV9zn8HBxxV5xn8PDxU32ivscHi5uslfc5/BwcZO94j6Hh4tb7BX3OTxc3GKvuM/h4eIWe8V9Dg8Xt9gr7nN4uLjNXnGfw8PFbfaK+xweLm6zV9zn8HBxh73iPoeHizvsFfc5PFzcYa+4z+Hh4i57xX0ODxd32Svuc3i4uMtecZ/Dw8Wlb8cPF/BwEfTt+OECHi6Cvh0/XMDDRdC344cLeLgI+nb8cAEPF0Hfjh8u4OEi6NvxwwU8XAR9O364gIeLoG/HDxfwcBH07fjhAh4ugr4dP1zAw0XQt+OHC3i4CPp2/HABDxdB344fLuDhIujb8cMFPFwEfTt+uICHi6Bvxw8X8HAR9O344QIeLoK+HT9cwMNF0Lfjhwt4uAj6dvxwAQ8XQd+OHy7g4SLo2/HDBTxcBH07friAh4ugb8cPF/BwEfTt+OECHi6Cvh0/XMDDRdC344cLeLgI+nb8cAEPF0Hfjh8u4OEi6NvxwwU8XAR9O364gIeLoG/HDxfwcBH07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4UL07fjhAh4uRN+OHy7g4SLp2/HDBTxcJH07friAh4ukb8cPF/BwkfTt+OECHi6Svh0/XMDDRdK344cLeLhI+nb8cAEPF0nfjh8u4OEi6dvxwwU8XCR9O364gIeLpG/HDxfwcJH07fjhAh4ukr4dP1zAw0XSt+OHC3i4SPp2/HABDxdJ344fLuDhIunb8cMFPFwkfTt+uICHi6Rvxw8X8HCR9O344QIeLpK+HT9cwMNF0rfjhwt4uEj6dvxwAQ8XSd+OHy7g4SLp2/HDBTxcJH07friAh4ukb8cPF/BwkfTt+OECHi6Svh0/XMDDRdK344cLeLhI+nb8cAEPF0nfjh8u4OEi6dvxwwU8XCR9O364gIeLom/HDxfwcFH07fjhAh4uir4dP1zAw0XRt+OHC3i4KPp2/HABDxdF344fLuDhoujb8cMFPFwUfTt+uICHi6Jvxw8X8HBR9O344QIeLoq+HT9cwMNF0bfjhwt4uCj6dvxwAQ8XRd+OHy7g4aLo2/HDBTxcFH07friAh4uib8cPF/BwUfTt+OECHi6Kvh0/XMDDRdG344cLeLgo+nb8cAEPF0Xfjh8u4OGi6NvxwwU8XBR9O364gIeLom/HDxfwcFH07fjhAh4uir4dP1zAw0XRt+OHC3i4KPp2/HABDxdF344fLuDhoujb8cMFPFwUfTt+uICHi6Jvxw8X8HDR9O344QIeLpq+HT9cwMNF07fjhwt4uGj6dvxwAQ8XTd+OHy7g4aLp2/HDBTxcNH07friAh4umb8cPF/Bw0fTt+OECHi6avh0/XMDDRdO344cLeLho+nb8cAEPF03fjh8u4OGi6dvxwwU8XDR9O364gIeLpm/HDxfwcNH07fjhAh4umr4dP1zAw0XTt+OHC3i4aPp2/HABDxdN344fLuDhounb8cMFPFw0fTt+uICHi6Zvxw8X8HDR9O344QIeLpq+HT9cwMNF07fjhwt4uGj6dvxwAQ8XTd+OHy7g4aLp2/HDBTxcNH07friAh4umb8cPF/Bw0fTt+OECHi6Gvh0/XMDDxdC344cLeLgY+nb8cAEPF0Pfjh8u4OFi6NvxwwU8XAx9O364gIeLoW/HDxfwcDH07fjhAh4uhr4dP1zAw8XQt+OHC3i4GPp2/HABDxdD344fLuDhYujb8cMFPFwMfTt+uICHi6Fvxw8X8HAx9O344QIeLoa+HT9cwMPF0Lfjhwt4uBj6dvxwAQ8XQ9+OHy7g4WLo2/HDBTxcDH07friAh4uhb8cPF/BwMfTt+OECHi6Gvh0/XMDDxdC344cLeLgY+nb8cAEPF0Pfjh8u4OFi6NvxwwU8XAx9O364gIeLoW/HDxfwcDH07fjhAh4uhr4dP1zAw8XQt+OHC3i4WPp2/HABDxdL344fLuDhYunb8cMFPFwsfTt+uICHi6Vvxw8X8HCx9O344QIeLpa+HT9cwMPF0rfjhwt4uFj6dvxwAQ8XS9+OHy7g4WLp2/HDBTxcLH07friAh4ulb8cPF/BwsfTt+OECHi6Wvh0/XMDDxdK344cLeLhY+nb8cAEPF0vfjh8u4OFi6dvxwwU8XCx9O364gIeLpW/HDxfwcLH07fjhAh4ulr4dP1zAw8XSt+OHC3i4WPp2/HABDxdL344fLuDhYunb8cMFPFwsfTt+uICHi6Vvxw8X8HCx9O344QIeLpa+HT9cwMPF0rfjhwt4uFj6dvxwgofT5/Xtwg8neDh9Xt8u/HCCh9Pn9e3CDyd4OH1e3y78cIKH0+f17cIPJ3g4fV7fLvxwgofT5/Xtwg8neDh9Xt8u/HCCh9Pn9e3CDyd4OH1e3y78cIKH0yfYq2AdwTeCvQrWEXwj2KtgHcE3xF6JdYhviL0S6xDfEHsl1iG+IfYqWUfyjWSvknUk30j2KllH8o1kr5J1FN8o9qpYR/GNYq+KdRTfKPaqWEfxjWavmnU032j2qllH841mr5p1NN9o9mpYx/CNYa+GdQzfGPZqWMfwjWGvhnUs31j2alnH8o1lr5Z1LN9Y9mpZB3V+Xt8u/HCCh9N5fbvwwwkeTuf17cIPJ3g4nde3Cz+c4OF0Xt8u/HCCh9N5fbvwwwkeTuf17cIPJ3g4nde3Cz+c4OF0Xt8u/HCCh9N5fbvwwwkeTifYq2Ad1PkJ9ipYB3V+gr0K1kGdn2CvxDqo8yP2SqyDOj9ir8Q6qPMj9kqsgzo/yV4l66DOT7JXyTqo85PsVbIO6vwUe1Wsgzo/xV4V66DOT7FXxTqo81PsVbMO6vw0e9Wsgzo/zV4166DOyUsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzycyEsVfjjBw4m8VOGHEzxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUxA+X8HBJXmrih0t4uCQvNfHDJTxckpea+OESHi7JS038cAkPl+SlJn64hIdL8lITP1zCwyV5qYkfLuHhkrzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64gocr8lILP1zBwxV5qYUfruDhirzUwg9X8HBFXmrhhyt4uCIvtfDDFTxckZda+OEKHq7ISy38cAUPV+SlFn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTxck5fa+OEaHq7JS238cA0P1+SlNn64hodr8lIbP1zDwzV5qY0fruHhmrzUxg/X8HBNXmrjh2t4uCYvtfHDNTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUwQ838HBDXurghxt4uCEvdfDDDTzckJc6+OEGHm7ISx38cAMPN+SlDn64gYcb8lIHP9zAww15qYMfbuDhhrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn64hYdb8lIXP9zCwy15qYsfbuHhlrzUxQ+38HBLXurih1t4uCUvdfHDLTzckpe6+OEWHm7JS138cAsPt+SlLn648wGI+z7+2q3v4/VPw4/yv5D+afmx/S+Mf+qvvRb++3j8U3/tdfHfR/mn/tpr5L+P7Z/6a6+X/+3xem3XX3vt/PfRa7v+2uvov49e2/XXXlP/ffTawl8L72R4beGvhXcyvLbw18I7GV5b+GvyTsprk78m76S8Nvlr8k7Ka5O/Ju9kem3pr6V3Mr229NfSO5leW/pr6Z1Mr638tfJOltdW/lp5J8trK3+tvJPltZW/1t7J9traX2vvZHtt7a+1d7K9tvbX2js5Xtv4a+OdHK9t/LXxTo7XNv7aeCfHa1t/bb2T67Wtv7beyfXa1l9b7+R6bT5LCGX9Ph7/9Pox/C/IP00/lv+F9k/Hj+wkOrrvo792rv+F8E/9tZP+F8o/9dfO+F/w2nyWkNT6ffTafJYQ1vp99Np8lpDX+n302nyWENn6ffTafJaQ2vp99Np8lhDc+n302nyWkN3626O8Np8lxLd+H702nyUkuH4fvTafJYS4fh+9Np8l5Lh+H702nyVEuX4fvTafJaS5fh+9Np8lBLp+H702nyVkun4fvTafJcS6fh+9Np8lJLv+9them88Swl2/j16bzxLyXb+PXpvPEiJev49em88SUl6/j16bzxKCXr+PXpvPErJev49em88S4l6/j16bzxISX7+PXpvPEkJfv49em88Scl9/OzPcl1yfJUS/fh/DP5Uf0/9C+aftx/G/wNquzxIyYL+P1z/11478L6R/6q+d9r8w/qm/dtnJ677k+iwhD/b76LX5LCES9vvotfksIRX2t0f3JddnCcGw30evzWcJ2bDfR6/NZwnxsN9Hr81nCQmx30evzWcJIbHfR6/NZwk5sd9Hr81nCVGx30evzWcJabHfR6/NZwmBsd9Hr81nCZmxvz26L7k+S4iN/T56bT5LSI79PnptPksIj/0+em0+S8iP/T56bT5LiJD9PnptPktIkf0+em0+SwiS/T56bT5LyJL9PnptPkuIk/0+em0+S0iU/e3Rfcn1WUKo7PfRa/NZQq7s99Fr81lCtOz3kbWFz5LwjBPuS8JnSXjGCfcl4bMkPOOE+5LwWRKeccJ9SfgsCc844b4kfJaEZ5xwXxI+S8IzTrgvCZ8l4Rkn3JeEz5LwjBPuS8JnSXjGCfcl4bMkPOOE+5LwWRKeccJ9SfgsCc844b4kfJaEZ5xwXxI+S8IzTrgvCZ8l4Rkn3JeEz5LwjBPuS8JnSXjGCfcl4bMkPOOE+5LwWRKeccJ9SfgsCc844b4kfJaEZ5xwXxI+S8IzTrgvCZ8l4Rkn3JeEz5LwjBPuS8JnSXjGCfcl4bMkPOOE+5LwWRKeccJ9SfgsCc844b4kfJaEZ5xwXxI+S8IzTrgvCZ8l4Rkn3JeEz5LwjBPuS8JniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM47cl8hniTzjyH2JfJbIM066L0mfJekZJ92XpM+S9IyT7kvSZ0l6xkn3JemzJD3jpPuS9FmSnnHSfUn6LEnPOOm+JH2WpGecdF+SPkvSM066L0mfJekZJ92XpM+S9IyT7kvSZ0l6xkn3JemzJD3jpPuS9FmSnnHSfUn6LEnPOOm+JH2WpGecdF+SPkvSM066L0mfJekZJ92XpM+S9IyT7kvSZ0l6xkn3JemzJD3jpPuS9FmSnnHSfUn6LEnPOOm+JH2WpGecdF+SPkvSM066L0mfJekZJ92XpM+S9IyT7kvSZ0l6xkn3JemzJD3jpPuS9FmSnnHSfUn6LEnPOOm+JH2WpGecdF+SPkvSM066L0mfJekZJ92XlM+S8oxT7kvKZ0l5xin3JeWzpDzjlPuS8llSnnHKfUn5LCnPOOW+pHyWlGeccl9SPkvKM065LymfJeUZp9yXlM+S8oxT7kvKZ0l5xin3JeWzpDzjlPuS8llSnnHKfUn5LCnPOOW+pHyWlGeccl9SPkvKM065LymfJeUZp9yXlM+S8oxT7kvKZ0l5xin3JeWzpDzjlPuS8llSnnHKfUn5LCnPOOW+pHyWlGeccl9SPkvKM065LymfJeUZp9yXlM+S8oxT7kvKZ0l5xin3JeWzpDzjlPuS8llSnnHKfUn5LCnPOOW+pHyWlGeccl9SPkvKM065LymfJeUZp9yXlM+S8oxT7kvKZ0l7xmn3Je2zpD3jtPuS9lnSnnHafUn7LGnPOO2+pH2WtGecdl/SPkvaM067L2mfJe0Zp92XtM+S9ozT7kvaZ0l7xmn3Je2zpD3jtPuS9lnSnnHafUn7LGnPOO2+pH2WtGecdl/SPkvaM067L2mfJe0Zp92XtM+S9ozT7kvaZ0l7xmn3Je2zpD3jtPuS9lnSnnHafUn7LGnPOO2+pH2WtGecdl/SPkvaM067L2mfJe0Zp92XtM+S9ozT7kvaZ0l7xmn3Je2zpD3jtPuS9lnSnnHafUn7LGnPOO2+pH2WtGecdl/SPkvaM067L2mfJe0Zp92XtM+S9ozT7kvaZ0l7xmn3Je2zpD3jjPuS8VkynnHGfcn4LBnPOOO+ZHyWjGeccV8yPkvGM864LxmfJeMZZ9yXjM+S8Ywz7kvGZ8l4xhn3JeOzZDzjjPuS8VkynnHGfcn4LBnPOOO+ZHyWjGeccV8yPkvGM864LxmfJeMZZ9yXjM+S8Ywz7kvGZ8l4xhn3JeOzZDzjjPuS8VkynnHGfcn4LBnPOOO+ZHyWjGeccV8yPkvGM864LxmfJeMZZ9yXjM+S8Ywz7kvGZ8l4xhn3JeOzZDzjjPuS8VkynnHGfcn4LBnPOOO+ZHyWjGeccV8yPkvGM864LxmfJeMZZ9yXjM+S8Ywz7kvGZ8l4xhn3JeOzZDzjjPuS8VkynnHGfcn6LFnPOOu+ZH2WrGecdV+yPkvWM866L1mfJesZZ92XrM+S9Yyz7kvWZ8l6xln3JeuzZD3jrPuS9VmynnHWfcn6LFnPOOu+ZH2WrGecdV+yPkvWM866L1mfJesZZ92XrM+S9Yyz7kvWZ8l6xln3JeuzZD3jrPuS9VmynnHWfcn6LFnPOOu+ZH2WrGecdV+yPkvWM866L1mfJesZZ92XrM+S9Yyz7kvWZ8l6xln3JeuzZD3jrPuS9VmynnHWfcn6LFnPOOu+ZH2WrGecdV+yPkvWM866L1mfJesZZ92XrM+S9Yyz7kvWZ8l6xln3JeuzZD3jrPuS9VmynnHWfcn6LFnPOOu+xNzrIRj5+3j80+vH8L8g/zT9WP4X2j8dPy7/An3JMfd6CEn+PoZ/6q8x4xzEkN9Hf40Z5+CGPMfc6yEt+fvotV1/jRnnYIj8PvprzDgHSeT30V8L72R4beGvhXcyvLbw18I7GV5b+GvhnZTXJn9N3kl5bfLX5J2U1yZ/Td5JeW3pr6V3Mr229NfSO5leW/pr6Z1Mry39tfJOltdW/lp5J8trK3+tvJPltZW/Vt7J9traX2vvZHtt7a+1d7K9tvbX2jvZXtv4a+OdHK9t/LXxTo7XNv7aeCfHaxt/bb2T67Wtv7beyfXa1l9b7+R6beuvMeMcZJPfx+PH638h/FP5Mf0vlH/afhz/C6zN3Oshh/n7dP1Tf40Z5+Ce/D76a8w4B/3k99FfY8Y5GCi/j/4aM85BQvl99NeYcQ4eyu+jv3a9k+G1+SwhnPn76LX5LCGf+fvotfksIaL5++i1+Swhpfn76LX5LCGo+fvotfksIav5++i1+Swhrvn76LX5LCGx+fvotfksIbT5++i1+Swht/n7P7HX5rOE6Obvo9fms4T05u+j1+azhADn76PX5rOEDOfvo9fms4QY5++j1+azhCTn76PX5rOEMOfvo9fms4Q85++j1+azhEjn76PX5rOEVOdvLXhtPksIdv4+em0+S8h2/j56bT5LiHf+PrI2c6+HhOfv4/VPw4/yv5D+afmx/S+Mf+qvMeOc677E3Osh7fn7KP/UX2PGOdd9ibnXQ+bz99Dw2nyWEPv8ffTafJaQ/Px99Np8lhD+/H302nyWkP/8ffTafJYQAf199Np8lpAC/X302nyWEAT9ffTafJaQBf199Np8lhAH/X302nyWkAj9PV29Np8lhEJ/H702nyXkQn8fvTafJURDfx+9Np8lpEN/H702nyUERH8fvTafJWREfx+9Np8lxER/H702nyUkRX8fvTafJYRFfx+9Np8l5EV/ryGvzWcJkdHfR6/NZwmp0d9Hr81nCcHR30evzWcJ2dHfR6/NZwnx0d9Hr81nCQnS30evzWdJeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMYJ9yXmXk94xgn3JeZeT3jGCfcl5l5PeMaR+xJzr0eeceS+xNzrkWccuS8x93rkGUfuS8y9HnnGkfsSc69HnnHkvsTc65FnHLkvMfd65BlH7kvMvR55xpH7EnOvR55x5L7E3OuRZxy5LzH3euQZR+5LzL0eecaR+xJzr0eeceS+xNzrkWccuS8x93rkGUfuS8y9HnnGkfsSc69HnnHkvsTc65FnHLkvMfd65BlH7kvMvR55xpH7EnOvR55x5L7E3OuRZxy5LzH3euQZR+5LzL0eecaR+xJzr0eeceS+xNzrkWccuS8x93rkGUfuS8y9HnnGkfsSc69HnnHkvsTc65FnHLkvMfd65BlH7kvMvR55xpH7EnOvR55x5L7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OtJzzjpvsTc60nPOOm+xNzrSc846b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjlvsTc6ynPOOW+xNzrKc845b7E3OspzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc62nPOO2+xNzrac847b7E3OtpzzjtvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc6xnPOOO+xNzrGc84477E3OsZzzjjvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc61nPOOu+xNzrWc84677E3OtZzzjrvsTc6yH//IuXvLVdc6+XCPTvY/in8mP6Xyj/tP04/heWnx5/jRnn2vd6zb1e4tC/j+mf+mvMONe+12vu9RKK/n302q6/xoxz7Xu95l4v0ejfR6/t+mvXOxleW/hr4Z0Mry38tfBOhtcW/lp4J8Nrk78m76S8Nvlr8k7Ka5O/Ju+kvDb5a+mdTK8t/bX0TqbXlv5aeifTa0t/Lb2T5bWVv1beyfLayl8r72R5beWvlXeyvLb219o72V5b+2vtnWyvrf219k6219b+2ngnx2sbf228k+O1jb823snx2sZfG+/kem3rr613cr229dfWO7le2/pr652kL7nmXi8p69/H65+GH+V/If3T8mP7Xxj/1F9jxrn2vV5zr5fE9e+j/FN/jRnn2vd6zb1ecte/CJzX5rOE6PXvo9fms4T09e+j1+azhAD276PX5rOEDPbvo9fms4QY9u+j1+azhCT276PX5rOEMPbvo9fms4Q89u+j1+azhEj276PX5rOEVPYvK+i1+SwhmP376LX5LCGb/fvotfksIZ79++i1+Swhof376LX5LCGk/fvotfksIaf9++i1+Swhqv376LX5LCGt/fvotfksIbD9++i1+Swhs/0LVXptPkuIbf8+em0+S0hu/z56bT5LCG//PnptPkvIb/8+em0+S4hw/z56bT5LSHH/PnptPksIcv8+Hv/0+jH8L8g/TT+W/4X2T8eP7KR9r9fc6yXU/fsY/qm/xoxz7Xu95l4v0e7fR6/NZwnp7t9Hr81nCQHv30evzWcJGe/fR6/NZwkx799Hr81nCUnv30evzWcJYe/fR6/NZwl5719M12vzWULk+/fRa/NZQur799Fr81lC8Pv30WvzWUL2+/fRa/NZQvz799Fr81lCAvz30WvzWUII/PfRa/NZQg7899Fr81lCFPz30WvzWUIa/Jdn9tp8lhAI/3302nyWkAn/ffTafJYQC/999Np8lpAM/3302nyWEA7/ffTafJaQD/999Np8lhAR/3302nyWkBL/ffTafJYQFP999Np8llzPOPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb3e8Ixj3+s193rDM459r9fc6w3POPa9XnOvNzzj2Pd6zb1eecax7/Wae73yjGPf6zX3euUZx77Xa+71yjOOfa/X3OuVZxz7Xq+51yvPOPa9XnOvV55x7Hu95l6vPOPY93rNvV55xrHv9Zp7vfKMY9/rNfd65RnHvtdr7vXKM459r9fc65VnHPter7nXK8849r1ec69XnnHse73mXq8849j3es29XnnGse/1mnu98oxj3+s193rlGce+12vu9cozjn2v19zrlWcc+16vudcrzzj2vV5zr1eecex7veZerzzj2Pd6zb1eecax7/Wae73yjGPf6zX3euUZx77Xa+71yjOOfa/X3OuVZxz7Xq+51yvPOPa9XnOvV55x7Hu95l6vPOPY93rNvV55xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vudebnnHse73mXm96xrHv9Zp7vekZx77Xa+71pmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm95xrHv9Zp7veUZx77Xa+71lmcc+16vuddbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7ve0Zx77Xa+71tmcc+16vudfbnnHse73mXm97xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vudc7nnHse73mXu94xrHv9Zp7veMZx77Xa+71jmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHse73mXu96xrHv9Zp7vesZx77Xa+71rmcc+16vude7nnHsew1zr/Fhxgn7XsPca3yYccK+1zD3Gh9mnLDvNcy9xocZJ+x7DXOv8WHGCftew9xrfJhxwr7XMPcaH2acsO81zL3Ghxkn7HsNc6/xYcYJ+17D3Gt8mHHCvtcw9xqf8E6G1xb+Wngnw2sLfy28k+G1hb8m76S8Nvlr8k7Ka5O/Ju+kvDb5a/JOpteW/lp6J9NrS38tvZPptaW/lt7J9NrKXyvvZHlt5a+Vd7K8tvLXyjtZXlv5a+2dbK+t/bX2TrbX1v5aeyfba2t/rb2T47WNvzbeyfHaxl8b7+R4beOvjXdyvLb119Y7uV7b+mvrnVyvbf219U6u1+az5DDjhH2vYe41DjNO2Pca5l7jMOOEfa9h7jUOM07Y9xrmXuMw44R9r2HuNQ4zTtj3GuZe4zDjhH2vYe41DjNO2Pca5l7jMOOEfa9h7jUOM07Y9xrmXuOEdzK8Np8lJ7yT4bX5LDnhnQyvzWfJCe+kvDafJUfeSXltPkuOvJPy2nyWHHkn5bX5LDnpnUyvzWfJSe9kem0+S056J9Nr81lyyjtZXpvPklPeyfLafJac8k6W1+az5JR3sr02nyWnvZPttfksOe2dbK/NZ8lp72R7bT5Lzngnx2vzWXLGOzlem8+SM97J8dp8lpz1Tq7X5rPkrHdyvTafJWe9k+u1+Sw5zDhh32uYe43LjBP2vYa517jMOGHfa5h7jcuME/a9hrnXuMw4Yd9rmHuNy4wT9r2Gude4zDhh32uYe43LjBP2vYa517jMOGHfa5h7jcuME/a9hrnXuNc76b7E3Gvc8E66LzH3Gje8k+5LzL3GDe+k+xJzr3HlnXRfYu41rryT7kvMvcaVd9J9ibnXuOmddF9i7jVueifdl5h7jZveSfcl5l7jpnfSfYm517jlnXRfYu41bnkn3ZeYe41b3kn3JeZe47Z30n2Jude47Z10X2LuNW57J92XmHuNO95J9yXmXuOOd9J9ibnXuOOddF9i7jXueCfdl5h7jbveSfcl5l7jrnfSfYm517jrnXRfYu41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe41wjOOfa9h7jXCM459r2HuNcIzjn2vYe415BnHvtcw9xryjGPfa5h7DXnGse81zL2GPOPY9xrmXkOecex7DXOvIc849r2GudeQZxz7XsPca8gzjn2vYe415BnHvtcw9xryjGPfa5h7DXnGse81zL2GPOPY9xrmXkOecex7DXOvIc849r2GudeQZxz7XsPca8gzjn2vYe415BnHvtcw9xryjGPfa5h7DXnGse81zL2GPOPY9xrmXkOecex7DXOvIc849r2GudeQZxz7XsPca8gzjn2vYe415BnHvtcw9xryjGPfa5h7DXnGse81zL2GPOPY9xrmXkOecex7DXOvIc849r2GudeQZxz7XsPca8gzjn2vYe415BnHvtcw9xryjGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfSMY99rmHuN9Ixj32uYe430jGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfKMY99rmHuN8oxj32uYe43yjGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN9oxj32uYe432jGPfa5h7jfaMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN8Yxj32uYe43xjGPfa5h7jfGMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHuN9Yxj32uYe431jGPfa5h7jfWMY99rmHvVhxlH9r3K3Ks+zDiy71XmXvVhxpF9rzL3qg8zjux7lblXfZhxZN+rzL3qw4wj+15l7lUfZhzZ9ypzr/ow48i+V5l71YcZR/a9ytyrPsw4su9V5l71Ce9keG3hr4V3Mry28NfCOxleW/hr4Z2U1yZ/Td5JeW3y1+SdlNcmf03eSXlt6a+ldzK9tvTX0juZXlv6a+mdTK8t/bXyTpbXVv5aeSfLayt/rbyT5bWVv1beyfba2l9r72R7be2vtXeyvbb219o72V7b+GvjnRyvbfy18U6O1zb+2ngnx2sbf229k+u1rb+23sn12tZfW+/kem3rrzHjyL5XmXvVYcaRfa8y96rDjCP7XmXuVYcZR/a9ytyrDjOO7HuVuVcdZhzZ9ypzrzrMOLLvVeZedZhxZN+rzL3qMOPIvleZe9VhxpF9rzL3qnO9k+G1+Sw54Z0Mr81nyQnvZHhtPktOeCfDa/NZcuSdlNfms+TIOymvzWfJkXdSXpvPkpPeyfTafJac9E6m1+az5KR3Mr02nyUnvZPltfksOeWdLK/NZ8kp72R5bT5LTnkny2vzWXLaO9lem8+S097J9tp8lpz2TrbX5rPkjHdyvDafJWe8k+O1+Sw5450cr81nyRnv5HptPkvOeifXa/NZctY7uV6bz5Kz3kn3JeZedZlxZN+rzL3qMuPIvleZe9VlxpF9rzL3qsuMI/teZe5VlxlH9r3K3KsuM47se5W5V11mHNn3KnOvusw4su9V5l51mXFk36vMveoy48i+V5l71Q3vpPsSc6+64Z10X2LuVTe8k+5LzL3qyjvpvsTcq668k+5LzL3qyjvpvsTcq668k+5LzL3qpnfSfYm5V930TrovMfeqm95J9yXmXnXLO+m+xNyrbnkn3ZeYe9Ut76T7EnOvuu2ddF9i7lW3vZPuS8y96rZ30n2JuVfd9k66LzH3qjveSfcl5l51xzvpvsTcq+54J92XmHvVXe+k+xJzr7rrnXRfYu5Vd72T7kvMvSo849j3KnOvCs849r3K3KvCM459rzL3qvCMY9+rzL0qPOPY9ypzrwrPOPa9ytyrwjOOfa8y96rwjGPfq8y9Kjzj2Pcqc68Kzzj2vcrcq8Izjn2vMveq8Ixj36vMvSo849j3KnOvCs849r3K3KvCM459rzL3qvCMY9+rzL0qPOPY9ypzrwrPOPa9ytyrwjOOfa8y96rwjGPfq8y9Kjzj2Pcqc68Kzzj2vcrcq8Izjn2vMveq8Ixj36vMvSo849j3KnOvCs849r3K3KvCM459rzL3qvCMY9+rzL0qPOPY9ypzrwrPOPa9ytyrwjOOfa8y96rwjGPfq8y9Kjzj2Pcqc68Kzzj2vcrcq+QZx75XmXuVPOPY9ypzr5JnHPteZe5V8oxj36vMvUqecex7lblXyTOOfa8y9yp5xrHvVeZeJc849r3K3KvkGce+V5l7lTzj2Pcqc6+SZxz7XmXuVfKMY9+rzL1KnnHse5W5V8kzjn2vMvcqecax71XmXiXPOPa9ytyr5BnHvleZe5U849j3KnOvkmcc+15l7lXyjGPfq8y9Sp5x7HuVuVfJM459rzL3KnnGse9V5l4lzzj2vcrcq+QZx75XmXuVPOPY9ypzr5JnHPteZe5V8oxj36vMvUqecex7lblXyTOOfa8y9yp5xrHvVeZeJc849r3K3KvkGce+V5l7VXrGse9V5l6VnnHse5W5V6VnHPteZe5V6RnHvleZe1V6xrHvVeZelZ5x7HuVuVelZxz7XmXuVekZx75XmXtVesax71XmXpWecex7lblXpWcc+15l7lXpGce+V5l7VXrGse9V5l6VnnHse5W5V6VnHPteZe5V6RnHvleZe1V6xrHvVeZelZ5x7HuVuVelZxz7XmXuVekZx75XmXtVesax71XmXpWecex7lblXpWcc+15l7lXpGce+V5l7VXrGse9V5l6VnnHse5W5V6VnHPteZe5V6RnHvleZe1V6xrHvVeZelZ5x7HuVuVelZxz7XmXuVekZx75XmXtVesax71XmXlWecex7lblXlWcc+15l7lXlGce+V5l7VXnGse9V5l5VnnHse5W5V5VnHPteZe5V5RnHvleZe1V5xrHvVeZeVZ5x7HuVuVeVZxz7XmXuVeUZx75XmXtVecax71XmXlWecex7lblXlWcc+15l7lXlGce+V5l7VXnGse9V5l5VnnHse5W5V5VnHPteZe5V5RnHvleZe1V5xrHvVeZeVZ5x7HuVuVeVZxz7XmXuVeUZx75XmXtVecax71XmXlWecex7lblXlWcc+15l7lXlGce+V5l7VXnGse9V5l5VnnHse5W5V5VnHPteZe5V5RnHvleZe1V5xrHvVeZeVZ5x7HuVuVeVZxz7XmXuVe0Zx75XmXtVe8ax71XmXtWecex7lblXtWcc+15l7lXtGce+V5l7VXvGse9V5l7VnnHse5W5V7VnHPteZe5V7RnHvleZe1V7xrHvVeZe1Z5x7HuVuVe1Zxz7XmXuVe0Zx75XmXtVe8ax71XmXtWecex7lblXtWcc+15l7lXtGce+V5l7VXvGse9V5l7VnnHse5W5V7VnHPteZe5V7RnHvleZe1V7xrHvVeZe1Z5x7HuVuVe1Zxz7XmXuVe0Zx75XmXtVe8ax71XmXtWecex7lblXtWcc+15l7lXtGce+V5l7VXvGse9V5l7VnnHse5W5V7VnHPteZe5V7RnHvleZe9V4xrHvVeZeNZ5x7HuVuVeNZxz7XmXuVeMZx75XmXvVeMax71XmXjWecex7lblXjWcc+15l7lXjGce+V5l71XjGse9V5l41nnHse5W5V41nHPteZe5V4xnHvleZe9V4xrHvVeZeNZ5x7HuVuVeNZxz7XmXuVeMZx75XmXvVeMax71XmXjWecex7lblXjWcc+15l7lXjGce+V5l71XjGse9V5l41nnHse5W5V41nHPteZe5V4xnHvleZe9V4xrHvVeZeNZ5x7HuVuVeNZxz7XmXuVeMZx75XmXvVeMax71XmXjWecex7lblXjWcc+15l7lXjGce+V5l71XjGse9V5l61nnHse5W5V61nHPteZe5V6xnHvleZe9V6xrHvVeZetZ5x7HuVuVetZxz7XmXuVesZx75XmXvVesax71XmXrWecex7lblXrWcc+15l7lXrGce+V5l71XrGse9V5l61nnHse5W5V61nHPteZe5V6xnHvleZe9V6xrHvVeZetZ5x7HuVuVetZxz7XmXuVesZx75XmXvVesax71XmXrWecex7lblXrWcc+15l7lXrGce+V5l71XrGse9V5l61nnHse5W5V61nHPteZe5V6xnHvleZe9V6xrHvVeZetZ5x7HuVuVetZxz7XmXuVesZx75XmXvVesax71XmXrWecex7lblXLTNO2vea5l7zw4yT9r2mudf8MOOkfa9p7jU/zDhp32uae80PM07a95rmXvPDjJP2vaa51/ww46R9r2nuNT/MOGnfa5p7zQ8zTtr3muZe88OMk/a9prnX/FzvZHht4a+FdzK8tvDXwjsZXlv4a+GdDK9N/pq8k/La5K/JOymvTf6avJPy2uSvpXcyvbb019I7mV5b+mvpnUyvLf219E6W11b+Wnkny2srf628k+W1lb9W3sny2tpfa+9ke23tr7V3sr229tfaO9leW/tr450cr238tfFOjtc2/tp4J8drG39tvJPrta2/tt7J9drWX1vv5Hpt66+td5K+JM295mHGSfte09xrHmactO81zb3mYcZJ+17T3GseZpz/LxH3kuPIrmRRdEpykvab/8SqMm8+Wz3vKSggiOPQxgrea+he49t3nOC9hu41vn3HCd5r6F7j23ec4L2G7jW+fccJ3mvoXuPbd5zgvYbuNb59xwnea+he47u+yets7pLv+iavs7lLvuubvM7mLvmeb/I5m7vke77J52zuku/5Jp+zuUu+55sMZ3OXfOGbDGdzl3zhmwxnc5d84ZsMZ3OXfOmbTGdzl3zpm0xnc5d86ZtMZ3OXfOWbLGdzl3zlmyxnc5d85ZssZ3OXfOWbbGdzl3ztm2xnc5d87ZtsZ3OXfO2bbGdzl3zjmxxnc5d845scZ3OXfOObHGdzl5x9xwnea+he4+w7TvBeQ/caZ99xgvcautc4+44TvNfQvcbZd5zgvYbuNc6+4wTvNXSvcfYdJ3ivoXuNs+84wXsN3WucfccJ3mvoXuPsO07wXkP3Guf6Ju0S3Wuc65u0S3Svca5v0i7Rvca5vkm7RPca5/km7RLda5znm7RLdK9xnm/SLtG9xgnfpF2ie40Tvkm7RPcaJ3yTdonuNU76Ju0S3Wuc9E3aJbrXOOmbtEt0r3HSN2mX6F7jlG/SLtG9xinfpF2ie41Tvkm7RPcap32TdonuNU77Ju0S3Wuc9k3aJbrXOOObtEt0r3HGN2mX6F7jjG/SLtG9xvGOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvWOw3sN3Wtc7zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3Ws87zi819C9xvOOw3sN3WuEdxzea+heI7zj8F5D9xrhHYf3GrrXCO84vNfQvUZ4x+G9hu41wjsO7zV0rxHecXivoXuN8I7Dew3da4R3HN5r6F4jvOPwXkP3GuEdh/cautcI7zi819C9RnjH4b2G7jXCOw7vNXSvEd5xeK+he43wjsN7Dd1rhHcc3mvoXiO84/BeQ/ca4R2H9xq61wjvOLzX0L1GeMfhvYbuNcI7Du81dK8R3nF4r6F7jfCOw3sN3WuEdxzea+heI7zj8F5D9xrhHYf3GrrXCO84vNfQvUZ4x+G9hu41wjsO7zV0rxHecXivoXuN8I7Dew3da4R3HN5r6F4jvOPwXkP3Gukdh/cautdI7zi819C9RnrH4b2G7jXSOw7vNXSvkd5xeK+he430jsN7Dd1rpHcc3mvoXiO94/BeQ/ca6R2H9xq610jvOLzX0L1GesfhvYbuNdI7Du81dK+R3nF4r6F7jfSOw3sN3Wukdxzea+heI73j8F5D9xrpHYf3GrrXSO84vNfQvUZ6x+G9hu410jsO7zV0r5HecXivoXuN9I7Dew3da6R3HN5r6F4jvePwXkP3Gukdh/cautdI7zi819C9RnrH4b2G7jXSOw7vNXSvkd5xeK+he430jsN7Dd1rpHcc3mvoXiO94/BeQ/ca6R2H9xq61yjvOLzX0L1GecfhvYbuNco7Du81dK9R3nF4r6F7jfKOw3sN3WuUdxzea+heo7zj8F5D9xrlHYf3GrrXKO84vNfQvUZ5x+G9hu41yjsO7zV0r1HecXivoXuN8o7Dew3da5R3HN5r6F6jvOPwXkP3GuUdh/cautco7zi819C9RnnH4b2G7jXKOw7vNXSvUd5xeK+he43yjsN7Dd1rlHcc3mvoXqO84/BeQ/ca5R2H9xq61yjvOLzX0L1GecfhvYbuNco7Du81dK9R3nF4r6F7jfKOw3sN3WuUdxzea+heo7zj8F5D9xrlHYf3GrrXKO84vNfQvUZ7x+G9hu412jsO7zV0r9HecXivoXuN9o7Dew3da7R3HN5r6F6jvePwXkP3Gu0dh/cautdo7zi819C9RnvH4b2G7jXaOw7vNXSv0d5xeK+he432jsN7Dd1rtHcc3mvoXqO94/BeQ/ca7R2H9xq612jvOLzX0L1Ge8fhvYbuNdo7Du81dK/R3nF4r6F7jfaOw3sN3Wu0dxzea+heo73j8F5D9xrtHYf3GrrXaO84vNfQvUZ7x+G9hu412jsO7zV0r9HecXivoXuN9o7Dew3da7R3HN5r6F6jvePwXkP3Gu0dh/cautdo7zi819C9RnvH4b2G7jXaOw7vNXSvMd5xeK+he43xjsN7Dd1rjHcc3mvoXmO84/BeQ/ca4x2H9xq61xjvOLzX0L3GeMfhvYbuNcY7Du81dK8x3nF4r6F7jfGOw3sN3WuMdxzea+heY7zj8F5D9xrjHYf3GrrXGO84vNfQvcZ4x+G9hu41xjsO7zV0rzHecXivoXuN8Y7Dew3da4x3HN5r6F5jvOPwXkP3GuMdh/cautcY7zi819C9xnjH4b2G7jXGOw7vNXSvMd5xeK+he43xjsN7Dd1rjHcc3mvoXmO84/BeQ/ca4x2H9xq61xjvOLzX0L3GeMfhvYbuNcY7Du81dK8x3nF4r6l7zd++4yTvNXWv+dt3nOS9pu41f/uOk7zX1L3mb99xkveautf87TtO8l5T95q/fcdJ3mvqXvO37zjJe03da/72HSd5r6l7zd++4yTvNXWv+dt3nOS9pu41f9c3eZ3t+rTrm7zOdn3a9U1eZ7s+7fkmn7M9n/Z8k8/Znk97vsnnbM+nPd9kOFv4tPBNhrOFTwvfZDhb+LTwTYazpU9L32Q6W/q09E2ms6VPS99kOlv6tPJNlrOVTyvfZDlb+bTyTZazlU8r32Q7W/u09k22s7VPa99kO1v7tPZNtrONTxvf5Djb+LTxTY6zjU8b3+Q4m7vk23ec5L2m7jW/fcdJ3mvqXvPbd5zkvabuNb99x0nea+pe89t3nOS9pu41v33HSd5r6l7z23ec5L2m7jW/fcdJ3mvqXvPbd5zkvabuNb99x0nea+pe87u+yets7pLv+iavs7lLvuubvM7mLvmub/I5m7vke77J52zuku/5Jp+zuUu+55t8zuYu+cI3Gc7mLvnCNxnO5i75wjcZzuYu+dI3mc7mLvnSN5nO5i750jeZzuYu+dI3Wc7mLvnKN1nO5i75yjdZzuYu+co3Wc7mLvnaN9nO5i752jfZzuYu+do32c7mLvnGNznO5i75xjc5zuYu+cY3Oc7mLvn2HSd5r6l7zbPvOMl7Td1rnn3HSd5r6l7z7DtO8l5T95pn33GS95q61zz7jpO819S95tl3nOS9pu41z77jJO81da959h0nea+pe82z7zjJe03da57jm7RLdK95rm/SLtG95rm+SbtE95rn+ibtEt1rnuebtEt0r3meb9Iu0b3meb5Ju0T3mid8k3aJ7jVP+CbtEt1rnvBN2iW61zzhm7RLdK950jdpl+he86Rv0i7RveZJ36RdonvNU75Ju0T3mqd8k3aJ7jVP+SbtEt1rnvZN2iW61zztm7RLdK952jdpl+he87Rv0i7RveYZ36RdonvNM75Ju0T3mmd8k3aJ7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83rH4b2m7jWvdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+pe83nH4b2m7jWfdxzea+peM7zj8F5T95rhHYf3mrrXDO84vNfUvWZ4x+G9pu41wzsO7zV1rxnecXivqXvN8I7De03da4Z3HN5r6l4zvOPwXlP3muEdh/eautcM7zi819S9ZnjH4b2m7jX/dq9x/3v8/0+L9/fxz13yv8fP4/F4PT6P4TE9lsf26NPCp4VP+3OXRPz3eD0+j+ExPZbHP5/23zH/3CUxfx//3CX/Tpw+LZ0tnS2dLZ0tnS2dLZ0tna2crXxa+bTyaeVs5WzlbOVsf+6S/z3OPv65S/6d+M9d8u/Ef+6Sfydun9bO1s7WztbO1s7WzjbONs42zjY+bXza+LRxtnG2cbbZs/3tXv/3+Hk8/zvx3+71vxP/7V7/O/Hf7vW/T/vbvf7vsTy2xz3b3+71f4+fx+Pxenwefdrn0z6f9u3Z/nav/x6Psx1nO8fj9fj2xH/ukn8n/nOX/Dvx8WnH2Y6zXWe7znad7TrbdbbrbNfZrk+7Ps1d8rd7/fenP2d7zvac7T2P4TH3xH/vkv9O/PbmSndJukvSXfK3e/3fo7OFs4WzhbOFs4WzhU9Ln+Yu+du9/vvT09nS2dLZMj2Wx725/nav/05ce3OluyTdJeku+du9/u/R2crZytnK2crZ2tnap7VPc5f87V7//entbO1s7WztP6D9B8zeXH+7138nnr250l2S7pJ0l/ztXv/36GzjbLNn+9u9/u/x83g8Xo/PY3jcs/3tXv/32B73bH+71/89fh735vrbvf534r/d638nLndJuUvKXfK3e/3fo7MdZzvOdpztONtxtuPTjk9zl/ztXv/96cfZrrNdZ7vH4/W4N9ff7vXfie/eXOUuKXdJuUvKLim7pOySskvKLim7pOySskvKLil3yd/u9d+fHs5ml5RdUnZJ2SV/u9d/J469uf52r/9O7C4pd0m5S8ouKbuk7JKyS8ouKbuk7JKyS8ouKXfJ3+71359ezmaXlF1SdknZJX+7138nrr25/nav/07sLil3SblLyi4pu6TskrJLyi4pu6TskrJLyi4pd8nf7vXfnz7OZpeUXVJ2Sdklf7vX/078t3v978R/u9f/TtzuknaXtLuk7ZK2S9ouabuk7ZK2S9ouabuk7ZJ2l/ztXv/96V95bI/OZpe0XfK3e/134rM319/u9d+J3SXtLml3SdslbZe0XdJ2SdslbZe0XdJ2Sdsl7S75273++9Ovs9klbZe0XdJ2yd/u9d+J395cf7vXfyd2l7S7pN0lbZe0XdJ2SdslbZe0XdJ2SdslbZe0u+Rv9/rvT09ns0vaLmm7pO2Sv93rvxPn3lx/u9d/J3aXtLuk3SVtl7Rd0nZJ2yVtl7Rd0nZJ2yVtl7S75G/3+u9Pb2ezS9ouabuk7ZK/3eu/E/feXH+7138ndpe0u6TdJW2XtF3SdknbJW2XtF0ydsnYJWOXjLvkb/f635/+t3v932N6LI/tcf8D/nav/534b/f634n/dq//nXjcJeMuGXfJ2CVjl4xdMnbJ2CVjl4xdMnbJ2CXjLvnbvf7704+z2SVjl4xdMnbJ3+7134nv3lx/u9d/J3aXjLtk3CVjl4xdMnbJ2CVjl4xdMnbJ2CVjl4y75G/3+u9Pf85ml4xdMnbJ2CV/u9d/J469uf52r/9O7C4Zd8m4S8YuGbtk7JKxS8YuGbtk7JKxS8YuGXfJ3+71359ezmaXjF0ydsnYJX+7138nrr25/nav/07sLhl3ybhLxi4Zu2TskrFLxi4Zu2TskrFLxi4Zd8nf7vXfnz7OZpeMXTJ2ydglf7vXfyee/91c9bd7/Xvi+u1dUr+9S+q3d0n9dpfUb3dJ/XaX1G93Sf12l9Rvd0n9dpfU7/Npn0/7fNr3v7PV3+71f4/psTy2x9nH87+bq/52r/9OfM6e+Pi042zH2Y6zHWc7znac7TrbdbbrbNenXZ92fdp1tuts19mus+0uqd/ukvrbvf478bt74vf2xM+nPWd7zvac7TlbOFs4WzhbOFs4W/i08Gnh08LZwtnS2dLZdpfUb3dJ/e1e/504Y0+cuSdOn5bOls5WzlbOVs5WzlbOVs5WzlY+rXxa+bR2tna2drZ2tvYf0P4DOvfEXXvi7j1x+7RxtnG2cbZxtnG2cbZxtnG2cbbdJfXtLqnPXfK3e/3vT//bvf7v8XkMj+mxPP7v5qq/3et/J/7bvf534s9d8rlLPnfJt7ukvt0l9e0uqW93SX27S+r7nO042/Fpx6e5S/52r//+9ONsx9mOs+0uqW93Sf3tXv+d+O7N9bd7/Xdid8nnLvncJd91tuts19musz1ne872nO35tOfT3CV/u9d/f/pztudsz9l2l9S3u6T+dq//Thx7c/3tXv+d2F3yuUs+d8kXzhbOls6WzpbOls6WzpY+LX2au+Rv9/rvT09nK2crZyv/AeU/oPbm+tu9/jtx7c31uUs+d8nnLvna2drZ2tna2drZ2tna2dqntU9zl/ztXv/96eNs42zjbOM/YPwHzN5cf7vXfyeevbk+d8lxlxx3ybFLjl1y7JJjlxy75Nglxy45dsmxS4675G/3+t+f/rd7/d/j8xge02N53Jvrb/f634n/dq//nfi4S4675LhLjl1y7JJjlxy75Nglxy45dsmxS45dctwlf7vXf3/6dTa75Nglxy45dsnf7vXfid/eXH+7138ndpccd8lxlxy75Nglxy45dsmxS45dcuySY5ccu+S4S044WzibXXLskmOXHLvkb/f678S5N9ff7vXfid0lx11y3CXHLjl2ybFLjl1y7JJjlxy75Nglxy457pJTzlbOZpccu+TYJccu+du9/jtx7831t3v9d2J3yXGXHHfJsUuOXXLskmOXHLvk2CXHLjl2ybFLjrvk7m/Cdfc34bp2ybVLrl1y7ZK/3et/J/7bvf534r/d638nvu6S6y657pJrl1y75Nol1y65dsm1S65dcu2Sa5dcd8k9znaczS65dsm1S65d8rd7/XfiszfX3+7134ndJdddct0l1y65dsm1S65dcu2Sa5dcu+TaJdcuue6S+5ztOZtdcu2Sa5dcu+Rv9/rvxLE319/u9d+J3SXXXXLdJdcuuXbJtUuuXXLtkmuXXLvk2iXXLrnukpvOls5ml1y75Nol1y75273+O3HtzfW3e/13YnfJdZdcd8m1S65dcu2Sa5dcu+TaJdcuuXbJtUuuu+S2s7Wz2SXXLrl2ybVL/nav/048e3P97V7/ndhdct0l113y7JJnlzy75Nklzy55dsmzS55d8uyS5y55+5twvf1NuJ5d8uySZ5c8u+Rv9/rfif92r/+d+G/3+t+Jn7vkuUueu+TZJc8ueXbJs0ueXfLskmeXPLvk2SXPXfKus11ns0ueXfLskmeX/O1e/5347s31t3v9d2J3yXOXPHfJs0ueXfLskmeXPLvk2SXPLnl2ybNLnrvkhbOFs9klzy55dsmzS/52r/9OnHtz/e1e/53YXfLcJc9d8uySZ5c8u+TZJc8ueXbJs0ueXfLskucueeVs5Wx2ybNLnl3y7JK/3eu/E/feXH+7138ndpc8d8lzlzy75Nklzy55dsmzS55d8uySZ5c8u+S5S9442/4mXGGXhF0SdknYJX+71/9O/Ld7/e/Ef7vX/04c7pJwl4S7JOySsEvCLgm7JOySsEvCLgm7JOyScJfEcbbjbHZJ2CVhl4Rd8rd7/XfiszfX3+7134ndJeEuCXdJ2CVhl4RdEnZJ2CVhl4Rdonst3WvpXiuesz1ns0vCLgm7JOyS/7rX/0789ub6r3v978TuknCXhLsk7JKwS8IuCbsk7JKwS8Iu0b2W7rV0rxXpbOlsdknYJWGXhF3yX/f634lrb67/utf/TuwuCXdJuEvCLgm7JOySsEvCLgm7JOwS3WvpXkv3WtHO1s5ml4RdEnZJ2CX/da//nXj25vqve/3vxO6ScJeEuyTskrBL0i5JuyTtkrRL0i7RvZbutXSvlfubcOX+Jlxpl6RdknZJ2iX/da/93+PeXP91r/e/R5/mLkl3SdolaZekXZJ2SdolaZekXaJ7Ld1r6V4rr7NdZ7NL0i5JuyTtkv+61/9OfPfmym3oS/da6S5Jd0naJWmXpF2SdknaJWmXpF2iey3da+leK8PZwtnskrRL0i5JuyS3oa/chr5yG/rSvVa6S9JdknZJ2iVpl6RdknZJ2iVpl+heS/dautfKcrZyNrsk7ZK0S9IuyW3oK7ehr9yGvnSvle6SdJekXZJ2SdolaZekXZJ2SdolutfSvZbutXKcbZzNLkm7pOySsktqG/qqbeirtqEv3WuVu6TcJWWXlF1SdknZJWWXlF1SdonutXSvpXut8ptw+U247JKyS8ouKbuktqGv2oa+ahv60r1WuUvKXVJ2SdklZZeUXVJ2SdklZZfoXkv3WrrXKr8Jl9+Eyy4pu6TskrJLahv6qm3oq7ahL91rlbuk3CVll5RdUnZJ2SVll5RdUnaJ7rV0r6V7rfKbcPlNuOySskvKLim7pLahr9qGvmob+tK9VrlLyl1SdknZJWWXlF1SdknZJWWX6F5L91q61yq/CZffhMsuKbuk7JKyS2ob+qpt6Ku2oS/da5W7pNwlZZeUXVJ2SdklbZe0XdJ2ie61dK+le632m3D7TbjtkrZL2i5pu6S3oa/ehr56G/rSvVa7S9pd0nZJ2yVtl7Rd0nZJ2yVtl+heS/dautdqvwm334TbLmm7pO2Stkt6G/rqbeirt6Ev3Wu1u6TdJW2XtF3SdknbJW2XtF3SdonutXSvpXut9ptw+0247ZK2S9ouabukt6Gv3oa+ehv60r1Wu0vaXdJ2SdslbZe0XdJ2SdslbZfoXkv3WrrXar8Jt9+E2y5pu6TtkrZLehv66m3oq7ehL91rtbuk3SVtl7Rd0nZJ2yVtl7Rd0naJ7rV0r6V7rfabcPtNuO2StkvaLmm7ZLahr9mGvmYb+tK91rhLxl0ydsnYJWOXjF0ydsnYJWOX6F5L91q61xq/CY/fhMcuGbtk7JKxS2Yb+ppt6Gu2oS/da427ZNwlY5eMXTJ2ydglY5eMXTJ2ie61dK+le63xm/D4TXjskrFLxi4Zu2S2oa/Zhr5mG/rSvda4S8ZdMnbJ2CVjl4xdMnbJ2CVjl+heS/dautcavwmP34THLhm7ZOySsUtmG/qabehrtqEv3WuNu2TcJWOXjF0ydsnYJWOXjF0ydonutXSvpXut8Zvw+E147JKxS8YuGbtktqGv2Ya+Zhv60r3WuEvGXTJ2ydglY5eMXTJ2yewu6d/ukta9tu61da/929+E+7e/Cfdvd0n/dpf0b3dJ/3aX9G8b+v5tQ9+/behb99q/vUv6t3dJ/3aX9G93Sf92l/Tvc7bjbMfZjrMdn3Z82vFpx9mOsx1nO862u6R/u0v6tw19/7ah79829K177d91tuts19musz1ne872nO0523O259OeT3s+7Tnbc7ZwtnC23SX9213Sv23o+7cNff+2oW/da//C2cLZ0tnS2dLZ0tnS2dLZ0tnSp6VPS59WzlbOVs5Wzlb+A8p/wDb0/duGvn/b0LfutX/tbO1s7WztbO1s7WztbO1s7Wzt08anjU8bZxtnG2cbZxv/AeM/YBv6/m1D39829K177c9d8rlLvt0l/e0u6W93SX+7S/rbXdLf7pL+dpe07rV1r6177W9/E+5vfxPub3dJf7tL+ttd0t/ukv62oe9vG/r+tqFv3Wt/7pLPXfIdZzvOdpztONt1tuts19muT7s+zV3yXWe7znad7Trb7pL+dpf0tw19f9vQ97cNfete+3OXfO6S7znbc7ZwtnC2cLZwtnC28Gnh09wlXzhbOFs6Wzrb7pL+dpf0tw19f9vQ97cNfete+3OXfO6Sr5ytnK2crZytnK2crZytfFr5NHfJ187WztbO1s7W/gPaf8A29P1tQ9/fNvSte+3PXfK5S75xtnG2cbZxtnG2cbZxNrtE99q61z77m3Cf/U24j11y7JJjlxy75GxD32cb+j7b0LfutY+75LhLjl1y7JJjlxy75Nglxy45donutXWvrXvtc5ztOJtdcuySY5ccu+RsQ99nG/o+29C37rWPu+S4S45dcuySY5ccu+TYJccuOXaJ7rV1r6177fOc7TmbXXLskmOXHLvkbEPfZxv6PtvQt+61j7vkuEuOXXLskmOXHLvk2CXHLjl2ie61da+te+2TzpbOZpccu+TYJccuOdvQ99mGvs829K177eMuOe6SY5ccu+TYJccuOXbJsUuOXaJ7bd1r6177jLONs9klxy45dsmxS8429H22oe+zDX3rXvu6S6675Nol1y65dsm1S65dcu2Sa5foXlv32rrXvvubcN/9TbivXXLtkmuXXLvkbkPfdxv6vtvQt+61r7vkukuuXXLtkmuXXLvk2iXXLrl2ie61da+te+17ne06m11y7ZJrl1y75G5D33cb+r7b0Lfuta+75LpLrl1y7ZJrl1y75Nol1y65donutXWvrXvtG84WzmaXXLvk2iXXLrnb0Pfdhr7vNvSte+3rLrnukmuXXLvk2iXXLrl2ybVLrl2ie23da+te+5azlbPZJdcuuXbJtUvuNvR9t6Hvuw196177ukuuu+TaJdcuuXbJtUuuXXLtkmuX6F5b99q61377m3C//U24n13y7JJnlzy75G1D328b+n7b0LfutZ+75LlLnl3y7JJnlzy75Nklzy55donutXWvrXvtd5ztOJtd8uySZ5c8u+RtQ99vG/p+29C37rWfu+S5S55d8uySZ5c8u+TZJc8ueXaJ7rV1r6177fec7TmbXfLskmeXPLvkbUPfbxv6ftvQt+61n7vkuUueXfLskmeXPLvk2SXPLnl2ie61da+te+2XzpbOZpc8u+TZJc8uedvQ99uGvt829K177ecuee6SZ5c8u+TZJc8ueXbJs0ueXaJ7bd1r6177tbO1s9klzy55dsmzS9429P22oe+3DX3rXvu5S567JOySsEvCLgm7JOySsEvCLtG9tu61da8d+5twx/4m3GGXhF0SdknYJbENfcc29B3b0LfutcNdEu6SsEvCLgm7JOySsEvCLgm7RPfautfWvXZcZ7vOZpeEXRJ2SdglsQ19xzb0HdvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277XDLgm7JLah79iGvmMb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122CVhl8Q29B3b0HdsQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXTrsk7ZLchr5zG/rObehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32mmXpF2S29B3bkPfuQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXjvtkrRLchv6zm3oO7ehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3munXZJ2SW5D37kNfec29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvttEvSLslt6Du3oe/chr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvXXZJ2SW1DX3XNvRd29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtcsuKbuktqHv2oa+axv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvXbZJWWX1Db0XdvQd21D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNcuu6TsktqGvmsb+q5t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fabZe0XdLb0HdvQ9+9DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Neu+2Stkt6G/rubei7t6Fv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea7dd0nZJb0PfvQ199zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+22S9ou6W3ou7eh796GvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/ddknbJb0Nffc29N3b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1xy4Zu2S2oe/Zhr5nG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99tglY5fMNvQ929D3bEPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81x67ZOyS2Ya+Zxv6nm3oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99pjl4xdMtvQ92xD37MNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81577JLZXTK/bejntw39/LahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uv8dpfMb3fJ/Lahn9829PPbhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv89tdMr/dJfPbhn5+29DPbxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc5vd8n8dpfMbxv6+W1DP79t6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6v/Yf0P4DtqGf3zb089uGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK/z7S6Zb3fJfNvQz7cN/Xzb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91vt0l8+0umW8b+vm2oZ9vG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9zre7ZL7dJfNtQz/fNvTzbUM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81/nKf0D5D9iGfr5t6Ofbhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv843/gPEfsA39fNvQz9mGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK9z7JJjl5xt6OdsQz9nG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9zrFLjl1ytqGfsw39nG3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zrHLjl2ydmGfs429HO2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rHLvk2CVnG/o529DP2YZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r3PtkmuX3G3o525DP3cb+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3OtUuuXXK3oZ+7Df3cbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OtcuuXbJ3YZ+7jb0c7ehH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3utcu+TaJXcb+rnb0M/dhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXivc+2Sa5fcbejnbkM/dxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc6zS55d8rahn7cN/bxt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6zy55dsnbhn7eNvTztqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e6zy75Nklbxv6edvQz9uGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK/z7JJnl7xt6OdtQz9vG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtglYZfENvQT29BPbEM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81wm7JOyS2IZ+Yhv6iW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zphl4RdEtvQT2xDP7EN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F4n7JKwS2Ib+olt6Ce2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rhF0SdklsQz+xDf3ENvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbRL0i7Jbegnt6Gf3IZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r5N2SdoluQ395Db0k9vQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XSLkm7JLehn9yGfnIb+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b1O2iVpl+Q29JPb0E9uQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXKbuk7JLahn5qG/qpbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OmWXlF1S29BPbUM/tQ396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXqfskrJLahv6qW3op7ahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uuUXVJ2SW1DP7UN/dQ29KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udskvKLqlt6Ke2oZ/ahn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv03ZJ2yW9Df30NvTT29CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vddouabukt6Gf3oZ+ehv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvU7bJW2X9Db009vQT29DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNdpu6Ttkt6Gfnob+ult6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6Y5eMXTLb0M9sQz+zDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/BeZ+ySsUtmG/qZbehntqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e64xdMnbJbEM/sw39zDb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De52xS8YumW3oZ7ahn9mGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK8zdsnYJbMN/cw29DPb0I/udXivw3sd3uvwXof3Ouu9nt96r38eP4/H4/X4PIbHf2f781ge2+Ps4/92yZ/Hz+O/m+vP47+b68/jv5vrz6NP+99d8uexPLZHZzvOdpztONtxtuNsx6cdn3Z82nG242zX2a6z/W+X/Hm8Ht+e+H8N/Z/H3BNfn3ad7Trbc7bnbM/ZnrM9Z3vO9pzt+bTn055PC2cLZwtnC2f73y758xgec0/8v4b+z2PvicOnpbOls6WzpbOls6WzpbOls6WzpU8rn1Y+rZytnK2crZyt/AeU/4D/NfR/HmdP/L+G/s+jT2tna2drZ2tna2drZ2tna2cbZxufNj5tfNo42zjbONs42/gPmP0P+P7X0P95/P534u9/Df2fx/20z13yuUvWe/3zWB7b455tvdc/j5/H49GnfT7NXbLe65/H8tgene38PH4e9+b6zt5c39mb63OXfO6Sz12y3uufR2e7znad7TrbdbbrbNenXZ/mLlnv9c+jsz1ne872jsfrcW+u7+3N9b29uT53yecu+dwl673+eXS2cLZwtnC2cLZwtvBp4dPcJeu9/nl0tnS2dLZ8HsPj3lxf7s315d5cn7vkc5d87pL1Xv88Ols5WzlbOVs5Wzlb+bT2ae6S9V7/PDpbO1s7W/sPaP8BvTfX13tzfbM31+cu+dwln7tkvdc/j842zjbONs5mlxy75Nglxy457pL1Xv88hsf0WB7b4/4HnG9vrvPtzXW+vbmOu+S4S4675Nglxy45dsmxS45dcuySY5ccu+TYJcddst7rn0dns0uOXXLskmOXnLs317l7c527N9dxlxx3yXGXHLvk2CXHLjl2ybFLjl1y7JJjlxy75LhL1nv98+hsdsmxS45dcuySE3tzndib68TeXMddctwlx11y7JJjlxy75Nglxy45dsmxS45dcuyS4y5Z7/XPo7PZJccuOXbJsUtO7c11am+uU3tzHXfJcZccd8mxS45dcuySY5ccu+TYJccuOXbJsUuOu2S91z+PzmaXHLvk2CXHLjmzN9eZvbnub2+u6y657pLrLrl2ybVLrl1y7ZJrl1y75Nol1y65dsl1l6z3+ucxPKbH8tge9z/gnr257tmb6569ua675LpLrrvk2iXXLrl2ybVLrl1y7ZJrl1y75Nol112y3uufR2ezS65dcu2Sa5fctzfXfXtz3bc313WXXHfJdZdcu+TaJdcuuXbJtUuuXXLtkmuXXLvkukvWe/3z6Gx2ybVLrl1y7ZKbe3Pd3Jvr5t5c111y3SXXXXLtkmuXXLvk2iXXLrl2ybVLrl1y7ZLrLlnv9c+js9kl1y65dsm1S27vzXV7b67be3Ndd8l1l1x3ybVLrl1y7ZJrl1y75Nol1y65dsmzS567ZL3XP4/X4/MYHtNjedyb6/325nrf3lzPXfLcJc9d8uySZ5c8u+TZJc8ueXbJs0ueXfLskucuWe/1z6Oz2SXPLnl2ybNL3t2b6929ud7dm+u5S5675LlLnl3y7JJnlzy75Nklzy55dsmzS55d8twl673+eXQ2u+TZJc8ueXbJi725XuzN9WJvrucuee6S5y55dsmzS55d8uySZ5c8u+TZJc8ueXbJc5es9/rn0dnskmeXPLvk2SWv9uZ6tTfXq725nrvkuUueu+TZJc8ueXbJs0ueXfLskmeXPLvk2SXPXbLe659HZ7NLnl3y7JJnl7zZm+vN3lxv9uZ67pJwl4S7JOySsEvCLgm7JOySsEvCLgm7JOyScJes9/rn8Xp8HsNjeiyPe3PFtzdXnL25wl0S7pJwl4RdEnZJ2CVhl4RdEnZJ2CVhl4RdEu6S9V7/PDqbXRJ2SdglYZfE25sr3t5c8fbmCndJuEvCXRJ2SdglYZeEXRJ2SdglYZeEXRJ2SbhL1nv98+hsdknYJWGXhF0SuTdX5N5ckXtzhbsk3CXhLgm7JOySsEvCLgm7JOySsEvCLgm7JNwl673+eXQ2uyTskrBLwi6J3psrem+u6L25wl0S7pJwl4RdEnZJ2CVhl4RdEnZJ2CVhl4RdEu6S9V7/PH4ej8fr8XkMj3tz5W9vrvztzZXuknSXpLsk7ZK0S9IuSbsk7ZK0S9IuSbsk7ZJ0l6z3+ufR2eyStEvSLkm7JM/eXHn25sq7N1e6S9Jdku6StEvSLkm7JO2StEvSLkm7JO2StEvSXbLe659HZ7NL0i5JuyTtkoy9uTL25srYmyvdJekuSXdJ2iVpl6RdknZJ2iVpl6RdknZJ2iXpLlnv9c+js9klaZekXZJ2SdbeXFl7c2XtzZXuknSXpLsk7ZK0S9IuSbsk7ZK0S9IuSbsk7ZJ0l6z3+ufR2eyStEvSLkm7JGdvrpy9uXL25kp3SbpL0l1SdknZJWWXlF1SdknZJWWXlF1Sdkm5S8pvwuU34bJLyi4pu6Tskvr25qpvb6769uYqd0m5S8pdUnZJ2SVll5RdUnZJ2SVll5RdUnZJuUvKb8LlN+GyS8ouKbuk7JK6e3PV3Zur3t5c5S4pd0m5S8ouKbuk7JKyS8ouKbuk7JKyS8ouKXdJ+U24/CZcdknZJWWXlF1SuTdX5d5clXtzlbuk3CXlLim7pOySskvKLim7pOySskvKLim7pNwl5Tfh8ptw2SVll5RdUnZJ9d5c1XtzVe/NVe6ScpeUu6TskrJLyi4pu6TskrJLyi4pu6TsknKXlN+Ey2/CbZe0XdJ2Sdsl/dubq397c/Vvb652l7S7pN0lbZe0XdJ2SdslbZe0XdJ2SdslbZe0u6T9Jtx+E267pO2StkvaLumzN1efvbn67M3V7pJ2l7S7pO2StkvaLmm7pO2StkvaLmm7pO2Sdpe034Tbb8Jtl7Rd0nZJ2yX99ubqtzdXx95c7S5pd0m7S9ouabuk7ZK2S9ouabuk7ZK2S9ouaXdJ+024/SbcdknbJW2XtF3StTdX195cXXtztbuk3SXtLmm7pO2StkvaLmm7pO2StkvaLmm7pN0l7Tfh9ptw2yVtl7Rd0nZJz95cPXtz9ezN1e6Sdpe0u6TtkrZLxi4Zu2TskrFLxi4Zu2TsknGXjN+Ex2/CY5eMXTJ2ydgl8+3NNd/eXPPtzTXuknGXjLtk7JKxS8YuGbtk7JKxS8YuGbtk7JJxl4zfhMdvwmOXjF0ydsnYJXP35pq7N9fcvbnGXTLuknGXjF0ydsnYJWOXjF0ydsnYJWOXjF0y7pLxm/D4TXjskrFLxi4Zu2Rib66Jvbkm9+Yad8m4S8ZdMnbJ2CVjl4xdMnbJ2CVjl4xdMnbJuEvGb8LjN+GxS8YuGbtk7JLpvbmm9+aa3ptr3CXjLhl3ydglY5eMXTJ2ydglY5eMXTJ2ydgl4y4ZvwmP34THLlnv9Xy/3SXfb3fJ9/tfQ//n8X831/f7X0P/5/F/n/at9/rnsTy2x9nH3SXfeq9/Ho/H6/F59GmfT/t82v4m/K33+v+Px9mOs+0u+X67S77f/xr6P4+xJ/5fQ//n0acdZzvOdp3tOtt1tuts19mus11nuz7t+rTr056zPWd7zvacbXfJ99td8v3+19D/eaw98f8a+j+PPi2cLZwtnC2cLZwtnC2cLZwtnC18Wvq09GnpbOls6WzpbLtLvt/uku/3v4b+z+Psif/X0P959GnlbOVs5WzlbOVs5WzlbOVs7Wzt09qntU9rZ2tna2drZ2v/Ae0/4H8N/Z/Hb0/8v4b+z6NPG2cbZxtnG2cbZ9td8q33+ufx83g8Xo/PY3jcs633+uexPe7Zvt0l37e75Pu2of++bei/bxv6T/f6fe6Sz12y3uufR2c7znac7TjbcbbjbMenHZ/mLlnv9c+js11nu862u+T7dpd83zb037cN/fdtQ//pXr/PXfK5S9Z7/fPobM/ZnrM9Z3vO9pzt+bTn09wl673+eXS2cLZwtt0l37e75Pu2of++bei/bxv6T/f6fe6Sz12y3uufR2dLZ0tnS2dLZ0tnS59WPs1dst7rn0dnK2crZyv/AeU/YBv679uG/vu2of90r9/nLvncJeu9/nl0tna2drZ2tna2cbbxaePT3CXrvf55dLZxtnG28R9gl5xt6L+zDf13tqH/dK/fcZccd8mxS45dcuySY5ccu+TYJccu0b1+utdP9/qt9/rnsTy2R2ezS45dcrah/8429N/Zhv7TvX7HXXLcJccuOXbJsUuOXXLskmOXHLtE9/rpXj/d67fe659HZ7NLjl1y7JJjl5xt6L+zDf13tqH/dK/fcZccd8mxS45dcuySY5ccu+TYJccu0b1+utdP9/qt9/rn0dnskmOXHLvk2CVnG/rvbEP/nW3oP93rd9wlx11y7JJjlxy75Nglxy45dsmxS3Svn+71071+673+eXQ2u+TYJccuOXbJ2Yb+O9vQf2cb+k/3+h13yXGXHLvk2CXHLjl2ybFLjl1y7RLd66d7/XSv33qvfx7DY3osj+1x/wPuNvTf3Yb+u9vQf7rX77pLrrvk2iXXLrl2ybVLrl1y7ZJrl+heP93rp3v91nv98+hsdsm1S65dcu2Suw39d7eh/+429J/u9bvukusuuXbJtUuuXXLtkmuXXLvk2iW610/3+ulev/Ve/zw6m11y7ZJrl1y75G5D/91t6L+7Df2ne/2uu+S6S65dcu2Sa5dcu+TaJdcuuXaJ7vXTvX6612+91z+PzmaXXLvk2iXXLrnb0H93G/rvbkP/6V6/6y657pJrl1y75Nol1y65dsm1S65donv9dK+f7vVb7/XPo7PZJdcuuXbJtUvuNvTf3Yb+e9vQf7rX77lLnrvk2SXPLnl2ybNLnl3y7JJnl+heP93rp3v91nv98xge02N5bI/7H/C2of/eNvTf24b+071+z13y3CXPLnl2ybNLnl3y7JJnlzy7RPf66V4/3eu33uufR2ezS55d8uySZ5e8bei/tw3997ah/3Sv33OXPHfJs0ueXfLskmeXPLvk2SXPLtG9frrXT/f6rff659HZ7JJnlzy75Nklbxv6721D/71t6D/d6/fcJc9d8uySZ5c8u+TZJc8ueXbJs0t0r5/u9dO9fuu9/nl0Nrvk2SXPLnl2yduG/nvb0H9vG/pP9/o9d8lzlzy75Nklzy55dsmzS55d8uwS3eune/10r996r38er8fnMTymx/K4N1dsQ//FNvSf7vULd0m4S8IuCbsk7JKwS8IuCbsk7BLd66d7/XSv33qvfx6dzS4JuyTskrBLYhv6L7ah/2Ib+k/3+oW7JNwlYZeEXRJ2SdglYZeEXRJ2ie71071+utdvvdc/j85ml4RdEnZJ2CWxDf0X29B/sQ39p3v9wl0S7pKwS8IuCbsk7JKwS8IuCbtE9/rpXj/d67fe659HZ7NLwi4JuyTsktiG/ott6L/Yhv7TvX7hLgl3SdglYZeEXRJ2SdglYZeEXaJ7/XSvn+71W+/1z6Oz2SVhl4RdEnZJbEP/xTb0X2xD/+lev3SXpLsk7ZK0S9IuSbsk7ZK0S9Iu0b1+utdP9/qt9/rn8Xp8HsNjeiyPe3PlNvRfbkP/6V6/dJekuyTtkrRL0i5JuyTtkrRL0i7RvX6610/3+q33+ufR2eyStEvSLkm7JLeh/3Ib+i+3of90r1+6S9JdknZJ2iVpl6RdknZJ2iVpl+heP93rp3v91nv98+hsdknaJWmXpF2S29B/uQ39l9vQf7rXL90l6S5JuyTtkrRL0i5JuyTtkrRLdK+f7vXTvX7rvf55dDa7JO2StEvSLslt6L/chv7Lbeg/3euX7pJ0l6RdknZJ2iVpl6RdknZJ2iW610/3+ulev/KbcPlNuOySskvKLim7pLah/2ob+q+2of90r1+5S8pdUnZJ2SVll5RdUnZJ2SVll+heP93rp3v9ym/C5TfhskvKLim7pOyS2ob+q23ov9qG/tO9fuUuKXdJ2SVll5RdUnZJ2SVll5Rdonv9dK+f7vUrvwmX34TLLim7pOySsktqG/qvtqH/ahv6T/f6lbuk3CVll5RdUnZJ2SVll5RdUnaJ7vXTvX6616/8Jlx+Ey67pOySskvKLqlt6L/ahv6rbeg/3etX7pJyl5RdUnZJ2SVll5RdUnZJ2SW610/3+ulev/KbcPlNuOySskvKLim7pLah/2ob+q+2of90r1+5S8pd0nZJ2yVtl7Rd0nZJ2yVtl+heP93rp3v92m/C7TfhtkvaLmm7pO2S3ob+623ov96G/tO9fu0uaXdJ2yVtl7Rd0nZJ2yVtl7Rdonv9dK+f7vVrvwm334TbLmm7pO2Stkt6G/qvt6H/ehv6T/f6tbuk3SVtl7Rd0nZJ2yVtl7Rd0naJ7vXTvX6616/9Jtx+E267pO2StkvaLult6L/ehv7rbeg/3evX7pJ2l7Rd0nZJ2yVtl7Rd0nZJ2yW610/3+ulev/abcPtNuO2StkvaLmm7pLeh/3ob+q+3of90r1+7S9pd0nZJ2yVtl7Rd0nZJ2yVtl+heP93rp3v92m/C7TfhsUvGLhm7ZOyS2Yb+m23ov9mG/tO9fuMuGXfJ2CVjl4xdMnbJ2CVjl4xdonv9dK+f7vUbvwmP34THLhm7ZOySsUtmG/pvtqH/Zhv6T/f6jbtk3CVjl4xdMnbJ2CVjl4xdMnaJ7vXTvX6612/8Jjx+Ex67ZOySsUvGLplt6L/Zhv6bbeg/3es37pJxl4xdMnbJ2CVjl4xdMnbJ2CW610/3+ulev/Gb8PhNeOySsUvGLhm7ZLah/2Yb+m+2of90r9+4S8ZdMnbJ2CVjl4xdMnbJ2CVjl+heP93rp3v9xm/C4zfhsUvGLhm7ZOyS2Yb+m23ov9mG/tO9fuMuGXfJ2CW818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281/PbXXJ+u0vObxv689uG/vy2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNfz211yfrtLzm8b+vPbhv78tqE/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzX89tdcn67S85vG/rz24b+/LahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281/Mr/wHlP2Ab+vPbhv78tqE/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzX8+0uOd/ukvNtQ3++bejPtw390b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7e69G9Ht3r0b0e3uvhvR7e6+G9nm93yfl2l5xvG/rzbUN/vm3oj+718F4P7/XwXg/v9fBeD+/18F4P7/XwXo/u9ehej+718F4P7/XwXg/v9Xy7S863u+R829Cfbxv6821Df3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4r+fbXXK+3SXn24b+fNvQn28b+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez1f+w9o/wHb0J9vG/rzbUN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3eniv59glxy4529Cfsw39OdvQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e6zl2ybFLzjb052xDf8429Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93qOXXLskrMN/Tnb0J+zDf3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2eY5ccu+RsQ3/ONvTnbEN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3eniv59glxy6529Cfuw39udvQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e67l2ybVL7jb0525Df+429Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93quXXLtkrsN/bnb0J+7Df3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2ea5dcu+RuQ3/uNvTnbkN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3eniv59ol1y6529Cfuw39udvQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e63l2ybNL3jb0521Df9429Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93qeXfLskrcN/Xnb0J+3Df3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2eZ5c8u+RtQ3/eNvTnbUN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3eniv59klzy5529Cftw39edvQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e63l2ybNL3jb0521Df2Ib+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez1hl4RdEtvQn9iG/sQ29Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93rCLgm7JLahP7EN/Ylt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/WEXRJ2SWxDf2Ib+hPb0B/d6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3evRvR7d6+G9Ht7r4b0e3usJuyTsktiG/sQ29Ce2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNeTdknaJbkN/clt6E9uQ390r4f3enivh/d6eK+H93p4r4f3enivh/d6dK9H93p0r4f3enivh/d6eK8n7ZK0S3Ib+pPb0J/chv7oXg/v9fBeD+/18F4P7/XwXg/v9fBeD+/16F6P7vXoXg/v9fBeD+/18F5P2iVpl+Q29Ce3oT+5Df3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2etEvSLslt6E9uQ39yG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9aZekXZLb0J/chv7kNvRH93p4r4f3enivh/d6eK+H93p4r4f3enivR/d6dK9H93p4r4f3enivh/d6yi4pu6S2oT+1Df2pbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1lF1SdkltQ39qG/pT29Af3evhvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht3r0b0e3evhvR7e6+G9Ht7rKbuk7JLahv7UNvSntqE/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzXU3ZJ2SW1Df2pbehPbUN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3enivp+2Stkt6G/rT29Cf3ob+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBeT9slbZf0NvSnt6E/vQ390b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7e69G9Ht3r0b0e3uvhvR7e6+G9nrZL2i7pbehPb0N/ehv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PW2XtF3S29Cf3ob+9Db0R/d6eK+H93p4r4f3enivh/d6eK+H93p4r0f3enSvR/d6eK+H93p4r4f3etouabukt6E/vQ396W3oj+718F4P7/XwXg/v9fBeD+/18F4P7/XwXo/u9ehej+718F4P7/XwXg/v9YxdMnbJbEN/Zhv6M9vQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e6xm7ZOyS2Yb+zDb0Z7ahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281zN2ydglsw39mW3oz2xDf3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4r2fskrFLZhv6M9vQn9mG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4v7/XyXu9vd8n97S65v23o728b+vvbhv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l7vb3fJ/e0uub9t6O9vG/r724b+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJe7293yf3tLrm/bejvbxv6+9uG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu9vd8n9pf+Abejvbxv6+9uG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu9v/AeM/4Bt6O9vG/r724b+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJe77e75H67S+63Df39tqG/3zb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3er/dJffbXXK/bejvtw39/bahv7rXy3u9vNfLe72818t7vbzXy3u9vNfLe72616t7vbrXy3u9vNfLe7281/vtLrnf7pL7bUN/v23o77cN/dW9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3uvVvV7d69W9Xt7r5b1e3uvlvd6v/AeU/4Bt6O+3Df39tqG/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXe+ySY5ecbejv2Yb+nm3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9R675NglZxv6e7ahv2cb+qt7vbzXy3u9vNfLe72818t7vbzXy3u9vNere72616t7vbzXy3u9vNfLe73HLjl2ydmG/p5t6O/Zhv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l7vsUuOXXK2ob9nG/p7tqG/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXe+ySY5ecbejv2Yb+nm3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9V675Noldxv6e7ehv3cb+qt7vbzXy3u9vNfLe72818t7vbzXy3u9vNere72616t7vbzXy3u9vNfLe73XLrl2yd2G/t5t6O/dhv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l7vtUuuXXK3ob93G/p7t6G/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXe+2Sa5fcbejv3Yb+3m3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9V675Nolbxv6+7ahv28b+qt7vbzXy3u9vNfLe72818t7vbzXy3u9vNere72616t7vbzXy3u9vNfLe73PLnl2yduG/r5t6O/bhv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l7vs0ueXfK2ob9vG/r7tqG/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzX++ySZ5e8bejv24b+vm3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9T675Nklbxv6+7ahv28b+qt7vbzXy3u9vNfLe72818t7vbzXy3u9vNere72616t7vbzXy3u9vNfLe71hl4RdEtvQ39iG/sY29Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93rDLgm7JLahv7EN/Y1t6K/u9fJeL+/18l4v7/XyXi/v9fJeL+/18l6v7vXqXq/u9fJeL+/18l4v7/WGXRJ2SWxDf2Mb+hvb0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3usNuyTsktiG/sY29De2ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNcbdknYJbEN/Y1t6G9uQ391r5f3enmvl/d6ea+X93p5r5f3enmvl/d6da9X93p1r5f3enmvl/d6ea837ZK0S3Ib+pvb0N/chv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l5v2iVpl+Q29De3ob+5Df3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3etEvSLslt6G9uQ39zG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9aZekXZLb0N/chv7mNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6yy4pu6S2ob+1Df2tbeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1ll1SdkltQ39rG/pb29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7rLbuk7JLahv7WNvS3tqG/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXW3ZJ2SW1Df2tbehvbUN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmvt+ySsktqG/pb29Df2ob+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJeb9slbZf0NvS3t6G/vQ391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93rZL2i7pbehvb0N/exv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vW2XtF3S29Df3ob+9jb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3etsuabukt6G/vQ397W3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9Y5dMnbJbEN/Zxv6O9vQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6x27ZOyS2Yb+zjb0d7ahv7rXy3u9vNfLe72818t7vbzXy3u9vNfLe72616t7vbrXy3u9vNfLe7281zt2ydglsw39nW3o72xDf3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r3fskrFLZhv6O9vQ39mG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu/YJWOXzDb0d7ahv7MN/dW9Xt7r5b0+3uvjvT7e6+O9Pt7r470+3uvTvT7d69O9Pt7r470+3uvjvb7f7pL3213yftvQv9829O+3Df3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+3+6S99td8n7b0L/fNvTvtw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vt/ukvfbXfJ+29C/3zb077cN/dO9Pt7r470+3uvjvT7e6+O9Pt7r470+3uvTvT7d69O9Pt7r470+3uvjvb5f+w9o/wHb0L/fNvTvtw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vm93yft2l7xvG/r3bUP/vm3on+718V4f7/XxXh/v9fFeH+/18V4f7/XxXp/u9elen+718V4f7/XxXh/v9X27S963u+R929C/bxv6921D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/bXfK+3SXv24b+fdvQv28b+qd7fbzXx3t9vNfHe32818d7fbzXx3t9vNene32616d7fbzXx3t9vNfHe33f7pL3pf+Abejftw39+7ahf7rXx3t9vNfHe32818d7fbzXx3t9vNfHe32616d7fbrXx3t9vNfHe3281/eN/4DxH7AN/fu2oX/fNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6jl1y7JKzDf0729C/sw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmOXHLvkbEP/zjb072xD/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/YJccuOdvQv7MN/Tvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3us7dsmxS8429O9sQ//ONvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6rl1y7ZK7Df2729C/uw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmuXXLvkbkP/7jb0725D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/aJdcuudvQv7sN/bvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3uu7dsm1S+429O9uQ//uNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6rl1y7ZK7Df2729C/uw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmeXPLvkbUP/3jb0721D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/ZJc8uedvQv7cN/Xvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3ut7dsmzS9429O9tQ//eNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6nl3y7JK3Df1729C/tw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmeXPLsktqF/sQ39i23on+718V4f7/XxXh/v9fFeH+/18V4f7/XxXp/u9elen+718V4f7/XxXh/v9YVdEnZJbEP/Yhv6F9vQP93r470+3uvjvT7e6+O9Pt7r470+3uvjvT7d69O9Pt3r470+3uvjvT7e6wu7JOyS2Ib+xTb0L7ahf7rXx3t9vNfHe32818d7fbzXx3t9vNfHe32616d7fbrXx3t9vNfHe3281xd2SdglsQ39i23oX2xD/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4ry/skrBLYhv6F9vQv9iG/uleH+/18V4f7/XxXh/v9fFeH+/18V4f7/XpXp/u9eleH+/18V4f7/XxXl/aJWmX5Db0L7ehf7kN/dO9Pt7r470+3uvjvT7e6+O9Pt7r470+3uvTvT7d69O9Pt7r470+3uvjvb60S9IuyW3oX25D/3Ib+qd7fbzXx3t9vNfHe32818d7fbzXx3t9vNene32616d7fbzXx3t9vNfHe31pl6RdktvQv9yG/uU29E/3+nivj/f6eK+P9/p4r4/3+nivj/f6eK9P9/p0r0/3+nivj/f6eK+P9/rSLkm7JLehf7kN/ctt6J/u9fFeH+/18V4f7/XxXh/v9fFeH+/18V6f7vXpXp/u9fFeH+/18V4f7/WlXZJ2SW5D/3Ib+lfb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3usru6TsktqG/tU29K+2oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNdXdknZJbUN/att6F9tQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK+v7JKyS2ob+lfb0L/ahv7pXh/v9fFeH+/18V4f7/XxXh/v9fFeH+/16V6f7vXpXh/v9fFeH+/18V5f2SVll9Q29K+2oX+1Df3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+tkvaLult6F9vQ/96G/qne32818d7fbzXx3t9vNfHe32818d7fbzXp3t9utene32818d7fbzXx3t9bZe0XdLb0L/ehv71NvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f62i5pu6S3oX+9Df3rbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1tV3SdklvQ/96G/rX29A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7ra7uk7ZLehv71NvSvt6F/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzXN3bJ2CWzDf2bbejfbEP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+nivb+ySsUtmG/o329C/2Yb+6V4f7/XxXh/v9fFeH+/18V4f7/XxXh/v9elen+716V4f7/XxXh/v9fFe39glY5fMNvRvtqF/sw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vrFLxi6ZbejfbEP/Zhv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3sN3mvwXoP3GrzX+O0uid/ukvhtQx+/bejjtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuO3uyR+u0vitw19/Lahj9829KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuN3+6S+O0uid829PHbhj5+29CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNX7lP6D8B2xDH79t6OO3DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be4zf+A8Z/wDb08duGPn7b0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81vt0l8e0uiW8b+vi2oY9vG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xre7JL7dJfFtQx/fNvTxbUMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81/h2l8S3uyS+bejj24Y+vm3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xpf+w9o/wHb0Me3DX1829CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNY5dcuySsw19nG3o42xDH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNc4dsmxS8429HG2oY+zDX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be49glxy4529DH2YY+zjb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be41jlxy75GxDH2cb+jjb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81jl1y7JKzDX2cbejjbEMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq817h2ybVL7jb0cbehj7sNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F7j2iXXLrnb0Mfdhj7uNvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jWuXXLvkbkMfdxv6uNvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zWuXXLtkrsNfdxt6ONuQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXeHbJs0veNvTxtqGPtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuPZJc8uedvQx9uGPt429KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNZ5c8u+RtQx9vG/p429CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNZ5d8uyStw19vG3o421DH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNd4dsmzS9429PG2oY+3DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/BeI+ySsEtiG/qIbegjtqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea4RdEnZJbEMfsQ19xDb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42wS8IuiW3oI7ahj9iGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8RdknYJbENfcQ29BHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81wi4JuyS3oY/chj5yG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9RtolaZfkNvSR29BHbkMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq810i7JO2S3IY+chv6yG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xppl6RdktvQR25DH7kNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F4j7ZK0S3Ib+sht6CO3oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rlF1SdkltQx+1DX3UNvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbJLyi6pbeijtqGP2oY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r1F2SdkltQ191Db0UdvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXKLim7pLahj9qGPmob+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2SVll9Q29FHb0EdvQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXaLuk7ZLehj56G/robehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3Gm2XtF3S29BHb0MfvQ196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXqPtkrZLehv66G3oo7ehD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mu0XdJ2SW9DH70NffQ29KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNsUvGLplt6GO2oY/Zhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivMXbJ2CWzDX3MNvQx29CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNcYuGbtktqGP2YY+Zhv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvcbYJWOXzDb0MdvQx2xDH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNcYu2TsktmGPmYb+pht6EP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eav90l+dtdkr9t6PO3DX3+tqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea/52l+Rvd0n+tqHP3zb0+duGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea/5212Sv90l+duGPn/b0OdvG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S95q/9B7T/gG3o87cNff62oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rfrtL8ttdkt829PltQ5/fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zW93SX67S/Lbhj6/bejz24Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/ntLslvd0l+29Dntw19ftvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zW/8h9Q/gO2oc9vG/r8tqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea37jP2D8B2xDn9829PltQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXPHbJsUvONvR5tqHPsw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXvPYJccuOdvQ59mGPs829Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNY5ccu+RsQ59nG/o829Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNY9dcuySsw19nm3o82xDn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNe8dsm1S+429Hm3oc+7DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Je89ol1y6529Dn3YY+7zb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je81rl1y75G5Dn3cb+rzb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81r11y7ZK7DX3ebejzbkOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q817x2ybVL7jb0ebehz7sNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7z2SXPLnnb0Ofbhj7fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zWeXPLvkbUOfbxv6fNvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zWfXfLskrcNfb5t6PNtQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXfHbJs0veNvT5tqHPtw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXjPskrBLYhv6jG3oM7ahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3muGXRJ2SWxDn7ENfcY29Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNsEvCLolt6DO2oc/Yhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvGXZJ2CWxDX3GNvQZ29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNcMuCbsktqHP2IY+Yxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvWbaJWmX5Db0mdvQZ25Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNdMuyTtktyGPnMb+sxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaaZekXZLb0GduQ5+5DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/JeM+2StEtyG/rMbegzt6FP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea6ZdknZJbUOftQ191jb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82yS8ouqW3os7ahz9qGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea9ZdknZJbUNfdY29Fnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81yy4pu6S2oc/ahj5rG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S9ZtklZZfUNvRZ29BnbUOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q812y7pO2S3oY+exv67G3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95ptl7Rd0tvQZ29Dn70Nfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l6z7ZK2S3ob+uxt6LO3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rtl3SdklvQ5+9DX32NvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zbZL2i7pbeizt6HP2YY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5rzl2ydglsw19zjb0OdvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXHLhm7ZLahz9mGPmcb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3m2CVjl8w29Dnb0OdsQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXHLtk7JLZhj5nG/qcbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvZbutXSvxXst3mvxXov3Wr/dJfXbXVK/bejrtw19/bahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3mv9dpfUb3dJ/bahr9829PXbhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXiv9dtdUr/dJfXbhr5+29DXbxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdav/AeU/4Bt6Ou3DX39tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea/3Gf8D4D9iGvn7b0NdvG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91re7pL7dJfVtQ1/fNvT1bUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81/p2l9S3u6S+bejr24a+vm3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rf7pL6dpfUtw19fdvQ17cNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V7ra/8B7T9gG/r6tqGvbxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdaxS45dcrahr7MNfZ1t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/daxy45dsnZhr7ONvR1tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3eax275NglZxv6OtvQ19mGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK917JJjl5xt6OtsQ19nG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91rFLjl1ytqGvsw19nW3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rXLrl2yd2Gvu429HW3oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rXbvk2iV3G/q629DX3Ya+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r3XtkmuX3G3o625DX3cb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r3WtUuuXXK3oa+7DX3dbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Ws8ueXbJ24a+3jb09bahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3ms9u+TZJW8b+nrb0Nfbhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXiv9eySZ5e8bejrbUNfbxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdazS55d8rahr7cNfb1t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/dazy55dsnbhr7eNvT1tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea4VdEnZJbENfsQ19xTb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe62wS8IuiW3oK7ahr9iGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK8VdknYJbENfcU29BXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1wi4JuyS2oa/Yhr5iG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtolaZfkNvSV29BXbkNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q810q7JO2S3Ia+chv6ym3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91ppl6RdktvQV25DX7kNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V4r7ZK0S3Ib+spt6Cu3oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rpV2SdkluQ1+5DX3lNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbJLyi6pbeirtqGv2oa+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r1V2SdkltQ191Tb0VdvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XKLim7pLahr9qGvmob+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r1W2SVll9Q29FXb0FdtQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXKruk7JLehr56G/rqbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Wm2XtF3S29BXb0NfvQ196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXqvtkrZLehv66m3oq7ehL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3mu1XdJ2SW9DX70NffU29KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXuttkvaLult6Ku3oa/ehr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivNXbJ2CWzDX3NNvQ129CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtcYuGbtktqGv2Ya+Zhv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdbYJWOXzDb0NdvQ12xDX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNcau2TsktmGvmYb+ppt6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/daY5eMXTLb0NdsQ9+/behb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32r/dJf3bXdK/bej7tw19/7ahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mv/dpf0b3dJ/7ah79829P3bhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv/dtd0r/dJf3bhr5/29D3bxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfav/Qe0/4Bt6Pu3DX3/tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea3+7S/rbXdLfNvT9bUPf3zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+1vd0l/u0v624a+v23o+9uGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/97S7pb3dJf9vQ97cNfX/b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1v/IfUP4DtqHvbxv6/rahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mt/4z9g/AdsQ9/fNvT9bUPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81z52ybFLzjb0fbah77MNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81772CXHLjnb0PfZhr7PNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177WOXHLvkbEPfZxv6PtvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277WPXXLskrMNfZ9t6PtsQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXvnbJtUvuNvR9t6Hvuw19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXvvaJdcuudvQ992Gvu829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvta5dcu+RuQ993G/q+29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvta9dcu2Suw19323o+25D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNe+dsm1S+429H23oe+7DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9klzy5529D324a+3zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+1nlzy75G1D328b+n7b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1n13y7JK3DX2/bej7bUPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81352ybNL3jb0/bah77cNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81477JKwS2Ib+o5t6Du2oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rh10SdklsQ9+xDX3HNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177bBLwi6Jbeg7tqHv2Ia+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5rx12SdglsQ19xzb0HdvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277XDLgm7JLah79iGvmMb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122iVpl+Q29J3b0HduQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXTrsk7ZLchr5zG/rObehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32mmXpF2S29B3bkPfuQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXjvtkrRLchv6zm3oO7ehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3muXXVJ2SW1D37UNfdc29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtskvKLqlt6Lu2oe/ahr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvXXZJ2SW1DX3XNvRd29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtcsuKbuktqHv2oa+axv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvXbZJWWX1Db0XdvQd21D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNduu6Ttkt6Gvnsb+u5t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fabZe0XdLb0HdvQ9+9DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Neu+2Stkt6G/rubei7t6Fv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea7dd0nZJb0PfvQ199zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+22S9oumW3oe7ah79mGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea89dsnYJbMNfc829D3b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1xy4Zu2S2oe/Zhr5nG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99tglY5fMNvQ929D3bEPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81x67ZOyS2Ya+Zxv6nm3oW/favNfmvTbvtXmvzXtt3mvzXpv3OrzX0b2O7nV0r8N7Hd7r8F6H9zq/3SXz210yv23o57cN/fy2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7r/HaXzG93yfy2oZ/fNvTz24Z+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r/PbXTK/3SXz24Z+ftvQz28b+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3Or/wHlP+Abejntw39/LahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uv8xn/A+A/Yhn5+29DPtw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXufbXTLf7pL5tqGfbxv6+bahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3ut8u0vm210y3zb0821DP9829KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udb3fJfLtL5tuGfr5t6Ofbhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv87X/gPYfsA39fNvQz7cN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F7n2CXHLjnb0M/Zhn7ONvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWOXHLvkbEM/Zxv6OdvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73WOXXLskrMN/Zxt6OdsQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXOXbJsUvONvRztqGfsw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXufYJccuOdvQz9mGfs429KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3uda5dcu+RuQz93G/q529CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vda5dcu2Suw393G3o525DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNe5dsm1S+429HO3oZ+7Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be59ol1y6529DP3YZ+7jb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De51nlzy75G1DP28b+nnb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91nl3y7JK3Df28bejnbUM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq813l2ybNL3jb087ahn7cN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F7n2SXPLnnb0M/bhn7eNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWeXPLvkbUM/bxv6edvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XCLgm7JLahn9iGfmIb+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b1O2CVhl8Q29BPb0E9sQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXCbsk7JLYhn5iG/qJbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OmGXhF0S29BPbEM/sQ396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXiftkrRLchv6yW3oJ7ehH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uukXZJ2SW5DP7kN/eQ29KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udtEvSLslt6Ce3oZ/chn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXivk3ZJ2iW5Df3kNvST29CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vddIuSbskt6Gf3IZ+chv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvU7ZJWWX1Db0U9vQT21DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNcpu6TsktqGfmob+qlt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6ZZeUXVLb0E9tQz+1Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Bep+ySsktqG/qpbeintqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e67Rd0nZJb0M/vQ399Db0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De522S9ou6W3op7ehn96GfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK/TdknbJb0N/fQ29NPb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du912i5pu6S3oZ/ehn56G/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtslbZf0NvTT29BPb0M/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81xm7ZOyS2YZ+Zhv6mW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zpjl4xdMtvQz2xDP7MN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F5n7JKxS2Yb+plt6Ge2oR/d6/Be/4+IO7iRZcehKOhSJUmJov+OzTTwH2OXu4YWTVygDmJ4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc7YJWOXzDb0M9vQz2xDP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNcZu2T+7ZL//yL8r6H/+/zvcv19/ne5/j7/+2t/n+Xz+Lw+2+fzOfv5b5f8fX4+w6e/9vlrn7/27zfhv8/2+Xx6279d8vf5+Yx98b+G/u+z9sXhr4W3hbeFt4W3pbelt6W3pbelt6W/lv5a+mvpbelt5W3lbf92yd9n+qx98b+G/u/z7ovLXytvK2873na87Xjb8bbjbcfbjrcdf+34a8dfu952ve162/W2f7vk7/P4vPvifw393+fbF19/rb2tva29rb2tva29rb2tva29rf215689f+152/O2523P257/gOc/4F9D//c5++J/Df3fp7823jbeNt423jbeNt423jb7tvVe/z4/n+Ezfe7b1nv9+7w+2+fzuf8B37eX6/v2cn3fXq7PLfncks8tWe/177N9Pp/eFt4W3hbeFv5a+GtuyXqvf5/eFt4W3pY/n5/PvVxf7uX6ci/X55Z8bsnnlqz3+vfpbeVt5W3lbeVt5W3lr5W/5pas9/r36W3H2463nfCZPvdyfWcv13f2cn1uyeeWfG7Jeq9/n952ve162/W2623X266/dv01t2S9179Pb2tva29r/wHtP6D3cn29l+vrvVyfW/K5JZ9bst7r36e3PW973va87Xnb87bnr42/5pas9/r36W3jbeNt4z9g/AfMXq5v9nLFby9XuCXhloRbEnZJ2CVhl4RdEnZJ2CVhl4RdEnZJuCXrvf59Hp/XZ/t8Pvc/IGIvV8Reroi9XOGWhFsSbknYJWGXhF0SdknYJWGXhF0SdknYJeGWrPf69+ltdknYJWGXhF0StZcrai9X1F6ucEvCLQm3JOySsEvCLgm7JOySsEvCLgm7JOyScEvWe/379Da7JOySsEvCLom7lyvuXq64e7nCLQm3JNySsEvCLgm7JOySsEvCLgm7JOySsEvCLVnv9e/T2+ySsEvCLgm7JN5ernh7ueLt5Qq3JNyScEvCLgm7JOySsEvCLgm7JOySsEvSLkm3ZL3Xv8/0WT6Pz+uzfe7lyt9ervz2cqVbkm5JuiVpl6RdknZJ2iVpl6RdknZJ2iVpl6Rbst7r36e32SVpl6RdknZJ5l6uzL1cmXu50i1JtyTdkrRL0i5JuyTtkrRL0i5JuyTtkrRL0i1Z7/Xv09vskrRL0i5JuyTPXq48e7ny7OVKtyTdknRL0i5JuyTtkrRL0i5JuyTtkrRL0i5Jt2S9179Pb7NL0i5JuyTtkuy9XNl7ubL3cqVbkm5JuiVpl6RdknZJ2iVpl6RdknZJ2iVpl6Rbst7r36e32SVpl6RdknZJzl6unL1cOXu50i0pt6TckrJLyi4pu6TskrJLyi4pu6TskrJLyi1Z7/XvM32Wz+Pz+myfe7nq28tVsZer3JJyS8otKbuk7JKyS8ouKbuk7JKyS8ouKbuk3JL1Xv8+vc0uKbuk7JKyS6r2clXt5aray1VuSbkl5ZaUXVJ2SdklZZeUXVJ2SdklZZeUXVJuyXqvf5/eZpeUXVJ2Sdkldfdy1d3LVXcvV7kl5ZaUW1J2SdklZZeUXVJ2SdklZZeUXVJ2Sbkl673+fXqbXVJ2SdklZZfU28tVby9Xvb1c5ZaUW1JuSdklZZeUXVJ2SdklZZeUXVJ2Sdkl5Zas9/r3+fkMn+mzfB6fe7nOby/X+e3lOm7JcUuOW3LskmOXHLvk2CXHLjl2ybFLjl1y7JLjlqz3+vfpbXbJsUuOXXLskhN7uU7s5Tq5l+u4JcctOW7JsUuOXXLskmOXHLvk2CXHLjl2ybFLjluy3uvfp7fZJccuOXbJsUvO2ct1zl6uc/ZyHbfkuCXHLTl2ybFLjl1y7JJjlxy75Nglxy45dslxS9Z7/fv0Nrvk2CXHLjl2yem9XKf3cp3ey3XckuOWHLfk2CXHLjl2ybFLjl1y7JJjlxy75Nglxy1Z7/Xv09vskmOXHLvk2CVn9nKd2ct1Zi/XcUuOW3LckmuXXLvk2iXXLrl2ybVLrl1y7ZJrl1y3ZL3Xv8/PZ/hMn+Xz+NzLdb+9XPfby3XdkuuWXLfk2iXXLrl2ybVLrl1y7ZJrl1y75Nol1y1Z7/Xv09vskmuXXLvk2iU393Ld3Mt1ay/XdUuuW3LdkmuXXLvk2iXXLrl2ybVLrl1y7ZJrl1y3ZL3Xv09vs0uuXXLtkmuX3LuX6969XPfu5bpuyXVLrlty7ZJrl1y75Nol1y65dsm1S65dcu2S65as9/r36W12ybVLrl1y7ZL79nLdt5frvr1c1y25bsl1S65dcu2Sa5dcu+TaJdcuuXbJtUuuXXLdkvVe/z73bW2XtF3SdknbJf3by9W/vVz928vVbkm7Je2WtF3SdknbJW2XtF3SdknbJW2XtF3Sbkn7Tbj9Jtx2SdslbZe0XdKxl6tjL1fHXq52S9otabek7ZK2S9ouabuk7ZK2S9ouabuk7ZJ2S9pvwu034bZL2i5pu6Ttkq69XF17ufrs5Wq3pN2SdkvaLmm7pO2StkvaLmm7pO2StkvaLmm3pP0m3H4Tbruk7ZK2S9ou6d7L1b2Xq3svV7sl7Za0W9J2SdslbZe0XdJ2SdslbZe0XdJ2Sbsl7Tfh9ptw2yVtl7Rd0nZJz16unr1cPXu52i1pt6TdkrZL2i55dsmzS55d8uySZ5c8u+TZJc8teX4Tfn4TfnbJs0ueXfLskvft5XrfXq737eV6bslzS55b8uySZ5c8u+TZJc8ueXbJs0ueXfLskueWPL8JP78JP7vk2SXPLnl2ycu9XC/3cr3cy/XckueWPLfk2SXPLnl2ybNLnl3y7JJnlzy75Nklzy15fhN+fhN+dsmzS55d8uySd/ZyvbOX6929XM8teW7Jc0ueXfLskmeXPLvk2SXPLnl2ybNLnl3y3JLnN+HnN+Fnlzy75Nklzy55by/Xe3u53tvL9dyS55Y8t+TZJc8ueXbJs0ueXfLskmeXPLvk2SXPLXl+E35+E352ybNLxi4Zu2R+e7nmt5drfnu5xi0Zt2TckrFLxi4Zu2TskrFLxi4Zu2TskrFLxi0ZvwmP34THLhm7ZOySsUsm9nJN7OWa2Ms1bsm4JeOWjF0ydsnYJWOXjF0ydsnYJWOXjF0ybsn4TXj8Jjx2ydglY5eMXTK1l2tqL9fUXq5xS8YtGbdk7JKxS8YuGbtk7JKxS8YuGbtk7JJxS8ZvwuM34bFLxi4Zu2Tskrl7uebu5ZreyzVuybgl45aMXTJ2ydglY5eMXTJ2ydglY5eMXTJuyfhNePwmPHbJ2CVjl4xdMrOXa2Yv18xernFLxi0Zt2TskrFLxi5Z7/X/v9HuLvnWe/37DJ/ps3wen//e9q33+vf5fM5+7i75frtLvt+/hv7v89/l+n7/Gvq/T39tb8m33uvf5/PpbeFt4W3hbeFt4W3hr4W/Fv5aeFt4W3pbetvuku+3u+T7/Wvo/z7PvvhfQ//36a+lt6W3lbeVt5W3lbeVt5W3lbeVv1b+Wvlrx9uOtx1vO962u+T77S75fv8a+r/P3hf/a+j/Pv21623X2663XW+73na97Xrb9bbrbddfa3+t/bX2tva29rb2tvYf0P4D/jX0f5+zL/7X0P99+mvP2563PW973va87Xnb87bnbeNt46+Nvzb+2njbeNt423jb+A/YXfJ929B/3zb037cN/ad7/T635HNL1nv9+2yfz+e+bb3Xv8/PZ/j01z5/zS1Z7/Xvs30+n962u+T7dpd83zb037cN/fdtQ//pXr/PLfnckvVe/z69Lb0tvS29Lb0tvS39tfTX3JL1Xv8+va28rbxtd8n37S75vm3ov28b+u/bhv7TvX6fW/K5Jeu9/n162/G2423H2463HW87/trx19yS9V7/Pr3tetv1tt0l37e75Pu2of++bei/bxv6T/f6fW7J55as9/r36W3tbe1t7W3tbe1t7a89f80tWe/179Pbnrc9b3v+A57/gG3ov28b+u/bhv7TvX6fW/K5Jeu9/n1623jbeNt4m10Sdonu9dO9frrXb73Xv8/j8/psn8/n/gfENvRfbEP/xTb0n+71C7ck3JKwS8IuCbsk7JKwS8IuCbtE9/rpXj/d67fe69+nt9klYZeEXRJ2SWxD/8U29F9sQ//pXr9wS8ItCbsk7JKwS8IuCbsk7JKwS3Svn+71071+673+fXqbXRJ2SdglYZfENvRfbEP/xTb0n+71C7ck3JKwS8IuCbsk7JKwS8IuCbtE9/rpXj/d67fe69+nt9klYZeEXRJ2SWxD/8U29F9sQ//pXr9wS8ItCbsk7JKwS8IuCbsk7JKwS3Svn+71071+673+fXqbXRJ2SdglYZfENvRfbEP/5Tb0n+71S7ck3ZK0S9IuSbsk7ZK0S9IuSbtE9/rpXj/d67fe69/n8Xl9ts/nc/8Dchv6L7eh/3Ib+k/3+qVbkm5J2iVpl6RdknZJ2iVpl6Rdonv9dK+f7vVb7/Xv09vskrRL0i5JuyS3of9yG/ovt6H/dK9fuiXplqRdknZJ2iVpl6RdknZJ2iW610/3+ulev/Ve/z69zS5JuyTtkrRLchv6L7eh/3Ib+k/3+qVbkm5J2iVpl6RdknZJ2iVpl6Rdonv9dK+f7vVb7/Xv09vskrRL0i5JuyS3of9yG/ovt6H/dK9fuiXplqRdknZJ2iVpl6RdknZJ2iW610/3+ulev/Ve/z7TZ/k8Pq/P9rmXq7ah/2ob+k/3+pVbUm5J2SVll5RdUnZJ2SVll5Rdonv9dK+f7vVb7/Xv09vskrJLyi4pu6S2of9qG/qvtqH/dK9fuSXllpRdUnZJ2SVll5RdUnZJ2SW610/3+ulev/Ve/z69zS4pu6TskrJLahv6r7ah/2ob+k/3+pVbUm5J2SVll5RdUnZJ2SVll5Rdonv9dK+f7vVb7/Xv09vskrJLyi4pu6S2of9qG/qvtqH/dK9fuSXllpRdUnZJ2SVll5RdUnZJ2SW610/3+ulev/Ve/z69zS4pu6TskrJLahv6r7ah/2ob+k/3+h235Lglxy45dsmxS45dcuySY5ccu0T3+uleP93rt97r32f6LJ/H5/XZPvdynW3ov7MN/ad7/Y5bctySY5ccu+TYJccuOXbJsUuOXaJ7/XSvn+71W+/179Pb7JJjlxy75NglZxv672xD/51t6D/d63fckuOWHLvk2CXHLjl2ybFLjl1y7BLd66d7/XSv33qvf5/eZpccu+TYJccuOdvQf2cb+u9sQ//pXr/jlhy35Nglxy45dsmxS45dcuySY5foXj/d66d7/dZ7/fv0Nrvk2CXHLjl2ydmG/jvb0H9nG/pP9/odt+S4JccuOXbJsUuOXXLskmOXHLtE9/rpXj/d67fe69/n5zN8ps/yeXzu5brb0H93G/pP9/pdt+S6JdcuuXbJtUuuXXLtkmuXXLtE9/rpXj/d67fe69+nt9kl1y65dsm1S+429N/dhv6729B/utfvuiXXLbl2ybVLrl1y7ZJrl1y75NolutdP9/rpXr/1Xv8+vc0uuXbJtUuuXXK3of/uNvTf3Yb+071+1y25bsm1S65dcu2Sa5dcu+TaJdcu0b1+utdP9/qt9/r36W12ybVLrl1y7ZK7Df13t6H/7jb0n+71u27JdUuuXXLtkmuXXLvk2iXXLrl2ie71071+utdvvde/T2+zS65dcu2Sa5fcbei/uw39d7eh/3Sv33VLrlvSdknbJW2XtF3SdknbJW2X6F4/3eune/3ab8LtN+G2S9ouabuk7ZLehv7rbei/3ob+071+7Za0W9J2SdslbZe0XdJ2SdslbZfoXj/d66d7/dpvwu034bZL2i5pu6Ttkt6G/utt6L/ehv7TvX7tlrRb0nZJ2yVtl7Rd0nZJ2yVtl+heP93rp3v92m/C7TfhtkvaLmm7pO2S3ob+623ov96G/tO9fu2WtFvSdknbJW2XtF3SdknbJW2X6F4/3eune/3ab8LtN+G2S9ouabuk7ZLehv7rbei/3ob+071+7Za0W9J2SdslbZe0XdJ2SdslbZfoXj/d66d7/dpvwu034WeXPLvk2SXPLnnb0H9vG/rvbUP/6V6/55Y8t+TZJc8ueXbJs0ueXfLskmeX6F4/3eune/2e34Sf34SfXfLskmeXPLvkbUP/vW3ov7cN/ad7/Z5b8tySZ5c8u+TZJc8ueXbJs0ueXaJ7/XSvn+71e34Tfn4TfnbJs0ueXfLskrcN/fe2of/eNvSf7vV7bslzS55d8uySZ5c8u+TZJc8ueXaJ7vXTvX661+/5Tfj5TfjZJc8ueXbJs0veNvTf24b+e9vQf7rX77klzy15dsmzS55d8uySZ5c8u+TZJbrXT/f66V6/5zfh5zfhZ5c8u+TZJc8uedvQf28b+u9tQ//pXr/nljy35Nklzy4Zu2TskrFLxi4Zu0T3+uleP93rN34THr8Jj10ydsnYJWOXzDb032xD/8029J/u9Ru3ZNySsUvGLhm7ZOySsUvGLhm7RPf66V4/3es3fhMevwmPXTJ2ydglY5fMNvTfbEP/zTb0n+71G7dk3JKxS8YuGbtk7JKxS8YuGbtE9/rpXj/d6zd+Ex6/CY9dMnbJ2CVjl8w29N9sQ//NNvSf7vUbt2TckrFLxi4Zu2TskrFLxi4Zu0T3+uleP93rN34THr8Jj10ydsnYJWOXzDb032xD/8029J/u9Ru3ZNySsUvGLhm7ZOySsUvGLhm7RPf66V4/3es3fhMevwmPXcJ7jd/ukvjtLonfNvTx24Y+ftvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zV+u0vit7skftvQx28b+vhtQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzX+O0uid/ukvhtQx+/bejjtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuO3uyR+u0vitw19/Lahj9829KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuN3/Mf8PwHbEMfv23o47cNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F7j210S3+6S+Lahj28b+vi2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rfLtL4ttdEt829PFtQx/fNvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jW93SXy7S+Lbhj6+bejj24Y+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r/G1/4D2H7ANfXzb0Me3DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be4xv/AXZJbEMfsQ19xDb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42wS8IuiW3oI7ahj9iGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8RdknYJbENfcQ29BHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81wi4JuyS2oY/Yhj5iG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9RtglYZfENvQR29BHbEMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq810i7JO2S3IY+chv6yG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xppl6RdktvQR25DH7kNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F4j7ZK0S3Ib+sht6CO3oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rpF2SdkluQx+5DX3kNvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbRL0i7Jbegjt6GP2oY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r1F2SdkltQ191Db0UdvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXKLim7pLahj9qGPmob+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2SVll9Q29FHb0EdtQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXKLuk7JLahj5qG/qobehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GscuOXbJ2YY+zjb0cbahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mscu+TYJWcb+jjb0MfZhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivceySY5ecbejjbEMfZxv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvcaxS45dcrahj7MNfZxt6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/caxy45dsnZhj7ONvRxtqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea1y75Noldxv6uNvQx92GPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK9x7ZJrl9xt6ONuQx93G/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xrVLrl1yt6GPuw193G3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xrXLrl2yd2GPu429HG3oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rtF3SdklvQx+9DX30NvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbZL2i7pbeijt6GP3oY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r9F2SdslvQ199Db00dvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXaLmm7pLehj96GPnob+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2yVtl/Q29NHb0EdvQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXeHbJs0veNvTxtqGPtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuPZJc8uedvQx9uGPt429KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNZ5c8u+RtQx9vG/p429CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNZ5d8uyStw19vG3o421DH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNcYu2TsktmGPmYb+pht6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/caY5eMXTLb0MdsQx+zDX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/BeY+ySsUtmG/qYbehjtqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea4xdMnbJbEMfsw19zDb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42xS8YumW3oY7ahj9mGPnSvwXsN3mvwXoP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea/5212Sv90l+duGPn/b0OdvG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S95m93Sf52l+RvG/r8bUOfv23oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95q/3SX5212Sv23o87cNff62oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5r/tp/QPsP2IY+f9vQ528b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3mt7skv90l+W1Dn9829PltQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzX/HaX5Le7JL9t6PPbhj6/behT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mt/ukvx2l+S3DX1+29Dntw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXvPbXZLf7pL8tqHPbxv6/LahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mt+z3/A8x+wDX1+29Dntw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXjPskrBLYhv6jG3oM7ahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3muGXRJ2SWxDn7ENfcY29Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNsEvCLolt6DO2oc/Yhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvGXZJ2CWxDX3GNvQZ29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNcMuCbskt6HP3IY+cxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvWbaJWmX5Db0mdvQZ25Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNdMuyTtktyGPnMb+sxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaaZekXZLb0GduQ5+5DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/JeM+2StEtyG/rMbegzt6FP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea5ZdUnZJbUOftQ191jb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82yS8ouqW3os7ahz9qGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea9ZdknZJbUNfdY29Fnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81yy4pu6S2oc/ahj5rG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S9ZtklZZfUNvRZ29Dn2YY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r3nskmOXnG3o82xDn2cb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3msUuOXXK2oc+zDX2ebehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mscuOXbJ2YY+zzb0ebahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mseu+TYJWcb+jzb0OfZhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvee2Sa5fcbejzbkOfdxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvea1S65dcrehz7sNfd5t6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/ea1y65dsndhj7vNvR5t6FP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea1675Noldxv6vNvQ592GPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea957ZJrl9xt6PNuQ593G/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S9ZtslbZf0NvTZ29Bnb0OfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q812y7pO2S3oY+exv67G3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95ptl7Rd0tvQZ29Dn70Nfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l6z7ZK2S3ob+uxt6LO3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rPrvk2SVvG/p829Dn24Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/nskmeXvG3o821Dn28b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3ms0ueXfK2oc+3DX2+behT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3ms8ueXbJ24Y+3zb0+bahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3ms+u+TZJW8b+nzb0Ofbhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvOXbJ2CWzDX3ONvQ529Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNccuGbtktqHP2YY+Zxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvebYJWOXzDb0OdvQ52xDn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNccu2TsktmGPmcb+pxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Fei/dav90l9dtdUr9t6Ou3DX39tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea/12l9Rvd0n9tqGv3zb09duGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/1211Sv90l9duGvn7b0NdvG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91m93Sf2u/4Bt6Ou3DX39tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea/3Gf8D4D9iGvn7b0NdvG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91re7pL7dJfVtQ1/fNvT1bUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81/p2l9S3u6S+bejr24a+vm3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rf7pL6dpfUtw19fdvQ17cNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V7ra/8B7T9gG/r6tqGvbxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivVbYJWGXxDb0FdvQV2xDX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNcKuyTsktiGvmIb+opt6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/daYZeEXRLb0FdsQ1+xDX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/FeK+ySsEtiG/qKbegrtqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea4VdEnZJbENfsQ19xTb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe620S9IuyW3oK7ehr9yGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK+VdknaJbkNfeU29JXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+10i5JuyS3oa/chr5yG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtolaZfkNvSV29BXbkNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q810q7JO2S2oa+ahv6qm3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91pll5RdUtvQV21DX7UNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V6r7JKyS2ob+qpt6Ku2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rlV1SdkltQ1+1DX3VNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbJLyi6pbeirtqGv2oa+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r3XskmOXnG3o62xDX2cb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r3WsUuOXXK2oa+zDX2dbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WscuOXbJ2Ya+zjb0dbahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3msdu+TYJWcb+jrb0NfZhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivdeySY5ecbejrbENfdxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivda1S65dcrehr7sNfd1t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/da1y65dsndhr7uNvR1t6Ev3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea1275Noldxv6utvQ192GvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK917ZJrl9xt6OtuQ193G/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtslbZf0NvTV29BXb0NfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q812q7pO2S3oa+ehv66m3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91ptl7Rd0tvQV29DX70Nfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V6r7ZK2S3ob+upt6Ku3oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rtV3SdklvQ1+9DX31NvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rWeXPLvkbUNfbxv6etvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77WeXfLskrcNfb1t6OttQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXenbJs0veNvT1tqGvtw196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXuvZJc8uedvQ19uGvt429KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutsUvGLplt6Gu2oa/Zhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivNXbJ2CWzDX3NNvQ129CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtcYuGbtktqGv2Ya+Zhv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdbYJWOXzDb0NdvQ12xDX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNcau2TsktmGvmYb+ppt6Ev3WrzX4r0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ7f7pLz211yftvQn9829Oe3Df3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2e3+6S89tdcn7b0J/fNvTntw390b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7e69G9Ht3r0b0e3uvhvR7e6+G9nt/ukvPbXXJ+29Cf3zb057cN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ7f8x/w/AdsQ39+29Cf3zb0R/d6eK+H93p4r4f3enivh/d6eK+H93p4r0f3enSvR/d6eK+H93p4r4f3er7dJefbXXK+bejPtw39+bahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281/PtLjnf7pLzbUN/vm3oz7cN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ5vd8n5dpecbxv6821Df75t6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/V8u0vOd/0HbEN/vm3oz7cN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ5v/AeM/4Bt6M+3Df35tqE/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzXE3ZJ2CWxDf2JbehPbEN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3enivJ+ySsEtiG/oT29Cf2Ib+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBeT9glYZfENvQntqE/sQ390b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7e69G9Ht3r0b0e3uvhvR7e6+G9nrBLwi6JbehPbEN/Yhv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PWmXpF2S29Cf3Ib+5Db0R/d6eK+H93p4r4f3enivh/d6eK+H93p4r0f3enSvR/d6eK+H93p4r4f3etIuSbskt6E/uQ39yW3oj+718F4P7/XwXg/v9fBeD+/18F4P7/XwXo/u9ehej+718F4P7/XwXg/v9aRdknZJbkN/chv6k9vQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e60m7JO2S3Ib+5Db0J7ehP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez2815N2SdoluQ39yW3oT25Df3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4r6fskrJLahv6U9vQn9qG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXk/ZJWWX1Db0p7ahP7UN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ6yS8ouqW3oT21Df2ob+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez1ll5RdUtvQn9qG/tQ29Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93rKLim75GxDf8429OdsQ390r4f3enivh/d6eK+H93p4r4f3enivh/d6dK9H93p0r4f3enivh/d6eK/n2CXHLjnb0J+zDf0529Af3evhvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht3r0b0e3evhvR7e6+G9Ht7rOXbJsUvONvTnbEN/zjb0R/d6eK+H93p4r4f3enivh/d6eK+H93p4r0f3enSvR/d6eK+H93p4r4f3eo5dcuySsw39OdvQn7MN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ5jlxy75GxDf8429OdsQ390r4f3enivh/d6eK+H93p4r4f3enivh/d6dK9H93p0r4f3enivh/d6eK/n2iXXLrnb0J+7Df2529Af3evhvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht3r0b0e3evhvR7e6+G9Ht7ruXbJtUvuNvTnbkN/7jb0R/d6eK+H93p4r4f3enivh/d6eK+H93p4r0f3enSvR/d6eK+H93p4r4f3eq5dcu2Suw39udvQn7sN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ5rl1y75G5Df+429OduQ390r4f3enivh/d6eK+H93p4r4f3enivh/d6dK9H93p0r4f3enivh/d6eK/n2iXXLrnb0J+7Df3pbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1tF3SdklvQ396G/rT29Af3evhvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht3r0b0e3evhvR7e6+G9Ht7rabuk7ZLehv70NvSnt6E/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzX03ZJ2yW9Df3pbehPb0N/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3enivp+2Stkt6G/rT29Cf3ob+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBez7NLnl3ytqE/bxv687ahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281/PskmeXvG3oz9uG/rxt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/U8u+TZJW8b+vO2oT9vG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9zy55dsnbhv68bejP24b+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBez7NLnl3ytqE/bxv687ahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281zN2ydglsw39mW3oz2xDf3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4r2fskrFLZhv6M9vQn9mG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs/YJWOXzDb0Z7ahP7MN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ6xS8YumW3oz2xDf2Yb+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7vbzXy3u9vNfLe72/3SX3t7vk/rahv79t6O9vG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9v90l97e75P62ob+/bejvbxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vb/dJfe3u+T+tqG/v23o728b+qt7vbzXy3u9vNfLe72818t7vbzXy3u9vNere72616t7vbzXy3u9vNfLe72/9h/Q/gO2ob+/bejvbxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vb/xHzD+A7ahv79t6O9vG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u93+6S++0uud829Pfbhv5+29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7r/XaX3G93yf22ob/fNvT324b+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJe77e75H67S+63Df39tqG/3zb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3er/nP+D5D9iG/n7b0N9vG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9YZeEXRLb0N/Yhv7GNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6wy4JuyS2ob+xDf2Nbeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1hl0SdklsQ39jG/ob29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7rDbsk7JLYhv7GNvQ3tqG/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXG3ZJ2CWxDf2NbehvbEN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmvN+2StEtyG/qb29Df3Ib+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJeb9olaZfkNvQ3t6G/uQ391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93rRL0i7JbehvbkN/cxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vWmXpF2S29Df3Ib+5jb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3essuKbuktqG/tQ39rW3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9ZZdUnZJbUN/axv6W9vQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6y27pOyS2ob+1jb0t7ahv7rXy3u9vNfLe72818t7vbzXy3u9vNfLe72616t7vbrXy3u9vNfLe72811t2SdkltQ39rW3ob21Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r7fskrJLahv6W9vQ39qG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu+xS45dcrahv2cb+nu2ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNd77JJjl5xt6O/Zhv6ebeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1Hrvk2CVnG/p7tqG/Zxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vccuOXbJ2Yb+nm3o79mG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu+xS45dcrehv3cb+nu3ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNd77ZJrl9xt6O/dhv7ebeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1Xrvk2iV3G/p7t6G/dxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vdcuuXbJ3Yb+3m3o792G/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu+1S65dcrehv3cb+nu3ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNfbdknbJb0N/e1t6G9vQ391r5f3enmvl/d6ea+X93p5r5f3enmvl/d6da9X93p1r5f3enmvl/d6ea+37ZK2S3ob+tvb0N/ehv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l5v2yVtl/Q29Le3ob+9Df3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3etkvaLult6G9vQ397G/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9bZe0XdLb0N/ehv6+beiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1Prvk2SVvG/r7tqG/bxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vc8ueXbJ24b+vm3o79uG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu+zS55d8rahv28b+vu2ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNf77JJnl7xt6O/bhv6+beiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1jl0ydslsQ39nG/o729Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7rHbtk7JLZhv7ONvR3tqG/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXO3bJ2CWzDf2dbejvbEN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmvd+ySsUtmG/o729Df2Yb+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJe79glY5fMNvR3tqG/sw391b0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfZvd0n/dpf0bxv6/m1D379t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fav90l/dtd0r9t6Pu3DX3/tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea/92l/Rvd0n/tqHv3zb0/duGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/9e/4Dnv+Abej7tw19/7ahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mt/u0v6213S3zb0/W1D39829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtb3dJf7tL+tuGvr9t6Pvbhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv/e0u6W93SX/b0Pe3DX1/29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtb/2H9D+A7ah728b+v62oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rf+M/YPwHbEPf3zb0/W1D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNcOuyTsktiGvmMb+o5t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/faYZeEXRLb0HdsQ9+xDX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/NeO+ySsEtiG/qObeg7tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea4ddEnZJbEPfsQ19xzb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+20S9IuyW3oO7eh79yGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea+ddknaJbkNfec29J3b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+10y5JuyS3oe/chr5zG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a9dtolaZfkNvSd29B3bkPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81067JO2S3Ia+cxv6zm3oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99pll5RdUtvQd21D37UNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81677JKyS2ob+q5t6Lu2oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rl11SdkltQ9+1DX3XNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177bJLyi6pbei7tqHv2oa+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r33skmOXnG3o+2xD32cb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r32sUuOXXK2oe+zDX2fbehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32scuOXbJ2Ya+zzb0fbahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3msfu+TYJWcb+j7b0PfZhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvfeySY5ecbej7bEPfZxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfa1S65dcreh77sNfd9t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fa1y65dsndhr7vNvR9t6Fv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea1+75Noldxv6vtvQ992GvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea997ZJrl9xt6PtuQ993G/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99rVLrl3S29B3b0PfvQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXrvtkrZLehv67m3ou7ehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mu3XdJ2SW9D370Nffc29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvttkvaLult6Lu3oe/ehr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv3XZJ2yW9DX33NvTd29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtZ9d8uyStw19v23o+21D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNd+dsmzS9429P22oe+3DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9klzy5529D324a+3zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+1nlzy75G1D328b+n7b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1n13y7JK3DX2/beh7tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea49dMnbJbEPfsw19zzb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+2xS8YumW3oe7ah79mGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea89dsnYJbMNfc829D3b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1xy4Zu2S2oe/Zhr5nG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r0/3+nSvj/f6eK+P9/p4r++3u+T9dpe83zb077cN/fttQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK/vt7vk/XaXvN829O+3Df37bUP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+niv77e75P12l7zfNvTvtw39+21D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/X/gPaf8A29O+3Df37bUP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+niv7zf+A8Z/wDb077cN/fttQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK/v213yvt0l79uG/n3b0L9vG/qne32818d7fbzXx3t9vNfHe32818d7fbzXp3t9utene32818d7fbzXx3t93+6S9+0ued829O/bhv5929A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7r+3aXvG93yfu2oX/fNvTv24b+6V4f7/XxXh/v9fFeH+/18V4f7/XxXh/v9elen+716V4f7/XxXh/v9fFe3/f8Bzz/AdvQv28b+vdtQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK8v7JKwS2Ib+hfb0L/Yhv7pXh/v9fFeH+/18V4f7/XxXh/v9fFeH+/16V6f7vXpXh/v9fFeH+/18V5f2CVhl8Q29C+2oX+xDf3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+sEvCLolt6F9sQ/9iG/qne32818d7fbzXx3t9vNfHe32818d7fbzXp3t9utene32818d7fbzXx3t9YZeEXRLb0L/Yhv7FNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6wi4JuyS2oX+xDf2Lbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1pV2SdkluQ/9yG/qX29A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7rS7sk7ZLchv7lNvQvt6F/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzXl3ZJ2iW5Df3LbehfbkP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+nivL+2StEtyG/qX29C/3Ib+6V4f7/XxXh/v9fFeH+/18V4f7/XxXh/v9elen+716V4f7/XxXh/v9fFeX9klZZfUNvSvtqF/tQ39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vrJLyi6pbehfbUP/ahv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fWWXlF1S29C/2ob+1Tb0T/f6eK+P9/p4r4/3+nivj/f6eK+P9/p4r0/3+nSvT/f6eK+P9/p4r4/3+souKbuktqF/tQ39q23on+718V4f7/XxXh/v9fFeH+/18V4f7/XxXp/u9elen+718V4f7/XxXh/v9ZVdUnZJbUP/ahv6V9vQP93r470+3uvjvT7e6+O9Pt7r470+3uvjvT7d69O9Pt3r470+3uvjvT7e6zt2ybFLzjb072xD/8429E/3+nivj/f6eK+P9/p4r4/3+nivj/f6eK9P9/p0r0/3+nivj/f6eK+P9/qOXXLskrMN/Tvb0L+zDf3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+Y5ccu+RsQ//ONvTvbEP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+niv79glxy4529C/sw39O9vQP93r470+3uvjvT7e6+O9Pt7r470+3uvjvT7d69O9Pt3r470+3uvjvT7e67t2ybVL7jb0725D/+429E/3+nivj/f6eK+P9/p4r4/3+nivj/f6eK9P9/p0r0/3+nivj/f6eK+P9/quXXLtkrsN/bvb0L+7Df3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+a5dcu+RuQ//uNvTvbkP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+niv79ol1y6529C/uw39u9vQP93r470+3uvjvT7e6+O9Pt7r470+3uvjvT7d69O9Pt3r470+3uvjvT7e67t2ybVL7jb0725D/+429E/3+nivj/f6eK+P9/p4r4/3+nivj/f6eK9P9/p0r0/3+nivj/f6eK+P9/raLmm7pLehf70N/ett6J/u9fFeH+/18V4f7/XxXh/v9fFeH+/18V6f7vXpXp/u9fFeH+/18V4f7/W1XdJ2SW9D/3ob+tfb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3utru6Ttkt6G/vU29K+3oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNfXdknbJb0N/ett6F9vQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK+v7ZK2S9429O9tQ//eNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6nl3y7JK3Df1729C/tw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmeXPLvkbUP/3jb0721D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/ZJc8uedvQv7cN/Xvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3ut7dsmzS9429O9tQ//eNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6xi4Zu2S2oX+zDf2bbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1jV0ydslsQ/9mG/o329A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7rG7tk7JLZhv7NNvRvtqF/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzXN3bJ2CWzDf2bbejfbEP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+nivb+ySsUtmG/o329DPbxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc5vd8n8dpfMbxv6+W1DP79t6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6v90l89tdMr9t6Oe3Df38tqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e6/x2l8xvd8n8tqGf3zb089uGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK/ze/4Dnv+Abejntw39/LahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3ut8u0vm210y3zb0821DP9829KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udb3fJfLtL5tuGfr5t6Ofbhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv8+0umW93yXzb0M+3Df1829CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdb72H9D+A7ahn28b+vm2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rfOM/YPwHbEM/3zb0821DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNcJuyTsktiGfmIb+olt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6YZeEXRLb0E9sQz+xDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/BeJ+ySsEtiG/qJbegntqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e64RdEnZJbEM/sQ39xDb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De520S9IuyW3oJ7ehn9yGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK+TdknaJbkN/eQ29JPb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du910i5JuyS3oZ/chn5yG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtolaZfkNvST29BPbkM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq810m7JO2S3IZ+chv6yW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zpll5RdUtvQT21DP7UN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F6n7JKyS2ob+qlt6Ke2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rlF1SdkltQz+1Df3UNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbJLyi6pbeintqGf2oZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r3PskmOXnG3o52xDP2cb+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3OsUuOXXK2oZ+zDf2cbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OscuOXbJ2YZ+zjb0c7ahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uscu+TYJWcb+jnb0M/Zhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXivc+ySY5ecbejnbEM/Zxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc61S65dcrehn7sN/dxt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c61y65dsndhn7uNvRzt6Ef3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e61y75Noldxv6udvQz92GfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK9z7ZJrl9xt6OduQz93G/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtslbZf0NvTT29BPb0M/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq812m7pO2S3oZ+ehv66W3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zptl7Rd0tvQT29DP70N/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F6n7ZK2S3ob+ult6Ke3oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rtF3SdklvQz+9Df30NvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWeXPLvkbUM/bxv6edvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73WeXfLskrcN/bxt6OdtQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXeXbJs0veNvTztqGftw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXufZJc8uedvQz9uGft429KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udZ5c8u2S2oZ/Zhn5mG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9ztglY5fMNvQz29DPbEM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81xm7ZOyS2YZ+Zhv6mW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zpjl4xdMtvQz2xDP7MN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F5n7JKxS2Yb+plt6Ge2oR/d6/Beh/c6vNfhvQ7vdXivw3ud9V7//yvOv13y9/n5DJ/p87+3/X0en9dn+3w+Zz//NfR/n/9drr/P/y7X36e/9u+W/H0en9dn+3w+vS28LbwtvC38tfDXwl8LbwtvC28Lb/u3S/4+P5+xL/7X0P991r44/bX0tvS29Lb0tvK28rbytvK28rby18pfK3+tvK287Xjb8bZ/u+TvM33WvvhfQ//3effFx1873na87Xrb9bbrbdfbrrddb7vedv21669df629rb2tva29rf0HtP+Afw3932fvi/819H+f/trztudtz9uetz1ve972vO152/O256+Nvzb+2njbeNt423jb+A8Y/wH/Gvq/z/n34u9fQ//3uX/tc0s+t2S917/P4/P6bJ/P575tvde/T3/t89fckvVe/z6Pz+uzfT6f+x/wxV6uL/ZyfbGX63NLPrfkc0vWe/379LbwtvC29Lb0tvS29NfSX3NL1nv9+/S29Lb0tvr5/Hzu5fpqL9dXe7k+t+RzSz63ZL3Xv09vO952vO142/G2423HXzv+mluy3uvfp7ddb7vedsNn+tzL9d29XN/dy/W5JZ9b8rkl673+fXpbe1t7W3tbe1t7W/tr7a+5Jeu9/n162/O2523Pf8DzH/D2cn1vL9f39nJ9bsnnlnxuyXqvf5/eNt423jbeNt423maXhF0Sbsl6r3+f6bN8Hp/XZ/vcyxW/vVzx7eUKtyTcknBLwi4JuyTskrBLwi4JuyTskrBLwi4Jt2S9179Pb7NLwi4JuyTsksi9XJF7uSL3coVbEm5JuCVhl4RdEnZJ2CVhl4RdEnZJ2CVhl4Rbst7r36e32SVhl4RdEnZJnL1ccfZyxdnLFW5JuCXhloRdEnZJ2CVhl4RdEnZJ2CVhl4RdEm7Jeq9/n95ml4RdEnZJ2CXRe7mi93JF7+UKtyTcknBLwi4JuyTskrBLwi4JuyTskrBLwi4Jt2S9179Pb7NLwi4JuyTskpi9XDF7uWL2coVbkm5JuiVpl6RdknZJ2iVpl6RdknZJ2iVpl6Rbst7r32f6LJ/H5/XZPvdy5beXK2MvV7ol6ZakW5J2SdolaZekXZJ2SdolaZekXZJ2Sbol673+fXqbXZJ2SdolaZdk7eXK2suVtZcr3ZJ0S9ItSbsk7ZK0S9IuSbsk7ZK0S9IuSbsk3ZL1Xv8+vc0uSbsk7ZK0S/Lu5cq7lyvvXq50S9ItSbck7ZK0S9IuSbsk7ZK0S9IuSbsk7ZJ0S9Z7/fv0Nrsk7ZK0S9IuybeXK99ernx7udItSbck3ZK0S9IuSbsk7ZK0S9IuSbsk7ZK0S9ItWe/17/PzGT7TZ/k8Pvdy1W8vV/32cpVbUm5JuSVll5RdUnZJ2SVll5RdUnZJ2SVll5Rbst7r36e32SVll5RdUnZJxV6uir1clXu5yi0pt6TckrJLyi4pu6TskrJLyi4pu6TskrJLyi1Z7/Xv09vskrJLyi4pu6TOXq46e7nq7OUqt6TcknJLyi4pu6TskrJLyi4pu6TskrJLyi4pt2S9179Pb7NLyi4pu6Tskuq9XNV7uar3cpVbUm5JuSVll5RdUnZJ2SVll5RdUnZJ2SVll5Rbst7r36e32SVll5RdUnZJzV6umr1cNXu5yi0pt6TckmOXHLvk2CXHLjl2ybFLjl1y7JJjlxy3ZL3Xv8/PZ/hMn+Xz+NzLdb69XOfby3XckuOWHLfk2CXHLjl2ybFLjl1y7JJjlxy75Nglxy1Z7/Xv09vskmOXHLvk2CUn93Kd3Mt1ai/XcUuOW3LckmOXHLvk2CXHLjl2ybFLjl1y7JJjlxy3ZL3Xv09vs0uOXXLskmOXnLuX69y9XOfu5TpuyXFLjlty7JJjlxy75Nglxy45dsmxS45dcuyS45as9/r36W12ybFLjl1y7JLz9nKdt5frvL1cxy05bslxS45dcuySY5ccu+TYJccuOXbJsUuOXXLckvVe/z73bdcuuXbJtUuuXXJ/e7nuby/X/e3lum7JdUuuW3LtkmuXXLvk2iXXLrl2ybVLrl1y7ZLrlqz3+vfpbXbJtUuuXXLtkht7uW7s5bqxl+u6JdctuW7JtUuuXXLtkmuXXLvk2iXXLrl2ybVLrluy3uvfp7fZJdcuuXbJtUtu7eW6tZfrnr1c1y25bsl1S65dcu2Sa5dcu+TaJdcuuXbJtUuuXXLdkvVe/z69zS65dsm1S65dcnsv1+29XLf3cl235Lol1y25dsm1S65dcu2Sa5dcu+TaJdcuuXbJdUvWe/379Da75Nol1y65dsmdvVx39nLd2ct13ZLrlly35Nol1y5pu6TtkrZL2i5pu6TtkrZL2i1pvwm334TbLmm7pO2Stkv628vV316u/vZytVvSbkm7JW2XtF3SdknbJW2XtF3SdknbJW2XtFvSfhNuvwm3XdJ2SdslbZd07uXq3MvVuZer3ZJ2S9otabuk7ZK2S9ouabuk7ZK2S9ouabuk3ZL2m3D7TbjtkrZL2i5pu6TPXq4+e7n67uVqt6TdknZL2i5pu6TtkrZL2i5pu6TtkrZL2i5pt6T9Jtx+E267pO2StkvaLum3l6vfXq5+e7naLWm3pN2StkvaLmm7pO2StkvaLmm7pO2StkvaLWm/CbffhNsuabvk2SXPLnm/vVzvt5fr/fZyPbfkuSXPLXl2ybNLnl3y7JJnlzy75Nklzy55dslzS57fhJ/fhJ9d8uySZ5c8u+TFXq4Xe7le7OV6bslzS55b8uySZ5c8u+TZJc8ueXbJs0ueXfLskueWPL8JP78JP7vk2SXPLnl2yau9XK/2cr3ay/XckueWPLfk2SXPLnl2ybNLnl3y7JJnlzy75Nklzy15fhN+fhN+dsmzS55d8uySd/dyvbuX6/VerueWPLfkuSXPLnl2ybNLnl3y7JJnlzy75Nklzy55bsnzm/Dzm/CzS55d8uySZ5e82cv1Zi/Xm71czy15bslzS55d8uySZ5c8u2TskrFLxi4Zu2TsknFLxm/C4zfhsUvGLhm7ZOyS+fZyzbeXa769XOOWjFsybsnYJWOXjF0ydsnYJWOXjF0ydsnYJeOWjN+Ex2/CY5eMXTJ2ydglk3u5JvdyTe7lGrdk3JJxS8YuGbtk7JKxS8YuGbtk7JKxS8YuGbdk/CY8fhMeu2TskrFLxi6Zs5drzl6uOXu5xi0Zt2TckrFLxi4Zu2TskrFLxi4Zu2TskrFLxi0ZvwmP34THLhm7ZOySsUum93JN7+Wat5dr3JJxS8YtGbtk7JKxS8YuGbtk7JKxS8YuGbtk3JLxm/D4TXjskrFLxi6Z3SXf719D//f573J9v38N/d/nv7/2rff693l8Xp/t8/mc/dxd8q33+vcZPv21z1/7/LX9Tfhb7/Xv8/n0tt0l3293yff719D/fea++F9D//fpr4W3hbeFt4W3pbelt6W3pbelt6W/lv5a+mvpbelt5W3lbbtLvt/uku/3r6H/+zz74n8N/d+nv1beVt52vO142/G2423H2463HW87/trx146/dr3tetv1tuttu0u+3+6S7/evof/77H3xv4b+79Nfa29rb2tva29rb2tva29rb2tva3/t+WvPX3ve9rztedvztuc/4PkP+NfQ/33OvvhfQ//36a+Nt423jbeNt423jbeNt+0u+dZ7/fv8fIbP9LlvW+/17/P6bJ/P5/4HfNvQf9829N+3Df2ne/0+t+RzS9Z7/ftsn8+nt4W3hbeFt4W/Fv6aW7Le69+nt4W3hbftLvm+3SXftw39921D/33b0H+61+9zSz63ZL3Xv09vK28rbytvK28rbyt/rfw1t2S9179Pbzvedrxtd8n37S75vm3ov28b+u/bhv7TvX6fW/K5Jeu9/n162/W2623X2663XW+7/tr119yS9V7/Pr2tva29rf0HtP+Abei/bxv679uG/tO9fp9b8rkl673+fXrb87bnbc/bnrc9b3v+2vhrbsl6r3+f3jbeNt42/gPGf8A29N+3Df0X29B/utcv3JJwS8IuCbsk7JKwS8IuCbsk7BLd66d7/XSv33qvf5/H5/XZPp/P/Q+Ibei/2Ib+i23oP93rF25JuCVhl4RdEnZJ2CVhl4RdEnaJ7vXTvX6612+9179Pb7NLwi4JuyTsktiG/ott6L/Yhv7TvX7hloRbEnZJ2CVhl4RdEnZJ2CVhl+heP93rp3v91nv9+/Q2uyTskrBLwi6Jbei/2Ib+i23oP93rF25JuCVhl4RdEnZJ2CVhl4RdEnaJ7vXTvX6612+9179Pb7NLwi4JuyTsktiG/ott6L/Yhv7TvX7hloRbEnZJ2CVhl4RdEnZJ2CVhl+heP93rp3v91nv9+0yf5fP4vD7b516u3Ib+y23oP93rl25JuiVpl6RdknZJ2iVpl6RdknaJ7vXTvX6612+9179Pb7NL0i5JuyTtktyG/stt6L/chv7TvX7plqRbknZJ2iVpl6RdknZJ2iVpl+heP93rp3v91nv9+/Q2uyTtkrRL0i7Jbei/3Ib+y23oP93rl25JuiVpl6RdknZJ2iVpl6RdknaJ7vXTvX6612+9179Pb7NL0i5JuyTtktyG/stt6L/chv7TvX7plqRbknZJ2iVpl6RdknZJ2iVpl+heP93rp3v91nv9+/Q2uyTtkrRL0i7Jbei/3Ib+y23oP93rV25JuSVll5RdUnZJ2SVll5RdUnaJ7vXTvX6612+917/P9Fk+j8/rs33u5apt6L/ahv7TvX7llpRbUnZJ2SVll5RdUnZJ2SVll+heP93rp3v91nv9+/Q2u6TskrJLyi6pbei/2ob+q23oP93rV25JuSVll5RdUnZJ2SVll5RdUnaJ7vXTvX6612+9179Pb7NLyi4pu6TsktqG/qtt6L/ahv7TvX7llpRbUnZJ2SVll5RdUnZJ2SVll+heP93rp3v91nv9+/Q2u6TskrJLyi6pbei/2ob+q23oP93rV25JuSVll5RdUnZJ2SVll5RdUnaJ7vXTvX6612+917/Pz2f4TJ/l8/jcy3W2of/ONvSf7vU7bslxS45dcuySY5ccu+TYJccuOXaJ7vXTvX6612+9179Pb7NLjl1y7JJjl5xt6L+zDf13tqH/dK/fcUuOW3LskmOXHLvk2CXHLjl2ybFLdK+f7vXTvX7rvf59eptdcuySY5ccu+RsQ/+dbei/sw39p3v9jlty3JJjlxy75Nglxy45dsmxS45donv9dK+f7vVb7/Xv09vskmOXHLvk2CVnG/rvbEP/nW3oP93rd9yS45Ycu+TYJccuOXbJsUuOXXLsEt3rp3v9dK/feq9/n95mlxy75Nglxy4529B/Zxv672xD/+lev+OWHLfk2iXXLrl2ybVLrl1y7ZJrl+heP93rp3v91nv9+/x8hs/0WT6Pz71cdxv6725D/+lev+uWXLfk2iXXLrl2ybVLrl1y7ZJrl+heP93rp3v91nv9+/Q2u+TaJdcuuXbJ3Yb+u9vQf3cb+k/3+l235Lol1y65dsm1S65dcu2Sa5dcu0T3+uleP93rt97r36e32SXXLrl2ybVL7jb0392G/rvb0H+61++6JdctuXbJtUuuXXLtkmuXXLvk2iW610/3+ulev/Ve/z69zS65dsm1S65dcreh/+429N/dhv7TvX7XLbluybVLrl1y7ZJrl1y75Nol1y7RvX6610/3+q33+ve5b2u7pO2StkvaLult6L/ehv7rbeg/3evXbkm7JW2XtF3SdknbJW2XtF3Sdonu9dO9frrXr/0m3H4Tbruk7ZK2S9ou6W3ov96G/utt6D/d69duSbslbZe0XdJ2SdslbZe0XdJ2ie71071+utev/SbcfhNuu6TtkrZL2i7pbei/3ob+623oP93r125JuyVtl7Rd0nZJ2yVtl7Rd0naJ7vXTvX6616/9Jtx+E267pO2StkvaLult6L/ehv7rbeg/3evXbkm7JW2XtF3SdknbJW2XtF3Sdonu9dO9frrXr/0m3H4Tbruk7ZK2S9ou6W3ov96G/utt6D/d69duSbslbZe0XfLskmeXPLvk2SXPLtG9frrXT/f6Pb8JP78JP7vk2SXPLnl2yduG/nvb0H9vG/pP9/o9t+S5Jc8ueXbJs0ueXfLskmeXPLtE9/rpXj/d6/f8Jvz8JvzskmeXPLvk2SVvG/rvbUP/vW3oP93r99yS55Y8u+TZJc8ueXbJs0ueXfLsEt3rp3v9dK/f85vw85vws0ueXfLskmeXvG3ov7cN/fe2of90r99zS55b8uySZ5c8u+TZJc8ueXbJs0t0r5/u9dO9fs9vws9vws8ueXbJs0ueXfK2of/eNvTf24b+071+zy15bsmzS55d8uySZ5c8u+TZJc8u0b1+utdP9/o9vwk/vwk/u+TZJWOXjF0y29B/sw39N9vQf7rXb9yScUvGLhm7ZOySsUvGLhm7ZOwS3eune/10r9/4TXj8Jjx2ydglY5eMXTLb0H+zDf0329B/utdv3JJxS8YuGbtk7JKxS8YuGbtk7BLd66d7/XSv3/hNePwmPHbJ2CVjl4xdMtvQf7MN/Tfb0H+612/cknFLxi4Zu2TskrFLxi4Zu2TsEt3rp3v9dK/f+E14/CY8dsnYJWOXjF0y29B/sw39N9vQf7rXb9yScUvGLhm7ZOySsUvGLhm7ZOwS3eune/10r9/4TXj8Jjx2ydglY5eMXTLb0H+zDf0329B/utdv3JJxS8YuGbtk7BLea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3Gr/dJfHbXRK/bejjtw19/LahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mv8dpfEb3dJ/Lahj9829PHbhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXiv8dtdEr/dJfHbhj5+29DHbxv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvcav/Qe0/4Bt6OO3DX38tqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea/zGf8Dukvi2oY9vG/r4tqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea3y7S+LbXRLfNvTxbUMf3zb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be41vd0l8u0vi24Y+vm3o49uGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK/x7S6Jb3dJfNvQx7cNfXzb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81vuc/4PkP2IY+vm3o49uGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8RdknYJbENfcQ29BHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81wi4JuyS2oY/Yhj5iG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9RtglYZfENvQR29BHbEMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81wi7JOyS2IY+Yhv6iG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xphl4RdEtvQR2xDH7kNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F4j7ZK0S3Ib+sht6CO3oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rpF2SdkluQx+5DX3kNvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbRL0i7Jbegjt6GP3IY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r5F2SdoluQ195Db0kdvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXKLim7pLahj9qGPmob+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2SVll9Q29FHb0EdtQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXKLuk7JLahj5qG/qobehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GmWXlF1S29BHbUMftQ196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXqPskrJLahv6qG3oo7ahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mscu+TYJWcb+jjb0MfZhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivceySY5ecbejjbEMfZxv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvcaxS45dcrahj7MNfZxt6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/caxy45dsnZhj7ONvRxtqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea1y75Noldxv6uNvQx92GPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK9x7ZJrl9xt6ONuQx93G/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xrVLrl1yt6GPuw193G3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xrXLrl2yd2GPu429HG3oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rXLvk2iV3G/q429DH3YY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r9F2SdslvQ199Db00dvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXaLmm7pLehj96GPnob+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2yVtl/Q29NHb0EdvQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXaLuk7ZLehj56G/robehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3Gs8ueXbJ24Y+3jb08bahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3ms8u+TZJW8b+njb0Mfbhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXiv8eySZ5e8bejjbUMfbxv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvcazS55d8rahj7cNfbxt6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/cazy55dsnbhj7eNvTxtqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea4xdMnbJbEMfsw19zDb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42xS8YumW3oY7ahj9mGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8xdsnYJbMNfcw29DHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81xi4Zu2S2oY/Zhj5mG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C95m93Sf52l+RvG/r8bUOfv23oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95q/3SX5212Sv23o87cNff62oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5r/naX5G93Sf62oc/fNvT524Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/nbXZK/3SX524Y+f9vQ528b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3m7/kPeP4DtqHP3zb0+duGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea/57S7Jb3dJftvQ57cNfX7b0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81v90l+e0uyW8b+vy2oc9vG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S95re7JL/dJfltQ5/fNvT5bUOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q81/zaf0D7D9iGPr9t6PPbhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmv+Y3/ALsktqHP2IY+Yxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/f6/8/n09vskrBLYhv6jG3oM7ahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3muGXRJ2SWxDn7ENfcY29Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNsEvCLolt6DO2oc/Yhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvGXZJ2CWxDX3GNvQZ29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNdMuSbskt6HP3IY+cxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvWbaJWmX5Db0mdvQZ25Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNdMuyTtktyGPnMb+sxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaaZekXZLb0GduQ5+5DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/JeM+2StEtyG/rMbeiztqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea5ZdUnZJbUOftQ191jb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82yS8ouqW3os7ahz9qGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea9ZdknZJbUNfdY29Fnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81yy4pu6S2oc/ahj5rG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S95rFLjl1ytqHPsw19nm3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95rHLjl2ydmGPs829Hm2oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rHrvk2CVnG/o829Dn2YY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r3nskmOXnG3o82xDn2cb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3msUuOXXK2oc+zDX2ebehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mtcuuXbJ3YY+7zb0ebehT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mteu+TaJXcb+rzb0Ofdhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvee2Sa5fcbejzbkOfdxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvea1S65dcrehz7sNfd5t6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eabZe0XdLb0GdvQ5+9DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Jes+2Stkt6G/rsbeizt6FP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea7Zd0nZJb0OfvQ199jb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je822S9ou6W3os7ehz96GPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea/ZdknbJb0NffY29Nnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81n13y7JK3DX2+bejzbUOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q813x2ybNL3jb0+bahz7cNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7z2SXPLnnb0Ofbhj7fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zWeXPLvkbUOfbxv6fNvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXHLhm7ZLahz9mGPmcb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3m2CVjl8w29Dnb0OdsQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXHLtk7JLZhj5nG/qcbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mmOXjF0y29DnbEOfsw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXnPskrFLZhv6nG3oc7ahT91r8l6T95q81+S9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3mv9dpfUb3dJ/bahr9829PXbhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXiv9dtdUr/dJfXbhr5+29DXbxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdZvd0n9dpfUbxv6+m1DX79t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/dav/Yf0P4DtqGv3zb09duGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/17S6pb3dJfdvQ17cNfX3b0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1vt0l9e0uqW8b+vq2oa9vG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91re7pL7dJfVtQ1/fNvT1bUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81/p2l9S3u6S+bejr24a+vm3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rf8x/w/AdsQ1/fNvT1bUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81wq7JOyS2Ia+Yhv6im3oS/davNfivVbYJbzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe62wS8IuiW3oK7ahr9iGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK8VdknYJbENfcU29BXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1wi4JuyS2oa/Yhr5iG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtglYZfkNvSV29BXbkNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q810q7JO2S3Ia+chv6ym3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91ppl6RdktvQV25DX7kNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V4r7ZK0S3Ib+spt6Cu3oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rpV2SdkluQ1+5DX3lNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbJLyi6pbeirtqGv2oa+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r1V2SdkltQ191Tb0VdvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XKLim7pLahr9qGvmob+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r1W2SVll9Q29FXb0FdtQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXKruk7JLahr5qG/o629CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtY5dcuySsw19nW3o62xDX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNc6dsmxS8429HW2oa+zDX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/Fe69glxy4529DX2Ya+zjb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe61jlxy75GxDX2cb+jrb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1rl1y7ZK7DX3dbejrbkNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q817p2ybVL7jb0dbehr7sNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V7r2iXXLrnb0Nfdhr7uNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rWuXXLvkbkNfdxv6utvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77WuXXLtkrsNfd1t6OtuQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXaruk7ZLehr56G/rqbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Wm2XtF3S29BXb0NfvQ196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXqvtkrZLehv66m3oq7ehL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3mu1XdJ2SW9DX70NffU29KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3e6/+IuJcbSXYkioIqZZD0n/6KzStg2m0XuwYX6bjoOrCne32616d7fbzXx3t9vNfHe31tl7Rd0tvQv96G/vU29E/3+nivj/f6eK+P9/p4r4/3+nivj/f6eK9P9/p0r0/3+nivj/f6eK+P9/raLmm7pLehf70N/ett6J/u9fFeH+/18V4f7/XxXh/v9fFeH+/18V6f7vXpXp/u9fFeH+/18V4f7/W1XdJ2SW9D/3ob+tfb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3utru6Ttkt6G/vU29K+3oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNfXdknbJb0N/ett6F9vQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK9v7JKxS2Yb+jfb0L/Zhv7pXh/v9fFeH+/18V4f7/XxXh/v9fFeH+/16V6f7vXpXh/v9fFeH+/18V7f2CVjl8w29G+2oX+zDf3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+sUvGLplt6N9sQ/9mG/qne32818d7fbzXx3t9vNfHe32818d7fbzXp3t9utene32818d7fbzXx3t9Y5eMXTLb0L/Zhv7NNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3GrzX4L3Gb3dJ/HaXxG8b+vhtQx+/behD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3Gr/dJfHbXRK/bejjtw19/LahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mv8dpfEb3dJ/Lahj9829PHbhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXiv8dtdEr/0C9iGPn7b0MdvG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xm/8AsYvYBv6+G1DH79t6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/ca3+6S+HaXxLcNfXzb0Me3DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be49tdEt/ukvi2oY9vG/r4tqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea3y7S+LbXRLfNvTxbUMf3zb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42v/ALKL2Ab+vi2oY9vG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xrFLjl1ytqGPsw19nG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xrHLjl2ydmGPs429HG2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rHLvk2CVnG/o429DH2YY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r3HskmOXnG3o42xDH2cb+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L3GsUuOXXK2oY+zDX2cbehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GtcuuXbJ3YY+7jb0cbehD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mtcu+TaJXcb+rjb0Mfdhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivce2Sa5fcbejjbkMfdxv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvca1S65dcrehj7sNfdxt6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/ca1y65dsnbhj7eNvTxtqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3eazy75Nklbxv6eNvQx9uGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK/x7JJnl7xt6ONtQx9vG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xrNLnl3ytqGPtw19vG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xrPLnl2yduGPt429PG2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rhF0SdklsQx+xDX3ENvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbBLwi6JbegjtqGP2IY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4rxF2SdglsQ19xDb0EdvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXCLgm7JLahj9iGPmIb+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2CVhl8Q29BHb0EduQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXSLsk7ZLchj5yG/rIbehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GmmXpF2S29BHbkMfuQ196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXiPtkrRLchv6yG3oI7ehD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mukXZJ2SW5DH7kNfeQ29KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNskvKLqlt6KO2oY/ahj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivUXZJ2SW1DX3UNvRR29CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNcouKbuktqGP2oY+ahv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvUbZJWWX1Db0UdvQR21DH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNcou6TsktqGPmob+qht6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/cabZe0XdLb0EdvQx+9DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Beo+2Stkt6G/robeijt6EP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea7Rd0nZJb0MfvQ199Db0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be422S9ou6W3oo7ehj96GPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8xdsnYJbMNfcw29DHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81xi4Zu2S2oY/Zhj5mG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xtglY5fMNvQx29DHbEMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81xi7ZOyS2YY+Zhv6mG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xpjl4xdMtvQx2xDH7MNfeheg/cavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7zt7skf7tL8rcNff62oc/fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zd/ukvztLsnfNvT524Y+f9vQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zV/u0vyt7skf9vQ528b+vxtQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzX/LVfQPsFbEOfv23o87cNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7z212S3+6S/Lahz28b+vy2oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rfrtL8ttdkt829PltQ5/fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zW93SX67S/Lbhj6/bejz24Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/ntLskv/QK2oc9vG/r8tqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea37jFzB+AdvQ57cNfX7b0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81j11y7JKzDX2ebejzbEOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q81zx2ybFLzjb0ebahz7MNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7z2CXHLjnb0OfZhj7PNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zWOXHLvkbEOfZxv6PNvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zWvXXLtkrsNfd5t6PNuQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXvHbJtUvuNvR5t6HPuw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXvPaJdcuudvQ592GPu829Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNa5dcu+RuQ593G/q829Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNa9dcu2Suw193m3o825Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNd8dsmzS9429Pm2oc+3DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Je89klzy5529Dn24Y+3zb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je81nlzy75G1Dn28b+nzb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81n13y7JK3DX2+bejzbUOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q813x2ybNLYhv6jG3oM7ahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3muGXRJ2SWxDn7ENfcY29Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNsEvCLolt6DO2oc/Yhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvGXZJ2CWxDX3GNvQZ29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNcMuCbsktqHP2IY+Yxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvWbaJWmX5Db0mdvQZ25Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNdMuyTtktyGPnMb+sxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaaZekXZLb0GduQ5+5DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/JeM+2StEtyG/rMbegzt6FP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea6ZdknZJbkOfuQ191jb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82yS8ouqW3os7ahz9qGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea9ZdknZJbUNfdY29Fnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81yy4pu6S2oc/ahj5rG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S9ZtklZZfUNvRZ29BnbUOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q812y7pO2S3oY+exv67G3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95ptl7Rd0tvQZ29Dn70Nfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l6z7ZK2S3ob+uxt6LO3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rtl3SdklvQ5+9DX32NvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zbZL2i7pbeizt6HP3oY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5rzl2ydglsw19zjb0OdvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXHLhm7ZLahz9mGPmcb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3m2CVjl8w29Dnb0OdsQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXHLtk7JLZhj5nG/qcbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvxXst3mvxXov3Wr/dJfXbXVK/bejrtw19/bahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3mv9dpfUb3dJ/bahr9829PXbhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXiv9dtdUr/dJfXbhr5+29DXbxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdav/ALKL2Ab+vptQ1+/behL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Wr/xCxi/gG3o67cNff22oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rfbtL6ttdUt829PVtQ1/fNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rW93SX27S+rbhr6+bejr24a+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r/XtLqlvd0l929DXtw19fdvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77W+9gtov4Bt6Ovbhr6+behL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WscuOXbJ2Ya+zjb0dbahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3msdu+TYJWcb+jrb0NfZhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivdeySY5ecbejrbENfZxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdaxS45dcrahr7MNfZ1t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/daxy45dsnZhr7ONvR1tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea1275Noldxv6utvQ192GvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK917ZJrl9xt6OtuQ193G/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91rVLrl1yt6Gvuw193W3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rXLrl2yd2Gvu429HW3oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rPbvk2SVvG/p629DX24a+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r/XskmeXvG3o621DX28b+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r3Ws0ueXfK2oa+3DX29behL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Ws8ueXbJ24a+3jb09bahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3ms9u+TZJW8b+nrb0Nfbhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivFXZJ2CWxDX3FNvQV29CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtcIuCbsktqGv2Ia+Yhv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivVbYJWGXxDb0FdvQV2xDX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNcKuyTsktiGvmIb+opt6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/daYZeEXZLb0FduQ1+5DX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/FeK+2StEtyG/rKbegrt6Ev3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea6VdknZJbkNfuQ195Tb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe620S9IuyW3oK7ehr9yGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK+VdknaJbkNfeU29JXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1yi4pu6S2oa/ahr5qG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtklZZfUNvRV29BXbUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81yq7pOyS2oa+ahv6qm3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91pll5RdUtvQV21DX7UNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V6r7JKyS2ob+qpt6Ku3oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rtV3SdklvQ1+9DX31NvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbZL2i7pbeirt6Gv3oa+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r9V2SdslvQ199Tb01dvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XaLmm7pLehr96Gvnob+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r3W2CVjl8w29DXb0NdsQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXGrtk7JLZhr5mG/qabehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WmOXjF0y29DXbENfsw196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXmvskrFLZhv6mm3oa7ahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3muNXTJ2yWxDX7MNfc029KV7bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvt3+6S/u0u6d829P3bhr5/29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtX+7S/q3u6R/29D3bxv6/m1D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNf+7S7p3+6S/m1D379t6Pu3DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9d+Ae0XsA19/7ah79829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtb3dJf7tL+tuGvr9t6Pvbhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv/e0u6W93SX/b0Pe3DX1/29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtb/dJf3tLulvG/r+tqHvbxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfZXfgHlF7ANfX/b0Pe3DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+xu/gPEL2Ia+v23o+9uGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea997JJjl5xt6PtsQ99nG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99rFLjl1ytqHvsw19n23oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99rHLjl2ydmGvs829H22oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rH7vk2CVnG/o+29D32Ya+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r33tkmuX3G3o+25D33cb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r32tUuuXXK3oe+7DX3fbehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32tcuuXbJ3Ya+7zb0fbehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mtfu+TaJXcb+r7b0Pfdhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvfe2Sa5fcbej7bkPfdxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfazS55d8rah77cNfb9t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fazy55dsnbhr7fNvT9tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23eaz+75Nklbxv6ftvQ99uGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/97JJnl7xt6P/73Mv1tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea4ddEnZJbEPfsQ19xzb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+2wS8IuiW3oO7ah79iGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea8ddknYJbENfcc29B3b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1wy4JuyS2oe/Yhr5jG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a9dtglYZfENvQd29B3bEPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81067JO2S3Ia+cxv6zm3oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99ppl6RdktvQd25D37kNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81477ZK0S3Ib+s5t6Du3oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rp12SdkluQ9+5DX3nNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177bRL0i6pbei7tqHv2oa+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r112SdkltQ191zb0XdvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277XLLim7pLah79qGvmsb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122SVll9Q29F3b0HdtQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXLruk7JLahr5rG/qubehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32m2XtF3S29B3b0PfvQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXrvtkrZLehv67m3ou7ehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mu3XdJ2SW9D370Nffc29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvttkvaLult6Lu3oe/ehr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv3XZJ2yW9DX33NvQ929C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtccuGbtktqHv2Ya+Zxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfbYJWOXzDb0PdvQ92xD37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNceu2TsktmGvmcb+p5t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/faY5eMXTLb0PdsQ9+zDX3rXpv32rzX5r0277V5r817bd5r816b99q619G9ju51eK/Dex3e6/Be57e7ZH67S+a3Df38tqGf3zb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De53f7pL57S6Z3zb089uGfn7b0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91frtL5re7ZH7b0M9vG/r5bUM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81/mVX0D5BWxDP79t6Oe3Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be5zd+AeMXsA39/Lahn9829KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udb3fJfLtL5tuGfr5t6Ofbhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv8+0umW93yXzb0M+3Df1829CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdb7dJfPtLplvG/r5tqGfbxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc7XfgHtF7AN/Xzb0M+3Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be59glxy4529DP2YZ+zjb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De51jlxy75GxDP2cb+jnb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91jl1y7JKzDf2cbejnbEM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81zl2ybFLzjb0c7ahn7MN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F7n2CXHLjnb0M/Zhn7ONvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWuXXLvkbkM/dxv6udvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73WuXXLtkrsN/dxt6OduQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXuXbJtUvuNvRzt6Gfuw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXufaJdcuudvQz92Gfu429KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udZ5c8u+RtQz9vG/p529CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdZ5d8uyStw39vG3o521DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNd5dsmzS9429PO2oZ+3Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be59klzy5529DP24Z+3jb0o3sd3uvwXof3OrzX4b0O73V4r/PsEt7r6F5H9zq61+G9Du91eK/De51nlzy75G1DP28b+nnb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91wi4JuyS2oZ/Yhn5iG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtglYZfENvQT29BPbEM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81wm7JOyS2IZ+Yhv6iW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zphl4RdEtvQT2xDP7EN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F4n7ZK0S3Ib+slt6Ce3oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rpF2SdkluQz+5Df3kNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbRL0i7Jbegnt6Gf3IZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r5N2SdoluQ395Db0k9vQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XSLkm7JLehn9yGfnIb+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b1O2SVll9Q29FPb0E9tQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXKbuk7JLahn5qG/qpbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OmWXlF1S29BPbUM/tQ396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXqfskrJLahv6qW3op7ahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uuUXVJ2SW9DP70N/fQ29KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udtkvaLult6Ke3oZ/ehn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv03ZJ2yW9Df30NvTT29CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vddouabukt6Gf3oZ+ehv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvU7bJW2X9Db009vQT29DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNcZu2TsktmGfmYb+plt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6Y5eMXTLb0M9sQz+zDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/BeZ+ySsUtmG/qZbehntqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e64xdMnbJbEM/sw39zDb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De52xS8YumW3oZ/419P/9z+u/hv7v8///2t/n8Xl9Pp/hM32Wz/Y5+/lvl/x9+tc+/9rnX/v3N+G/z/CZPstn+5z9/NfQ/31+++J/Df3fp3/teNvxtuNtx9uOtx1vu952ve162/WvXf/a9a9db7vedr3tetu/XfL3+fk8++J/Df3f59sXP//a87bnbc/bnreFt4W3hbeFt4W3hX8t/GvhXwtvC29Lb0tv+7dL/j6vz7cv/tfQ/33mvjj9a+lt6W3lbeVt5W3lbeVt5W3lbeVfK/9a+dfa29rb2tva29ovoP0C/jX0f5+1L/7X0P99+tfG28bbxtvG28bbxtvG28bbxttm/7XtXv8+P5/7tvVe/z6fz/CZPstn/3vx99vL9X17uT635HNLPrdkvde/z/CZPstn+/S2423Hv3b8a27Jeq9/n952vO1422mf+wv47l6u7+7l+u5ers8t+dySzy1Z7/Xv09uut11ve972vO152/OvPf+aW7Le69+ntz1ve94WP5+fz71cX+zl+mIv1+eWfG7J55as9/r36W3pbelt6W3pbelt6V9L/5pbst7r36e3lbeVt5VfQPkF1F6ur/ZyfbWX63NLPrfkc0vWe/379Lb2tva29rb2tva29q+1f80tWe/179PbxtvG28YvYPwCZi/XN3u5vtnL9bklxy05bsmxS45dcuySY5ccu+TYJccuOXbJsUuOW7Le69/n9fl8hs/0WT73cp1vL9c5e7mOW3LckuOWHLvk2CXHLjl2ybFLjl1y7JJjlxy75Lgl673+fXqbXXLskmOXHLvkvL1c5+3lOm8v13FLjlty3JJjlxy75Nglxy45dsmxS45dcuySY5cct2S9179Pb7NLjl1y7JJjl5zcy3VyL9fJvVzHLTluyXFLjl1y7JJjlxy75Nglxy45dsmxS45dctyS9V7/Pr3NLjl2ybFLjl1yei/X6b1cp/dyHbfkuCXHLTl2ybFLjl1y7JJjlxy75Nglxy45dslxS9Z7/fv8fB6f1+fzGT73ct3fXq7728t13ZLrlly35Nol1y65dsm1S65dcu2Sa5dcu+TaJdctWe/179Pb7JJrl1y75Nol9+zlumcv1717ua5bct2S65Zcu+TaJdcuuXbJtUuuXXLtkmuXXLvkuiXrvf59eptdcu2Sa5dcu+TGXq4be7lu7OW6bsl1S65bcu2Sa5dcu+TaJdcuuXbJtUuuXXLtkuuWrPf69+ltdsm1S65dcu2SW3u5bu3lurWX67ol1y25bsm1S65dcu2Sa5dcu+TaJdcuuXbJtUuuW7Le69+nt9kl1y65dsm1S+7s5bqzl+vOXq7rlly35Lolzy55dsmzS55d8uySZ5c8u+TZJc8ueW7Jeq9/n5/P4/P6fD7D516u9+3let9erueWPLfkuSXPLnl2ybNLnl3y7JJnlzy75Nklzy55bsl6r3+f3maXPLvk2SXPLnl3L9e7e7ne28v13JLnljy35Nklzy55dsmzS55d8uySZ5c8u+TZJc8tWe/179Pb7JJnlzy75NklL/dyvdzL9XIv13NLnlvy3JJnlzy75Nklzy55dsmzS55d8uySZ5c8t2S9179Pb7NLnl3y7JJnl7zey/V6L9frvVzPLXluyXNLnl3y7JJnlzy75Nklzy55dsmzS55d8tyS9V7/PvdtYZeEXRJ2Sdgl8dvLFb+9XPHbyxVuSbgl4ZaEXRJ2SdglYZeEXRJ2SdglYZeEXRJuyXqvf5/eZpeEXRJ2SdglcfZyxdnLFWcvV7gl4ZaEWxJ2SdglYZeEXRJ2SdglYZeEXRJ2Sbgl673+fXqbXRJ2SdglYZfE28sVby9XxF6ucEvCLQm3JOySsEvCLgm7JOySsEvCLgm7JOyScEvWe/379Da7JOySsEvCLonayxW1lytqL1e4JeGWhFsSdknYJWGXhF0SdknYJWGXhF0Sdkm4Jeu9/n16m10SdknYJWGXxOzlitnLFbOXK9yScEvCLQm7JOyStEvSLkm7JO2StEvSLkm7JN2S9V7/PvdtaZekXZJ2Sdol+e3lym8vV357udItSbck3ZK0S9IuSbsk7ZK0S9IuSbsk7ZK0S9ItWe/179Pb7JK0S9IuSbsk716uvHu58u7lSrck3ZJ0S9IuSbsk7ZK0S9IuSbsk7ZK0S9IuSbdkvde/T2+zS9IuSbsk7ZKMvVwZe7ky93KlW5JuSbolaZekXZJ2SdolaZekXZJ2SdolaZekW7Le69+nt9klaZekXZJ2SfZeruy9XNl7udItSbck3ZK0S9IuSbsk7ZK0S9IuSbsk7ZK0S9ItWe/179Pb7JK0S8ouKbukfnu56reXq357ucotKbek3JKyS8ouKbuk7JKyS8ouKbuk7JKyS8otKX8TLn8TLruk7JKyS8ouqbOXq85erjp7ucotKbek3JKyS8ouKbuk7JKyS8ouKbuk7JKyS8otKX8TLn8TLruk7JKyS8ouqbeXq95ernp7ucotKbek3JKyS8ouKbuk7JKyS8ouKbuk7JKyS8otKX8TLn8TLruk7JKyS8ouqdzLVbmXq2ovV7kl5ZaUW1J2SdklZZeUXVJ2SdklZZeUXVJ2Sbkl5W/C5W/CZZeUXVJ2SdklNXu5avZy1ezlKrek3JJyS8ouKbuk7JKyS9ouabuk7ZK2S9ouabek/U24/U247ZK2S9ouabukv71c/e3l6m8vV7sl7Za0W9J2SdslbZe0XdJ2SdslbZe0XdJ2Sbsl7W/C7W/CbZe0XdJ2Sdslffdy9d3L1XcvV7sl7Za0W9J2SdslbZe0XdJ2SdslbZe0XdJ2Sbsl7W/C7W/CbZe0XdJ2SdslHXu5OvZydezlarek3ZJ2S9ouabuk7ZK2S9ouabuk7ZK2S9ouabek/U24/U247ZK2S9ouabukay9X116u7r1c7Za0W9JuSdslbZe0XdJ2SdslbZe0XdJ2Sdsl7Za0vwm3vwm3XdJ2SdslbZfMby/X/PZyzW8v17gl45aMWzJ2ydglY5eMXTJ2ydglY5eMXTJ2ybgl42/C42/CY5eMXTJ2ydglc/ZyzdnLNWcv17gl45aMWzJ2ydglY5eMXTJ2ydglY5eMXTJ2ybgl42/C42/CY5eMXTJ2ydgl8/ZyzdvLNW8v17gl45aMWzJ2ydglY5eMXTJ2ydglY5eMXTJ2ybgl42/C42/CY5eMXTJ2ydglk3u5JvdyTe7lGrdk3JJxS8YuGbtk7JKxS8YuGbtk7JKxS8YuGbdk/E14/E147JKxS8YuGbtkei/X9F6umb1c45aMWzJuydglY5eMXTJ2ydgl673+93+hu0s+3eune/10r996r3+f4TN9ls/2Ofv5r6H/+/x3ub7fv4b+79O/trfkW+/17zN9ls/26W3H2463HW87/rXjXzv+teNtx9uOtx1v213y/XaXfL9/Df3f590X/2vo/z79a9fbrrddb7ve9rztedvztudtz9uef+35155/7Xnb87bwtvC23SXfb3fJ9/vX0P99xr74X0P/9+lfC28Lb0tvS29Lb0tvS29Lb0tvS/9a+tfSv1beVt5W3lbeVn4B5Rfwr6H/+6x98b+G/u/Tv9be1t7W3tbe1t7W3tbe1t7W3tb+tfGvjX9tvG28bbxtvG38AsYv4F9D//f573J93zb0n+71+9ySzy1Z7/XvM3ymz/LZPvdt673+ffrXPv+aW7Le699n+Eyf5bN97i/g24b++7ah/75t6D/d6/e5JZ9bst7r36e3HW873na97Xrb9bbrX7v+Nbdkvde/T2+73na9bXfJ9+0u+b5t6L9vG/rv24b+071+n1vyuSXrvf59elt4W3hbeFt4W3hb+NfCv+aWrPf69+lt6W3pbbtLvm93yfdtQ/9929B/3zb0n+71+9ySzy1Z7/Xv09vK28rbytvK28rbyr9W/jW3ZL3Xv09va29rb2u/gPYL2Ib++7ah/75t6D/d6/e5JZ9bst7r36e3jbeNt423jbeNt9klutdP9/qt9/r3eX0+n+EzfZbPvVxnG/rvbEP/6V6/45Yct+TYJccuOXbJsUuOXXLskmOX6F4/3eune/3We/379Da75Nglxy45dsnZhv4729B/Zxv6T/f6HbfkuCXHLjl2ybFLjl1y7JJjlxy7RPf66V4/3eu33uvfp7fZJccuOXbJsUvONvTf2Yb+O9vQf7rX77glxy05dsmxS45dcuySY5ccu+TYJbrXT/f66V6/9V7/Pr3NLjl2ybFLjl1ytqH/zjb039mG/tO9fsctOW7JsUuOXXLskmOXHLvk2CXHLtG9frrXT/f6rff69+ltdsmxS45dcuySsw39d7ah/8429J/u9btuyXVLrl1y7ZJrl1y75Nol1y65donu9dO9frrXb73Xv8/r8/kMn+mzfO7lutvQf3cb+k/3+l235Lol1y65dsm1S65dcu2Sa5dcu0T3+uleP93rt97r36e32SXXLrl2ybVL7jb0392G/rvb0H+61++6JdctuXbJtUuuXXLtkmuXXLvk2iW610/3+ulev/Ve/z69zS65dsm1S65dcreh/+429N/dhv7TvX7XLbluybVLrl1y7ZJrl1y75Nol1y7RvX6610/3+q33+vfpbXbJtUuuXXLtkrsN/Xe3of/uNvSf7vW7bsl1S65dcu2Sa5dcu+TaJdcuuXaJ7vXTvX6612+917/Pz+fxeX0+n+FzL9fbhv5729B/utfvuSXPLXl2ybNLnl3y7JJnlzy75NklutdP9/rpXr/1Xv8+vc0ueXbJs0ueXfK2of/eNvTf24b+071+zy15bsmzS55d8uySZ5c8u+TZJc8u0b1+utdP9/qt9/r36W12ybNLnl3y7JK3Df33tqH/3jb0n+71e27Jc0ueXfLskmeXPLvk2SXPLnl2ie71071+utdvvde/T2+zS55d8uySZ5e8bei/tw3997ah/3Sv33NLnlvy7JJnlzy75Nklzy55dsmzS3Svn+71071+673+fXqbXfLskmeXPLvkbUP/vW3ov7cN/ad7/Z5b8tySsEvCLgm7JOySsEvCLgm7RPf66V4/3eu33uvf5+fz+Lw+n8/wuZcrtqH/Yhv6T/f6hVsSbknYJWGXhF0SdknYJWGXhF2ie/10r5/u9Vvv9e/T2+ySsEvCLgm7JLah/2Ib+i+2of90r1+4JeGWhF0SdknYJWGXhF0SdknYJbrXT/f66V6/9V7/Pr3NLgm7JOySsEtiG/ovtqH/Yhv6T/f6hVsSbknYJWGXhF0SdknYJWGXhF2ie/10r5/u9Vvv9e/T2+ySsEvCLgm7JLah/2Ib+i+2of90r1+4JeGWhF0SdknYJWGXhF0SdknYJbrXT/f66V6/9V7/PvdtaZekXZJ2SdoluQ39l9vQf7kN/ad7/dItSbck7ZK0S9IuSbsk7ZK0S9Iu0b1+utdP9/qt9/r36W12SdolaZekXZLb0H+5Df2X29B/utcv3ZJ0S9IuSbsk7ZK0S9IuSbsk7RLd66d7/XSv33qvf5/eZpekXZJ2SdoluQ39l9vQf7kN/ad7/dItSbck7ZK0S9IuSbsk7ZK0S9Iu0b1+utdP9/qt9/r36W12SdolaZekXZLb0H+5Df2X29B/utcv3ZJ0S9IuSbsk7ZK0S9IuSbsk7RLd66d7/XSv33qvf5/eZpekXZJ2SdoluQ39l9vQf7kN/ad7/dItSbck7ZK0S8ouKbuk7JKyS8ou0b1+utdP9/qVvwmXvwmXXVJ2SdklZZfUNvRfbUP/1Tb0n+71K7ek3JKyS8ouKbuk7JKyS8ouKbtE9/rpXj/d61f+Jlz+Jlx2SdklZZeUXVLb0H+1Df1X29B/utev3JJyS8ouKbuk7JKyS8ouKbuk7BLd66d7/XSvX/mbcPmbcNklZZeUXVJ2SW1D/9U29F9tQ//pXr9yS8otKbuk7JKyS8ouKbuk7JKyS3Svn+71071+5W/C5W/CZZeUXVJ2SdkltQ39V9vQf7UN/ad7/cotKbek7JKyS8ouKbuk7JKyS8ou0b1+utdP9/qVvwmXvwmXXVJ2SdslbZf0NvRfb0P/9Tb0n+71a7ek3ZK2S9ouabuk7ZK2S9ouabtE9/rpXj/d69f+Jtz+Jtx2SdslbZe0XdLb0H+9Df3X29B/utev3ZJ2S9ouabuk7ZK2S9ouabuk7RLd66d7/XSvX/ubcPubcNslbZe0XdJ2SW9D//U29F9vQ//pXr92S9otabuk7ZK2S9ouabuk7ZK2S3Svn+71071+7W/C7W/CbZe0XdJ2SdslvQ3919vQf70N/ad7/dotabek7ZK2S9ouabuk7ZK2S9ou0b1+utdP9/q1vwm3vwm3XdJ2SdslbZf0NvRfb0P/9Tb0n+71a7ek3ZK2S9ouabuk7ZKxS8YuGbtE9/rpXj/d6zf+Jjz+Jjx2ydglY5eMXTLb0H+zDf0329B/utdv3JJxS8YuGbtk7JKxS8YuGbtk7BLd66d7/XSv3/ib8Pib8NglY5eMXTJ2yWxD/8029N9sQ//pXr9xS8YtGbtk7JKxS8YuGbtk7JKxS3Svn+71071+42/C42/CY5eMXTJ2ydglsw39N9vQf7MN/ad7/cYtGbdk7JKxS8YuGbtk7JKxS8Yu0b1+utdP9/qNvwmPvwmPXTJ2ydglY5fMNvTfbEP/zTb0n+71G7dk3JKxS8YuGbtk7JKxS8YuGbtE9/rpXj/d6zf+Jjz+Jjx2ydglY5fM7pLz24b+/LahP79t6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/X8dpec3+6S89uG/vy2oT+/beiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1/HaXnN/ukvPbhv78tqE/v23oj+718F4P7/XwXg/v9fBeD+/18F4P7/XwXo/u9ehej+718F4P7/XwXg/v9fx2l5zf7pLz24b+/LahP79t6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/X82i+g/QK2oT+/bejPbxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pd/ukvPtLjnfNvTn24b+fNvQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e6/l2l5xvd8n5tqE/3zb059uG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+3u+R8u0vOtw39+bahP9829Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93q+8gsov4Bt6M+3Df35tqE/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzX841fwPgFbEN/vm3oz9mG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+xS45dcrahP2cb+nO2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNdz7JJjl5xt6M/Zhv6cbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1HLvk2CVnG/pztqE/Zxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PccuOXbJ2Yb+nG3oz9mG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+1S65dcrehP3cb+nO3oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNdz7ZJrl9xt6M/dhv7cbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1XLvk2iV3G/pzt6E/dxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PdcuuXbJ3Yb+3G3oz92G/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+1S65dcrehP3cb+nO3oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNfz7JJnl7xt6M/bhv68beiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1PLvk2SVvG/rztqE/bxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pc8ueXbJ24b+vG3oz9uG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+zS55d8rahP28b+vO2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNcTdknYJbEN/Ylt6E9sQ390r4f3enivh/d6eK+H93p4r4f3enivh/d6dK9H93p0r4f3enivh/d6eK8n7JKwS2Ib+hPb0J/Yhv7oXg/v9fBeD+/18F4P7/XwXg/v9fBeD+/16F6P7vXoXg/v9fBeD+/18F5P2CVhl8Q29Ce2oT+xDf3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2esEvCLolt6E9sQ39iG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9YZeEXRLb0J/Yhv7ENvRH93p4r4f3enivh/d6eK+H93p4r4f3enivR/d6dK9H93p4r4f3enivh/d60i5JuyS3oT+5Df3JbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1pF2SdkluQ39yG/qT29Af3evhvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht3r0b0e3evhvR7e6+G9Ht7rSbsk7ZLchv7kNvQnt6E/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzXk3ZJ2iW5Df3JbehPbkN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3enivp+ySsktqG/pT29Cf2ob+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBeT9klZZfUNvSntqE/tQ390b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7e69G9Ht3r0b0e3uvhvR7e6+G9nrJLyi6pbehPbUN/ahv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PWWXlF1S29Cf2ob+1Db0R/d6eK+H93p4r4f3enivh/d6eK+H93p4r0f3enSvR/d6eK+H93p4r4f3esouKbuktqE/tQ39qW3oj+718F4P7/XwXg/v9fBeD+/18F4P7/XwXo/u9ehej+718F4P7/XwXg/v9bRd0nZJb0N/ehv609vQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e62m7pO2S3ob+9Db0p7ehP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez2819N2SdslvQ396W3oT29Df3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4r6ftkrZLehv609vQn96G/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs/YJWOXzDb0Z7ahP7MN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ6xS8YumW3oz2xDf2Yb+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez1jl4xdMtvQn9mG/sw29Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93rGLhm7ZLahP7MN/Zlt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/WMXTJ2yWxDf2Yb+jPb0B/d6+G9Ht7r4b0e3uvhvR7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3uv97S65v90l97cN/f1tQ39/29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7r/e0uub/dJfe3Df39bUN/f9vQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6/3tLrm/3SX3tw39/W1Df3/b0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3uv9lV9A+QVsQ39/29Df3zb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3en/jF7C75H7b0N9vG/r7bUN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmv99tdcr/dJffbhv5+29Dfbxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vd/ukvvtLrnfNvT324b+ftvQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6/12l9xvd8n9tqG/3zb099uG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXu/XfgHtF7AN/f22ob/fNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6j11y7JKzDf0929Dfsw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93mOXHLvkbEN/zzb092xDf3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r/fYJccuOdvQ37MN/T3b0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3us9dsmxS8429PdsQ3/PNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6j11y7JKzDf0929Dfuw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93muXXLvkbkN/7zb0925Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r/faJdcuudvQ37sN/b3b0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3uu9dsm1S+429PduQ3/vNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6r11y7ZK7Df2929Dfuw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93meXPLvkbUN/3zb0921Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r/fZJc8uedvQ37cN/X3b0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3ut9dsmzS9429PdtQ3/fNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6n13y7JK3Df1929Dftw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93meXPLvkbUN/3zb0921Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5rzfskrBLYhv6G9vQ39iG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXm/YJWGXxDb0N7ahv7EN/dW9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3uvVvV7d69W9Xt7r5b1e3uvlvd6wS8IuiW3ob2xDf2Mb+qt7vbzXy3u9vNfLe72818t7vbzXy3u9vNere72616t7vbzXy3u9vNfLe71hl4RdEtvQ39iG/sY29Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93rTLkm7JLehv7kN/c1t6K/u9fJeL+/18l4v7/XyXi/v9fJeL+/18l6v7vXqXq/u9fJeL+/18l4v7/WmXZJ2SW5Df3Mb+pvb0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3utNuyTtktyG/uY29De3ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNebdknaJbkN/c1t6G9uQ391r5f3enmvl/d6ea+X93p5r5f3enmvl/d6da9X93p1r5f3enmvl/d6ea837ZK0S3Ib+pvb0N/chv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l5v2SVll9Q29Le2ob+1Df3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3eskvKLqlt6G9tQ39rG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9ZZeUXVLb0N/ahv7WNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6yy4pu6S2ob+1Df2tbeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1tl3SdklvQ397G/rb29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7rbbuk7ZLehv72NvS3t6G/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzX23ZJ2yW9Df3tbehvb0N/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmvt+2Stkt6G/rb29Df3ob+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJeb9slbZf0NvS3t6G/vQ391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93rFLxi6ZbejvbEN/Zxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vWOXjF0y29Df2Yb+zjb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3escuGbtktqG/sw39nW3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9Y5dMnbJbEN/Zxv6O9vQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6/vtLnm/3SXvtw39+21D/37b0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3uv77S55v90l77cN/fttQ/9+29A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7r++0ueb/dJe+3Df37bUP/ftvQP93r470+3uvjvT7e6+O9Pt7r470+3uvjvT7d69O9Pt3r470+3uvjvT7e6/vtLnm/3SXvtw39+21D/37b0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3uv7tV9A+wVsQ/9+29C/3zb0T/f6eK+P9/p4r4/3+nivj/f6eK+P9/p4r0/3+nSvT/f6eK+P9/p4r4/3+r7dJe/bXfK+bejftw39+7ahf7rXx3t9vNfHe32818d7fbzXx3t9vNfHe32616d7fbrXx3t9vNfHe3281/ftLnnf7pL3bUP/vm3o37cN/dO9Pt7r470+3uvjvT7e6+O9Pt7r470+3uvTvT7d69O9Pt7r470+3uvjvb5vd8n7dpe8bxv6921D/75t6J/u9fFeH+/18V4f7/XxXh/v9fFeH+/18V6f7vXpXp/u9fFeH+/18V4f7/V95RdQfgHb0L9vG/r3bUP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+niv7xu/ALvkbEP/zjb072xD/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/YJccuOdvQv7MN/Tvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3us7dsmxS8429O9sQ//ONvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6jl1y7JKzDf0729C/sw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmOXHLvkbEP/zjb072xD/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/aJdcuudvQv7sN/bvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3uu7dsm1S+429O9uQ//uNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6rl1y7ZK7Df2729C/uw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmuXXLvkbkP/7jb0725D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/aJdcuudvQv7sN/Xvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3ut7dsmzS9429O9tQ//eNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6nl3y7JK3Df1729C/tw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vmeXPLvkbUP/3jb0721D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r+/ZJc8uedvQv7cN/Xvb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3usLuyTsktiG/sU29C+2oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNcXdknYJbEN/Ytt6F9sQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK8v7JKwS2Ib+hfb0L/Yhv7pXh/v9fFeH+/18V4f7/XxXh/v9fFeH+/16V6f7vXpXh/v9fFeH+/18V5f2CVhl8Q29C+2oX+xDf3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+sEvCLolt6F9sQ/9iG/qne32818d7fbzXx3t9vNfHe32818d7fbzXp3t9utene32818d7fbzXx3t9aZekXZLb0L/chv7lNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f60i5JuyS3oX+5Df3Lbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1pV2SdkluQ/9yG/qX29A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7rS7sk7ZLchv7lNvQvt6F/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzXV3ZJ2SW1Df2rbehfbUP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+nivr+ySsktqG/pX29C/2ob+6V4f7/XxXh/v9fFeH+/18V4f7/XxXh/v9elen+716V4f7/XxXh/v9fFeX9klZZfUNvSvtqF/tQ39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vrJLyi6pbehfbUP/ahv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fWWXlF1S29C/2ob+1Tb0T/f6eK+P9/p4r4/3+nivj/f6eK+P9/p4r0/3+nSvT/f6eK+P9/p4r4/3+touabukt6F/vQ39623on+718V4f7/XxXh/v9fFeH+/18V4f7/XxXp/u9elen+718V4f7/XxXh/v9bVd0nZJb0P/ehv619vQP93r470+3uvjvT7e6+O9Pt7r470+3uvjvT7d69O9Pt3r470+3uvjvT7e62u7pO2S3ob+9Tb0r7ehf7rXx3t9vNfHe32818d7fbzXx3t9vNfHe32616d7fbrXx3t9vNfHe32819d2SdslvQ39623oX29D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r2/skrFLZhv6N9vQv9mG/uleH+/18V4f7/XxXh/v9fFeH+/18V4f7/XpXp/u9eleH+/18V4f7/XxXt/YJWOXzDb0b7ahf7MN/dO9Pt7r470+3uvjvT7e6+O9Pt7r470+3uvTvT7d69O9Pt7r470+3uvjvb6xS8YumW3o32xD/2Yb+qd7fbzXx3t9vNfHe32818d7fbzXx3t9vNene32616d7fbzXx3t9vNfHe31jl4xdMtvQv9mG/s029E/3+nivj/f6eK+P9/p4r4/3+nivj/f6eK9P9/p0r0/3+nivj/f6eK+P9/rGLhm7ZLahf7MN/Ztt6J/u9fFeH+/18V4f7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be47e7JH67S+K3DX38tqGP3zb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be43f7pL47S6J3zb08duGPn7b0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81frtL4re7JH7b0MdvG/r4bUMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81/iVX0D5BWxDH79t6OO3DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be49tdEt/ukvi2oY9vG/r4tqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea3y7S+LbXRLfNvTxbUMf3zb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be41vd0l8u0vi24Y+vm3o49uGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK/x7S6Jb3dJfNvQx7cNfXzb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81vvYLaL+Abejj24Y+vm3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xrHLjl2ydmGPs429HG2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rHLvk2CVnG/o429DH2YY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r3HskmOXnG3o42xDH2cb+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L3GsUuOXXK2oY+zDX2cbehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GscuOXbJ3YY+7jb0cbehD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mtcu+TaJXcb+rjb0Mfdhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivce2Sa5fcbejjbkMfdxv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvca1S65dcrehj7sNfdxt6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/ca1y65dsndhj7uNvRxt6EP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3eazy75Nklbxv6eNvQx9uGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK/x7JJnl7xt6ONtQx9vG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xrNLnl3ytqGPtw19vG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xrPLnl2yduGPt429PG2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rPLvk2SVvG/p429BHbEMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81wi7JOyS2IY+Yhv6iG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xphl4RdEtvQR2xDH7ENfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F4j7JKwS2Ib+oht6CO2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rhF0SdklsQx+xDX3ENvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbRL0i7Jbegjt6GP3IY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r5F2SdoluQ195Db0kdvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXSLkm7JLehj9yGPnIb+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2iVpl+Q29JHb0EduQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXSLsk7ZLchj5yG/rIbehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GmWXlF1S29BHbUMftQ196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXqPskrJLahv6qG3oo7ahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3muUXVJ2SW1DH7UNfdQ29KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNskvKLqlt6KO2oY/ahj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXiv0XZJ2yW9DX30NvTR29CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNdouabukt6GP3oY+ehv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvUbbJW2X9Db00dvQR29DH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNdou6Ttkt6GPnob+uht6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/cabZe0XdLb0EdvQx+9DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/BeY+ySsUtmG/qYbehjtqEP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea4xdMnbJbEMfsw19zDb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42xS8YumW3oY7ahj9mGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8xdsnYJbMNfcw29DHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+S9Ju81f7tL8re7JH/b0OdvG/r8bUOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q81/ztLsnf7pL8bUOfv23o87cNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7zt7skf7tL8rcNff62oc/fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zd/ukvylX8A29Pnbhj5/29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNX/jFzB+AdvQ528b+vxtQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzX/HaX5Le7JL9t6PPbhj6/behT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mt/ukvx2l+S3DX1+29Dntw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXvPbXZLf7pL8tqHPbxv6/LahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mt+5RdQfgHb0Oe3DX1+29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNY9dcuySsw19nm3o82xDn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNc8dsmxS8429Hm2oc+zDX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Je89glxy4529Dn2YY+zzb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je81jlxy75GxDn2cb+jzb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81j11y7JKzDX2ebejzbEOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q817x2ybVL7jb0ebehz7sNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7z2iXXLrnb0Ofdhj7vNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zWuXXLvkbkOfdxv6vNvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zWvXXLtkrsNfd5t6PNuQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXvHbJtUveNvT5tqHPtw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXvPZJc8uedvQ59uGPt829Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNZ5c8u+RtQ59vG/p829Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNZ9d8uyStw19vm3o821Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNd8dsmzS9429Pm2oc+3DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/JeM+ySsEtiG/qMbegztqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea4ZdEnZJbEOfsQ19xjb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82wS8IuiW3oM7ahz9iGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea8ZdknYJbENfcY29Bnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81wy4JuyS2oc/Yhj5zG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S9ZtolaZfkNvSZ29BnbkOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q810y7JO2S3IY+cxv6zG3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95ppl6RdktvQZ25Dn7kNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l4z7ZK0S3Ib+sxt6DO3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rll1SdkltQ5+1DX3WNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zbJLyi6pbeiztqHP2oY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r1l2SdkltQ191jb0WdvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXLLim7pLahz9qGPmsb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L1m2SVll9Q29Fnb0GdtQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXbLuk7ZLehj57G/rsbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mm2XtF3S29Bnb0OfvQ196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXrPtkrZLehv67G3os7ehT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mu2XdJ2SW9Dn70NffY29Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNsUvGLplt6HO2oc/Zhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvOXbJ2CWzDX3ONvQ529Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNccuGbtktqHP2YY+Zxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvebYJWOXzDb0OdvQ52xDn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNccu2TsktmGPmcb+pxt6FP3mrzX5L0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/dav90l9dtdUr9t6Ou3DX39tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea/12l9Rvd0n9tqGv3zb09duGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/1211Sv90l9duGvn7b0NdvG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91q/9AtovYBv6+m1DX79t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/da3+6S+naX1LcNfX3b0Ne3DX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/Fe69tdUt/ukvq2oa9vG/r6tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea327S+rbXVLfNvT1bUNf3zb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe61vd0l96RewDX1929DXtw196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXusbv4DxC9iGvr5t6Ovbhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivdeySY5ecbejrbENfZxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdaxS45dcrahr7MNfZ1t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/daxy45dsnZhr7ONvR1tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3eax275NglZxv6OtvQ19mGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK917ZJrl9xt6OtuQ193G/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91rVLrl1yt6Gvuw193W3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rXLrl2yd2Gvu429HW3oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rXbvk2iV3G/q629DX3Ya+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r3XtkmuX3G3o625DX3cb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r3Ws0ueXfK2oa+3DX29behL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Ws8ueXbJ24a+3jb09bahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3ms9u+TZJW8b+nrb0Nfbhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXiv9eySZ5e8bejrbUNfbxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivdazS55dEtvQV2xDX7ENfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V4r7JKwS2Ib+opt6Cu2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rhV0SdklsQ1+xDX3FNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbBLwi6JbegrtqGv2Ia+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4rxV2SdglsQ19xTb0FdvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XSLkm7JLehr9yGvnIb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r1W2iVpl+Q29JXb0FduQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXSrsk7ZLchr5yG/rKbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WmmXpF2S29BXbkNfuQ196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXivtkrRLchv6ym3oq7ahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3muVXVJ2SW1DX7UNfdU29KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutskvKLqlt6Ku2oa/ahr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivVXZJ2SW1DX3VNvRV29CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtcouKbuktqGv2oa+ahv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivVbbJW2X9Db01dvQV29DX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNdqu6Ttkt6Gvnob+upt6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/dabZe0XdLb0FdvQ1+9DX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/Feq+2Stkt6G/rqbeirt6Ev3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea7Vd0nZJb0NfvQ199Tb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe62xS8YumW3oa7ahr9mGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK81dsnYJbMNfc029DXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1xi4Zu2S2oa/Zhr5mG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91tglY5fMNvQ129DXbENfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7bd5r816b99q81/7tLunf7pL+bUPfv23o+7cNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r8177t7ukf7tL+rcNff+2oe/fNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177d/ukv7tLunfNvT924a+f9vQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277V/5RdQfgHb0PdvG/r+bUPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81/6NX8D4BWxD379t6Pu3DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9td0t/ukv62oe9vG/r+tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea3+7S/rbXdLfNvT9bUPf3zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+1vd0l/u0v624a+v23o+9uGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/9tV9A+wVsQ9/fNvT9bUPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81z52ybFLzjb0fbah77MNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81772CXHLjnb0PfZhr7PNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177WOXHLvkbEPfZxv6PtvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277WPXXLskrMNfZ9t6PtsQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXPnbJsUvONvR9tqHvsw19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXvvaJdcuudvQ992Gvu829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvta5dcu+RuQ993G/q+29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvta9dcu2Suw19323o+25D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNe+dsm1S+429H23oe+7DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9klzy5529D324a+3zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+1nlzy75G1D328b+n7b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1n13y7JK3DX2/bej7bUPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81352ybNL3jb0/bah77cNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81772SXPLnnb0Pfbhr7fNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177bBLwi6Jbeg7tqHv2Ia+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5rx12SdglsQ19xzb0HdvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277XDLgm7JLah79iGvmMb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122CVhl8Q29B3b0HdsQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXDrsk7JLchr5zG/rObehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32mmXpF2S29B3bkPfuQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXjvtkrRLchv6zm3oO7ehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3munXZJ2SW5D37kNfec29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvttEvSLslt6Du3oe/chr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvXXZJ2SW1DX3XNvRd29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtcsuKbuktqHv2oa+axv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvXbZJWWX1Db0XdvQd21D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNcuu6TsktqGvmsb+q5t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/faZZeUXVLb0HdtQ9+9DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Neu+2Stkt6G/rubei7t6Fv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea7dd0nZJb0PfvQ199zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+22S9ou6W3ou7eh796GvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/ddknbJb0Nffc29N3b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1xy4Zu2S2oe/Zhr5nG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99tglY5fMNvQ929D3bEPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81x67ZOyS2Ya+Zxv6nm3oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99pjl4xdMtvQ92xD37MNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81577JKxS2Yb+p5t6Hu2oW/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7r/HaXzG93yfy2oZ/fNvTz24Z+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r/PbXTK/3SXz24Z+ftvQz28b+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3Ob3fJ/HaXzG8b+vltQz+/behH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3Or/2C2i/gG3o57cN/fy2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rfLtL5ttdMt829PNtQz/fNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nW93yXy7S+bbhn6+bejn24Z+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r/PtLplvd8l829DPtw39fNvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73W+8gsov4Bt6Ofbhn6+behH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3Ot/4BYxfwDb0821DP9829KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udY5ccu+RsQz9nG/o529CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdY5dcuySsw39nG3o52xDP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNc5dsmxS8429HO2oZ+zDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be59glxy4529DP2YZ+zjb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De51rl1y75G5DP3cb+rnb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91rl1y7ZK7Df3cbejnbkM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq817l2ybVL7jb0c7ehn7sN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F7n2iXXLrnb0M/dhn7uNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWuXXLvkbkM/dxv6udvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73WeXfLskrcN/bxt6OdtQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXeXbJs0veNvTztqGftw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXufZJc8uedvQz9uGft429KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udZ5c8u+RtQz9vG/p529CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdcIuCbsktqGf2IZ+Yhv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvU7YJWGXxDb0E9vQT2xDP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNcJuyTsktiGfmIb+olt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6YZeEXRLb0E9sQz+xDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/BeJ+ySsEtiG/qJbegntqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e66RdknZJbkM/uQ395Db0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De520S/5HxB3kSJLrWBTdkhtJSeT+N9Y/0JU8M5sFNEjiVfnFuXbJ3YZ+7jb0c7ehH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3utcu+TaJXcb+rnb0M/dhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXivc+2Sa5fcbejnbkM/dxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc61S65d8rahn7cN/bxt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6zy55dsnbhn7eNvTztqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e6zy75Nklbxv6edvQz9uGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK/z7JJnl7xt6OdtQz9vG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9zrNLnl3ytqGftw39vG3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zptl7Rd0tvQT29DP70N/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F6n7ZK2S3ob+ult6Ke3oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rtF3SdklvQz+9Df30NvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbZL2i7pbeint6Gf3oZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r9N2SdslvQ399Db0M9vQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XGLhm7ZLahn9mGfmYb+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3O2CVjl8w29DPb0M9sQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXGbtk7JLZhn5mG/qZbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OmOXjF0y29DPbEM/sw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6273+7/+W/Nslf5+fz//e9veZPsvn8Xl9Pp//Xa6/z/8u1/8+/zX0f5/+2r9b8veZPsvn8Xl9Pp/t09vC28JfC38t/LXwtvC28Lbwtn+75O9z9vNfQ//3+e2L/zX0f5/+Wnpbelt6W3pbelt6W3lbeVt5W/lr5a+Vv1beVt5W3lbe9m+X/H1+PmNf/K+h//usffHx1463HW873na87Xrb9bbrbdfbrrddf+36a9dfu952ve152/O251/A8y/gX0P/93n2xf8a+r9Pf+152/O29rb2tva29rb2tva29rb219pfa39tvG28bbxtvG38Cxj/Av419H+fb1/8r6H/+9y/9rkln1uy3uvfZ/osn8fn9fl8tk9/7fPX3JL1Xv8+02f5PD6vz+dzL9f37eX6Yi/X55Z8bsnnlqz3+vfpbeFt4W3hbeFt6W3pr6W/5pas9/r36W3pbelt2T73X8BXe7m+2sv11V6uzy353JLPLVnv9e/T28rbytuOtx1vO952/LXjr7kl673+fXrb8bbjbffn8/O5l+u7e7m+u5frc0s+t+RzS9Z7/fv0tudtz9uetz1ve972/LXnr7kl673+fXpbe1t7W/sX0P4F9F6ur/dyfb2X63NLPrfkc0vWe/379LbxtvG28bbxtvG28dfGX3NL1nv9+/x8hs/0WT6Pz71c8dvLFb+9XOGWhFsSbknYJWGXhF0SdknYJWGXhF0SdknYJeGWrPf69+ltdknYJWGXhF0SsZcrYi9X5F6ucEvCLQm3JOySsEvCLgm7JOySsEvCLgm7JOyScEvWe/379Da7JOySsEvCLomzlyvOXq44e7nCLQm3JNySsEvCLgm7JOySsEvCLgm7JOySsEvCLVnv9e/T2+ySsEvCLgm7JN5ernh7ueLt5Qq3JNyScEvCLgm7JOySsEvCLgm7JOySsEvCLgm3ZL3Xv09vs0vCLgm7JOySmL1cMXu5YvZyhVsSbkm4JWmXpF2SdknaJWmXpF2SdknaJWmXpFuy3uvf5+czfKbP8nl87uXKby9Xfnu50i1JtyTdkrRL0i5JuyTtkrRL0i5JuyTtkrRL0i1Z7/Xv09vskrRL0i5JuyRzL1fmXq6svVzplqRbkm5J2iVpl6RdknZJ2iVpl6RdknZJ2iXplqz3+vfpbXZJ2iVpl6RdkncvV969XHn3cqVbkm5JuiVpl6RdknZJ2iVpl6RdknZJ2iVpl6Rbst7r36e32SVpl6RdknZJ9l6u7L1c2Xu50i1JtyTdkrRL0i5JuyTtkrRL0i5JuyTtkrRL0i1Z7/Xvc99WdknZJWWXlF1Sv71c9dvLVb+9XOWWlFtSbknZJWWXlF1SdknZJWWXlF1SdknZJeWWrPf69+ltdknZJWWXlF1SsZerYi9XxV6uckvKLSm3pOySskvKLim7pOySskvKLim7pOySckvWe/379Da7pOySskvKLqnay1W1l6vOXq5yS8otKbek7JKyS8ouKbuk7JKyS8ouKbuk7JJyS9Z7/fv0Nruk7JKyS8ouqbeXq95ernp7ucotKbek3JKyS8ouKbuk7JKyS8ouKbuk7JKyS8otWe/179Pb7JKyS8ouKbukZi9XzV6umr1c5ZaUW1JuSdklZZccu+TYJccuOXbJsUuOXXLskuOWrPf697lvO3bJsUuOXXLskvPt5TrfXq7z7eU6bslxS45bcuySY5ccu+TYJccuOXbJsUuOXXLskuOWrPf69+ltdsmxS45dcuySk3u5Tu7lOrmX67glxy05bsmxS45dcuySY5ccu+TYJccuOXbJsUuOW7Le69+nt9klxy45dsmxS87Zy3XOXq5z93Idt+S4JcctOXbJsUuOXXLskmOXHLvk2CXHLjl2yXFL1nv9+/Q2u+TYJccuOXbJ6b1cp/dynd7LddyS45Yct+TYJccuOXbJsUuOXXLskmOXHLvk2CXHLVnv9e/T2+ySY5dcu+TaJfe3l+v+9nLd316u65Zct+S6JdcuuXbJtUuuXXLtkmuXXLvk2iXXLrluyXqvf5/eZpdcu+TaJdcuubGX68Zerht7ua5bct2S65Zcu+TaJdcuuXbJtUuuXXLtkmuXXLvkuiXrvf59eptdcu2Sa5dcu+TWXq5be7lu7eW6bsl1S65bcu2Sa5dcu+TaJdcuuXbJtUuuXXLtkuuWrPf69+ltdsm1S65dcu2Se/dy3buX6769XNctuW7JdUuuXXLtkmuXXLvk2iXXLrl2ybVLrl1y3ZL1Xv8+vc0uuXbJtUuuXXJnL9edvVx39nJdt+S6JdctuXbJtUuuXXLtkmeXPLvk2SXPLnl2yXNLnt+En9+En13y7JJnlzy75H17ud63l+t9e7meW/LckueWPLvk2SXPLnl2ybNLnl3y7JJnlzy75Lklz2/Cz2/Czy55dsmzS55d8nIv18u9XC/3cj235Lklzy15dsmzS55d8uySZ5c8u+TZJc8ueXbJc0ue34Sf34SfXfLskmeXPLvknb1c7+zlemcv13NLnlvy3JJnlzy75Nklzy55dsmzS55d8uySZ5c8t+T5Tfj5TfjZJc8ueXbJs0ve28v13l6u13u5nlvy3JLnljy75Nklzy55dsmzS55d8uySZ5c8u+S5Jc9vws9vws8ueXbJs0ueXdK/vVz928vVv71c7Za0W9JuSdslbZe0XdJ2SdslbZe0XdJ2Sdsl7Za034Tbb8Jtl7Rd0nZJ2yUde7k69nJ17OVqt6TdknZL2i5pu6TtkrZL2i5pu6TtkrZL2i5pt6T9Jtx+E267pO2StkvaLunay9W1l6trL1e7Je2WtFvSdknbJW2XtF3SdknbJW2XtF3Sdkm7Je034fabcNslbZe0XdJ2Sd+9XH33cvXdy9VuSbsl7Za0XdJ2SdslbZe0XdJ2SdslbZe0XdJuSftNuP0m3HZJ2yVtl7Rd0r2Xq3svV89ernZL2i1pt6TtkrZL2i5pu6TtkrZLxi4Zu2TsknFLxm/C4zfhsUvGLhm7ZOyS+fZyzbeXa769XOOWjFsybsnYJWOXjF0ydsnYJWOXjF0ydsnYJeOWjN+Ex2/CY5eMXTJ2ydglk3u5JvdyTe7lGrdk3JJxS8YuGbtk7JKxS8YuGbtk7JKxS8YuGbdk/CY8fhMeu2TskrFLxi6Zs5drzl6uOXu5xi0Zt2TckrFLxi4Zu2TskrFLxi4Zu2TskrFLxi0ZvwmP34THLhm7ZOySsUvm7eWat5dr3l6ucUvGLRm3ZOySsUvGLhm7ZOySsUvGLhm7ZOyScUvGb8LjN+GxS8YuGbtk7JKZvVzzr6H/3/+/+NfQ/33++2vfeq9/n+mzfB6f1+fz2T5nP3eXfLrXT/f66V6/9V7/Po/P6/P5bJ+zn/8a+r/Pb1/8r6H/+/TXwtvC28LbwtvC28Lb0tvS29Lb0l9Lfy39tfS29Lb0tvS23SXfb3fJ9/vX0P995r74X0P/9+mvlbeVt5W3lbcdbzvedrzteNvxtuOvHX/t+GvH2463XW+73ra75PvtLvl+/xr6v8+zL/7X0P99+mvX2663PW973va87Xnb87bnbc/bnr/2/LXnr7W3tbe1t7W3tX8B7V/Av4b+7/Pti/819H+f/tp423jbeNt423jbeNt423jbeNvukk/3+ulev/Ve/z7TZ/k8Pq/P5/Pf5fq+bei/bxv6T/f6fW7J55as9/r3eXxen89n+/S28Lbw18Jfc0vWe/379LbwtvC23SXft7vk+7ah/75t6L9vG/pP9/p9bsnnlqz3+vfpbelt6W3lbeVt5W3lr5W/5pas9/r36W3lbeVtu0u+b3fJ921D/33b0H/fNvSf7vX73JLPLVnv9e/T2663XW+73na97Xrb9deuv+aWrPf69+ltz9uetz3/Ap5/AdvQf9829N+3Df2ne/0+t+RzS9Z7/fv0tva29rb2tva29rb219pfc0vWe/379LbxtvG28S9g/AvYhv77tqH/vm3oP93rF25JuCVhl4RdEnZJ2CVhl4RdEnaJ7vXTvX6612+917/P9Fk+j8/r8/ncyxXb0H+xDf2ne/3CLQm3JOySsEvCLgm7JOySsEvCLtG9frrXT/f6rff69+ltdknYJWGXhF0S29B/sQ39F9vQf7rXL9yScEvCLgm7JOySsEvCLgm7JOwS3eune/10r996r3+f3maXhF0SdknYJbEN/Rfb0H+xDf2ne/3CLQm3JOySsEvCLgm7JOySsEvCLtG9frrXT/f6rff69+ltdknYJWGXhF0S29B/sQ39F9vQf7rXL9yScEvCLgm7JOySsEvCLgm7JOwS3eune/10r996r3+fn8/wmT7L5/G5lyu3of9yG/pP9/qlW5JuSdolaZekXZJ2SdolaZekXaJ7/XSvn+71W+/179Pb7JK0S9IuSbskt6H/chv6L7eh/3SvX7ol6ZakXZJ2SdolaZekXZJ2SdolutdP9/rpXr/1Xv8+vc0uSbsk7ZK0S3Ib+i+3of9yG/pP9/qlW5JuSdolaZekXZJ2SdolaZekXaJ7/XSvn+71W+/179Pb7JK0S9IuSbskt6H/chv6L7eh/3SvX7ol6ZakXZJ2SdolaZekXZJ2SdolutdP9/rpXr/1Xv8+vc0uSbsk7ZK0S3Ib+i+3of9yG/pP9/qlW5JuSdklZZeUXVJ2SdklZZeUXaJ7/XSvn+71W+/17/PzGT7TZ/k8Pvdy1Tb0X21D/+lev3JLyi0pu6TskrJLyi4pu6TskrJLdK+f7vXTvX7rvf59eptdUnZJ2SVll9Q29F9tQ//VNvSf7vUrt6TckrJLyi4pu6TskrJLyi4pu0T3+uleP93rt97r36e32SVll5RdUnZJbUP/1Tb0X21D/+lev3JLyi0pu6TskrJLyi4pu6TskrJLdK+f7vXTvX7rvf59eptdUnZJ2SVll9Q29F9tQ//VNvSf7vUrt6TckrJLyi4pu6TskrJLyi4pu0T3+uleP93rt97r3+e+7dglxy45dsmxS8429N/Zhv4729B/utfvuCXHLTl2ybFLjl1y7JJjlxy75NglutdP9/rpXr/1Xv8+vc0uOXbJsUuOXXK2of/ONvTf2Yb+071+xy05bsmxS45dcuySY5ccu+TYJccu0b1+utdP9/qt9/r36W12ybFLjl1y7JKzDf13tqH/zjb0n+71O27JcUuOXXLskmOXHLvk2CXHLjl2ie71071+utdvvde/T2+zS45dcuySY5ecbei/sw39d7ah/3Sv33FLjlty7JJjlxy75Nglxy45dsmxS3Svn+71071+673+fXqbXXLskmOXHLvkbEP/nW3ov7MN/ad7/Y5bctySY5ccu+TaJdcuuXbJtUuuXaJ7/XSvn+71W+/173Pfdu2Sa5dcu+TaJXcb+u9uQ//dbeg/3et33ZLrlly75Nol1y65dsm1S65dcu0S3eune/10r996r3+f3maXXLvk2iXXLrnb0H93G/rvbkP/6V6/65Zct+TaJdcuuXbJtUuuXXLtkmuX6F4/3eune/3We/379Da75Nol1y65dsndhv6729B/dxv6T/f6XbfkuiXXLrl2ybVLrl1y7ZJrl1y7RPf66V4/3eu33uvfp7fZJdcuuXbJtUvuNvTf3Yb+u9vQf7rX77ol1y25dsm1S65dcu2Sa5dcu+TaJbrXT/f66V6/9V7/Pr3NLrl2ybNLnl3ytqH/3jb039uG/tO9fs8teW7Js0ueXfLskmeXPLvk2SXPLtG9frrXT/f6Pb8JP78JP7vk2SXPLnl2yduG/nvb0H9vG/pP9/o9t+S5Jc8ueXbJs0ueXfLskmeXPLtE9/rpXj/d6/f8Jvz8JvzskmeXPLvk2SVvG/rvbUP/vW3oP93r99yS55Y8u+TZJc8ueXbJs0ueXfLsEt3rp3v9dK/f85vw85vws0ueXfLskmeXvG3ov7cN/fe2of90r99zS55b8uySZ5c8u+TZJc8ueXbJs0t0r5/u9dO9fs9vws9vws8ueXbJs0ueXfK2of/eNvTf24b+071+zy15bsmzS55d8uySZ5e0XdJ2SdslutdP9/rpXr/2m3D7TbjtkrZL2i5pu6S3of96G/qvt6H/dK9fuyXtlrRd0nZJ2yVtl7Rd0nZJ2yW610/3+ulev/abcPtNuO2StkvaLmm7pLeh/3ob+q+3of90r1+7Je2WtF3SdknbJW2XtF3SdknbJbrXT/f66V6/9ptw+0247ZK2S9ouabukt6H/ehv6r7eh/3SvX7sl7Za0XdJ2SdslbZe0XdJ2SdslutdP9/rpXr/2m3D7TbjtkrZL2i5pu6S3of96G/qvt6H/dK9fuyXtlrRd0nZJ2yVtl7Rd0nZJ2yW610/3+ulev/abcPtNuO2StkvaLmm7ZLah/2Yb+m+2of90r9+4JeOWjF0ydsnYJWOXjF0ydsnYJbrXT/f66V6/8Zvw+E147JKxS8YuGbtktqH/Zhv6b7ah/3Sv37gl45aMXTJ2ydglY5eMXTJ2ydglutdP9/rpXr/xm/D4TXjskrFLxi4Zu2S2of9mG/pvtqH/dK/fuCXjloxdMnbJ2CVjl4xdMnbJ2CW610/3+ulev/Gb8PhNeOySsUvGLhm7ZLah/2Yb+m+2of90r9+4JeOWjF0ydsnYJWOXjF0ydsnYJbrXT/f66V6/8Zvw+E147JKxS8YuGbtktqH/Zhv6b7ah/3Sv37gl45aMXTJ2ydglY5eMXcJ7Dd5r6F5D9xq61+C9Bu81eK/Be43f7pL47S6J3zb08duGPn7b0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81frtL4re7JH7b0MdvG/r4bUMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81/jtLonf7pL4bUMfv23o47cNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F7j9/wLeP4FbEMfv23o47cNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F7jN/4FjH8B29DHbxv6+LahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mt8u0vi210S3zb08W1DH9829KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNb3dJfLtL4tuGPr5t6OPbhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXiv8e0uiW93SXzb0Me3DX1829CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNb72L6D9C9iGPr5t6OPbhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivEXZJ2CWxDX3ENvQR29CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNcIuCbsktqGP2IY+Yhv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvUbYJWGXxDb0EdvQR2xDH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNcIuyTsktiGPmIb+oht6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/caYZeEXRLb0EdsQx+xDX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/BeI+2StEtyG/rIbegjt6EP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea6RdknZJbkMfuQ195Db0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be420S9IuyW3oI7ehj9yGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK+RdknaJbkNfeQ29JHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81yi4pu6S2oY/ahj5qG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9RtklZZfUNvRR29BHbUMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81yi7pOyS2oY+ahv6qG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xpll5RdUtvQR21DH7UNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F6j7JKyS2ob+qht6KO2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rHLvk2CVnG/o429DH2YY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r3HskmOXnG3o42xDH2cb+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L3GsUuOXXK2oY+zDX2cbehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GscuOXbJ2YY+zjb0cbahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mtcu+TaJXcb+rjb0Mfdhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivce2Sa5fcbejjbkMfdxv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvca1S65dcrehj7sNfdxt6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/ca1y65dsndhj7uNvRxt6EP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea1y75Noldxv6uNvQx92GPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK/x7JJnl7xt6ONtQx9vG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xrNLnl3ytqGPtw19vG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xrPLnl2yduGPt429PG2oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rPLvk2SVvG/p429DH24Y+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r9F2SdslvQ199Db00dvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXaLmm7pLehj96GPnob+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2yVtl/Q29NHb0EdvQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXaLuk7ZLehj56G/robehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3Gm2XtF3S29BHb0MfvQ196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXmPskrFLZhv6mG3oY7ahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3muMXTJ2yWxDH7MNfcw29KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNsUvGLplt6GO2oY/Zhj50r8F7Dd5r8F6D9xq81+C9Bu81eK/Bew3da+heQ/cavNfgvQbvNXivMXbJ2CWzDX3MNvQx29CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNcYumd0l+duGPn/b0OdvG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S95m93Sf52l+RvG/r8bUOfv23oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95q/3SX5212Sv23o87cNff62oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5r/naX5G93Sf62oc/fNvT524Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/lr/wLav4Bt6PO3DX3+tqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea367S/LbXZLfNvT5bUOf3zb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je81vd0l+u0vy24Y+v23o89uGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea/57S7Jb3dJftvQ57cNfX7b0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81v+dfwPMvYBv6/Lahz28b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3mN/4FjH8B29Dntw19xjb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82wS8IuiW3oM7ahz9iGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea8ZdknYJbENfcY29Bnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81wy4JuyS2oc/Yhj5jG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S9ZtglYZfENvQZ29BnbEOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q810y7JO2S3IY+cxv6zG3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95ppl6RdktvQZ25Dn7kNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l4z7ZK0S3Ib+sxt6DO3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rpl2SdkluQ5+5DX3mNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zbRL0i7Jbegzt6HP3IY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r1l2SdkltQ191jb0WdvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXLLim7pLahz9qGPmsb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L1m2SVll9Q29Fnb0GdtQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXLLuk7JLahj5rG/qsbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mscuOXbJ2YY+zzb0ebahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mseu+TYJWcb+jzb0OfZhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmveeySY5ecbejzbEOfZxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkveaxS45dcrahz7MNfZ5t6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaxy45dsnZhj7PNvR5tqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea1675Noldxv6vNvQ592GPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea957ZJrl9xt6PNuQ593G/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S95rVLrl1yt6HPuw193m3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95rXLrl2yd2GPu829Hm3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rPrvk2SVvG/p829Dn24Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/nskmeXvG3o821Dn28b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3ms0ueXfK2oc+3DX2+behT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3ms8ueXbJ24Y+3zb0+bahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3ms+u+TZJW8b+nzb0Ofbhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmv2XZJ2yW9DX32NvTZ29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNdsuabukt6HP3oY+exv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvWbbJW2X9Db02dvQZ29Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNdsu6Ttkt6GPnsb+uxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaY5eMXTLb0OdsQ5+zDX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Jec+ySsUtmG/qcbehztqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea45dMnbJbEOfsw19zjb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82xS8YumW3oc7ahz9mGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea85dsnYJbMNfc429Dnb0KfuNXmvyXtN3mvyXpP3mrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1frtL6re7pH7b0NdvG/r6bUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81/rtLqnf7pL6bUNfv23o67cNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V7rt7ukfrtL6rcNff22oa/fNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rd/zL+D5F7ANff22oa/fNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rd/4F7C7pL5t6Ovbhr6+behL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Wt/ukvp2l9S3DX1929DXtw196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXuvbXVLf7pL6tqGvbxv6+rahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3mt9u0vq211S3zb09W1DX9829KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutr/0LaP8CtqGvbxv6+rahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3muFXRJ2SWxDX7ENfcU29KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutsEvCLolt6Cu2oa/Yhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivFXZJ2CWxDX3FNvQV29CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtcIuCbsktqGv2Ia+Yhv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivVbYJWGXxDb0FdvQV25DX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNdKuyTtktyGvnIb+spt6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/daaZekXZLb0FduQ1+5DX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/FeK+2StEtyG/rKbegrt6Ev3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea6VdknZJbkNfuQ195Tb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe62yS8ouqW3oq7ahr9qGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK9VdknZJbUNfdU29FXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1yi4pu6S2oa/ahr5qG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtklZZfUNvRV29BXbUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81yq7pOyS2oa+ahv6qm3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rHLjl2ydmGvs429HW2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rHbvk2CVnG/o629DX2Ya+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r3XskmOXnG3o62xDX2cb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r3WsUuOXXK2oa+zDX2dbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WtcuuXbJ3Ya+7jb0dbehL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3mtdu+TaJXcb+rrb0Nfdhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivde2Sa5fcbejrbkNfdxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivda1S65dcrehr7sNfd1t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/da1y65dsndhr7uNvR1t6Ev3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3eaz275Nklbxv6etvQ19uGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/17JJnl7xt6OttQ19vG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91rNLnl3ytqGvtw19vW3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rPLnl2yduGvt429PW2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rtV3SdklvQ1+9DX31NvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbZL2i7pbeirt6Gv3oa+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r9V2SdslvQ199Tb01dvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XaLmm7pLehr96Gvnob+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r1W2yVtl/Q29NXb0FdvQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXGrtk7JLZhr5mG/qabehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WmOXjF0y29DXbENfsw196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXmvskrFLZhv6mm3oa7ahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3muNXTJ2yWxDX7MNfc029KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXs9v90l57e75Py2oT+/bejPbxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pb/dJee3u+T8tqE/v23oz28b+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez2/3SXnt7vk/LahP79t6M9vG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9v90l57e75Py2oT+/bejPbxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pb/2L6D9C9iG/vy2oT+/beiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1fLtLzre75Hzb0J9vG/rzbUN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3eniv59tdcr7dJefbhv5829Cfbxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pd/ukvPtLjnfNvTn24b+fNvQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e6/mefwHPv4Bt6M+3Df35tqE/utfDez2818N7PbzXw3s9vNfDez2818N7PbrXo3s9utfDez2818N7PbzX841/AXZJbEN/Yhv6E9vQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e6wm7JOyS2Ib+xDb0J7ahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281xN2SdglsQ39iW3oT2xDf3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4ryfskrBLYhv6E9vQn9iG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXk/YJWGXxDb0J7ahP7EN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ60S9IuyW3oT25Df3Ib+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez1pl6RdktvQn9yG/uQ29Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93rSLkm7JLehP7kN/clt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/WkXZJ2SW5Df3Ib+pPb0B/d6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3evRvR7d6+G9Ht7r4b0e3utJuyTtktyG/uQ29Ke2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNdTdknZJbUN/alt6E9tQ390r4f3enivh/d6eK+H93p4r4f3enivh/d6dK9H93p0r4f3enivh/d6eK+n7JKyS2ob+lPb0J/ahv7oXg/v9fBeD+/18F4P7/XwXg/v9fBeD+/16F6P7vXoXg/v9fBeD+/18F5P2SVll9Q29Ke2oT+1Df3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2eskvKLqlt6E9tQ39qG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9xy45dsnZhv6cbejP2Yb+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBez7FLjl1ytqE/Zxv6c7ahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez2813PskmOXnG3oz9mG/pxt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/Ucu+TYJWcb+nO2oT9nG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9xy45dsnZhv6cbejP2Yb+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBez7VLrl1yt6E/dxv6c7ehP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez2813PtkmuX3G3oz92G/txt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/Vcu+TaJXcb+nO3oT93G/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s91y65dsndhv7cbejP3Yb+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBez7NLnl3ytqE/bxv687ahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez281/PskmeXvG3oz9uG/rxt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/U8u+TZJW8b+vO2oT9vG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9zy55dsnbhv68bejP24b+6F4P7/XwXg/v9fBeD+/18F4P7/XwXg/v9ehej+716F4P7/XwXg/v9fBez7NLnl3ytqE/bxv687ahP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez2819N2SdslvQ396W3oT29Df3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4r6ftkrZLehv609vQn96G/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXk/bJW2X9Db0p7ehP70N/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ62S9ou6W3oT29Df3ob+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez1jl4xdMtvQn9mG/sw29Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93rGLhm7ZLahP7MN/Zlt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/WMXTJ2yWxDf2Yb+jPb0B/d6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3evRvR7d6+G9Ht7r4b0e3usZu2TsktmG/sw29Ge2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNczdsnYJbMN/Zlt6M9sQ390r4f3enivh/d6eK+X93p5r5f3enmvl/d6da9X93p1r5f3enmvl/d6ea/3t7vk/naX3N829Pe3Df39bUN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmv97e75P52l9zfNvT3tw39/W1Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r/e3u+T+dpfc3zb097cN/f1tQ391r5f3enmvl/d6ea+X93p5r5f3enmvl/d6da9X93p1r5f3enmvl/d6ea/39/wLeP4FbEN/f9vQ39829Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93q/3SX3211yv23o77cN/f22ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNf77S653+6S+21Df79t6O+3Df3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3eb3fJ/XaX3G8b+vttQ3+/beiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1frtL7re75H7b0N9vG/r7bUN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmv92v/Atq/gG3o77cN/f22ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNcbdknYJbEN/Y1t6G9sQ391r5f3enmvl/d6ea+X93p5r5f3enmvl/d6da9X93p1r5f3enmvl/d6ea837JKwS2Ib+hvb0N/Yhv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l5v2CVhl8Q29De2ob+xDf3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3esEvCLolt6G9sQ39jG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9YZeEXZLb0N/chv7mNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d60y5JuyS3ob+5Df3Nbeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1pl2SdkluQ39zG/qb29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7rTbsk7ZLchv7mNvQ3t6G/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXm3ZJ2iW5Df3NbehvbkN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmvt+ySsktqG/pb29Df2ob+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJeb9klZZfUNvS3tqG/tQ391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93rJLyi6pbehvbUN/axv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vWWXlF1S29Df2ob+1jb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3essuKbuktqG/tQ39PdvQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6z12ybFLzjb092xDf8829Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93qPXXLskrMN/T3b0N+zDf3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3eY5ccu+RsQ3/PNvT3bEN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmv99glxy4529Dfsw39PdvQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6712ybVL7jb0925Df+829Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93qvXXLtkrsN/b3b0N+7Df3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3ea5dcu+RuQ3/vNvT3bkN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmv99ol1y6529Dfuw39vdvQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6712ybVL7jb0925Df+829Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93qfXfLskrcN/X3b0N+3Df3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3eZ5c8u+RtQ3/fNvT3bUN/da+X93p5r5f3enmvl/d6ea+X93p5r5f3enWvV/d6da+X93p5r5f3enmv99klzy5529Dftw39fdvQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6312ybNL3jb0921Df9829Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93rbLmm7pLehv70N/e1t6K/u9fJeL+/18l4v7/XyXi/v9fJeL+/18l6v7vXqXq/u9fJeL+/18l4v7/W2XdJ2SW9Df3sb+tvb0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3uttu6Ttkt6G/vY29Le3ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNfbdknbJb0N/e1t6G9vQ391r5f3enmvl/d6ea+X93p5r5f3enmvl/d6da9X93p1r5f3enmvl/d6ea+37ZK2S3ob+tvb0N/ehv7qXi/v9fJeL+/18l4v7/XyXi/v9fJeL+/16l6v7vXqXi/v9fJeL+/18l7v2CVjl8w29He2ob+zDf3VvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r1b1e3evVvV7e6+W9Xt7r5b3esUvGLplt6O9sQ39nG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9Y5eMXTLb0N/Zhv7ONvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6xy4Zu2S2ob+zDf2dbeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fFeH+/1/XaXvN/ukvfbhv79tqF/v23on+718V4f7/XxXh/v9fFeH+/18V4f7/XxXp/u9elen+718V4f7/XxXh/v9f12l7zf7pL324b+/bahf79t6J/u9fFeH+/18V4f7/XxXh/v9fFeH+/18V6f7vXpXp/u9fFeH+/18V4f7/X9dpe83+6S99uG/v22oX+/beif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1/XaXvN/1L2Ab+vfbhv79tqF/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzX9xv/Asa/gG3o328b+vfbhv7pXh/v9fFeH+/18V4f7/XxXh/v9fFeH+/16V6f7vXpXh/v9fFeH+/18V7ft7vkfbtL3rcN/fu2oX/fNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6vt0l79td8r5t6N+3Df37tqF/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzX9+0ued/ukvdtQ/++bejftw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vu/5F/D8C9iG/n3b0L9vG/qne32818d7fbzXx3t9vNfHe32818d7fbzXp3t9utene32818d7fbzXx3t9YZeEXRLb0L/Yhv7FNvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f6wi4JuyS2oX+xDf2Lbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1hV0SdklsQ/9iG/oX29A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7rC7sk7JLYhv7FNvQvtqF/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzXF3ZJ2CWxDf2LbehfbEP/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+nivL+2StEtyG/qX29C/3Ib+6V4f7/XxXh/v9fFeH+/18V4f7/XxXh/v9elen+716V4f7/XxXh/v9fFeX9olaZfkNvQvt6F/uQ39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vrRL0i7JbehfbkP/chv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fWmXpF2S29C/3Ib+5Tb0T/f6eK+P9/p4r4/3+nivj/f6eK+P9/p4r0/3+nSvT/f6eK+P9/p4r4/3+tIuSbuktqF/tQ39q23on+718V4f7/XxXh/v9fFeH+/18V4f7/XxXp/u9elen+718V4f7/XxXh/v9ZVdUnZJbUP/ahv6V9vQP93r470+3uvjvT7e6+O9Pt7r470+3uvjvT7d69O9Pt3r470+3uvjvT7e6yu7pOyS2ob+1Tb0r7ahf7rXx3t9vNfHe32818d7fbzXx3t9vNfHe32616d7fbrXx3t9vNfHe32811d2SdkltQ39q23oX21D/3Svj/f6eK+P9/p4r4/3+nivj/f6eK+P9/p0r0/3+nSvj/f6eK+P9/p4r6/skrJLahv6V9vQv9qG/uleH+/18V4f7/XxXh/v9fFeH+/18V4f7/XpXp/u9eleH+/18V4f7/XxXt+xS45dcrahf2cb+ne2oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNd37JJjl5xt6N/Zhv6dbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1Hbvk2CVnG/p3tqF/Zxv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fccuOXbJ2Yb+nW3o39mG/uleH+/18V4f7/XxXh/v9fFeH+/18V4f7/XpXp/u9eleH+/18V4f7/XxXt+xS45dcrahf2cb+ne3oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNd37ZJrl9xt6N/dhv7dbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1Xbvk2iV3G/p3t6F/dxv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fdcuuXbJ3Yb+3W3o392G/uleH+/18V4f7/XxXh/v9fFeH+/18V4f7/XpXp/u9eleH+/18V4f7/XxXt+1S65dcrehf3cb+ne3oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNf37JJnl7xt6N/bhv69beif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1Pbvk2SVvG/r3tqF/bxv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fc8ueXbJ24b+vW3o39uG/uleH+/18V4f7/XxXh/v9fFeH+/18V4f7/XpXp/u9eleH+/18V4f7/XxXt+zS55d8rahf28b+ve2oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNf37JJnl7xt6N/bhv69beif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1tV3SdklvQ/96G/rX29A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7ra7uk7ZLehv71NvSvt6F/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzX13ZJ2yW9Df3rbehfb0P/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+nivr+2Stkt6G/rX29C/3ob+6V4f7/XxXh/v9fFeH+/18V4f7/XxXh/v9elen+716V4f7/XxXh/v9fFe39glY5fMNvRvtqF/sw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vrFLxi6ZbejfbEP/Zhv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fWOXjF0y29C/2Yb+zTb0T/f6eK+P9/p4r4/3+nivj/f6eK+P9/p4r0/3+nSvT/f6eK+P9/p4r4/3+sYuGbtktqF/sw39m23on+718V4f7/XxXh/v9fFeH+/18V4f7/XxXp/u9elen+718V4f7/XxXh/v9Y1dMnbJbEP/Zhv6N9vQP93r470+3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/9213Sv90l/duGvn/b0PdvG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99m93Sf92l/RvG/r+bUPfv23oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99q/3SX9213Sv23o+7cNff+2oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5r/9q/gPYvYBv6/m1D379t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fa3+6S/naX9LcNfX/b0Pe3DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9td0t/ukv62oe9vG/r+tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea3+7S/rbXdLfNvT9bUPf3zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+1vd0l/17+Abej724a+v23oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99rf+Bcw/gVsQ9/fNvT9bUPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81w67JOyS2Ia+Yxv6jm3oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99phl4RdEtvQd2xD37ENfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81477JKwS2Ib+o5t6Du2oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rh10SdklsQ9+xDX3HNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177bRL0i7Jbeg7t6Hv3Ia+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r512SdoluQ195zb0ndvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277XTLkm7JLeh79yGvnMb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122iVpl+Q29J3b0HduQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXTrsk7ZLchr5zG/rObehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32mWXlF1S29B3bUPftQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXrvskrJLahv6rm3ou7ahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3muXXVJ2SW1D37UNfdc29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtskvKLqlt6Lu2oe/ahr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvXXZJ2SVnG/o+29D32Ya+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r33skmOXnG3o+2xD32cb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r32sUuOXXK2oe+zDX2fbehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32scuOXbJ2Ya+zzb0fbahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3msfu+TYJWcb+j7b0PfZhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvfe2Sa5fcbej7bkPfdxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfa1S65dcreh77sNfd9t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fa1y65dsndhr7vNvR9t6Fv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea1+75Noldxv6vtvQ992GvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea997ZJrl9xt6PtuQ99vG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99rNLnl3ytqHvtw19v23oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99rPLnl2yduGvt829P22oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rP7vk2SVvG/p+29D324a+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r/3skmeXvG3o+21D328b+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122yVtl/Q29N3b0HdvQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXbruk7ZLehr57G/rubehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32m2XtF3S29B3b0PfvQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXrvtkrZLehv67m3ou7ehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mu3XdJ2SW9D370Nffc29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtsUvGLplt6Hu2oe/Zhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvPXbJ2CWzDX3PNvQ929C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtccuGbtktqHv2Ya+Zxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfbYJWOXzDb0PdvQ92xD37rX5r0277V5r817bd5r816b99q81+a9tu61da+tex3e6/Beh/c6vNf57S6Z3+6S+W1DP79t6Oe3Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be57e7ZH67S+a3Df38tqGf3zb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De53f7pL57S6Z3zb089uGfn7b0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91fs+/gOdfwDb089uGfn7b0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91fuNfwPgXsA39/Lahn9829KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udb3fJfLtL5tuGfr5t6Ofbhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv8+0umW93yXzb0M+3Df1829CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdb7dJfPtLplvG/r5tqGfbxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc7X/gW0fwHb0M+3Df1829CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdcIuCbsktqGf2IZ+Yhv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvU7YJWGXxDb0E9vQT2xDP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNcJuyTsktiGfmIb+olt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6YZeEXRLb0E9sQz+xDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/BeJ+ySsEtiG/qJbegntqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e66RdknZJbkM/uQ395Db0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De520S9IuyW3oJ7ehn9yGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK+TdknaJbkN/eQ29JPb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du910i5JuyS3oZ/chn5yG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtklZZfUNvRT29BPbUM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81ym7pOyS2oZ+ahv6qW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zpll5RdUtvQT21DP7UN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F6n7JKyS2ob+qlt6Ke2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rlF1SdkltQz+1Df3UNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWOXHLvkbEM/Zxv6OdvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73WOXXLskrMN/Zxt6OdsQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXOXbJsUvONvRztqGfsw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXufYJccuOdvQz9mGfs429KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udY5ccu+RuQz93G/q529CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vda5dcu2Suw393G3o525DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNe5dsm1S+429HO3oZ+7Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be59ol1y6529DP3YZ+7jb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De51rl1y75G5DP3cb+rnb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91nl3y7JK3Df28bejnbUM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq813l2ybNL3jb087ahn7cN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F7n2SXPLnnb0M/bhn7eNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWeXPLvkbUM/bxv6edvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73WeXfLskrcN/bxt6Ke3oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rtF3SdklvQz+9Df30NvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbZL2i7pbeint6Gf3oZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r9N2SdslvQ399Db009vQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XaLmm7pLehn96Gfnob+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3O2CVjl8w29DPb0M9sQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXGbtk7JLZhn5mG/qZbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OmOXjF0y29DPbEM/sw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXmfskrFLZhv6mW3oZ7ahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uuMXTJ2yWxDP7MN/cw29LPd6//+C+ffLfn7/HyGz/RZPo/P6/P5bJ/+2uevff7av9+E/z7TZ/k8Pq/P5/O/y/X3+d/l+t/nv4b+79NfC28LbwtvC28LbwtvC28Lb0tvS38t/bX019Lb0tvS29Lb/u2Sv8/Zz38N/d/nty/+19D/ffpr5W3lbeVt5W3lbeVtx9uOtx1vO/7a8deOv3a87Xjb8bbjbf92yd/n5zP2xf8a+r/P2hdff+162/W2623X2563PW973va87Xnb89eev/b8tedtz9va29rb2r+A9i/gX0P/93n2xf8a+r9Pf629rb1tvG28bbxtvG28bbxtvG38tfHX3JL1Xv8+P5/hM32Wz+Pz/nvx96+h//vsfy/+3JLPLfnckvVe/z7TZ/k8Pq/P57N9+mvhr7kl673+fXpbeFt4W1yfz+deri/2cn25l+tzSz635HNL1nv9+/S29Lb0tvS29LbytvLXyl9zS9Z7/fv0tvK28rZqn/sv4Dt7ub6zl+s7e7k+t+RzSz63ZL3Xv09vO952vO162/W2623XX7v+mluy3uvfp7ddb7ve9vwLeP4FvL1c39vL9b29XJ9b8rkln1uy3uvfp7e1t7W3tbe1t7W3tb/W/ppbst7r36e3jbeNt41/AeNfwOzl+mYv1zd7uT635HNLPrck7JKwS8IuCbsk7JKwS8IuCbsk7JJwS9Z7/fv8fIbP9Fk+j8+9XPHt5YpvL1e4JeGWhFsSdknYJWGXhF0SdknYJWGXhF0Sdkm4Jeu9/n16m10SdknYJWGXRO7litzLFbWXK9yScEvCLQm7JOySsEvCLgm7JOySsEvCLgm7JNyS9V7/Pr3NLgm7JOySsEvi7uWKu5cr7l6ucEvCLQm3JOySsEvCLgm7JOySsEvCLgm7JOyScEvWe/379Da7JOySsEvCLoneyxW9lyt6L1e4JeGWhFsSdknYJWGXhF0SdknYJWGXhF0Sdkm4Jeu9/n3u29IuSbsk7ZK0S/K3lyt/e7nyt5cr3ZJ0S9ItSbsk7ZK0S9IuSbsk7ZK0S9IuSbsk3ZL1Xv8+vc0uSbsk7ZK0SzL2cmXs5crYy5VuSbol6ZakXZJ2SdolaZekXZJ2SdolaZekXZJuyXqvf5/eZpekXZJ2SdolWXu5svZy5dnLlW5JuiXplqRdknZJ2iVpl6RdknZJ2iVpl6Rdkm7Jeq9/n95ml6RdknZJ2iX59nLl28uVby9XuiXplqRbknZJ2iVpl6RdknZJ2iVpl6RdknZJuiXrvf59eptdknZJ2iVpl+Ts5crZy5WzlyvdknRL0i1JuyTtkrJLyi4pu6TskrJLyi4pu6TckvVe/z73bWWXlF1SdknZJfXt5apvL1d9e7nKLSm3pNySskvKLim7pOySskvKLim7pOySskvKLVnv9e/T2+ySskvKLim7pHIvV+Versq9XOWWlFtSbknZJWWXlF1SdknZJWWXlF1SdknZJeWWrPf69+ltdknZJWWXlF1SZy9Xnb1cdfdylVtSbkm5JWWXlF1SdknZJWWXlF1SdknZJWWXlFuy3uvfp7fZJWWXlF1Sdkn1Xq7qvVzVe7nKLSm3pNySskvKLim7pOySskvKLim7pOySskvKLVnv9e/T2+ySskuOXXLskvPby3V+e7nOby/XcUuOW3LckmOXHLvk2CXHLjl2ybFLjl1y7JJjlxy3ZL3Xv09vs0uOXXLskmOXnNjLdWIv14m9XMctOW7JcUuOXXLskmOXHLvk2CXHLjl2ybFLjl1y3JL1Xv8+vc0uOXbJsUuOXXJqL9epvVyn9nIdt+S4JcctOXbJsUuOXXLskmOXHLvk2CXHLjl2yXFL1nv9+/Q2u+TYJccuOXbJuXu5zt3Ldd5eruOWHLfkuCXHLjl2ybFLjl1y7JJjlxy75Nglxy45bsl6r3+f3maXHLvk2CXHLjmzl+vMXq4ze7mOW3LckuOWHLvk2CXHLjl2ybVLrl1y7ZJrl1y75Lol673+fT6f7XPfdu2Sa5fcby/X/fZy3W8v13VLrlty3ZJrl1y75Nol1y65dsm1S65dcu2Sa5dct2S9179Pb7NLrl1y7ZJrl9zcy3VzL9fNvVzXLbluyXVLrl1y7ZJrl1y75Nol1y65dsm1S65dct2S9V7/Pr3NLrl2ybVLrl1yz16ue/Zy3bOX67ol1y25bsm1S65dcu2Sa5dcu+TaJdcuuXbJtUuuW7Le69+nt9kl1y65dsm1S+7by3XfXq7be7muW3LdkuuWXLvk2iXXLrl2ybVLrl1y7ZJrl1y75Lol673+fXqbXXLtkmuXXLvk/fZyvd9ervfby/XckueWPLfk2SXPLnl2ybNLnl3y7JJnlzy75Nklzy15fhN+fhN+dsmzS55d8uySF3u5XuzlerGX67klzy15bsmzS55d8uySZ5c8u+TZJc8ueXbJs0ueW/L8Jvz8JvzskmeXPLvk2SWv9nK92sv1ai/Xc0ueW/LckmeXPLvk2SXPLnl2ybNLnl3y7JJnlzy35PlN+PlN+Nklzy55dsmzS97dy/XuXq5393I9t+S5Jc8teXbJs0ueXfLskmeXPLvk2SXPLnl2yXNLnt+En9+En13y7JJnlzy75PVertd7ud7s5XpuyXNLnlvy7JJnlzy75Nklzy55dknbJW2XtF3Sbkn7Tbj9Jtx2SdslbZe0XdLfXq7+9nL1t5er3ZJ2S9otabuk7ZK2S9ouabuk7ZK2S9ouabuk3ZL2m3D7TbjtkrZL2i5pu6RzL1fnXq7OvVztlrRb0m5J2yVtl7Rd0nZJ2yVtl7Rd0nZJ2yXtlrTfhNtvwm2XtF3SdknbJX32cvXZy9VnL1e7Je2WtFvSdknbJW2XtF3SdknbJW2XtF3Sdkm7Je034fabcNslbZe0XdJ2Sb+9XP32cvXby9VuSbsl7Za0XdJ2SdslbZe0XdJ2SdslbZe0XdJuSftNuP0m3HZJ2yVtl7Rd0rOXq2cv1/z2co1bMm7JuCVjl4xdMnbJ2CVjl4xdMnbJ2CVjl4xbMn4THr8Jj10ydsnYJWOXTOzlmtjLNbGXa9yScUvGLRm7ZOySsUvGLhm7ZOySsUvGLhm7ZNyS8Zvw+E147JKxS8YuGbtkai/X1F6uqb1c45aMWzJuydglY5eMXTJ2ydglY5eMXTJ2ydgl45aM34THb8Jjl4xdMnbJ2CVz93LN3cs1dy/XuCXjloxbMnbJ2CVjl4xdMnbJ2CVjl4xdMnbJuCXjN+Hxm/DYJWOXjF0ydsn0Xq7pvVzTe7nGLRm3ZNySsUvGLhm7ZOySsUvGLhm7RPf66V4/3eu33uvfZ/osn8fn9fl8/rtc3+9fQ/+/z38N/d+nv7a35Fvv9e+zfB6f1+fz2T69Lbwt/LXw18JfC28LbwtvC2/bXfL9dpd8v38N/d/nty/+19D/ffpr6W3pbelt6W3pbelt5W3lbeVt5a+Vv1b+WnlbeVt5W3nb7pLvt7vk+/1r6P8+c1/8r6H/+/TXjrcdbzvedrztetv1tutt19uut11/7fpr11+73na97Xnb87bnX8DzL+BfQ//3efbF/xr6v09/7Xnb87b2tva29rb2tva29rb2tvbX2l9rf228bbxtvG28bfwLGP8C/jX0f59vX/yvof/73L/2uSWfW7Le699n+iyfx+f1+Xy2T3/t89fckvVe/z7TZ/k8Pq/P53Mv17cN/fdtQ//pXr/PLfnckvVe/z69LbwtvC28LbwtvS39tfTX3JL1Xv8+vS29Lb1td8n37S75vm3ov28b+u/bhv7TvX6fW/K5Jeu9/n16W3lbedvxtuNtx9uOv3b8Nbdkvde/T2873na8bXfJ9+0u+b5t6L9vG/rv24b+071+n1vyuSXrvf59etvztudtz9uetz1ve/7a89fckvVe/z69rb2tva39C2j/Arah/75t6L9vG/pP9/p9bsnnlqz3+vfpbeNt423jbeNt423jr42/5pas9/r3+fkMn+mzfB6fe7liG/ovtqH/dK9fuCXhloRdEnZJ2CVhl4RdEnZJ2CW610/3+ulev/Ve/z69zS4JuyTskrBLYhv6L7ah/2Ib+k/3+oVbEm5J2CVhl4RdEnZJ2CVhl4Rdonv9dK+f7vVb7/Xv09vskrBLwi4JuyS2of9iG/ovtqH/dK9fuCXhloRdEnZJ2CVhl4RdEnZJ2CW610/3+ulev/Ve/z69zS4JuyTskrBLYhv6L7ah/2Ib+k/3+oVbEm5J2CVhl4RdEnZJ2CVhl4Rdonv9dK+f7vVb7/Xv09vskrBLwi4JuyS2of9iG/ovtqH/dK9fuCXhlqRdknZJ2iVpl6RdknZJ2iW610/3+ulev/Ve/z4/n+EzfZbP43MvV25D/+U29J/u9Uu3JN2StEvSLkm7JO2StEvSLkm7RPf66V4/3eu33uvfp7fZJWmXpF2SdkluQ//lNvRfbkP/6V6/dEvSLUm7JO2StEvSLkm7JO2StEt0r5/u9dO9fuu9/n16m12SdknaJWmX5Db0X25D/+U29J/u9Uu3JN2StEvSLkm7JO2StEvSLkm7RPf66V4/3eu33uvfp7fZJWmXpF2SdkluQ//lNvRfbkP/6V6/dEvSLUm7JO2StEvSLkm7JO2StEt0r5/u9dO9fuu9/n3u28ouKbuk7JKyS2ob+q+2of9qG/pP9/qVW1JuSdklZZeUXVJ2SdklZZeUXaJ7/XSvn+71W+/179Pb7JKyS8ouKbuktqH/ahv6r7ah/3SvX7kl5ZaUXVJ2SdklZZeUXVJ2SdklutdP9/rpXr/1Xv8+vc0uKbuk7JKyS2ob+q+2of9qG/pP9/qVW1JuSdklZZeUXVJ2SdklZZeUXaJ7/XSvn+71W+/179Pb7JKyS8ouKbuktqH/ahv6r7ah/3SvX7kl5ZaUXVJ2SdklZZeUXVJ2SdklutdP9/rpXr/1Xv8+vc0uKbuk7JKyS2ob+q+2of9qG/pP9/qVW1JuSdklZZccu+TYJccuOXbJsUt0r5/u9dO9fuu9/n3u245dcuySY5ccu+RsQ/+dbei/sw39p3v9jlty3JJjlxy75Nglxy45dsmxS45donv9dK+f7vVb7/Xv09vskmOXHLvk2CVnG/rvbEP/nW3oP93rd9yS45Ycu+TYJccuOXbJsUuOXXLsEt3rp3v9dK/feq9/n95mlxy75Nglxy4529B/Zxv672xD/+lev+OWHLfk2CXHLjl2ybFLjl1y7JJjl+heP93rp3v91nv9+/Q2u+TYJccuOXbJ2Yb+O9vQf2cb+k/3+h235Lglxy45dsmxS45dcuySY5ccu0T3+uleP93rt97r36e32SXHLrl2ybVL7jb0392G/rvb0H+61++6JdctuXbJtUuuXXLtkmuXXLvk2iW610/3+ulev/Ve/z69zS65dsm1S65dcreh/+429N/dhv7TvX7XLbluybVLrl1y7ZJrl1y75Nol1y7RvX6610/3+q33+vfpbXbJtUuuXXLtkrsN/Xe3of/uNvSf7vW7bsl1S65dcu2Sa5dcu+TaJdcuuXaJ7vXTvX6612+9179Pb7NLrl1y7ZJrl9xt6L+7Df13t6H/dK/fdUuuW3LtkmuXXLvk2iXXLrl2ybVLdK+f7vXTvX7rvf59eptdcu2Sa5dcu+RuQ//dbei/uw39p3v9rlty3ZJrl1y75Nol1y55dsmzS55donv9dK+f7vV7fhN+fhN+dsmzS55d8uyStw3997ah/9429J/u9XtuyXNLnl3y7JJnlzy75Nklzy55donu9dO9frrX7/lN+PlN+Nklzy55dsmzS9429N/bhv5729B/utfvuSXPLXl2ybNLnl3y7JJnlzy75NklutdP9/rpXr/nN+HnN+Fnlzy75Nklzy5529B/bxv6721D/+lev+eWPLfk2SXPLnl2ybNLnl3y7JJnl+heP93rp3v9nt+En9+En13y7JJnlzy75G1D/71t6L+3Df2ne/2eW/LckmeXPLvk2SXPLnl2ybNLnl2ie/10r5/u9Xt+E35+E352ybNLnl3y7JLehv7rbei/3ob+071+7Za0W9J2SdslbZe0XdJ2SdslbZfoXj/d66d7/dpvwu034bZL2i5pu6Ttkt6G/utt6L/ehv7TvX7tlrRb0nZJ2yVtl7Rd0nZJ2yVtl+heP93rp3v92m/C7TfhtkvaLmm7pO2S3ob+623ov96G/tO9fu2WtFvSdknbJW2XtF3SdknbJW2X6F4/3eune/3ab8LtN+G2S9ouabuk7ZLehv7rbei/3ob+071+7Za0W9J2SdslbZe0XdJ2SdslbZfoXj/d66d7/dpvwu034bZL2i5pu6Ttkt6G/utt6L/ehv7TvX7tlrRb0nZJ2yVtl7Rd0nZJ2yVjl+heP93rp3v9xm/C4zfhsUvGLhm7ZOyS2Yb+m23ov9mG/tO9fuOWjFsydsnYJWOXjF0ydsnYJWOX6F4/3eune/3Gb8LjN+GxS8YuGbtk7JLZhv6bbei/2Yb+071+45aMWzJ2ydglY5eMXTJ2ydglY5foXj/d66d7/cZvwuM34bFLxi4Zu2TsktmG/ptt6L/Zhv7TvX7jloxbMnbJ2CVjl4xdMnbJ2CVjl+heP93rp3v9xm/C4zfhsUvGLhm7ZOyS2Yb+m23ov9mG/tO9fuOWjFsydsnYJWOXjF0ydsnYJWOX6F4/3eune/3Gb8LjN+GxS8YuGbtk7JLZhv6bbejjtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuO3uyR+u0vitw19/Lahj9829KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuN3+6S+O0uid829PHbhj5+29CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNX67S+K3uyR+29DHbxv6+G1DH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNf4tX8B7V/ANvTx24Y+ftvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zW+3SXx/93rf5//Lld829DHtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuPbXRLf7pL4tqGPbxv6+LahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mt8u0vi210S3zb08W1DH9829KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuN7/kX8PwL2IY+vm3o49uGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK/xjX8B41/ANvTxbUMf3zb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42wS8IuiW3oI7ahj9iGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8RdknYJbENfcQ29BHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81wi4JuyS2oY/Yhj5iG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9RtglYZfENvQR29BHbEMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq810i7JO2S3IY+/r97nf//3Mulew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbRL0i7Jbegjt6GP3IY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r5F2SdoluQ195Db0kdvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXSLkm7JLehj9yGPnIb+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2iVpl+Q29JHb0EduQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXKLuk7JLahj5qG/qobehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GmWXlF1S29BHbUMftQ196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXqPskrJLahv6qG3oo7ahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3muUXVJ2SW1DH7UNfdQ29KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNY5ccu+RsQx9nG/o429CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNY5dcuySsw19nG3o42xDH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNc4dsmxS8429HG2oY+zDX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be49glxy4529DH2YY+zjb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be41jlxy75GxDH2cb+jjb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81rl1y7ZK7DX3cbejjbkMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq817h2ybVL7jb0cbehj7sNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F7j2iXXLrnb0Mfdhj7uNvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jWuXXLvkbkMfdxv6uNvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zWeXfLskrcNfbxt6ONtQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXeHbJs0veNvTxtqGPtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuPZJc8uedvQx9uGPt429KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNZ5c8u+RtQx9vG/p429CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNZ5d8uyStw19vG3o421DH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNdou6Ttkt6GPnob+uht6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/cabZe0XdLb0EdvQx+9DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Beo+2Stkt6G/robeijt6EP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea7Rd0nZJb0MfvQ199Db0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be422S9oumW3oY7ahj9mGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK8xdsnYJbMNfcw29DHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81xi4Zu2S2oY/Zhj5mG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9xtglY5fMNvQx29DHbEMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq81xi7ZOyS2YY+Zhv6mG3oQ/cavNfgvQbvNXivwXsN3mvwXoP3mrzX1L2m7jV1r8l7Td5r8l6T95q/3SX5212Sv23o87cNff62oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5r/naX5G93Sf62oc/fNvT524Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/nbXZK/3SX524Y+f9vQ528b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3m7/kX8PwL2IY+f9vQ528b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3mb/wLGP8CtqHP3zb0+W1Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNf8dpfkt7skv23o89uGPr9t6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/ea3+6S/HaX5LcNfX7b0Oe3DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Je89tdkt/ukvy2oc9vG/r8tqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea37tX0D7F7ANfX7b0Oe3DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/JeM+ySsEtiG/qMbegztqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea4ZdEnZJbEOfsQ19xjb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82wS8IuiW3oM7ahz9iGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea8ZdknYJbENfcY29Bnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81wy4JuyS2oc/Yhj5jG/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S9ZtolaZfkNvSZ29BnbkOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q810y7JO2S3IY+cxv6zG3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95ppl6RdktvQZ25Dn7kNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l4z7ZK0S3Ib+sxt6DO3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rll1SdkltQ5+1DX3WNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zbJLyi6pbeiztqHP2oY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r1l2SdkltQ191jb0WdvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXLLim7pLahz9qGPmsb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L1m2SVll9Q29Fnb0GdtQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXPHbJsUvONvR5tqHPsw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXvPYJccuOdvQ59mGPs829Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNY5ccu+RsQ59nG/o829Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNY9dcuySsw19nm3o82xDn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNe8dsm1S+429Hm3oc+7DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Je89ol1y6529Dn3YY+7zb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je81rl1y75G5Dn3cb+rzb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81r11y7ZK7DX3ebejzbkOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q817x2ybVL7jb0ebehz7sNfepek/eavNfkvSbvNXmvyXtN3mvyXpP3mrrX1L2m7jV5r8l7Td5r8l7z2SXPLnnb0Ofbhj7fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zWeXPLvkbUOfbxv6fNvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zWfXfLskrcNfb5t6PNtQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXfHbJs0veNvT5tqHPtw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXrPtkrZLehv67G3os7ehT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mu2XdJ2SW9Dn70NffY29Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNtkvaLult6LO3oc/ehj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmv2XZJ2yW9DX32NvTZ29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNdsuabukt6HP3oY+exv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvebYJWOXzDb0OdvQ52xDn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNccu2TsktmGPmcb+pxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaY5eMXTLb0OdsQ5+zDX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Jec+ySsUtmG/qcbehztqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea45dMrtL6rcNff22oa/fNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rd/ukvrtLqnfNvT124a+ftvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77V+u0vqt7ukftvQ128b+vptQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzX+u0uqd/ukvptQ1+/bejrtw196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXuvX/gW0fwHb0NdvG/r6bUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81/p2l9S3u6S+bejr24a+vm3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rf7pL6dpfUtw19fdvQ17cNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V7r211S3+6S+rahr28b+vq2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rfc+/gOdfwDb09W1DX9829KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutb/wLGP8CtqGvbxv6im3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91phl4RdEtvQV2xDX7ENfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V4r7JKwS2Ib+opt6Cu2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rhV0SdklsQ1+xDX3FNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbBLwi6JbegrtqGv2Ia+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r5V2SdoluQ195Tb0ldvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XSLkm7JLehr9yGvnIb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r1W2iVpl+Q29JXb0FduQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXSrsk7ZLchr5yG/rKbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WmmXpF2S29BXbkNfuQ196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXqvskrJLahv6qm3oq7ahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3muVXVJ2SW1DX7UNfdU29KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutskvKLqlt6Ku2oa/ahr50r8V7Ld5r8V6L91q81+K9Fu/1/4i6lxzJlWXLglNympn+5j+xqjjvpkqPyA7BRig24IKVT+/16b0+7vVxr497fXqvT+/16b0+vdf37JJnl7w19O+toX9vDf3jXp/e69N7fXqvT+/16b0+vden9/r0Xp/e6+NeH/f6uNen9/r0Xp/e69N7fWGXhF0Sa+hfrKF/sYb+ca9P7/XpvT6916f3+vRen97r03t9eq9P7/Vxr497fdzr03t9eq9P7/Xpvb6wS8IuiTX0L9bQv1hD/7jXp/f69F6f3uvTe316r0/v9em9Pr3Xp/f6uNfHvT7u9em9Pr3Xp/f69F5f2CVhl8Qa+hdr6F+soX/c69N7fXqvT+/16b0+vden9/r0Xp/e69N7fdzr414f9/r0Xp/e69N7fXqvL+ySsEtiDf2LNfQv1tA/7vXpvT6916f3+vRen97r03t9eq9P7/XpvT7u9XGvj3t9eq9P7/XpvT691xd2SdglsYb+xRr6F2voH/f69F6f3uvTe316r0/v9em9Pr3Xp/f69F4f9/q418e9Pr3Xp/f69F6f3utLuyTtklxD/3IN/cs19I97fXqvT+/16b0+vden9/r0Xp/e69N7fXqvj3t93OvjXp/e69N7fXqvT+/1pV2SdkmuoX+5hv7lGvrHvT6916f3+vRen97r03t9eq9P7/XpvT6918e9Pu71ca9P7/XpvT6916f3+tIuSbsk19C/XEP/cg39416f3uvTe316r0/v9em9Pr3Xp/f69F6f3uvjXh/3+rjXp/f69F6f3uvTe31pl6RdkmvoX66hf7mG/nGvT+/16b0+vden9/r0Xp/e69N7fXqvT+/1ca+Pe33c69N7fXqvT+/16b2+skvKLqk19K/W0L9aQ/+416f3+vRen97r03t9eq9P7/XpvT6916f3+rjXx70+7vXpvT6916f3+vReX9klZZfUGvpXa+hfraF/3OvTe316r0/v9em9Pr3Xp/f69F6f3uvTe33c6+NeH/f69F6f3uvTe316r6/skrJLag39qzX0r9bQP+716b0+vden9/r0Xp/e69N7fXqvT+/16b0+7vVxr497fXqvT+/16b0+vddXdknZJbWG/tUa+ldr6B/3+vRen97r03t9eq9P7/XpvT6916f3+vReH/f6uNfHvT6916f3+vRen97rK7uk7JJaQ/9qDf2rNfSPe316r0/v9em9Pr3Xp/f69F6f3uvTe316r497fdzr416f3uvTe316r0/v9bVd0nZJr6F/vYb+9Rr6x70+vden9/r0Xp/e69N7fXqvT+/16b0+vdfHvT7u9XGvT+/16b0+vden9/raLmm7pNfQv15D/3oN/eNen97r03t9eq9P7/XpvT6916f3+vRen97r414f9/q416f3+vRen97r03t9bZe0XdJr6F+voX+9hv5xr0/v9em9Pr3Xp/f69F6f3uvTe316r0/v9XGvj3t93OvTe316r0/v9em9vrZL2i7pNfSv19C/XkP/uNen9/r0Xp/e69N7fXqvT+/16b0+vden9/q418e9Pu716b0+vden9/r0Xt/YJWOXzBr6N2vo36yhf9zr03t9eq9P7/XpvT6916f3+vRen97r03t93OvjXh/3+vRen97r03t9eq9v7JKxS2YN/Zs19G/W0D/u9em9Pr3Xp/f69F6f3uvTe316r0/v9em9Pu71ca+Pe316r0/v9em9Pr3XN3bJ2CWzhv7NGvo3a+gf9/r0Xp/e69N7fXqvT+/16b0+vden9/r0Xh/3+rjXx70+vden9/r0Xp/e6xu7ZOySWUP/Zg39mzX0j3t9eq9P7/XpvT6916f3+vRen97r03t9eq+Pe33c6+Nen97r03t9eq9P7/WNXTJ2yayhf7OG/s0a+se9Pr3Xp/f69F6f3uvTe316r6H3Gnqvofca3Gtwr8G9ht5r6L2G3mvovcZvd0n8dpfEbw19/NbQx28NfXCvofcaeq+h9xp6r6H3Gnqvofcaeq+h9xrca3Cvwb2G3mvovYbea+i9xm93Sfx2l8RvDX381tDHbw19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L3Gb3dJ/HaXxG8NffzW0MdvDX1wr6H3Gnqvofcaeq+h9xp6r6H3Gnqvofca3Gtwr8G9ht5r6L2G3mvovcav/AWUv4A19PFbQx+/NfTBvYbea+i9ht5r6L2G3mvovYbea+i9ht5rcK/BvQb3Gnqvofcaeq+h9xq/8RewuyS+NfTxraGPbw19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L3Gt7skvt0l8a2hj28NfXxr6IN7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgXoN7De419F5D7zX0XkPvNb7dJfHtLolvDX18a+jjW0Mf3GvovYbea+i9ht5r6L2G3mvovYbea+i9Bvca3Gtwr6H3Gnqvofcaeq/x7S6Jb3dJfGvo41tDH98a+uBeQ+819F5D7zX0XkPvNfReQ+819F5D7zW41+Beg3sNvdfQew2919B7ja/9BbS/gDX08a2hj28NfXCvofcaeq+h9xp6r6H3Gnqvofcaeq+h9xrca3Cvwb2G3mvovYbea+i9xrFLjl1y1tDHWUMfZw19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L3GsUuOXXLW0MdZQx9nDX1wr6H3Gnqvofcaeq+h9xp6r6H3Gnqvofca3Gtwr8G9ht5r6L2G3mvovcaxS45dctbQx1lDH2cNfXCvofcaeq+h9xp6r6H3Gnqvofcaeq+h9xrca3Cvwb2G3mvovYbea+i9xrFLjl1y1tDHWUMfZw19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L3GsUuOXXLW0MdZQx93DX1wr6H3Gnqvofcaeq+h9xp6r6H3Gnqvofca3Gtwr8G9ht5r6L2G3mvovca1S65dctfQx11DH3cNfXCvofcaeq+h9xp6r6H3Gnqvofcaeq+h9xrca3Cvwb2G3mvovYbea+i9xrVLrl1y19DHXUMfdw19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L3GtUuuXXLX0MddQx93DX1wr6H3Gnqvofcaeq+h9xp6r6H3Gnqvofca3Gtwr8G9ht5r6L2G3mvovca1S65dctfQx11DH3cNfXCvofcaeq+h9xp6r6H3Gnqvofcaeq+h9xrca3Cvwb2G3mvovYbea+i9xrNLnl3y1tDHW0Mfbw19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L3Gs0ueXfLW0MdbQx9vDX1wr6H3Gnqvofcaeq+h9xp6r6H3Gnqvofca3Gtwr8G9ht5r6L2G3mvovcazS55d8tbQx1tDH28NfXCvofcaeq+h9xp6r6H3Gnqvofcaeq+h9xrca3Cvwb2G3mvovYbea+i9xrNLnl3y1tDHW0Mfbw19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L3Gs0ueXfLW0MdbQx9vDX1wr6H3Gnqvofcaeq+h9xp6r6H3Gnqvofca3Gtwr8G9ht5r6L2G3mvovUbYJWGXxBr6iDX0EWvog3sNvdfQew2919B7Db3X0HsNvdfQew291+Beg3sN7jX0XkPvNfReQ+81wi4JuyTW0EesoY9YQx/ca+i9ht5r6L2G3mvovYbea+i9ht5r6L0G9xrca3Cvofcaeq+h9xp6rxF2SdglsYY+Yg19xBr64F5D7zX0XkPvNfReQ+819F5D7zX0XkPvNbjX4F6Dew2919B7Db3X0HuNsEvCLok19BFr6CPW0Af3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/BvQb3Gtxr6L2G3mvovYbea6RdknZJrqGPXEMfuYY+uNfQew2919B7Db3X0HsNvdfQew2919B7De41uNfgXkPvNfReQ+819F4j7ZK0S3INfeQa+sg19MG9ht5r6L2G3mvovYbea+i9ht5r6L2G3mtwr8G9Bvcaeq+h9xp6r6H3GmmXpF2Sa+gj19BHrqEP7jX0XkPvNfReQ+819F5D7zX0XkPvNfReg3sN7jW419B7Db3X0HsNvddIuyTtklxDH7mGPnINfXCvofcaeq+h9xp6r6H3Gnqvofcaeq+h9xrca3Cvwb2G3mvovYbea+i9RtolaZfkGvrINfSRa+iDew2919B7Db3X0HsNvdfQew2919B7Db3X4F6Dew3uNfReQ+819F5D7zXKLim7pNbQR62hj1pDH9xr6L2G3mvovYbea+i9ht5r6L2G3mvovQb3GtxrcK+h9xp6r6H3GnqvUXZJ2SW1hj5qDX3UGvrgXkPvNfReQ+819F5D7zX0XkPvNfReQ+81uNfgXoN7Db3X0HsNvdfQe42yS8ouqTX0UWvoo9bQB/caeq+h9xp6r6H3Gnqvofcaeq+h9xp6r8G9Bvca3GvovYbea+i9ht5rlF1SdkmtoY9aQx+1hj6419B7Db3X0HsNvdfQew2919B7Db3X0HsN7jW41+BeQ+819F5D7zX0XqPtkrZLeg199Br66DX0wb2G3mvovYbea+i9ht5r6L2G3mvovYbea3Cvwb0G9xp6r6H3GnqvofcabZe0XdJr6KPX0EevoQ/uNfReQ+819F5D7zX0XkPvNfReQ+819F6Dew3uNbjX0HsNvdfQew2912i7pO2SXkMfvYY+eg19cK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GtxrcK/BvYbea+i9ht5r6L1G2yVtl/Qa+ug19NFr6IN7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgXoN7De419F5D7zX0XkPvNdouabuk19BHr6GPXkMf3GvovYbea+i9ht5r6L2G3mvovYbea+i9Bvca3Gtwr6H3Gnqvofcaeq8xdsnYJbOGPmYNfcwa+uBeQ+819F5D7zX0XkPvNfReQ+819F5D7zW41+Beg3sNvdfQew2919B7jbFLxi6ZNfQxa+hj1tAH9xp6r6H3Gnqvofcaeq+h9xp6r6H3Gnqvwb0G9xrca+i9ht5r6L2G3muMXTJ2yayhj1lDH7OGPrjX0HsNvdfQew2919B7Db3X0HsNvdfQew3uNbjX4F5D7zX0XkPvNfReY+ySsUtmDX3MGvqYNfTBvYbea+i9ht5r6L2G3mvovYbea+i9ht5rcK/BvQb3Gnqvofcaeq+h95q/3SX5212SvzX0+VtDn7819Mm9pt5r6r2m3mvqvabea+q9pt5r6r2m3mtyr8m9Jveaeq+p95p6r6n3mr/dJfnbXZK/NfT5W0OfvzX0yb2m3mvqvabea+q9pt5r6r2m3mvqvabea3Kvyb0m95p6r6n3mnqvqfeav90l+dtdkr819PlbQ5+/NfTJvabea+q9pt5r6r2m3mvqvabea+q9pt5rcq/JvSb3mnqvqfeaeq+p95q/3SX5212SvzX0+VtDn7819Mm9pt5r6r2m3mvqvabea+q9pt5r6r2m3mtyr8m9Jveaeq+p95p6r6n3mr/2F9D+AtbQ528Nff7W0Cf3mnqvqfeaeq+p95p6r6n3mnqvqfeaeq/JvSb3mtxr6r2m3mvqvabea367S/LbXZLfGvr81tDnt4Y+udfUe02919R7Tb3X1HtNvdfUe02919R7Te41udfkXlPvNfVeU+819V7z212S3+6S/NbQ57eGPr819Mm9pt5r6r2m3mvqvabea+q9pt5r6r2m3mtyr8m9Jveaeq+p95p6r6n3mt/ukvx2l+S3hj6/NfT5raFP7jX1XlPvNfVeU+819V5T7zX1XlPvNfVek3tN7jW519R7Tb3X1HtNvdf8yl9A+QtYQ5/fGvr81tAn95p6r6n3mnqvqfeaeq+p95p6r6n3mnqvyb0m95rca+q9pt5r6r2m3mt+4y/ALjlr6POsoc+zhj6519R7Tb3X1HtNvdfUe02919R7Tb3X1HtN7jW51+ReU+819V5T7zX1XvPYJccuOWvo86yhz7OGPrnX1HtNvdfUe02919R7Tb3X1HtNvdfUe03uNbnX5F5T7zX1XlPvNfVe89glxy45a+jzrKHPs4Y+udfUe02919R7Tb3X1HtNvdfUe02919R7Te41udfkXlPvNfVeU+819V7z2CXHLjlr6POsoc+zhj6519R7Tb3X1HtNvdfUe02919R7Tb3X1HtN7jW51+ReU+819V5T7zX1XvPYJccuOWvo86yhz7OGPrnX1HtNvdfUe02919R7Tb3X1HtNvdfUe03uNbnX5F5T7zX1XlPvNfVe89ol1y65a+jzrqHPu4Y+udfUe02919R7Tb3X1HtNvdfUe02919R7Te41udfkXlPvNfVeU+819V7z2iXXLrlr6POuoc+7hj6519R7Tb3X1HtNvdfUe02919R7Tb3X1HtN7jW51+ReU+819V5T7zX1XvPaJdcuuWvo866hz7uGPrnX1HtNvdfUe02919R7Tb3X1HtNvdfUe03uNbnX5F5T7zX1XlPvNfVe89ol1y65a+jzrqHPu4Y+udfUe02919R7Tb3X1HtNvdfUe02919R7Te41udfkXlPvNfVeU+819V7z2iXXLrlr6POuoc+3hj6519R7Tb3X1HtNvdfUe02919R7Tb3X1HtN7jW51+ReU+819V5T7zX1XvPZJc8ueWvo862hz7eGPrnX1HtNvdfUe02919R7Tb3X1HtNvdfUe03uNbnX5F5T7zX1XlPvNfVe89klzy55a+jzraHPt4Y+udfUe02919R7Tb3X1HtNvdfUe02919R7Te41udfkXlPvNfVeU+819V7z2SXPLnlr6POtoc+3hj6519R7Tb3X1HtNvdfUe02919R7Tb3X1HtN7jW51+ReU+819V5T7zX1XvPZJc8ueWvo862hz7eGPrnX1HtNvdfUe02919R7Tb3X1HtNvdfUe03uNbnX5F5T7zX1XlPvNfVeM+ySsEtiDX3GGvqMNfTJvabea+q9pt5r6r2m3mvqvabea+q9pt5rcq/JvSb3mnqvqfeaeq+p95phl4RdEmvoM9bQZ6yhT+419V5T7zX1XlPvNfVeU+819V5T7zX1XpN7Te41udfUe02919R7Tb3XDLsk7JJYQ5+xhj5jDX1yr6n3mnqvqfeaeq+p95p6r6n3mnqvqfea3Gtyr8m9pt5r6r2m3mvqvWbYJWGXxBr6jDX0GWvok3tNvdfUe02919R7Tb3X1HtNvdfUe0291+Rek3tN7jX1XlPvNfVeU+81wy4JuyTW0Gesoc9YQ5/ca+q9pt5r6r2m3mvqvabea+q9pt5r6r0m95rca3Kvqfeaeq+p95p6r5l2SdoluYY+cw195hr65F5T7zX1XlPvNfVeU+819V5T7zX1XlPvNbnX5F6Te02919R7Tb3X1HvNtEvSLsk19Jlr6DPX0Cf3mnqvqfeaeq+p95p6r6n3mnqvqfeaeq/JvSb3mtxr6r2m3mvqvabea6ZdknZJrqHPXEOfuYY+udfUe02919R7Tb3X1HtNvdfUe02919R7Te41udfkXlPvNfVeU+819V4z7ZK0S3INfeYa+sw19Mm9pt5r6r2m3mvqvabea+q9pt5r6r2m3mtyr8m9Jveaeq+p95p6r6n3mmWXlF1Sa+iz1tBnraFP7jX1XlPvNfVeU+819V5T7zX1XlPvNfVek3tN7jW519R7Tb3X1HtNvdcsu6TsklpDn7WGPmsNfXKvqfeaeq+p95p6r6n3mnqvqfeaeq+p95rca3Kvyb2m3mvqvabea+q9ZtklZZfUGvqsNfRZa+iTe02919R7Tb3X1HtNvdfUe02919R7Tb3X5F6Te03uNfVeU+819V5T7zXLLim7pNbQZ62hz1pDn9xr6r2m3mvqvabea+q9pt5r6r2m3mvqvSb3mtxrcq+p95p6r6n3mnqvWXZJ2SW1hj5rDX3WGvrkXlPvNfVeU+819V5T7zX1XlPvNfVeU+81udfkXpN7Tb3X1HtNvdfUe822S9ou6TX02Wvos9fQJ/eaeq+p95p6r6n3mnqvqfeaeq+p95p6r8m9Jvea3Gvqvabea+q9pt5rtl3Sdkmvoc9eQ5+9hj6519R7Tb3X1HtNvdfUe02919R7Tb3X1HtN7jW51+ReU+819V5T7zX1XrPtkrZLeg199hr67DX0yb2m3mvqvabea+q9pt5r6r2m3mvqvabea3Kvyb0m95p6r6n3mnqvqfeabZe0XdJr6LPX0GevoU/uNfVeU+819V5T7zX1XlPvNfVeU+819V6Te03uNbnX1HtNvdfUe0291xy7ZOySWUOfs4Y+Zw19cq+p95p6r6n3mnqvqfeaeq+p95p6r6n3mtxrcq/Jvabea+q9pt5r6r3m2CVjl8wa+pw19Dlr6JN7Tb3X1HtNvdfUe02919R7Tb3X1HtNvdfkXpN7Te419V5T7zX1XlPvNccuGbtk1tDnrKHPWUOf3Gvqvabea+q9pt5r6r2m3mvqvabea+q9Jvea3Gtyr6n3mnqvqfeaeq85dsnYJbOGPmcNfc4a+uReU+819V5T7zX1XlPvNfVeU+819V5T7zW51+Rek3v9/4++zW/Ceq+p95pjl4xdMmvoc9bQ56yhT+419V5T7zX1XlPvtfReS++19F5L77X0Xot7Le61uNfSey2919J7Lb3X+u0uqd/ukvqtoa/fGvr6raEv7rX0XkvvtfReS++19F5L77X0XkvvtfRei3st7rW419J7Lb3X0nstvdf67S6p3+6S+q2hr98a+vqtoS/utfReS++19F5L77X0XkvvtfReS++19F6Ley3utbjX0nstvdfSey291/rtLqnf7pL6raGv3xr6+q2hL+619F5L77X0XkvvtfReS++19F5L77X0Xot7Le61uNfSey2919J7Lb3X+pW/gPIXsIa+fmvo67eGvrjX0nstvdfSey2919J7Lb3X0nstvdfSey3utbjX4l5L77X0XkvvtfRe69tdUt/ukvrW0Ne3hr6+NfTFvZbea+m9lt5r6b2W3mvpvZbea+m9lt5rca/FvRb3Wnqvpfdaeq+l91rf7pL6dpfUt4a+vjX09a2hL+619F5L77X0XkvvtfReS++19F5L77X0Xot7Le61uNfSey2919J7Lb3X+naX1Le7pL419PWtoa9vDX1xr6X3Wnqvpfdaeq+l91p6r6X3Wnqvpfda3Gtxr8W9lt5r6b2W3mvpvda3u6S+3SX1raGvbw19fWvoi3stvdfSey2919J7Lb3X0nstvdfSey291+Jei3st7rX0XkvvtfReS++1vvYX0P4C1tDXt4a+vjX0xb2W3mvpvZbea+m9lt5r6b2W3mvpvZbea3Gvxb0W91p6r6X3Wnqvpfdaxy45dslZQ19nDX2dNfTFvZbea+m9lt5r6b2W3mvpvZbea+m9lt5rca/FvRb3Wnqvpfdaeq+l91rHLjl2yVlDX2cNfZ019MW9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mtxr8W9Fvdaeq+l91p6r6X3WscuOXbJWUNfZw19nTX0xb2W3mvpvZbea+m9lt5r6b2W3mvpvZbea3Gvxb0W91p6r6X3Wnqvpfdaxy45dslZQ19nDX2dNfTFvZbea+m9lt5r6b2W3mvpvZbea+m9lt5rca/FvRb3Wnqvpfdaeq+l91rHLjl2yV1DX3cNfd019MW9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mtxr8W9Fvdaeq+l91p6r6X3WtcuuXbJXUNfdw193TX0xb2W3mvpvZbea+m9lt5r6b2W3mvpvZbea3Gvxb0W91p6r6X3Wnqvpfda1y65dsldQ193DX3dNfTFvZbea+m9lt5r6b2W3mvpvZbea+m9lt5rca/FvRb3Wnqvpfdaeq+l91rXLrl2yV1DX3cNfd019MW9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mtxr8W9Fvdaeq+l91p6r6X3WtcuuXbJXUNfdw193TX0xb2W3mvpvZbea+m9lt5r6b2W3mvpvZbea3Gvxb0W91p6r6X3Wnqvpfdazy55dslbQ19vDX29NfTFvZbea+m9lt5r6b2W3mvpvZbea+m9lt5rca/FvRb3Wnqvpfdaeq+l91rPLnl2yVtDX28Nfb019MW9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mtxr8W9Fvdaeq+l91p6r6X3Ws8ueXbJW0Nfbw19vTX0xb2W3mvpvZbea+m9lt5r6b2W3mvpvZbea3Gvxb0W91p6r6X3Wnqvpfdazy55dslbQ19vDX29NfTFvZbea+m9lt5r6b2W3mvpvZbea+m9lt5rca/FvRb3Wnqvpfdaeq+l91rPLnl2yVtDX28NfcUa+uJeS++19F5L77X0XkvvtfReS++19F5L77W41+Jei3stvdfSey2919J7rbBLwi6JNfQVa+gr1tAX91p6r6X3Wnqvpfdaeq+l91p6r6X3Wnqvxb0W91rca+m9lt5r6b2W3muFXRJ2Sayhr1hDX7GGvrjX0nstvdfSey2919J7Lb3X0nstvdfSey3utbjX4l5L77X0XkvvtfReK+ySsEtiDX3FGvqKNfTFvZbea+m9lt5r6b2W3mvpvZbea+m9lt5rca/FvRb3Wnqvpfdaeq+l91phl4RdEmvoK9bQV6yhL+619F5L77X0XkvvtfReS++19F5L77X0Xot7Le61uNfSey2919J7Lb3XSrsk7ZJcQ1+5hr5yDX1xr6X3Wnqvpfdaeq+l91p6r6X3Wnqvpfda3Gtxr8W9lt5r6b2W3mvpvVbaJWmX5Br6yjX0lWvoi3stvdfSey2919J7Lb3X0nstvdfSey291+Jei3st7rX0XkvvtfReS++10i5JuyTX0Feuoa9cQ1/ca+m9lt5r6b2W3mvpvZbea+m9lt5r6b0W91rca3Gvpfdaeq+l91p6r5V2SdoluYa+cg195Rr64l5L77X0XkvvtfReS++19F5L77X0XkvvtbjX4l6Ley2919J7Lb3X0nuttEvSLsk19JVr6CvX0Bf3Wnqvpfdaeq+l91p6r6X3Wnqvpfdaeq/FvRb3Wtxr6b2W3mvpvZbea5VdUnZJraGvWkNftYa+uNfSey2919J7Lb3X0nstvdfSey2919J7Le61uNfiXkvvtfReS++19F6r7JKyS2oNfdUa+qo19MW9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mtxr8W9Fvdaeq+l91p6r6X3WmWXlF1Sa+ir1tBXraEv7rX0XkvvtfReS++19F5L77X0XkvvtfRei3st7rW419J7Lb3X0nstvdcqu6TsklpDX7WGvmoNfXGvpfdaeq+l91p6r6X3Wnqvpfdaeq+l91rca3Gvxb2W3mvpvZbea+m9VtslbZf0GvrqNfTVa+iLey2919J7Lb3X0nstvdfSey2919J7Lb3X4l6Ley3utfReS++19F5L77XaLmm7pNfQV6+hr15DX9xr6b2W3mvpvZbea+m9lt5r6b2W3mvpvRb3Wtxrca+l91p6r6X3Wnqv1XZJ2yW9hr56DX31GvriXkvvtfReS++19F5L77X0XkvvtfReS++1uNfiXot7Lb3X0nstvdfSe622S9ou6TX01Wvoq9fQF/daeq+l91p6r6X3Wnqvpfdaeq+l91p6r8W9Fvda3GvpvZbea+m9lt5rtV3Sdkmvoa9eQ1+9hr6419J7Lb3X0nstvdfSey2919J7Lb3X0nst7rW41+JeS++19F5L77X0XmvskrFLZg19zRr6mjX0xb2W3mvpvZbea+m9lt5r6b2W3mvpvZbea3Gvxb0W91p6r6X3WnqvpfdaY5eMXTJr6GvW0NesoS/utfReS++19F5L77X0XkvvtfReS++19F6Ley3utbjX0nstvdfSey291xq7ZOySWUNfs4a+Zg19ca+l91p6r6X3Wnqvpfdaeq+l91p6r6X3Wtxrca/FvZbea+m9lt5r6b3W2CVjl8wa+po19DVr6It7Lb3X0nstvdfSey2919J7Lb3X0nstvdfiXot7Le619F5L77X1XlvvtX+7S/q3u6R/a+j7t4a+f2vom3ttvdfWe22919Z7bb3X1nttvdfWe2291+Zem3tt7rX1XlvvtfVeW++1f7tL+re7pH9r6Pu3hr5/a+ibe22919Z7bb3X1nttvdfWe22919Z7bb3X5l6be23utfVeW++19V5b77V/u0v6t7ukf2vo+7eGvn9r6Jt7bb3X1nttvdfWe22919Z7bb3X1nttvdfmXpt7be619V5b77X1XlvvtX+7S/qX/gLW0PdvDX3/1tA399p6r6332nqvrffaeq+t99p6r6332nqvzb0299rca+u9tt5r67223mv/xl/A+AtYQ9+/NfT9W0Pf3Gvrvbbea+u9tt5r67223mvrvbbea+u9Nvfa3Gtzr6332nqvrffaeq/97S7pb3dJf2vo+1tD398a+uZeW++19V5b77X1XlvvtfVeW++19V5b77W51+Zem3ttvdfWe22919Z77W93SX+7S/pbQ9/fGvr+1tA399p6r6332nqvrffaeq+t99p6r6332nqvzb0299rca+u9tt5r67223mt/u0v6213S3xr6/tbQ97eGvrnX1nttvdfWe22919Z7bb3X1nttvdfWe23utbnX5l5b77X1XlvvtfVe+yt/AeUvYA19f2vo+1tD39xr67223mvrvbbea+u9tt5r67223mvrvTb32txrc6+t99p6r6332nqvfeySY5ecNfR91tD3WUPf3Gvrvbbea+u9tt5r67223mvrvbbea+u9Nvfa3Gtzr6332nqvrffaeq997JJjl5w19H3W0PdZQ9/ca+u9tt5r67223mvrvbbea+u9tt5r670299rca3Ovrffaeq+t99p6r33skmOXnDX0fdbQ91lD39xr67223mvrvbbea+u9tt5r67223mvrvTb32txrc6+t99p6r6332nqvfeySY5ecNfR91tD3WUPf3Gvrvbbea+u9tt5r67223mvrvbbea+u9Nvfa3Gtzr6332nqvrffaeq997JJjl5w19H3W0PdZQ9/ca+u9tt5r67223mvrvbbea+u9tt5r670299rca3Ovrffaeq+t99p6r33tkmuX3DX0fdfQ911D39xr67223mvrvbbea+u9tt5r67223mvrvTb32txrc6+t99p6r6332nqvfe2Sa5fcNfR919D3XUPf3Gvrvbbea+u9tt5r67223mvrvbbea+u9Nvfa3Gtzr6332nqvrffaeq997ZJrl9w19H3X0PddQ9/ca+u9tt5r67223mvrvbbea+u9tt5r670299rca3Ovrffaeq+t99p6r33tkmuX3DX0fdfQ911D39xr67223mvrvbbea+u9tt5r67223mvrvTb32txrc6+t99p6r6332nqvfe2Sa5e8NfT91tD3W0Pf3Gvrvbbea+u9tt5r67223mvrvbbea+u9Nvfa3Gtzr6332nqvrffaeq/97JJnl7w19P3W0PdbQ9/ca+u9tt5r67223mvrvbbea+u9tt5r670299rca3Ovrffaeq+t99p6r/3skmeXvDX0/dbQ91tD39xr67223mvrvbbea+u9tt5r67223mvrvTb32txrc6+t99p6r6332nqv/eySZ5e8NfT91tD3W0Pf3Gvrvbbea+u9tt5r67223mvrvbbea+u9Nvfa3Gtzr6332nqvrffaeq/97JJnl7w19P3W0PdbQ9/ca+u9tt5r67223mvrvbbea+u9tt5r670299rca3Ovrffaeq+t99p6rx12SdglsYa+Yw19xxr65l5b77X1XlvvtfVeW++19V5b77X1XlvvtbnX5l6be22919Z7bb3X1nvtsEvCLok19B1r6DvW0Df32nqvrffaeq+t99p6r6332nqvrffaeq/NvTb32txr67223mvrvbbea4ddEnZJrKHvWEPfsYa+udfWe22919Z7bb3X1nttvdfWe22919Z7be61udfmXlvvtfVeW++19V477JKwS2INfcca+o419M29tt5r67223mvrvbbea+u9tt5r67223mtzr829Nvfaeq+t99p6r6332mGXhF0Sa+g71tB3rqFv7rX1XlvvtfVeW++19V5b77X1XlvvtfVem3tt7rW519Z7bb3X1nttvddOuyTtklxD37mGvnMNfXOvrffaeq+t99p6r6332nqvrffaeq+t99rca3Ovzb223mvrvbbea+u9dtolaZfkGvrONfSda+ibe22919Z7bb3X1nttvdfWe22919Z7bb3X5l6be23utfVeW++19V5b77XTLkm7JNfQd66h71xD39xr67223mvrvbbea+u9tt5r67223mvrvTb32txrc6+t99p6r6332nqvnXZJ2iW5hr5zDX3nGvrmXlvvtfVeW++19V5b77X1XlvvtfVeW++1udfmXpt7bb3X1nttvdfWe+2yS8ouqTX0XWvou9bQN/faeq+t99p6r6332nqvrffaeq+t99p6r829Nvfa3Gvrvbbea+u9tt5rl11Sdkmtoe9aQ9+1hr6519Z7bb3X1nttvdfWe22919Z7bb3X1ntt7rW51+ZeW++19V5b77X1XrvskrJLag191xr6rjX0zb223mvrvbbea+u9tt5r67223mvrvbbea3Ovzb0299p6r6332nqvrffaZZeUXVJr6LvW0HetoW/utfVeW++19V5b77X1XlvvtfVeW++19V6be23utbnX1nttvdfWe2291y67pOySWkPftYa+aw19c6+t99p6r6332nqvrffaeq+t99p6r6332txrc6/Nvbbea+u9tt5r67122yVtl/Qa+u419N1r6Jt7bb3X1nttvdfWe22919Z7bb3X1nttvdfmXpt7be619V5b77X1Xlvvtdsuabuk19B3r6HvXkPf3Gvrvbbea+u9tt5r67223mvrvbbea+u9Nvfa3Gtzr6332nqvrffaeq/ddknbJb2GvnsNffca+uZeW++19V5b77X1XlvvtfVeW++19V5b77W51+Zem3ttvdfWe22919Z77bZL2i7pNfTda+i719A399p6r6332nqvrffaeq+t99p6r6332nqvzb0299rca+u9tt5r67223muPXTJ2yayh71lD37OGvrnX1nttvdfWe22919Z7bb3X1nttvdfWe23utbnX5l5b77X1XlvvtfVee+ySsUtmDX3PGvqeNfTNvbbea+u9tt5r67223mvrvbbea+u9tt5rc6/NvTb32nqvrffaeq+t99pjl4xdMmvoe9bQ96yhb+619V5b77X1XlvvtfVeW++19V5b77X1Xpt7be61udfWe22919Z7bb3XHrtk7JJZQ9+zhr5nDX1zr6332nqvrffaeq+t99p6r6332nqvrffa3Gtzr829tt5r67223mvrvfbYJWOXzBr6njX0PWvom3ttvdfWex2919F7Hb3X0XsdvdfRex291+Feh3sd7nX0XkfvdfReR+91frtL5re7ZH5r6Oe3hn5+a+iHex2919F7Hb3X0XsdvdfRex2919F7Hb3X4V6Hex3udfReR+919F5H73V+u0vmt7tkfmvo57eGfn5r6Id7Hb3X0XsdvdfRex2919F7Hb3X0XsdvdfhXod7He519F5H73X0XkfvdX67S+a3u2R+a+jnt4Z+fmvoh3sdvdfRex2919F7Hb3X0XsdvdfRex291+Feh3sd7nX0XkfvdfReR+91fu0voP0FrKGf3xr6+a2hH+519F5H73X0XkfvdfReR+919F5H73X0Xod7He51uNfRex2919F7Hb3X+XaXzLe7ZL419POtoZ9vDf1wr6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c63Otwr8O9jt7r6L2O3uvovc63u2S+3SXzraGfbw39fGvoh3sdvdfRex2919F7Hb3X0XsdvdfRex291+Feh3sd7nX0XkfvdfReR+91vt0l8+0umW8N/Xxr6OdbQz/c6+i9jt7r6L2O3uvovY7e6+i9jt7r6L0O9zrc63Cvo/c6eq+j9zp6r/PtLpkv/QWsoZ9vDf18a+iHex2919F7Hb3X0XsdvdfRex2919F7Hb3X4V6Hex3udfReR+919F5H73W+8Rcw/gLW0M+3hn6+NfTDvY7e6+i9jt7r6L2O3uvovY7e6+i9jt7rcK/DvQ73Onqvo/c6eq+j9zrHLjl2yVlDP2cN/Zw19MO9jt7r6L2O3uvovY7e6+i9jt7r6L2O3utwr8O9Dvc6eq+j9zp6r6P3OscuOXbJWUM/Zw39nDX0w72O3uvovY7e6+i9jt7r6L2O3uvovY7e63Cvw70O9zp6r6P3Onqvo/c6xy45dslZQz9nDf2cNfTDvY7e6+i9jt7r6L2O3uvovY7e6+i9jt7rcK/DvQ73Onqvo/c6eq+j9zrHLjl2yVlDP2cN/Zw19MO9jt7r6L2O3uvovY7e6+i9jt7r6L2O3utwr8O9Dvc6eq+j9zp6r6P3OtcuuXbJXUM/dw393DX0w72O3uvovY7e6+i9jt7r6L2O3uvovY7e63Cvw70O9zp6r6P3Onqvo/c61y65dsldQz93Df3cNfTDvY7e6+i9jt7r6L2O3uvovY7e6+i9jt7rcK/DvQ73Onqvo/c6eq+j9zrXLrl2yV1DP3cN/dw19MO9jt7r6L2O3uvovY7e6+i9jt7r6L2O3utwr8O9Dvc6eq+j9zp6r6P3OtcuuXbJXUM/dw393DX0w72O3uvovY7e6+i9jt7r6L2O3uvovY7e63Cvw70O9zp6r6P3Onqvo/c61y65dsldQz93Df3cNfTDvY7e6+i9jt7r6L2O3uvovY7e6+i9jt7rcK/DvQ73Onqvo/c6eq+j9zrPLnl2yVtDP28N/bw19MO9jt7r6L2O3uvovY7e6+i9jt7r6L2O3utwr8O9Dvc6eq+j9zp6r6P3Os8ueXbJW0M/bw39vDX0w72O3uvovY7e6+i9jt7r6L2O3uvovY7e63Cvw70O9zp6r6P3Onqvo/c6zy55dslbQz9vDf28NfTDvY7e6+i9jt7r6L2O3uvovY7e6+i9jt7rcK/DvQ73Onqvo/c6eq+j9zrPLnl2yVtDP28N/bw19MO9jt7r6L2O3uvovY7e6+i9jt7r6L2O3utwr8O9Dvc6eq+j9zp6r6P3Os8ueXZJrKGfWEM/sYZ+uNfRex2919F7Hb3X0XsdvdfRex2919F7He51uNfhXkfvdfReR+919F4n7JKwS2IN/cQa+ok19MO9jt7r6L2O3uvovY7e6+i9jt7r6L2O3utwr8O9Dvc6eq+j9zp6r6P3OmGXhF0Sa+gn1tBPrKEf7nX0XkfvdfReR+919F5H73X0XkfvdfReh3sd7nW419F7Hb3X0XsdvdcJuyTsklhDP7GGfmIN/XCvo/c6eq+j9zp6r6P3Onqvo/c6eq+j9zrc63Cvw72O3uvovY7e6+i9TtglYZfEGvqJNfQTa+iHex2919F7Hb3X0XsdvdfRex2919F7Hb3X4V6Hex3udfReR+919F5H73XSLkm7JNfQT66hn1xDP9zr6L2O3uvovY7e6+i9jt7r6L2O3uvovQ73OtzrcK+j9zp6r6P3Onqvk3ZJ2iW5hn5yDf3kGvrhXkfvdfReR+919F5H73X0XkfvdfReR+91uNfhXod7Hb3X0XsdvdfRe520S9IuyTX0k2voJ9fQD/c6eq+j9zp6r6P3Onqvo/c6eq+j9zp6r8O9Dvc63OvovY7e6+i9jt7rpF2SdkmuoZ9cQz+5hn6419F7Hb3X0XsdvdfRex2919F7Hb3X0Xsd7nW41+FeR+919F5H73X0XiftkrRLcg395Br6qTX0w72O3uvovY7e6+i9jt7r6L2O3uvovY7e63Cvw70O9zp6r6P3Onqvo/c6ZZeUXVJr6KfW0E+toR/udfReR+919F5H73X0XkfvdfReR+919F6Hex3udbjX0XsdvdfRex291ym7pOySWkM/tYZ+ag39cK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OtzrcK/DvY7e6+i9jt7r6L1O2SVll9Qa+qk19FNr6Id7Hb3X0XsdvdfRex2919F7Hb3X0XsdvdfhXod7He519F5H73X0XkfvdcouKbuk1tBPraGfWkM/3OvovY7e6+i9jt7r6L2O3uuUXaL3Onqvw70O9zrc6+i9jt7r6L2O3uu0XdJ2Sa+hn15DP72GfrjX0XsdvdfRex2919F7Hb3X0XsdvdfRex3udbjX4V5H73X0XkfvdfRep+2Stkt6Df30GvrpNfTDvY7e6+i9jt7r6L2O3uvovY7e6+i9jt7rcK/DvQ73Onqvo/c6eq+j9zptl7Rd0mvop9fQT6+hH+519F5H73X0XkfvdfReR+919F5H73X0Xod7He51uNfRex2919F7Hb3Xabuk7ZJeQz+9hn56Df1wr6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c63Otwr8O9jt7r6L2O3uvovU7bJW2X9Br66TX002voh3sdvdfRex2919F7Hb3X0XsdvdfRex291+Feh3sd7nX0XkfvdfReR+91xi4Zu2TW0M+soZ9ZQz/c6+i9jt7r6L2O3uvovY7e6+i9jt7r6L0O9zrc63Cvo/c6eq+j9zp6rzN2ydgls4Z+Zg39zBr64V5H73X0XkfvdfReR+919F5H73X0XkfvdbjX4V6Hex2919F7Hb3X0XudsUvGLpk19DNr6GfW0A/3Onqvo/c6eq+j9zp6r6P3Onqvo/c6eq/DvQ73Otzr6L2O3uvovY7e64xdMnbJrKGfWUM/s4Z+uNfRex2919F7Hb3X0XsdvdfRex2919F7He51uNdZ9/qXe/3ft/09fh6Px+vxeQyP/7tcf4//u1x/j/+7XH+P3vbvlvw9fh6Px+vxeQyP6bE8tkdvO952vO34tuPbjm87vu3fLvl7LI+9X/zP0P91cX/7xdfbrm+7vu36tuvbrm+7vu36tuvbnm973va87Xnb823Ptz3f9nzbv13y9zj7+M/Q/z1++8X/DP3fo7eFbwvfFr4tfFv4tvBt6dvSt6VvS29Lb0tvS9+Wvi19W/q28hdQ/gL+Gfq/x7tf/M/Q/z16W/m28m3l28q3tW9r39a+rX1b+7b2tva29rb2be3bxreNbxt/AeMv4J+h/3uM/eJ/hv7v0dvGt7kl23v9e/w8Ho/X4/MYHtNjeWyP3vbtt23v9e/xeLwen8fwuJfr+/Zyfd9ers8t+dySzy3Z3uvfo287vu34tuPbjm87vu142/U2t2R7r3+Pvu36tuvbbnosj3u5vruX63t7uT635HNLPrdke69/j77t+bbn255ve74tfFt4W3ibW7K9179H3xa+LXxbtMf9C/hyL9eXe7m+3Mv1uSWfW/K5Jdt7/Xv0benb0reVbyvfVr6tvK28zS3Z3uvfo28r31a+rf0FtL+A3sv19V6ur/dyfW7J55Z8bsn2Xv8efdv4tvFt49vGt41vG28bb3NLtvf697jfduySY5ccu+TYJee3l+v89nKd316u45Yct+S4JccuOXbJsUuOXXLskmOXHLvk2CXHLjluyfZe/x59m11y7JJjlxy75Jy9XOfs5TpnL9dxS45bctySY5ccu+TYJccuOXbJsUuOXXLskmOXHLdke69/j77NLjl2ybFLjl1y3l6u8/ZyndjLddyS45Yct+TYJccuOXbJsUuOXXLskmOXHLvk2CXHLdne69+jb7NLjl1y7JJjl5zay3VqL9epvVzHLTluyXFLjl1y7JJjlxy75Nglxy45dsmxS45dctyS7b3+Pfo2u+TYJccuOXbJmb1cZ/ZyndnLddyS45Yct+TYJccuuXbJtUuuXXLtkmuXXLvk2iXXLdne69/jftu1S65dcu2Sa5fcby/X/fZy3W8v13VLrlty3ZJrl1y75Nol1y65dsm1S65dcu2Sa5dct2R7r3+Pvs0uuXbJtUuuXXLvXq5793Ldu5fruiXXLbluybVLrl1y7ZJrl1y75Nol1y65dsm1S65bsr3Xv0ffZpdcu+TaJdcuubGX68Zerpt7ua5bct2S65Zcu+TaJdcuuXbJtUuuXXLtkmuXXLvkuiXbe/179G12ybVLrl1y7ZLbe7lu7+W6vZfruiXXLbluybVLrl1y7ZJrl1y75Nol1y65dsm1S65bsr3Xv0ffZpdcu+TZJc8ueb+9XO+3l+v99nI9t+S5Jc8teXbJs0ueXfLskmeXPLvk2SXPLnl2yXNLtvf69+jb7JJnlzy75Nkl7+zlemcv1zt7uZ5b8tyS55Y8u+TZJc8ueXbJs0ueXfLskmeXPLvkuSXbe/179G12ybNLnl3y7JL39nK9t5frvb1czy15bslzS55d8uySZ5c8u+TZJc8ueXbJs0ueXfLcku29/j36Nrvk2SXPLnl2ycu9XC/3cr3ay/XckueWPLfk2SXPLnl2ybNLnl3y7JJnlzy75Nklzy3Z3uvfo2+zS55d8uySZ5e82cv1Zi/Xm71czy15bslzS55d8uySZ5c8uyTskrBLwi4JuyTsknBLtvf691ge2+N+W9glYZfEt5crvr1c8e3lCrck3JJwS8IuCbsk7JKwS8IuCbsk7JKwS8IuCbdke69/j77NLgm7JOySsEvi7uWKu5cr7l6ucEvCLQm3JOySsEvCLgm7JOySsEvCLgm7JOyScEu29/r36NvskrBLwi4JuyRiL1fEXq6IvVzhloRbEm5J2CVhl4RdEnZJ2CVhl4RdEnZJ2CXhlmzv9e/Rt9klYZeEXRJ2SdRerqi9XNF7ucItCbck3JKwS8IuCbsk7JKwS8IuCbsk7JKwS8It2d7r36Nvs0vCLgm7JOyS/O3lyt9ervzt5Uq3JN2SdEvSLkm7JO2StEvSLkm7JO2StEvSLkm3ZHuvf4/lsT36Nrsk7ZI8e7ny7OXKs5cr3ZJ0S9ItSbsk7ZK0S9IuSbsk7ZK0S9IuSbsk3ZLtvf49+ja7JO2StEvSLsm3lyvfXq58e7nSLUm3JN2StEvSLkm7JO2StEvSLkm7JO2StEvSLdne69+jb7NL0i5JuyTtksy9XJl7uTL3cqVbkm5JuiVpl6RdknZJ2iVpl6RdknZJ2iVpl6Rbsr3Xv0ffZpekXZJ2Sdol2Xu5svdy5ezlSrck3ZJ0S9IuSbsk7ZK0S9IuSbuk7JKyS8ouKbek/CZcfhMuu6TskrJLyi6pby9XfXu56tvLVW5JuSXllpRdUnZJ2SVll5RdUnZJ2SVll5RdUm5J+U24/CZcdknZJWWXlF1Sdy9X3b1cdfdylVtSbkm5JWWXlF1SdknZJWWXlF1SdknZJWWXlFtSfhMuvwmXXVJ2SdklZZdU7OWq2MtVsZer3JJyS8otKbuk7JKyS8ouKbuk7JKyS8ouKbuk3JLym3D5TbjskrJLyi4pu6RqL1fVXq6qvVzllpRbUm5J2SVll5RdUnZJ2SVll5RdUnZJ2SXllpTfhMtvwmWXlF1SdknZJTV7uWr2cvVvL1e7Je2WtFvSdknbJW2XtF3SdknbJW2XtF3Sdkm7Je034fabcNslbZe0XdJ2SZ+9XH32cvXZy9VuSbsl7Za0XdJ2SdslbZe0XdJ2SdslbZe0XdJuSftNuP0m3HZJ2yVtl7Rd0m8vV7+9XP32crVb0m5JuyVtl7Rd0nZJ2yVtl7Rd0nZJ2yVtl7Rb0n4Tbr8Jt13SdknbJW2XdO7l6tzL1bmXq92SdkvaLWm7pO2StkvaLmm7pO2StkvaLmm7pN2S9ptw+0247ZK2S9ouabukey9X916u7r1c7Za0W9JuSdslbZe0XdJ2SdslbZe0XdJ2ydgl45aM34THb8Jjl4xdMnbJ2CXz28s1v71c8+3lGrdk3JJxS8YuGbtk7JKxS8YuGbtk7JKxS8YuGbdk/CY8fhMeu2TskrFLxi6Zu5dr7l6uuXu5xi0Zt2TckrFLxi4Zu2TskrFLxi4Zu2TskrFLxi0ZvwmP34THLhm7ZOySsUsm9nJN7OWa2Ms1bsm4JeOWjF0ydsnYJWOXjF0ydsnYJWOXjF0ybsn4TXj8Jjx2ydglY5eMXTK1l2tqL9fUXq5xS8YtGbdk7JKxS8YuGbtk7JKxS8YuGbtk7JJxS8ZvwuM34bFLxi4Zu2Tskpm9XDN7uWb2cnGv3/Ze/x4/j8fj9fg8hsf0WB7bo7d93vZ52/4m/G3v9e/xeQyP6bE8/rtc3++fof/7D9b/Xa6Pe/229/r36NuObzu+7fi249uObzu+7fq2623X2663Xd92fdv1bde37S75frtLvt8/Q//3+O0X/zP0f4/e9nzb823Ptz3f9nzb823h28K3hW8LbwtvC28L3xa+LXxb+LbdJd9vd8n3+2fo/x7vfvE/Q//36G3p29K3pW9L31a+rXxb+bbybeXbytvK28rbyreVb2vf1r6t/QW0v4B/hv7vMfaL/xn6v0dva9/Wvm182/i28W3j28a3jW8b3zbeNt7mlmzv9e/x83g8Xo/PY3j8d7m+bw39962h/7jX73NLPrdke69/j9fj8xge02N5bI/edrzNLdne69+jbzu+7fi23SXft7vk+9bQf98a+u9bQ/9xr9/nlnxuyfZe/x592/Vt17dd33Z92/Ntz9uet7kl23v9e/Rtz7c937a75Pt2l3zfGvrvW0P/fWvoP+71+9ySzy3Z3uvfo28L3xa+LX1b+rb0belt6W1uyfZe/x59W/q29G3lL6D8Bayh/7419N+3hv7jXr/PLfncku29/j36tvZt7dvat7Vva9/W3tbe5pZs7/Xv0beNbxvfNv4Cxl/AGvrvW0P/fWvoP+71+9ySzy05dsmxS45dcuySY5ccu+TYJdzrx71+3Ou3vde/x8/j8Xg9Po/hcS/XWUP/nTX0H/f6HbfkuCXHLjl2ybFLjl1y7JJjlxy7hHv9uNePe/229/r36NvskmOXHLvk2CVnDf131tB/Zw39x71+xy05bsmxS45dcuySY5ccu+TYJccu4V4/7vXjXr/tvf49+ja75Nglxy45dslZQ/+dNfTfWUP/ca/fcUuOW3LskmOXHLvk2CXHLjl2ybFLuNePe/241297r3+Pvs0uOXbJsUuOXXLW0H9nDf131tB/3Ot33JLjlhy75Nglxy45dsmxS45dcuwS7vXjXj/u9dve69/jftu1S65dcu2Sa5fcNfTfXUP/3TX0H/f6XbfkuiXXLrl2ybVLrl1y7ZJrl1y7hHv9uNePe/229/r36NvskmuXXLvk2iV3Df1319B/dw39x71+1y25bsm1S65dcu2Sa5dcu+TaJdcu4V4/7vXjXr/tvf49+ja75Nol1y65dsldQ//dNfTfXUP/ca/fdUuuW3LtkmuXXLvk2iXXLrl2ybVLuNePe/241297r3+Pvs0uuXbJtUuuXXLX0H93Df1319B/3Ot33ZLrlly75Nol1y65dsm1S65dcu0S7vXjXj/u9dve69+jb7NLrl1y7ZJrl9w19N9dQ//dNfQf9/pdt+S6JdcuuXbJs0ueXfLskmeXPLuEe/241497/bb3+ve43/bskmeXPLvk2SVvDf331tB/bw39x71+zy15bsmzS55d8uySZ5c8u+TZJc8u4V4/7vXjXr/tvf49+ja75Nklzy55dslbQ/+9NfTfW0P/ca/fc0ueW/LskmeXPLvk2SXPLnl2ybNLuNePe/241297r3+Pvs0ueXbJs0ueXfLW0H9vDf331tB/3Ov33JLnljy75Nklzy55dsmzS55d8uwS7vXjXj/u9dve69+jb7NLnl3y7JJnl7w19N9bQ/+9NfQf9/o9t+S5Jc8ueXbJs0ueXfLskmeXPLuEe/241497/bb3+vfo2+ySZ5eEXRJ2Sayh/2IN/Rdr6D/u9Qu3JNySsEvCLgm7JOySsEvCLgm7hHv9uNePe/229/r36NvskrBLwi4JuyTW0H+xhv6LNfQf9/qFWxJuSdglYZeEXRJ2SdglYZeEXcK9ftzrx71+23v9e/RtdknYJWGXhF0Sa+i/WEP/xRr6j3v9wi0JtyTskrBLwi4JuyTskrBLwi7hXj/u9eNev+29/j36Nrsk7JKwS8IuiTX0X6yh/2IN/ce9fuGWhFsSdknYJWGXhF0SdknYJWGXcK8f9/pxr9/2Xv8efZtdEnZJ2CVhl8Qa+i/W0H+xhv7jXr9wS8ItCbsk7JKwS8IuSbsk7ZK0S7jXj3v9uNdve69/j+WxPe63pV2Sdkmuof9yDf2Xa+g/7vVLtyTdkrRL0i5JuyTtkrRL0i5Ju4R7/bjXj3v9tvf69+jb7JK0S9IuSbsk19B/uYb+yzX0H/f6pVuSbknaJWmXpF2SdknaJWmXpF3CvX7c68e9ftt7/Xv0bXZJ2iVpl6Rdkmvov1xD/+Ua+o97/dItSbck7ZK0S9IuSbsk7ZK0S9Iu4V4/7vXjXr/tvf49+ja7JO2StEvSLsk19F+uof9yDf3HvX7plqRbknZJ2iVpl6RdknZJ2iVpl3CvH/f6ca/f9l7/Hn2bXZJ2SdolaZfUGvqv1tB/tYb+416/ckvKLSm7pOySskvKLim7pOySsku41497/bjXr/wmXH4TLruk7JKyS8ouqTX0X62h/2oN/ce9fuWWlFtSdknZJWWXlF1SdknZJWWXcK8f9/pxr1/5Tbj8Jlx2SdklZZeUXVJr6L9aQ//VGvqPe/3KLSm3pOySskvKLim7pOySskvKLuFeP+71416/8ptw+U247JKyS8ouKbuk1tB/tYb+qzX0H/f6lVtSbknZJWWXlF1SdknZJWWXlF3CvX7c68e9fuU34fKbcNklZZeUXVJ2Sa2h/2oN/Vdr6D/u9Su3pNySskvKLim7pOySskvKLmm7hHv9uNePe/3ab8LtN+G2S9ouabuk7ZJeQ//1Gvqv19B/3OvXbkm7JW2XtF3SdknbJW2XtF3Sdgn3+nGvH/f6td+E22/CbZe0XdJ2SdslvYb+6zX0X6+h/7jXr92SdkvaLmm7pO2StkvaLmm7pO0S7vXjXj/u9Wu/CbffhNsuabuk7ZK2S3oN/ddr6L9eQ/9xr1+7Je2WtF3SdknbJW2XtF3SdknbJdzrx71+3OvXfhNuvwm3XdJ2SdslbZf0Gvqv19B/vYb+416/dkvaLWm7pO2StkvaLmm7pO2Stku41497/bjXr/0m3H4Tbruk7ZK2S9ou6TX0X6+h/2YN/ce9fuOWjFsydsnYJWOXjF0ydsnYJWOXcK8f9/pxr9/4TXj8Jjx2ydglY5eMXTJr6L9ZQ//NGvqPe/3GLRm3ZOySsUvGLhm7ZOySsUvGLuFeP+71416/8Zvw+E147JKxS8YuGbtk1tB/s4b+mzX0H/f6jVsybsnYJWOXjF0ydsnYJWOXjF3CvX7c68e9fuM34fGb8NglY5eMXTJ2yayh/2YN/Tdr6D/u9Ru3ZNySsUvGLhm7ZOySsUvGLhm7hHv9uNePe/3Gb8LjN+GxS8YuGbtk7JJZQ//NGvpv1tB/3Os3bsm4JWOXjF0ydsnYJWOXjF0ydgn3erjXw70evdej93r0Xo/e6/ntLjm/3SXnt4b+/NbQn98a+sO9Hr3Xo/d69F6P3uvRez16r0fv9ei9Hr3Xw70e7vVwr0fv9ei9Hr3Xo/d6frtLzm93yfmtoT+/NfTnt4b+cK9H7/XovR6916P3evRej97r0Xs9eq9H7/Vwr4d7Pdzr0Xs9eq9H7/XovZ7f7pLz211yfmvoz28N/fmtoT/c69F7PXqvR+/16L0evdej93r0Xo/e69F7Pdzr4V4P93r0Xo/e69F7PXqv51f+AspfwBr681tDf35r6A/3evRej97r0Xs9eq9H7/XovR6916P3evReD/d6uNfDvR6916P3evRej97r+Y2/gPEXsIb+/NbQn98a+sO9Hr3Xo/d69F6P3uvRez16r0fv9ei9Hr3Xw70e7vVwr0fv9ei9Hr3Xo/d6vt0l59tdcr419OdbQ3++NfSHez16r0fv9ei9Hr3Xo/d69F6P3uvRez16r4d7Pdzr4V6P3uvRez16r0fv9Xy7S863u+R8a+jPt4b+fGvoD/d69F6P3uvRez16r0fv9ei9Hr3Xo/d69F4P93q418O9Hr3Xo/d69F6P3uv5dpecb3fJ+dbQn28N/fnW0B/u9ei9Hr3Xo/d69F6P3uvRez16r0fv9ei9Hu71cK+Hez16r0fv9ei9Hr3X87W/gPYXsIb+fGvoz7eG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2eY5ccu+SsoT9nDf05a+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e6zl2ybFLzhr6c9bQn7OG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2eY5ccu+SsoT9nDf05a+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e6zl2ybFLzhr6c9bQn7OG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2eY5ccu+SsoT9nDf05a+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e67l2ybVL7hr6c9fQn7uG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2ea5dcu+SuoT93Df25a+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e67l2ybVL7hr6c9fQn7uG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2ea5dcu+SuoT93Df25a+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e63l2ybNL3hr689bQn7eG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2eZ5c8u+StoT9vDf15a+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e63l2ybNL3hr689bQn7eG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2eZ5c8u+StoT9vDf15a+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e63l2ybNL3hr689bQn7eG/nCvR+/16L0evdej93r0Xo/e69F7PXqvR+/1cK+Hez3c69F7PXqvR+/16L2esEvCLok19CfW0J9YQ3+416P3evRej97r0Xs9eq9H7/XovR6916P3erjXw70e7vXovR6916P3evReT9glYZfEGvoTa+hPrKE/3OvRez16r0fv9ei9Hr3Xo/d69F6P3uvRez3c6+FeD/d69F6P3uvRez16ryfskrBLYg39iTX0J9bQH+716L0evdej93r0Xo/e69F7PXqvR+/16L0e7vVwr4d7PXqvR+/16L0evdcTdknYJbGG/sQa+hNr6A/3evRej97r0Xs9eq9H7/XovR6916P3evReD/d6uNfDvR6916P3evRej97rSbsk7ZJcQ39yDf3JNfSHez16r0fv9ei9Hr3Xo/d69F6P3uvRez16r4d7Pdzr4V6P3uvRez16r0fv9aRdknZJrqE/uYb+5Br6w70evdej93r0Xo/e69F7PXqvR+/16L0evdfDvR7u9XCvR+/16L0evdej93rSLkm7JNfQn1xDf3IN/eFej97r0Xs9eq9H7/XovR6916P3evRej97r4V4P93q416P3evRej97r0Xs9aZekXZJr6E+uoT+5hv5wr0fv9ei9Hr3Xo/d69F6P3uvRez16r0fv9XCvh3s93OvRez16r0fv9ei9nrRL0i7JNfQn19CfXEN/uNej93r0Xo/e69F7PXqvR+/16L0evdej93q418O9Hu716L0evdej93r0Xk/ZJWWX1Br6U2voT62hP9zr0Xs9eq9H7/XovR6916P3evRej97r0Xs93OvhXg/3evRej97r0Xs9eq+n7JKyS2oN/ak19KfW0B/u9ei9Hr3Xo/d69F6P3uvRez16r0fv9ei9Hu71cK+Hez16r0fv9ei9Hr3XU3ZJ2SW1hv7UGvpTa+gP93r0Xo/e69F7PXqvR+/16L0evdej93r0Xg/3erjXw70evdej93r0Xo/e6ym7pOySWkN/ag39qTX0h3s9eq9H7/XovR6916P3evRej97r0Xs9eq+Hez3c6+Fej97r0Xs9eq9H7/WUXVJ2Sa+hP72G/vQa+sO9Hr3Xo/d69F6P3uvRez16r0fv9ei9Hr3Xw70e7vVwr0fv9ei9Hr3Xo/d62i5pu6TX0J9eQ396Df3hXo/e69F7PXqvR+/16L0evdej93r0Xo/e6+FeD/d6uNej93r0Xo/e69F7PW2XtF3Sa+hPr6E/vYb+cK9H7/XovR6916P3evRej97r0Xs9eq9H7/Vwr4d7Pdzr0Xs9eq9H7/XovZ62S9ou6TX0p9fQn15Df7jXo/d69F6P3uvRez16r0fv9ei9Hr3Xo/d6uNfDvR7u9ei9Hr3Xo/d69F5P2yVtl/Qa+tNr6E+voT/c69F7PXqvR+/16L0evdej93r0Xo/e69F7Pdzr4V4P93r0Xo/e69F7PXqvZ+ySsUtmDf2ZNfRn1tAf7vXovR6916P3evRej97r0Xs9eq9H7/XovR7u9XCvh3s9eq9H7/XovR691zN2ydgls4b+zBr6M2voD/d69F6P3uvRez16r0fv9ei9Hr3Xo/d69F4P93q418O9Hr3Xo/d69F6P3usZu2TskllDf2YN/Zk19Id7PXqvR+/16L0evdej93r0Xo/e69F7PXqvh3s93OvhXo/e69F7PXqvR+/1jF0ydsmsoT+zhv7MGvrDvR6916P3evRej97r0Xs9eq9H7/XovR6918O9Hu71cK9H7/XovR6916P3esYuGbtk1tCfWUN/f2voL/d69V6v3uvVe716r1fv9eq9Xr3Xq/d69V4v93q518u9Xr3Xq/d69V6v3uv97S65v90l97eG/v7W0N/fGvrLvV6916v3evVer97r1Xu9eq9X7/XqvV6918u9Xu71cq9X7/XqvV6916v3en+7S+5vd8n9raG/vzX097eG/nKvV+/16r1evder93r1Xq/e69V7vXqvV+/1cq+Xe73c69V7vXqvV+/16r3e3+6S+9tdcn9r6O9vDf39raG/3OvVe716r1fv9eq9Xr3Xq/d69V6v3uvVe73c6+VeL/d69V6v3uvVe716r/fX/gLaX8Aa+vtbQ39/a+gv93r1Xq/e69V7vXqvV+/16r1evder93r1Xi/3ernXy71evder93r1Xq/e6/12l9xvd8n91tDfbw39/dbQX+716r1evder93r1Xq/e69V7vXqvV+/16r1e7vVyr5d7vXqvV+/16r1evdf77S653+6S+62hv98a+vutob/c69V7vXqvV+/16r1evder93r1Xq/e69V7vdzr5V4v93r1Xq/e69V7vXqv99tdcr/dJfdbQ3+/NfT3W0N/uder93r1Xq/e69V7vXqvV+/16r1evder93q518u9Xu716r1evder93r1Xu9X/gLKX8Aa+vutob/fGvrLvV6916v3evVer97r1Xu9eq9X7/XqvV6918u9Xu71cq9X7/XqvV6916v3er/xFzD+AtbQ328N/f3W0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3Xe+ySY5ecNfT3rKG/Zw395V6v3uvVe716r1fv9eq9Xr3Xq/d69V6v3uvlXi/3ernXq/d69V6v3uvVe73HLjl2yVlDf88a+nvW0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3Xe+ySY5ecNfT3rKG/Zw395V6v3uvVe716r1fv9eq9Xr3Xq/d69V6v3uvlXi/3ernXq/d69V6v3uvVe73HLjl2yVlDf88a+nvW0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3Xe+2Sa5fcNfT3rqG/dw395V6v3uvVe716r1fv9eq9Xr3Xq/d69V6v3uvlXi/3ernXq/d69V6v3uvVe73XLrl2yV1Df+8a+nvX0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3Xe+2Sa5fcNfT3rqG/dw395V6v3uvVe716r1fv9eq9Xr3Xq/d69V6v3uvlXi/3ernXq/d69V6v3uvVe73XLrl2yV1Df+8a+nvX0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3Xe+2Sa5fcNfT3rqG/dw395V6v3uvVe716r1fv9eq9Xr3Xq/d69V6v3uvlXi/3ernXq/d69V6v3uvVe73PLnl2yVtDf98a+vvW0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3X++ySZ5e8NfT3raG/bw395V6v3uvVe716r1fv9eq9Xr3Xq/d69V6v3uvlXi/3ernXq/d69V6v3uvVe73PLnl2yVtDf98a+vvW0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3X++ySZ5e8NfT3raG/bw395V6v3uvVe716r1fv9eq9Xr3Xq/d69V6v3uvlXi/3ernXq/d69V6v3uvVe71hl4RdEmvob6yhv7GG/nKvV+/16r1evder93r1Xq/e69V7vXqvV+/1cq+Xe73c69V7vXqvV+/16r3esEvCLok19DfW0N9YQ3+516v3evVer97r1Xu9eq9X7/XqvV6916v3ernXy71e7vXqvV6916v3evVeb9glYZfEGvoba+hvrKG/3OvVe716r1fv9eq9Xr3Xq/d69V6v3uvVe73c6+VeL/d69V6v3uvVe716rzfskrBLYg39jTX0N9bQX+716r1evder93r1Xq/e69V7vXqvV+/16r1e7vVyr5d7vXqvV+/16r1evdcbdknYJbGG/sYa+htr6C/3evVer97r1Xu9eq9X7/XqvV6916v3evVeL/d6udfLvV6916v3evVer97rTbsk7ZJcQ39zDf3NNfSXe716r1fv9eq9Xr3Xq/d69V6v3uvVe716r5d7vdzr5V6v3uvVe716r1fv9aZdknZJrqG/uYb+5hr6y71evder93r1Xq/e69V7vXqvV+/16r1evdfLvV7u9XKvV+/16r1evder93rTLkm7JNfQ31xDf3MN/eVer97r1Xu9eq9X7/XqvV6916v3evVer97r5V4v93q516v3evVer97r1Xu9aZekXZJr6G+uob+5hv5yr1fv9eq9Xr3Xq/d69V6v3uvVe716r1fv9XKvl3u93OvVe716r1fv9eq93rJLyi6pNfS31tDfWkN/uder93r1Xq/e69V7vXqvV+/16r1evder93q518u9Xu716r1evder93r1Xm/ZJWWX1Br6W2vob62hv9zr1Xu9eq9X7/XqvV6916v3evVer97r1Xu93OvlXi/3evVer97r1Xu9eq+37JKyS2oN/a019LfW0F/u9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xu71cq+Xe716r1fv9eq9Xr3XW3ZJ2SW1hv7WGvpba+gv93r1Xq/e69V7vXqvV+/16r1evder93r1Xi/3ernXy71evder93r1Xq/e6y27pOySWkN/aw39rTX0l3u9eq9X7/XqvV6916v3evVer97r1Xu9eq+Xe73c6+Ver97r1Xu9eq9X7/W2XdJ2Sa+hv72G/vYa+su9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xr3Xy71e7vVyr1fv9eq9Xr3Xq/d62y5pu6TX0N9eQ397Df3lXq/e69V7vXqvV+/16r1evder93r1Xq/e6+VeL/d6uder93r1Xq/e69V7vW2XtF3Sa+hvr6G/vYb+cq9X7/XqvV6916v3evVer97r1Xu9eq9X7/Vyr5d7vdzr1Xu9eq9X7/Xqvd62S9ou6TX0t9fQ315Df7nXq/d69V6v3uvVe716r1fv9eq9Xr3Xq/d6udfLvV7u9eq9Xr3Xq/d69V5v2yVtl8wa+jtr6O+sob/c69V7vXqvV+/16r1evder93r1Xq/e69V7vdzr5V4v93r1Xq/e69V7vXqvd+ySsUtmDf2dNfR31tBf7vXqvV6916v3evVer97r1Xu9eq9X7/XqvV7u9XKvl3u9eq9X7/XqvV691zt2ydgls4b+zhr6O2voL/d69V6v3uvVe716r1fv9eq9Xr3Xq/d69V4v93q518u9Xr3Xq/d69V6v3usdu2TskllDf2cN/Z019Jd7vXqvV+/16r1evder93r1Xq/e69V7vXqvl3u93OvlXq/e69V7vXqvV+/1jl0ydsmsob+zhv7OGvrLvV6916v3evVer97r1Xu9eq9X7/XqvT6918e9Pu71ca9P7/XpvT6916f3+n67S95vd8n7raF/vzX077eG/nGvT+/16b0+vden9/r0Xp/e69N7fXqvT+/1ca+Pe33c69N7fXqvT+/16b2+3+6S99td8n5r6N9vDf37raF/3OvTe316r0/v9em9Pr3Xp/f69F6f3uvTe33c6+NeH/f69F6f3uvTe316r++3u+T9dpe83xr691tD/35r6B/3+vRen97r03t9eq9P7/XpvT6916f3+vReH/f6uNfHvT6916f3+vRen97r+5W/gPIXsIb+/dbQv98a+se9Pr3Xp/f69F6f3uvTe316r0/v9em9Pr3Xx70+7vVxr0/v9em9Pr3Xp/f6fuMvYPwFrKF/vzX071tD/7jXp/f69F6f3uvTe316r0/v9em9Pr3Xp/f6uNfHvT7u9em9Pr3Xp/f69F7ft7vkfbtL3reG/n1r6N9/7jX/96/X4/MYHtNjeWyPs49/t+Tf4+fR2663XW+73na97Xrb9bbrbc/bnrc9b3ve9rztedvztudtz9uet4W3hbeFt4W3hbeFt4W3hbeFt4W3pbelt6W3pbelt6W3pbelt6W3pbeVt5W3lbeVt5W3lbeVt5W3lbeVt7W3tbe1t7W3tbe1t7W3tbe1t7W3jbeNt423jbeNt423jbeNt423zb7tP/f67/HzeDxej89jeEyP5bE9etvnbZ+3fd72edvnbZ+3fd72edvnbZ+3HW873uaWHLfkuCXHLTluyXFLjlty3JLjlhy35Lglxy05bslxS45bctyS45Yct+S4JcctOW7JcUuOW3LckuOWHLfkuCXHLTluyXFLjlty3JLjlhy35Lglxy05bslxS45bctyS45Yct+S4JcctOW7JcUuOW3LckuOWHLfkuCXHLTluyXFLjlty3JLjlhy35Lglxy05bslxS45bctyS45Yct+S4JcctOW7JcUuOW3LckuOWHLfkuCXHLTluyXFLrlty3ZLrlly35Lol1y25bsl1S65bct2S65Zct+S6JdctuW7JdUuuW3LdkuuWXLfkuiXXLbluyXVLrlty3ZLrlly35Lol1y25bsl1S65bct2S65Zct+S6JdctuW7JdUuuW3LdkuuWXLfkuiXXLbluyXVLrlty3ZLrlly35Lol1y25bsl1S65bct2S65Zct+S6JdctuW7JdUuuW3LdkuuWXLfkuiXXLbluyXVLrlty3ZLrlly35Lol1y25bsl1S65bct2S65Zct+S6JdctuW7JdUuuW3LdkuuWXLfkuiXXLbluyXVLrlty3ZLrlly35Lklzy15bslzS55b8tyS55Y8t+S5Jc8teW7Jc0ueW/LckueWPLfkuSXPLXluyXNLnlvy3JLnljy35Lklzy15bslzS55b8tyS55Y8t+S5Jc8teW7Jc0ueW/LckueWPLfkuSXPLXluyXNLnlvy3JLnljy35Lklzy15bslzS55b8tyS55Y8t+S5Jc8teW7Jc0ueW/LckueWPLfkuSXPLXluyXNLnlvy3JLnljy35Lklzy15bslzS55b8tyS55Y8t+S5Jc8teW7Jc0ueW/LckueWPLfkuSXPLXluyXNLnlvy3JLnljy35Lklzy15bslzS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS8ItCbck3JJwS9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S9ItSbck3ZJ0S8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS8otKbek3JJyS9otabek3ZL/3GvF/z0+/xoe02N5bI/e5pa0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0W9JuSbsl7Za0WzJuybgl45aMXTJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45aMWzJuybgl45bM3pL47S2J396S+O0tid/ekvjtLYnf3pL47S2J396S+O0tid/P2z5v+7zt87bP2z5v+7zt87bP2z5v+7zteNvxtuNtx9uOtx1vO952vO142/G2623X2663XW+73na97Xrb9bbrbdfbnrc9b3ve9rztedvztudtz9uetz1vC28LbwtvC28LbwtvC28LbwtvC29Lb0tvS29Lb0tvS29Lb0tvS29LbytvK28rbytvK28rbytvK28rbytva29rb2tva29rb2tva29rb2tva28bbxtvG28bbxtvG28bbxtvG29zSz635HNLPrfkc0s+t+RzSz635HNLPrfkc0s+t+RzSz635HNLPrfkc0s+t+RzSz635HNLPrfkc0u41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Beg3sN7jW41+Be4z/3+t9PqPGfe/336G1uCfca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr9FuCfca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr8m9Jvea3Gtyr/mfe/3v19TkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfkXpN7Te41udfUe0291+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jX/c6//92vqf+7136O3uSXca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvxb0W91rca3Gvpfda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda3Gtxr8W9Fvda/7nX/35NLe61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Le61uNfiXot7Lb3X0nst7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Ze+z/3+t+vqf2fe/336G1uCffa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3Gtzr829Nvfa3GvrvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvTb32txrc6/NvfZ/7vX/fk3lXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7be61udfmXpt7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfhXod7He51uNfRex291+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7nW41+Feh3sd7vX/FXE3KxBl5RmF78WxA/fZvyu3EkTUmCCISkcDIfS9J92JeSbFV9TgHRQ8FJxFpXtN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO99nP3+vPT1H7uXv9xWmOJ7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda/7vNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le072me033mu413Wu613Sv6V7TvaZ7Tfea7jXda7rXdK/pXtO9pntN95ruNd1rutd0r+le0732/93rT9nrr5zD+Tmnczm38ziv8zmtDWvD2rA2rA1rw9qwNqwNa8PaZ+2z9ln7rH3WPmuftc/aZ+2zNq1Na9PatDatTWvT2rQ2rU1ry9qytqwta8vasrasLWvL2rK2rW1r29q2tq1ta9vatratbWvH2rF2rB1rx9qxdqwda8fasXatXWvX2rV2rV1r19q1dq1da8/as/asPWvP2rP2rD1rz9qzlrWsZS1rWcta1rKWNZYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlnws+VjyseRjyceSjyUfSz6WfCz5WPKx5GPJx5KPJR9LPpZ8LPlY8rHkY8nHko8lH0s+lnws+VjyseRjyceSjyUfSz6WfCz5WPKx5GPJx5KPJR9LPpZ8LPlY8rHkY8nHko8lH0s+lnws+VjyseRjyceSjyUfSz6WfCz5WPKx5GPJx5KPJT93rz89Tf3ptMaSjyUfSz6WfCz5WPKx5GPJx5KPJR9LPpZ8LPlY8rHkY8nHko8lH0s+lnws+VjyseRjyceSjyUfSz6WfCz5WPKx5GPJx5KPJR9LPpZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTJZMlkyWTL9LJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksmSyZLJksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLNks2SzZLDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSy5LLksuSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LHkseSx5LYkksiSWxJJbEklgSS2JJLIklsSSWxJJYEktiSSyJJbEklsSSWBJLYkksiSWxJJbEklgSS2JJLIklsSSWxJJYEktiSSyJJbHk5+71f5+m/ty93v3jL3/xH7/94Y+//d2f/vDvv/in//qft//69z///m9//Muf/+/t3/7zr//45Hc//PFPf/rjv/3mrz/85fd/+Je///CH3/zpL7//6bNf/Oqnl5++0X+ev/rl3L/+8ccff/3jfwM=","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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_E_SM_BIT_SECRET,\n SHARE_COMPUTATION_E_SM_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SmudgingNoiseShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n e_sm_secret: [Polynomial; L_THRESHOLD],\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let share_computation_e_sm: SmudgingNoiseShareComputation = SmudgingNoiseShareComputation::new(\n SHARE_COMPUTATION_E_SM_CONFIGS,\n expected_secret_commitment,\n e_sm_secret,\n y,\n PARITY_MATRIX,\n );\n\n share_computation_e_sm.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/e_sm_share_computation/src/main.nr"},"63":{"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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/share_computation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/e_sm_share_computation.vk b/crates/zk-prover/tests/fixtures/e_sm_share_computation.vk index c7cdb4eeb7b0d9951f7428b2c6b741a6f7430b70..70efd9e0c24c6f638143cf1acbdbb43c2487db6c 100644 GIT binary patch delta 1747 zcmV;^1}ypD9N-R+V1FsaEjZ!#A+QeC*EXO*837(zc(oy>!JzI}|DbO;0EidZ8ox3H zILQ+Kv!05b#o>|BYCSSuw7eC1CF7g^n{_TCLj{!Tb9Bg;pvD`8U|@azXA{8R#J)5B zv-SOC#NrNo_szJ*4{jq&^OVX=xm)X@j*hRcPKdelTr!lxPJenXclcboU^!)7;<=_P{|KT+HUsw~h_?2;mmGG_x zHtG;*%+4rTO9KLa^RD3IxA$hWSZ3_4`BW%aY;pi9WelfWP4(k$<6G#z$?Oby4;UIX z={L=KODwteoqwoK7VBVQtSo(P?vF6`BPP1%(A!nfDTAX1Gm;U4r8-x631IZX6KtI} zbk6m0zfONSLrPz(BS^V|nE|=x;U`iYFf|`a>Z68wAD;-~;TgGWmX5j@k0~h_fU}nz z4mO;$3A+RBlWAJ=spB^9s9QqvTQzDtdV%gBDxR0G)_-Fcb0q{ZLFc6vXnbve(1km8 z*{zFNL+a9W9{uYv8-oSO+YOChg%dpn)nZA;MmoSFG)LfCv_J`&$#6(wluqzFvji&s zH{2M=x0ghvLt6qdeV2qk3{E)A6;*E2?Z|J4z!sYm@n2V3r>QfPkEswrc-wOMl4s&jKVPi5{nu5-CGblJ_cc=Cv#F>>Lts1mjjLTUk9%hYB$A9~ls54LAQh zPBjuM9WEe7hmLJSrolGM=rf_OWKmZFraC93uYbs3604pgmCeXMk4ND@;3jWS;^+JH zNtaDIS}&JagcHvz`FVRQxQo{NAp{6X&}bP(g#Rt-Y$8WkNCOml2yDBqlPEX0US=)+o7vB!-mWDHcG`Nq#p zFQGsq?6Sumn+F_-e(*fKkSWoJ}w!_=h7vi0R9FN73XblXWKG zb;-O2x-pA`#aeO;bJWuB`pF`|<(;D?{J99WA*lnHqvF#YSUd~Z-Q8K$H_}}sG?^eR z-~i6Nv_TGpy1!agh;x5zDA5YzWPjrB!E1cT74PdV3H}2F(`h7FMTNmvkE)D4qi{^I zAIINXF9JG9A-z~5_>J2utl+_jW?X($T%7^CEn>QR|DC9iN09)VNw?o6Y1FlrVll6u z|MM;E$nwSn2`=_6yP>DM%Y%ED}LG&f~g}SeC*S!G)R604;hUstS+zrb(~Rx!*EKAFKw;% zdye5*#I>(d=1<*ZOAJGS+ka*Yr)G*MXhK>x5(%C=)u5mXxBeIe0R_3Um9^Nnw5B@+ z-(@Qe5bqRiCIA(<(otP@;>_%s+|iU-At|pqV}Dv=Dl$Y5h7BGne;bi?7m^FDJ&V8` zm6Zu9A}ff22;3#nsznY9OTrSvelT8%lCenc+al)ak_UQ(NFhPT>wn}R0HM{4%XBy& zZ5b0*emjv|fdM+&6(eh<&!zzpv_L=$E6O+Gu?Sw0N_PQB(j|$x9}SO2bgx%L-rD_R z%Ic6yLr!#$mlNKM!`B2o20If9-?MWiPBE$%j zFl1`~mUCg0l#?)(Dw8t}9+40ZlYb2$K>{mR9QlgyD@kAfvrfFdJg7bl#L pS6>V{v7|1G#Tv^6H(|kxDldzXU;k36@p~yyZ_Y?sV}Y?@x);g|I>!J2 literal 3680 zcmajic|4SB8wc>)dhFYr3E6jMGRPV^3?)kxZ?+-pR1~QU6|#kEoX9Y zWJzSn)`Au#Sw7K0TrZ3Qj*#^5 z=DS<@%zC8QH6<5{JAntBSwDnn9qVW@T(4PNBX>*!M~I+m%SWGyq;%((cFCm%0QZ?? zWMnY^bfGpZ_->`&bBO_tkXYREgWFx=N7Z&O(0g|`0H?jUS0*yL`db`x?q;;xq%#9J z=lmyEd>f}EO3A9Hqld>*fb;3ICyZA8y)bnvdB;=pKK%(CA>JmE-}AULu7h8{f55yM z2R_cKUp`ptb#U(Hw|&}PVJ84{n*1g+5~2MMwY{BqxZ@XK|01WwWi}hXH+>M}w54IG zxYA`q2e<>pe_Zu?gkj;_2t!0+SQ6aQwdb7$4pqlk`y;SCY?s7AzgPAurg(^C35s z^rebrGGFOq1N_BJnz!xDAVqO))$sI9;`^9Q$X z`bws|K7U7W@Kd8IC;VEheIBGU1y=_9+Tr+c#;*|b+24~?QDsQatdbytd~cx# zHaJj_pdAw2nl{bH$Oev(#K^E~yuY$!yLATZwsRivgzn`>-0EuQ6)SS3bZlL7mVqOr zmA>bjV}p#qyh1K_ubvZdZ_7RBg!I2C$x0j&HDzyiF$Rth?)Y>a{_~u?)G=O`#}*&p zh72az)sws2T&s-P9UyhR1UN!ccm;y8-MNf#+wwM({&&Ft`Rb7Gyp5!n@0Egig#UIr z7C1s`c@Mg+GIvc_jcZ2ioqP*iCMPO5mPRCFrzV@#a{sz53>+bRqb<9^?W&ar(MEQZ zvK4scrZhRzlS?+Mb}f!J0e$9w0Ozcq6F3W_1KSvvl?jL3_;rE5sqhJ}%;{Gjug}W= zLqLDiE8v_rLLyDY>`t=5!e@s77cMwI%CF5b+|CyK?bSv6MR#At2hk0A-BY(G!+fh! z_7@zIv~i5OK7c-2W81*t%Z#A3b#ciR=r2>9R zK=MqKH{~CS9Mu~*FG1tW-IGje2`$m^J8@ov0vsV>YDsQO{*ti8j9{gGL?CeOu_DTr z4yyCJc9MJb{d65NaL)Q+J@XK?ncs|6!0wI=I{5jBWFE^wc6ZY_Z5MczPM^>cA&{!inX8dwQV8j9B|I_f4rXZtk^KQ-k}3U2$cd? zAUs_;+}V}r+I6nTSzmo+V_qWtoH+lb)7dT4I4hov-$A~onZMD1cD9prLOAlt;QVS2 zaL)R%roQis-8C?!l^dlw4(o%-AqB7P!o#DZ-cL;j_p2KfY{;v&zA3(<@x4LdZ(3VObF8+5Mq%hKeio->&DK{0!K($cN{%zt|f}4G~Ok-!}{i;<&|T*tCjALk@UFD z?N#o0ZO9V@*Liq{Le;%?rnY%zUIWh6q#M*2%Py|W+Let89qPw`bMAj7eFT4Fyp4L$ zH-4WloWEVXf`ldACPq`EReJJ!@^aUPyhiAgx=TR@%**Tr-MQ{Bz*W0)Px2?cUXx1? zvFn&)Mx_Hsh^IdM{?0*4!`=4wUJ9W1k2%tSbMo;oG09bGs&R8e*NyDsfs>s?Y?DR~3RfJwpdDgEGLZs~kY4!B zrPz!K?~XdA+w`7M;CXe!^|j>|d}9ajq7w7JhHC=n?7t-zPfJUM>epp>x%e93`&~tc zX&#(F3c_vOA)Y3xh=cVFr#tNJLD&7!ll^lAuLkIF|53$LlLTIA3|!kOChT-isvX`R z=lN$xN#_XPw4}Al=j93F!1dXy5bw`UDI>K@?rL+$Ur)Mga7yk{66|of8OH$ z`5`|X5n)g3XjylY)+);M^cUGyef0(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n", - "path": "std/field/mod.nr" - }, - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::dkg::{\n DKG_SHARE_ENCRYPTION_BIT_CT, DKG_SHARE_ENCRYPTION_BIT_E0, DKG_SHARE_ENCRYPTION_BIT_E1,\n DKG_SHARE_ENCRYPTION_BIT_MSG, DKG_SHARE_ENCRYPTION_BIT_P1, DKG_SHARE_ENCRYPTION_BIT_P2,\n DKG_SHARE_ENCRYPTION_BIT_PK, DKG_SHARE_ENCRYPTION_BIT_R1, DKG_SHARE_ENCRYPTION_BIT_R2,\n DKG_SHARE_ENCRYPTION_BIT_U, DKG_SHARE_ENCRYPTION_CONFIGS, L, N,\n};\nuse lib::core::dkg::share_encryption::ShareEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_pk_commitment: pub Field,\n expected_message_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: pub [Polynomial; L],\n ct1is: pub [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n) {\n let share_encryption: ShareEncryption = ShareEncryption::new(\n DKG_SHARE_ENCRYPTION_CONFIGS,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n share_encryption.execute();\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_encryption/src/main.nr" - }, - "65": { - "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::commitments::compute_dkg_pk_commitment;\nuse crate::math::commitments::{\n compute_share_encryption_challenge, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for DKG share encryption circuit.\npub struct Configs {\n /// Plaintext modulus t\n pub t: Field,\n /// Q mod t (for scaling message)\n pub q_mod_t: Field,\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Bound for message polynomial (m)\n pub msg_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n t: Field,\n q_mod_t: Field,\n qis: [Field; L],\n k0is: [Field; L],\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n msg_bound: Field,\n ) -> Self {\n Configs {\n t,\n q_mod_t,\n qis,\n k0is,\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n msg_bound,\n }\n }\n}\n\n/// DKG Share Encryption Circuit (Circuit 3).\n///\n/// Verifies:\n/// 1. Public key commitment matches expected (from Circuit 0)\n/// 2. Message commitment matches expected (from SK shares circuit)\n/// 3. Correct DKG share encryption: ct0[l] = pk0[l] * u + e0[l] + k1 * k0[l] + r1[l] * q[l] + r2[l] * (X^N + 1)\n/// and ct1[l] = pk1[l] * u + e1 + p2[l] * (X^N + 1) + p1[l] * q[l]\npub struct ShareEncryption {\n /// Circuit parameters\n configs: Configs,\n /// Expected commitment to public key (from Circuit 0)\n /// (public witness)\n expected_pk_commitment: Field,\n /// Expected commitment to message (from SK shares verification circuit)\n /// (public witness)\n expected_message_commitment: Field,\n /// Public key component 0 for each CRT basis (committed witnesses)\n pk0is: [Polynomial; L],\n /// Public key component 1 for each CRT basis (committed witnesses)\n pk1is: [Polynomial; L],\n /// Ciphertext component 0 for each CRT basis (public witnesses)\n ct0is: [Polynomial; L],\n /// Ciphertext component 1 for each CRT basis (public witnesses)\n ct1is: [Polynomial; L],\n /// Random ternary polynomial u (secret witness)\n u: Polynomial,\n /// Error polynomial e0 (secret witness)\n e0: Polynomial,\n /// Per-basis error polynomials e0[l] (secret witnesses)\n e0is: [Polynomial; L],\n /// CRT quotients for e0 (secret witnesses)\n e0_quotients: [Polynomial; L],\n /// Error polynomial e1 (secret witness)\n e1: Polynomial,\n /// Raw message polynomial (secret witness)\n message: Polynomial,\n /// Modulus switching quotient polynomials r1 (secret witnesses, degree 2N-1)\n r1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials r2 (secret witnesses, degree N-1)\n r2is: [Polynomial; L],\n /// Modulus switching quotient polynomials p1 (secret witnesses, degree 2N-1)\n p1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials p2 (secret witnesses, degree N-1)\n p2is: [Polynomial; L],\n}\n\nimpl ShareEncryption {\n pub fn new(\n configs: Configs,\n expected_pk_commitment: Field,\n expected_message_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> Self {\n ShareEncryption {\n configs,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Verifies that the public key hashes to the expected commitment\n fn verify_pk_commitment(self) {\n assert(\n compute_dkg_pk_commitment::(self.pk0is, self.pk1is)\n == self.expected_pk_commitment,\n \"Public key commitment mismatch\",\n );\n }\n\n /// Verifies that the message polynomial hashes to the expected commitment\n fn verify_message_commitment(self) {\n assert(\n compute_share_encryption_commitment_from_message::(self.message)\n == self.expected_message_commitment,\n \"Message commitment mismatch\",\n );\n }\n\n /// Computes the scaled message k1 from the raw message in centered form\n /// k1[i] = (q_mod_t * message[i]) mod t, centered to [-t/2, t/2)\n fn compute_scaled_message(self) -> Polynomial {\n let t = self.configs.t;\n let t_mod = ModU128::new(t);\n let q_mod_t: Field = self.configs.q_mod_t;\n let mut k1_coeffs: [Field; N] = [0; N];\n\n // Integer division for t_half\n let t_half: u128 = (t as u128) / 2;\n\n for i in 0..N {\n let msg_i: Field = self.message.coefficients[i];\n let q_times_m_mod_t = t_mod.mul_mod(q_mod_t, msg_i);\n\n // Check if centering is needed (value > t/2 means negative in centered form)\n let needs_centering = (q_times_m_mod_t as u128) > t_half;\n\n k1_coeffs[i] = if needs_centering {\n // Value is in (t/2, t), negative in centered form\n // Represent as P - magnitude (i.e., 0 - magnitude in Field)\n let magnitude = t - q_times_m_mod_t;\n 0 - magnitude\n } else {\n // Value is in [0, t/2], stays positive\n q_times_m_mod_t\n };\n }\n\n Polynomial { coefficients: k1_coeffs }\n }\n\n /// Flattens all polynomial coefficients into a single array for Fiat-Shamir challenge generation\n fn payload(self, k1: Polynomial) -> Vec {\n let mut inputs = Vec::new();\n\n // Use pk commitment instead of full pk polynomials\n inputs.push(self.expected_pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n\n // Use message commitment instead of full message\n inputs.push(self.expected_message_commitment);\n\n // Include computed k1 in payload\n for i in 0..N {\n inputs.push(k1.coefficients[i]);\n }\n\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Performs coefficient-wise CRT consistency check for the e0 error polynomial\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n for j in 0..N {\n assert(\n self.e0.coefficients[j]\n == self.e0is[i].coefficients[j]\n + self.e0_quotients[i].coefficients[j] * self.configs.qis[i],\n );\n }\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify public key commitment matches expected\n self.verify_pk_commitment();\n\n // Step 2: Verify message commitment matches expected\n self.verify_message_commitment();\n\n // Step 3: Perform range checks\n self.check_range_bounds();\n\n // Step 4: Check CRT consistency for e0\n self.check_e0_crt_consistency();\n\n // Step 5: Compute scaled message k1 from message\n let k1 = self.compute_scaled_message();\n\n // Step 6: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge(k1);\n\n // Step 7: Verify encryption constraints\n self.verify_evaluations(gammas, k1)\n }\n\n /// Performs range checks on all secret witness polynomial coefficients\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::(self.configs.e0_bound, self.configs.e0_bound);\n self.e1.range_check_2bounds::(self.configs.e1_bound, self.configs.e1_bound);\n\n // Message should be in [0, t)\n self.message.range_check_standard::(self.configs.msg_bound);\n\n for i in 0..L {\n self.pk0is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n\n self.r1is[i].range_check_2bounds::(\n self.configs.r1_up_bounds[i],\n self.configs.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n\n self.p1is[i].range_check_2bounds::(\n self.configs.p1_bounds[i],\n self.configs.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n self.configs.p2_bounds[i],\n self.configs.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(self, k1: Polynomial) -> Vec {\n let inputs = self.payload(k1);\n\n compute_share_encryption_challenge::(inputs)\n }\n\n /// Verifies DKG encryption constraints using Fiat-Shamir challenges and the Schwartz-Zippel lemma\n fn verify_evaluations(self, gammas: Vec, k1: Polynomial) {\n let gamma = gammas.get(0);\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n // Verify ct0 equation: ct0[i] = pk0[i]*u + e0[i] + k1*k0[i] + r1[i]*q[i] + r2[i]*cyclo\n let mut ct0_rhs = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n ct0_rhs += k1_at_gamma * self.configs.k0is[i];\n ct0_rhs += r1i_at_gamma * self.configs.qis[i];\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n let ct0_lhs = self.ct0is[i].eval(gamma);\n\n // Verify ct1 equation: ct1[i] = pk1[i]*u + e1 + p2[i]*cyclo + p1[i]*q[i]\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n let mut ct1_rhs = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n ct1_rhs += p2is_at_gamma * cyclo_at_gamma;\n ct1_rhs += p1is_at_gamma * self.configs.qis[i];\n let ct1_lhs = self.ct1is[i].eval(gamma);\n\n // Accumulate weighted sums for batch verification\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n assert(sum.0 == sum.1);\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_encryption.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "77": { - "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" - }, - "79": { - "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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" - }, - "80": { - "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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/polynomial.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} diff --git a/crates/zk-prover/tests/fixtures/e_sm_share_encryption.vk b/crates/zk-prover/tests/fixtures/e_sm_share_encryption.vk deleted file mode 100644 index 05163e1cbe3ac39ced1e8ac38809ddb99dac74b7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3680 zcmajic|6ql9|!QyAjf2gG1i$|W2DfEbv2_VM`AUSwNgsuPB|;NwIjETBaM~w*EvzN zDWXWBbsvM8a!js~HcPS9Z~oo)JRa@*H}jm=_w#ssKJU-x{rMvF-H*(76^Y1x-w_75 zuk={ABH86l1n;Arlvqa`88|{)Y4}f7*eowQg)5J6S-${R3}n8u4H)an?ksm6So~1+ z5;#Hz4CXV+#Wbn7w^7TZFNJ{LuIoAC#hHNsqy^$$gUYvxS%VTW75_ZOe2X!gUZZprIzQEC|vI}IEmX+zZvg#aV( z%bxy1Wak>-X9iWAlI3!gmT18X1;=7tvA_|+I#h`Fr#6*Wn=v%LEmDA|8)h80a;UG< zH_g=y&U6mY1CEe(HFKL+;+sb`zN8GZ=4Zfzn8hX6EerLTTI!fxlZ!3{;0O`xxY&DA zMuelIYbULxiNF<08a~YZeM01g=1qbn_ZOpK;0Vc54{u&MqGtOP*XkD1J_$T0_UP2K z@wvCB7GLR#CMx%y0nVSl*qrsQCV{5x&c);GzqSBR%u`_1CKl4{(?yfcN8O(v0FIDw z;6zzpo3-Mdyw8q{mHEJ1WfIKHgBxrsqWT;qtS2|N0q4(Oe=Uo_3gNj&+J~#Q-36Xb z9F_PVeY;0F-u=goHf~h7zYvmPSoBBB#JpN5FmW!q>1xcS9!dV&zt#3&3fFq>Px%6{Z zv*aKDC{A3ftH%SUwDv^(Zsh6DO#AKd8}1{r3UGe?qLv9(cFlfSFOmwozXA9lm(0v! zUd@pm)~P5F3y_A+AOF#_jIUCwj^dIXA+xUgL4GY#smME@Zk$@RvTS!ikG>Z;LXz64 z4<5G^#4GkE`nNkr1OJqepYS;>F75a<)|>8gdy@`u{{GpzTet4#V3UO|d*yF0SAZAm zWKq`U%Hpf^R)nr!Qq_14oIn1{i;ZZJenz{@a_AOu1b9mK#~ra|XB~d{-R7o;frusC z-w26_C3q*(I>b~Y?rzX4Vu3uHYLrTqmg?;tZ#+ill73|ZM`%;yX=3zy8&-tpY0daW z1>ku(qRMoq8DW3wIucti!?hhaLi%{+oy!T04P?#RE*|Vxz~^MQd%n0gEZ*eKt5Fi+ z{jCO^-+%UG2Ixs+aN<&qNfT3Wf1kI}Iin#ln8_2tJi6X*;8F3EtsAHKR@6IZD@Nq=|t)3nYudK>bxxlI4AAg{cA(9D+795 z3@7GFVJvWjFbOFo{Vq*zqTG8?4$E(V(q1W5AUW^$awf>@0Ng?OkwEB^a5;ulU@CE zU@MaygJb_Fke4J36sHy@?c)@U>{H5v^*?(OE7nnV`U4@9(Go)o-yI>4m(F6O_x2k| zh1qZaG)~?Q+&o%KR=8k#PyK^tn)>Wi6};adq<7K*=VUySQ5SA$+9jL;@_X|qpVeS1 zM>o&7Ot9|~Lg4w1kWiQ--tWR5YDM~rK?8dV&KoZ|D4fcam@CnQQKMAe=BIU@%e_NWcA{orerAZtR4#F zv5`^H>bW)>M_pd5l@`PLV$=@bzgKCoj&n>Ox8c29kgh;pqS#`fqy&5atAYq--2*tj zh91lOXspK(lJPF-3%HFW!TLvpKYCpbMvQmP7moGh!uzwPK0RK1OsD5MRcig7C$djt z1jbj+4*wx%{Vl81CKU!l0ULi z0k6c!+#{3M>$jVZSBrb)I79+R2=5kSk?k3eF&`ml1ypnaANg{$eKu>)PN%TUeEjRQ zr$fN`>u1-ilkz|fm$^HPbzs+P;6z?e)ns52?n>?s4t1Z3&!52g=eL!p1s=<}8*0O% zb`v~+UovEn-Z>tylE1+2a6qAEuD}t}C1|#YUo!OZ|CSf(otrD*|NcSn{`PPGuW#`E z=D+?Q5jnI{DfilLGWibv;>K-NUIKy5vYi#n^OX#X!0XuN&ziuEJjuIPbw|pm={ljl bLw4> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::dkg::{L, N};\nuse lib::configs::default::dkg::PK_BIT_PK;\nuse lib::core::dkg::pk::Pk;\nuse lib::math::polynomial::Polynomial;\n\nfn main(pk0is: [Polynomial; L], pk1is: [Polynomial; L]) -> pub Field {\n let pk: Pk = Pk::new(pk0is, pk1is);\n pk.execute()\n}\n", - "path": "/home/ace/main/gnosis/enclave/circuits/bin/dkg/pk/src/main.nr" - }, - "62": { - "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::commitments::compute_dkg_pk_commitment;\nuse crate::math::polynomial::Polynomial;\n\n/// Correct DKG Public Key Circuit (Circuit 0).\npub struct Pk {\n /// Correct DKG public key components\n /// pk0[i] is the first component for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component for modulus i\n pk1: [Polynomial; L],\n}\n\nimpl Pk {\n pub fn new(pk0: [Polynomial; L], pk1: [Polynomial; L]) -> Self {\n Pk { pk0, pk1 }\n }\n\n /// Main verification function\n /// Returns commitment to correct DKG public key\n pub fn execute(self) -> Field {\n compute_dkg_pk_commitment::(self.pk0, self.pk1)\n }\n}\n", - "path": "/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/pk.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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": "/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"4119404624100087182","abi":{"parameters":[{"name":"pk0is","type":{"kind":"array","length":1,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk1is","type":{"kind":"array","length":1,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"field"},"visibility":"public"},"error_types":{}},"bytecode":"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","debug_symbols":"pdjRattIFIfxd/F1Lub8z2hG01dZluKmbjEYJ7jJwlL67mvX5ztOFiTSpDdK4upDkc5PM+Tn5uvuy/P3z/vjt4cfm09//dx8Oe0Ph/33z4eH++3T/uF4/unPX3cbvv38dNrtzj/avPj8fNbj9rQ7Pm0+HZ8Ph7vNP9vD8+//9ONxe/x9fNqezp+Wu83u+PV8PAe/7Q+7y1e/7m5nl+VTa5/j5DrPefr0+nxbPn+UGuePNuX5Ta/O1/L5bVQuoJdyu4JeXxV8pdCtR6H1aSwV6nLBy8Q1eHnxW/Tp7YXqWehjqdCWC9P5XxSmaS7vKTTLQpO/q1BKFsw+WlBdKqzMQy+qOQ+zLT1Nsw8PhOnDE7GeeNNIWP3wTKwm3jYU64k3TcWbE+8cizlfEza1xWc6VsbCL59ex8J7WUqorF5FyeEci3dTa8Npl6G5XoVNt6s4j/pbE9M8GndzvHhl/j+x8s4cVrkXw0ZdTKw801qbsXLUcbsKG39wL1o+EZX+nnvxKiG963aOeruddfkq1ubCZDmdvvi60Mp09ub8Ir1NtnQVXj78UN0+/lDXfpHZuZ197tOrq/j7/N32fn96tQnalHPw/JKy60HXg18P9XqYrod2PfTrYb4eRpxOJjoWIYuSRcqiZRGzqFnkLHqKnriu6Cl6ip6ip+gpeoqeoufR8+g5v2j0PHoePY+eR8+j59Gr0avRq9Gr3Lno1ejV6NXo1ejV6E3Rm6I3RW+K3sSjiN4UvSl6U/Sm6LXotei16LXoteg1nm30WvRa9Fr0evR69Hr0evR69Hr0OsMSvR69Hr05enP05ujN0ZujN0dvjt7M9EVvjt6I3ojeiN6I3ojeiN6I3ojeYJxznhnowkQXRrow04WhLkx1YawLc10Y7EL5RoVyYkktySW9JJgUk2QwY6AxpULKuDHgGHIMOoYdA4+hx+Bj+DFP4JQhZBgyEBmKDEaGIwOSIcmgZDXfHZTRZHAyPBmgDFEGKcOUgcpQZVO+ligDy5Bl0DJsGbgMXQYvw5cBzFq+8ShjzEBmKDOYGc4MaIY0g5phzXq+TCnDzfBmgDPEGeQMcwY6Q53BzuZ8T1NGnkHPsGfgM/QZ/Ax/BkBDoI1cAnINYBHAoDAoDAqDwqAwKAwKg8KgLJcXyhgUBoVBYVAYFAaFQeW6lQvXbeWinGtXLl65euXyletXLmAYFAaFQXkuipQxKAwKg8KgMCgMCoPCoDComustZQwKg8KgMCgMCoPCoDAoDGrKpZwyBoVBYVAYFAaFQWFQGBQG1XKXQBmDwqAwKAwKg8KgMCgMCoPquQGhjEFhUBgUBoVBYVAYFAaFQc25t6GMQWFQGBQGhUFhUBgUBoVBjdw25b6JjRMGHYOOQcegY9Ax6Bh0DDoG3XJLRhmDjkHHoGPQMegYdAw6Bh2DrtztUcagY9Ax6Bh0DDoGPXeRuY3MfeRtI0k5t5K5l8zNZO4mczuJQcegXwy6Ll/o8sWvy17/tN9+Oezib5bfno/3L/6E+fTvI5/wR87H08P97uvzaXfZ6f/+7Lz3/w8=","file_map":{"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{L, N};\nuse lib::configs::default::dkg::PK_BIT_PK;\nuse lib::core::dkg::pk::Pk;\nuse lib::math::polynomial::Polynomial;\n\nfn main(pk0is: [Polynomial; L], pk1is: [Polynomial; L]) -> pub Field {\n let pk: Pk = Pk::new(pk0is, pk1is);\n pk.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/pk/src/main.nr"},"62":{"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::commitments::compute_dkg_pk_commitment;\nuse crate::math::polynomial::Polynomial;\n\n/// Correct DKG Public Key Circuit (Circuit 0).\npub struct Pk {\n /// Correct DKG public key components\n /// pk0[i] is the first component for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component for modulus i\n pk1: [Polynomial; L],\n}\n\nimpl Pk {\n pub fn new(pk0: [Polynomial; L], pk1: [Polynomial; L]) -> Self {\n Pk { pk0, pk1 }\n }\n\n /// Main verification function\n /// Returns commitment to correct DKG public key\n pub fn execute(self) -> Field {\n compute_dkg_pk_commitment::(self.pk0, self.pk1)\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/pk.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/pk_aggregation.json b/crates/zk-prover/tests/fixtures/pk_aggregation.json index 4ac30f3f3f..5660d816a2 100644 --- a/crates/zk-prover/tests/fixtures/pk_aggregation.json +++ b/crates/zk-prover/tests/fixtures/pk_aggregation.json @@ -1,116 +1 @@ -{ - "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "16715564098402969150", - "abi": { - "parameters": [ - { - "name": "expected_threshold_pk_commitments", - "type": { "kind": "array", "length": 5, "type": { "kind": "field" } }, - "visibility": "public" - }, - { - "name": "pk0", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - } - }, - "visibility": "private" - }, - { - "name": "pk1", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - } - }, - "visibility": "private" - }, - { - "name": "pk0_agg", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "pk1_agg", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - } - ], - "return_type": { "abi_type": { "kind": "field" }, "visibility": "public" }, - "error_types": { - "15123513130736236245": { "error_kind": "string", "string": "pk aggregation mismatch" }, - "15764276373176857197": { "error_kind": "string", "string": "Stack too deep" }, - "16412438021473037783": { "error_kind": "string", "string": "PK commitment mismatch" } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "file_map": { - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::H;\nuse lib::configs::default::threshold::{L, N, PK_AGGREGATION_BIT_PK, PK_AGGREGATION_CONFIGS};\nuse lib::core::threshold::pk_aggregation::PkAggregation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_threshold_pk_commitments: pub [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n) -> pub Field {\n let pk_aggregation: PkAggregation = PkAggregation::new(\n PK_AGGREGATION_CONFIGS,\n expected_threshold_pk_commitments,\n pk0,\n pk1,\n pk0_agg,\n pk1_agg,\n );\n\n pk_aggregation.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/pk_aggregation/src/main.nr" - }, - "69": { - "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::commitments::compute_pk_aggregation_commitment;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold public key aggregation circuit.\npub struct Configs {\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Public Key Aggregation (Circuit 5).\n///\n/// Verifies that for each CRT basis l and each coefficient i:\n/// - pk0_agg[l][i] = sum_h(pk0[h][l][i]) mod q_l\n/// - pk1_agg[l][i] = sum_h(pk1[h][l][i]) mod q_l\npub struct PkAggregation {\n /// Circuit parameters including CRT moduli\n configs: Configs,\n\n /// Expected commitments to threshold public key (from C1)\n /// We need one commitment from each honest party (H).\n /// (public witness)\n expected_threshold_pk_commitments: [Field; H],\n\n /// Individual public keys from H honest parties\n /// pk0[party_idx][basis_idx] - first component of public key for each party and CRT basis\n /// (committed witnesses)\n pk0: [[Polynomial; L]; H],\n /// pk1[party_idx][basis_idx] - second component of public key for each party and CRT basis\n /// (committed witnesses)\n pk1: [[Polynomial; L]; H],\n\n /// Claimed aggregated public key\n /// pk0_agg[basis_idx] - first component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk0_agg: [Polynomial; L],\n /// pk1_agg[basis_idx] - second component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk1_agg: [Polynomial; L],\n}\n\nimpl PkAggregation {\n pub fn new(\n configs: Configs,\n expected_threshold_pk_commitments: [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n ) -> Self {\n PkAggregation { configs, expected_threshold_pk_commitments, pk0, pk1, pk0_agg, pk1_agg }\n }\n\n /// Verifies that pk hashes to each expected_threshold_pk_commitment\n fn verify_pk_commitments(self) {\n for i in 0..H {\n assert(\n compute_pk_aggregation_commitment::(self.pk0[i], self.pk1[i])\n == self.expected_threshold_pk_commitments[i],\n \"PK commitment mismatch\",\n );\n }\n }\n\n fn verify_pk_for_basis(\n self,\n pk: [[Polynomial; L]; H],\n pk_agg: [Polynomial; L],\n basis_idx: u32,\n ) {\n let q_l = self.configs.qis[basis_idx];\n let mod_q_l = ModU128::new(q_l);\n\n for coeff_idx in 0..N {\n // Sum pk coefficients from all honest parties\n let mut sum_pk: Field = 0;\n for party_idx in 0..H {\n sum_pk = sum_pk + pk[party_idx][basis_idx].coefficients[coeff_idx];\n }\n\n // Reduce mod q_l\n let sum_pk_reduced = mod_q_l.reduce_mod(sum_pk);\n\n // Verify equality\n assert(\n sum_pk_reduced == pk_agg[basis_idx].coefficients[coeff_idx],\n \"pk aggregation mismatch\",\n );\n }\n }\n\n /// Main verification function\n /// Returns commitment to aggregated threshold public key\n pub fn execute(self) -> Field {\n // 0. Verify pk commitments\n self.verify_pk_commitments();\n\n // 1. Verify pk0 & pk1 aggregations for each CRT basis\n for basis_idx in 0..L {\n self.verify_pk_for_basis(self.pk0, self.pk0_agg, basis_idx);\n self.verify_pk_for_basis(self.pk1, self.pk1_agg, basis_idx);\n }\n\n // 2. Commit to aggregated threshold public key\n compute_pk_aggregation_commitment::(self.pk0_agg, self.pk1_agg)\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/pk_aggregation.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "77": { - "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" - }, - "79": { - "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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"18330888056988993146","abi":{"parameters":[{"name":"expected_threshold_pk_commitments","type":{"kind":"array","length":5,"type":{"kind":"field"}},"visibility":"public"},{"name":"pk0","type":{"kind":"array","length":5,"type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}}},"visibility":"private"},{"name":"pk1","type":{"kind":"array","length":5,"type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}}},"visibility":"private"},{"name":"pk0_agg","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk1_agg","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"field"},"visibility":"public"},"error_types":{"15123513130736236245":{"error_kind":"string","string":"pk aggregation mismatch"},"15764276373176857197":{"error_kind":"string","string":"Stack too deep"},"16412438021473037783":{"error_kind":"string","string":"PK commitment mismatch"}}},"bytecode":"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","debug_symbols":"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","file_map":{"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::H;\nuse lib::configs::default::threshold::{L, N, PK_AGGREGATION_BIT_PK, PK_AGGREGATION_CONFIGS};\nuse lib::core::threshold::pk_aggregation::PkAggregation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_threshold_pk_commitments: pub [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n) -> pub Field {\n let pk_aggregation: PkAggregation = PkAggregation::new(\n PK_AGGREGATION_CONFIGS,\n expected_threshold_pk_commitments,\n pk0,\n pk1,\n pk0_agg,\n pk1_agg,\n );\n\n pk_aggregation.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/pk_aggregation/src/main.nr"},"69":{"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::commitments::compute_pk_aggregation_commitment;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold public key aggregation circuit.\npub struct Configs {\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Public Key Aggregation (Circuit 5).\n///\n/// Verifies that for each CRT basis l and each coefficient i:\n/// - pk0_agg[l][i] = sum_h(pk0[h][l][i]) mod q_l\n/// - pk1_agg[l][i] = sum_h(pk1[h][l][i]) mod q_l\npub struct PkAggregation {\n /// Circuit parameters including CRT moduli\n configs: Configs,\n\n /// Expected commitments to threshold public key (from C1)\n /// We need one commitment from each honest party (H).\n /// (public witness)\n expected_threshold_pk_commitments: [Field; H],\n\n /// Individual public keys from H honest parties\n /// pk0[party_idx][basis_idx] - first component of public key for each party and CRT basis\n /// (committed witnesses)\n pk0: [[Polynomial; L]; H],\n /// pk1[party_idx][basis_idx] - second component of public key for each party and CRT basis\n /// (committed witnesses)\n pk1: [[Polynomial; L]; H],\n\n /// Claimed aggregated public key\n /// pk0_agg[basis_idx] - first component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk0_agg: [Polynomial; L],\n /// pk1_agg[basis_idx] - second component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk1_agg: [Polynomial; L],\n}\n\nimpl PkAggregation {\n pub fn new(\n configs: Configs,\n expected_threshold_pk_commitments: [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n ) -> Self {\n PkAggregation { configs, expected_threshold_pk_commitments, pk0, pk1, pk0_agg, pk1_agg }\n }\n\n /// Verifies that pk hashes to each expected_threshold_pk_commitment\n fn verify_pk_commitments(self) {\n for i in 0..H {\n assert(\n compute_pk_aggregation_commitment::(self.pk0[i], self.pk1[i])\n == self.expected_threshold_pk_commitments[i],\n \"PK commitment mismatch\",\n );\n }\n }\n\n fn verify_pk_for_basis(\n self,\n pk: [[Polynomial; L]; H],\n pk_agg: [Polynomial; L],\n basis_idx: u32,\n ) {\n let q_l = self.configs.qis[basis_idx];\n let mod_q_l = ModU128::new(q_l);\n\n for coeff_idx in 0..N {\n // Sum pk coefficients from all honest parties\n let mut sum_pk: Field = 0;\n for party_idx in 0..H {\n sum_pk = sum_pk + pk[party_idx][basis_idx].coefficients[coeff_idx];\n }\n\n // Reduce mod q_l\n let sum_pk_reduced = mod_q_l.reduce_mod(sum_pk);\n\n // Verify equality\n assert(\n sum_pk_reduced == pk_agg[basis_idx].coefficients[coeff_idx],\n \"pk aggregation mismatch\",\n );\n }\n }\n\n /// Main verification function\n /// Returns commitment to aggregated threshold public key\n pub fn execute(self) -> Field {\n // 0. Verify pk commitments\n self.verify_pk_commitments();\n\n // 1. Verify pk0 & pk1 aggregations for each CRT basis\n for basis_idx in 0..L {\n self.verify_pk_for_basis(self.pk0, self.pk0_agg, basis_idx);\n self.verify_pk_for_basis(self.pk1, self.pk1_agg, basis_idx);\n }\n\n // 2. Commit to aggregated threshold public key\n compute_pk_aggregation_commitment::(self.pk0_agg, self.pk1_agg)\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/pk_aggregation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/pk_aggregation.vk b/crates/zk-prover/tests/fixtures/pk_aggregation.vk index e6e87604774c2e1e8c8e44ff6f3eb498ca04eed4..58a10c89eef0602904ff50a5ced0d1cbabd1509e 100644 GIT binary patch delta 1747 zcmV;^1}ypD9N-R+V1E=j;2nN9Jh>XtKLu76`Kr6yt{x>aS{^9CEr zW@rPWVy>MqQW;xB2I1YLoDW<96DLUzH#e1%_nAYeu5?^5KD20Ty%>OKFOtzUHXK+7 zVbp|r{lfqq{4Ve4#Lj){la(CH$hveV9f^KHxhV=D2#Sz!#0dpQhxvI)iP(P6I=!Jh zqJmLi+@C-D+SUY$CfaVGB{6-0w}_m;&?qQ+c3E}dgE}oDDVmB7t~kqs}hR| zLq$QOH|**{cr^@ZS;He5Oa1xDKvezCA)dY6RQk@^57knKP#Mn;Elm)5gXWRnivDv;7`+4OWR^&K_Y(io7S6r`VgW`XJq@ zou@qYLzN(35EblmVt3ic2s!&=v59EJ{tWYkcm>_%bEe=w;8YVC|G< zA8X=rB7b@EmJ1b~pV|xWU0K=`M6lfmO$kG1#UQI8|-#7%Cb*3&?@-pd1AuZjTBLqmgS1xq8D`M)ySON|I|O zHf<_Y;T9KJQ9Wx|;CA=y(PH5oxF8$0 zsH)5&RB&JHJ#k{h6&`ti=hXq7u`ChqP;H18t-bO4BQF6KB8=RT#~a|057;E{HKZ_4 z0Dtq+h%Y-459xVpG{DZ}JvUMpTd;Q#iqV?>a9q z1bTZO3j$?~QG6^HDUtVE_J`$CE~4Cp9e>G+vA7hH(G{eQe*!UO@rGt8!fjES#;$TF zT%>UMk@!`2vboSGAQej`3eKM`u2Hsye~Ix$zjc1JPKw9S)bh*br?Q?zSrrki*3KYi z0&A9e-Szc5`5`uqY0bcJY$e0sThcOH;wPrKT)dJ^FN33bvslqhX)Xu*T22vbcYoUM z0mE^#yCw?}=fxd)zf4Yuh_ASB7An_=CWR!4921WkzL!B9owBg-Oo2VfsXuAm2sGZgAm6j$t@k z1vYTdID}kueApKdbp+A(BsqLN2YTM7*KJx^SSe)g_<_r$`~0w==f0FEdiz*bi8ni( zTdC0!>t}xj@!hAhxi?|{Bweh{{;om*MRKHIWphCgfK-^^CO-s#?%inetAAwJ3T@?_ zu}jVNBYbVhSyLvx7llgH$3EU^|OCDCLF9s{O@ z(r{66-JS^O{nuLT9(T1FyMOWExAu@T3GIy9ZV8?{)u5mXxBeIe0R_3Um9^Nnw5B@+ z-(@Qe5bqRiCIA(<(otP@;>_%s+|iU-At|pqV}Dv=Dl$Y5h7BGne;bi?7m^FDJ&V8` zm6Zu9A}ff22;3#nsznY9OTrSvelT8%lCenc+al)ak_UQ(NFhPT>wn}R0HM{4%XBy& zZ5b0*emjv|fdM+&6(eh<&!zzpv_L=$E6O+Gu?Sw0N_PQB(j|$x9}SO2bgx%L-rD_R z%Ic6yLr!#$mlNKM!`B2o20If9-?MWiPBE$%j zFl1`~mUCg0l#?)(Dw8t}9+40ZlYb2$K>`sOSl6}Mh||B{@=0`LTm{?(*$s_@^${0iGYlOY)hD1xsMRTS4g*RMX~?@ literal 3680 zcmajic{r479|!PzEZLH6hK8~4OGrm1%c+D{h88Jnktj7dLRnrfE%t~R%b_F(Q4v|n zs3gldEh=V87>#i#N*H89qBHNG{pPw(&wuyzdA`?mU-$BReh)(b`pEvPA|(G4#{l=V za1dWy$k7?CeZV~-_odMsI6~Mh!)nH@uOq%&w;k=>;tu?Ses}1_6>Gddd%3X9yj|}i zaD)Ule)(!9HU3@DxWJDxehPTmx;<}H-bhy2VBSXiE$s`S0Y}K#jddW}NVn8{|DE~d z_7A}As^{XB?vn~#W-BN1H~G~Z0glkR%kk7%`Z=r89+L9~<`8hfGXI(@rmlEzyET8a z%8R6YfFrcwnvTEbz5RiMpVufoI~oMs$Mo06px~DEXM#+qbo0#w58w!4`Dhx{$|Yi(D@R0e79xGAJ(Nw z`07yCZ2SegQs4-wiKb_Vb&3i9CuJ#SXIek-f{|z&qe0VVV(e%bO>agFt}jA{!VJ~N z`KH-s#NC+!dhH-@8*RS!xMzo^B57sm={C0&I6s6GUc1j!$zBlKVZXi1VsZlHr8c-o z$DSXfu+vwg<3|eGUI9l)y|{(t_Vp!Gs@FAT5561ty#NOXeJ?cw{Yqb3EMu^U4ICla zAlj|w>Lj;zFQuMzE(tihO+)xoG?z3mAGv|6Y(BsMju0+9uaHAby?%wp)t9{s&&Pmu z!!eP=PoCP$t2I>iU#|JemtUV<@@`q^b~uh9=tBK=0=R!d?gV$|88!Ly(KG2JQ(_Nr z-u|&}T&c9??#NT~mBvj*0RIr!UE?>EdsLM?60Q+5moEXFH~*OwBPW+Sa@_ROMKkR_ z;MElKiq;)VHW675H@{NKA@ZMJ+?A_L3C=-JCf4pYOFbLpw~5t%QavWKvA+UK+#fQ% z-T*j4+VjCA&+hN#J#D!Acc0Dzr;sI@V>>(?7VIXRsATQUA;1w*{8i$~+1V0;uzF~g zxMUe{(Q>S?pCA)c;i(v}g$KaZlWgaYXC8l@oH=}YVUq6uH*kauoa9=zPfFDn zdQl3uDsKYr--%O+Nf__NT&XjX;p_=X1&$DbrlxfF`pxGWZehNYHYb4(Q>6N}IOgT1 zyU}Mxs)>~haNhm9)iS%RX@Zg0$aqV6tOUHIwd}b8)+au*)xAog>0EsqaD=2j#*lw` zG1%#zmA?)gzM-1CFQ-Vap~J6<)`U&G%S_Qmlult zuZn~~V8-4!BL#iR0`R|T!gYPh!+8x8*3^VT$ z;Jmy{^_!P!M+M0FF)S|E3ixqjk!7!4GUO=cG^XQZ!+jm#2&9;OwO0ZGS5#+KI9~LBeoVEmxkc7W!TEtJ) zzNUmPkGLYY6^j#n*ZAJ(tlqc{c#R-Fu9u)+hR<^%p|I#;MC-z}I#tNJ^ zSqH)Ww>FF$_UY_#ATHhrt9R5qcaJZ>cHU*ED$ds(|4yNnk_YPpHRBWQPrUHvupVNf zPh?!b0$*Nkz-esEIka(R?I0t@l?B|((?dUCdhu*m`SQ2hCF2isfg>b+N{GIowI$9* zBzCBx57xH?;aOH?L$k%Xo|KAjfe2x-QJJbCYy zth`7|aj(c_0=KaZWCxaRY~jW-n#B_ZrLO_!)t@BN+Fv$Y>Wmmvyh_fD0nXrPdb6~? zM#~%3$!lrT1H^#y>fgJFzR^qly{_q*>JKmk;FBs*ckuUThnv1+ZxWlzV1@!mNJX$B zi4nH+!t6jpNofu?g#Z4C6gz~@bt*@$-=kvTv#783{%gFzSXARv|lGdYM1SZ=gTWm zPAO0&ZrNOTM99k%gWp$2_3e*8y;DPf^k#HL5>-R+e0kGDY1BH$=|PRLk5rM^MBo(| znZ|9~Bn+QfjMRx9qB=zZM@a5KycNagEXI&x|~o1(T#8ZIyj9^(Hzr&6W{YA4(IaU&mRNu|L8~k`AFdBul(=^ z>yq>5AeFYsSnm2YSC!2KW`5BB4`lEjeRr6tuUgromv7jw0$0b2jwa9PMh!cQG-pY7 ZxH|$zNa*5fZ~4iaGwjZ9;)7dr{sC5EKED6} diff --git a/crates/zk-prover/tests/fixtures/pk_generation.json b/crates/zk-prover/tests/fixtures/pk_generation.json index c1ae8868bf..b89a636e89 100644 --- a/crates/zk-prover/tests/fixtures/pk_generation.json +++ b/crates/zk-prover/tests/fixtures/pk_generation.json @@ -1,154 +1 @@ -{ - "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "944264242874897871", - "abi": { - "parameters": [ - { - "name": "a", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "public" - }, - { - "name": "eek", - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - }, - "visibility": "private" - }, - { - "name": "sk", - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - }, - "visibility": "private" - }, - { - "name": "e_sm", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "r1is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 1023, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "r2is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 511, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "pk0is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "pk1is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "lib::math::polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "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" }, - "15711739108859631478": { "error_kind": "string", "string": "Public key equation 2 failed" }, - "16226075151901316264": { "error_kind": "string", "string": "Public key equation 1 failed" } - } - }, - "bytecode": "H4sIAAAAAAAA/6zwVbSW9R+2e0t3d190d3d3d3d3d3d3d3c3iIiIiIiIiIiUiIiAiICIiIi8y3etNcZ8xtqY//O4z2uDucHxu8/v+ER47//+Iv8/f3u3796nfP/33qs4+L3/zxfx//kbvPc/fRH++9H/t83Xqc6Au/nXZT9Wr/KR8eObtc5W8GG14cf7za949+XCZ//X/79L9z//buII/9c/kf7/A//3u6jh3Klsh9f+Fwbv/U9ftrB3/vcovDvD+SJEEDwjBMwzQhC6Z9jt8NqIAfOMGITuGVHwjBQwz0hB6J5ht8NrIwfMM3IQumckwTNKwDyjBKF7ht0Or40aMM+oQeiekQXPaAHzjBaE7hl2O7w2esA8owehe0YRPGMEzDNGELpn2O3w2pgB84wZhO4ZVfCMFTDPWEHonmG3w2tjB8wzdhC6ZzTBM07APOMEoXuG3Q6vjRswz7hB6J7RBc94AfOMF4TuGXY7vDZ+wDzjB6F7xhA8EwTMM0EQumfY7fDahAHzTBiE7hlT8EwUMM9EQeieYbfDaxMHzDNxELpnLMEzScA8kwShe4bdDq9NGjDPpEHonrEFz2QB80wWhO4Zdju8NnnAPJMHoXvGETxTBMwzRRC6Z9jt8NqUAfNMGYTuGVfwTBUwz1RB6J5ht8NrUwfMM3UQumc8wTNNwDzTBKF7ht0Or00bMM+0Qeie8QXPdAHzTBeE7hl2O7w2CJhnEITumUDwTB8wz/RB6J5ht8NrMwTMM0MQumdCwTNjwDwzBqF7ht0Or80UMM9MQeieiQTPzAHzzByE7hl2O7w2S8A8swSheyYWPLMGzDNrELpn2O3w2mwB88wWhO6ZRPDMHjDP7EHonmG3w2tzBMwzRxC6Z1LBM2fAPHMGoXuG3Q6vzRUwz1xB6J7JBM/cAfPMHYTuGXY7vDZPwDzzBKF7Jhc88wbMM28QumfY7fDafAHzzBeE7plC8MwfMM/8QeieYbfDawsEzLNAELpnSsGzYMA8Cwahe4bdDq8tFDDPQkHonqkEz8IB8ywchO4Zdju8tkjAPIsEoXumFjyLBsyzaBC6Z9jt8NpiAfMsFoTumUbwLB4wz+JB6J5ht8NrSwTMs0QQumdawbNkwDxLBqF7ht0Ory0VMM9SQeie6QTP0gHzLB2E7hl2O7y2TMA8ywShewaCZ9mAeZYNQvcMux1eWy5gnuWC0D3TC57lA+ZZPgjdM+x2eG2FgHlWCEL3zCB4VgyYZ8UgdM+w2+G1lQLmWSkI3TOj4Fk5YJ6Vg9A9w26H11YJmGeVIHTPTIJn1YB5Vg1C9wy7HV5bLWCe1YLQPTMLntUD5lk9CN0z7HZ4bY2AedYIQvfMInjWDJhnzSB0z7Db4bW1AuZZKwjdM6vgWTtgnrWD0D3DbofX1gmYZ50gdM9sgmfdgHnWDUL3DLsdXlsvYJ71gtA9swue9QPmWT8I3TPsdnhtg4B5NghC98wheDYMmGfDIHTPsNvhtY0C5tkoCN0zp+DZOGCejYPQPcNuh9c2CZhnkyB0z1yCZ9OAeTYNQvcMux1e2yxgns2C0D1zC57NA+bZPAjdM+x2eG2LgHm2CEL3zCN4tgyYZ8sgdM+w2+G1rQLm2SoI3TOv4Nk6YJ6tg9A9w26H17YJmGebIHTPfIJn24B5tg1C9wy7HV7bLmCe7YLQPfMLnu0D5tk+CN0z7HZ4bYeAeXYIQvcsIHh2DJhnxyB0z7Db4bWdAubZKQjds6Dg2Tlgnp2D0D3DbofXdgmYZ5cgdM9CgmfXgHl2DUL3DLsdXtstYJ7dgtA9Cwue3QPm2T0I3TPsdnhtj4B59ghC9ywiePYMmGfPIHTPsNvhtb0C5tkrCN2zqODZO2CevYPQPcNuh9f2CZhnnyB0z2KCZ9+AefYNQvcMux1e2y9gnv2C0D2LC579A+bZPwjdM+x2eO2AgHkOCEL3LCF4DgyY58AgdM+w2+G1gwLmOSgI3bOk4Dk4YJ6Dg9A9w26H1w4JmOeQIHTPUoLn0IB5Dg1C9wy7HV47LGCew4LQPUsLnsMD5jk8CN0z7HZ47YiAeY4IQvcsI3iODJjnyCB0z7Db4bWjAuY5Kgjds6zgOTpgnqOD0D3DbofXjgmY55ggdM9ygufYgHmODUL3DLsdXjsuYJ7jgtA9ywue4wPmOT4I3TPsdnjthIB5TghC96wgeE4MmOfEIHTPsNvhtZMC5jkpCN2zouA5OWCek4PQPcNuh9dOCZjnlCB0z0qC59SAeU4NQvcMux1eOy1gntOC0D0rC57TA+Y5PQjdM+x2eO2MgHnOCEL3rCJ4zgyY58wgdM+w2+G1swLmOSsI3bOq4Dk7YJ6zg9A9w26H184JmOecIHTPaoLn3IB5zg1C9wy7HV47L2Ce84LQPasLnvMD5jk/CN0z7HZ47YKAeS4IQvesIXguDJjnwiB0z7Db4bWLAua5KAjds6bguThgnouD0D3DbofXLgmY55IgdM9agufSgHkuDUL3DLsdXrssYJ7LgtA9awueywPmuTwI3TPsdnjtioB5rghC96wjeK4MmOfKIHTPsNvhtasC5rkqCN2zruC5OmCeq4PQPcNuh9euCZjnmiB0z3qC59qAea4NQvcMux1euy5gnuuC0D3rC57rA+a5PgjdM+x2eO2GgHluCEL3bCB4bgyY58YgdM+w2+G1mwLmuSkI3bOh4Lk5YJ6bg9A9w26H124JmOeWIHTPRoLn1oB5bg1C9wy7HV67LWCe24LQPRsLntsD5rk9CN0z7HZ47Y6Aee4IQvdsInjuDJjnziB0z7Db4bW7Aua5Kwjds6nguTtgnruD0D3DbofX7gmY554gdM9mgufegHnuDUL3DLsdXrsvYJ77gtA9mwue+wPmuT8I3TPsdnjtgYB5HghC92wheB4MmOfBIHTPsNvhtYcC5nkoCN2zpeB5OGCeh4PQPcNuh9ceCZjnkSB0z1aC59GAeR4NQvcMux1eeyxgnseC0D1bC57HA+Z5PAjdM+x2eO37AfN8Pwjds43geSJgnieC0D3DbofXfhAwzw+C0D3bCp4nA+Z5MgjdM+x2eO2HAfP8MAjds53geSpgnqeC0D3DbofXfhQwz4+C0D3bC56nA+Z5OgjdM+x2eO3HAfP8OAjds4PgeSZgnmeC0D3DbofXfhIwz0+C0D07Cp5nA+Z5NgjdM+x2eO2nAfP8NAjds5PgeS5gnueC0D3DbofXfhYwz8+C0D07C57nA+Z5PgjdM+x2eO3nAfP8PAjds4vgeSFgnheC0D3DbofXfhEwzy+C0D27Cp4XA+Z5MQjdM+x2eO2XAfP8Mgjds5vgeSlgnpeC0D3DbofXfhUwz6+C0D27C56XA+Z5OQjdM+x2eO3XAfP8Ogjds4fgeSVgnleC0D3DbofXfhMwz2+C0D17Cp5XA+Z5NQjdM+x2eO23AfP8Ngjds5fgeS1gnteC0D3DbofXfhcwz++C0D17C57XA+Z5PQjdM+x2eO2NgHneCEL37CN43gyY580gdM+w2+G1twLmeSsI3bOv4Hk7YJ63g9A9w26H134fMM/vg9A9+wmedwLmeScI3TPsdnjtDwHz/CEI3bO/4Hk3YJ53g9A9w26H1/4YMM8fg9A9Bwie9wLmeS8I3TPsdnjtTwHz/CkI3XOg4Hk/YJ73g9A9w26H1/4cMM+fg9A9BwmeDwLm+SAI3TPsdnjtw4B5PgxC9xwseD4KmOejIHTPsNvhtb8EzPOXIHTPIYLn44B5Pg5C9wy7HV77a8A8fw1C9xwqeD4JmOeTIHTPsNvhtb8FzPO3IHTPYYLn04B5Pg1C9wy7HV77LGCez4LQPYcLns8D5vk8CN0z7HZ47e8B8/w9CN1zhOD5ImCeL4LQPcNuh9f+ETDPP4LQPUcKni8D5vkyCN0z7HZ47Z8B8/wzCN1zlOD5KmCer4LQPcNuh9f+FTDPv4LQPUcLnq8D5vk6CN0z7HZ47d8B8/w7CN1zjOD5JmCeb4LQPcNuh9f+EzDPf4LQPccKnm8D5vk2CN0z7HZ47b8B8/w3CN1znOD5LmCe74LQPcNuh9e+l555/vcuVM/xgmeE9MwzQvrQPcNuh9dGhJ4RDZ4TBM9I0DOSwTOS4BkZekY2eE4UPKNAzygGzyiCZ1ToGdXgOUnwjAY9oxk8owme0aFndIPnZMEzBvSMYfCMIXjGhJ4xDZ5TBM9Y0DOWwTOW4BkbesY2eE4VPONAzzgGzziCZ1zoGdfgOU3wjAc94xk84wme8aFnfIPndMEzAfRMYPBMIHgmhJ4JDZ4zBM9E0DORwTOR4JkYeiY2eM4UPJNAzyQGzySCZ1LomdTgOUvwTAY9kxk8kwmeyaFncoPnbMEzBfRMYfBMIXimhJ4pDZ5zBM9U0DOVwTOV4JkaeqY2eM4VPNNAzzQGzzSCZ1romdbgOU/wTAc90xk80wmeAfQMDJ7zBc/00DO9wTO94JkBemYweC4QPDNCz4wGz4yCZybomcnguVDwzAw9Mxs8MwueWaBnFoPnIsEzK/TMavDMKnhmg57ZDJ6LBc/s0DO7wTO74JkDeuYweC4RPHNCz5wGz5yCZy7omcvguVTwzA09cxs8cwueeaBnHoPnMsEzL/TMa/DMK3jmg575DJ7LBc/80DO/wTO/4FkAehYweK4QPAtCz4IGz4KCZyHoWcjguVLwLAw9Cxs8CwueRaBnEYPnKsGzKPQsavAsKngWg57FDJ6rBc/i0LO4wbO44FkCepYweK4RPEtCz5IGz5KCZynoWcrguVbwLA09Sxs8SwueZaBnGYPnOsGzLPQsa/AsK3iWg57lDJ7rBc/y0LO8wbO84FkBelYweG4QPCtCz4oGz4qCZyXoWcnguVHwrAw9Kxs8KwueVaBnFYPnJsGzKvSsavCsKnhWg57VDJ6bBc/q0LO6wbO64FkDetYweG4RPGtCz5oGz5qCZy3oWcvguVXwrA09axs8awuedaBnHYPnNsGzLvSsa/CsK3jWg571DJ7bBc/60LO+wbO+4NkAejYweO4QPBtCz4YGz4aCZyPo2cjguVPwbAw9Gxs8GwueTaBnE4PnLsGzKfRsavBsKng2g57NDJ67Bc/m0LO5wbO54NkCerYweO4RPFtCz5YGz5aCZyvo2crguVfwbA09Wxs8WwuebaBnG4PnPsGzLfRsa/BsK3i2g57tDJ77Bc/20LO9wbO94NkBenYweB4QPDtCz44Gz46CZyfo2cngeVDw7Aw9Oxs8OwueXaBnF4PnIcGzK/TsavDsKnh2g57dDJ6HBc/u0LO7wbO74NkDevYweB4RPHtCz54Gz56CZy/o2cvgeVTw7A09exs8ewuefaBnH4PnMcGzL/Tsa/DsK3j2g579DJ7HBc/+0LO/wbO/4DkAeg4weL4veA6EngMNngMFz0HQc5DB84TgORh6DjZ4DhY8h0DPIQbPDwTPodBzqMFzqOA5DHoOM3ieFDyHQ8/hBs/hgucI6DnC4Pmh4DkSeo40eI4UPEdBz1EGz1OC52joOdrgOVrwHAM9xxg8PxI8x0LPsQbPsYLnOOg5zuB5WvAcDz3HGzzHC54ToOcEg+fHgudE6DnR4DlR8JwEPScZPM8InpOh52SD52TBcwr0nGLw/ETwnAo9pxo8pwqe06DnNIPnWcFzOvScbvCcLnjOgJ4zDJ6fCp4zoedMg+dMwXMW9Jxl8DwneM6GnrMNnrMFzznQc47B8zPBcy70nGvwnCt4zoOe8wye5wXP+dBzvsFzvuC5AHouMHh+LnguhJ4LDZ4LBc9F0HORwfOC4LkYei42eC4WPJdAzyUGzy8Ez6XQc6nBc6nguQx6LjN4XhQ8l0PP5QbP5YLnCui5wuD5peC5EnquNHiuFDxXQc9VBs9Lgudq6Lna4Lla8FwDPdcYPL8SPNdCz7UGz7WC5zrouc7geVnwXA891xs81wueG6DnBoPn14LnRui50eC5UfDcBD03GTyvCJ6boedmg+dmwXML9Nxi8PxG8NwKPbcaPLcKntug5zaD51XBczv03G7w3C547oCeOwye3wqeO6HnToPnTsFzF/TcZfC8Jnjuhp67DZ67Bc890HOPwfM7wXMv9Nxr8NwreO6DnvsMntcFz/3Qc7/Bc7/geQB6HjB43hA8D0LPgwbPg4LnIeh5yOB5U/A8DD0PGzwPC55HoOcRg+ctwfMo9Dxq8DwqeB6DnscMnrcFz+PQ87jB87jg+T70fN/g+b3geQJ6njB4nhA8P4CeHxg87wieJ6HnSYPnScHzQ+j5ocHzB8HzFPQ8ZfA8JXh+BD0/MnjeFTxPQ8/TBs/TgufH0PNjg+ePgucZ6HnG4HlG8PwEen5i8LwneJ6FnmcNnmcFz0+h56cGz58Ez3PQ85zB85zg+Rn0/MzgeV/wPA89zxs8zwuen0PPzw2ePwueF6DnBYPnBcHzC+j5hcHzgeB5EXpeNHheFDy/hJ5fGjwfCp6XoOclg+clwfMr6PmVwfOR4HkZel42eF4WPL+Gnl8bPH8RPK9AzysGzyuC5zfQ8xuD52PB8yr0vGrwvCp4fgs9vzV4/ip4XoOe1wye1wTP76DndwbPJ4Lndeh53eB5XfC8AT1vGDx/EzxvQs+bBs+bguct6HnL4PlU8LwNPW8bPG8Lnt9Dz+8Nns8EzzvQ847B847g+QP0/MHg+VzwvAs97xo87wqeP0LPHw2evwue96DnPYPnPcHzJ+j5k8HzheB5H3reN3jeFzx/hp4/Gzz/EDwfQM8HBs8HgudD6PnQ4PlS8HwEPR8ZPB8Jnr9Az18Mnn8Kno+h52OD52PB81fo+avB85Xg+QR6PjF4PhE8f4Oevxk8/xI8n0LPpwbPp4LnM+j5zOD5WvB8Dj2fGzyfC56/Q8/fDZ5/C54voOcLg+cLwfMP6PmHwfON4PkSer40eL4UPP+Enn8aPP8RPF9Bz1cGz1eC51/Q8y+D51vB8zX0fG3wfC14/g09/zZ4/it4voGebwyebwTPf6DnPwbPd4LnW+j51uD5VvD8F3r+a/B8L8r/fuc76PnO4PlO8HwvA/P8712onhEEzwgZmGeEDKF7ht0Or40IPSMaPCMKnpGgZySDZyTBMzL0jGzwjCR4RoGeUQyeUQTPqNAzqsEzsuAZDXpGM3hGEzyjQ8/oBs8ogmcM6BnD4BlD8IwJPWMaPKMKnrGgZyyDZyzBMzb0jG3wjCZ4xoGecQyecQTPuNAzrsEzuuAZD3rGM3jGEzzjQ8/4Bs8YgmcC6JnA4JlA8EwIPRMaPGMKnomgZyKDZyLBMzH0TGzwjCV4JoGeSQyeSQTPpNAzqcEztuCZDHomM3gmEzyTQ8/kBs84gmcK6JnC4JlC8EwJPVMaPOMKnqmgZyqDZyrBMzX0TG3wjCd4poGeaQyeaQTPtNAzrcEzvuCZDnqmM3imEzwD6BkYPBMInumhZ3qDZ3rBMwP0zGDwTCh4ZoSeGQ2eGQXPTNAzk8EzkeCZGXpmNnhmFjyzQM8sBs/EgmdW6JnV4JlV8MwGPbMZPJMIntmhZ3aDZ3bBMwf0zGHwTCp45oSeOQ2eOQXPXNAzl8EzmeCZG3rmNnjmFjzzQM88Bs/kgmde6JnX4JlX8MwHPfMZPFMInvmhZ36DZ37BswD0LGDwTCl4FoSeBQ2eBQXPQtCzkMEzleBZGHoWNngWFjyLQM8iBs/UgmdR6FnU4FlU8CwGPYsZPNMInsWhZ3GDZ3HBswT0LGHwTCt4loSeJQ2eJQXPUtCzlMEzneBZGnqWNniWFjzLQM8yBs9A8CwLPcsaPMsKnuWgZzmDZ3rBszz0LG/wLC94VoCeFQyeGQTPitCzosGzouBZCXpWMnhmFDwrQ8/KBs/KgmcV6FnF4JlJ8KwKPasaPKsKntWgZzWDZ2bBszr0rG7wrC541oCeNQyeWQTPmtCzpsGzpuBZC3rWMnhmFTxrQ8/aBs/agmcd6FnH4JlN8KwLPesaPOsKnvWgZz2DZ3bBsz70rG/wrC94NoCeDQyeOQTPhtCzocGzoeDZCHo2MnjmFDwbQ8/GBs/GgmcT6NnE4JlL8GwKPZsaPJsKns2gZzODZ27Bszn0bG7wbC54toCeLQyeeQTPltCzpcGzpeDZCnq2MnjmFTxbQ8/WBs/Wgmcb6NnG4JlP8GwLPdsaPNsKnu2gZzuDZ37Bsz30bG/wbC94doCeHQyeBQTPjtCzo8Gzo+DZCXp2MngWFDw7Q8/OBs/OgmcX6NnF4FlI8OwKPbsaPLsKnt2gZzeDZ2HBszv07G7w7C549oCePQyeRQTPntCzp8Gzp+DZC3r2MngWFTx7Q8/eBs/egmcf6NnH4FlM8OwLPfsaPPsKnv2gZz+DZ3HBsz/07G/w7C94DoCeAwyeJQTPgdBzoMFzoOA5CHoOMniWFDwHQ8/BBs/BgucQ6DnE4FlK8BwKPYcaPIcKnsOg5zCDZ2nBczj0HG7wHC54joCeIwyeZQTPkdBzpMFzpOA5CnqOMniWFTxHQ8/RBs/RgucY6DnG4FlO8BwLPccaPMcKnuOg5ziDZ3nBczz0HG/wHC94ToCeEwyeFQTPidBzosFzouA5CXpOMnhWFDwnQ8/JBs/JgucU6DnF4FlJ8JwKPacaPKcKntOg5zSDZ2XBczr0nG7wnC54zoCeMwyeVQTPmdBzpsFzpuA5C3rOMnhWFTxnQ8/ZBs/Zgucc6DnH4FlN8JwLPecaPOcKnvOg5zyDZ3XBcz70nG/wnC94LoCeCwyeNQTPhdBzocFzoeC5CHouMnjWFDwXQ8/FBs/FgucS6LnE4FlL8FwKPZcaPJcKnsug5zKDZ23Bczn0XG7wXC54roCeKwyedQTPldBzpcFzpeC5CnquMnjWFTxXQ8/VBs/Vguca6LnG4FlP8FwLPdcaPNcKnuug5zqDZ33Bcz30XG/wXC94boCeGwyeDQTPjdBzo8Fzo+C5CXpuMng2FDw3Q8/NBs/NgucW6LnF4NlI8NwKPbcaPLcKntug5zaDZ2PBczv03G7w3C547oCeOwyeTQTPndBzp8Fzp+C5C3ruMng2FTx3Q8/dBs/dguce6LnH4NlM8NwLPfcaPPcKnvug5z6DZ3PBcz/03G/w3C94HoCeBwyeLQTPg9DzoMHzoOB5CHoeMni2FDwPQ8/DBs/DgucR6HnE4NlK8DwKPY8aPI8Knseg5zGDZ2vB8zj0PG7wPC54vg893zd4thE8T0DPEwbPE4LnB9DzA4NnW8HzJPQ8afA8KXh+CD0/NHi2EzxPQc9TBs9TgudH0PMjg2d7wfM09Dxt8DwteH4MPT82eHYQPM9AzzMGzzOC5yfQ8xODZ0fB8yz0PGvwPCt4fgo9PzV4dhI8z0HPcwbPc4LnZ9DzM4NnZ8HzPPQ8b/A8L3h+Dj0/N3h2ETwvQM8LBs8LgucX0PMLg2dXwfMi9Lxo8LwoeH4JPb80eHYTPC9Bz0sGz0uC51fQ8yuDZ3fB8zL0vGzwvCx4fg09vzZ49hA8r0DPKwbPK4LnN9DzG4NnT8HzKvS8avC8Knh+Cz2/NXj2EjyvQc9rBs9rgud30PM7g2dvwfM69Lxu8LwueN6AnjcMnn0Ez5vQ86bB86bgeQt63jJ49hU8b0PP2wbP24Ln99Dze4NnP8HzDvS8Y/C8I3j+AD1/MHj2FzzvQs+7Bs+7gueP0PNHg+cAwfMe9Lxn8LwneP4EPX8yeA4UPO9Dz/sGz/uC58/Q82eD5yDB8wH0fGDwfCB4PoSeDw2egwXPR9DzkcHzkeD5C/T8xeA5RPB8DD0fGzwfC56/Qs9fDZ5DBc8n0POJwfOJ4Pkb9PzN4DlM8HwKPZ8aPJ8Kns+g5zOD53DB8zn0fG7wfC54/g49fzd4jhA8X0DPFwbPF4LnH9DzD4PnSMHzJfR8afB8KXj+CT3/NHiOEjxfQc9XBs9Xgudf0PMvg+dowfM19Hxt8HwteP4NPf82eI4RPN9AzzcGzzeC5z/Q8x+D51jB8y30fGvwfCt4/gs9/zV4jhM830HPdwbPd4LnexmZ53/vQvUcL3hGyMg8I2QM3TPsdnhtROgZ0eA5QfCMBD0jGTwjCZ6RoWdkg+dEwTMK9Ixi8IwieEaFnlENnpMEz2jQM5rBM5rgGR16Rjd4ThY8Y0DPGAbPGIJnTOgZ0+A5RfCMBT1jGTxjCZ6xoWdsg+dUwTMO9Ixj8IwjeMaFnnENntMEz3jQM57BM57gGR96xjd4Thc8E0DPBAbPBIJnQuiZ0OA5Q/BMBD0TGTwTCZ6JoWdig+dMwTMJ9Exi8EwieCaFnkkNnrMEz2TQM5nBM5ngmRx6Jjd4zhY8U0DPFAbPFIJnSuiZ0uA5R/BMBT1TGTxTCZ6poWdqg+dcwTMN9Exj8EwjeKaFnmkNnvMEz3TQM53BM53gGUDPwOA5X/BMDz3TGzzTC54ZoGcGg+cCwTMj9Mxo8MwoeGaCnpkMngsFz8zQM7PBM7PgmQV6ZjF4LhI8s0LPrAbPrIJnNuiZzeC5WPDMDj2zGzyzC545oGcOg+cSwTMn9Mxp8MwpeOaCnrkMnksFz9zQM7fBM7fgmQd65jF4LhM880LPvAbPvIJnPuiZz+C5XPDMDz3zGzzzC54FoGcBg+cKwbMg9Cxo8CwoeBaCnoUMnisFz8LQs7DBs7DgWQR6FjF4rhI8i0LPogbPooJnMehZzOC5WvAsDj2LGzyLC54loGcJg+cawbMk9Cxp8CwpeJaCnqUMnmsFz9LQs7TBs7TgWQZ6ljF4rhM8y0LPsgbPsoJnOehZzuC5XvAsDz3LGzzLC54VoGcFg+cGwbMi9Kxo8KwoeFaCnpUMnhsFz8rQs7LBs7LgWQV6VjF4bhI8q0LPqgbPqoJnNehZzeC5WfCsDj2rGzyrC541oGcNg+cWwbMm9Kxp8KwpeNaCnrUMnlsFz9rQs7bBs7bgWQd61jF4bhM860LPugbPuoJnPehZz+C5XfCsDz3rGzzrC54NoGcDg+cOwbMh9Gxo8GwoeDaCno0MnjsFz8bQs7HBs7Hg2QR6NjF47hI8m0LPpgbPpoJnM+jZzOC5W/BsDj2bGzybC54toGcLg+cewbMl9Gxp8GwpeLaCnq0MnnsFz9bQs7XBs7Xg2QZ6tjF47hM820LPtgbPtoJnO+jZzuC5X/BsDz3bGzzbC54doGcHg+cBwbMj9Oxo8OwoeHaCnp0MngcFz87Qs7PBs7Pg2QV6djF4HhI8u0LPrgbProJnN+jZzeB5WPDsDj27Gzy7C549oGcPg+cRwbMn9Oxp8OwpePaCnr0MnkcFz97Qs7fBs7fg2Qd69jF4HhM8+0LPvgbPvoJnP+jZz+B5XPDsDz37Gzz7C54DoOcAg+f7gudA6DnQ4DlQ8BwEPQcZPE8InoOh52CD52DBcwj0HGLw/EDwHAo9hxo8hwqew6DnMIPnScFzOPQcbvAcLniOgJ4jDJ4fCp4joedIg+dIwXMU9Bxl8DwleI6GnqMNnqMFzzHQc4zB8yPBcyz0HGvwHCt4joOe4wyepwXP8dBzvMFzvOA5AXpOMHh+LHhOhJ4TDZ4TBc9J0HOSwfOM4DkZek42eE4WPKdAzykGz08Ez6nQc6rBc6rgOQ16TjN4nhU8p0PP6QbP6YLnDOg5w+D5qeA5E3rONHjOFDxnQc9ZBs9zguds6Dnb4Dlb8JwDPecYPD8TPOdCz7kGz7mC5zzoOc/geV7wnA895xs85wueC6DnAoPn54LnQui50OC5UPBcBD0XGTwvCJ6Loedig+diwXMJ9Fxi8PxC8FwKPZcaPJcKnsug5zKD50XBczn0XG7wXC54roCeKwyeXwqeK6HnSoPnSsFzFfRcZfC8JHiuhp6rDZ6rBc810HONwfMrwXMt9Fxr8FwreK6DnusMnpcFz/XQc73Bc73guQF6bjB4fi14boSeGw2eGwXPTdBzk8HziuC5GXpuNnhuFjy3QM8tBs9vBM+t0HOrwXOr4LkNem4zeF4VPLdDz+0Gz+2C5w7oucPg+a3guRN67jR47hQ8d0HPXQbPa4Lnbui52+C5W/DcAz33GDy/Ezz3Qs+9Bs+9guc+6LnP4Hld8NwPPfcbPPcLngeg5wGD5w3B8yD0PGjwPCh4HoKehwyeNwXPw9DzsMHzsOB5BHoeMXjeEjyPQs+jBs+jgucx6HnM4Hlb8DwOPY8bPI8Lnu9Dz/cNnt8Lnieg5wmD5wnB8wPo+YHB847geRJ6njR4nhQ8P4SeHxo8fxA8T0HPUwbPU4LnR9DzI4PnXcHzNPQ8bfA8LXh+DD0/Nnj+KHiegZ5nDJ5nBM9PoOcnBs97gudZ6HnW4HlW8PwUen5q8PxJ8DwHPc8ZPM8Jnp9Bz88MnvcFz/PQ87zB87zg+Tn0/Nzg+bPgeQF6XjB4XhA8v4CeXxg8HwieF6HnRYPnRcHzS+j5pcHzoeB5CXpeMnheEjy/gp5fGTwfCZ6Xoedlg+dlwfNr6Pm1wfMXwfMK9Lxi8LwieH4DPb8xeD4WPK9Cz6sGz6uC57fQ81uD56+C5zXoec3geU3w/A56fmfwfCJ4Xoee1w2e1wXPG9DzhsHzN8HzJvS8afC8KXjegp63DJ5PBc/b0PO2wfO24Pk99Pze4PlM8LwDPe8YPO8Inj9Azx8Mns8Fz7vQ867B867g+SP0/NHg+bvgeQ963jN43hM8f4KePxk8Xwie96HnfYPnfcHzZ+j5s8HzD8HzAfR8YPB8IHg+hJ4PDZ4vBc9H0PORwfOR4PkL9PzF4Pmn4PkYej42eD4WPH+Fnr8aPF8Jnk+g5xOD5xPB8zfo+ZvB8y/B8yn0fGrwfCp4PoOezwyerwXP59DzucHzueD5O/T83eD5t+D5Anq+MHi+EDz/gJ5/GDzfCJ4voedLg+dLwfNP6PmnwfMfwfMV9Hxl8HwleP4FPf8yeL4VPF9Dz9cGz9eC59/Q82+D57+C5xvo+cbg+Ubw/Ad6/mPwfCd4voWebw2ebwXPf6HnvwbP/34g+B/vfPe/3xkh7J3/vYsYzp3Kdnjte5n+5zsjhr3zv3fh3RnOFyGC4BkhE/OMkCl0z7Db4bURoWdEg2dEwTMS9Ixk8IwkeEaGnpENnpEEzyjQM4rBM4rgGRV6RjV4RhY8o0HPaAbPaIJndOgZ3eAZRfCMAT1jGDxjCJ4xoWdMg2dUwTMW9Ixl8IwleMaGnrENntEEzzjQM47BM47gGRd6xjV4Rhc840HPeAbPeIJnfOgZ3+AZQ/BMAD0TGDwTCJ4JoWdCg2dMwTMR9Exk8EwkeCaGnokNnrEEzyTQM4nBM4ngmRR6JjV4xhY8k0HPZAbPZIJncuiZ3OAZR/BMAT1TGDxTCJ4poWdKg2dcwTMV9Exl8EwleKaGnqkNnvEEzzTQM43BM43gmRZ6pjV4xhc800HPdAbPdIJnAD0Dg2cCwTM99Exv8EwveGaAnhkMngkFz4zQM6PBM6PgmQl6ZjJ4JhI8M0PPzAbPzIJnFuiZxeCZWPDMCj2zGjyzCp7ZoGc2g2cSwTM79Mxu8MwueOaAnjkMnkkFz5zQM6fBM6fgmQt65jJ4JhM8c0PP3AbP3IJnHuiZx+CZXPDMCz3zGjzzCp75oGc+g2cKwTM/9Mxv8MwveBaAngUMnikFz4LQs6DBs6DgWQh6FjJ4phI8C0PPwgbPwoJnEehZxOCZWvAsCj2LGjyLCp7FoGcxg2cawbM49Cxu8CwueJaAniUMnmkFz5LQs6TBs6TgWQp6ljJ4phM8S0PP0gbP0oJnGehZxuAZCJ5loWdZg2dZwbMc9Cxn8EwveJaHnuUNnuUFzwrQs4LBM4PgWRF6VjR4VhQ8K0HPSgbPjIJnZehZ2eBZWfCsAj2rGDwzCZ5VoWdVg2dVwbMa9Kxm8MwseFaHntUNntUFzxrQs4bBM4vgWRN61jR41hQ8a0HPWgbPrIJnbehZ2+BZW/CsAz3rGDyzCZ51oWddg2ddwbMe9Kxn8MwueNaHnvUNnvUFzwbQs4HBM4fg2RB6NjR4NhQ8G0HPRgbPnIJnY+jZ2ODZWPBsAj2bGDxzCZ5NoWdTg2dTwbMZ9Gxm8MwteDaHns0Nns0FzxbQs4XBM4/g2RJ6tjR4thQ8W0HPVgbPvIJna+jZ2uDZWvBsAz3bGDzzCZ5toWdbg2dbwbMd9Gxn8MwveLaHnu0Nnu0Fzw7Qs4PBs4Dg2RF6djR4dhQ8O0HPTgbPgoJnZ+jZ2eDZWfDsAj27GDwLCZ5doWdXg2dXwbMb9Oxm8CwseHaHnt0Nnt0Fzx7Qs4fBs4jg2RN69jR49hQ8e0HPXgbPooJnb+jZ2+DZW/DsAz37GDyLCZ59oWdfg2dfwbMf9Oxn8CwuePaHnv0Nnv0FzwHQc4DBs4TgORB6DjR4DhQ8B0HPQQbPkoLnYOg52OA5WPAcAj2HGDxLCZ5DoedQg+dQwXMY9Bxm8CwteA6HnsMNnsMFzxHQc4TBs4zgORJ6jjR4jhQ8R0HPUQbPsoLnaOg52uA5WvAcAz3HGDzLCZ5joedYg+dYwXMc9Bxn8CwveI6HnuMNnuMFzwnQc4LBs4LgORF6TjR4ThQ8J0HPSQbPioLnZOg52eA5WfCcAj2nGDwrCZ5ToedUg+dUwXMa9Jxm8KwseE6HntMNntMFzxnQc4bBs4rgORN6zjR4zhQ8Z0HPWQbPqoLnbOg52+A5W/CcAz3nGDyrCZ5zoedcg+dcwXMe9Jxn8KwueM6HnvMNnvMFzwXQc4HBs4bguRB6LjR4LhQ8F0HPRQbPmoLnYui52OC5WPBcAj2XGDxrCZ5LoedSg+dSwXMZ9Fxm8KwteC6HnssNnssFzxXQc4XBs47guRJ6rjR4rhQ8V0HPVQbPuoLnaui52uC5WvBcAz3XGDzrCZ5roedag+dawXMd9Fxn8KwveK6HnusNnusFzw3Qc4PBs4HguRF6bjR4bhQ8N0HPTQbPhoLnZui52eC5WfDcAj23GDwbCZ5boedWg+dWwXMb9Nxm8GwseG6HntsNntsFzx3Qc4fBs4nguRN67jR47hQ8d0HPXQbPpoLnbui52+C5W/DcAz33GDybCZ57oedeg+dewXMf9Nxn8GwueO6HnvsNnvsFzwPQ84DBs4XgeRB6HjR4HhQ8D0HPQwbPloLnYeh52OB5WPA8Aj2PGDxbCZ5HoedRg+dRwfMY9Dxm8GwteB6HnscNnscFz/eh5/sGzzaC5wnoecLgeULw/AB6fmDwbCt4noSeJw2eJwXPD6HnhwbPdoLnKeh5yuB5SvD8CHp+ZPBsL3iehp6nDZ6nBc+PoefHBs8OgucZ6HnG4HlG8PwEen5i8OwoeJ6FnmcNnmcFz0+h56cGz06C5znoec7geU7w/Ax6fmbw7Cx4noee5w2e5wXPz6Hn5wbPLoLnBeh5weB5QfD8Anp+YfDsKnhehJ4XDZ4XBc8voeeXBs9ugucl6HnJ4HlJ8PwKen5l8OwueF6GnpcNnpcFz6+h59cGzx6C5xXoecXgeUXw/AZ6fmPw7Cl4XoWeVw2eVwXPb6HntwbPXoLnNeh5zeB5TfD8Dnp+Z/DsLXheh57XDZ7XBc8b0POGwbOP4HkTet40eN4UPG9Bz1sGz76C523oedvgeVvw/B56fm/w7Cd43oGedwyedwTPH6DnDwbP/oLnXeh51+B5V/D8EXr+aPAcIHjeg573DJ73BM+foOdPBs+Bgud96Hnf4Hlf8PwZev5s8BwkeD6Ang8Mng8Ez4fQ86HBc7Dg+Qh6PjJ4PhI8f4Gevxg8hwiej6HnY4PnY8HzV+j5q8FzqOD5BHo+MXg+ETx/g56/GTyHCZ5PoedTg+dTwfMZ9Hxm8BwueD6Hns8Nns8Fz9+h5+8GzxGC5wvo+cLg+ULw/AN6/mHwHCl4voSeLw2eLwXPP6HnnwbPUYLnK+j5yuD5SvD8C3r+ZfAcLXi+hp6vDZ6vBc+/oeffBs8xgucb6PnG4PlG8PwHev5j8BwreL6Fnm8Nnm8Fz3+h578Gz3GC5zvo+c7g+U7wfC8z8/zvXaie4wXPCJmZZ4TMoXuG3Q6vjQg9Ixo8JwiekaBnJINnJMEzMvSMbPCcKHhGgZ5RDJ5RBM+o0DOqwXOS4BkNekYzeEYTPKNDz+gGz8mCZwzoGcPgGUPwjAk9Yxo8pwiesaBnLINnLMEzNvSMbfCcKnjGgZ5xDJ5xBM+40DOuwXOa4BkPesYzeMYTPONDz/gGz+mCZwLomcDgmUDwTAg9Exo8ZwieiaBnIoNnIsEzMfRMbPCcKXgmgZ5JDJ5JBM+k0DOpwXOW4JkMeiYzeCYTPJNDz+QGz9mCZwromcLgmULwTAk9Uxo85wieqaBnKoNnKsEzNfRMbfCcK3imgZ5pDJ5pBM+00DOtwXOe4JkOeqYzeKYTPAPoGRg85wue6aFneoNnesEzA/TMYPBcIHhmhJ4ZDZ4ZBc9M0DOTwXOh4JkZemY2eGYWPLNAzywGz0WCZ1bomdXgmVXwzAY9sxk8Fwue2aFndoNndsEzB/TMYfBcInjmhJ45DZ45Bc9c0DOXwXOp4JkbeuY2eOYWPPNAzzwGz2WCZ17omdfgmVfwzAc98xk8lwue+aFnfoNnfsGzAPQsYPBcIXgWhJ4FDZ4FBc9C0LOQwXOl4FkYehY2eBYWPItAzyIGz1WCZ1HoWdTgWVTwLAY9ixk8VwuexaFncYNnccGzBPQsYfBcI3iWhJ4lDZ4lBc9S0LOUwXOt4FkaepY2eJYWPMtAzzIGz3WCZ1noWdbgWVbwLAc9yxk81wue5aFneYNnecGzAvSsYPDcIHhWhJ4VDZ4VBc9K0LOSwXOj4FkZelY2eFYWPKtAzyoGz02CZ1XoWdXgWVXwrAY9qxk8Nwue1aFndYNndcGzBvSsYfDcInjWhJ41DZ41Bc9a0LOWwXOr4FkbetY2eNYWPOtAzzoGz22CZ13oWdfgWVfwrAc96xk8twue9aFnfYNnfcGzAfRsYPDcIXg2hJ4NDZ4NBc9G0LORwXOn4NkYejY2eDYWPJtAzyYGz12CZ1Po2dTg2VTwbAY9mxk8dwuezaFnc4Nnc8GzBfRsYfDcI3i2hJ4tDZ4tBc9W0LOVwXOv4NkaerY2eLYWPNtAzzYGz32CZ1vo2dbg2VbwbAc92xk89wue7aFne4Nne8GzA/TsYPA8IHh2hJ4dDZ4dBc9O0LOTwfOg4NkZenY2eHYWPLtAzy4Gz0OCZ1fo2dXg2VXw7AY9uxk8Dwue3aFnd4Nnd8GzB/TsYfA8Inj2hJ49DZ49Bc9e0LOXwfOo4NkbevY2ePYWPPtAzz4Gz2OCZ1/o2dfg2Vfw7Ac9+xk8jwue/aFnf4Nnf8FzAPQcYPB8X/AcCD0HGjwHCp6DoOcgg+cJwXMw9Bxs8BwseA6BnkMMnh8InkOh51CD51DBcxj0HGbwPCl4Doeeww2ewwXPEdBzhMHzQ8FzJPQcafAcKXiOgp6jDJ6nBM/R0HO0wXO04DkGeo4xeH4keI6FnmMNnmMFz3HQc5zB87TgOR56jjd4jhc8J0DPCQbPjwXPidBzosFzouA5CXpOMnieETwnQ8/JBs/JgucU6DnF4PmJ4DkVek41eE4VPKdBz2kGz7OC53ToOd3gOV3wnAE9Zxg8PxU8Z0LPmQbPmYLnLOg5y+B5TvCcDT1nGzxnC55zoOccg+dngudc6DnX4DlX8JwHPecZPM8LnvOh53yD53zBcwH0XGDw/FzwXAg9Fxo8Fwqei6DnIoPnBcFzMfRcbPBcLHgugZ5LDJ5fCJ5LoedSg+dSwXMZ9Fxm8LwoeC6HnssNnssFzxXQc4XB80vBcyX0XGnwXCl4roKeqwyelwTP1dBztcFzteC5BnquMXh+JXiuhZ5rDZ5rBc910HOdwfOy4Lkeeq43eK4XPDdAzw0Gz68Fz43Qc6PBc6PguQl6bjJ4XhE8N0PPzQbPzYLnFui5xeD5jeC5FXpuNXhuFTy3Qc9tBs+rgud26Lnd4Lld8NwBPXcYPL8VPHdCz50Gz52C5y7oucvgeU3w3A09dxs8dwuee6DnHoPnd4LnXui51+C5V/DcBz33GTyvC577oed+g+d+wfMA9Dxg8LwheB6EngcNngcFz0PQ85DB86bgeRh6HjZ4HhY8j0DPIwbPW4LnUeh51OB5VPA8Bj2PGTxvC57Hoedxg+dxwfN96Pm+wfN7wfME9Dxh8DwheH4APT8weN4RPE9Cz5MGz5OC54fQ80OD5w+C5ynoecrgeUrw/Ah6fmTwvCt4noaepw2epwXPj6HnxwbPHwXPM9DzjMHzjOD5CfT8xOB5T/A8Cz3PGjzPCp6fQs9PDZ4/CZ7noOc5g+c5wfMz6PmZwfO+4Hkeep43eJ4XPD+Hnp8bPH8WPC9AzwsGzwuC5xfQ8wuD5wPB8yL0vGjwvCh4fgk9vzR4PhQ8L0HPSwbPS4LnV9DzK4PnI8HzMvS8bPC8LHh+DT2/Nnj+InhegZ5XDJ5XBM9voOc3Bs/HgudV6HnV4HlV8PwWen5r8PxV8LwGPa8ZPK8Jnt9Bz+8Mnk8Ez+vQ87rB87rgeQN63jB4/iZ43oSeNw2eNwXPW9DzlsHzqeB5G3reNnjeFjy/h57fGzyfCZ53oOcdg+cdwfMH6PmDwfO54HkXet41eN4VPH+Enj8aPH8XPO9Bz3sGz3uC50/Q8yeD5wvB8z70vG/wvC94/gw9fzZ4/iF4PoCeDwyeDwTPh9DzocHzpeD5CHo+Mng+Ejx/gZ6/GDz/FDwfQ8/HBs/Hguev0PNXg+crwfMJ9Hxi8HwieP4GPX8zeP4leD6Fnk8Nnk8Fz2fQ85nB87Xg+Rx6Pjd4Phc8f4eevxs8/xY8X0DPFwbPF4LnH9DzD4PnG8HzJfR8afB8KXj+CT3/NHj+I3i+gp6vDJ6vBM+/oOdfBs+3gudr6Pna4Pla8Pwbev5t8PxX8HwDPd8YPN8Inv9Az38Mnu8Ez7fQ863B863g+S/0/Nfg+V60//3Od9DzncHzneD5Xhbm+d+7UD0jCJ4RsjDPCFlC9wy7HV4bEXpGNHhGFDwjQc9IBs9Igmdk6BnZ4BlJ8IwCPaMYPKMInlGhZ1SDZ2TBMxr0jGbwjCZ4Roee0Q2eUQTPGNAzhsEzhuAZE3rGNHhGFTxjQc9YBs9Ygmds6Bnb4BlN8IwDPeMYPOMInnGhZ1yDZ3TBMx70jGfwjCd4xoee8Q2eMQTPBNAzgcEzgeCZEHomNHjGFDwTQc9EBs9Egmdi6JnY4BlL8EwCPZMYPJMInkmhZ1KDZ2zBMxn0TGbwTCZ4JoeeyQ2ecQTPFNAzhcEzheCZEnqmNHjGFTxTQc9UBs9Ugmdq6Jna4BlP8EwDPdMYPNMInmmhZ1qDZ3zBMx30TGfwTCd4BtAzMHgmEDzTQ8/0Bs/0gmcG6JnB4JlQ8MwIPTMaPDMKnpmgZyaDZyLBMzP0zGzwzCx4ZoGeWQyeiQXPrNAzq8Ezq+CZDXpmM3gmETyzQ8/sBs/sgmcO6JnD4JlU8MwJPXMaPHMKnrmgZy6DZzLBMzf0zG3wzC145oGeeQyeyQXPvNAzr8Ezr+CZD3rmM3imEDzzQ8/8Bs/8gmcB6FnA4JlS8CwIPQsaPAsKnoWgZyGDZyrBszD0LGzwLCx4FoGeRQyeqQXPotCzqMGzqOBZDHoWM3imETyLQ8/iBs/igmcJ6FnC4JlW8CwJPUsaPEsKnqWgZymDZzrBszT0LG3wLC14loGeZQyegeBZFnqWNXiWFTzLQc9yBs/0gmd56Fne4Fle8KwAPSsYPDMInhWhZ0WDZ0XBsxL0rGTwzCh4VoaelQ2elQXPKtCzisEzk+BZFXpWNXhWFTyrQc9qBs/Mgmd16Fnd4Fld8KwBPWsYPLMInjWhZ02DZ03Bsxb0rGXwzCp41oaetQ2etQXPOtCzjsEzm+BZF3rWNXjWFTzrQc96Bs/sgmd96Fnf4Flf8GwAPRsYPHMIng2hZ0ODZ0PBsxH0bGTwzCl4NoaejQ2ejQXPJtCzicEzl+DZFHo2NXg2FTybQc9mBs/cgmdz6Nnc4Nlc8GwBPVsYPPMIni2hZ0uDZ0vBsxX0bGXwzCt4toaerQ2erQXPNtCzjcEzn+DZFnq2NXi2FTzbQc92Bs/8gmd76Nne4Nle8OwAPTsYPAsInh2hZ0eDZ0fBsxP07GTwLCh4doaenQ2enQXPLtCzi8GzkODZFXp2NXh2FTy7Qc9uBs/Cgmd36Nnd4Nld8OwBPXsYPIsInj2hZ0+DZ0/Bsxf07GXwLCp49oaevQ2evQXPPtCzj8GzmODZF3r2NXj2FTz7Qc9+Bs/igmd/6Nnf4Nlf8BwAPQcYPEsIngOh50CD50DBcxD0HGTwLCl4Doaegw2egwXPIdBziMGzlOA5FHoONXgOFTyHQc9hBs/Sgudw6Dnc4Dlc8BwBPUcYPMsIniOh50iD50jBcxT0HGXwLCt4joaeow2eowXPMdBzjMGznOA5FnqONXiOFTzHQc9xBs/ygud46Dne4Dle8JwAPScYPCsInhOh50SD50TBcxL0nGTwrCh4Toaekw2ekwXPKdBzisGzkuA5FXpONXhOFTynQc9pBs/Kgud06Dnd4Dld8JwBPWcYPKsInjOh50yD50zBcxb0nGXwrCp4zoaesw2eswXPOdBzjsGzmuA5F3rONXjOFTznQc95Bs/qgud86Dnf4Dlf8FwAPRcYPGsInguh50KD50LBcxH0XGTwrCl4Loaeiw2eiwXPJdBzicGzluC5FHouNXguFTyXQc9lBs/agudy6Lnc4Llc8FwBPVcYPOsIniuh50qD50rBcxX0XGXwrCt4roaeqw2eqwXPNdBzjcGznuC5FnquNXiuFTzXQc91Bs/6gud66Lne4Lle8NwAPTcYPBsInhuh50aD50bBcxP03GTwbCh4boaemw2emwXPLdBzi8GzkeC5FXpuNXhuFTy3Qc9tBs/Ggud26Lnd4Lld8NwBPXcYPJsInjuh506D507Bcxf03GXwbCp47oaeuw2euwXPPdBzj8GzmeC5F3ruNXjuFTz3Qc99Bs/mgud+6Lnf4Llf8DwAPQ8YPFsIngeh50GD50HB8xD0PGTwbCl4Hoaehw2ehwXPI9DziMGzleB5FHoeNXgeFTyPQc9jBs/Wgudx6Hnc4Hlc8Hwfer5v8GwjeJ6AnicMnicEzw+g5wcGz7aC50noedLgeVLw/BB6fmjwbCd4noKepwyepwTPj6DnRwbP9oLnaeh52uB5WvD8GHp+bPDsIHiegZ5nDJ5nBM9PoOcnBs+OgudZ6HnW4HlW8PwUen5q8OwkeJ6DnucMnucEz8+g52cGz86C53noed7geV7w/Bx6fm7w7CJ4XoCeFwyeFwTPL6DnFwbProLnReh50eB5UfD8Enp+afDsJnhegp6XDJ6XBM+voOdXBs/ugudl6HnZ4HlZ8Pwaen5t8OwheF6BnlcMnlcEz2+g5zcGz56C51XoedXgeVXw/BZ6fmvw7CV4XoOe1wye1wTP76DndwbP3oLndeh53eB5XfC8AT1vGDz7CJ43oedNg+dNwfMW9Lxl8OwreN6GnrcNnrcFz++h5/cGz36C5x3oecfgeUfw/AF6/mDw7C943oWedw2edwXPH6HnjwbPAYLnPeh5z+B5T/D8CXr+ZPAcKHjeh573DZ73Bc+foefPBs9BgucD6PnA4PlA8HwIPR8aPAcLno+g5yOD5yPB8xfo+YvBc4jg+Rh6PjZ4PhY8f4Wevxo8hwqeT6DnE4PnE8HzN+j5m8FzmOD5FHo+NXg+FTyfQc9nBs/hgudz6Pnc4Plc8Pwdev5u8BwheL6Ani8Mni8Ezz+g5x8Gz5GC50vo+dLg+VLw/BN6/mnwHCV4voKerwyerwTPv6DnXwbP0YLna+j52uD5WvD8G3r+bfAcI3i+gZ5vDJ5vBM9/oOc/Bs+xgudb6PnW4PlW8PwXev5r8BwneL6Dnu8Mnu8Ez/eyMs//3oXqOV7wjJCVeUbIGrpn2O3w2ojQM6LBc4LgGQl6RjJ4RhI8I0PPyAbPiYJnFOgZxeAZRfCMCj2jGjwnCZ7RoGc0g2c0wTM69Ixu8JwseMaAnjEMnjEEz5jQM6bBc4rgGQt6xjJ4xhI8Y0PP2AbPqYJnHOgZx+AZR/CMCz3jGjynCZ7xoGc8g2c8wTM+9Ixv8JwueCaAngkMngkEz4TQM6HBc4bgmQh6JjJ4JhI8E0PPxAbPmYJnEuiZxOCZRPBMCj2TGjxnCZ7JoGcyg2cywTM59Exu8JwteKaAnikMnikEz5TQM6XBc47gmQp6pjJ4phI8U0PP1AbPuYJnGuiZxuCZRvBMCz3TGjznCZ7poGc6g2c6wTOAnoHBc77gmR56pjd4phc8M0DPDAbPBYJnRuiZ0eCZUfDMBD0zGTwXCp6ZoWdmg2dmwTML9Mxi8FwkeGaFnlkNnlkFz2zQM5vBc7HgmR16Zjd4Zhc8c0DPHAbPJYJnTuiZ0+CZU/DMBT1zGTyXCp65oWdug2duwTMP9Mxj8FwmeOaFnnkNnnkFz3zQM5/Bc7ngmR965jd45hc8C0DPAgbPFYJnQehZ0OBZUPAsBD0LGTxXCp6FoWdhg2dhwbMI9Cxi8FwleBaFnkUNnkUFz2LQs5jBc7XgWRx6Fjd4Fhc8S0DPEgbPNYJnSehZ0uBZUvAsBT1LGTzXCp6loWdpg2dpwbMM9Cxj8FwneJaFnmUNnmUFz3LQs5zBc73gWR56ljd4lhc8K0DPCgbPDYJnRehZ0eBZUfCsBD0rGTw3Cp6VoWdlg2dlwbMK9Kxi8NwkeFaFnlUNnlUFz2rQs5rBc7PgWR16Vjd4Vhc8a0DPGgbPLYJnTehZ0+BZU/CsBT1rGTy3Cp61oWdtg2dtwbMO9Kxj8NwmeNaFnnUNnnUFz3rQs57Bc7vgWR961jd41hc8G0DPBgbPHYJnQ+jZ0ODZUPBsBD0bGTx3Cp6NoWdjg2djwbMJ9Gxi8NwleDaFnk0Nnk0Fz2bQs5nBc7fg2Rx6Njd4Nhc8W0DPFgbPPYJnS+jZ0uDZUvBsBT1bGTz3Cp6toWdrg2drwbMN9Gxj8NwneLaFnm0Nnm0Fz3bQs53Bc7/g2R56tjd4thc8O0DPDgbPA4JnR+jZ0eDZUfDsBD07GTwPCp6doWdng2dnwbML9Oxi8DwkeHaFnl0Nnl0Fz27Qs5vB87Dg2R16djd4dhc8e0DPHgbPI4JnT+jZ0+DZU/DsBT17GTyPCp69oWdvg2dvwbMP9Oxj8DwmePaFnn0Nnn0Fz37Qs5/B87jg2R969jd49hc8B0DPAQbP9wXPgdBzoMFzoOA5CHoOMnieEDwHQ8/BBs/BgucQ6DnE4PmB4DkUeg41eA4VPIdBz2EGz5OC53DoOdzgOVzwHAE9Rxg8PxQ8R0LPkQbPkYLnKOg5yuB5SvAcDT1HGzxHC55joOcYg+dHgudY6DnW4DlW8BwHPccZPE8LnuOh53iD53jBcwL0nGDw/FjwnAg9Jxo8Jwqek6DnJIPnGcFzMvScbPCcLHhOgZ5TDJ6fCJ5ToedUg+dUwXMa9Jxm8DwreE6HntMNntMFzxnQc4bB81PBcyb0nGnwnCl4zoKeswye5wTP2dBztsFztuA5B3rOMXh+JnjOhZ5zDZ5zBc950HOewfO84Dkfes43eM4XPBdAzwUGz88Fz4XQc6HBc6HguQh6LjJ4XhA8F0PPxQbPxYLnEui5xOD5heC5FHouNXguFTyXQc9lBs+Lgudy6Lnc4Llc8FwBPVcYPL8UPFdCz5UGz5WC5yroucrgeUnwXA09Vxs8Vwuea6DnGoPnV4LnWui51uC5VvBcBz3XGTwvC57roed6g+d6wXMD9Nxg8Pxa8NwIPTcaPDcKnpug5yaD5xXBczP03Gzw3Cx4boGeWwye3wieW6HnVoPnVsFzG/TcZvC8Knhuh57bDZ7bBc8d0HOHwfNbwXMn9Nxp8NwpeO6CnrsMntcEz93Qc7fBc7fguQd67jF4fid47oWeew2eewXPfdBzn8HzuuC5H3ruN3juFzwPQM8DBs8bgudB6HnQ4HlQ8DwEPQ8ZPG8Knoeh52GD52HB8wj0PGLwvCV4HoWeRw2eRwXPY9DzmMHztuB5HHoeN3geFzzfh57vGzy/FzxPQM8TBs8TgucH0PMDg+cdwfMk9Dxp8DwpeH4IPT80eP4geJ6CnqcMnqcEz4+g50cGz7uC52noedrgeVrw/Bh6fmzw/FHwPAM9zxg8zwien0DPTwye9wTPs9DzrMHzrOD5KfT81OD5k+B5DnqeM3ieEzw/g56fGTzvC57noed5g+d5wfNz6Pm5wfNnwfMC9Lxg8LwgeH4BPb8weD4QPC9Cz4sGz4uC55fQ80uD50PB8xL0vGTwvCR4fgU9vzJ4PhI8L0PPywbPy4Ln19Dza4PnL4LnFeh5xeB5RfD8Bnp+Y/B8LHhehZ5XDZ5XBc9voee3Bs9fBc9r0POawfOa4Pkd9PzO4PlE8LwOPa8bPK8Lnjeg5w2D52+C503oedPgeVPwvAU9bxk8nwqet6HnbYPnbcHze+j5vcHzmeB5B3reMXjeETx/gJ4/GDyfC553oeddg+ddwfNH6PmjwfN3wfMe9Lxn8LwneP4EPX8yeL4QPO9Dz/sGz/uC58/Q82eD5x+C5wPo+cDg+UDwfAg9Hxo8Xwqej6DnI4PnI8HzF+j5i8HzT8HzMfR8bPB8LHj+Cj1/NXi+EjyfQM8nBs8ngudv0PM3g+dfgudT6PnU4PlU8HwGPZ8ZPF8Lns+h53OD53PB83fo+bvB82/B8wX0fGHwfCF4/gE9/zB4vhE8X0LPlwbPl4Lnn9DzT4PnP4LnK+j5yuD5SvD8C3r+ZfB8K3i+hp6vDZ6vBc+/oeffBs9/Bc830PONwfON4PkP9PzH4PlO8HwLPd8aPN8Knv9Cz38Nnu9F/9/vfPe/3nniwnth7/zvXYpw7lS2w2vfy/a/3Rlh6JL/487/3oV3Z3g/GUHwjJCNeUbIFrpn2O3w2ojQM6LBM6LgGQl6RjJ4RhI8I0PPyAbPSIJnFOgZxeAZRfCMCj2jGjwjC57RoGc0g2c0wTM69Ixu8IwieMaAnjEMnjEEz5jQM6bBM6rgGQt6xjJ4xhI8Y0PP2AbPaIJnHOgZx+AZR/CMCz3jGjyjC57xoGc8g2c8wTM+9Ixv8IwheCaAngkMngkEz4TQM6HBM6bgmQh6JjJ4JhI8E0PPxAbPWIJnEuiZxOCZRPBMCj2TGjxjC57JoGcyg2cywTM59Exu8IwjeKaAnikMnikEz5TQM6XBM67gmQp6pjJ4phI8U0PP1AbPeIJnGuiZxuCZRvBMCz3TGjzjC57poGc6g2c6wTOAnoHBM4HgmR56pjd4phc8M0DPDAbPhIJnRuiZ0eCZUfDMBD0zGTwTCZ6ZoWdmg2dmwTML9Mxi8EwseGaFnlkNnlkFz2zQM5vBM4ngmR16Zjd4Zhc8c0DPHAbPpIJnTuiZ0+CZU/DMBT1zGTyTCZ65oWdug2duwTMP9Mxj8EwueOaFnnkNnnkFz3zQM5/BM4XgmR965jd45hc8C0DPAgbPlIJnQehZ0OBZUPAsBD0LGTxTCZ6FoWdhg2dhwbMI9Cxi8EwteBaFnkUNnkUFz2LQs5jBM43gWRx6Fjd4Fhc8S0DPEgbPtIJnSehZ0uBZUvAsBT1LGTzTCZ6loWdpg2dpwbMM9Cxj8AwEz7LQs6zBs6zgWQ56ljN4phc8y0PP8gbP8oJnBehZweCZQfCsCD0rGjwrCp6VoGclg2dGwbMy9Kxs8KwseFaBnlUMnpkEz6rQs6rBs6rgWQ16VjN4ZhY8q0PP6gbP6oJnDehZw+CZRfCsCT1rGjxrCp61oGctg2dWwbM29Kxt8KwteNaBnnUMntkEz7rQs67Bs67gWQ961jN4Zhc860PP+gbP+oJnA+jZwOCZQ/BsCD0bGjwbCp6NoGcjg2dOwbMx9Gxs8GwseDaBnk0MnrkEz6bQs6nBs6ng2Qx6NjN45hY8m0PP5gbP5oJnC+jZwuCZR/BsCT1bGjxbCp6toGcrg2dewbM19Gxt8GwteLaBnm0MnvkEz7bQs63Bs63g2Q56tjN45hc820PP9gbP9oJnB+jZweBZQPDsCD07Gjw7Cp6doGcng2dBwbMz9Oxs8OwseHaBnl0MnoUEz67Qs6vBs6vg2Q16djN4FhY8u0PP7gbP7oJnD+jZw+BZRPDsCT17Gjx7Cp69oGcvg2dRwbM39Oxt8OwtePaBnn0MnsUEz77Qs6/Bs6/g2Q969jN4Fhc8+0PP/gbP/oLnAOg5wOBZQvAcCD0HGjwHCp6DoOcgg2dJwXMw9Bxs8BwseA6BnkMMnqUEz6HQc6jBc6jgOQx6DjN4lhY8h0PP4QbP4YLnCOg5wuBZRvAcCT1HGjxHCp6joOcog2dZwXM09Bxt8BwteI6BnmMMnuUEz7HQc6zBc6zgOQ56jjN4lhc8x0PP8QbP8YLnBOg5weBZQfCcCD0nGjwnCp6ToOckg2dFwXMy9Jxs8JwseE6BnlMMnpUEz6nQc6rBc6rgOQ16TjN4VhY8p0PP6QbP6YLnDOg5w+BZRfCcCT1nGjxnCp6zoOcsg2dVwXM29Jxt8JwteM6BnnMMntUEz7nQc67Bc67gOQ96zjN4Vhc850PP+QbP+YLnAui5wOBZQ/BcCD0XGjwXCp6LoOcig2dNwXMx9Fxs8FwseC6BnksMnrUEz6XQc6nBc6nguQx6LjN41hY8l0PP5QbP5YLnCui5wuBZR/BcCT1XGjxXCp6roOcqg2ddwXM19Fxt8FwteK6BnmsMnvUEz7XQc63Bc63guQ56rjN41hc810PP9QbP9YLnBui5weDZQPDcCD03Gjw3Cp6boOcmg2dDwXMz9Nxs8NwseG6BnlsMno0Ez63Qc6vBc6vguQ16bjN4NhY8t0PP7QbP7YLnDui5w+DZRPDcCT13Gjx3Cp67oOcug2dTwXM39Nxt8NwteO6BnnsMns0Ez73Qc6/Bc6/guQ967jN4Nhc890PP/QbP/YLnAeh5wODZQvA8CD0PGjwPCp6HoOchg2dLwfMw9Dxs8DwseB6BnkcMnq0Ez6PQ86jB86jgeQx6HjN4thY8j0PP4wbP44Ln+9DzfYNnG8HzBPQ8YfA8IXh+AD0/MHi2FTxPQs+TBs+TgueH0PNDg2c7wfMU9Dxl8DwleH4EPT8yeLYXPE9Dz9MGz9OC58fQ82ODZwfB8wz0PGPwPCN4fgI9PzF4dhQ8z0LPswbPs4Lnp9DzU4NnJ8HzHPQ8Z/A8J3h+Bj0/M3h2FjzPQ8/zBs/zgufn0PNzg2cXwfMC9Lxg8LwgeH4BPb8weHYVPC9Cz4sGz4uC55fQ80uDZzfB8xL0vGTwvCR4fgU9vzJ4dhc8L0PPywbPy4Ln19Dza4NnD8HzCvS8YvC8Inh+Az2/MXj2FDyvQs+rBs+rgue30PNbg2cvwfMa9Lxm8LwmeH4HPb8zePYWPK9Dz+sGz+uC5w3oecPg2UfwvAk9bxo8bwqet6DnLYNnX8HzNvS8bfC8LXh+Dz2/N3j2EzzvQM87Bs87gucP0PMHg2d/wfMu9Lxr8LwreP4IPX80eA4QPO9Bz3sGz3uC50/Q8yeD50DB8z70vG/wvC94/gw9fzZ4DhI8H0DPBwbPB4LnQ+j50OA5WPB8BD0fGTwfCZ6/QM9fDJ5DBM/H0POxwfOx4Pkr9PzV4DlU8HwCPZ8YPJ8Inr9Bz98MnsMEz6fQ86nB86ng+Qx6PjN4Dhc8n0PP5wbP54Ln79Dzd4PnCMHzBfR8YfB8IXj+AT3/MHiOFDxfQs+XBs+Xguef0PNPg+cowfMV9Hxl8HwleP4FPf8yeI4WPF9Dz9cGz9eC59/Q82+D5xjB8w30fGPwfCN4/gM9/zF4jhU830LPtwbPt4Lnv9DzX4PnOMHzHfR8Z/B8J3i+l515/vcuVM/xgmeE7MwzQvbQPcNuh9dGhJ4RDZ4TBM9I0DOSwTOS4BkZekY2eE4UPKNAzygGzyiCZ1ToGdXgOUnwjAY9oxk8owme0aFndIPnZMEzBvSMYfCMIXjGhJ4xDZ5TBM9Y0DOWwTOW4BkbesY2eE4VPONAzzgGzziCZ1zoGdfgOU3wjAc94xk84wme8aFnfIPndMEzAfRMYPBMIHgmhJ4JDZ4zBM9E0DORwTOR4JkYeiY2eM4UPJNAzyQGzySCZ1LomdTgOUvwTAY9kxk8kwmeyaFncoPnbMEzBfRMYfBMIXimhJ4pDZ5zBM9U0DOVwTOV4JkaeqY2eM4VPNNAzzQGzzSCZ1romdbgOU/wTAc90xk80wmeAfQMDJ7zBc/00DO9wTO94JkBemYweC4QPDNCz4wGz4yCZybomcnguVDwzAw9Mxs8MwueWaBnFoPnIsEzK/TMavDMKnhmg57ZDJ6LBc/s0DO7wTO74JkDeuYweC4RPHNCz5wGz5yCZy7omcvguVTwzA09cxs8cwueeaBnHoPnMsEzL/TMa/DMK3jmg575DJ7LBc/80DO/wTO/4FkAehYweK4QPAtCz4IGz4KCZyHoWcjguVLwLAw9Cxs8CwueRaBnEYPnKsGzKPQsavAsKngWg57FDJ6rBc/i0LO4wbO44FkCepYweK4RPEtCz5IGz5KCZynoWcrguVbwLA09Sxs8SwueZaBnGYPnOsGzLPQsa/AsK3iWg57lDJ7rBc/y0LO8wbO84FkBelYweG4QPCtCz4oGz4qCZyXoWcnguVHwrAw9Kxs8KwueVaBnFYPnJsGzKvSsavCsKnhWg57VDJ6bBc/q0LO6wbO64FkDetYweG4RPGtCz5oGz5qCZy3oWcvguVXwrA09axs8awuedaBnHYPnNsGzLvSsa/CsK3jWg571DJ7bBc/60LO+wbO+4NkAejYweO4QPBtCz4YGz4aCZyPo2cjguVPwbAw9Gxs8GwueTaBnE4PnLsGzKfRsavBsKng2g57NDJ67Bc/m0LO5wbO54NkCerYweO4RPFtCz5YGz5aCZyvo2crguVfwbA09Wxs8WwuebaBnG4PnPsGzLfRsa/BsK3i2g57tDJ77Bc/20LO9wbO94NkBenYweB4QPDtCz44Gz46CZyfo2cngeVDw7Aw9Oxs8OwueXaBnF4PnIcGzK/TsavDsKnh2g57dDJ6HBc/u0LO7wbO74NkDevYweB4RPHtCz54Gz56CZy/o2cvgeVTw7A09exs8ewuefaBnH4PnMcGzL/Tsa/DsK3j2g579DJ7HBc/+0LO/wbO/4DkAeg4weL4veA6EngMNngMFz0HQc5DB84TgORh6DjZ4DhY8h0DPIQbPDwTPodBzqMFzqOA5DHoOM3ieFDyHQ8/hBs/hgucI6DnC4Pmh4DkSeo40eI4UPEdBz1EGz1OC52joOdrgOVrwHAM9xxg8PxI8x0LPsQbPsYLnOOg5zuB5WvAcDz3HGzzHC54ToOcEg+fHgudE6DnR4DlR8JwEPScZPM8InpOh52SD52TBcwr0nGLw/ETwnAo9pxo8pwqe06DnNIPnWcFzOvScbvCcLnjOgJ4zDJ6fCp4zoedMg+dMwXMW9Jxl8DwneM6GnrMNnrMFzznQc47B8zPBcy70nGvwnCt4zoOe8wye5wXP+dBzvsFzvuC5AHouMHh+LnguhJ4LDZ4LBc9F0HORwfOC4LkYei42eC4WPJdAzyUGzy8Ez6XQc6nBc6nguQx6LjN4XhQ8l0PP5QbP5YLnCui5wuD5peC5EnquNHiuFDxXQc9VBs9Lgudq6Lna4Lla8FwDPdcYPL8SPNdCz7UGz7WC5zrouc7geVnwXA891xs81wueG6DnBoPn14LnRui50eC5UfDcBD03GTyvCJ6boedmg+dmwXML9Nxi8PxG8NwKPbcaPLcKntug5zaD51XBczv03G7w3C547oCeOwye3wqeO6HnToPnTsFzF/TcZfC8Jnjuhp67DZ67Bc890HOPwfM7wXMv9Nxr8NwreO6DnvsMntcFz/3Qc7/Bc7/geQB6HjB43hA8D0LPgwbPg4LnIeh5yOB5U/A8DD0PGzwPC55HoOcRg+ctwfMo9Dxq8DwqeB6DnscMnrcFz+PQ87jB87jg+T70fN/g+b3geQJ6njB4nhA8P4CeHxg87wieJ6HnSYPnScHzQ+j5ocHzB8HzFPQ8ZfA8JXh+BD0/MnjeFTxPQ8/TBs/TgufH0PNjg+ePgucZ6HnG4HlG8PwEen5i8LwneJ6FnmcNnmcFz0+h56cGz58Ez3PQ85zB85zg+Rn0/MzgeV/wPA89zxs8zwuen0PPzw2ePwueF6DnBYPnBcHzC+j5hcHzgeB5EXpeNHheFDy/hJ5fGjwfCp6XoOclg+clwfMr6PmVwfOR4HkZel42eF4WPL+Gnl8bPH8RPK9AzysGzyuC5zfQ8xuD52PB8yr0vGrwvCp4fgs9vzV4/ip4XoOe1wye1wTP76DndwbPJ4Lndeh53eB5XfC8AT1vGDx/EzxvQs+bBs+bguct6HnL4PlU8LwNPW8bPG8Lnt9Dz+8Nns8EzzvQ847B847g+QP0/MHg+VzwvAs97xo87wqeP0LPHw2evwue96DnPYPnPcHzJ+j5k8HzheB5H3reN3jeFzx/hp4/Gzz/EDwfQM8HBs8HgudD6PnQ4PlS8HwEPR8ZPB8Jnr9Az18Mnn8Kno+h52OD52PB81fo+avB85Xg+QR6PjF4PhE8f4Oevxk8/xI8n0LPpwbPp4LnM+j5zOD5WvB8Dj2fGzyfC56/Q8/fDZ5/C54voOcLg+cLwfMP6PmHwfON4PkSer40eL4UPP+Enn8aPP8RPF9Bz1cGz1eC51/Q8y+D51vB8zX0fG3wfC14/g09/zZ4/it4voGebwyebwTPf6DnPwbPd4LnW+j51uD5VvD8F3r+a/B8L8b/fuc76PnO4PlO8HwvB/P8712onhEEzwg5mGeEHKF7ht0Or40IPSMaPCMKnpGgZySDZyTBMzL0jGzwjCR4RoGeUQyeUQTPqNAzqsEzsuAZDXpGM3hGEzyjQ8/oBs8ogmcM6BnD4BlD8IwJPWMaPKMKnrGgZyyDZyzBMzb0jG3wjCZ4xoGecQyecQTPuNAzrsEzuuAZD3rGM3jGEzzjQ8/4Bs8YgmcC6JnA4JlA8EwIPRMaPGMKnomgZyKDZyLBMzH0TGzwjCV4JoGeSQyeSQTPpNAzqcEztuCZDHomM3gmEzyTQ8/kBs84gmcK6JnC4JlC8EwJPVMaPOMKnqmgZyqDZyrBMzX0TG3wjCd4poGeaQyeaQTPtNAzrcEzvuCZDnqmM3imEzwD6BkYPBMInumhZ3qDZ3rBMwP0zGDwTCh4ZoSeGQ2eGQXPTNAzk8EzkeCZGXpmNnhmFjyzQM8sBs/EgmdW6JnV4JlV8MwGPbMZPJMIntmhZ3aDZ3bBMwf0zGHwTCp45oSeOQ2eOQXPXNAzl8EzmeCZG3rmNnjmFjzzQM88Bs/kgmde6JnX4JlX8MwHPfMZPFMInvmhZ36DZ37BswD0LGDwTCl4FoSeBQ2eBQXPQtCzkMEzleBZGHoWNngWFjyLQM8iBs/UgmdR6FnU4FlU8CwGPYsZPNMInsWhZ3GDZ3HBswT0LGHwTCt4loSeJQ2eJQXPUtCzlMEzneBZGnqWNniWFjzLQM8yBs9A8CwLPcsaPMsKnuWgZzmDZ3rBszz0LG/wLC94VoCeFQyeGQTPitCzosGzouBZCXpWMnhmFDwrQ8/KBs/KgmcV6FnF4JlJ8KwKPasaPKsKntWgZzWDZ2bBszr0rG7wrC541oCeNQyeWQTPmtCzpsGzpuBZC3rWMnhmFTxrQ8/aBs/agmcd6FnH4JlN8KwLPesaPOsKnvWgZz2DZ3bBsz70rG/wrC94NoCeDQyeOQTPhtCzocGzoeDZCHo2MnjmFDwbQ8/GBs/GgmcT6NnE4JlL8GwKPZsaPJsKns2gZzODZ27Bszn0bG7wbC54toCeLQyeeQTPltCzpcGzpeDZCnq2MnjmFTxbQ8/WBs/Wgmcb6NnG4JlP8GwLPdsaPNsKnu2gZzuDZ37Bsz30bG/wbC94doCeHQyeBQTPjtCzo8Gzo+DZCXp2MngWFDw7Q8/OBs/OgmcX6NnF4FlI8OwKPbsaPLsKnt2gZzeDZ2HBszv07G7w7C549oCePQyeRQTPntCzp8Gzp+DZC3r2MngWFTx7Q8/eBs/egmcf6NnH4FlM8OwLPfsaPPsKnv2gZz+DZ3HBsz/07G/w7C94DoCeAwyeJQTPgdBzoMFzoOA5CHoOMniWFDwHQ8/BBs/BgucQ6DnE4FlK8BwKPYcaPIcKnsOg5zCDZ2nBczj0HG7wHC54joCeIwyeZQTPkdBzpMFzpOA5CnqOMniWFTxHQ8/RBs/RgucY6DnG4FlO8BwLPccaPMcKnuOg5ziDZ3nBczz0HG/wHC94ToCeEwyeFQTPidBzosFzouA5CXpOMnhWFDwnQ8/JBs/JgucU6DnF4FlJ8JwKPacaPKcKntOg5zSDZ2XBczr0nG7wnC54zoCeMwyeVQTPmdBzpsFzpuA5C3rOMnhWFTxnQ8/ZBs/Zgucc6DnH4FlN8JwLPecaPOcKnvOg5zyDZ3XBcz70nG/wnC94LoCeCwyeNQTPhdBzocFzoeC5CHouMnjWFDwXQ8/FBs/FgucS6LnE4FlL8FwKPZcaPJcKnsug5zKDZ23Bczn0XG7wXC54roCeKwyedQTPldBzpcFzpeC5CnquMnjWFTxXQ8/VBs/Vguca6LnG4FlP8FwLPdcaPNcKnuug5zqDZ33Bcz30XG/wXC94boCeGwyeDQTPjdBzo8Fzo+C5CXpuMng2FDw3Q8/NBs/NgucW6LnF4NlI8NwKPbcaPLcKntug5zaDZ2PBczv03G7w3C547oCeOwyeTQTPndBzp8Fzp+C5C3ruMng2FTx3Q8/dBs/dguce6LnH4NlM8NwLPfcaPPcKnvug5z6DZ3PBcz/03G/w3C94HoCeBwyeLQTPg9DzoMHzoOB5CHoeMni2FDwPQ8/DBs/DgucR6HnE4NlK8DwKPY8aPI8Knseg5zGDZ2vB8zj0PG7wPC54vg893zd4thE8T0DPEwbPE4LnB9DzA4NnW8HzJPQ8afA8KXh+CD0/NHi2EzxPQc9TBs9TgudH0PMjg2d7wfM09Dxt8DwteH4MPT82eHYQPM9AzzMGzzOC5yfQ8xODZ0fB8yz0PGvwPCt4fgo9PzV4dhI8z0HPcwbPc4LnZ9DzM4NnZ8HzPPQ8b/A8L3h+Dj0/N3h2ETwvQM8LBs8LgucX0PMLg2dXwfMi9Lxo8LwoeH4JPb80eHYTPC9Bz0sGz0uC51fQ8yuDZ3fB8zL0vGzwvCx4fg09vzZ49hA8r0DPKwbPK4LnN9DzG4NnT8HzKvS8avC8Knh+Cz2/NXj2EjyvQc9rBs9rgud30PM7g2dvwfM69Lxu8LwueN6AnjcMnn0Ez5vQ86bB86bgeQt63jJ49hU8b0PP2wbP24Ln99Dze4NnP8HzDvS8Y/C8I3j+AD1/MHj2FzzvQs+7Bs+7gueP0PNHg+cAwfMe9Lxn8LwneP4EPX8yeA4UPO9Dz/sGz/uC58/Q82eD5yDB8wH0fGDwfCB4PoSeDw2egwXPR9DzkcHzkeD5C/T8xeA5RPB8DD0fGzwfC56/Qs9fDZ5DBc8n0POJwfOJ4Pkb9PzN4DlM8HwKPZ8aPJ8Kns+g5zOD53DB8zn0fG7wfC54/g49fzd4jhA8X0DPFwbPF4LnH9DzD4PnSMHzJfR8afB8KXj+CT3/NHiOEjxfQc9XBs9Xgudf0PMvg+dowfM19Hxt8HwteP4NPf82eI4RPN9AzzcGzzeC5z/Q8x+D51jB8y30fGvwfCt4/gs9/zV4jhM830HPdwbPd4LnezmZ53/vQvUcL3hGyMk8I+QM3TPsdnhtROgZ0eA5QfCMBD0jGTwjCZ6RoWdkg+dEwTMK9Ixi8IwieEaFnlENnpMEz2jQM5rBM5rgGR16Rjd4ThY8Y0DPGAbPGIJnTOgZ0+A5RfCMBT1jGTxjCZ6xoWdsg+dUwTMO9Ixj8IwjeMaFnnENntMEz3jQM57BM57gGR96xjd4Thc8E0DPBAbPBIJnQuiZ0OA5Q/BMBD0TGTwTCZ6JoWdig+dMwTMJ9Exi8EwieCaFnkkNnrMEz2TQM5nBM5ngmRx6Jjd4zhY8U0DPFAbPFIJnSuiZ0uA5R/BMBT1TGTxTCZ6poWdqg+dcwTMN9Exj8EwjeKaFnmkNnvMEz3TQM53BM53gGUDPwOA5X/BMDz3TGzzTC54ZoGcGg+cCwTMj9Mxo8MwoeGaCnpkMngsFz8zQM7PBM7PgmQV6ZjF4LhI8s0LPrAbPrIJnNuiZzeC5WPDMDj2zGzyzC545oGcOg+cSwTMn9Mxp8MwpeOaCnrkMnksFz9zQM7fBM7fgmQd65jF4LhM880LPvAbPvIJnPuiZz+C5XPDMDz3zGzzzC54FoGcBg+cKwbMg9Cxo8CwoeBaCnoUMnisFz8LQs7DBs7DgWQR6FjF4rhI8i0LPogbPooJnMehZzOC5WvAsDj2LGzyLC54loGcJg+cawbMk9Cxp8CwpeJaCnqUMnmsFz9LQs7TBs7TgWQZ6ljF4rhM8y0LPsgbPsoJnOehZzuC5XvAsDz3LGzzLC54VoGcFg+cGwbMi9Kxo8KwoeFaCnpUMnhsFz8rQs7LBs7LgWQV6VjF4bhI8q0LPqgbPqoJnNehZzeC5WfCsDj2rGzyrC541oGcNg+cWwbMm9Kxp8KwpeNaCnrUMnlsFz9rQs7bBs7bgWQd61jF4bhM860LPugbPuoJnPehZz+C5XfCsDz3rGzzrC54NoGcDg+cOwbMh9Gxo8GwoeDaCno0MnjsFz8bQs7HBs7Hg2QR6NjF47hI8m0LPpgbPpoJnM+jZzOC5W/BsDj2bGzybC54toGcLg+cewbMl9Gxp8GwpeLaCnq0MnnsFz9bQs7XBs7Xg2QZ6tjF47hM820LPtgbPtoJnO+jZzuC5X/BsDz3bGzzbC54doGcHg+cBwbMj9Oxo8OwoeHaCnp0MngcFz87Qs7PBs7Pg2QV6djF4HhI8u0LPrgbProJnN+jZzeB5WPDsDj27Gzy7C549oGcPg+cRwbMn9Oxp8OwpePaCnr0MnkcFz97Qs7fBs7fg2Qd69jF4HhM8+0LPvgbPvoJnP+jZz+B5XPDsDz37Gzz7C54DoOcAg+f7gudA6DnQ4DlQ8BwEPQcZPE8InoOh52CD52DBcwj0HGLw/EDwHAo9hxo8hwqew6DnMIPnScFzOPQcbvAcLniOgJ4jDJ4fCp4joedIg+dIwXMU9Bxl8DwleI6GnqMNnqMFzzHQc4zB8yPBcyz0HGvwHCt4joOe4wyepwXP8dBzvMFzvOA5AXpOMHh+LHhOhJ4TDZ4TBc9J0HOSwfOM4DkZek42eE4WPKdAzykGz08Ez6nQc6rBc6rgOQ16TjN4nhU8p0PP6QbP6YLnDOg5w+D5qeA5E3rONHjOFDxnQc9ZBs9zguds6Dnb4Dlb8JwDPecYPD8TPOdCz7kGz7mC5zzoOc/geV7wnA895xs85wueC6DnAoPn54LnQui50OC5UPBcBD0XGTwvCJ6Loedig+diwXMJ9Fxi8PxC8FwKPZcaPJcKnsug5zKD50XBczn0XG7wXC54roCeKwyeXwqeK6HnSoPnSsFzFfRcZfC8JHiuhp6rDZ6rBc810HONwfMrwXMt9Fxr8FwreK6DnusMnpcFz/XQc73Bc73guQF6bjB4fi14boSeGw2eGwXPTdBzk8HziuC5GXpuNnhuFjy3QM8tBs9vBM+t0HOrwXOr4LkNem4zeF4VPLdDz+0Gz+2C5w7oucPg+a3guRN67jR47hQ8d0HPXQbPa4Lnbui52+C5W/DcAz33GDy/Ezz3Qs+9Bs+9guc+6LnP4Hld8NwPPfcbPPcLngeg5wGD5w3B8yD0PGjwPCh4HoKehwyeNwXPw9DzsMHzsOB5BHoeMXjeEjyPQs+jBs+jgucx6HnM4Hlb8DwOPY8bPI8Lnu9Dz/cNnt8Lnieg5wmD5wnB8wPo+YHB847geRJ6njR4nhQ8P4SeHxo8fxA8T0HPUwbPU4LnR9DzI4PnXcHzNPQ8bfA8LXh+DD0/Nnj+KHiegZ5nDJ5nBM9PoOcnBs97gudZ6HnW4HlW8PwUen5q8PxJ8DwHPc8ZPM8Jnp9Bz88MnvcFz/PQ87zB87zg+Tn0/Nzg+bPgeQF6XjB4XhA8v4CeXxg8HwieF6HnRYPnRcHzS+j5pcHzoeB5CXpeMnheEjy/gp5fGTwfCZ6Xoedlg+dlwfNr6Pm1wfMXwfMK9Lxi8LwieH4DPb8xeD4WPK9Cz6sGz6uC57fQ81uD56+C5zXoec3geU3w/A56fmfwfCJ4Xoee1w2e1wXPG9DzhsHzN8HzJvS8afC8KXjegp63DJ5PBc/b0PO2wfO24Pk99Pze4PlM8LwDPe8YPO8Inj9Azx8Mns8Fz7vQ867B867g+SP0/NHg+bvgeQ963jN43hM8f4KePxk8Xwie96HnfYPnfcHzZ+j5s8HzD8HzAfR8YPB8IHg+hJ4PDZ4vBc9H0PORwfOR4PkL9PzF4Pmn4PkYej42eD4WPH+Fnr8aPF8Jnk+g5xOD5xPB8zfo+ZvB8y/B8yn0fGrwfCp4PoOezwyerwXP59DzucHzueD5O/T83eD5t+D5Anq+MHi+EDz/gJ5/GDzfCJ4voedLg+dLwfNP6PmnwfMfwfMV9Hxl8HwleP4FPf8yeL4VPF9Dz9cGz9eC59/Q82+D57+C5xvo+cbg+Ubw/Ad6/mPwfCd4voWebw2ebwXPf6HnvwbP92L/73e++18930v8f9z537u44dypbIfXvpfrf70z2/9x53/vwrsznC9CBMEzQi7mGSFX6J5ht8NrI0LPiAbPiIJnJOgZyeAZSfCMDD0jGzwjCZ5RoGcUg2cUwTMq9Ixq8IwseEaDntEMntEEz+jQM7rBM4rgGQN6xjB4xhA8Y0LPmAbPqIJnLOgZy+AZS/CMDT1jGzyjCZ5xoGccg2ccwTMu9Ixr8IwueMaDnvEMnvEEz/jQM77BM4bgmQB6JjB4JhA8E0LPhAbPmIJnIuiZyOCZSPBMDD0TGzxjCZ5JoGcSg2cSwTMp9Exq8IwteCaDnskMnskEz+TQM7nBM47gmQJ6pjB4phA8U0LPlAbPuIJnKuiZyuCZSvBMDT1TGzzjCZ5poGcag2cawTMt9Exr8IwveKaDnukMnukEzwB6BgbPBIJneuiZ3uCZXvDMAD0zGDwTCp4ZoWdGg2dGwTMT9Mxk8EwkeGaGnpkNnpkFzyzQM4vBM7HgmRV6ZjV4ZhU8s0HPbAbPJIJnduiZ3eCZXfDMAT1zGDyTCp45oWdOg2dOwTMX9Mxl8EwmeOaGnrkNnrkFzzzQM4/BM7ngmRd65jV45hU880HPfAbPFIJnfuiZ3+CZX/AsAD0LGDxTCp4FoWdBg2dBwbMQ9Cxk8EwleBaGnoUNnoUFzyLQs4jBM7XgWRR6FjV4FhU8i0HPYgbPNIJncehZ3OBZXPAsAT1LGDzTCp4loWdJg2dJwbMU9Cxl8EwneJaGnqUNnqUFzzLQs4zBMxA8y0LPsgbPsoJnOehZzuCZXvAsDz3LGzzLC54VoGcFg2cGwbMi9Kxo8KwoeFaCnpUMnhkFz8rQs7LBs7LgWQV6VjF4ZhI8q0LPqgbPqoJnNehZzeCZWfCsDj2rGzyrC541oGcNg2cWwbMm9Kxp8KwpeNaCnrUMnlkFz9rQs7bBs7bgWQd61jF4ZhM860LPugbPuoJnPehZz+CZXfCsDz3rGzzrC54NoGcDg2cOwbMh9Gxo8GwoeDaCno0MnjkFz8bQs7HBs7Hg2QR6NjF45hI8m0LPpgbPpoJnM+jZzOCZW/BsDj2bGzybC54toGcLg2cewbMl9Gxp8GwpeLaCnq0MnnkFz9bQs7XBs7Xg2QZ6tjF45hM820LPtgbPtoJnO+jZzuCZX/BsDz3bGzzbC54doGcHg2cBwbMj9Oxo8OwoeHaCnp0MngUFz87Qs7PBs7Pg2QV6djF4FhI8u0LPrgbProJnN+jZzeBZWPDsDj27Gzy7C549oGcPg2cRwbMn9Oxp8OwpePaCnr0MnkUFz97Qs7fBs7fg2Qd69jF4FhM8+0LPvgbPvoJnP+jZz+BZXPDsDz37Gzz7C54DoOcAg2cJwXMg9Bxo8BwoeA6CnoMMniUFz8HQc7DBc7DgOQR6DjF4lhI8h0LPoQbPoYLnMOg5zOBZWvAcDj2HGzyHC54joOcIg2cZwXMk9Bxp8BwpeI6CnqMMnmUFz9HQc7TBc7TgOQZ6jjF4lhM8x0LPsQbPsYLnOOg5zuBZXvAcDz3HGzzHC54ToOcEg2cFwXMi9Jxo8JwoeE6CnpMMnhUFz8nQc7LBc7LgOQV6TjF4VhI8p0LPqQbPqYLnNOg5zeBZWfCcDj2nGzynC54zoOcMg2cVwXMm9Jxp8JwpeM6CnrMMnlUFz9nQc7bBc7bgOQd6zjF4VhM850LPuQbPuYLnPOg5z+BZXfCcDz3nGzznC54LoOcCg2cNwXMh9Fxo8FwoeC6CnosMnjUFz8XQc7HBc7HguQR6LjF41hI8l0LPpQbPpYLnMui5zOBZW/BcDj2XGzyXC54roOcKg2cdwXMl9Fxp8FwpeK6CnqsMnnUFz9XQc7XBc7XguQZ6rjF41hM810LPtQbPtYLnOui5zuBZX/BcDz3XGzzXC54boOcGg2cDwXMj9Nxo8NwoeG6CnpsMng0Fz83Qc7PBc7PguQV6bjF4NhI8t0LPrQbPrYLnNui5zeDZWPDcDj23Gzy3C547oOcOg2cTwXMn9Nxp8NwpeO6CnrsMnk0Fz93Qc7fBc7fguQd67jF4NhM890LPvQbPvYLnPui5z+DZXPDcDz33Gzz3C54HoOcBg2cLwfMg9Dxo8DwoeB6CnocMni0Fz8PQ87DB87DgeQR6HjF4thI8j0LPowbPo4LnMeh5zODZWvA8Dj2PGzyPC57vQ8/3DZ5tBM8T0POEwfOE4PkB9PzA4NlW8DwJPU8aPE8Knh9Czw8Nnu0Ez1PQ85TB85Tg+RH0/Mjg2V7wPA09Txs8TwueH0PPjw2eHQTPM9DzjMHzjOD5CfT8xODZUfA8Cz3PGjzPCp6fQs9PDZ6dBM9z0POcwfOc4PkZ9PzM4NlZ8DwPPc8bPM8Lnp9Dz88Nnl0EzwvQ84LB84Lg+QX0/MLg2VXwvAg9Lxo8LwqeX0LPLw2e3QTPS9DzksHzkuD5FfT8yuDZXfC8DD0vGzwvC55fQ8+vDZ49BM8r0POKwfOK4PkN9PzG4NlT8LwKPa8aPK8Knt9Cz28Nnr0Ez2vQ85rB85rg+R30/M7g2VvwvA49rxs8rwueN6DnDYNnH8HzJvS8afC8KXjegp63DJ59Bc/b0PO2wfO24Pk99Pze4NlP8LwDPe8YPO8Inj9Azx8Mnv0Fz7vQ867B867g+SP0/NHgOUDwvAc97xk87wmeP0HPnwyeAwXP+9DzvsHzvuD5M/T82eA5SPB8AD0fGDwfCJ4PoedDg+dgwfMR9Hxk8HwkeP4CPX8xeA4RPB9Dz8cGz8eC56/Q81eD51DB8wn0fGLwfCJ4/gY9fzN4DhM8n0LPpwbPp4LnM+j5zOA5XPB8Dj2fGzyfC56/Q8/fDZ4jBM8X0POFwfOF4PkH9PzD4DlS8HwJPV8aPF8Knn9Czz8NnqMEz1fQ85XB85Xg+Rf0/MvgOVrwfA09Xxs8Xwuef0PPvw2eYwTPN9DzjcHzjeD5D/T8x+A5VvB8Cz3fGjzfCp7/Qs9/DZ7jBM930POdwfOd4Plebub537tQPccLnhFyM88IuUP3DLsdXhsRekY0eE4QPCNBz0gGz0iCZ2ToGdngOVHwjAI9oxg8owieUaFnVIPnJMEzGvSMZvCMJnhGh57RDZ6TBc8Y0DOGwTOG4BkTesY0eE4RPGNBz1gGz1iCZ2zoGdvgOVXwjAM94xg84wiecaFnXIPnNMEzHvSMZ/CMJ3jGh57xDZ7TBc8E0DOBwTOB4JkQeiY0eM4QPBNBz0QGz0SCZ2LomdjgOVPwTAI9kxg8kwieSaFnUoPnLMEzGfRMZvBMJngmh57JDZ6zBc8U0DOFwTOF4JkSeqY0eM4RPFNBz1QGz1SCZ2romdrgOVfwTAM90xg80wieaaFnWoPnPMEzHfRMZ/BMJ3gG0DMweM4XPNNDz/QGz/SCZwbomcHguUDwzAg9Mxo8MwqemaBnJoPnQsEzM/TMbPDMLHhmgZ5ZDJ6LBM+s0DOrwTOr4JkNemYzeC4WPLNDz+wGz+yCZw7omcPguUTwzAk9cxo8cwqeuaBnLoPnUsEzN/TMbfDMLXjmgZ55DJ7LBM+80DOvwTOv4JkPeuYzeC4XPPNDz/wGz/yCZwHoWcDguULwLAg9Cxo8CwqehaBnIYPnSsGzMPQsbPAsLHgWgZ5FDJ6rBM+i0LOowbOo4FkMehYzeK4WPItDz+IGz+KCZwnoWcLguUbwLAk9Sxo8SwqepaBnKYPnWsGzNPQsbfAsLXiWgZ5lDJ7rBM+y0LOswbOs4FkOepYzeK4XPMtDz/IGz/KCZwXoWcHguUHwrAg9Kxo8KwqelaBnJYPnRsGzMvSsbPCsLHhWgZ5VDJ6bBM+q0LOqwbOq4FkNelYzeG4WPKtDz+oGz+qCZw3oWcPguUXwrAk9axo8awqetaBnLYPnVsGzNvSsbfCsLXjWgZ51DJ7bBM+60LOuwbOu4FkPetYzeG4XPOtDz/oGz/qCZwPo2cDguUPwbAg9Gxo8GwqejaBnI4PnTsGzMfRsbPBsLHg2gZ5NDJ67BM+m0LOpwbOp4NkMejYzeO4WPJtDz+YGz+aCZwvo2cLguUfwbAk9Wxo8WwqeraBnK4PnXsGzNfRsbfBsLXi2gZ5tDJ77BM+20LOtwbOt4NkOerYzeO4XPNtDz/YGz/aCZwfo2cHgeUDw7Ag9Oxo8OwqenaBnJ4PnQcGzM/TsbPDsLHh2gZ5dDJ6HBM+u0LOrwbOr4NkNenYzeB4WPLtDz+4Gz+6CZw/o2cPgeUTw7Ak9exo8ewqevaBnL4PnUcGzN/TsbfDsLXj2gZ59DJ7HBM++0LOvwbOv4NkPevYzeB4XPPtDz/4Gz/6C5wDoOcDg+b7gORB6DjR4DhQ8B0HPQQbPE4LnYOg52OA5WPAcAj2HGDw/EDyHQs+hBs+hgucw6DnM4HlS8BwOPYcbPIcLniOg5wiD54eC50joOdLgOVLwHAU9Rxk8Twmeo6HnaIPnaMFzDPQcY/D8SPAcCz3HGjzHCp7joOc4g+dpwXM89Bxv8BwveE6AnhMMnh8LnhOh50SD50TBcxL0nGTwPCN4Toaekw2ekwXPKdBzisHzE8FzKvScavCcKnhOg57TDJ5nBc/p0HO6wXO64DkDes4weH4qeM6EnjMNnjMFz1nQc5bB85zgORt6zjZ4zhY850DPOQbPzwTPudBzrsFzruA5D3rOM3ieFzznQ8/5Bs/5gucC6LnA4Pm54LkQei40eC4UPBdBz0UGzwuC52LoudjguVjwXAI9lxg8vxA8l0LPpQbPpYLnMui5zOB5UfBcDj2XGzyXC54roOcKg+eXgudK6LnS4LlS8FwFPVcZPC8Jnquh52qD52rBcw30XGPw/ErwXAs91xo81wqe66DnOoPnZcFzPfRcb/BcL3hugJ4bDJ5fC54boedGg+dGwXMT9Nxk8LwieG6GnpsNnpsFzy3Qc4vB8xvBcyv03Grw3Cp4boOe2wyeVwXP7dBzu8Fzu+C5A3ruMHh+K3juhJ47DZ47Bc9d0HOXwfOa4Lkbeu42eO4WPPdAzz0Gz+8Ez73Qc6/Bc6/guQ967jN4Xhc890PP/QbP/YLnAeh5wOB5Q/A8CD0PGjwPCp6HoOchg+dNwfMw9Dxs8DwseB6BnkcMnrcEz6PQ86jB86jgeQx6HjN43hY8j0PP4wbP44Ln+9DzfYPn94LnCeh5wuB5QvD8AHp+YPC8I3iehJ4nDZ4nBc8PoeeHBs8fBM9T0POUwfOU4PkR9PzI4HlX8DwNPU8bPE8Lnh9Dz48Nnj8Knmeg5xmD5xnB8xPo+YnB857geRZ6njV4nhU8P4Wenxo8fxI8z0HPcwbPc4LnZ9DzM4PnfcHzPPQ8b/A8L3h+Dj0/N3j+LHhegJ4XDJ4XBM8voOcXBs8HgudF6HnR4HlR8PwSen5p8HwoeF6CnpcMnpcEz6+g51cGz0eC52XoedngeVnw/Bp6fm3w/EXwvAI9rxg8rwie30DPbwyejwXPq9DzqsHzquD5LfT81uD5q+B5DXpeM3heEzy/g57fGTyfCJ7Xoed1g+d1wfMG9Lxh8PxN8LwJPW8aPG8Knreg5y2D51PB8zb0vG3wvC14fg89vzd4PhM870DPOwbPO4LnD9DzB4Pnc8HzLvS8a/C8K3j+CD1/NHj+Lnjeg573DJ73BM+foOdPBs8Xgud96Hnf4Hlf8PwZev5s8PxD8HwAPR8YPB8Ing+h50OD50vB8xH0fGTwfCR4/gI9fzF4/il4Poaejw2ejwXPX6HnrwbPV4LnE+j5xOD5RPD8DXr+ZvD8S/B8Cj2fGjyfCp7PoOczg+drwfM59Hxu8HwueP4OPX83eP4teL6Ani8Mni8Ezz+g5x8GzzeC50vo+dLg+VLw/BN6/mnw/EfwfAU9Xxk8Xwmef0HPvwyebwXP19DztcHzteD5N/T82+D5r+D5Bnq+MXi+ETz/gZ7/GDzfCZ5voedbg+dbwfNf6PmvwfO9OP/7ne+g5zuD5zvB8708zPO/d6F6RhA8I+RhnhHyhO4Zdju8NiL0jGjwjCh4RoKekQyekQTPyNAzssEzkuAZBXpGMXhGETyjQs+oBs/Igmc06BnN4BlN8IwOPaMbPKMInjGgZwyDZwzBMyb0jGnwjCp4xoKesQyesQTP2NAztsEzmuAZB3rGMXjGETzjQs+4Bs/ogmc86BnP4BlP8IwPPeMbPGMIngmgZwKDZwLBMyH0TGjwjCl4JoKeiQyeiQTPxNAzscEzluCZBHomMXgmETyTQs+kBs/Ygmcy6JnM4JlM8EwOPZMbPOMInimgZwqDZwrBMyX0TGnwjCt4poKeqQyeqQTP1NAztcEznuCZBnqmMXimETzTQs+0Bs/4gmc66JnO4JlO8AygZ2DwTCB4poee6Q2e6QXPDNAzg8EzoeCZEXpmNHhmFDwzQc9MBs9Egmdm6JnZ4JlZ8MwCPbMYPBMLnlmhZ1aDZ1bBMxv0zGbwTCJ4Zoee2Q2e2QXPHNAzh8EzqeCZE3rmNHjmFDxzQc9cBs9kgmdu6Jnb4Jlb8MwDPfMYPJMLnnmhZ16DZ17BMx/0zGfwTCF45oee+Q2e+QXPAtCzgMEzpeBZEHoWNHgWFDwLQc9CBs9Ugmdh6FnY4FlY8CwCPYsYPFMLnkWhZ1GDZ1HBsxj0LGbwTCN4FoeexQ2exQXPEtCzhMEzreBZEnqWNHiWFDxLQc9SBs90gmdp6Fna4Fla8CwDPcsYPAPBsyz0LGvwLCt4loOe5Qye6QXP8tCzvMGzvOBZAXpWMHhmEDwrQs+KBs+Kgmcl6FnJ4JlR8KwMPSsbPCsLnlWgZxWDZybBsyr0rGrwrCp4VoOe1QyemQXP6tCzusGzuuBZA3rWMHhmETxrQs+aBs+agmct6FnL4JlV8KwNPWsbPGsLnnWgZx2DZzbBsy70rGvwrCt41oOe9Qye2QXP+tCzvsGzvuDZAHo2MHjmEDwbQs+GBs+Ggmcj6NnI4JlT8GwMPRsbPBsLnk2gZxODZy7Bsyn0bGrwbCp4NoOezQyeuQXP5tCzucGzueDZAnq2MHjmETxbQs+WBs+Wgmcr6NnK4JlX8GwNPVsbPFsLnm2gZxuDZz7Bsy30bGvwbCt4toOe7Qye+QXP9tCzvcGzveDZAXp2MHgWEDw7Qs+OBs+Ogmcn6NnJ4FlQ8OwMPTsbPDsLnl2gZxeDZyHBsyv07Grw7Cp4doOe3QyehQXP7tCzu8Gzu+DZA3r2MHgWETx7Qs+eBs+egmcv6NnL4FlU8OwNPXsbPHsLnn2gZx+DZzHBsy/07Gvw7Ct49oOe/QyexQXP/tCzv8Gzv+A5AHoOMHiWEDwHQs+BBs+Bgucg6DnI4FlS8BwMPQcbPAcLnkOg5xCDZynBcyj0HGrwHCp4DoOewwyepQXP4dBzuMFzuOA5AnqOMHiWETxHQs+RBs+Rguco6DnK4FlW8BwNPUcbPEcLnmOg5xiDZznBcyz0HGvwHCt4joOe4wye5QXP8dBzvMFzvOA5AXpOMHhWEDwnQs+JBs+Jguck6DnJ4FlR8JwMPScbPCcLnlOg5xSDZyXBcyr0nGrwnCp4ToOe0wyelQXP6dBzusFzuuA5A3rOMHhWETxnQs+ZBs+Zgucs6DnL4FlV8JwNPWcbPGcLnnOg5xyDZzXBcy70nGvwnCt4zoOe8wye1QXP+dBzvsFzvuC5AHouMHjWEDwXQs+FBs+Fguci6LnI4FlT8FwMPRcbPBcLnkug5xKDZy3Bcyn0XGrwXCp4LoOeywyetQXP5dBzucFzueC5AnquMHjWETxXQs+VBs+Vgucq6LnK4FlX8FwNPVcbPFcLnmug5xqDZz3Bcy30XGvwXCt4roOe6wye9QXP9dBzvcFzveC5AXpuMHg2EDw3Qs+NBs+Ngucm6LnJ4NlQ8NwMPTcbPDcLnlug5xaDZyPBcyv03Grw3Cp4boOe2wyejQXP7dBzu8Fzu+C5A3ruMHg2ETx3Qs+dBs+dgucu6LnL4NlU8NwNPXcbPHcLnnug5x6DZzPBcy/03Gvw3Ct47oOe+wyezQXP/dBzv8Fzv+B5AHoeMHi2EDwPQs+DBs+Dguch6HnI4NlS8DwMPQ8bPA8Lnkeg5xGDZyvB8yj0PGrwPCp4HoOexwyerQXP49DzuMHzuOD5PvR83+DZRvA8AT1PGDxPCJ4fQM8PDJ5tBc+T0POkwfOk4Pkh9PzQ4NlO8DwFPU8ZPE8Jnh9Bz48Mnu0Fz9PQ87TB87Tg+TH0/Njg2UHwPAM9zxg8zwien0DPTwyeHQXPs9DzrMHzrOD5KfT81ODZSfA8Bz3PGTzPCZ6fQc/PDJ6dBc/z0PO8wfO84Pk59Pzc4NlF8LwAPS8YPC8Inl9Azy8Mnl0Fz4vQ86LB86Lg+SX0/NLg2U3wvAQ9Lxk8LwmeX0HPrwye3QXPy9DzssHzsuD5NfT82uDZQ/C8Aj2vGDyvCJ7fQM9vDJ49Bc+r0POqwfOq4Pkt9PzW4NlL8LwGPa8ZPK8Jnt9Bz+8Mnr0Fz+vQ87rB87rgeQN63jB49hE8b0LPmwbPm4LnLeh5y+DZV/C8DT1vGzxvC57fQ8/vDZ79BM870POOwfOO4PkD9PzB4Nlf8LwLPe8aPO8Knj9Czx8NngMEz3vQ857B857g+RP0/MngOVDwvA897xs87wueP0PPnw2egwTPB9DzgcHzgeD5EHo+NHgOFjwfQc9HBs9Hgucv0PMXg+cQwfMx9Hxs8HwseP4KPX81eA4VPJ9AzycGzyeC52/Q8zeD5zDB8yn0fGrwfCp4PoOezwyewwXP59DzucHzueD5O/T83eA5QvB8AT1fGDxfCJ5/QM8/DJ4jBc+X0POlwfOl4Pkn9PzT4DlK8HwFPV8ZPF8Jnn9Bz78MnqMFz9fQ87XB87Xg+Tf0/NvgOUbwfAM93xg83wie/0DPfwyeYwXPt9DzrcHzreD5L/T81+A5TvB8Bz3fGTzfCZ7v5WWe/70L1XO84BkhL/OMkDd0z7Db4bURoWdEg+cEwTMS9Ixk8IwkeEaGnpENnhMFzyjQM4rBM4rgGRV6RjV4ThI8o0HPaAbPaIJndOgZ3eA5WfCMAT1jGDxjCJ4xoWdMg+cUwTMW9Ixl8IwleMaGnrENnlMFzzjQM47BM47gGRd6xjV4ThM840HPeAbPeIJnfOgZ3+A5XfBMAD0TGDwTCJ4JoWdCg+cMwTMR9Exk8EwkeCaGnokNnjMFzyTQM4nBM4ngmRR6JjV4zhI8k0HPZAbPZIJncuiZ3OA5W/BMAT1TGDxTCJ4poWdKg+ccwTMV9Exl8EwleKaGnqkNnnMFzzTQM43BM43gmRZ6pjV4zhM800HPdAbPdIJnAD0Dg+d8wTM99Exv8EwveGaAnhkMngsEz4zQM6PBM6PgmQl6ZjJ4LhQ8M0PPzAbPzIJnFuiZxeC5SPDMCj2zGjyzCp7ZoGc2g+diwTM79Mxu8MwueOaAnjkMnksEz5zQM6fBM6fgmQt65jJ4LhU8c0PP3AbP3IJnHuiZx+C5TPDMCz3zGjzzCp75oGc+g+dywTM/9Mxv8MwveBaAngUMnisEz4LQs6DBs6DgWQh6FjJ4rhQ8C0PPwgbPwoJnEehZxOC5SvAsCj2LGjyLCp7FoGcxg+dqwbM49Cxu8CwueJaAniUMnmsEz5LQs6TBs6TgWQp6ljJ4rhU8S0PP0gbP0oJnGehZxuC5TvAsCz3LGjzLCp7loGc5g+d6wbM89Cxv8CwveFaAnhUMnhsEz4rQs6LBs6LgWQl6VjJ4bhQ8K0PPygbPyoJnFehZxeC5SfCsCj2rGjyrCp7VoGc1g+dmwbM69Kxu8KwueNaAnjUMnlsEz5rQs6bBs6bgWQt61jJ4bhU8a0PP2gbP2oJnHehZx+C5TfCsCz3rGjzrCp71oGc9g+d2wbM+9Kxv8KwveDaAng0MnjsEz4bQs6HBs6Hg2Qh6NjJ47hQ8G0PPxgbPxoJnE+jZxOC5S/BsCj2bGjybCp7NoGczg+duwbM59Gxu8GwueLaAni0MnnsEz5bQs6XBs6Xg2Qp6tjJ47hU8W0PP1gbP1oJnG+jZxuC5T/BsCz3bGjzbCp7toGc7g+d+wbM99Gxv8GwveHaAnh0MngcEz47Qs6PBs6Pg2Ql6djJ4HhQ8O0PPzgbPzoJnF+jZxeB5SPDsCj27Gjy7Cp7doGc3g+dhwbM79Oxu8OwuePaAnj0MnkcEz57Qs6fBs6fg2Qt69jJ4HhU8e0PP3gbP3oJnH+jZx+B5TPDsCz37Gjz7Cp79oGc/g+dxwbM/9Oxv8OwveA6AngMMnu8LngOh50CD50DBcxD0HGTwPCF4Doaegw2egwXPIdBziMHzA8FzKPQcavAcKngOg57DDJ4nBc/h0HO4wXO44DkCeo4weH4oeI6EniMNniMFz1HQc5TB85TgORp6jjZ4jhY8x0DPMQbPjwTPsdBzrMFzrOA5DnqOM3ieFjzHQ8/xBs/xgucE6DnB4Pmx4DkRek40eE4UPCdBz0kGzzOC52ToOdngOVnwnAI9pxg8PxE8p0LPqQbPqYLnNOg5zeB5VvCcDj2nGzynC54zoOcMg+engudM6DnT4DlT8JwFPWcZPM8JnrOh52yD52zBcw70nGPw/EzwnAs95xo85wqe86DnPIPnecFzPvScb/CcL3gugJ4LDJ6fC54LoedCg+dCwXMR9Fxk8LwgeC6GnosNnosFzyXQc4nB8wvBcyn0XGrwXCp4LoOeywyeFwXP5dBzucFzueC5AnquMHh+KXiuhJ4rDZ4rBc9V0HOVwfOS4Lkaeq42eK4WPNdAzzUGz68Ez7XQc63Bc63guQ56rjN4XhY810PP9QbP9YLnBui5weD5teC5EXpuNHhuFDw3Qc9NBs8rgudm6LnZ4LlZ8NwCPbcYPL8RPLdCz60Gz62C5zbouc3geVXw3A49txs8twueO6DnDoPnt4LnTui50+C5U/DcBT13GTyvCZ67oedug+duwXMP9Nxj8PxO8NwLPfcaPPcKnvug5z6D53XBcz/03G/w3C94HoCeBwyeNwTPg9DzoMHzoOB5CHoeMnjeFDwPQ8/DBs/DgucR6HnE4HlL8DwKPY8aPI8Knseg5zGD523B8zj0PG7wPC54vg893zd4fi94noCeJwyeJwTPD6DnBwbPO4LnSeh50uB5UvD8EHp+aPD8QfA8BT1PGTxPCZ4fQc+PDJ53Bc/T0PO0wfO04Pkx9PzY4Pmj4HkGep4xeJ4RPD+Bnp8YPO8Jnmeh51mD51nB81Po+anB8yfB8xz0PGfwPCd4fgY9PzN43hc8z0PP8wbP84Ln59Dzc4Pnz4LnBeh5weB5QfD8Anp+YfB8IHhehJ4XDZ4XBc8voeeXBs+Hgucl6HnJ4HlJ8PwKen5l8HwkeF6GnpcNnpcFz6+h59cGz18EzyvQ84rB84rg+Q30/Mbg+VjwvAo9rxo8rwqe30LPbw2evwqe16DnNYPnNcHzO+j5ncHzieB5HXpeN3heFzxvQM8bBs/fBM+b0POmwfOm4HkLet4yeD4VPG9Dz9sGz9uC5/fQ83uD5zPB8w70vGPwvCN4/gA9fzB4Phc870LPuwbPu4Lnj9DzR4Pn74LnPeh5z+B5T/D8CXr+ZPB8IXjeh573DZ73Bc+foefPBs8/BM8H0POBwfOB4PkQej40eL4UPB9Bz0cGz0eC5y/Q8xeD55+C52Po+djg+Vjw/BV6/mrwfCV4PoGeTwyeTwTP36DnbwbPvwTPp9DzqcHzqeD5DHo+M3i+FjyfQ8/nBs/ngufv0PN3g+ffgucL6PnC4PlC8PwDev5h8HwjeL6Eni8Nni8Fzz+h558Gz38Ez1fQ85XB85Xg+Rf0/Mvg+VbwfA09Xxs8Xwuef0PPvw2e/wqeb6DnG4PnG8HzH+j5j8HzneD5Fnq+NXi+FTz/hZ7/Gjz/+4Hgf7zzHfR8Z/B8J3i+l495/vcuVM8IgmeEfMwzQr7QPcNuh9dGhJ4RDZ4RBc9I0DOSwTOS4BkZekY2eEYSPKNAzygGzyiCZ1ToGdXgGVnwjAY9oxk8owme0aFndINnFMEzBvSMYfCMIXjGhJ4xDZ5RBc9Y0DOWwTOW4BkbesY2eEYTPONAzzgGzziCZ1zoGdfgGV3wjAc94xk84wme8aFnfINnDMEzAfRMYPBMIHgmhJ4JDZ4xBc9E0DORwTOR4JkYeiY2eMYSPJNAzyQGzySCZ1LomdTgGVvwTAY9kxk8kwmeyaFncoNnHMEzBfRMYfBMIXimhJ4pDZ5xBc9U0DOVwTOV4JkaeqY2eMYTPNNAzzQGzzSCZ1romdbgGV/wTAc90xk80wmeAfQMDJ4JBM/00DO9wTO94JkBemYweCYUPDNCz4wGz4yCZybomcngmUjwzAw9Mxs8MwueWaBnFoNnYsEzK/TMavDMKnhmg57ZDJ5JBM/s0DO7wTO74JkDeuYweCYVPHNCz5wGz5yCZy7omcvgmUzwzA09cxs8cwueeaBnHoNncsEzL/TMa/DMK3jmg575DJ4pBM/80DO/wTO/4FkAehYweKYUPAtCz4IGz4KCZyHoWcjgmUrwLAw9Cxs8CwueRaBnEYNnasGzKPQsavAsKngWg57FDJ5pBM/i0LO4wbO44FkCepYweKYVPEtCz5IGz5KCZynoWcrgmU7wLA09Sxs8SwueZaBnGYNnIHiWhZ5lDZ5lBc9y0LOcwTO94FkeepY3eJYXPCtAzwoGzwyCZ0XoWdHgWVHwrAQ9Kxk8MwqelaFnZYNnZcGzCvSsYvDMJHhWhZ5VDZ5VBc9q0LOawTOz4FkdelY3eFYXPGtAzxoGzyyCZ03oWdPgWVPwrAU9axk8swqetaFnbYNnbcGzDvSsY/DMJnjWhZ51DZ51Bc960LOewTO74FkfetY3eNYXPBtAzwYGzxyCZ0Po2dDg2VDwbAQ9Gxk8cwqejaFnY4NnY8GzCfRsYvDMJXg2hZ5NDZ5NBc9m0LOZwTO34NkcejY3eDYXPFtAzxYGzzyCZ0vo2dLg2VLwbAU9Wxk88wqeraFna4Nna8GzDfRsY/DMJ3i2hZ5tDZ5tBc920LOdwTO/4NkeerY3eLYXPDtAzw4GzwKCZ0fo2dHg2VHw7AQ9Oxk8CwqenaFnZ4NnZ8GzC/TsYvAsJHh2hZ5dDZ5dBc9u0LObwbOw4NkdenY3eHYXPHtAzx4GzyKCZ0/o2dPg2VPw7AU9exk8iwqevaFnb4Nnb8GzD/TsY/AsJnj2hZ59DZ59Bc9+0LOfwbO44NkfevY3ePYXPAdAzwEGzxKC50DoOdDgOVDwHAQ9Bxk8Swqeg6HnYIPnYMFzCPQcYvAsJXgOhZ5DDZ5DBc9h0HOYwbO04Dkceg43eA4XPEdAzxEGzzKC50joOdLgOVLwHAU9Rxk8ywqeo6HnaIPnaMFzDPQcY/AsJ3iOhZ5jDZ5jBc9x0HOcwbO84Dkeeo43eI4XPCdAzwkGzwqC50ToOdHgOVHwnAQ9Jxk8Kwqek6HnZIPnZMFzCvScYvCsJHhOhZ5TDZ5TBc9p0HOawbOy4Dkdek43eE4XPGdAzxkGzyqC50zoOdPgOVPwnAU9Zxk8qwqes6HnbIPnbMFzDvScY/CsJnjOhZ5zDZ5zBc950HOewbO64Dkfes43eM4XPBdAzwUGzxqC50LoudDguVDwXAQ9Fxk8awqei6HnYoPnYsFzCfRcYvCsJXguhZ5LDZ5LBc9l0HOZwbO24Lkcei43eC4XPFdAzxUGzzqC50roudLguVLwXAU9Vxk86wqeq6HnaoPnasFzDfRcY/CsJ3iuhZ5rDZ5rBc910HOdwbO+4Lkeeq43eK4XPDdAzw0GzwaC50boudHguVHw3AQ9Nxk8Gwqem6HnZoPnZsFzC/TcYvBsJHhuhZ5bDZ5bBc9t0HObwbOx4Lkdem43eG4XPHdAzx0GzyaC507oudPguVPw3AU9dxk8mwqeu6HnboPnbsFzD/TcY/BsJnjuhZ57DZ57Bc990HOfwbO54Lkfeu43eO4XPA9AzwMGzxaC50HoedDgeVDwPAQ9Dxk8Wwqeh6HnYYPnYcHzCPQ8YvBsJXgehZ5HDZ5HBc9j0POYwbO14Hkceh43eB4XPN+Hnu8bPNsInieg5wmD5wnB8wPo+YHBs63geRJ6njR4nhQ8P4SeHxo82wmep6DnKYPnKcHzI+j5kcGzveB5GnqeNnieFjw/hp4fGzw7CJ5noOcZg+cZwfMT6PmJwbOj4HkWep41eJ4VPD+Fnp8aPDsJnueg5zmD5znB8zPo+ZnBs7PgeR56njd4nhc8P4eenxs8uwieF6DnBYPnBcHzC+j5hcGzq+B5EXpeNHheFDy/hJ5fGjy7CZ6XoOclg+clwfMr6PmVwbO74HkZel42eF4WPL+Gnl8bPHsInleg5xWD5xXB8xvo+Y3Bs6fgeRV6XjV4XhU8v4We3xo8ewme16DnNYPnNcHzO+j5ncGzt+B5HXpeN3heFzxvQM8bBs8+gudN6HnT4HlT8LwFPW8ZPPsKnreh522D523B83vo+b3Bs5/geQd63jF43hE8f4CePxg8+wued6HnXYPnXcHzR+j5o8FzgOB5D3reM3jeEzx/gp4/GTwHCp73oed9g+d9wfNn6PmzwXOQ4PkAej4weD4QPB9Cz4cGz8GC5yPo+cjg+Ujw/AV6/mLwHCJ4Poaejw2ejwXPX6HnrwbPoYLnE+j5xOD5RPD8DXr+ZvAcJng+hZ5PDZ5PBc9n0POZwXO44Pkcej43eD4XPH+Hnr8bPEcIni+g5wuD5wvB8w/o+YfBc6Tg+RJ6vjR4vhQ8/4Sefxo8Rwmer6DnK4PnK8HzL+j5l8FztOD5Gnq+Nni+Fjz/hp5/GzzHCJ5voOcbg+cbwfMf6PmPwXOs4PkWer41eL4VPP+Fnv8aPMcJnu+g5zuD5zvB8738zPO/d6F6jhc8I+RnnhHyh+4Zdju8NiL0jGjwnCB4RoKekQyekQTPyNAzssFzouAZBXpGMXhGETyjQs+oBs9Jgmc06BnN4BlN8IwOPaMbPCcLnjGgZwyDZwzBMyb0jGnwnCJ4xoKesQyesQTP2NAztsFzquAZB3rGMXjGETzjQs+4Bs9pgmc86BnP4BlP8IwPPeMbPKcLngmgZwKDZwLBMyH0TGjwnCF4JoKeiQyeiQTPxNAzscFzpuCZBHomMXgmETyTQs+kBs9Zgmcy6JnM4JlM8EwOPZMbPGcLnimgZwqDZwrBMyX0TGnwnCN4poKeqQyeqQTP1NAztcFzruCZBnqmMXimETzTQs+0Bs95gmc66JnO4JlO8AygZ2DwnC94poee6Q2e6QXPDNAzg8FzgeCZEXpmNHhmFDwzQc9MBs+Fgmdm6JnZ4JlZ8MwCPbMYPBcJnlmhZ1aDZ1bBMxv0zGbwXCx4Zoee2Q2e2QXPHNAzh8FzieCZE3rmNHjmFDxzQc9cBs+lgmdu6Jnb4Jlb8MwDPfMYPJcJnnmhZ16DZ17BMx/0zGfwXC545oee+Q2e+QXPAtCzgMFzheBZEHoWNHgWFDwLQc9CBs+Vgmdh6FnY4FlY8CwCPYsYPFcJnkWhZ1GDZ1HBsxj0LGbwXC14FoeexQ2exQXPEtCzhMFzjeBZEnqWNHiWFDxLQc9SBs+1gmdp6Fna4Fla8CwDPcsYPNcJnmWhZ1mDZ1nBsxz0LGfwXC94loee5Q2e5QXPCtCzgsFzg+BZEXpWNHhWFDwrQc9KBs+Ngmdl6FnZ4FlZ8KwCPasYPDcJnlWhZ1WDZ1XBsxr0rGbw3Cx4Voee1Q2e1QXPGtCzhsFzi+BZE3rWNHjWFDxrQc9aBs+tgmdt6Fnb4Flb8KwDPesYPLcJnnWhZ12DZ13Bsx70rGfw3C541oee9Q2e9QXPBtCzgcFzh+DZEHo2NHg2FDwbQc9GBs+dgmdj6NnY4NlY8GwCPZsYPHcJnk2hZ1ODZ1PBsxn0bGbw3C14NoeezQ2ezQXPFtCzhcFzj+DZEnq2NHi2FDxbQc9WBs+9gmdr6Nna4Nla8GwDPdsYPPcJnm2hZ1uDZ1vBsx30bGfw3C94toee7Q2e7QXPDtCzg8HzgODZEXp2NHh2FDw7Qc9OBs+Dgmdn6NnZ4NlZ8OwCPbsYPA8Jnl2hZ1eDZ1fBsxv07GbwPCx4doee3Q2e3QXPHtCzh8HziODZE3r2NHj2FDx7Qc9eBs+jgmdv6Nnb4Nlb8OwDPfsYPI8Jnn2hZ1+DZ1/Bsx/07GfwPC549oee/Q2e/QXPAdBzgMHzfcFzIPQcaPAcKHgOgp6DDJ4nBM/B0HOwwXOw4DkEeg4xeH4geA6FnkMNnkMFz2HQc5jB86TgORx6Djd4Dhc8R0DPEQbPDwXPkdBzpMFzpOA5CnqOMnieEjxHQ8/RBs/RgucY6DnG4PmR4DkWeo41eI4VPMdBz3EGz9OC53joOd7gOV7wnAA9Jxg8PxY8J0LPiQbPiYLnJOg5yeB5RvCcDD0nGzwnC55ToOcUg+cngudU6DnV4DlV8JwGPacZPM8KntOh53SD53TBcwb0nGHw/FTwnAk9Zxo8Zwqes6DnLIPnOcFzNvScbfCcLXjOgZ5zDJ6fCZ5zoedcg+dcwXMe9Jxn8DwveM6HnvMNnvMFzwXQc4HB83PBcyH0XGjwXCh4LoKeiwyeFwTPxdBzscFzseC5BHouMXh+IXguhZ5LDZ5LBc9l0HOZwfOi4Lkcei43eC4XPFdAzxUGzy8Fz5XQc6XBc6XguQp6rjJ4XhI8V0PP1QbP1YLnGui5xuD5leC5FnquNXiuFTzXQc91Bs/Lgud66Lne4Lle8NwAPTcYPL8WPDdCz40Gz42C5yboucngeUXw3Aw9Nxs8NwueW6DnFoPnN4LnVui51eC5VfDcBj23GTyvCp7boed2g+d2wXMH9Nxh8PxW8NwJPXcaPHcKnrug5y6D5zXBczf03G3w3C147oGeewye3wmee6HnXoPnXsFzH/TcZ/C8Lnjuh577DZ77Bc8D0POAwfOG4HkQeh40eB4UPA9Bz0MGz5uC52HoedjgeVjwPAI9jxg8bwmeR6HnUYPnUcHzGPQ8ZvC8LXgeh57HDZ7HBc/3oef7Bs/vBc8T0POEwfOE4PkB9PzA4HlH8DwJPU8aPE8Knh9Czw8Nnj8Inqeg5ymD5ynB8yPo+ZHB867geRp6njZ4nhY8P4aeHxs8fxQ8z0DPMwbPM4LnJ9DzE4PnPcHzLPQ8a/A8K3h+Cj0/NXj+JHieg57nDJ7nBM/PoOdnBs/7gud56Hne4Hle8Pwcen5u8PxZ8LwAPS8YPC8Inl9Azy8Mng8Ez4vQ86LB86Lg+SX0/NLg+VDwvAQ9Lxk8LwmeX0HPrwyejwTPy9DzssHzsuD5NfT82uD5i+B5BXpeMXheETy/gZ7fGDwfC55XoedVg+dVwfNb6PmtwfNXwfMa9Lxm8LwmeH4HPb8zeD4RPK9Dz+sGz+uC5w3oecPg+ZvgeRN63jR43hQ8b0HPWwbPp4Lnbeh52+B5W/D8Hnp+b/B8JnjegZ53DJ53BM8foOcPBs/ngudd6HnX4HlX8PwRev5o8Pxd8LwHPe8ZPO8Jnj9Bz58Mni8Ez/vQ877B877g+TP0/Nng+Yfg+QB6PjB4PhA8H0LPhwbPl4LnI+j5yOD5SPD8BXr+YvD8U/B8DD0fGzwfC56/Qs9fDZ6vBM8n0POJwfOJ4Pkb9PzN4PmX4PkUej41eD4VPJ9Bz2cGz9eC53Po+dzg+Vzw/B16/m7w/FvwfAE9Xxg8Xwief0DPPwyebwTPl9DzpcHzpeD5J/T80+D5j+D5Cnq+Mni+Ejz/gp5/GTzfCp6voedrg+drwfNv6Pm3wfNfwfMN9Hxj8HwjeP4DPf8xeL4TPN9Cz7cGz7eC57/Q81+D53vx/vc730HPdwbPd4LnewWY53/vQvWMIHhGKMA8IxQI3TPsdnhtROgZ0eAZUfCMBD0jGTwjCZ6RoWdkg2ckwTMK9Ixi8IwieEaFnlENnpEFz2jQM5rBM5rgGR16Rjd4RhE8Y0DPGAbPGIJnTOgZ0+AZVfCMBT1jGTxjCZ6xoWdsg2c0wTMO9Ixj8IwjeMaFnnENntEFz3jQM57BM57gGR96xjd4xhA8E0DPBAbPBIJnQuiZ0OAZU/BMBD0TGTwTCZ6JoWdig2cswTMJ9Exi8EwieCaFnkkNnrEFz2TQM5nBM5ngmRx6Jjd4xhE8U0DPFAbPFIJnSuiZ0uAZV/BMBT1TGTxTCZ6poWdqg2c8wTMN9Exj8EwjeKaFnmkNnvEFz3TQM53BM53gGUDPwOCZQPBMDz3TGzzTC54ZoGcGg2dCwTMj9Mxo8MwoeGaCnpkMnokEz8zQM7PBM7PgmQV6ZjF4JhY8s0LPrAbPrIJnNuiZzeCZRPDMDj2zGzyzC545oGcOg2dSwTMn9Mxp8MwpeOaCnrkMnskEz9zQM7fBM7fgmQd65jF4Jhc880LPvAbPvIJnPuiZz+CZQvDMDz3zGzzzC54FoGcBg2dKwbMg9Cxo8CwoeBaCnoUMnqkEz8LQs7DBs7DgWQR6FjF4phY8i0LPogbPooJnMehZzOCZRvAsDj2LGzyLC54loGcJg2dawbMk9Cxp8CwpeJaCnqUMnukEz9LQs7TBs7TgWQZ6ljF4BoJnWehZ1uBZVvAsBz3LGTzTC57loWd5g2d5wbMC9Kxg8MwgeFaEnhUNnhUFz0rQs5LBM6PgWRl6VjZ4VhY8q0DPKgbPTIJnVehZ1eBZVfCsBj2rGTwzC57VoWd1g2d1wbMG9Kxh8MwieNaEnjUNnjUFz1rQs5bBM6vgWRt61jZ41hY860DPOgbPbIJnXehZ1+BZV/CsBz3rGTyzC571oWd9g2d9wbMB9Gxg8MwheDaEng0Nng0Fz0bQs5HBM6fg2Rh6NjZ4NhY8m0DPJgbPXIJnU+jZ1ODZVPBsBj2bGTxzC57NoWdzg2dzwbMF9Gxh8MwjeLaEni0Nni0Fz1bQs5XBM6/g2Rp6tjZ4thY820DPNgbPfIJnW+jZ1uDZVvBsBz3bGTzzC57toWd7g2d7wbMD9Oxg8CwgeHaEnh0Nnh0Fz07Qs5PBs6Dg2Rl6djZ4dhY8u0DPLgbPQoJnV+jZ1eDZVfDsBj27GTwLC57doWd3g2d3wbMH9Oxh8CwiePaEnj0Nnj0Fz17Qs5fBs6jg2Rt69jZ49hY8+0DPPgbPYoJnX+jZ1+DZV/DsBz37GTyLC579oWd/g2d/wXMA9Bxg8CwheA6EngMNngMFz0HQc5DBs6TgORh6DjZ4DhY8h0DPIQbPUoLnUOg51OA5VPAcBj2HGTxLC57Doedwg+dwwXME9Bxh8CwjeI6EniMNniMFz1HQc5TBs6zgORp6jjZ4jhY8x0DPMQbPcoLnWOg51uA5VvAcBz3HGTzLC57joed4g+d4wXMC9Jxg8KwgeE6EnhMNnhMFz0nQc5LBs6LgORl6TjZ4ThY8p0DPKQbPSoLnVOg51eA5VfCcBj2nGTwrC57Toed0g+d0wXMG9Jxh8KwieM6EnjMNnjMFz1nQc5bBs6rgORt6zjZ4zhY850DPOQbPaoLnXOg51+A5V/CcBz3nGTyrC57zoed8g+d8wXMB9Fxg8KwheC6EngsNngsFz0XQc5HBs6bguRh6LjZ4LhY8l0DPJQbPWoLnUui51OC5VPBcBj2XGTxrC57Loedyg+dywXMF9Fxh8KwjeK6EnisNnisFz1XQc5XBs67guRp6rjZ4rhY810DPNQbPeoLnWui51uC5VvBcBz3XGTzrC57roed6g+d6wXMD9Nxg8GwgeG6EnhsNnhsFz03Qc5PBs6HguRl6bjZ4bhY8t0DPLQbPRoLnVui51eC5VfDcBj23GTwbC57boed2g+d2wXMH9Nxh8GwieO6EnjsNnjsFz13Qc5fBs6nguRt67jZ47hY890DPPQbPZoLnXui51+C5V/DcBz33GTybC577oed+g+d+wfMA9Dxg8GwheB6EngcNngcFz0PQ85DBs6XgeRh6HjZ4HhY8j0DPIwbPVoLnUeh51OB5VPA8Bj2PGTxbC57Hoedxg+dxwfN96Pm+wbON4HkCep4weJ4QPD+Anh8YPNsKnieh50mD50nB80Po+aHBs53geQp6njJ4nhI8P4KeHxk82wuep6HnaYPnacHzY+j5scGzg+B5BnqeMXieETw/gZ6fGDw7Cp5noedZg+dZwfNT6PmpwbOT4HkOep4zeJ4TPD+Dnp8ZPDsLnueh53mD53nB83Po+bnBs4vgeQF6XjB4XhA8v4CeXxg8uwqeF6HnRYPnRcHzS+j5pcGzm+B5CXpeMnheEjy/gp5fGTy7C56Xoedlg+dlwfNr6Pm1wbOH4HkFel4xeF4RPL+Bnt8YPHsKnleh51WD51XB81vo+a3Bs5fgeQ16XjN4XhM8v4Oe3xk8ewue16HndYPndcHzBvS8YfDsI3jehJ43DZ43Bc9b0POWwbOv4Hkbet42eN4WPL+Hnt8bPPsJnneg5x2D5x3B8wfo+YPBs7/geRd63jV43hU8f4SePxo8Bwie96DnPYPnPcHzJ+j5k8FzoOB5H3reN3jeFzx/hp4/GzwHCZ4PoOcDg+cDwfMh9Hxo8BwseD6Cno8Mno8Ez1+g5y8GzyGC52Po+djg+Vjw/BV6/mrwHCp4PoGeTwyeTwTP36DnbwbPYYLnU+j51OD5VPB8Bj2fGTyHC57Poedzg+dzwfN36Pm7wXOE4PkCer4weL4QPP+Ann8YPEcKni+h50uD50vB80/o+afBc5Tg+Qp6vjJ4vhI8/4Kefxk8Rwuer6Hna4Pna8Hzb+j5t8FzjOD5Bnq+MXi+ETz/gZ7/GDzHCp5voedbg+dbwfNf6PmvwXOc4PkOer4zeL4TPN8ryDz/exeq53jBM0JB5hmhYOieYbfDayNCz4gGzwmCZyToGcngGUnwjAw9Ixs8JwqeUaBnFINnFMEzKvSMavCcJHhGg57RDJ7RBM/o0DO6wXOy4BkDesYweMYQPGNCz5gGzymCZyzoGcvgGUvwjA09Yxs8pwqecaBnHINnHMEzLvSMa/CcJnjGg57xDJ7xBM/40DO+wXO64JkAeiYweCYQPBNCz4QGzxmCZyLomcjgmUjwTAw9Exs8ZwqeSaBnEoNnEsEzKfRMavCcJXgmg57JDJ7JBM/k0DO5wXO24JkCeqYweKYQPFNCz5QGzzmCZyromcrgmUrwTA09Uxs85wqeaaBnGoNnGsEzLfRMa/CcJ3img57pDJ7pBM8AegYGz/mCZ3romd7gmV7wzAA9Mxg8FwieGaFnRoNnRsEzE/TMZPBcKHhmhp6ZDZ6ZBc8s0DOLwXOR4JkVemY1eGYVPLNBz2wGz8WCZ3bomd3gmV3wzAE9cxg8lwieOaFnToNnTsEzF/TMZfBcKnjmhp65DZ65Bc880DOPwXOZ4JkXeuY1eOYVPPNBz3wGz+WCZ37omd/gmV/wLAA9Cxg8VwieBaFnQYNnQcGzEPQsZPBcKXgWhp6FDZ6FBc8i0LOIwXOV4FkUehY1eBYVPItBz2IGz9WCZ3HoWdzgWVzwLAE9Sxg81wieJaFnSYNnScGzFPQsZfBcK3iWhp6lDZ6lBc8y0LOMwXOd4FkWepY1eJYVPMtBz3IGz/WCZ3noWd7gWV7wrAA9Kxg8NwieFaFnRYNnRcGzEvSsZPDcKHhWhp6VDZ6VBc8q0LOKwXOT4FkVelY1eFYVPKtBz2oGz82CZ3XoWd3gWV3wrAE9axg8twieNaFnTYNnTcGzFvSsZfDcKnjWhp61DZ61Bc860LOOwXOb4FkXetY1eNYVPOtBz3oGz+2CZ33oWd/gWV/wbAA9Gxg8dwieDaFnQ4NnQ8GzEfRsZPDcKXg2hp6NDZ6NBc8m0LOJwXOX4NkUejY1eDYVPJtBz2YGz92CZ3Po2dzg2VzwbAE9Wxg89wieLaFnS4NnS8GzFfRsZfDcK3i2hp6tDZ6tBc820LONwXOf4NkWerY1eLYVPNtBz3YGz/2CZ3vo2d7g2V7w7AA9Oxg8DwieHaFnR4NnR8GzE/TsZPA8KHh2hp6dDZ6dBc8u0LOLwfOQ4NkVenY1eHYVPLtBz24Gz8OCZ3fo2d3g2V3w7AE9exg8jwiePaFnT4NnT8GzF/TsZfA8Knj2hp69DZ69Bc8+0LOPwfOY4NkXevY1ePYVPPtBz34Gz+OCZ3/o2d/g2V/wHAA9Bxg83xc8B0LPgQbPgYLnIOg5yOB5QvAcDD0HGzwHC55DoOcQg+cHgudQ6DnU4DlU8BwGPYcZPE8KnsOh53CD53DBcwT0HGHw/FDwHAk9Rxo8Rwqeo6DnKIPnKcFzNPQcbfAcLXiOgZ5jDJ4fCZ5joedYg+dYwXMc9Bxn8DwteI6HnuMNnuMFzwnQc4LB82PBcyL0nGjwnCh4ToKekwyeZwTPydBzssFzsuA5BXpOMXh+InhOhZ5TDZ5TBc9p0HOawfOs4Dkdek43eE4XPGdAzxkGz08Fz5nQc6bBc6bgOQt6zjJ4nhM8Z0PP2QbP2YLnHOg5x+D5meA5F3rONXjOFTznQc95Bs/zgud86Dnf4Dlf8FwAPRcYPD8XPBdCz4UGz4WC5yLoucjgeUHwXAw9Fxs8FwueS6DnEoPnF4LnUui51OC5VPBcBj2XGTwvCp7Loedyg+dywXMF9Fxh8PxS8FwJPVcaPFcKnqug5yqD5yXBczX0XG3wXC14roGeawyeXwmea6HnWoPnWsFzHfRcZ/C8LHiuh57rDZ7rBc8N0HODwfNrwXMj9Nxo8NwoeG6CnpsMnlcEz83Qc7PBc7PguQV6bjF4fiN4boWeWw2eWwXPbdBzm8HzquC5HXpuN3huFzx3QM8dBs9vBc+d0HOnwXOn4LkLeu4yeF4TPHdDz90Gz92C5x7oucfg+Z3guRd67jV47hU890HPfQbP64Lnfui53+C5X/A8AD0PGDxvCJ4HoedBg+dBwfMQ9Dxk8LwpeB6GnocNnocFzyPQ84jB85bgeRR6HjV4HhU8j0HP/x/rdBV1Zdl3bVy6u7u7u+Giu7u7u0VEREREREQERERERERERES6u7u7u7u/79m7363beax5bc9zHf/xG2MtN3ieETxXQM8VBs8VgudK6LnS4HlW8FwFPVcZPFcJnquh52qD5znBcw30XGPwXCN4roWeaw2e5wXPddBzncFzneC5HnquN3heEDw3QM8NBs8NgudG6LnR4HlR8NwEPTcZPDcJnpuh52aD5yXBcwv03GLw3CJ4boWeWw2elwXPbdBzm8Fzm+C5HXpuN3heETx3QM8dBs8dgudO6LnT4HlV8NwFPXcZPHcJnruh526D5zXBcw/03GPw3CN47oWeew2e1wXPfdBzn8Fzn+C5H3ruN3jeEDwPQM8DBs8DgudB6HnQ4HlT8DwEPQ8ZPA8Jnoeh52GD5y3B8wj0PGLwPCJ4HoWeRw2etwXPY9DzmMHzmOB5HHoeN3jeETxPQM8TBs8TgudJ6HnS4HlX8DwFPU8ZPE8Jnqeh52mD5z3B8wz0PGPwPCN4noWeZw2e9wXPc9DznMHznOB5HnqeN3g+EDwvQM8LBs8LgudF6HnR4PlQ8LwEPS8ZPC8Jnpeh52WD5yPB8wr0vGLwvCJ4XoWeVw2ejwXPa9DzmsHzmuB5HXpeN3g+ETxvQM8bBs8bgudN6HnT4PlU8LwFPW8ZPG8Jnreh522D5zPB8w70vGPwvCN43oWedw2ezwXPe9DznsHznuB5H3reN3i+EDwfQM8HBs8HgudD6PnQ4PlS8HwEPR8ZPB8Jno+h52OD5yvB8wn0fGLwfCJ4PoWeTw2erwXPZ9DzmcHzmeD5HHo+N3i+ETxfQM8XBs8XgudL6PnS4PlW8HwFPV8ZPF8Jnq+h52uHZ6L/fueb/3ZntHfv+v2fO//3LnM4dyrt8LZv/9ud8d69Pf9/7nz7H+4M54vwTvB8Bz3fGTzfCZ7vFWae/3sXquf//2v+5zsjFGaeEQqH7hm2Hd42IvSMaPCMIHhGgp6RDJ6RBM/I0DOywTOi4BkFekYxeEYRPKNCz6gGz0iCZzToGc3gGU3wjA49oxs8IwueMaBnDINnDMEzJvSMafCMInjGgp6xDJ6xBM/Y0DO2wTOq4BkHesYxeMYRPONCz7gGz2iCZzzoGc/gGU/wjA894xs8owueCaBnAoNnAsEzIfRMaPCMIXgmgp6JDJ6JBM/E0DOxwTOm4JkEeiYxeCYRPJNCz6QGz1iCZzLomczgmUzwTA49kxs8YwueKaBnCoNnCsEzJfRMafCMI3imgp6pDJ6pBM/U0DO1wTOu4JkGeqYxeKYRPNNCz7QGz3iCZzromc7gmU7wTA890xs84wueGaBnBoNnBsEzI/TMaPBMIHhmgp6ZDJ6ZBM/M0DOzwTOh4JkFemYxeGYRPLNCz6wGz0SCZzbomc3gmU3wzA49sxs8EwueOaBnDoNnDsEzJ/TMafBMInjmgp65DJ65BM/c0DO3wTOp4JkHeuYxeOYRPPNCz7wGz2SCZz7omc/gmU/wzA898xs8kwueBaBnAYNnAcGzIPQsaPBMIXgWgp6FDJ6FBM/C0LOwwTOl4FkEehYxeBYRPItCz6IGz1SCZzHoWczgWUzwLA49ixs8UwueJaBnCYNnCcGzJPQsafBMI3iWgp6lDJ6lBM/S0LO0wTOt4FkGepYxeJYRPMtCz7IGz3SCZznoWc7gWU7wDKBnYPBML3iWh57lDZ7lBc8K0LOCwTOD4FkRelY0eFYUPCtBz0oGz4yCZ2XoWdngWVnwrAI9qxg8MwmeVaFnVYNnVcGzGvSsZvDMLHhWh57VDZ7VBc8a0LOGwTOL4FkTetY0eNYUPGtBz1oGz6yCZ23oWdvgWVvwrAM96xg8swmedaFnXYNnXcGzHvSsZ/DMLnjWh571DZ71Bc8G0LOBwTOH4NkQejY0eDYUPBtBz0YGz5yCZ2Po2djg2VjwbAI9mxg8cwmeTaFnU4NnU8GzGfRsZvDMLXg2h57NDZ7NBc8W0LOFwTOP4NkSerY0eLYUPFtBz1YGz7yCZ2vo2drg2VrwbAM92xg88wmebaFnW4NnW8GzHfRsZ/DML3i2h57tDZ7tBc8O0LODwbOA4NkRenY0eHYUPDtBz04Gz4KCZ2fo2dng2Vnw7AI9uxg8CwmeXaFnV4NnV8GzG/TsZvAsLHh2h57dDZ7dBc8e0LOHwbOI4NkTevY0ePYUPHtBz14Gz6KCZ2/o2dvg2Vvw7AM9+xg8iwmefaFnX4NnX8GzH/TsZ/AsLnj2h579DZ79Bc8B0HOAwbOE4DkQeg40eA4UPAdBz0EGz5KC52DoOdjgOVjwHAI9hxg8SwmeQ6HnUIPnUMHzfej5vsGztOA5DHoOM3gOEzw/gJ4fGDzLCJ7Doedwg+dwwfND6PmhwbOs4DkCeo4weI4QPD+Cnh8ZPMsJniOh50iD50jB82Po+bHBMxA8R0HPUQbPUYLnJ9DzE4NnecFzNPQcbfAcLXh+Cj0/NXhWEDzHQM8xBs8xgudn0PMzg2dFwXMs9Bxr8BwreH4OPT83eFYSPMdBz3EGz3GC5xfQ8wuDZ2XBczz0HG/wHC94fgk9vzR4VhE8J0DPCQbPCYLnV9DzK4NnVcFzIvScaPCcKHh+DT2/NnhWEzwnQc9JBs9Jguc30PMbg2d1wXMy9Jxs8JwseH4LPb81eNYQPKdAzykGzymC51ToOdXgWVPwnAY9pxk8pwme30HP7wyetQTP6dBzusFzuuD5PfT83uBZW/CcAT1nGDxnCJ4/QM8fDJ51BM+Z0HOmwXOm4Pkj9PzR4FlX8JwFPWcZPGcJnj9Bz58MnvUEz9nQc7bBc7bg+TP0/NngWV/wnAM95xg85wiev0DPXwyeDQTPudBzrsFzruD5K/T81eDZUPCcBz3nGTznCZ6/Qc/fDJ6NBM/50HO+wXO+4Pk79Pzd4NlY8FwAPRcYPBcInn9Azz8Mnk0Ez4XQc6HBc6Hg+Sf0/NPg2VTwXAQ9Fxk8Fwmef0HPvwyezQTPxdBzscFzseD5N/T82+DZXPBcAj2XGDyXCJ7/QM9/DJ4tBM+l0HOpwXOp4Pkv9PzX4NlS8FwGPZcZPJcJnsuh53KDZyvBcwX0XGHwXCF4roSeKw2erQXPVdBzlcFzleC5GnquNni2ETzXQM81Bs81guda6LnW4NlW8FwHPdcZPNcJnuuh53qDZzvBcwP03GDw3CB4boSeGw2e7QXPTdBzk8Fzk+C5GXpuNnh2EDy3QM8tBs8tgudW6LnV4NlR8NwGPbcZPLcJntuh53aDZyfBcwf03GHw3CF47oSeOw2enQXPXdBzl8Fzl+C5G3ruNnh2ETz3QM89Bs89gude6LnX4NlV8NwHPfcZPPcJnvuh536DZzfB8wD0PGDwPCB4HoSeBw2e3QXPQ9DzkMHzkOB5GHoeNnj2EDyPQM8jBs8jgudR6HnU4NlT8DwGPY8ZPI8Jnseh53GDZy/B8wT0PGHwPCF4noSeJw2evQXPU9DzlMHzlOB5GnqeNnj2ETzPQM8zBs8zgudZ6HnW4NlX8DwHPc8ZPM8Jnueh53mDZz/B8wL0vGDwvCB4XoSeFw2e/QXPS9DzksHzkuB5GXpeNngOEDyvQM8rBs8rgudV6HnV4DlQ8LwGPa8ZPK8Jnteh53WD5yDB8wb0vGHwvCF43oSeNw2egwXPW9DzlsHzluB5G3reNngOETzvQM87Bs87gudd6HnX4DlU8LwHPe8ZPO8Jnveh532D5/uC5wPo+cDg+UDwfAg9Hxo8hwmej6DnI4PnI8HzMfR8bPD8QPB8Aj2fGDyfCJ5PoedTg+dwwfMZ9Hxm8HwmeD6Hns8Nnh8Kni+g5wuD5wvB8yX0fGnwHCF4voKerwyerwTP19DztcHzI8HzDfR8Y/B8I3i+hZ5vDZ4jBc930POdwfOd4PleEeb5v3ehen4seEYowjwjFAndM2w7vG1E6BnR4DlK8IwEPSMZPCMJnpGhZ2SD5yeCZxToGcXgGUXwjAo9oxo8Rwue0aBnNINnNMEzOvSMbvD8VPCMAT1jGDxjCJ4xoWdMg+cYwTMW9Ixl8IwleMaGnrENnp8JnnGgZxyDZxzBMy70jGvwHCt4xoOe8Qye8QTP+NAzvsHzc8EzAfRMYPBMIHgmhJ4JDZ7jBM9E0DORwTOR4JkYeiY2eH4heCaBnkkMnkkEz6TQM6nBc7zgmQx6JjN4JhM8k0PP5AbPLwXPFNAzhcEzheCZEnqmNHhOEDxTQc9UBs9Ugmdq6Jna4PmV4JkGeqYxeKYRPNNCz7QGz4mCZzromc7gmU7wTA890xs8vxY8M0DPDAbPDIJnRuiZ0eA5SfDMBD0zGTwzCZ6ZoWdmg+c3gmcW6JnF4JlF8MwKPbMaPCcLntmgZzaDZzbBMzv0zG7w/FbwzAE9cxg8cwieOaFnToPnFMEzF/TMZfDMJXjmhp65DZ5TBc880DOPwTOP4JkXeuY1eE4TPPNBz3wGz3yCZ37omd/g+Z3gWQB6FjB4FhA8C0LPggbP6YJnIehZyOBZSPAsDD0LGzy/FzyLQM8iBs8igmdR6FnU4DlD8CwGPYsZPIsJnsWhZ3GD5w+CZwnoWcLgWULwLAk9Sxo8ZwqepaBnKYNnKcGzNPQsbfD8UfAsAz3LGDzLCJ5loWdZg+cswbMc9Cxn8CwneAbQMzB4/iR4loee5Q2e5QXPCtCzgsFztuBZEXpWNHhWFDwrQc9KBs+fBc/K0LOywbOy4FkFelYxeM4RPKtCz6oGz6qCZzXoWc3g+YvgWR16Vjd4Vhc8a0DPGgbPuYJnTehZ0+BZU/CsBT1rGTx/FTxrQ8/aBs/agmcd6FnH4DlP8KwLPesaPOsKnvWgZz2D52+CZ33oWd/gWV/wbAA9Gxg85wueDaFnQ4NnQ8GzEfRsZPD8XfBsDD0bGzwbC55NoGcTg+cCwbMp9Gxq8GwqeDaDns0Mnn8Ins2hZ3ODZ3PBswX0bGHwXCh4toSeLQ2eLQXPVtCzlcHzT8GzNfRsbfBsLXi2gZ5tDJ6LBM+20LOtwbOt4NkOerYzeP4leLaHnu0Nnu0Fzw7Qs4PBc7Hg2RF6djR4dhQ8O0HPTgbPvwXPztCzs8Gzs+DZBXp2MXguETy7Qs+uBs+ugmc36NnN4PmP4NkdenY3eHYXPHtAzx4Gz6WCZ0/o2dPg2VPw7AU9exk8/xU8e0PP3gbP3oJnH+jZx+C5TPDsCz37Gjz7Cp79oGc/g+dywbM/9Oxv8OwveA6AngMMnisEz4HQc6DBc6DgOQh6DjJ4rhQ8B0PPwQbPwYLnEOg5xOC5SvAcCj2HGjyHCp7vQ8/3DZ6rBc9h0HOYwXOY4PkB9PzA4LlG8BwOPYcbPIcLnh9Czw8NnmsFzxHQc4TBc4Tg+RH0/MjguU7wHAk9Rxo8RwqeH0PPjw2e6wXPUdBzlMFzlOD5CfT8xOC5QfAcDT1HGzxHC56fQs9PDZ4bBc8x0HOMwXOM4PkZ9PzM4LlJ8BwLPccaPMcKnp9Dz88NnpsFz3HQc5zBc5zg+QX0/MLguUXwHA89xxs8xwueX0LPLw2eWwXPCdBzgsFzguD5FfT8yuC5TfCcCD0nGjwnCp5fQ8+vDZ7bBc9J0HOSwXOS4PkN9PzG4LlD8JwMPScbPCcLnt9Cz28NnjsFzynQc4rBc4rgORV6TjV47hI8p0HPaQbPaYLnd9DzO4PnbsFzOvScbvCcLnh+Dz2/N3juETxnQM8ZBs8ZgucP0PMHg+dewXMm9Jxp8JwpeP4IPX80eO4TPGdBz1kGz1mC50/Q8yeD537Bczb0nG3wnC14/gw9fzZ4HhA850DPOQbPOYLnL9DzF4PnQcFzLvSca/CcK3j+Cj1/NXgeEjznQc95Bs95gudv0PM3g+dhwXM+9Jxv8JwveP4OPX83eB4RPBdAzwUGzwWC5x/Q8w+D51HBcyH0XGjwXCh4/gk9/zR4HhM8F0HPRQbPRYLnX9DzL4PnccFzMfRcbPBcLHj+DT3/NnieEDyXQM8lBs8lguc/0PMfg+dJwXMp9Fxq8FwqeP4LPf81eJ4SPJdBz2UGz2WC53LoudzgeVrwXAE9Vxg8VwieK6HnSoPnGcFzFfRcZfBcJXiuhp6rDZ5nBc810HONwXON4LkWeq41eJ4TPNdBz3UGz3WC53roud7geV7w3AA9Nxg8NwieG6HnRoPnBcFzE/TcZPDcJHhuhp6bDZ4XBc8t0HOLwXOL4LkVem41eF4SPLdBz20Gz22C53boud3geVnw3AE9dxg8dwieO6HnToPnFcFzF/TcZfDcJXjuhp67DZ5XBc890HOPwXOP4LkXeu41eF4TPPdBz30Gz32C537oud/geV3wPAA9Dxg8DwieB6HnQYPnDcHzEPQ8ZPA8JHgehp6HDZ43Bc8j0POIwfOI4HkUeh41eN4SPI9Bz2MGz2OC53HoedzgeVvwPAE9Txg8TwieJ6HnSYPnHcHzFPQ8ZfA8JXiehp6nDZ53Bc8z0POMwfOM4HkWep41eN4TPM9Bz3MGz3OC53noed7geV/wvAA9Lxg8LwieF6HnRYPnA8HzEvS8ZPC8JHhehp6XDZ4PBc8r0POKwfOK4HkVel41eD4SPK9Bz2sGz2uC53Xoed3g+VjwvAE9bxg8bwieN6HnTYPnE8HzFvS8ZfC8JXjehp63DZ5PBc870POOwfOO4HkXet41eD4TPO9Bz3sGz3uC533oed/g+VzwfAA9Hxg8HwieD6HnQ4PnC8HzEfR8ZPB8JHg+hp6PDZ4vBc8n0POJwfOJ4PkUej41eL4SPJ9Bz2cGz2eC53Po+dzg+VrwfAE9Xxg8XwieL6HnS4PnG8HzFfR8ZfB8JXi+hp6vDZ5vBc830PONwfON4PkWer41eL4TPN9Bz3cGz3eC53tFmef/3oXq+V6S/35nhKLMM0LR0D3DtsPbRoSeEQ2eEQTPSNAzksEzkuAZGXpGNnhGFDyjQM8oBs8ogmdU6BnV4BlJ8IwGPaMZPKMJntGhZ3SDZ2TBMwb0jGHwjCF4xoSeMQ2eUQTPWNAzlsEzluAZG3rGNnhGFTzjQM84Bs84gmdc6BnX4BlN8IwHPeMZPOMJnvGhZ3yDZ3TBMwH0TGDwTCB4JoSeCQ2eMQTPRNAzkcEzkeCZGHomNnjGFDyTQM8kBs8kgmdS6JnU4BlL8EwGPZMZPJMJnsmhZ3KDZ2zBMwX0TGHwTCF4poSeKQ2ecQTPVNAzlcEzleCZGnqmNnjGFTzTQM80Bs80gmda6JnW4BlP8EwHPdMZPNMJnumhZ3qDZ3zBMwP0zGDwzCB4ZoSeGQ2eCQTPTNAzk8Ezk+CZGXpmNngmFDyzQM8sBs8sgmdW6JnV4JlI8MwGPbMZPLMJntmhZ3aDZ2LBMwf0zGHwzCF45oSeOQ2eSQTPXNAzl8Ezl+CZG3rmNngmFTzzQM88Bs88gmde6JnX4JlM8MwHPfMZPPMJnvmhZ36DZ3LBswD0LGDwLCB4FoSeBQ2eKQTPQtCzkMGzkOBZGHoWNnimFDyLQM8iBs8igmdR6FnU4JlK8CwGPYsZPIsJnsWhZ3GDZ2rBswT0LGHwLCF4loSeJQ2eaQTPUtCzlMGzlOBZGnqWNnimFTzLQM8yBs8ygmdZ6FnW4JlO8CwHPcsZPMsJngH0DAye6QXP8tCzvMGzvOBZAXpWMHhmEDwrQs+KBs+Kgmcl6FnJ4JlR8KwMPSsbPCsLnlWgZxWDZybBsyr0rGrwrCp4VoOe1QyemQXP6tCzusGzuuBZA3rWMHhmETxrQs+aBs+agmct6FnL4JlV8KwNPWsbPGsLnnWgZx2DZzbBsy70rGvwrCt41oOe9Qye2QXP+tCzvsGzvuDZAHo2MHjmEDwbQs+GBs+Ggmcj6NnI4JlT8GwMPRsbPBsLnk2gZxODZy7Bsyn0bGrwbCp4NoOezQyeuQXP5tCzucGzueDZAnq2MHjmETxbQs+WBs+Wgmcr6NnK4JlX8GwNPVsbPFsLnm2gZxuDZz7Bsy30bGvwbCt4toOe7Qye+QXP9tCzvcGzveDZAXp2MHgWEDw7Qs+OBs+Ogmcn6NnJ4FlQ8OwMPTsbPDsLnl2gZxeDZyHBsyv07Grw7Cp4doOe3QyehQXP7tCzu8Gzu+DZA3r2MHgWETx7Qs+eBs+egmcv6NnL4FlU8OwNPXsbPHsLnn2gZx+DZzHBsy/07Gvw7Ct49oOe/QyexQXP/tCzv8Gzv+A5AHoOMHiWEDwHQs+BBs+Bgucg6DnI4FlS8BwMPQcbPAcLnkOg5xCDZynBcyj0HGrwHCp4vg893zd4lhY8h0HPYQbPYYLnB9DzA4NnGcFzOPQcbvAcLnh+CD0/NHiWFTxHQM8RBs8RgudH0PMjg2c5wXMk9Bxp8BwpeH4MPT82eAaC5yjoOcrgOUrw/AR6fmLwLC94joaeow2eowXPT6HnpwbPCoLnGOg5xuA5RvD8DHp+ZvCsKHiOhZ5jDZ5jBc/PoefnBs9Kguc46DnO4DlO8PwCen5h8KwseI6HnuMNnuMFzy+h55cGzyqC5wToOcHgOUHw/Ap6fmXwrCp4ToSeEw2eEwXPr6Hn1wbPaoLnJOg5yeA5SfD8Bnp+Y/CsLnhOhp6TDZ6TBc9voee3Bs8agucU6DnF4DlF8JwKPacaPGsKntOg5zSD5zTB8zvo+Z3Bs5bgOR16Tjd4Thc8v4ee3xs8awueM6DnDIPnDMHzB+j5g8GzjuA5E3rONHjOFDx/hJ4/GjzrCp6zoOcsg+cswfMn6PmTwbOe4Dkbes42eM4WPH+Gnj8bPOsLnnOg5xyD5xzB8xfo+YvBs4HgORd6zjV4zhU8f4Wevxo8Gwqe86DnPIPnPMHzN+j5m8GzkeA5H3rON3jOFzx/h56/GzwbC54LoOcCg+cCwfMP6PmHwbOJ4LkQei40eC4UPP+Enn8aPJsKnoug5yKD5yLB8y/o+ZfBs5nguRh6LjZ4LhY8/4aefxs8mwueS6DnEoPnEsHzH+j5j8GzheC5FHouNXguFTz/hZ7/GjxbCp7LoOcyg+cywXM59Fxu8GwleK6AnisMnisEz5XQc6XBs7XguQp6rjJ4rhI8V0PP1QbPNoLnGui5xuC5RvBcCz3XGjzbCp7roOc6g+c6wXM99Fxv8GwneG6AnhsMnhsEz43Qc6PBs73guQl6bjJ4bhI8N0PPzQbPDoLnFui5xeC5RfDcCj23Gjw7Cp7boOc2g+c2wXM79Nxu8OwkeO6AnjsMnjsEz53Qc6fBs7PguQt67jJ47hI8d0PP3QbPLoLnHui5x+C5R/DcCz33Gjy7Cp77oOc+g+c+wXM/9Nxv8OwmeB6AngcMngcEz4PQ86DBs7vgeQh6HjJ4HhI8D0PPwwbPHoLnEeh5xOB5RPA8Cj2PGjx7Cp7HoOcxg+cxwfM49Dxu8OwleJ6AnicMnicEz5PQ86TBs7fgeQp6njJ4nhI8T0PP0wbPPoLnGeh5xuB5RvA8Cz3PGjz7Cp7noOc5g+c5wfM89Dxv8OwneF6AnhcMnhcEz4vQ86LBs7/geQl6XjJ4XhI8L0PPywbPAYLnFeh5xeB5RfC8Cj2vGjwHCp7XoOc1g+c1wfM69Lxu8BwkeN6AnjcMnjcEz5vQ86bBc7DgeQt63jJ43hI8b0PP2wbPIYLnHeh5x+B5R/C8Cz3vGjyHCp73oOc9g+c9wfM+9Lxv8Hxf8HwAPR8YPB8Ing+h50OD5zDB8xH0fGTwfCR4Poaejw2eHwieT6DnE4PnE8HzKfR8avAcLng+g57PDJ7PBM/n0PO5wfNDwfMF9Hxh8HwheL6Eni8NniMEz1fQ85XB85Xg+Rp6vjZ4fiR4voGebwyebwTPt9DzrcFzpOD5Dnq+M3i+EzzfK8Y8//cuVM+PBc8IxZhnhGKhe4Zth7eNCD0jGjxHCZ6RoGckg2ckwTMy9Ixs8PxE8IwCPaMYPKMInlGhZ1SD52jBMxr0jGbwjCZ4Roee0Q2enwqeMaBnDINnDMEzJvSMafAcI3jGgp6xDJ6xBM/Y0DO2wfMzwTMO9Ixj8IwjeMaFnnENnmMFz3jQM57BM57gGR96xjd4fi54JoCeCQyeCQTPhNAzocFznOCZCHomMngmEjwTQ8/EBs8vBM8k0DOJwTOJ4JkUeiY1eI4XPJNBz2QGz2SCZ3Lomdzg+aXgmQJ6pjB4phA8U0LPlAbPCYJnKuiZyuCZSvBMDT1TGzy/EjzTQM80Bs80gmda6JnW4DlR8EwHPdMZPNMJnumhZ3qD59eCZwbomcHgmUHwzAg9Mxo8JwmemaBnJoNnJsEzM/TMbPD8RvDMAj2zGDyzCJ5ZoWdWg+dkwTMb9Mxm8MwmeGaHntkNnt8KnjmgZw6DZw7BMyf0zGnwnCJ45oKeuQyeuQTP3NAzt8FzquCZB3rmMXjmETzzQs+8Bs9pgmc+6JnP4JlP8MwPPfMbPL8TPAtAzwIGzwKCZ0HoWdDgOV3wLAQ9Cxk8CwmehaFnYYPn94JnEehZxOBZRPAsCj2LGjxnCJ7FoGcxg2cxwbM49Cxu8PxB8CwBPUsYPEsIniWhZ0mD50zBsxT0LGXwLCV4loaepQ2ePwqeZaBnGYNnGcGzLPQsa/CcJXiWg57lDJ7lBM8AegYGz58Ez/LQs7zBs7zgWQF6VjB4zhY8K0LPigbPioJnJehZyeD5s+BZGXpWNnhWFjyrQM8qBs85gmdV6FnV4FlV8KwGPasZPH8RPKtDz+oGz+qCZw3oWcPgOVfwrAk9axo8awqetaBnLYPnr4JnbehZ2+BZW/CsAz3rGDznCZ51oWddg2ddwbMe9Kxn8PxN8KwPPesbPOsLng2gZwOD53zBsyH0bGjwbCh4NoKejQyevwuejaFnY4NnY8GzCfRsYvBcIHg2hZ5NDZ5NBc9m0LOZwfMPwbM59Gxu8GwueLaAni0MngsFz5bQs6XBs6Xg2Qp6tjJ4/il4toaerQ2erQXPNtCzjcFzkeDZFnq2NXi2FTzbQc92Bs+/BM/20LO9wbO94NkBenYweC4WPDtCz44Gz46CZyfo2cng+bfg2Rl6djZ4dhY8u0DPLgbPJYJnV+jZ1eDZVfDsBj27GTz/ETy7Q8/uBs/ugmcP6NnD4LlU8OwJPXsaPHsKnr2gZy+D57+CZ2/o2dvg2Vvw7AM9+xg8lwmefaFnX4NnX8GzH/TsZ/BcLnj2h579DZ79Bc8B0HOAwXOF4DkQeg40eA4UPAdBz0EGz5WC52DoOdjgOVjwHAI9hxg8VwmeQ6HnUIPnUMHzfej5vsFzteA5DHoOM3gOEzw/gJ4fGDzXCJ7Doedwg+dwwfND6PmhwXOt4DkCeo4weI4QPD+Cnh8ZPNcJniOh50iD50jB82Po+bHBc73gOQp6jjJ4jhI8P4Genxg8Nwieo6HnaIPnaMHzU+j5qcFzo+A5BnqOMXiOETw/g56fGTw3CZ5joedYg+dYwfNz6Pm5wXOz4DkOeo4zeI4TPL+Anl8YPLcInuOh53iD53jB80vo+aXBc6vgOQF6TjB4ThA8v4KeXxk8twmeE6HnRIPnRMHza+j5tcFzu+A5CXpOMnhOEjy/gZ7fGDx3CJ6Toedkg+dkwfNb6PmtwXOn4DkFek4xeE4RPKdCz6kGz12C5zToOc3gOU3w/A56fmfw3C14Toee0w2e0wXP76Hn9wbPPYLnDOg5w+A5Q/D8AXr+YPDcK3jOhJ4zDZ4zBc8foeePBs99gucs6DnL4DlL8PwJev5k8NwveM6GnrMNnrMFz5+h588GzwOC5xzoOcfgOUfw/AV6/mLwPCh4zoWecw2ecwXPX6HnrwbPQ4LnPOg5z+A5T/D8DXr+ZvA8LHjOh57zDZ7zBc/foefvBs8jgucC6LnA4LlA8PwDev5h8DwqeC6EngsNngsFzz+h558Gz2OC5yLoucjguUjw/At6/mXwPC54Loaeiw2eiwXPv6Hn3wbPE4LnEui5xOC5RPD8B3r+Y/A8KXguhZ5LDZ5LBc9/oee/Bs9Tgucy6LnM4LlM8FwOPZcbPE8Lniug5wqD5wrBcyX0XGnwPCN4roKeqwyeqwTP1dBztcHzrOC5BnquMXiuETzXQs+1Bs9zguc66LnO4LlO8FwPPdcbPM8Lnhug5waD5wbBcyP03GjwvCB4boKemwyemwTPzdBzs8HzouC5BXpuMXhuETy3Qs+tBs9Lguc26LnN4LlN8NwOPbcbPC8Lnjug5w6D5w7Bcyf03GnwvCJ47oKeuwyeuwTP3dBzt8HzquC5B3ruMXjuETz3Qs+9Bs9rguc+6LnP4LlP8NwPPfcbPK8Lngeg5wGD5wHB8yD0PGjwvCF4HoKehwyehwTPw9DzsMHzpuB5BHoeMXgeETyPQs+jBs9bgucx6HnM4HlM8DwOPY8bPG8Lnieg5wmD5wnB8yT0PGnwvCN4noKepwyepwTP09DztMHzruB5BnqeMXieETzPQs+zBs97guc56HnO4HlO8DwPPc8bPO8Lnheg5wWD5wXB8yL0vGjwfCB4XoKelwyelwTPy9DzssHzoeB5BXpeMXheETyvQs+rBs9Hguc16HnN4HlN8LwOPa8bPB8Lnjeg5w2D5w3B8yb0vGnwfCJ43oKetwyetwTP29DztsHzqeB5B3reMXjeETzvQs+7Bs9nguc96HnP4HlP8LwPPe8bPJ8Lng+g5wOD5wPB8yH0fGjwfCF4PoKejwyejwTPx9DzscHzpeD5BHo+MXg+ETyfQs+nBs9Xgucz6PnM4PlM8HwOPZ8bPF8Lni+g5wuD5wvB8yX0fGnwfC/mf7/zVbH/+Lurdv2fO//3LkU4dyrt8Lav/+OdEYZO/T93vv4Pd4b3kxEEzzfQ843B843g+RZ6vjV4RhQ830HPdwbPd4Lne8WZ5//eheoZSfCMUJx5RigeumfYdnjbiNAzosEzsuAZCXpGMnhGEjwjQ8/IBs8ogmcU6BnF4BlF8IwKPaMaPKMKntGgZzSDZzTBMzr0jG7wjCZ4xoCeMQyeMQTPmNAzpsEzuuAZC3rGMnjGEjxjQ8/YBs8Ygmcc6BnH4BlH8IwLPeMaPGMKnvGgZzyDZzzBMz70jG/wjCV4JoCeCQyeCQTPhNAzocEztuCZCHomMngmEjwTQ8/EBs84gmcS6JnE4JlE8EwKPZMaPOMKnsmgZzKDZzLBMzn0TG7wjCd4poCeKQyeKQTPlNAzpcEzvuCZCnqmMnimEjxTQ8/UBs8Egmca6JnG4JlG8EwLPdMaPBMKnumgZzqDZzrBMz30TG/wTCR4ZoCeGQyeGQTPjNAzo8EzseCZCXpmMnhmEjwzQ8/MBs8kgmcW6JnF4JlF8MwKPbMaPJMKntmgZzaDZzbBMzv0zG7wTCZ45oCeOQyeOQTPnNAzp8EzueCZC3rmMnjmEjxzQ8/cBs8Ugmce6JnH4JlH8MwLPfMaPFMKnvmgZz6DZz7BMz/0zG/wTCV4FoCeBQyeBQTPgtCzoMEzteBZCHoWMngWEjwLQ8/CBs80gmcR6FnE4FlE8CwKPYsaPNMKnsWgZzGDZzHBszj0LG7wTCd4loCeJQyeJQTPktCzpMEzveBZCnqWMniWEjxLQ8/SBs8MgmcZ6FnG4FlG8CwLPcsaPDMKnuWgZzmDZznBM4CegcEzk+BZHnqWN3iWFzwrQM8KBs/MgmdF6FnR4FlR8KwEPSsZPLMInpWhZ2WDZ2XBswr0rGLwzCp4VoWeVQ2eVQXPatCzmsEzm+BZHXpWN3hWFzxrQM8aBs/sgmdN6FnT4FlT8KwFPWsZPHMInrWhZ22DZ23Bsw70rGPwzCl41oWedQ2edQXPetCznsEzl+BZH3rWN3jWFzwbQM8GBs/cgmdD6NnQ4NlQ8GwEPRsZPPMIno2hZ2ODZ2PBswn0bGLwzCt4NoWeTQ2eTQXPZtCzmcEzn+DZHHo2N3g2FzxbQM8WBs/8gmdL6NnS4NlS8GwFPVsZPAsInq2hZ2uDZ2vBsw30bGPwLCh4toWebQ2ebQXPdtCzncGzkODZHnq2N3i2Fzw7QM8OBs/CgmdH6NnR4NlR8OwEPTsZPIsInp2hZ2eDZ2fBswv07GLwLCp4doWeXQ2eXQXPbtCzm8GzmODZHXp2N3h2Fzx7QM8eBs/igmdP6NnT4NlT8OwFPXsZPEsInr2hZ2+DZ2/Bsw/07GPwLCl49oWefQ2efQXPftCzn8GzlODZH3r2N3j2FzwHQM8BBs/SgudA6DnQ4DlQ8BwEPQcZPMsInoOh52CD52DBcwj0HGLwLCt4DoWeQw2eQwXP96Hn+wbPcoLnMOg5zOA5TPD8AHp+YPAMBM/h0HO4wXO44Pkh9PzQ4Fle8BwBPUcYPEcInh9Bz48MnhUEz5HQc6TBc6Tg+TH0/NjgWVHwHAU9Rxk8Rwmen0DPTwyelQTP0dBztMFztOD5KfT81OBZWfAcAz3HGDzHCJ6fQc/PDJ5VBM+x0HOswXOs4Pk59Pzc4FlV8BwHPccZPMcJnl9Azy8MntUEz/HQc7zBc7zg+SX0/NLgWV3wnAA9Jxg8JwieX0HPrwyeNQTPidBzosFzouD5NfT82uBZU/CcBD0nGTwnCZ7fQM9vDJ61BM/J0HOywXOy4Pkt9PzW4Flb8JwCPacYPKcInlOh51SDZx3Bcxr0nGbwnCZ4fgc9vzN41hU8p0PP6QbP6YLn99Dze4NnPcFzBvScYfCcIXj+AD1/MHjWFzxnQs+ZBs+ZgueP0PNHg2cDwXMW9Jxl8JwleP4EPX8yeDYUPGdDz9kGz9mC58/Q82eDZyPBcw70nGPwnCN4/gI9fzF4NhY850LPuQbPuYLnr9DzV4NnE8FzHvScZ/CcJ3j+Bj1/M3g2FTznQ8/5Bs/5gufv0PN3g2czwXMB9Fxg8FwgeP4BPf8weDYXPBdCz4UGz4WC55/Q80+DZwvBcxH0XGTwXCR4/gU9/zJ4thQ8F0PPxQbPxYLn39Dzb4NnK8FzCfRcYvBcInj+Az3/MXi2FjyXQs+lBs+lgue/0PNfg2cbwXMZ9Fxm8FwmeC6HnssNnm0FzxXQc4XBc4XguRJ6rjR4thM8V0HPVQbPVYLnaui52uDZXvBcAz3XGDzXCJ5roedag2cHwXMd9Fxn8FwneK6HnusNnh0Fzw3Qc4PBc4PguRF6bjR4dhI8N0HPTQbPTYLnZui52eDZWfDcAj23GDy3CJ5boedWg2cXwXMb9Nxm8NwmeG6HntsNnl0Fzx3Qc4fBc4fguRN67jR4dhM8d0HPXQbPXYLnbui52+DZXfDcAz33GDz3CJ57oedeg2cPwXMf9Nxn8NwneO6HnvsNnj0FzwPQ84DB84DgeRB6HjR49hI8D0HPQwbPQ4LnYeh52ODZW/A8Aj2PGDyPCJ5HoedRg2cfwfMY9Dxm8DwmeB6HnscNnn0FzxPQ84TB84TgeRJ6njR49hM8T0HPUwbPU4Lnaeh52uDZX/A8Az3PGDzPCJ5noedZg+cAwfMc9Dxn8DwneJ6HnucNngMFzwvQ84LB84LgeRF6XjR4DhI8L0HPSwbPS4LnZeh52eA5WPC8Aj2vGDyvCJ5XoedVg+cQwfMa9Lxm8LwmeF6HntcNnkMFzxvQ84bB84bgeRN63jR4vi943oKetwyetwTP29DztsFzmOB5B3reMXjeETzvQs+7Bs8PBM970POewfOe4Hkfet43eA4XPB9AzwcGzweC50Po+dDg+aHg+Qh6PjJ4PhI8H0PPxwbPEYLnE+j5xOD5RPB8Cj2fGjw/EjyfQc9nBs9ngudz6Pnc4DlS8HwBPV8YPF8Ini+h50uD58eC5yvo+crg+UrwfA09Xxs8Rwmeb6DnG4PnG8HzLfR8a/D8RPB8Bz3fGTzfCZ7vlWCe/3sXqudowTNCCeYZoUTonmHb4W0jQs+IBs9PBc9I0DOSwTOS4BkZekY2eI4RPKNAzygGzyiCZ1ToGdXg+ZngGQ16RjN4RhM8o0PP6AbPsYJnDOgZw+AZQ/CMCT1jGjw/FzxjQc9YBs9Ygmds6Bnb4DlO8IwDPeMYPOMInnGhZ1yD5xeCZzzoGc/gGU/wjA894xs8xwueCaBnAoNnAsEzIfRMaPD8UvBMBD0TGTwTCZ6JoWdig+cEwTMJ9Exi8EwieCaFnkkNnl8JnsmgZzKDZzLBMzn0TG7wnCh4poCeKQyeKQTPlNAzpcHza8EzFfRMZfBMJXimhp6pDZ6TBM800DONwTON4JkWeqY1eH4jeKaDnukMnukEz/TQM73Bc7LgmQF6ZjB4ZhA8M0LPjAbPbwXPTNAzk8Ezk+CZGXpmNnhOETyzQM8sBs8sgmdW6JnV4DlV8MwGPbMZPLMJntmhZ3aD5zTBMwf0zGHwzCF45oSeOQ2e3wmeuaBnLoNnLsEzN/TMbfCcLnjmgZ55DJ55BM+80DOvwfN7wTMf9Mxn8MwneOaHnvkNnjMEzwLQs4DBs4DgWRB6FjR4/iB4FoKehQyehQTPwtCzsMFzpuBZBHoWMXgWETyLQs+iBs8fBc9i0LOYwbOY4FkcehY3eM4SPEtAzxIGzxKCZ0noWdLg+ZPgWQp6ljJ4lhI8S0PP0gbP2YJnGehZxuBZRvAsCz3LGjx/FjzLQc9yBs9ygmcAPQOD5xzBszz0LG/wLC94VoCeFQyevwieFaFnRYNnRcGzEvSsZPCcK3hWhp6VDZ6VBc8q0LOKwfNXwbMq9Kxq8KwqeFaDntUMnvMEz+rQs7rBs7rgWQN61jB4/iZ41oSeNQ2eNQXPWtCzlsFzvuBZG3rWNnjWFjzrQM86Bs/fBc+60LOuwbOu4FkPetYzeC4QPOtDz/oGz/qCZwPo2cDg+Yfg2RB6NjR4NhQ8G0HPRgbPhYJnY+jZ2ODZWPBsAj2bGDz/FDybQs+mBs+mgmcz6NnM4LlI8GwOPZsbPJsLni2gZwuD51+CZ0vo2dLg2VLwbAU9Wxk8FwueraFna4Nna8GzDfRsY/D8W/BsCz3bGjzbCp7toGc7g+cSwbM99Gxv8GwveHaAnh0Mnv8Inh2hZ0eDZ0fBsxP07GTwXCp4doaenQ2enQXPLtCzi8HzX8GzK/TsavDsKnh2g57dDJ7LBM/u0LO7wbO74NkDevYweC4XPHtCz54Gz56CZy/o2cvguULw7A09exs8ewuefaBnH4PnSsGzL/Tsa/DsK3j2g579DJ6rBM/+0LO/wbO/4DkAeg4weK4WPAdCz4EGz4GC5yDoOcjguUbwHAw9Bxs8BwueQ6DnEIPnWsFzKPQcavAcKni+Dz3fN3iuEzyHQc9hBs9hgucH0PMDg+d6wXM49Bxu8BwueH4IPT80eG4QPEdAzxEGzxGC50fQ8yOD50bBcyT0HGnwHCl4fgw9PzZ4bhI8R0HPUQbPUYLnJ9DzE4PnZsFzNPQcbfAcLXh+Cj0/NXhuETzHQM8xBs8xgudn0PMzg+dWwXMs9Bxr8BwreH4OPT83eG4TPMdBz3EGz3GC5xfQ8wuD53bBczz0HG/wHC94fgk9vzR47hA8J0DPCQbPCYLnV9DzK4PnTsFzIvScaPCcKHh+DT2/NnjuEjwnQc9JBs9Jguc30PMbg+duwXMy9Jxs8JwseH4LPb81eO4RPKdAzykGzymC51ToOdXguVfwnAY9pxk8pwme30HP7wye+wTP6dBzusFzuuD5PfT83uC5X/CcAT1nGDxnCJ4/QM8fDJ4HBM+Z0HOmwXOm4Pkj9PzR4HlQ8JwFPWcZPGcJnj9Bz58MnocEz9nQc7bBc7bg+TP0/NngeVjwnAM95xg85wiev0DPXwyeRwTPudBzrsFzruD5K/T81eB5VPCcBz3nGTznCZ6/Qc/fDJ7HBM/50HO+wXO+4Pk79Pzd4Hlc8FwAPRcYPBcInn9Azz8MnicEz4XQc6HBc6Hg+Sf0/NPgeVLwXAQ9Fxk8Fwmef0HPvwyepwTPxdBzscFzseD5N/T82+B5WvBcAj2XGDyXCJ7/QM9/DJ5nBM+l0HOpwXOp4Pkv9PzX4HlW8FwGPZcZPJcJnsuh53KD5znBcwX0XGHwXCF4roSeKw2e5wXPVdBzlcFzleC5GnquNnheEDzXQM81Bs81guda6LnW4HlR8FwHPdcZPNcJnuuh53qD5yXBcwP03GDw3CB4boSeGw2elwXPTdBzk8Fzk+C5GXpuNnheETy3QM8tBs8tgudW6LnV4HlV8NwGPbcZPLcJntuh53aD5zXBcwf03GHw3CF47oSeOw2e1wXPXdBzl8Fzl+C5G3ruNnjeEDz3QM89Bs89gude6LnX4HlT8NwHPfcZPPcJnvuh536D5y3B8wD0PGDwPCB4HoSeBw2etwXPQ9DzkMHzkOB5GHoeNnjeETyPQM8jBs8jgudR6HnU4HlX8DwGPY8ZPI8Jnseh53GD5z3B8wT0PGHwPCF4noSeJw2e9wXPU9DzlMHzlOB5GnqeNng+EDzPQM8zBs8zgudZ6HnW4PlQ8DwHPc8ZPM8Jnueh53mD5yPB8wL0vGDwvCB4XoSeFw2ejwXPS9DzksHzkuB5GXpeNng+ETyvQM8rBs8rgudV6HnV4PlU8LwGPa8ZPK8Jnteh53WD5zPB8wb0vGHwvCF43oSeNw2ezwXPW9DzlsHzluB5G3reNni+EDzvQM87Bs87gudd6HnX4PlS8LwHPe8ZPO8Jnveh532D5yvB8wH0fGDwfCB4PoSeDw2erwXPR9DzkcHzkeD5GHo+Nni+ETyfQM8nBs8ngudT6PnU4PlW8HwGPZ8ZPJ8Jns+h53OD5zvB8wX0fGHwfCF4voSeLw2e78X673e+gp6vDJ6vBM/X0PO1wTOC4PkGer4xeL4RPN9Cz7cGz4iC5zvo+c7g+U7wfK8k8/zfu1A9IwmeEUoyzwglQ/cM2w5vGxF6RjR4RhY8I0HPSAbPSIJnZOgZ2eAZRfCMAj2jGDyjCJ5RoWdUg2dUwTMa9Ixm8IwmeEaHntENntEEzxjQM4bBM4bgGRN6xjR4Rhc8Y0HPWAbPWIJnbOgZ2+AZQ/CMAz3jGDzjCJ5xoWdcg2dMwTMe9Ixn8IwneMaHnvENnrEEzwTQM4HBM4HgmRB6JjR4xhY8E0HPRAbPRIJnYuiZ2OAZR/BMAj2TGDyTCJ5JoWdSg2dcwTMZ9Exm8EwmeCaHnskNnvEEzxTQM4XBM4XgmRJ6pjR4xhc8U0HPVAbPVIJnauiZ2uCZQPBMAz3TGDzTCJ5poWdag2dCwTMd9Exn8EwneKaHnukNnokEzwzQM4PBM4PgmRF6ZjR4JhY8M0HPTAbPTIJnZuiZ2eCZRPDMAj2zGDyzCJ5ZoWdWg2dSwTMb9Mxm8MwmeGaHntkNnskEzxzQM4fBM4fgmRN65jR4Jhc8c0HPXAbPXIJnbuiZ2+CZQvDMAz3zGDzzCJ55oWdeg2dKwTMf9Mxn8MwneOaHnvkNnqkEzwLQs4DBs4DgWRB6FjR4phY8C0HPQgbPQoJnYehZ2OCZRvAsAj2LGDyLCJ5FoWdRg2dawbMY9Cxm8CwmeBaHnsUNnukEzxLQs4TBs4TgWRJ6ljR4phc8S0HPUgbPUoJnaehZ2uCZQfAsAz3LGDzLCJ5loWdZg2dGwbMc9Cxn8CwneAbQMzB4ZhI8y0PP8gbP8oJnBehZweCZWfCsCD0rGjwrCp6VoGclg2cWwbMy9Kxs8KwseFaBnlUMnlkFz6rQs6rBs6rgWQ16VjN4ZhM8q0PP6gbP6oJnDehZw+CZXfCsCT1rGjxrCp61oGctg2cOwbM29Kxt8KwteNaBnnUMnjkFz7rQs67Bs67gWQ961jN45hI860PP+gbP+oJnA+jZwOCZW/BsCD0bGjwbCp6NoGcjg2cewbMx9Gxs8GwseDaBnk0MnnkFz6bQs6nBs6ng2Qx6NjN45hM8m0PP5gbP5oJnC+jZwuCZX/BsCT1bGjxbCp6toGcrg2cBwbM19Gxt8GwteLaBnm0MngUFz7bQs63Bs63g2Q56tjN4FhI820PP9gbP9oJnB+jZweBZWPDsCD07Gjw7Cp6doGcng2cRwbMz9Oxs8OwseHaBnl0MnkUFz67Qs6vBs6vg2Q16djN4FhM8u0PP7gbP7oJnD+jZw+BZXPDsCT17Gjx7Cp69oGcvg2cJwbM39Oxt8OwtePaBnn0MniUFz77Qs6/Bs6/g2Q969jN4lhI8+0PP/gbP/oLnAOg5wOBZWvAcCD0HGjwHCp6DoOcgg2cZwXMw9Bxs8BwseA6BnkMMnmUFz6HQc6jBc6jg+T70fN/gWU7wHAY9hxk8hwmeH0DPDwyegeA5HHoON3gOFzw/hJ4fGjzLC54joOcIg+cIwfMj6PmRwbOC4DkSeo40eI4UPD+Gnh8bPCsKnqOg5yiD5yjB8xPo+YnBs5LgORp6jjZ4jhY8P4Wenxo8KwueY6DnGIPnGMHzM+j5mcGziuA5FnqONXiOFTw/h56fGzyrCp7joOc4g+c4wfML6PmFwbOa4Dkeeo43eI4XPL+Enl8aPKsLnhOg5wSD5wTB8yvo+ZXBs4bgORF6TjR4ThQ8v4aeXxs8awqek6DnJIPnJMHzG+j5jcGzluA5GXpONnhOFjy/hZ7fGjxrC55ToOcUg+cUwXMq9Jxq8KwjeE6DntMMntMEz++g53cGz7qC53ToOd3gOV3w/B56fm/wrCd4zoCeMwyeMwTPH6DnDwbP+oLnTOg50+A5U/D8EXr+aPBsIHjOgp6zDJ6zBM+foOdPBs+Gguds6Dnb4Dlb8PwZev5s8GwkeM6BnnMMnnMEz1+g5y8Gz8aC51zoOdfgOVfw/BV6/mrwbCJ4zoOe8wye8wTP36DnbwbPpoLnfOg53+A5X/D8HXr+bvBsJngugJ4LDJ4LBM8/oOcfBs/mgudC6LnQ4LlQ8PwTev5p8GwheC6CnosMnosEz7+g518Gz5aC52LoudjguVjw/Bt6/m3wbCV4LoGeSwyeSwTPf6DnPwbP1oLnUui51OC5VPD8F3r+a/BsI3gug57LDJ7LBM/l0HO5wbOt4LkCeq4weK4QPFdCz5UGz3aC5yroucrguUrwXA09Vxs82wuea6DnGoPnGsFzLfRca/DsIHiug57rDJ7rBM/10HO9wbOj4LkBem4weG4QPDdCz40Gz06C5yboucnguUnw3Aw9Nxs8OwueW6DnFoPnFsFzK/TcavDsInhug57bDJ7bBM/t0HO7wbOr4LkDeu4weO4QPHdCz50Gz26C5y7oucvguUvw3A09dxs8uwuee6DnHoPnHsFzL/Tca/DsIXjug577DJ77BM/90HO/wbOn4HkAeh4weB4QPA9Cz4MGz16C5yHoecjgeUjwPAw9Dxs8ewueR6DnEYPnEcHzKPQ8avDsI3geg57HDJ7HBM/j0PO4wbOv4HkCep4weJ4QPE9Cz5MGz36C5ynoecrgeUrwPA09Txs8+wueZ6DnGYPnGcHzLPQ8a/AcIHieg57nDJ7nBM/z0PO8wXOg4HkBel4weF4QPC9Cz4sGz0GC5yXoecngeUnwvAw9Lxs8BwueV6DnFYPnFcHzKvS8avAcInheg57XDJ7XBM/r0PO6wXOo4HkDet4weN4QPG9Cz5sGz/cFz1vQ85bB85bgeRt63jZ4DhM870DPOwbPO4LnXeh51+D5geB5D3reM3jeEzzvQ8/7Bs/hgucD6PnA4PlA8HwIPR8aPD8UPB9Bz0cGz0eC52Po+djgOULwfAI9nxg8nwieT6HnU4PnR4LnM+j5zOD5TPB8Dj2fGzxHCp4voOcLg+cLwfMl9Hxp8PxY8HwFPV8ZPF8Jnq+h52uD5yjB8w30fGPwfCN4voWebw2enwie76DnO4PnO8HzvVLM83/vQvUcLXhGKMU8I5QK3TNsO7xtROgZ0eD5qeAZCXpGMnhGEjwjQ8/IBs8xgmcU6BnF4BlF8IwKPaMaPD8TPKNBz2gGz2iCZ3ToGd3gOVbwjAE9Yxg8YwieMaFnTIPn54JnLOgZy+AZS/CMDT1jGzzHCZ5xoGccg2ccwTMu9Ixr8PxC8IwHPeMZPOMJnvGhZ3yD53jBMwH0TGDwTCB4JoSeCQ2eXwqeiaBnIoNnIsEzMfRMbPCcIHgmgZ5JDJ5JBM+k0DOpwfMrwTMZ9Exm8EwmeCaHnskNnhMFzxTQM4XBM4XgmRJ6pjR4fi14poKeqQyeqQTP1NAztcFzkuCZBnqmMXimETzTQs+0Bs9vBM900DOdwTOd4JkeeqY3eE4WPDNAzwwGzwyCZ0bomdHg+a3gmQl6ZjJ4ZhI8M0PPzAbPKYJnFuiZxeCZRfDMCj2zGjynCp7ZoGc2g2c2wTM79Mxu8JwmeOaAnjkMnjkEz5zQM6fB8zvBMxf0zGXwzCV45oaeuQ2e0wXPPNAzj8Ezj+CZF3rmNXh+L3jmg575DJ75BM/80DO/wXOG4FkAehYweBYQPAtCz4IGzx8Ez0LQs5DBs5DgWRh6FjZ4zhQ8i0DPIgbPIoJnUehZ1OD5o+BZDHoWM3gWEzyLQ8/iBs9ZgmcJ6FnC4FlC8CwJPUsaPH8SPEtBz1IGz1KCZ2noWdrgOVvwLAM9yxg8ywieZaFnWYPnz4JnOehZzuBZTvAMoGdg8JwjeJaHnuUNnuUFzwrQs4LB8xfBsyL0rGjwrCh4VoKelQyecwXPytCzssGzsuBZBXpWMXj+KnhWhZ5VDZ5VBc9q0LOawXOe4FkdelY3eFYXPGtAzxoGz98Ez5rQs6bBs6bgWQt61jJ4zhc8a0PP2gbP2oJnHehZx+D5u+BZF3rWNXjWFTzrQc96Bs8Fgmd96Fnf4Flf8GwAPRsYPP8QPBtCz4YGz4aCZyPo2cjguVDwbAw9Gxs8GwueTaBnE4Pnn4JnU+jZ1ODZVPBsBj2bGTwXCZ7NoWdzg2dzwbMF9Gxh8PxL8GwJPVsaPFsKnq2gZyuD52LBszX0bG3wbC14toGebQyefwuebaFnW4NnW8GzHfRsZ/BcIni2h57tDZ7tBc8O0LODwfMfwbMj9Oxo8OwoeHaCnp0MnksFz87Qs7PBs7Pg2QV6djF4/it4doWeXQ2eXQXPbtCzm8FzmeDZHXp2N3h2Fzx7QM8eBs/lgmdP6NnT4NlT8OwFPXsZPFcInr2hZ2+DZ2/Bsw/07GPwXCl49oWefQ2efQXPftCzn8FzleDZH3r2N3j2FzwHQM8BBs/VgudA6DnQ4DlQ8BwEPQcZPNcInoOh52CD52DBcwj0HGLwXCt4DoWeQw2eQwXP96Hn+wbPdYLnMOg5zOA5TPD8AHp+YPBcL3gOh57DDZ7DBc8PoeeHBs8NgucI6DnC4DlC8PwIen5k8NwoeI6EniMNniMFz4+h58cGz02C5yjoOcrgOUrw/AR6fmLw3Cx4joaeow2eowXPT6HnpwbPLYLnGOg5xuA5RvD8DHp+ZvDcKniOhZ5jDZ5jBc/PoefnBs9tguc46DnO4DlO8PwCen5h8NwueI6HnuMNnuMFzy+h55cGzx2C5wToOcHgOUHw/Ap6fmXw3Cl4ToSeEw2eEwXPr6Hn1wbPXYLnJOg5yeA5SfD8Bnp+Y/DcLXhOhp6TDZ6TBc9voee3Bs89gucU6DnF4DlF8JwKPacaPPcKntOg5zSD5zTB8zvo+Z3Bc5/gOR16Tjd4Thc8v4ee3xs89wueM6DnDIPnDMHzB+j5g8HzgOA5E3rONHjOFDx/hJ4/GjwPCp6zoOcsg+cswfMn6PmTwfOQ4Dkbes42eM4WPH+Gnj8bPA8LnnOg5xyD5xzB8xfo+YvB84jgORd6zjV4zhU8f4Wevxo8jwqe86DnPIPnPMHzN+j5m8HzmOA5H3rON3jOFzx/h56/GzyPC54LoOcCg+cCwfMP6PmHwfOE4LkQei40eC4UPP+Enn8aPE8Knoug5yKD5yLB8y/o+ZfB85TguRh6LjZ4LhY8/4aefxs8TwueS6DnEoPnEsHzH+j5j8HzjOC5FHouNXguFTz/hZ7/GjzPCp7LoOcyg+cywXM59Fxu8DwneK6AnisMnisEz5XQc6XB87zguQp6rjJ4rhI8V0PP1QbPC4LnGui5xuC5RvBcCz3XGjwvCp7roOc6g+c6wXM99Fxv8LwkeG6AnhsMnhsEz43Qc6PB87LguQl6bjJ4bhI8N0PPzQbPK4LnFui5xeC5RfDcCj23GjyvCp7boOc2g+c2wXM79Nxu8LwmeO6AnjsMnjsEz53Qc6fB87rguQt67jJ47hI8d0PP3QbPG4LnHui5x+C5R/DcCz33GjxvCp77oOc+g+c+wXM/9Nxv8LwleB6AngcMngcEz4PQ86DB87bgeQh6HjJ4HhI8D0PPwwbPO4LnEeh5xOB5RPA8Cj2PGjzvCp7HoOcxg+cxwfM49Dxu8LwneJ6AnicMnicEz5PQ86TB877geQp6njJ4nhI8T0PP0wbPB4LnGeh5xuB5RvA8Cz3PGjwfCp7noOc5g+c5wfM89Dxv8HwkeF6AnhcMnhcEz4vQ86LB87HgeQl6XjJ4XhI8L0PPywbPJ4LnFeh5xeB5RfC8Cj2vGjyfCp7XoOc1g+c1wfM69Lxu8HwmeN6AnjcMnjcEz5vQ86bB87ngeQt63jJ43hI8b0PP2wbPF4LnHeh5x+B5R/C8Cz3vGjxfCp73oOc9g+c9wfM+9Lxv8HwleD6Ang8Mng8Ez4fQ86HB87Xg+Qh6PjJ4PhI8H0PPxwbPN4LnE+j5xOD5RPB8Cj2fGjzfCp7PoOczg+czwfM59Hxu8HwneL6Ani8Mni8Ez5fQ86XDM95/v/PVf/V8L/H/ufN/7+KGc6fSDm/7+j/fmf3/3Pn6P9wZzhfhvfj//c430PONwfON4PkWer41eEYQPN9Bz3cGz3eC53ulmef/3oXqGVHwjFCaeUYoHbpn2HZ424jQM6LBM5LgGQl6RjJ4RhI8I0PPyAbPyIJnFOgZxeAZRfCMCj2jGjyjCJ7RoGc0g2c0wTM69Ixu8IwqeMaAnjEMnjEEz5jQM6bBM5rgGQt6xjJ4xhI8Y0PP2AbP6IJnHOgZx+AZR/CMCz3jGjxjCJ7xoGc8g2c8wTM+9Ixv8IwpeCaAngkMngkEz4TQM6HBM5bgmQh6JjJ4JhI8E0PPxAbP2IJnEuiZxOCZRPBMCj2TGjzjCJ7JoGcyg2cywTM59Exu8IwreKaAnikMnikEz5TQM6XBM57gmQp6pjJ4phI8U0PP1AbP+IJnGuiZxuCZRvBMCz3TGjwTCJ7poGc6g2c6wTM99Exv8EwoeGaAnhkMnhkEz4zQM6PBM5HgmQl6ZjJ4ZhI8M0PPzAbPxIJnFuiZxeCZRfDMCj2zGjyTCJ7ZoGc2g2c2wTM79Mxu8EwqeOaAnjkMnjkEz5zQM6fBM5ngmQt65jJ45hI8c0PP3AbP5IJnHuiZx+CZR/DMCz3zGjxTCJ75oGc+g2c+wTM/9Mxv8EwpeBaAngUMngUEz4LQs6DBM5XgWQh6FjJ4FhI8C0PPwgbP1IJnEehZxOBZRPAsCj2LGjzTCJ7FoGcxg2cxwbM49Cxu8EwreJaAniUMniUEz5LQs6TBM53gWQp6ljJ4lhI8S0PP0gbP9IJnGehZxuBZRvAsCz3LGjwzCJ7loGc5g2c5wTOAnoHBM6PgWR56ljd4lhc8K0DPCgbPTIJnRehZ0eBZUfCsBD0rGTwzC56VoWdlg2dlwbMK9Kxi8MwieFaFnlUNnlUFz2rQs5rBM6vgWR16Vjd4Vhc8a0DPGgbPbIJnTehZ0+BZU/CsBT1rGTyzC561oWdtg2dtwbMO9Kxj8MwheNaFnnUNnnUFz3rQs57BM6fgWR961jd41hc8G0DPBgbPXIJnQ+jZ0ODZUPBsBD0bGTxzC56NoWdjg2djwbMJ9Gxi8MwjeDaFnk0Nnk0Fz2bQs5nBM6/g2Rx6Njd4Nhc8W0DPFgbPfIJnS+jZ0uDZUvBsBT1bGTzzC56toWdrg2drwbMN9Gxj8CwgeLaFnm0Nnm0Fz3bQs53Bs6Dg2R56tjd4thc8O0DPDgbPQoJnR+jZ0eDZUfDsBD07GTwLC56doWdng2dnwbML9Oxi8CwieHaFnl0Nnl0Fz27Qs5vBs6jg2R16djd4dhc8e0DPHgbPYoJnT+jZ0+DZU/DsBT17GTyLC569oWdvg2dvwbMP9Oxj8CwhePaFnn0Nnn0Fz37Qs5/Bs6Tg2R969jd49hc8B0DPAQbPUoLnQOg50OA5UPAcBD0HGTxLC56Doedgg+dgwXMI9Bxi8CwjeA6FnkMNnkMFz/eh5/sGz7KC5zDoOczgOUzw/AB6fmDwLCd4Doeeww2ewwXPD6HnhwbPQPAcAT1HGDxHCJ4fQc+PDJ7lBc+R0HOkwXOk4Pkx9PzY4FlB8BwFPUcZPEcJnp9Az08MnhUFz9HQc7TBc7Tg+Sn0/NTgWUnwHAM9xxg8xwien0HPzwyelQXPsdBzrMFzrOD5OfT83OBZRfAcBz3HGTzHCZ5fQM8vDJ5VBc/x0HO8wXO84Pkl9PzS4FlN8JwAPScYPCcInl9Bz68MntUFz4nQc6LBc6Lg+TX0/NrgWUPwnAQ9Jxk8Jwme30DPbwyeNQXPydBzssFzsuD5LfT81uBZS/CcAj2nGDynCJ5ToedUg2dtwXMa9Jxm8JwmeH4HPb8zeNYRPKdDz+kGz+mC5/fQ83uDZ13Bcwb0nGHwnCF4/gA9fzB41hM8Z0LPmQbPmYLnj9DzR4NnfcFzFvScZfCcJXj+BD1/Mng2EDxnQ8/ZBs/ZgufP0PNng2dDwXMO9Jxj8JwjeP4CPX8xeDYSPOdCz7kGz7mC56/Q81eDZ2PBcx70nGfwnCd4/gY9fzN4NhE850PP+QbP+YLn79Dzd4NnU8FzAfRcYPBcIHj+AT3/MHg2EzwXQs+FBs+Fguef0PNPg2dzwXMR9Fxk8FwkeP4FPf8yeLYQPBdDz8UGz8WC59/Q82+DZ0vBcwn0XGLwXCJ4/gM9/zF4thI8l0LPpQbPpYLnv9DzX4Nna8FzGfRcZvBcJnguh57LDZ5tBM8V0HOFwXOF4LkSeq40eLYVPFdBz1UGz1WC52roudrg2U7wXAM91xg81wiea6HnWoNne8FzHfRcZ/BcJ3iuh57rDZ4dBM8N0HODwXOD4LkRem40eHYUPDdBz00Gz02C52boudng2Unw3AI9txg8twieW6HnVoNnZ8FzG/TcZvDcJnhuh57bDZ5dBM8d0HOHwXOH4LkTeu40eHYVPHdBz10Gz12C527oudvg2U3w3AM99xg89wiee6HnXoNnd8FzH/TcZ/DcJ3juh577DZ49BM8D0POAwfOA4HkQeh40ePYUPA9Bz0MGz0OC52Hoedjg2UvwPAI9jxg8jwieR6HnUYNnb8HzGPQ8ZvA8Jngeh57HDZ59BM8T0POEwfOE4HkSep40ePYVPE9Bz1MGz1OC52noedrg2U/wPAM9zxg8zwieZ6HnWYNnf8HzHPQ8Z/A8J3ieh57nDZ4DBM8L0POCwfOC4HkRel40eA4UPC9Bz0sGz0uC52XoedngOUjwvAI9rxg8rwieV6HnVYPnYMHzGvS8ZvC8Jnheh57XDZ5DBM8b0POGwfOG4HkTet40eA4VPG9Bz1sGz1uC523oedvg+b7geQd63jF43hE870LPuwbPYYLnPeh5z+B5T/C8Dz3vGzw/EDwfQM8HBs8HgudD6PnQ4Dlc8HwEPR8ZPB8Jno+h52OD54eC5xPo+cTg+UTwfAo9nxo8Rwiez6DnM4PnM8HzOfR8bvD8SPB8AT1fGDxfCJ4voedLg+dIwfMV9Hxl8HwleL6Gnq8Nnh8Lnm+g5xuD5xvB8y30fGvwHCV4voOe7wye7wTP98owz/+9C9XzE8EzQhnmGaFM6J5h2+FtI0LPiAbP0YJnJOgZyeAZSfCMDD0jGzw/FTyjQM8oBs8ogmdU6BnV4DlG8IwGPaMZPKMJntGhZ3SD52eCZwzoGcPgGUPwjAk9Yxo8xwqesaBnLINnLMEzNvSMbfD8XPCMAz3jGDzjCJ5xoWdcg+c4wTMe9Ixn8IwneMaHnvENnl8IngmgZwKDZwLBMyH0TGjwHC94JoKeiQyeiQTPxNAzscHzS8EzCfRMYvBMIngmhZ5JDZ4TBM9k0DOZwTOZ4JkceiY3eH4leKaAnikMnikEz5TQM6XBc6LgmQp6pjJ4phI8U0PP1AbPrwXPNNAzjcEzjeCZFnqmNXhOEjzTQc90Bs90gmd66Jne4PmN4JkBemYweGYQPDNCz4wGz8mCZybomcngmUnwzAw9Mxs8vxU8s0DPLAbPLIJnVuiZ1eA5RfDMBj2zGTyzCZ7ZoWd2g+dUwTMH9Mxh8MwheOaEnjkNntMEz1zQM5fBM5fgmRt65jZ4fid45oGeeQyeeQTPvNAzr8FzuuCZD3rmM3jmEzzzQ8/8Bs/vBc8C0LOAwbOA4FkQehY0eM4QPAtBz0IGz0KCZ2HoWdjg+YPgWQR6FjF4FhE8i0LPogbPmYJnMehZzOBZTPAsDj2LGzx/FDxLQM8SBs8SgmdJ6FnS4DlL8CwFPUsZPEsJnqWhZ2mD50+CZxnoWcbgWUbwLAs9yxo8Zwue5aBnOYNnOcEzgJ6BwfNnwbM89Cxv8CwveFaAnhUMnnMEz4rQs6LBs6LgWQl6VjJ4/iJ4VoaelQ2elQXPKtCzisFzruBZFXpWNXhWFTyrQc9qBs9fBc/q0LO6wbO64FkDetYweM4TPGtCz5oGz5qCZy3oWcvg+ZvgWRt61jZ41hY860DPOgbP+YJnXehZ1+BZV/CsBz3rGTx/FzzrQ8/6Bs/6gmcD6NnA4LlA8GwIPRsaPBsKno2gZyOD5x+CZ2Po2djg2VjwbAI9mxg8FwqeTaFnU4NnU8GzGfRsZvD8U/BsDj2bGzybC54toGcLg+ciwbMl9Gxp8GwpeLaCnq0Mnn8Jnq2hZ2uDZ2vBsw30bGPwXCx4toWebQ2ebQXPdtCzncHzb8GzPfRsb/BsL3h2gJ4dDJ5LBM+O0LOjwbOj4NkJenYyeP4jeHaGnp0Nnp0Fzy7Qs4vBc6ng2RV6djV4dhU8u0HPbgbPfwXP7tCzu8Gzu+DZA3r2MHguEzx7Qs+eBs+egmcv6NnL4Llc8OwNPXsbPHsLnn2gZx+D5wrBsy/07Gvw7Ct49oOe/QyeKwXP/tCzv8Gzv+A5AHoOMHiuEjwHQs+BBs+Bgucg6DnI4Lla8BwMPQcbPAcLnkOg5xCD5xrBcyj0HGrwHCp4vg893zd4rhU8h0HPYQbPYYLnB9DzA4PnOsFzOPQcbvAcLnh+CD0/NHiuFzxHQM8RBs8RgudH0PMjg+cGwXMk9Bxp8BwpeH4MPT82eG4UPEdBz1EGz1GC5yfQ8xOD5ybBczT0HG3wHC14fgo9PzV4bhY8x0DPMQbPMYLnZ9DzM4PnFsFzLPQca/AcK3h+Dj0/N3huFTzHQc9xBs9xgucX0PMLg+c2wXM89Bxv8BwveH4JPb80eG4XPCdAzwkGzwmC51fQ8yuD5w7BcyL0nGjwnCh4fg09vzZ47hQ8J0HPSQbPSYLnN9DzG4PnLsFzMvScbPCcLHh+Cz2/NXjuFjynQM8pBs8pgudU6DnV4LlH8JwGPacZPKcJnt9Bz+8MnnsFz+nQc7rBc7rg+T30/N7guU/wnAE9Zxg8ZwieP0DPHwye+wXPmdBzpsFzpuD5I/T80eB5QPCcBT1nGTxnCZ4/Qc+fDJ4HBc/Z0HO2wXO24Pkz9PzZ4HlI8JwDPecYPOcInr9Az18MnocFz7nQc67Bc67g+Sv0/NXgeUTwnAc95xk85wmev0HP3wyeRwXP+dBzvsFzvuD5O/T83eB5TPBcAD0XGDwXCJ5/QM8/DJ7HBc+F0HOhwXOh4Pkn9PzT4HlC8FwEPRcZPBcJnn9Bz78MnicFz8XQc7HBc7Hg+Tf0/NvgeUrwXAI9lxg8lwie/0DPfwyepwXPpdBzqcFzqeD5L/T81+B5RvBcBj2XGTyXCZ7Loedyg+dZwXMF9Fxh8FwheK6EnisNnucEz1XQc5XBc5XguRp6rjZ4nhc810DPNQbPNYLnWui51uB5QfBcBz3XGTzXCZ7roed6g+dFwXMD9Nxg8NwgeG6EnhsNnpcEz03Qc5PBc5PguRl6bjZ4XhY8t0DPLQbPLYLnVui51eB5RfDcBj23GTy3CZ7boed2g+dVwXMH9Nxh8NwheO6EnjsNntcEz13Qc5fBc5fguRt67jZ4Xhc890DPPQbPPYLnXui51+B5Q/DcBz33GTz3CZ77oed+g+dNwfMA9Dxg8DwgeB6EngcNnrcEz0PQ85DB85DgeRh6HjZ43hY8j0DPIwbPI4LnUeh51OB5R/A8Bj2PGTyPCZ7Hoedxg+ddwfME9Dxh8DwheJ6EnicNnvcEz1PQ85TB85TgeRp6njZ43hc8z0DPMwbPM4LnWeh51uD5QPA8Bz3PGTzPCZ7noed5g+dDwfMC9Lxg8LwgeF6EnhcNno8Ez0vQ85LB85LgeRl6XjZ4PhY8r0DPKwbPK4LnVeh51eD5RPC8Bj2vGTyvCZ7Xoed1g+dTwfMG9Lxh8LwheN6EnjcNns8Ez1vQ85bB85bgeRt63jZ4Phc870DPOwbPO4LnXeh51+D5QvC8Bz3vGTzvCZ73oed9g+dLwfMB9Hxg8HwgeD6Eng8Nnq8Ez0fQ85HB85Hg+Rh6PjZ4vhY8n0DPJwbPJ4LnU+j51OD5RvB8Bj2fGTyfCZ7Poedzg+dbwfMF9Hxh8HwheL6Eni8Nnu8Ez1fQ85XB85Xg+Rp6vjZ4vpfgv9/5Bnq+MXi+ETzfQs+3Bs8Iguc76PnO4PlO8HyvLPP837tQPSMKnhHKMs8IZUP3DNsObxsRekY0eEYSPCNBz0gGz0iCZ2ToGdngGVnwjAI9oxg8owieUaFnVINnFMEzGvSMZvCMJnhGh57RDZ5RBc8Y0DOGwTOG4BkTesY0eEYTPGNBz1gGz1iCZ2zoGdvgGV3wjAM94xg84wiecaFnXINnDMEzHvSMZ/CMJ3jGh57xDZ4xBc8E0DOBwTOB4JkQeiY0eMYSPBNBz0QGz0SCZ2LomdjgGVvwTAI9kxg8kwieSaFnUoNnHMEzGfRMZvBMJngmh57JDZ5xBc8U0DOFwTOF4JkSeqY0eMYTPFNBz1QGz1SCZ2romdrgGV/wTAM90xg80wieaaFnWoNnAsEzHfRMZ/BMJ3imh57pDZ4JBc8M0DODwTOD4JkRemY0eCYSPDNBz0wGz0yCZ2bomdngmVjwzAI9sxg8swieWaFnVoNnEsEzG/TMZvDMJnhmh57ZDZ5JBc8c0DOHwTOH4JkTeuY0eCYTPHNBz1wGz1yCZ27omdvgmVzwzAM98xg88wieeaFnXoNnCsEzH/TMZ/DMJ3jmh575DZ4pBc8C0LOAwbOA4FkQehY0eKYSPAtBz0IGz0KCZ2HoWdjgmVrwLAI9ixg8iwieRaFnUYNnGsGzGPQsZvAsJngWh57FDZ5pBc8S0LOEwbOE4FkSepY0eKYTPEtBz1IGz1KCZ2noWdrgmV7wLAM9yxg8ywieZaFnWYNnBsGzHPQsZ/AsJ3gG0DMweGYUPMtDz/IGz/KCZwXoWcHgmUnwrAg9Kxo8KwqelaBnJYNnZsGzMvSsbPCsLHhWgZ5VDJ5ZBM+q0LOqwbOq4FkNelYzeGYVPKtDz+oGz+qCZw3oWcPgmU3wrAk9axo8awqetaBnLYNndsGzNvSsbfCsLXjWgZ51DJ45BM+60LOuwbOu4FkPetYzeOYUPOtDz/oGz/qCZwPo2cDgmUvwbAg9Gxo8GwqejaBnI4NnbsGzMfRsbPBsLHg2gZ5NDJ55BM+m0LOpwbOp4NkMejYzeOYVPJtDz+YGz+aCZwvo2cLgmU/wbAk9Wxo8WwqeraBnK4NnfsGzNfRsbfBsLXi2gZ5tDJ4FBM+20LOtwbOt4NkOerYzeBYUPNtDz/YGz/aCZwfo2cHgWUjw7Ag9Oxo8OwqenaBnJ4NnYcGzM/TsbPDsLHh2gZ5dDJ5FBM+u0LOrwbOr4NkNenYzeBYVPLtDz+4Gz+6CZw/o2cPgWUzw7Ak9exo8ewqevaBnL4NnccGzN/TsbfDsLXj2gZ59DJ4lBM++0LOvwbOv4NkPevYzeJYUPPtDz/4Gz/6C5wDoOcDgWUrwHAg9Bxo8Bwqeg6DnIINnacFzMPQcbPAcLHgOgZ5DDJ5lBM+h0HOowXOo4Pk+9Hzf4FlW8BwGPYcZPIcJnh9Azw8MnuUEz+HQc7jBc7jg+SH0/NDgGQieI6DnCIPnCMHzI+j5kcGzvOA5EnqONHiOFDw/hp4fGzwrCJ6joOcog+cowfMT6PmJwbOi4Dkaeo42eI4WPD+Fnp8aPCsJnmOg5xiD5xjB8zPo+ZnBs7LgORZ6jjV4jhU8P4eenxs8qwie46DnOIPnOMHzC+j5hcGzquA5HnqON3iOFzy/hJ5fGjyrCZ4ToOcEg+cEwfMr6PmVwbO64DkRek40eE4UPL+Gnl8bPGsInpOg5ySD5yTB8xvo+Y3Bs6bgORl6TjZ4ThY8v4We3xo8awmeU6DnFIPnFMFzKvScavCsLXhOg57TDJ7TBM/voOd3Bs86gud06Dnd4Dld8Pween5v8KwreM6AnjMMnjMEzx+g5w8Gz3qC50zoOdPgOVPw/BF6/mjwrC94zoKeswyeswTPn6DnTwbPBoLnbOg52+A5W/D8GXr+bPBsKHjOgZ5zDJ5zBM9foOcvBs9Ggudc6DnX4DlX8PwVev5q8GwseM6DnvMMnvMEz9+g528GzyaC53zoOd/gOV/w/B16/m7wbCp4LoCeCwyeCwTPP6DnHwbPZoLnQui50OC5UPD8E3r+afBsLngugp6LDJ6LBM+/oOdfBs8Wgudi6LnY4LlY8Pwbev5t8GwpeC6BnksMnksEz3+g5z8Gz1aC51LoudTguVTw/Bd6/mvwbC14LoOeywyeywTP5dBzucGzjeC5AnquMHiuEDxXQs+VBs+2gucq6LnK4LlK8FwNPVcbPNsJnmug5xqD5xrBcy30XGvwbC94roOe6wye6wTP9dBzvcGzg+C5AXpuMHhuEDw3Qs+NBs+Ogucm6LnJ4LlJ8NwMPTcbPDsJnlug5xaD5xbBcyv03Grw7Cx4boOe2wye2wTP7dBzu8Gzi+C5A3ruMHjuEDx3Qs+dBs+ugucu6LnL4LlL8NwNPXcbPLsJnnug5x6D5x7Bcy/03Gvw7C547oOe+wye+wTP/dBzv8Gzh+B5AHoeMHgeEDwPQs+DBs+eguch6HnI4HlI8DwMPQ8bPHsJnkeg5xGD5xHB8yj0PGrw7C14HoOexwyexwTP49DzuMGzj+B5AnqeMHieEDxPQs+TBs++gucp6HnK4HlK8DwNPU8bPPsJnmeg5xmD5xnB8yz0PGvw7C94noOe5wye5wTP89DzvMFzgOB5AXpeMHheEDwvQs+LBs+Bgucl6HnJ4HlJ8LwMPS8bPAcJnleg5xWD5xXB8yr0vGrwHCx4XoOe1wye1wTP69DzusFziOB5A3reMHjeEDxvQs+bBs+hguct6HnL4HlL8LwNPW8bPN8XPO9AzzsGzzuC513oedfgOUzwvAc97xk87wme96HnfYPnB4LnA+j5wOD5QPB8CD0fGjyHC56PoOcjg+cjwfMx9Hxs8PxQ8HwCPZ8YPJ8Ink+h51OD5wjB8xn0fGbwfCZ4Poeezw2eHwmeL6DnC4PnC8HzJfR8afAcKXi+gp6vDJ6vBM/X0PO1wfNjwfMN9Hxj8HwjeL6Fnm8NnqMEz3fQ853B853g+V455vm/d6F6fiJ4RijHPCOUC90zbDu8bUToGdHgOVrwjAQ9Ixk8IwmekaFnZIPnp4JnFOgZxeAZRfCMCj2jGjzHCJ7RoGc0g2c0wTM69Ixu8PxM8IwBPWMYPGMInjGhZ0yD51jBMxb0jGXwjCV4xoaesQ2enwuecaBnHINnHMEzLvSMa/AcJ3jGg57xDJ7xBM/40DO+wfMLwTMB9Exg8EwgeCaEngkNnuMFz0TQM5HBM5HgmRh6JjZ4fil4JoGeSQyeSQTPpNAzqcFzguCZDHomM3gmEzyTQ8/kBs+vBM8U0DOFwTOF4JkSeqY0eE4UPFNBz1QGz1SCZ2romdrg+bXgmQZ6pjF4phE800LPtAbPSYJnOuiZzuCZTvBMDz3TGzy/ETwzQM8MBs8MgmdG6JnR4DlZ8MwEPTMZPDMJnpmhZ2aD57eCZxbomcXgmUXwzAo9sxo8pwie2aBnNoNnNsEzO/TMbvCcKnjmgJ45DJ45BM+c0DOnwXOa4JkLeuYyeOYSPHNDz9wGz+8EzzzQM4/BM4/gmRd65jV4Thc880HPfAbPfIJnfuiZ3+D5veBZAHoWMHgWEDwLQs+CBs8Zgmch6FnI4FlI8CwMPQsbPH8QPItAzyIGzyKCZ1HoWdTgOVPwLAY9ixk8iwmexaFncYPnj4JnCehZwuBZQvAsCT1LGjxnCZ6loGcpg2cpwbM09Cxt8PxJ8CwDPcsYPMsInmWhZ1mD52zBsxz0LGfwLCd4BtAzMHj+LHiWh57lDZ7lBc8K0LOCwXOO4FkRelY0eFYUPCtBz0oGz18Ez8rQs7LBs7LgWQV6VjF4zhU8q0LPqgbPqoJnNehZzeD5q+BZHXpWN3hWFzxrQM8aBs95gmdN6FnT4FlT8KwFPWsZPH8TPGtDz9oGz9qCZx3oWcfgOV/wrAs96xo86wqe9aBnPYPn74JnfehZ3+BZX/BsAD0bGDwXCJ4NoWdDg2dDwbMR9Gxk8PxD8GwMPRsbPBsLnk2gZxOD50LBsyn0bGrwbCp4NoOezQyefwqezaFnc4Nnc8GzBfRsYfBcJHi2hJ4tDZ4tBc9W0LOVwfMvwbM19Gxt8GwteLaBnm0MnosFz7bQs63Bs63g2Q56tjN4/i14toee7Q2e7QXPDtCzg8FzieDZEXp2NHh2FDw7Qc9OBs9/BM/O0LOzwbOz4NkFenYxeC4VPLtCz64Gz66CZzfo2c3g+a/g2R16djd4dhc8e0DPHgbPZYJnT+jZ0+DZU/DsBT17GTyXC569oWdvg2dvwbMP9Oxj8FwhePaFnn0Nnn0Fz37Qs5/Bc6Xg2R969jd49hc8B0DPAQbPVYLnQOg50OA5UPAcBD0HGTxXC56Doedgg+dgwXMI9Bxi8FwjeA6FnkMNnkMFz/eh5/sGz7WC5zDoOczgOUzw/AB6fmDwXCd4Doeeww2ewwXPD6HnhwbP9YLnCOg5wuA5QvD8CHp+ZPDcIHiOhJ4jDZ4jBc+PoefHBs+Nguco6DnK4DlK8PwEen5i8NwkeI6GnqMNnqMFz0+h56cGz82C5xjoOcbgOUbw/Ax6fmbw3CJ4joWeYw2eYwXPz6Hn5wbPrYLnOOg5zuA5TvD8Anp+YfDcJniOh57jDZ7jBc8voeeXBs/tgucE6DnB4DlB8PwKen5l8NwheE6EnhMNnhMFz6+h59cGz52C5yToOcngOUnw/AZ6fmPw3CV4Toaekw2ekwXPb6HntwbP3YLnFOg5xeA5RfCcCj2nGjz3CJ7ToOc0g+c0wfM76PmdwXOv4Dkdek43eE4XPL+Hnt8bPPcJnjOg5wyD5wzB8wfo+YPBc7/gORN6zjR4zhQ8f4SePxo8Dwies6DnLIPnLMHzJ+j5k8HzoOA5G3rONnjOFjx/hp4/GzwPCZ5zoOccg+ccwfMX6PmLwfOw4DkXes41eM4VPH+Fnr8aPI8InvOg5zyD5zzB8zfo+ZvB86jgOR96zjd4zhc8f4eevxs8jwmeC6DnAoPnAsHzD+j5h8HzuOC5EHouNHguFDz/hJ5/GjxPCJ6LoOcig+ciwfMv6PmXwfOk4LkYei42eC4WPP+Gnn8bPE8Jnkug5xKD5xLB8x/o+Y/B87TguRR6LjV4LhU8/4We/xo8zwiey6DnMoPnMsFzOfRcbvA8K3iugJ4rDJ4rBM+V0HOlwfOc4LkKeq4yeK4SPFdDz9UGz/OC5xroucbguUbwXAs91xo8Lwie66DnOoPnOsFzPfRcb/C8KHhugJ4bDJ4bBM+N0HOjwfOS4LkJem4yeG4SPDdDz80Gz8uC5xboucXguUXw3Ao9txo8rwie26DnNoPnNsFzO/TcbvC8KnjugJ47DJ47BM+d0HOnwfOa4LkLeu4yeO4SPHdDz90Gz+uC5x7oucfguUfw3As99xo8bwie+6DnPoPnPsFzP/Tcb/C8KXgegJ4HDJ4HBM+D0POgwfOW4HkIeh4yeB4SPA9Dz8MGz9uC5xHoecTgeUTwPAo9jxo87wiex6DnMYPnMcHzOPQ8bvC8K3iegJ4nDJ4nBM+T0POkwfOe4HkKep4yeJ4SPE9Dz9MGz/uC5xnoecbgeUbwPAs9zxo8Hwie56DnOYPnOcHzPPQ8b/B8KHhegJ4XDJ4XBM+L0POiwfOR4HkJel4yeF4SPC9Dz8sGz8eC5xXoecXgeUXwvAo9rxo8nwie16DnNYPnNcHzOvS8bvB8KnjegJ43DJ43BM+b0POmwfOZ4HkLet4yeN4SPG9Dz9sGz+eC5x3oecfgeUfwvAs97xo8Xwie96DnPYPnPcHzPvS8b/B8KXg+gJ4PDJ4PBM+H0POhwfOV4PkIej4yeD4SPB9Dz8cGz9eC5xPo+cTg+UTwfAo9nxo83wiez6DnM4PnM8HzOfR8bvB8K3i+gJ4vDJ4vBM+X0POlwfOd4PkKer4yeL4SPF9Dz9cGz/cS/vc730DPNwbPN4LnW+j51uAZQfB8Bz3fGTzfCZ7vBczzf+9C9YwoeEYImGeEIHTPsO3wthED5hkxCN0zkuAZKWCekYLQPcO2w9tGDphn5CB0z8iCZ5SAeUYJQvcM2w5vGzVgnlGD0D2jCJ7RAuYZLQjdM2w7vG30gHlGD0L3jCp4xgiYZ4wgdM+w7fC2MQPmGTMI3TOa4BkrYJ6xgtA9w7bD28YOmGfsIHTP6IJnnIB5xglC9wzbDm8bN2CecYPQPWMInvEC5hkvCN0zbDu8bfyAecYPQveMKXgmCJhngiB0z7Dt8LYJA+aZMAjdM5bgmShgnomC0D3DtsPbJg6YZ+IgdM/YgmeSgHkmCUL3DNsOb5s0YJ5Jg9A94wieyQLmmSwI3TNsO7xt8oB5Jg9C94wreKYImGeKIHTPsO3wtikD5pkyCN0znuCZKmCeqYLQPcO2w9umDphn6iB0z/iCZ5qAeaYJQvcM2w5vmzZgnmmD0D0TCJ7pAuaZLgjdM2w7vG36gHmmD0L3TCh4ZgiYZ4YgdM+w7fC2GQPmmTEI3TOR4JkpYJ6ZgtA9w7bD22YOmGfmIHTPxIJnloB5ZglC9wzbDm+bNWCeWYPQPZMIntkC5pktCN0zbDu8bfaAeWYPQvdMKnjmCJhnjiB0z7Dt8LY5A+aZMwjdM5ngmStgnrmC0D3DtsPb5g6YZ+4gdM/kgmeegHnmCUL3DNsOb5s3YJ55g9A9Uwie+QLmmS8I3TNsO7xt/oB55g9C90wpeBYImGeBIHTPsO3wtgUD5lkwCN0zleBZKGCehYLQPcO2w9sWDphn4SB0z9SCZ5GAeRYJQvcM2w5vWzRgnkWD0D3TCJ7FAuZZLAjdM2w7vG3xgHkWD0L3TCt4lgiYZ4kgdM+w7fC2JQPmWTII3TOd4FkqYJ6lgtA9w7bD25YOmGfpIHTP9IJnmYB5lglC9wzbDm9bNmCeZYPQPTMInuUC5lkuCN0zbDu8bRAwzyAI3TOj4Fk+YJ7lg9A9w7bD21YImGeFIHTPTIJnxYB5VgxC9wzbDm9bKWCelYLQPTMLnpUD5lk5CN0zbDu8bZWAeVYJQvfMInhWDZhn1SB0z7Dt8LbVAuZZLQjdM6vgWT1gntWD0D3DtsPb1giYZ40gdM9sgmfNgHnWDEL3DNsOb1srYJ61gtA9swuetQPmWTsI3TNsO7xtnYB51glC98wheNYNmGfdIHTPsO3wtvUC5lkvCN0zp+BZP2Ce9YPQPcO2w9s2CJhngyB0z1yCZ8OAeTYMQvcM2w5v2yhgno2C0D1zC56NA+bZOAjdM2w7vG2TgHk2CUL3zCN4Ng2YZ9MgdM+w7fC2zQLm2SwI3TOv4Nk8YJ7Ng9A9w7bD27YImGeLIHTPfIJny4B5tgxC9wzbDm/bKmCerYLQPfMLnq0D5tk6CN0zbDu8bZuAebYJQvcsIHi2DZhn2yB0z7Dt8LbtAubZLgjds6Dg2T5gnu2D0D3DtsPbdgiYZ4cgdM9CgmfHgHl2DEL3DNsOb9spYJ6dgtA9CwuenQPm2TkI3TNsO7xtl4B5dglC9ywieHYNmGfXIHTPsO3wtt0C5tktCN2zqODZPWCe3YPQPcO2w9v2CJhnjyB0z2KCZ8+AefYMQvcM2w5v2ytgnr2C0D2LC569A+bZOwjdM2w7vG2fgHn2CUL3LCF49g2YZ98gdM+w7fC2/QLm2S8I3bOk4Nk/YJ79g9A9w7bD2w4ImOeAIHTPUoLnwIB5DgxC9wzbDm87KGCeg4LQPUsLnoMD5jk4CN0zbDu87ZCAeQ4JQvcsI3gODZjn0CB0z7Dt8LbvB8zz/SB0z7KC57CAeQ4LQvcM2w5v+0HAPD8IQvcsJ3gOD5jn8CB0z7Dt8LYfBszzwyB0z0DwHBEwzxFB6J5h2+FtPwqY50dB6J7lBc+RAfMcGYTuGbYd3vbjgHl+HITuWUHwHBUwz1FB6J5h2+FtPwmY5ydB6J4VBc/RAfMcHYTuGbYd3vbTgHl+GoTuWUnwHBMwzzFB6J5h2+FtPwuY52dB6J6VBc+xAfMcG4TuGbYd3vbzgHl+HoTuWUXwHBcwz3FB6J5h2+FtvwiY5xdB6J5VBc/xAfMcH4TuGbYd3vbLgHl+GYTuWU3wnBAwzwlB6J5h2+FtvwqY51dB6J7VBc+JAfOcGITuGbYd3vbrgHl+HYTuWUPwnBQwz0lB6J5h2+FtvwmY5zdB6J41Bc/JAfOcHITuGbYd3vbbgHl+G4TuWUvwnBIwzylB6J5h2+FtpwbMc2oQumdtwXNawDynBaF7hm2Ht/0uYJ7fBaF71hE8pwfMc3oQumfYdnjb7wPm+X0QumddwXNGwDxnBKF7hm2Ht/0hYJ4/BKF71hM8ZwbMc2YQumfYdnjbHwPm+WMQumd9wXNWwDxnBaF7hm2Ht/0pYJ4/BaF7NhA8ZwfMc3YQumfYdnjbnwPm+XMQumdDwXNOwDznBKF7hm2Ht/0lYJ6/BKF7NhI85wbMc24QumfYdnjbXwPm+WsQumdjwXNewDznBaF7hm2Ht/0tYJ6/BaF7NhE85wfMc34QumfYdnjb3wPm+XsQumdTwXNBwDwXBKF7hm2Ht/0jYJ5/BKF7NhM8FwbMc2EQumfYdnjbPwPm+WcQumdzwXNRwDwXBaF7hm2Ht/0rYJ5/BaF7thA8FwfMc3EQumfYdnjbvwPm+XcQumdLwXNJwDyXBKF7hm2Ht/0nYJ7/BKF7thI8lwbMc2kQumfYdnjbfwPm+W8QumdrwXNZwDyXBaF7hm2Ht10eMM/lQeiebQTPFQHzXBGE7hm2Hd52ZcA8Vwahe7YVPFcFzHNVELpn2HZ429UB81wdhO7ZTvBcEzDPNUHonmHb4W3XBsxzbRC6Z3vBc13APNcFoXuGbYe3XR8wz/VB6J4dBM8NAfPcEITuGbYd3nZjwDw3BqF7dhQ8NwXMc1MQumfYdnjbzQHz3ByE7tlJ8NwSMM8tQeieYdvhbbcGzHNrELpnZ8FzW8A8twWhe4Zth7fdHjDP7UHonl0Ezx0B89wRhO4Zth3edmfAPHcGoXt2FTx3BcxzVxC6Z9h2eNvdAfPcHYTu2U3w3BMwzz1B6J5h2+Ft9wbMc28Qumd3wXNfwDz3BaF7hm2Ht90fMM/9QeiePQTPAwHzPBCE7hm2Hd72YMA8Dwahe/YUPA8FzPNQELpn2HZ428MB8zwchO7ZS/A8EjDPI0HonmHb4W2PBszzaBC6Z2/B81jAPI8FoXuGbYe3PR4wz+NB6J59BM8TAfM8EYTuGbYd3vZkwDxPBqF79hU8TwXM81QQumfYdnjb0wHzPB2E7tlP8DwTMM8zQeieYdvhbc8GzPNsELpnf8HzXMA8zwWhe4Zth7c9HzDP80HongMEzwsB87wQhO4Zth3e9mLAPC8GoXsOFDwvBczzUhC6Z9h2eNvLAfO8HITuOUjwvBIwzytB6J5h2+FtrwbM82oQuudgwfNawDyvBaF7hm2Ht70eMM/rQeieQwTPGwHzvBGE7hm2Hd72ZsA8bwahew4VPG8FzPNWELpn2HZ429sB87wdhO75vuB5J2Ced4LQPcO2w9veDZjn3SB0z2GC572Aed4LQvcM2w5vez9gnveD0D0/EDwfBMzzQRC6Z9h2eNuHAfN8GITuOVzwfBQwz0dB6J5h2+FtHwfM83EQuueHgueTgHk+CUL3DNsOb/s0YJ5Pg9A9RwiezwLm+SwI3TNsO7zt84B5Pg9C9/xI8HwRMM8XQeieYdvhbV8GzPNlELrnSMHzVcA8XwWhe4Zth7d9HTDP10Honh8Lnm8C5vkmCN0zbDu87duAeb4NQvccJXi+C5jnuyB0z7Dt8LbvlWee/3sXqucngmeE8swzQvnQPcO2w9tGhJ4RDZ6jBc9I0DOSwTOS4BkZekY2eH4qeEaBnlEMnlEEz6jQM6rBc4zgGQ16RjN4RhM8o0PP6AbPzwTPGNAzhsEzhuAZE3rGNHiOFTxjQc9YBs9Ygmds6Bnb4Pm54BkHesYxeMYRPONCz7gGz3GCZzzoGc/gGU/wjA894xs8vxA8E0DPBAbPBIJnQuiZ0OA5XvBMBD0TGTwTCZ6JoWdig+eXgmcS6JnE4JlE8EwKPZMaPCcInsmgZzKDZzLBMzn0TG7w/ErwTAE9Uxg8UwieKaFnSoPnRMEzFfRMZfBMJXimhp6pDZ5fC55poGcag2cawTMt9Exr8JwkeKaDnukMnukEz/TQM73B8xvBMwP0zGDwzCB4ZoSeGQ2ekwXPTNAzk8Ezk+CZGXpmNnh+K3hmgZ5ZDJ5ZBM+s0DOrwXOK4JkNemYzeGYTPLNDz+wGz6mCZw7omcPgmUPwzAk9cxo8pwmeuaBnLoNnLsEzN/TMbfD8TvDMAz3zGDzzCJ55oWdeg+d0wTMf9Mxn8MwneOaHnvkNnt8LngWgZwGDZwHBsyD0LGjwnCF4FoKehQyehQTPwtCzsMHzB8GzCPQsYvAsIngWhZ5FDZ4zBc9i0LOYwbOY4FkcehY3eP4oeJaAniUMniUEz5LQs6TBc5bgWQp6ljJ4lhI8S0PP0gbPnwTPMtCzjMGzjOBZFnqWNXjOFjzLQc9yBs9ygmcAPQOD58+CZ3noWd7gWV7wrAA9Kxg85wieFaFnRYNnRcGzEvSsZPD8RfCsDD0rGzwrC55VoGcVg+dcwbMq9Kxq8KwqeFaDntUMnr8KntWhZ3WDZ3XBswb0rGHwnCd41oSeNQ2eNQXPWtCzlsHzN8GzNvSsbfCsLXjWgZ51DJ7zBc+60LOuwbOu4FkPetYzeP4ueNaHnvUNnvUFzwbQs4HBc4Hg2RB6NjR4NhQ8G0HPRgbPPwTPxtCzscGzseDZBHo2MXguFDybQs+mBs+mgmcz6NnM4Pmn4NkcejY3eDYXPFtAzxYGz0WCZ0vo2dLg2VLwbAU9Wxk8/xI8W0PP1gbP1oJnG+jZxuC5WPBsCz3bGjzbCp7toGc7g+ffgmd76Nne4Nle8OwAPTsYPJcInh2hZ0eDZ0fBsxP07GTw/Efw7Aw9Oxs8OwueXaBnF4PnUsGzK/TsavDsKnh2g57dDJ7/Cp7doWd3g2d3wbMH9Oxh8FwmePaEnj0Nnj0Fz17Qs5fBc7ng2Rt69jZ49hY8+0DPPgbPFYJnX+jZ1+DZV/DsBz37GTxXCp79oWd/g2d/wXMA9Bxg8FwleA6EngMNngMFz0HQc5DBc7XgORh6DjZ4DhY8h0DPIQbPNYLnUOg51OA5VPB8H3q+b/BcK3gOg57DDJ7DBM8PoOcHBs91gudw6Dnc4Dlc8PwQen5o8FwveI6AniMMniMEz4+g50cGzw2C50joOdLgOVLw/Bh6fmzw3Ch4joKeowyeowTPT6DnJwbPTYLnaOg52uA5WvD8FHp+avDcLHiOgZ5jDJ5jBM/PoOdnBs8tgudY6DnW4DlW8Pwcen5u8NwqeI6DnuMMnuMEzy+g5xcGz22C53joOd7gOV7w/BJ6fmnw3C54ToCeEwyeEwTPr6DnVwbPHYLnROg50eA5UfD8Gnp+bfDcKXhOgp6TDJ6TBM9voOc3Bs9dgudk6DnZ4DlZ8PwWen5r8NwteE6BnlMMnlMEz6nQc6rBc4/gOQ16TjN4ThM8v4Oe3xk89wqe06HndIPndMHze+j5vcFzn+A5A3rOMHjOEDx/gJ4/GDz3C54zoedMg+dMwfNH6PmjwfOA4DkLes4yeM4SPH+Cnj8ZPA8KnrOh52yD52zB82fo+bPB85DgOQd6zjF4zhE8f4Gevxg8Dwuec6HnXIPnXMHzV+j5q8HziOA5D3rOM3jOEzx/g56/GTyPCp7zoed8g+d8wfN36Pm7wfOY4LkAei4weC4QPP+Ann8YPI8Lnguh50KD50LB80/o+afB84TguQh6LjJ4LhI8/4Kefxk8Twqei6HnYoPnYsHzb+j5t8HzlOC5BHouMXguETz/gZ7/GDxPC55LoedSg+dSwfNf6PmvwfOM4LkMei4zeC4TPJdDz+UGz7OC5wroucLguULwXAk9Vxo8zwmeq6DnKoPnKsFzNfRcbfA8L3iugZ5rDJ5rBM+10HOtwfOC4LkOeq4zeK4TPNdDz/UGz4uC5wboucHguUHw3Ag9Nxo8Lwmem6DnJoPnJsFzM/TcbPC8LHhugZ5bDJ5bBM+t0HOrwfOK4LkNem4zeG4TPLdDz+0Gz6uC5w7oucPguUPw3Ak9dxo8rwmeu6DnLoPnLsFzN/TcbfC8LnjugZ57DJ57BM+90HOvwfOG4LkPeu4zeO4TPPdDz/0Gz5uC5wHoecDgeUDwPAg9Dxo8bwmeh6DnIYPnIcHzMPQ8bPC8LXgegZ5HDJ5HBM+j0POowfOO4HkMeh4zeB4TPI9Dz+MGz7uC5wnoecLgeULwPAk9Txo87wmep6DnKYPnKcHzNPQ8bfC8L3iegZ5nDJ5nBM+z0POswfOB4HkOep4zeJ4TPM9Dz/MGz4eC5wXoecHgeUHwvAg9Lxo8Hwmel6DnJYPnJcHzMvS8bPB8LHhegZ5XDJ5XBM+r0POqwfOJ4HkNel4zeF4TPK9Dz+sGz6eC5w3oecPgeUPwvAk9bxo8nwmet6DnLYPnLcHzNvS8bfB8LnjegZ53DJ53BM+70POuwfOF4HkPet4zeN4TPO9Dz/sGz5eC5wPo+cDg+UDwfAg9Hxo8Xwmej6DnI4PnI8HzMfR8bPB8LXg+gZ5PDJ5PBM+n0POpwfON4PkMej4zeD4TPJ9Dz+cGz7eC5wvo+cLg+ULwfAk9Xxo83wmer6DnK4PnK8HzNfR8bfB8L9F/v/MN9Hxj8HwjeL6Fnm8NnhEEz3fQ853B853g+V4F5vm/d6F6RhQ8I1RgnhEqhO4Zth3eNiL0jGjwjCR4RoKekQyekQTPyNAzssEzsuAZBXpGMXhGETyjQs+oBs8ogmc06BnN4BlN8IwOPaMbPKMKnjGgZwyDZwzBMyb0jGnwjCZ4xoKesQyesQTP2NAztsEzuuAZB3rGMXjGETzjQs+4Bs8Ygmc86BnP4BlP8IwPPeMbPGMKngmgZwKDZwLBMyH0TGjwjCV4JoKeiQyeiQTPxNAzscEztuCZBHomMXgmETyTQs+kBs84gmcy6JnM4JlM8EwOPZMbPOMKnimgZwqDZwrBMyX0TGnwjCd4poKeqQyeqQTP1NAztcEzvuCZBnqmMXimETzTQs+0Bs8Egmc66JnO4JlO8EwPPdMbPBMKnhmgZwaDZwbBMyP0zGjwTCR4ZoKemQyemQTPzNAzs8EzseCZBXpmMXhmETyzQs+sBs8kgmc26JnN4JlN8MwOPbMbPJMKnjmgZw6DZw7BMyf0zGnwTCZ45oKeuQyeuQTP3NAzt8EzueCZB3rmMXjmETzzQs+8Bs8Ugmc+6JnP4JlP8MwPPfMbPFMKngWgZwGDZwHBsyD0LGjwTCV4FoKehQyehQTPwtCzsMEzteBZBHoWMXgWETyLQs+iBs80gmcx6FnM4FlM8CwOPYsbPNMKniWgZwmDZwnBsyT0LGnwTCd4loKepQyepQTP0tCztMEzveBZBnqWMXiWETzLQs+yBs8Mgmc56FnO4FlO8AygZ2DwzCh4loee5Q2e5QXPCtCzgsEzk+BZEXpWNHhWFDwrQc9KBs/Mgmdl6FnZ4FlZ8KwCPasYPLMInlWhZ1WDZ1XBsxr0rGbwzCp4Voee1Q2e1QXPGtCzhsEzm+BZE3rWNHjWFDxrQc9aBs/sgmdt6Fnb4Flb8KwDPesYPHMInnWhZ12DZ13Bsx70rGfwzCl41oee9Q2e9QXPBtCzgcEzl+DZEHo2NHg2FDwbQc9GBs/cgmdj6NnY4NlY8GwCPZsYPPMInk2hZ1ODZ1PBsxn0bGbwzCt4NoeezQ2ezQXPFtCzhcEzn+DZEnq2NHi2FDxbQc9WBs/8gmdr6Nna4Nla8GwDPdsYPAsInm2hZ1uDZ1vBsx30bGfwLCh4toee7Q2e7QXPDtCzg8GzkODZEXp2NHh2FDw7Qc9OBs/Cgmdn6NnZ4NlZ8OwCPbsYPIsInl2hZ1eDZ1fBsxv07GbwLCp4doee3Q2e3QXPHtCzh8GzmODZE3r2NHj2FDx7Qc9eBs/igmdv6Nnb4Nlb8OwDPfsYPEsInn2hZ1+DZ1/Bsx/07GfwLCl49oee/Q2e/QXPAdBzgMGzlOA5EHoONHgOFDwHQc9BBs/Sgudg6DnY4DlY8BwCPYcYPMsInkOh51CD51DB833o+b7Bs6zgOQx6DjN4DhM8P4CeHxg8ywmew6HncIPncMHzQ+j5ocEzEDxHQM8RBs8RgudH0PMjg2d5wXMk9Bxp8BwpeH4MPT82eFYQPEdBz1EGz1GC5yfQ8xODZ0XBczT0HG3wHC14fgo9PzV4VhI8x0DPMQbPMYLnZ9DzM4NnZcFzLPQca/AcK3h+Dj0/N3hWETzHQc9xBs9xgucX0PMLg2dVwXM89Bxv8BwveH4JPb80eFYTPCdAzwkGzwmC51fQ8yuDZ3XBcyL0nGjwnCh4fg09vzZ41hA8J0HPSQbPSYLnN9DzG4NnTcFzMvScbPCcLHh+Cz2/NXjWEjynQM8pBs8pgudU6DnV4Flb8JwGPacZPKcJnt9Bz+8MnnUEz+nQc7rBc7rg+T30/N7gWVfwnAE9Zxg8ZwieP0DPHwye9QTPmdBzpsFzpuD5I/T80eBZX/CcBT1nGTxnCZ4/Qc+fDJ4NBM/Z0HO2wXO24Pkz9PzZ4NlQ8JwDPecYPOcInr9Az18Mno0Ez7nQc67Bc67g+Sv0/NXg2VjwnAc95xk85wmev0HP3wyeTQTP+dBzvsFzvuD5O/T83eDZVPBcAD0XGDwXCJ5/QM8/DJ7NBM+F0HOhwXOh4Pkn9PzT4Nlc8FwEPRcZPBcJnn9Bz78Mni0Ez8XQc7HBc7Hg+Tf0/Nvg2VLwXAI9lxg8lwie/0DPfwyerQTPpdBzqcFzqeD5L/T81+DZWvBcBj2XGTyXCZ7Loedyg2cbwXMF9Fxh8FwheK6EnisNnm0Fz1XQc5XBc5XguRp6rjZ4thM810DPNQbPNYLnWui51uDZXvBcBz3XGTzXCZ7roed6g2cHwXMD9Nxg8NwgeG6EnhsNnh0Fz03Qc5PBc5PguRl6bjZ4dhI8t0DPLQbPLYLnVui51eDZWfDcBj23GTy3CZ7boed2g2cXwXMH9Nxh8NwheO6EnjsNnl0Fz13Qc5fBc5fguRt67jZ4dhM890DPPQbPPYLnXui51+DZXfDcBz33GTz3CZ77oed+g2cPwfMA9Dxg8DwgeB6EngcNnj0Fz0PQ85DB85DgeRh6HjZ49hI8j0DPIwbPI4LnUeh51ODZW/A8Bj2PGTyPCZ7Hoedxg2cfwfME9Dxh8DwheJ6EnicNnn0Fz1PQ85TB85TgeRp6njZ49hM8z0DPMwbPM4LnWeh51uDZX/A8Bz3PGTzPCZ7noed5g+cAwfMC9Lxg8LwgeF6EnhcNngMFz0vQ85LB85LgeRl6XjZ4DhI8r0DPKwbPK4LnVeh51eA5WPC8Bj2vGTyvCZ7Xoed1g+cQwfMG9Lxh8LwheN6EnjcNnkMFz1vQ85bB85bgeRt63jZ4vi943oGedwyedwTPu9DzrsFzmOB5D3reM3jeEzzvQ8/7Bs8PBM8H0POBwfOB4PkQej40eA4XPB9Bz0cGz0eC52Po+djg+aHg+QR6PjF4PhE8n0LPpwbPEYLnM+j5zOD5TPB8Dj2fGzw/EjxfQM8XBs8XgudL6PnS4DlS8HwFPV8ZPF8Jnq+h52uD58eC5xvo+cbg+UbwfAs93xo8Rwme76DnO4PnO8HzvYrM83/vQvX8RPCMUJF5RqgYumfYdnjbiNAzosFztOAZCXpGMnhGEjwjQ8/IBs9PBc8o0DOKwTOK4BkVekY1eI4RPKNBz2gGz2iCZ3ToGd3g+ZngGQN6xjB4xhA8Y0LPmAbPsYJnLOgZy+AZS/CMDT1jGzw/FzzjQM84Bs84gmdc6BnX4DlO8IwHPeMZPOMJnvGhZ3yD5xeCZwLomcDgmUDwTAg9Exo8xwueiaBnIoNnIsEzMfRMbPD8UvBMAj2TGDyTCJ5JoWdSg+cEwTMZ9Exm8EwmeCaHnskNnl8JnimgZwqDZwrBMyX0TGnwnCh4poKeqQyeqQTP1NAztcHza8EzDfRMY/BMI3imhZ5pDZ6TBM900DOdwTOd4JkeeqY3eH4jeGaAnhkMnhkEz4zQM6PBc7LgmQl6ZjJ4ZhI8M0PPzAbPbwXPLNAzi8Ezi+CZFXpmNXhOETyzQc9sBs9sgmd26Jnd4DlV8MwBPXMYPHMInjmhZ06D5zTBMxf0zGXwzCV45oaeuQ2e3wmeeaBnHoNnHsEzL/TMa/CcLnjmg575DJ75BM/80DO/wfN7wbMA9Cxg8CwgeBaEngUNnjMEz0LQs5DBs5DgWRh6FjZ4/iB4FoGeRQyeRQTPotCzqMFzpuBZDHoWM3gWEzyLQ8/iBs8fBc8S0LOEwbOE4FkSepY0eM4SPEtBz1IGz1KCZ2noWdrg+ZPgWQZ6ljF4lhE8y0LPsgbP2YJnOehZzuBZTvAMoGdg8PxZ8CwPPcsbPMsLnhWgZwWD5xzBsyL0rGjwrCh4VoKelQyevwielaFnZYNnZcGzCvSsYvCcK3hWhZ5VDZ5VBc9q0LOawfNXwbM69Kxu8KwueNaAnjUMnvMEz5rQs6bBs6bgWQt61jJ4/iZ41oaetQ2etQXPOtCzjsFzvuBZF3rWNXjWFTzrQc96Bs/fBc/60LO+wbO+4NkAejYweC4QPBtCz4YGz4aCZyPo2cjg+Yfg2Rh6NjZ4NhY8m0DPJgbPhYJnU+jZ1ODZVPBsBj2bGTz/FDybQ8/mBs/mgmcL6NnC4LlI8GwJPVsaPFsKnq2gZyuD51+CZ2vo2drg2VrwbAM92xg8FwuebaFnW4NnW8GzHfRsZ/D8W/BsDz3bGzzbC54doGcHg+cSwbMj9Oxo8OwoeHaCnp0Mnv8Inp2hZ2eDZ2fBswv07GLwXCp4doWeXQ2eXQXPbtCzm8HzX8GzO/TsbvDsLnj2gJ49DJ7LBM+e0LOnwbOn4NkLevYyeC4XPHtDz94Gz96CZx/o2cfguULw7As9+xo8+wqe/aBnP4PnSsGzP/Tsb/DsL3gOgJ4DDJ6rBM+B0HOgwXOg4DkIeg4yeK4WPAdDz8EGz8GC5xDoOcTguUbwHAo9hxo8hwqe70PP9w2eawXPYdBzmMFzmOD5AfT8wOC5TvAcDj2HGzyHC54fQs8PDZ7rBc8R0HOEwXOE4PkR9PzI4LlB8BwJPUcaPEcKnh9Dz48NnhsFz1HQc5TBc5Tg+Qn0/MTguUnwHA09Rxs8Rwuen0LPTw2emwXPMdBzjMFzjOD5GfT8zOC5RfAcCz3HGjzHCp6fQ8/PDZ5bBc9x0HOcwXOc4PkF9PzC4LlN8BwPPccbPMcLnl9Czy8NntsFzwnQc4LBc4Lg+RX0/MrguUPwnAg9Jxo8JwqeX0PPrw2eOwXPSdBzksFzkuD5DfT8xuC5S/CcDD0nGzwnC57fQs9vDZ67Bc8p0HOKwXOK4DkVek41eO4RPKdBz2kGz2mC53fQ8zuD517Bczr0nG7wnC54fg89vzd47hM8Z0DPGQbPGYLnD9DzB4PnfsFzJvScafCcKXj+CD1/NHgeEDxnQc9ZBs9ZgudP0PMng+dBwXM29Jxt8JwteP4MPX82eB4SPOdAzzkGzzmC5y/Q8xeD52HBcy70nGvwnCt4/go9fzV4HhE850HPeQbPeYLnb9DzN4PnUcFzPvScb/CcL3j+Dj1/N3geEzwXQM8FBs8Fgucf0PMPg+dxwXMh9Fxo8FwoeP4JPf80eJ4QPBdBz0UGz0WC51/Q8y+D50nBczH0XGzwXCx4/g09/zZ4nhI8l0DPJQbPJYLnP9DzH4PnacFzKfRcavBcKnj+Cz3/NXieETyXQc9lBs9lgudy6Lnc4HlW8FwBPVcYPFcIniuh50qD5znBcxX0XGXwXCV4roaeqw2e5wXPNdBzjcFzjeC5FnquNXheEDzXQc91Bs91gud66Lne4HlR8NwAPTcYPDcInhuh50aD5yXBcxP03GTw3CR4boaemw2elwXPLdBzi8Fzi+C5FXpuNXheETy3Qc9tBs9tgud26Lnd4HlV8NwBPXcYPHcInjuh506D5zXBcxf03GXw3CV47oaeuw2e1wXPPdBzj8Fzj+C5F3ruNXjeEDz3Qc99Bs99gud+6Lnf4HlT8DwAPQ8YPA8Ingeh50GD5y3B8xD0PGTwPCR4Hoaehw2etwXPI9DziMHziOB5FHoeNXjeETyPQc9jBs9jgudx6Hnc4HlX8DwBPU8YPE8Inieh50mD5z3B8xT0PGXwPCV4noaepw2e9wXPM9DzjMHzjOB5FnqeNXg+EDzPQc9zBs9zgud56Hne4PlQ8LwAPS8YPC8Inheh50WD5yPB8xL0vGTwvCR4Xoaelw2ejwXPK9DzisHziuB5FXpeNXg+ETyvQc9rBs9rgud16Hnd4PlU8LwBPW8YPG8Injeh502D5zPB8xb0vGXwvCV43oaetw2ezwXPO9DzjsHzjuB5F3reNXi+EDzvQc97Bs97gud96Hnf4PlS8HwAPR8YPB8Ing+h50OD5yvB8xH0fGTwfCR4Poaejw2erwXPJ9DzicHzieD5FHo+NXi+ETyfQc9nBs9ngudz6Pnc4Znkv9/54r/dGe3d2/T/587/vcsczp1KO7zty/92Z7x3r4P/c+fL/3BnOF+Et4LnK+j5yuD5SvB8DT1fGzzfCZ5voOcbg+cbwfMt9Hxr8Hwv6X+/8x30fGfwfCd4vleJef7vXaieEQTPCJWYZ4RKoXuGbYe3jQg9Ixo8IwqekaBnJINnJMEzMvSMbPCMJHhGgZ5RDJ5RBM+o0DOqwTOy4BkNekYzeEYTPKNDz+gGzyiCZwzoGcPgGUPwjAk9Yxo8owqesaBnLINnLMEzNvSMbfCMJnjGgZ5xDJ5xBM+40DOuwTO64BkPesYzeMYTPONDz/gGzxiCZwLomcDgmUDwTAg9Exo8YwqeiaBnIoNnIsEzMfRMbPCMJXgmgZ5JDJ5JBM+k0DOpwTO24JkMeiYzeCYTPJNDz+QGzziCZwromcLgmULwTAk9Uxo84wqeqaBnKoNnKsEzNfRMbfCMJ3imgZ5pDJ5pBM+00DOtwTO+4JkOeqYzeKYTPNNDz/QGzwSCZwbomcHgmUHwzAg9Mxo8EwqemaBnJoNnJsEzM/TMbPBMJHhmgZ5ZDJ5ZBM+s0DOrwTOx4JkNemYzeGYTPLNDz+wGzySCZw7omcPgmUPwzAk9cxo8kwqeuaBnLoNnLsEzN/TMbfBMJnjmgZ55DJ55BM+80DOvwTO54JkPeuYzeOYTPPNDz/wGzxSCZwHoWcDgWUDwLAg9Cxo8UwqehaBnIYNnIcGzMPQsbPBMJXgWgZ5FDJ5FBM+i0LOowTO14FkMehYzeBYTPItDz+IGzzSCZwnoWcLgWULwLAk9Sxo80wqepaBnKYNnKcGzNPQsbfBMJ3iWgZ5lDJ5lBM+y0LOswTO94FkOepYzeJYTPAPoGRg8Mwie5aFneYNnecGzAvSsYPDMKHhWhJ4VDZ4VBc9K0LOSwTOT4FkZelY2eFYWPKtAzyoGz8yCZ1XoWdXgWVXwrAY9qxk8swie1aFndYNndcGzBvSsYfDMKnjWhJ41DZ41Bc9a0LOWwTOb4FkbetY2eNYWPOtAzzoGz+yCZ13oWdfgWVfwrAc96xk8cwie9aFnfYNnfcGzAfRsYPDMKXg2hJ4NDZ4NBc9G0LORwTOX4NkYejY2eDYWPJtAzyYGz9yCZ1Po2dTg2VTwbAY9mxk88wiezaFnc4Nnc8GzBfRsYfDMK3i2hJ4tDZ4tBc9W0LOVwTOf4NkaerY2eLYWPNtAzzYGz/yCZ1vo2dbg2VbwbAc92xk8Cwie7aFne4Nne8GzA/TsYPAsKHh2hJ4dDZ4dBc9O0LOTwbOQ4NkZenY2eHYWPLtAzy4Gz8KCZ1fo2dXg2VXw7AY9uxk8iwie3aFnd4Nnd8GzB/TsYfAsKnj2hJ49DZ49Bc9e0LOXwbOY4NkbevY2ePYWPPtAzz4Gz+KCZ1/o2dfg2Vfw7Ac9+xk8Swie/aFnf4Nnf8FzAPQcYPAsKXgOhJ4DDZ4DBc9B0HOQwbOU4DkYeg42eA4WPIdAzyEGz9KC51DoOdTgOVTwfB96vm/wLCN4DoOewwyewwTPD6DnBwbPsoLncOg53OA5XPD8EHp+aPAsJ3iOgJ4jDJ4jBM+PoOdHBs9A8BwJPUcaPEcKnh9Dz48NnuUFz1HQc5TBc5Tg+Qn0/MTgWUHwHA09Rxs8Rwuen0LPTw2eFQXPMdBzjMFzjOD5GfT8zOBZSfAcCz3HGjzHCp6fQ8/PDZ6VBc9x0HOcwXOc4PkF9PzC4FlF8BwPPccbPMcLnl9Czy8NnlUFzwnQc4LBc4Lg+RX0/MrgWU3wnAg9Jxo8JwqeX0PPrw2e1QXPSdBzksFzkuD5DfT8xuBZQ/CcDD0nGzwnC57fQs9vDZ41Bc8p0HOKwXOK4DkVek41eNYSPKdBz2kGz2mC53fQ8zuDZ23Bczr0nG7wnC54fg89vzd41hE8Z0DPGQbPGYLnD9DzB4NnXcFzJvScafCcKXj+CD1/NHjWEzxnQc9ZBs9ZgudP0PMng2d9wXM29Jxt8JwteP4MPX82eDYQPOdAzzkGzzmC5y/Q8xeDZ0PBcy70nGvwnCt4/go9fzV4NhI850HPeQbPeYLnb9DzN4NnY8FzPvScb/CcL3j+Dj1/N3g2ETwXQM8FBs8Fgucf0PMPg2dTwXMh9Fxo8FwoeP4JPf80eDYTPBdBz0UGz0WC51/Q8y+DZ3PBczH0XGzwXCx4/g09/zZ4thA8l0DPJQbPJYLnP9DzH4NnS8FzKfRcavBcKnj+Cz3/NXi2EjyXQc9lBs9lgudy6Lnc4Nla8FwBPVcYPFcIniuh50qDZxvBcxX0XGXwXCV4roaeqw2ebQXPNdBzjcFzjeC5FnquNXi2EzzXQc91Bs91gud66Lne4Nle8NwAPTcYPDcInhuh50aDZwfBcxP03GTw3CR4boaemw2eHQXPLdBzi8Fzi+C5FXpuNXh2Ejy3Qc9tBs9tgud26Lnd4NlZ8NwBPXcYPHcInjuh506DZxfBcxf03GXw3CV47oaeuw2eXQXPPdBzj8Fzj+C5F3ruNXh2Ezz3Qc99Bs99gud+6Lnf4Nld8DwAPQ8YPA8Ingeh50GDZw/B8xD0PGTwPCR4Hoaehw2ePQXPI9DziMHziOB5FHoeNXj2EjyPQc9jBs9jgudx6Hnc4Nlb8DwBPU8YPE8Inieh50mDZx/B8xT0PGXwPCV4noaepw2efQXPM9DzjMHzjOB5FnqeNXj2EzzPQc9zBs9zgud56Hne4Nlf8LwAPS8YPC8Inheh50WD5wDB8xL0vGTwvCR4Xoaelw2eAwXPK9DzisHziuB5FXpeNXgOEjyvQc9rBs9rgud16Hnd4DlY8LwBPW8YPG8Injeh502D5xDB8xb0vGXwvCV43oaetw2eQwXPO9DzjsHzjuB5F3reNXi+L3jeg573DJ73BM/70PO+wXOY4PkAej4weD4QPB9Cz4cGzw8Ez0fQ85HB85Hg+Rh6PjZ4Dhc8n0DPJwbPJ4LnU+j51OD5oeD5DHo+M3g+EzyfQ8/nBs8RgucL6PnC4PlC8HwJPV8aPD8SPF9Bz1cGz1eC52vo+drgOVLwfAM93xg83wieb6HnW4Pnx4LnO+j5zuD5TvB8rzLz/N+7UD1HCZ4RKjPPCJVD9wzbDm8bEXpGNHh+InhGgp6RDJ6RBM/I0DOywXO04BkFekYxeEYRPKNCz6gGz08Fz2jQM5rBM5rgGR16Rjd4jhE8Y0DPGAbPGIJnTOgZ0+D5meAZC3rGMnjGEjxjQ8/YBs+xgmcc6BnH4BlH8IwLPeMaPD8XPONBz3gGz3iCZ3zoGd/gOU7wTAA9Exg8EwieCaFnQoPnF4JnIuiZyOCZSPBMDD0TGzzHC55JoGcSg2cSwTMp9Exq8PxS8EwGPZMZPJMJnsmhZ3KD5wTBMwX0TGHwTCF4poSeKQ2eXwmeqaBnKoNnKsEzNfRMbfCcKHimgZ5pDJ5pBM+00DOtwfNrwTMd9Exn8EwneKaHnukNnpMEzwzQM4PBM4PgmRF6ZjR4fiN4ZoKemQyemQTPzNAzs8FzsuCZBXpmMXhmETyzQs+sBs9vBc9s0DObwTOb4JkdemY3eE4RPHNAzxwGzxyCZ07omdPgOVXwzAU9cxk8cwmeuaFnboPnNMEzD/TMY/DMI3jmhZ55DZ7fCZ75oGc+g2c+wTM/9Mxv8JwueBaAngUMngUEz4LQs6DB83vBsxD0LGTwLCR4FoaehQ2eMwTPItCziMGziOBZFHoWNXj+IHgWg57FDJ7FBM/i0LO4wXOm4FkCepYweJYQPEtCz5IGzx8Fz1LQs5TBs5TgWRp6ljZ4zhI8y0DPMgbPMoJnWehZ1uD5k+BZDnqWM3iWEzwD6BkYPGcLnuWhZ3mDZ3nBswL0rGDw/FnwrAg9Kxo8KwqelaBnJYPnHMGzMvSsbPCsLHhWgZ5VDJ6/CJ5VoWdVg2dVwbMa9Kxm8JwreFaHntUNntUFzxrQs4bB81fBsyb0rGnwrCl41oKetQye8wTP2tCztsGztuBZB3rWMXj+JnjWhZ51DZ51Bc960LOewXO+4FkfetY3eNYXPBtAzwYGz98Fz4bQs6HBs6Hg2Qh6NjJ4LhA8G0PPxgbPxoJnE+jZxOD5h+DZFHo2NXg2FTybQc9mBs+Fgmdz6Nnc4Nlc8GwBPVsYPP8UPFtCz5YGz5aCZyvo2crguUjwbA09Wxs8WwuebaBnG4PnX4JnW+jZ1uDZVvBsBz3bGTwXC57toWd7g2d7wbMD9Oxg8Pxb8OwIPTsaPDsKnp2gZyeD5xLBszP07Gzw7Cx4doGeXQye/wieXaFnV4NnV8GzG/TsZvBcKnh2h57dDZ7dBc8e0LOHwfNfwbMn9Oxp8OwpePaCnr0MnssEz97Qs7fBs7fg2Qd69jF4Lhc8+0LPvgbPvoJnP+jZz+C5QvDsDz37Gzz7C54DoOcAg+dKwXMg9Bxo8BwoeA6CnoMMnqsEz8HQc7DBc7DgOQR6DjF4rhY8h0LPoQbPoYLn+9DzfYPnGsFzGPQcZvAcJnh+AD0/MHiuFTyHQ8/hBs/hgueH0PNDg+c6wXME9Bxh8BwheH4EPT8yeK4XPEdCz5EGz5GC58fQ82OD5wbBcxT0HGXwHCV4fgI9PzF4bhQ8R0PP0QbP0YLnp9DzU4PnJsFzDPQcY/AcI3h+Bj0/M3huFjzHQs+xBs+xgufn0PNzg+cWwXMc9Bxn8BwneH4BPb8weG4VPMdDz/EGz/GC55fQ80uD5zbBcwL0nGDwnCB4fgU9vzJ4bhc8J0LPiQbPiYLn19Dza4PnDsFzEvScZPCcJHh+Az2/MXjuFDwnQ8/JBs/Jgue30PNbg+cuwXMK9Jxi8JwieE6FnlMNnrsFz2nQc5rBc5rg+R30/M7guUfwnA49pxs8pwue30PP7w2eewXPGdBzhsFzhuD5A/T8weC5T/CcCT1nGjxnCp4/Qs8fDZ77Bc9Z0HOWwXOW4PkT9PzJ4HlA8JwNPWcbPGcLnj9Dz58NngcFzznQc47Bc47g+Qv0/MXgeUjwnAs95xo85wqev0LPXw2ehwXPedBznsFznuD5G/T8zeB5RPCcDz3nGzznC56/Q8/fDZ5HBc8F0HOBwXOB4PkH9PzD4HlM8FwIPRcaPBcKnn9Czz8NnscFz0XQc5HBc5Hg+Rf0/MvgeULwXAw9Fxs8Fwuef0PPvw2eJwXPJdBzicFzieD5D/T8x+B5SvBcCj2XGjyXCp7/Qs9/DZ6nBc9l0HOZwXOZ4Lkcei43eJ4RPFdAzxUGzxWC50roudLgeVbwXAU9Vxk8Vwmeq6HnaoPnOcFzDfRcY/BcI3iuhZ5rDZ7nBc910HOdwXOd4Lkeeq43eF4QPDdAzw0Gzw2C50boudHgeVHw3AQ9Nxk8Nwmem6HnZoPnJcFzC/TcYvDcInhuhZ5bDZ6XBc9t0HObwXOb4Lkdem43eF4RPHdAzx0Gzx2C507oudPgeVXw3AU9dxk8dwmeu6HnboPnNcFzD/TcY/DcI3juhZ57DZ7XBc990HOfwXOf4Lkfeu43eN4QPA9AzwMGzwOC50HoedDgeVPwPAQ9Dxk8Dwmeh6HnYYPnLcHzCPQ8YvA8IngehZ5HDZ63Bc9j0POYwfOY4Hkceh43eN4RPE9AzxMGzxOC50noedLgeVfwPAU9Txk8Twmep6HnaYPnPcHzDPQ8Y/A8I3iehZ5nDZ73Bc9z0POcwfOc4Hkeep43eD4QPC9AzwsGzwuC50XoedHg+VDwvAQ9Lxk8Lwmel6HnZYPnI8HzCvS8YvC8InhehZ5XDZ6PBc9r0POawfOa4Hkdel43eD4RPG9AzxsGzxuC503oedPg+VTwvAU9bxk8bwmet6HnbYPnM8HzDvS8Y/C8I3jehZ53DZ7PBc970POewfOe4Hkfet43eL4QPB9AzwcGzweC50Po+dDg+VLwfAQ9Hxk8Hwmej6HnY4PnK8HzCfR8YvB8Ing+hZ5PDZ6vBc9n0POZwfOZ4Pkcej43eL4RPF9AzxcGzxeC50vo+dLg+VbwfAU9Xxk8Xwmer6Hna4PnO8HzDfR8Y/B8I3i+hZ5vDZ7vJfvvd76Dnu8Mnu8Ez/eqMM//vQvVM4LgGaEK84xQJXTPsO3wthGhZ0SDZ0TBMxL0jGTwjCR4RoaekQ2ekQTPKNAzisEziuAZFXpGNXhGFjyjQc9oBs9ogmd06Bnd4BlF8IwBPWMYPGMInjGhZ0yDZ1TBMxb0jGXwjCV4xoaesQ2e0QTPONAzjsEzjuAZF3rGNXhGFzzjQc94Bs94gmd86Bnf4BlD8EwAPRMYPBMIngmhZ0KDZ0zBMxH0TGTwTCR4JoaeiQ2esQTPJNAzicEzieCZFHomNXjGFjyTQc9kBs9kgmdy6Jnc4BlH8EwBPVMYPFMInimhZ0qDZ1zBMxX0TGXwTCV4poaeqQ2e8QTPNNAzjcEzjeCZFnqmNXjGFzzTQc90Bs90gmd66Jne4JlA8MwAPTMYPDMInhmhZ0aDZ0LBMxP0zGTwzCR4ZoaemQ2eiQTPLNAzi8Ezi+CZFXpmNXgmFjyzQc9sBs9sgmd26Jnd4JlE8MwBPXMYPHMInjmhZ06DZ1LBMxf0zGXwzCV45oaeuQ2eyQTPPNAzj8Ezj+CZF3rmNXgmFzzzQc98Bs98gmd+6Jnf4JlC8CwAPQsYPAsIngWhZ0GDZ0rBsxD0LGTwLCR4FoaehQ2eqQTPItCziMGziOBZFHoWNXimFjyLQc9iBs9igmdx6Fnc4JlG8CwBPUsYPEsIniWhZ0mDZ1rBsxT0LGXwLCV4loaepQ2e6QTPMtCzjMGzjOBZFnqWNXimFzzLQc9yBs9ygmcAPQODZwbBszz0LG/wLC94VoCeFQyeGQXPitCzosGzouBZCXpWMnhmEjwrQ8/KBs/KgmcV6FnF4JlZ8KwKPasaPKsKntWgZzWDZxbBszr0rG7wrC541oCeNQyeWQXPmtCzpsGzpuBZC3rWMnhmEzxrQ8/aBs/agmcd6FnH4Jld8KwLPesaPOsKnvWgZz2DZw7Bsz70rG/wrC94NoCeDQyeOQXPhtCzocGzoeDZCHo2MnjmEjwbQ8/GBs/GgmcT6NnE4Jlb8GwKPZsaPJsKns2gZzODZx7Bszn0bG7wbC54toCeLQyeeQXPltCzpcGzpeDZCnq2MnjmEzxbQ8/WBs/Wgmcb6NnG4Jlf8GwLPdsaPNsKnu2gZzuDZwHBsz30bG/wbC94doCeHQyeBQXPjtCzo8Gzo+DZCXp2MngWEjw7Q8/OBs/OgmcX6NnF4FlY8OwKPbsaPLsKnt2gZzeDZxHBszv07G7w7C549oCePQyeRQXPntCzp8Gzp+DZC3r2MngWEzx7Q8/eBs/egmcf6NnH4Flc8OwLPfsaPPsKnv2gZz+DZwnBsz/07G/w7C94DoCeAwyeJQXPgdBzoMFzoOA5CHoOMniWEjwHQ8/BBs/BgucQ6DnE4Fla8BwKPYcaPIcKnu9Dz/cNnmUEz2HQc5jBc5jg+QH0/MDgWVbwHA49hxs8hwueH0LPDw2e5QTPEdBzhMFzhOD5EfT8yOAZCJ4joedIg+dIwfNj6PmxwbO84DkKeo4yeI4SPD+Bnp8YPCsInqOh52iD52jB81Po+anBs6LgOQZ6jjF4jhE8P4Oenxk8KwmeY6HnWIPnWMHzc+j5ucGzsuA5DnqOM3iOEzy/gJ5fGDyrCJ7joed4g+d4wfNL6PmlwbOq4DkBek4weE4QPL+Cnl8ZPKsJnhOh50SD50TB82vo+bXBs7rgOQl6TjJ4ThI8v4Ge3xg8awiek6HnZIPnZMHzW+j5rcGzpuA5BXpOMXhOETynQs+pBs9aguc06DnN4DlN8PwOen5n8KwteE6HntMNntMFz++h5/cGzzqC5wzoOcPgOUPw/AF6/mDwrCt4zoSeMw2eMwXPH6HnjwbPeoLnLOg5y+A5S/D8CXr+ZPCsL3jOhp6zDZ6zBc+foefPBs8Ggucc6DnH4DlH8PwFev5i8GwoeM6FnnMNnnMFz1+h568Gz0aC5zzoOc/gOU/w/A16/mbwbCx4zoee8w2e8wXP36Hn7wbPJoLnAui5wOC5QPD8A3r+YfBsKnguhJ4LDZ4LBc8/oeefBs9mguci6LnI4LlI8PwLev5l8GwueC6GnosNnosFz7+h598GzxaC5xLoucTguUTw/Ad6/mPwbCl4LoWeSw2eSwXPf6HnvwbPVoLnMui5zOC5TPBcDj2XGzxbC54roOcKg+cKwXMl9Fxp8GwjeK6CnqsMnqsEz9XQc7XBs63guQZ6rjF4rhE810LPtQbPdoLnOui5zuC5TvBcDz3XGzzbC54boOcGg+cGwXMj9Nxo8OwgeG6CnpsMnpsEz83Qc7PBs6PguQV6bjF4bhE8t0LPrQbPToLnNui5zeC5TfDcDj23Gzw7C547oOcOg+cOwXMn9Nxp8OwieO6CnrsMnrsEz93Qc7fBs6vguQd67jF47hE890LPvQbPboLnPui5z+C5T/DcDz33Gzy7C54HoOcBg+cBwfMg9Dxo8OwheB6CnocMnocEz8PQ87DBs6fgeQR6HjF4HhE8j0LPowbPXoLnMeh5zOB5TPA8Dj2PGzx7C54noOcJg+cJwfMk9Dxp8OwjeJ6CnqcMnqcEz9PQ87TBs6/geQZ6njF4nhE8z0LPswbPfoLnOeh5zuB5TvA8Dz3PGzz7C54XoOcFg+cFwfMi9Lxo8BwgeF6CnpcMnpcEz8vQ87LBc6DgeQV6XjF4XhE8r0LPqwbPQYLnNeh5zeB5TfC8Dj2vGzwHC543oOcNg+cNwfMm9Lxp8BwieN6CnrcMnrcEz9vQ87bBc6jgeQd63jF43hE870LPuwbP9wXPe9DznsHznuB5H3reN3gOEzwfQM8HBs8HgudD6PnQ4PmB4PkIej4yeD4SPB9Dz8cGz+GC5xPo+cTg+UTwfAo9nxo8PxQ8n0HPZwbPZ4Lnc+j53OA5QvB8AT1fGDxfCJ4voedLg+dHgucr6PnK4PlK8HwNPV8bPEcKnm+g5xuD5xvB8y30fGvw/FjwfAc93xk83wme71Vlnv97F6rnKMEzQlXmGaFq6J5h2+FtI0LPiAbPTwTPSNAzksEzkuAZGXpGNniOFjyjQM8oBs8ogmdU6BnV4Pmp4BkNekYzeEYTPKNDz+gGzzGCZwzoGcPgGUPwjAk9Yxo8PxM8Y0HPWAbPWIJnbOgZ2+A5VvCMAz3jGDzjCJ5xoWdcg+fngmc86BnP4BlP8IwPPeMbPMcJngmgZwKDZwLBMyH0TGjw/ELwTAQ9Exk8EwmeiaFnYoPneMEzCfRMYvBMIngmhZ5JDZ5fCp7JoGcyg2cywTM59Exu8JwgeKaAnikMnikEz5TQM6XB8yvBMxX0TGXwTCV4poaeqQ2eEwXPNNAzjcEzjeCZFnqmNXh+LXimg57pDJ7pBM/00DO9wXOS4JkBemYweGYQPDNCz4wGz28Ez0zQM5PBM5PgmRl6ZjZ4ThY8s0DPLAbPLIJnVuiZ1eD5reCZDXpmM3hmEzyzQ8/sBs8pgmcO6JnD4JlD8MwJPXMaPKcKnrmgZy6DZy7BMzf0zG3wnCZ45oGeeQyeeQTPvNAzr8HzO8EzH/TMZ/DMJ3jmh575DZ7TBc8C0LOAwbOA4FkQehY0eH4veBaCnoUMnoUEz8LQs7DBc4bgWQR6FjF4FhE8i0LPogbPHwTPYtCzmMGzmOBZHHoWN3jOFDxLQM8SBs8SgmdJ6FnS4Pmj4FkKepYyeJYSPEtDz9IGz1mCZxnoWcbgWUbwLAs9yxo8fxI8y0HPcgbPcoJnAD0Dg+dswbM89Cxv8CwveFaAnhUMnj8LnhWhZ0WDZ0XBsxL0rGTwnCN4VoaelQ2elQXPKtCzisHzF8GzKvSsavCsKnhWg57VDJ5zBc/q0LO6wbO64FkDetYweP4qeNaEnjUNnjUFz1rQs5bBc57gWRt61jZ41hY860DPOgbP3wTPutCzrsGzruBZD3rWM3jOFzzrQ8/6Bs/6gmcD6NnA4Pm74NkQejY0eDYUPBtBz0YGzwWCZ2Po2djg2VjwbAI9mxg8/xA8m0LPpgbPpoJnM+jZzOC5UPBsDj2bGzybC54toGcLg+efgmdL6NnS4NlS8GwFPVsZPBcJnq2hZ2uDZ2vBsw30bGPw/EvwbAs92xo82wqe7aBnO4PnYsGzPfRsb/BsL3h2gJ4dDJ5/C54doWdHg2dHwbMT9Oxk8FwieHaGnp0Nnp0Fzy7Qs4vB8x/Bsyv07Grw7Cp4doOe3QyeSwXP7tCzu8Gzu+DZA3r2MHj+K3j2hJ49DZ49Bc9e0LOXwXOZ4NkbevY2ePYWPPtAzz4Gz+WCZ1/o2dfg2Vfw7Ac9+xk8Vwie/aFnf4Nnf8FzAPQcYPBcKXgOhJ4DDZ4DBc9B0HOQwXOV4DkYeg42eA4WPIdAzyEGz9WC51DoOdTg+f94ewcwvZK2XXsFnQ46nU7H7ti2bdu2bdu2bdu2bdu2d+WbmvddmTeZ1FnVu+b4a9fa33enJ9d9ns+1nmT2cfztwT47aO6zgz/scyvYZ0fNfXb0h312BPvspLnPTv6wz21gn50199nZH/bZGeyzi+Y+u/jDPreDfXbV3GdXf9hnV7DPbpr77OYP+9wB9tldc5/d/WGf3cE+e2jus4c/7HMn2GdPzX329Id99gT77KW5z17+sM9dYJ+9NffZ2x/22Rvss4/mPvv4wz53g3321dxnX3/YZ1+wz36a++znD/vcA/bZX3Of/f1hn/3BPgdo7nOAP+xzL9jnQM19DvSHfQ4E+xykuc9B/rDPfWCfgzX3Odgf9jkY7HOI5j6H+MM+94N9DtXc51B/2OdQsM9hmvsc5g/7PAD2OVxzn8P9YZ/DwT5HaO5zhD/s8yDY50jNfY70h32OBPscpbnPUf6wz0Ngn6M19znaH/Y5GuxzjOY+x/jDPg+DfY7V3OdYf9jnWLDPcZr7HOcP+zwC9jlec5/j/WGf48E+J2juc4I/7PMo2OdEzX1O9Id9TgT7nKS5z0n+sM9jYJ+TNfc52R/2ORnsc4rmPqf4wz6Pg31O1dznVH/Y51Swz2ma+5zmD/s8AfY5XXOf0/1hn9PBPmdo7nOGP+zzJNjnTM19zvSHfc4E+5yluc9Z/rDPU2CfszX3Odsf9jkb7HOO5j7n+MM+T4N9ztXc51x/2OdcsM95mvuc5w/7PAP2OV9zn/P9YZ/zwT4XaO5zgT/s8yzY50LNfS70h30uBPtcpLnPRf6wz3Ngn4s197nYH/a5GOxzieY+l/jDPs+DfS7V3OdSf9jnUrDPZZr7XOYP+7wA9rlcc5/L/WGfy8E+V2juc4U/7PMi2OdKzX2u9Id9rgT7XKW5z1X+sM9LYJ+rNfe52h/2uRrsc43mPtf4wz4vg32u1dznWn/Y51qwz3Wa+1znD/u8Ava5XnOf6/1hn+vBPjdo7nODP+zzKtjnRs19bvSHfW4E+9ykuc9N/rDPa2CfmzX3udkf9rkZ7HOL5j63+MM+r4N9btXc51Z/2OdWsM9tmvvc5g/7vAH2uV1zn9v9YZ/bwT53aO5zhz/s8ybY507Nfe70h33uBPvcpbnPXf6wz1tgn7s197nbH/a5G+xzj+Y+9/jDPm+Dfe7V3Odef9jnXrDPfZr73OcP+7wD9rlfc5/7/WGf+8E+D2ju84A/7PMu2OdBzX0e9Id9HgT7PKS5z0P+sM97YJ+HNfd52B/2eRjs84jmPo/4wz7vg30e1dznUX/Y51Gwz2Oa+zzmD/t8APZ5XHOfx/1hn8fBPk9o7vOEP+zzIdjnSc19nvSHfZ4E+zyluc9T/rDPR2CfpzX3edof9nka7POM5j7P+MM+H4N9ntXc51l/2OdZsM9zmvs85w/7fAL2eV5zn+f9YZ/nwT4vaO7zgj/s8ynY50XNfV70h31eBPu8pLnPS/6wz2dgn5c193nZH/Z5GezziuY+r/jDPp+DfV7V3OdVf9jnVbDPa5r7vOYP+3wB9nldc5/X/WGf18E+b2ju84Y/7PMl2OdNzX3e9Id93gT7vKW5z1v+sM9XYJ+3Nfd52x/2eRvs847mPu/4wz5fg33e1dznXX/Y512wz3ua+7znD/t8A/Z5X3Of9/1hn/fBPh9o7vOBP+zzLdjnQ819PvSHfT4E+3ykuc9H/rDPd2CfjzX3+dgf9vkY7POJ5j6f+MM+34N9PtXc51N/2OdTsM9nmvt85g/7/AD2+Vxzn8/9YZ/PwT5faO7zhT/s8yPY50vNfb70h32+BPt8pbnPV/6wz09gn6819/naH/b5GuzzjeY+3/jDPj+Dfb7V3Odbf9jnW7DPd5r7fPeL32cA+Pt8/y//7iF3elR9ci39mA0p+gbKejXfM/f/zu8f93/+xb/7J4j73/PvwwF+mv334YA/z/7rcKB/zP7bcOB/zv7LsMf/zP5+OMj/zv522PMXs78bDvqr2d8MB/vl7K+Hg/969pfDIX4z+6thr9/N/mI45G9n/3fY+/ez/zMc6l9m/zns82+z/xgO/a+zPw/7/vvsT8Nh/jDrHg77p1nXcLg/zv53OPyfZ/8zHEFh9u/hiCqzcjiS0uxfw5HVZv9vOIri7I/hqKqzYjia8qwTIHoQ9e7+4O5un3//x/0v8fvH7QT4999UDNDdfqC7Y4LujgW6Ozbo7jigu+OC7o4Hujs+6O4EoLsTgu5OBLo7MejuJKC7k4LuTga6Ozno7hSgu1OC7k4Fujs16O40oLvTgu5OB7o7PejuDKC7M4LuzgS6OzPo7iygu7OC7v5oqbuzge7ODro7B+junKC7c4Huzg26Ow/o7rygu/OB7s4PursA6O6CoLsLge4uDLq7COjuoqC7i4HuLg66uwTo7pKgu0uB7i4NursM6O6yoLvLge4uD7q7AujuiqC7K4Hurgy6uwro7k+gu3/k8xIn8H9+V3/9ncuP+4O8P8r7x8/9e+6zeP4izldxvuX/+TcbU95+juuH/ss/VcE7oBp4B1QH74Aa4B1QE7wDaoF3QG3wDqgD3gF1wTugHngH1AfvgAbgHdAQvAMagXdAY/AOaALeAU3BO6AZeAc0B++AFuAd0BK8A1qBd0Br8A5oA94BbcE7oB14B7QH74AO4B3QEbwDOoF3QGcw+wX8/f53ze/6tOe7gJ7vCnq+G+j57qDne4Ce7wl6vhfo+d6g5/uAnu8Ler4f6Pn+oOcHgJ4fCHp+EOj5waDnh4CeHwp6fhjo+eGg50eAnh8Jen4U6PnRoOfHgJ4fC3p+HOj58aDnJ4Cenwi6exKY/Qp63ilgp+cng56fAnp+Kuj5aaDnp4OenwF6fibo+Vmg52eDnp8Den4u6Pl5oOfng55fAHp+Iej5RaDnF4OeXwJ6fino+WWg55eDnl8Ben4l6PlVoOdXg55fA3p+Lej5daDn14Oe3wC6eyOY/QZ6PgDo+R+7+Off/3yWf9/zXd4/3hsB5M/9ey6geA704/8ujkeBn3+z9H2xCbwvNoP3xRbwvtgK3hfbwPtiO3hf7ADvi53gfbELvC92g/fFHvC+2AveF/vA+2I/eF8cAO+Lg+B9cQi8Lw6D98UR8L44Ct4Xx8D74jh4X5wA74uT4H1xCrwvToP3xRnwvjgL3hfnwPviPHgHXACzgQqovy+CWPpzwUXQ85dAz18GPX8F9PxV0PPXQM9fBz1/A/T8TdDzt0DP3wY9fwf0/F3Q8/dAz98HPf8A9PxD0POPQM8/Bj3/BPT8U9Dzz0DPPwc9/wL0/EvQ869Az78GPf8G9Pxb0PPvQHe/B7OBQc97Wur5D6DnP4Ke/wR6/jPo+S+g57+Cnv8Gev476HnHU73nA3iq93xAT/WeD+Sp3vOBPdV73sNTveeDeKr3vKenes8H9VTv+WCe6j0f3FO950N4qve8159mXcMh/zj732HvP8/+ZziUwuzfwz4qs3I4tNLsX8O+arP/NxxGcfbHcFjVWTEcTnnWCRAezHqAng9q+Pc/AeXf9wSRt6e8g7r+/ieYeA4uTghxvAz//ieCp/r7IqKn+vsikqf6+yKyp/r7Ioqn+vsiqqf6+yKap/r7Irqn+vsiBnhf+IH3RUzwvogF3hexwfsiDnhfxAXvi3jgfREfvC8SgPdFQvC+SATeF4nB+yIJeF8kBe+LZOB9kRy8L1KA90VK8L5IBd4XqcH7Ig14B6QFs8HB+yKkpT8XpAM9nx70fAbQ8xlBz2cCPZ8Z9HwW0PNZQc9nAz2fHfR8DtDzOUHP5wI9nxv0fB7Q83lBz+cDPZ8f9HwB0PMFQc8XAj1fGPR8EdDzRUHPFwM9Xxz0fAnQ8yVBz5cCPV8adHcZMBsC9Ly3pZ4vC3q+HOj58qDnK4Cerwh6vhLo+cqg56uAnq8Ker4a6PnqoOdrgJ6vCXq+Fuj52qDn64Cerwt6vh7o+fqg5xuAnm8Ier4R6PnGoOebgJ5vCnq+Gej55qDnW4Cebwl6vhXo7tZg1gv0fCjDv/8JJv++J6S8veUdyvX3Pz7iObQ4vuKEMfz7nzbgfdEWvC/agfdFe/C+6ADeFx3B+6ITeF90Bu+LLuB90RW8L7qB90V38L7oAd4XPcH7ohd4X/QG74s+4H3RF7wv+oH3RX/wvhgA3hcDwftiEHhfDAbviyHgfTEUvC+GgffFcPC+GAHeFyPBO2AUmA0N3hdhLf25YDTo+TGg58eCnh8Hen486PkJoOcngp6fBHp+Muj5KaDnp4KenwZ6fjro+Rmg52eCnp8Fen426Pk5oOfngp6fB3p+Puj5BaDnF4KeXwR6fjHo+SWg55eCnl8Gen456PkVoLtXgllf0PPhLPX8KtDzq0HPrwE9vxb0/DrQ8+tBz28APb8R9Pwm0PObQc9vAT2/FfT8NtDz20HP7wA9vxP0/C7Q87tBz+8BPb8X9Pw+0PP7Qc8fAD1/EPT8IdDzh0HPHwE9fxT0/DHQ88dBd58As2FAz4c3/PsfH/n3PWHlHU7e4V1//xNBPEcUJ5I4kQ3//uckeF+cAu+L0+B9cQa8L86C98U58L44D94XF8D74iJ4X1wC74vL4H1xBbwvroL3xTXwvrgO3hc3wPviJnhf3ALvi9vgfXEHvC/ugvfFPfC+uA/eFw/A++IheF88Au+Lx+B98QS8L56C98Uz8A54DmYjgvdFFM0/F/jK2++/cf71nxeg51+Cnn8Fev416Pk3oOffgp5/B3r+Pej5D6DnP4Ke/wR6/jPo+S+g57+Cnv8Gev47+ExFAp+pqIbfwSLI71xR5B1V3pFd38Giiefo4sT48e8q8Oucqr/fmAV+v4ehPlcmz+17oWqT+s8HLU5cra77fxf8H/8e508f7KD/8+/x+d1ogKDqPgcM+rvf///++EBB1d/tgYP+wQ/Xj/f406zrxwdRmP37x3sqzv748UGDqjOP5WL+f9/7/+Vy/0OZBwPMgwPmIQBzL8A8JGDuDZiHAsx9APPQgHlsS8x9AfMwgHlYwDwcYB4eMI8AmEcEzCMB5pEB8ziA+a/eRTHluyeWvGPLO47rXRRXPMcTJ744Cf7xLgohbz/X79/5l3+iAHeiAneiAXeiA3diAHf8gDsxgTuxgDuxwWw88J0noWa3UD/iAD/iAj/iAT/iAz8SAD8SAj8SAT8SA+ZJwGx84EciS34kBX4kA34kB36kAH6kBH6kAn6kBn6kAczTgtkEwI/Ehu+puPK9lFDeieSd2PWeSiKek4qTTJzkhu+pdMCz9MCzDMCzjMCzTMCzzMCzLMCzrMCdbGA2KfAshaUeyg78yAH8yAn8yAX8yA38yAP8yAv8yAeY5wezyYAfKS35UQD4URD4UQj4URj4UQT4URT4UQz4URwwLwFmkwM/Uhm+p5LI91IKeaeUdyrXeyq1eE4jTlpx0hm+p0oCz0oBz0oDz8oAz8oCz8oBz8oDzyoAdyqC2TTAs/SWeqgS8KMy8KMK8KMq8KMa8KM68KMG8KMmYF6LfLcGfmSw5Edt4Ecd4Edd4Ec94Ed94EcD4EdD4EcjwLwxmE0H/Mho+J5KLd9L6eWdQd4ZXe+pTOI5szhZxMlq+J5qAjxrCjxrBjxrDjxrATxrCTxrBTxrDdxpA2YzA8+yWeqhtsCPdsCP9sCPDsCPjsCPTsCPzsCPLoB5VzCbBfiR3ZIf3YAf3YEfPYAfPYEfvYAfvYEffYAffQHzfmA2K/Ajh+F7KpN8L2WTd3Z553C9p3KK51zi5BYnj+F7qj/wbADwbCDwbBDwbDDwbAjwbCjwbBhwZziYzQU8y2uph0YAP0YCP0YBP0YDP8YAP8YCP8YBP8YD5hPAbG7gRz5LfkwEfkwCfkwGfkwBfkwFfkwDfkwHfswAzGeC2TzAj/yG76mc8r2UV9755J3f9Z4qIJ4LilNInMKG76lZwLPZwLM5wLO5wLN5wLP5wLMFwLOFwJ1FYLYg8KyIpR5aDPxYAvxYCvxYBvxYDvxYAfxYCfxYBZivBrOFgB9FLfmxBvixFvixDvixHvixAfixEfixCfixGTDfAmYLAz+KGb6nCsj3UhF5F5V3Mdd7qrh4LiFOSXFKGb6ntgLPtgHPtgPPdgDPdgLPdgHPdgPP9gB39oLZEsCz0pZ6aB/wYz/w4wDw4yDw4xDw4zDw4wjw4yhgfgzMlgR+lLHkx3Hgxwngx0ngxyngx2ngxxngx1ngxznA/DyYLQX8KGv4niou30ul5V1G3mVd76ly4rm8OBXEqWj4nroAPLsIPLsEPLsMPLsCPLsKPLsGPLsO3LkBZssDzypZ6qGbwI9bwI/bwI87wI+7wI97wI/7wI8HgPlDMFsB+FHZkh+PgB+PgR9PgB9PgR/PgB/PgR8vgB8vAfNXYLYi8KOK4XuqnHwvVZJ3ZXlXcb2nqornauJUF6eG4XvqNfDsDfDsLfDsHfDsPfDsA/DsI/DsE3DnM5itBjyraamHvgA/vgI/vgE/vgM/nGDqfgQI5ij7EVBh9u8fH0hx9sePDwxmqwM/alnywyOYuh9Bgqn74RlM3Y+gwdT9CAb8CA78CAH88ALMQ4LZGsCP2obvqaryvVRT3rXkXdv1nqojnuuKU0+c+obvKW/gWSjgmQ/wLDTwzBd4FgZ4FhZ4Fg64Ex7M1gWeNbDUQxGAHxGBH5GAH5GBH1GAH1GBH9GAH9EB8xhgth7wo6ElP/yAHzGBH7GAH7GBH3GAH3GBH/GAH/EB8wRgtj7wo5Hhe6qOfC81kHdDeTdyvacai+cm4jQVp5nheyoh8CwR8Cwx8CwJ8Cwp8CwZ8Cw58CwFcCclmG0CPGtuqYdSAT9SAz/SAD/SAj/SAT/SAz8yAD8yAuaZwGxT4EcLS35kBn5kAX5kBX5kA35kB37kAH7kBH7kAsxzg9lmwI+Whu+pxvK91FzeLeTd0vWeaiWeW4vTRpy2hu+pPMCzvMCzfMCz/MCzAsCzgsCzQsCzwsCdImC2NfCsnaUeKgr8KAb8KA78KAH8KAn8KAX8KA38KAOYlwWzbYAf7S35UQ74UR74UQH4URH4UQn4URn4UQX4URUwrwZm2wI/Ohi+p1rJ91I7ebeXdwfXe6qjeO4kTmdxuhi+p6oDz2oAz2oCz2oBz2oDz+oAz+oCz+qRP4uD2U7As66WeqgB8KMh8KMR8KMx8KMJ8KMp8KMZ8KM5YN4CzHYGfnSz5EdL4Ecr4Edr4Ecb4Edb4Ec74Ed74EcHwLwjmO0C/Ohu+J7qKN9LXeXdTd7dXe+pHuK5pzi9xOlt+J7qBDzrDDzrAjzrCjzrBjzrDjzrATzrCdzpBWZ7As/6WOqh3sCPPsCPvsCPfsCP/sCPAcCPgcCPQYD5YOIS8KOvJT+GAD+GAj+GAT+GAz9GAD9GAj9GAT9GA+ZjwGxv4Ec/w/dUD/le6iPvvvLu53pP9RfPA8QZKM4gw/fUWODZOODZeODZBODZRODZJODZZODZFODOVDA7AHg22FIPTQN+TAd+zAB+zAR+zAJ+zAZ+zAF+zAXM54HZgcCPIZb8mA/8WAD8WAj8WAT8WAz8WAL8WAr8WAaYLwezg4AfQw3fU/3le2mwvIfIe6jrPTVMPA8XZ4Q4Iw3fUyuAZyuBZ6uAZ6uBZ2uAZ2uBZ+uAZ+uBOxvA7HDg2ShLPbQR+LEJ+LEZ+LEF+LEV+LEN+LEd+LEDMN8JZkcAP0Zb8mMX8GM38GMP8GMv8GMf8GM/8OMA8OMgYH4IzI4EfowxfE8Nk++lUfIeLe8xrvfUWPE8Tpzx4kwwfE8dBp4dAZ4dBZ4dA54dB56dAJ6dBJ6dAu6cBrPjgGcTLfXQGeDHWeDHOeDHeeDHBeDHReDHJeDHZcD8CpgdD/yYZMmPq8CPa8CP68CPG8CPm8CPW8CP28CPO4D5XTA7Afgx2fA9NVa+lybKe5K8J7veU1PE81Rxpokz3fA9dQ94dh949gB49hB49gh49hh49gR49hS484z8HSHwbIalHnoO/HgB/HgJ/HgF/HgN/HgD/HgL/HgHmL8Hs9OAHzM1/aD//+j9APz4CPz4BPz4DPz4Avz4Cvz4Bvz4DphPB8xnGb57psh3zQx5z5T3LNe7Z7Z4niPOXHHmGb57fsjm9/P/5LfuBAiu7k7A4OruBAqu7k7g4OruePxp1vXjgyjM/v3jPRVnf/z4oGB2DvBsvqV3TzDgR3DgRwjghxfwIyTwwxv4EQr44QOYhwazc4EfCyz54Qv8CAP8CAv8CAf8CA/8iAD8iAj8iASYRwaz84AfCw3fU7Ple2m+vBfIe6HrPbVIPC8WZ4k4Sw3fU1GAZ1GBZ9GAZ9GBZzGAZ37As5jAs1jAndhgdjHwbJmlHooD/IgL/IgH/IgP/EgA/EgI/EgE/EgMmCcBs0uAH8st+ZEU+JEM+JEc+JEC+JES+JEK+JEa+JEGME8LZpcCP1YYvqcWyffSMnkvl/cK13tqpXheJc5qcdYYvqfSAc/SA88yAM8yAs8yAc8yA8+yAM+yAneygdlVwLO1lnooO/AjB/AjJ/AjF/AjN/AjD/AjL/AjH2CeH8yuBn6ss+RHAeBHQeBHIeBHYeBHEeBHUeBHMeBHccC8BJhdA/xYb/ieWinfS2vlvU7e613vqQ3ieaM4m8TZbPieKgk8KwU8Kw08KwM8Kws8Kwc8Kw88qwDcqQhmNwLPtljqoUrAj8rAjyrAj6rAj2rAj+rAjxrAj5qAeS0wuwn4sdWSH7WBH3WAH3WBH/WAH/WBHw2AHw2BH40A88ZgdjPwY5vhe2qDfC9tkfdWeW9zvae2i+cd4uwUZ5fhe6oJ8Kwp8KwZ8Kw58KwF8Kwl8KwV8Kw1cKcNmN0BPNttqYfaAj/aAT/aAz86AD86Aj86AT86Az+6AOZdwexO4MceS350A350B370AH70BH70An70Bn70AX70Bcz7gdldwI+9hu+p7fK9tFvee+S91/We2iee94tzQJyDhu+p/sCzAcCzgcCzQcCzwcCzIcCzocCzYcCd4WB2P/DskKUeGgH8GAn8GAX8GA38GAP8GAv8GAf8GA+YTwCzB4Afhy35MRH4MQn4MRn4MQX4MRX4MQ34MR34MQMwnwlmDwI/jhi+p/bJ99IheR+W9xHXe+qoeD4mznFxThi+p2YBz2YDz+YAz+YCz+YBz+YDzxYAzxYCdxaB2WPAs5OWemgx8GMJ8GMp8GMZ8GM58GMF8GMl8GMV+W9OYPY48OOUJT/WAD/WAj/WAT/WAz82AD82Aj82AT82A+ZbwOwJ4Mdpw/fUUfleOinvU/I+7XpPnRHPZ8U5J855w/fUVuDZNuDZduDZDuDZTuDZLuDZbuDZHuDOXjB7Fnh2wVIP7QN+7Ad+HAB+HAR+HAJ+HAZ+HAF+HCXfTcDsOeDHRUt+HAd+nAB+nAR+nAJ+nAZ+nAF+nAV+nAPMz5NZ4Mclw/fUGfleuiDvi/K+5HpPXRbPV8S5Ks41w/fUBeDZReDZJeDZZeDZFeDZVeDZNeDZdeDODTB7BXh23VIP3QR+3AJ+3AZ+3AF+3AV+3AN+3Ad+PADMH4LZq8CPG5b8eAT8eAz8eAL8eAr8eAb8eA78eAH8eAmYvwKz14AfNw3fU5fle+m6vG/I+6brPXVLPN8W5444dw3fU6+BZ2+AZ2+BZ++AZ++BZx+AZx+BZ5+AO5/B7G3g2T1LPfQF+PEV+PEN+PEd+PEj4G9n//HjA4RwlP0IqDD7948PpDj748cHBrN3gB/3LfnhEULdjyAh1P3wDKHuR9AQ6n4EA34EB36EAH54AeYhwexd4McDw/fULfleuifv+/J+4HpPPRTPj8R5LM4Tw/eUN/AsFPDMB3gWGnjmCzwLAzwLCzwLB9wJD2YfAc+eWuqhCMCPiMCPSMCPyMCPKMCPqMCPaMCP6IB5DDD7GPjxzJIffsCPmMCPWMCP2MCPOMCPuMCPeMCP+IB5AjD7BPjx3PA99VC+l57K+5m8n7veUy/E80txXonz2vA9lRB4lgh4lhh4lgR4lhR4lgx4lhx4lgK4kxLMvgSevbHUQ6mAH6mBH2mAH2mBH+mAH+mBHxmAHxkB80xg9hXw460lPzIDP7IAP7ICP7IBP7IDP3IAP3ICP3IB5rnB7GvgxzvD99QL+V56I++38n7nek+9F88fxPkozifD91Qe4Fle4Fk+4Fl+4FkB4FlB4Fkh4Flh4E4RMPsBePbZUg8VBX4UA34UB36UAH6UBH6UAn6UBn6UAczLgtmPwI8vlvwoB/woD/yoAPyoCPyoBPyoDPyoAvyoCphXA7OfgB9fDd9T7+V76bO8v8j7q+s99U08f//xfioo/ncFf/7NUs+qA89qAM9qAs9qAc9qA8/qAM/qAs/qAXfqg9nvwLOABe30UAPgR0PgRyPgR2PgRxPgR1PgRzPgR3PAvAWYdQqq+xHIkh8tgR+tgB+tgR9tgB9tgR/tgB/tgR8dAPOOYDYA8CMw8ONX76lv8r30o4d+3IHk/ePn/j3nIZ6DiOMpTlDD91Qn4Fln4FkX4FlX4Fk34Fl34FkP4FlP4E4vMBsEeBbMUg/1Bn70AX70BX70A370B34MAH4MBH4MAswHg1lP4EdwS34MAX4MBX4MA34MB36MAH6MBH6MAn6MBszHgNmgwI8Qhu8pD/leCibv4PIO4XpPeYnnkOJ4ixPK8D01Fng2Dng2Hng2AXg2EXg2CXg2GXg2BbgzFcyGBJ75WOqhacCP6cCPGcCPmcCPWcCP2cCPOcCPuYD5PDDrDfwIbcmP+cCPBcCPhcCPRcCPxcCPJcCPpcCPZYD5cjAbCvjha/ie8pLvJR95h5a3r+s9FUY8hxUnnDjhDd9TK4BnK4Fnq4Bnq4Fna4Bna4Fn64Bn64E7G8BsWOBZBEs9tBH4sQn4sRn4sQX4sRX4sQ34sR34sQMw3wlmwwE/IlryYxfwYzfwYw/wYy/wYx/wYz/w4wDw4yBgfgjMhgd+RDJ8T4WR76UI8o4o70iu91Rk8RxFnKjiRDN8Tx0Gnh0Bnh0Fnh0Dnh0Hnp0Anp0Enp0C7pwGs1GAZ9Et9dAZ4MdZ4Mc54Md54McF4MdF4Mcl4MdlwPwKmI0K/IhhyY+rwI9rwI/rwI8bwI+bwI9bwI/bwI87gPldMBsN+OFn+J6KLN9L0eUdQ95+rvdUTPEcS5zY4sQxfE/dA57dB549AJ49BJ49Ap49Bp49AZ49Be48A7OxgGdxLfXQc+DHC+DHS+DHK+DHa+DHG+DHW+DHO8D8PZiNDfyIp+lHcHn7uf69zr/88wH48RH48Qn48Rn48QX48RX48Q348R0wjwOYxzd898SU75q48o4n7/iud08C8ZxQnETiJC746134Kf5+kxT8/R7SvlsdqIVf7L7Xsz++M/70hDHu/53nP/49P//b//efLxF++e/55S/4GuH3v6d//oJvEf7A0fULvv9p1v0LIqr7ESCi+r6T/rRvn3/9P9z/0H0HjKi+70AR1fcdOKL6vj0iqu87CNi3J9h3Mkv7Dgr2HQzsOzjYdwiwby+w75Bg38nBvn/Vf0lk3yWVdzJ5J3f1XwrxnFKcVOKk/kf/BZW3388RnN/94w24hQLcfAC30ICbL+AWBsymBO+4NJqfKcomLGATDrAJD9hEAGwign1HArOpAJu0lthEBmyiADZRAZtogE10sO8YYDY1YJPOsBtTyC5MI++08k7n6sb04jmDOBnFyWTYjX6AcUzAOBZgHBswjgO4xQWzGQDjzJY+f/EAm/iATQLAJiFgkwjsOzGYzQjYZLHEJglgkxSwSQbYJAdsUpDvCWA2E2CT1bAb08suzCzvLPLO6urGbOI5uzg5xMlp2I2pAOPUgHEawDgtYJwOcEsPZrMDxrksff4yADYZAZtMgE1mwCYL2HdWMJsDsMltiU02wCY7YJMDsMkJ2OQC+84NZnMCNnkMuzGb7MJc8s4t7zyubswrnvOJk1+cAobdmAcwzgsY5wOM8wPGBQC3gmA2H2Bc0NLnrxBgUxiwKQLYFAVsioF9Fwez+QGbQpbYlABsSgI2pQCb0oBNGbDvsmC2AGBT2LAb88ouLCjvQvIu7OrGIuK5qDjFxClu2I3lAOPygHEFwLgiYFwJcKsMZosCxiUsff6qADZVAZtqgE11wKYG2HdNMFsMsClpiU0twKY2YFMHsKkL2NQD+65P3nGATSnDbiwiu7CEvEvKu5SrG0uL5zLilBWnnGE3NgCMGwLGjQDjxoBxE8CtKZgtAxiXt/T5awbYNAdsWgA2LQGbVmDfrcn3GMCmgiU2bQCbtoBNO8CmPWDTAey7I5gtB9hUNOzG0rILy8u7grwrurqxkniuLE4VcaoadmMnwLgzYNwFMO4KGHcD3LqT75iAcTVLn78egE1PwKYXYNMbsOkD9t0XzFYBbKpbYtMPsOkP2AwAbAYCNoPAvgeD2aqATQ3Dbqwku7CavKvLu4arG2uK51ri1BanjmE3DgGMhwLGwwDj4YDxCMBtJJitBRjXtfT5GwXYjAZsxgA2YwGbcWDf48FsbcCmniU2EwCbiYDNJMBmMmAzBex7KpitA9jUN+zGmrIL68q7nrzru7qxgXhuKE4jcRobduM0wHg6YDwDMJ4JGM8C3GaD2YaAcRNLn785gM1cwGYeYDMfsFkA9r0QzDYCbJpaYrMIsFkM2CwBbJYCNsvAvpeD2caATTPDbmwgu7CJvJvKu5mrG5uL5xbitBSnlWE3rgCMVwLGqwDj1YDxGsBtLZhtARi3tvT5WwfYrAdsNgA2GwGbTWDfm8FsS8CmjSU2WwCbrYDNNsBmO2CzA+x7J5htBdi0NezG5rILW8u7jbzburqxnXhuL04HcToaduMuwHg3YLwHMN4LGO8D3PaD2faAcSdLn78DgM1BwOYQYHMYsDkC9n0UzHYAbDpbYnMMsDkO2JwAbE4CNqfAvk+T/24D2HQx7MZ2sgs7ybuzvLu4urGreO4mTndxehh24xnA+CxgfA4wPg8YXwDcLoLZboBxT0ufv0uAzWXA5gpgcxWwuQb2fZ38NzXAppclNjcAm5uAzS3A5jZgcwfs+y6Y7QHY9Dbsxq6yC3vKu5e8e7u6sY947itOP3H6G3bjPcD4PmD8ADB+CBg/Atwek/9uChgPsPT5ewLYPAVsngE2zwGbF2DfL8FsP8BmoCU2rwCb14DNG8DmLWDzDuz7PZjtD9gMMuzGPrILB8h7oLwHubpxsHgeIs5QcYYZduMHwPgjYPwJMP4MGH8B3L6C2SGA8XBLn79vgM13wMaJpM4mQCR1NgEjqe87EJgdCtiMsMQmcCR1Nh6R1NkEAWw8AZugYN/BwOwwwGakYTcOll04XN4j5D3S1Y2jxPNoccaIM9awG4MDxiEAYy/AOCRg7A24hQKzowHjcZY+fz6ATWjAxhewCQPYhAX7DgdmxwA24y2xCQ/YRABsIgI2kQCbyGDfUcDsWMBmgmE3jpJdOE7e4+U9wdWNE8XzJHEmizPFsBujAsbRAOPogHEMwNgPcIsJZicBxlMtff5iATaxAZs4gE1cwCYe2Hd8MDsZsJlmiU0CwCYhYJMIsEkM2CQB+04KZqcANtMNu3Gi7MKp8p4m7+mubpwhnmeKM0uc2YbdmAwwTg4YpwCMUwLGqQC31GB2JmA8x9LnLw1gkxawSQfYpAdsMoB9ZwSzswCbuZbYZAJsMgM2WQCbrIBNNrDv7GB2NmAzz7AbZ8gunCPvufKe5+rG+eJ5gTgLxVlk2I05AOOcgHEuwDg3YJwHcMsLZhcAxostff7yATb5AZsCgE1BwKYQ2HdhMLsQsFliiU0RwKYoYFMMsCkO2JQA+y4JZhcBNksNu3G+7MLF8l4i76WublwmnpeLs0KclYbdWAowLg0YlwGMywLG5QC38mB2OWC8ytLnrwJgUxGwqQTYVAZsqoB9VwWzKwCb1ZbYVANsqgM2NQCbmoBNLbDv2mB2JWCzxrAbl8kuXCXv1fJe4+rGteJ5nTjrxdlg2I11AOO6gHE9wLg+YNwAcGsIZtcBxhstff4aATaNAZsmgE1TwKYZ2HdzMLsesNlkiU0LwKYlYNMKsGkN2LQB+24LZjcANpsNu3Gt7MKN8t4k782ubtwinreKs02c7Ybd2A4wbg8YdwCMOwLGnQC3zmB2K2C8w9Lnrwtg0xWw6QbYdAdseoB99wSz2wCbnZbY9AJsegM2fQCbvoBNP7Dv/mB2O2Czy7Abt8gu3CHvnfLe5erG3eJ5jzh7xdln2I0DAOOBgPEgwHgwYDwEcBsKZvcAxvstff6GATbDAZsRgM1IwGYU2PdoMLsXsDlgic0YwGYsYDMOsBkP2EwA+54IZvcBNgcNu3G37ML98j4g74Oubjwkng+Lc0Sco4bdOAkwngwYTwGMpwLG0wC36WD2MGB8zNLnbwZgMxOwmQXYzAZs5oB9zwWzRwCb45bYzANs5gM2CwCbhYDNIrDvxWD2KGBzwrAbD8kuPCbv4/I+4erGk+L5lDinxTlj2I1LAOOlgPEywHg5YLyC/D0xmD0FGJ+19PlbBdisBmzWADZrAZt15O8QwexpwOacJTYbAJuNgM0mwGYzYLOF/P0SmD0D2Jw37MaTsgvPyvucvM+7uvGCeL4oziVxLht24zbAeDtgvAMw3gkY7wLcdoPZi4DxFUufvz2AzV7AZh9gsx+wOQD2fRDMXgJsrlpicwiwOQzYHAFsjgI2x8C+j4PZy4DNNcNuvCC78Iq8r8r7mqsbr4vnG+LcFOeWYTeeAIxPAsanAOPTgPEZwO0smL0BGN+29Pk7B9icB2wuADYXAZtL5DMFZm8CNncssbkC2FwFbK4BNtcBmxtk32D2FmBz17Abr8suvC3vO/K+6+rGe+L5vjgPxHlo2I23AOPbgPEdwPguYHwPcLtPZgHjR5Y+fw8Am4eAzSPA5jFg8wTs+ymYfQDYPLbE5hlg8xyweQHYvARsXoF9vwazDwGbJ4bdeE924SN5P5b3E1c3PhXPz8R5Ls4Lw258Axi/BYzfAcbvAeMPgNtHMPsMMH6p+fn7m5/fz/9q53f/fAJsPoOsz0HWV5a65gvI+hV4+A14+B146ERW33cAMPsCsHlt2DVPZbe8lPcreb92dc0b8fxWnHfivDfsmoCR1RkHiqzOOHBkdcYekdUZBwHcPMHsW8D4g6XPX1DAJhhgExywCQHYeIF9hwSz7wCbj5bYeAM2oQAbH8AmNGDjC/YdBsy+B2w+GXbjG9mFH+T9Ud6fXN34WTx/EeerON8MuzEsYBwOMA4PGEcAjCMCbpHA7BfA+Lulz19kwCYKYBMVsIkG2EQH+44BZr8CNk4hO2z8AJuYgE0swCY2YBMH7DsumP0G2AQAbH7VjZ9lF36X9w/WAeTP/XsuoHgO9OP/Lo5HoZ9/s5RxPMA4PmCcADBOCBgnAtwSg9lAhdQZB7H0+UsC2CQFbJIBNskBmxRg3ynBbGDAxtMSm1SATWrAJg1gkxawSQf2nR7MegA2QQ27MaDswiDy9pR3UFc3BhPPwcUJIY6XYTdmAIwzAsaZAOPMgHEWwC0rmA0OGIe09PnLBthkB2xyADY5AZtcYN+5wWwIwMbbEps8gE1ewCYfYJMfsCkA9l0QzHoBNqEMuzGY7MKQ8vaWdyhXN/qI59Di+IoTxrAbCwHGhQHjIoBxUcC4GOBWHMyGBozDWvr8lQBsSgI2pQCb0oBNGbDvsmDWF7AJZ4lNOcCmPGBTAbCpCNhUAvuuTP5uErAJb9iNPrILw8o7nLzDu7oxgniOKE4kcSIbdmMVwLgqYFwNMK4OGNcA3GqC2YiAcRRLn79agE1twKYOYFMXsKkH9l2f/L0xYBPVEpsGgE1DwKYRYNMYsGkC9t0UzEYGbKIZdmME2YVR5B1V3tFc3RhdPMf48e8RJ6ZhNzYDjJsDxi0A45aAcSvArTX5bwOAcSxLn782gE1bwKYdYNMesOkA9t0RzPoBNrEtsekE2HQGbLoANl0Bm25g393BbEzAJo5hN0aXXRhL3rHlHcfVjXHFczxx4ouTwLAbewDGPQHjXoBxb8C4D+DWF8zGA4wTWvr89QNs+gM2AwCbgYDNILDvwWA2PmCTyBKbIYDNUMBmGGAzHLAZAfY9EswmAGwSG3ZjXNmFCeWdSN6JXd2YRDwnFSeZOMkNu3EUYDwaMB4DGI8FjMcBbuPBbFLAOIWlz98EwGYiYDMJsJkM2EwB+54KZpMBNiktsZkG2EwHbGYANjMBm1lg37PBbHLAJpVhNyaRXZhC3inlncrVjanFcxpx0oqTzrAb5wDGcwHjeYDxfMB4AeC2EMymAYzTW/r8LQJsFgM2SwCbpYDNMrDv5WA2LWCTwRKbFYDNSsBmFWCzGrBZA/a9FsymA2wyGnZjatmF6eWdQd4ZXd2YSTxnFieLOFkNu3EdYLweMN4AGG8EjDcBbpvBbGbAOJulz98WwGYrYLMNsNkO2OwA+94JZrMANtktsdkF2OwGbPYANnsBm31g3/vBbFbAJodhN2aSXZhN3tnlncPVjTnFcy5xcouTx7AbDwDGBwHjQ4DxYcD4COB2FMzmAozzWvr8HQNsjgM2JwCbk4DNKbDv02A2N2CTzxKbM4DNWcDmHGBzHrC5APZ9EczmAWzyG3ZjTtmFeeWdT975Xd1YQDwXFKeQOIUNu/ESYHwZML4CGF8FjK8BbtfBbEHAuIilz98NwOYmYHMLsLkN2NwB+74LZgsBNkUtsbkH2NwHbB4ANg8Bm0dg34/BbGHApphhNxaQXVhE3kXlXczVjcXFcwlxSopTyrAbnwDGTwHjZ4Dxc8D4BeD2EsyWAIxLW/r8vQJsXgM2bwCbt4DNO7Dv92C2JGBTxhKbD4DNR8DmE2DzGbD5Avb9FcyWAmzKGnZjcdmFpeVdRt5lXd1YTjyXF6eCOBUNu/EbYPwdMHaiqDMO8KdZ1y8IqDT71y8IBGbLA8aVLH3+AkdRZ+MRRZ1NEMDGE7AJCvYdDMxWAGwqW2ITHLAJAdh4ATYhARtvsO9QYLYiYFPFsBvLyS6sJO/K8q7i6saq4rmaONXFqWHYjT6AcWjA2BcwDgMYhwXcwoHZaoBxTUufv/CATQTAJiJgEwmwiQz2HQXMVgdsalliExWwiQbYRAdsYgA2fmDfMcFsDcCmtmE3VpVdWFPeteRd29WNdcRzXXHqiVPfsBtjAcaxAeM4gHFcwDge4BYfzNYFjBtY+vwlAGwSAjaJAJvEgE0SsO+kYLYeYNPQEptkgE1ywCYFYJMSsEkF9p0azNYHbBoZdmMd2YUN5N1Q3o1c3dhYPDcRp6k4zQy7MQ1gnBYwTgcYpweMMwBuGcFsE8C4uaXPXybAJjNgkwWwyQrYZAP7zg5mmwI2LSyxyQHY5ARscgE2uQGbPGDfecFsM8CmpWE3NpZd2FzeLeTd0tWNrcRza3HaiNPWsBvzAcb5AeMCgHFBwLgQ4FYYzLYGjNtZ+vwVAWyKAjbFAJvigE0JsO+SYLYNYNPeEptSgE1pwKYMYFMWsClH/u4dzLYFbDoYdmMr2YXt5N1e3h1c3dhRPHcSp7M4XQy7sQJgXBEwrgQYVwaMqwBuVcFsJ8C4q6XPXzXApjpgUwOwqQnY1AL7rg1mOwM23SyxqQPY1AVs6gE29QGbBmDfDcFsF8Cmu2E3dpRd2FXe3eTd3dWNPcRzT3F6idPbsBsbAcaNAeMmgHFTwLgZ4NYczPYEjPtY+vy1AGxaAjatAJvWgE0b8n0DzPYCbPpaYtMOsGkP2HQAbDoCNp3IuwjM9gZs+hl2Yw/ZhX3k3Vfe/Vzd2F88DxBnoDiDDLuxC2DcFTDuBhh3B4x7kL4DswMA48GWPn+9AJvegE0fwKYvYNMP7Ls/mB0I2AyxxGYAYDMQsBkE2AwGbIaAfQ8Fs4MAm6GG3dhfduFgeQ+R91BXNw4Tz8PFGSHOSMNuHAYYDweMRwDGIwHjUYDbaDA7HDAeZenzNwawGQvYjANsxgM2E8C+J4LZEYDNaEtsJgE2kwGbKYDNVMBmGtj3dDA7ErAZY9iNw2QXjpL3aHmPcXXjWPE8Tpzx4kww7MYZgPFMwHgWYDwbMJ4DuM0Fs+MA44mWPn/zAJv5gM0CwGYhYLMI7HsxmB0P2EyyxGYJYLMUsFkG2CwHbFaAfa8EsxMAm8mG3ThWduFEeU+S92RXN04Rz1PFmSbOdMNuXAUYrwaM1wDGawHjdYDbejA7FTCeYenztwGw2QjYbAJsNgM2W8C+t4LZaYDNTEtstgE22wGbHYDNTsBmF9j3bvIdE7CZZdiNU2QXzpD3THnPcnXjbPE8R5y54swz7MY9gPFewHgfYLwfMD4AuB0Es3MA4/mWPn+HAJvDgM0RwOYoYHMM7Ps4+f4P2CywxOYEYHMSsDkF2JwGbM6AfZ8Fs/MAm4WG3ThbduF8eS+Q90JXNy4Sz4vFWSLOUsNuPAcYnweMLwDGFwHjS4DbZfJnPMB4maXP3xXA5ipgcw2wuQ7Y3AD7vglmlwA2yy2xuQXY3AZs7gA2dwGbe2Df98HsUsBmhWE3LpJduEzey+W9wtWNK8XzKnFWi7PGsBsfAMYPAeNHgPFjwPgJ4PYUzK4CjNda+vw9A2yeAzYvAJuXgM0rsO/XYHY1YLPOEps3gM1bwOYdYPMesPkA9v0RzK4BbNYbduNK2YVr5b1O3utd3bhBPG8UZ5M4m//RjX/P+P0cwfndP58A489gZxvBzrZY8vkLyPoV+PwN+Pwd+OxEVd93ADC7CbDZaolNwKjqbAJFVWcTOKo6G4+o6myCgH17gtnNgM02w67ZILtli7y3ynubq2u2i+cd4uwUZ5fh97CggHEwwDg4YBwCMPYC3EKC2R2A8W5Lnz9vwCYUYOMD2IQGbHzBvsOA2Z2AzR5LbMICNuEAm/CATQTAJiLYdyQwuwuw2WvYjdtlF+6W9x5573V14z7xvF+cA+IcNOzGyIBxFMA4KmAcDTCODrjFALP7AeNDlj5/foBNTMAmFmATG7CJA/YdF8weAGwOW2ITD7CJD9gkAGwSAjaJwL4Tg9mDgM0Rw27cJ7vwkLwPy/uIqxuPiudj4hwX54RhNyYBjJMCxskA4+SAcQrALSWYPQYYn7T0+UsF2KQGbNIANmkBm3Rg3+nB7HHA5pQlNhkAm4yATSbAJjNgkwXsOyuYPQHYnDbsxqOyC0/K+5S8T7u68Yx4PivOOXHOG3ZjNsA4O2CcAzDOCRjnAtxyg9mzgPEFS5+/PIBNXsAmH2CTH7ApAPZdEMyeA2wuWmJTCLApDNgUAWyKAjbFwL6Lg9nzgM0lw248I7vwgrwvyvuSqxsvi+cr4lwV55phN5YAjEsCxqUA49KAcRnArSyYvQIYX7f0+SsH2JQHbCoANhUBm0pg35XB7FXA5oYlNlUAm6qATTXApjpgUwPsuyaYvQbY3DTsxsuyC6/L+4a8b7q68ZZ4vi3OHXHuGnZjLcC4NmBcBzCuCxjXA9zqg9nbgPE9S5+/BoBNQ8CmEWDTGLBpAvbdFMzeAWzuW2LTDLBpDti0AGxaAjatwL5bg9m7gM0Dw268Jbvwnrzvy/uBqxsfiudH4jwW54lhN7YBjNsCxu0A4/aAcQfArSOYfQQYP7X0+esE2HQGbLoANl0Bm25g393B7GPA5pklNj0Am56ATS/Apjdg0wfsuy+YfQLYPDfsxoeyC5/K+5m8n7u68YV4finOK3FeG3ZjP8C4P2A8ADAeCBgPAtwGg9mXgPEbS5+/IYDNUMBmGGAzHLAZAfY9Esy+AmzeWmIzCrAZDdiMAWzGAjbjwL7Hg9nXgM07w258Ibvwjbzfyvudqxvfi+cP4nwU55NhN04AjCcCxpMA48mA8RTAbSqY/QAYf7b0+ZsG2EwHbGYANjMBm1lg37PB7EfA5oslNnMAm7mAzTzAZj5gswDseyGY/QTYfDXsxveyCz/L+4u8v7q68Zt4/v6jEwuL/13hn3+zlPEiwHgxYLwEMF4KGC8D3JaD2e+AccDCdj5/KwCblYDNKsBmNWCzBux7LZh1CquzCWSJzTrAZj1gswGw2QjYbAL73gxmAwA2gQGbX3XjN9mFPz5/P+5A8v7xc/+e8xDPQcTxFCeoYTduAYy3AsbbAOPtgPEOwG0nmA0CGAez9PnbBdjsBmz2ADZ7AZt9YN/7wawnYBPcEpsDgM1BwOYQYHMYsDkC9n0UzAYFbEIYdqOH7MJg8g4u7xCubvQSzyHF8RYnlGE3HgOMjwPGJwDjk4DxKcDtNJgNCRj7WPr8nQFszgI25wCb84DNBbDvi2DWG7AJbYnNJcDmMmBzBbC5CthcA/u+DmZDATa+ht3oJbvQR96h5e3r6sYw4jmsOOHECW/YjTcA45uA8S3A+DZgfIf8vy8As2EB4wiWPn/3AJv7gM0DwOYhYPOI/LdnMBsOsIloic0TwOYpYPMMsHkO2Lwg/10SzIYHbCIZdmMY2YUR5B1R3pFc3RhZPEcRJ6o40Qy78RVg/BowfgMYvwWM3wFu78FsFMA4uqXP3wfA5iNg8wmw+QzYfAH7/gpmowI2MSyx+QbYfAdsnGjqbAJEU2cTMJr6vgOB2WiAjZ9hN0aWXRhd3jHk7efqxpjiOZY4scWJY9iNgaOpM/aIps44CGDsCRgHBdyCgdlYgHFcS5+/4IBNCMDGC7AJCdh4g32HArOxAZt4ltj4ADahARtfwCYMYBMW7DscmI0D2MQ37MaYsgvjyjuevOO7ujGBeE4oTiJxEht2Y3jAOAJgHBEwjgQYRwbcooDZhIBxEkufv6iATTTAJjpgEwOw8QP7jglmEwE2SS2xiQXYxAZs4gA2cQGbeGDf8cFsYsAmmWE3JpBdmETeSeWdzNWNycVzCnFSipPKsBsTAMYJAeNEgHFiwDgJ4JYUzKYAjFNb+vwlA2ySAzYpAJuUgE0qsO/UYDYlYJPGEps0gE1awCYdYJMesMkA9p0RzKYCbNIadmNy2YWp5Z1G3mld3ZhOPKcXJ4M4GQ27MRNgnBkwzgIYZwWMswFu2cFsesA4k6XPXw7AJidgkwuwyQ3Y5AH7zgtmMwA2mS2xyQfY5AdsCgA2BQGbQmDfhUmPAjZZDLsxnezCTPLOLO8srm7MKp6ziZNdnByG3VgEMC4KGBcDjIsDxiUAt5JgNhtgnNPS568UYFMasCkD2JQFbMqBfZcn7zjAJpclNhUAm4qATSXApjJgUwXsuyqYzQHY5DbsxqyyC3PKO5e8c7u6MY94zitOPnHyG3ZjNcC4OmBcAzCuCRjXAtxqk+8xgHEBS5+/OoBNXcCmHmBTH7BpAPbdEMzmA2wKWmLTCLBpDNg0AWyaAjbNwL6bg9n8gE0hw27MI7uwgLwLyruQqxsLi+ci4hQVp5hhN7YAjFsCxq0A49aAcRvArS2YLQIYF7f0+WsH2LQHbDoANh0Bm05g353BbFHApoQlNl0Am66ATTfApjtg0wPsuyeYLQbYlDTsxsKyC4vLu4S8S7q6sZR4Li1OGXHKGnZjL8C4N2DcBzDuCxj3A9z6g9nSgHE5S5+/AYDNQMBmEGAzGLAZAvY9FMyWAWzKW2IzDLAZDtiMAGxGAjajwL5Hg9mygE0Fw24sJbuwnLzLy7uCqxsriudK4lQWp4phN44BjMcCxuMA4/GA8QTAbSKYrQQYV7X0+ZsE2EwGbKYANlMBm2lg39PBbGXAppolNjMAm5mAzSzAZjZgMwfsey6YrQLYVDfsxoqyC6vKu5q8q7u6sYZ4rilOLXFqG3bjPMB4PmC8ADBeCBgvAtwWg9magHEdS5+/JYDNUsBmGWCzHLBZAfa9EszWAmzqWmKzCrBZDdisAWzWAjbrwL7Xk7/TB2zqGXZjDdmFdeRdV971XN1YXzw3EKehOI0Mu3EDYLwRMN4EGG8GjLcAblvBbAPAuLGlz982wGY7YLMDsNkJ2OwC+95N/rsNYNPEEps9gM1ewGYfYLMfsDkA9n0QzDYCbJoadmN92YWN5d1E3k1d3dhMPDcXp4U4LQ278RBgfBgwPgIYHwWMjwFux8l/mwOMW1n6/J0AbE4CNqcAm9OAzRmw77NgtgVg09oSm3OAzXnA5gJgcxGwuQT2fRnMtgRs2hh2YzPZha3k3VrebVzd2FY8txOnvTgdDLvxCmB8FTC+BhhfB4xvAG43wWw7wLijpc/fLcDmNmBzB7C5C9jcA/u+D2bbAzadLLF5ANg8BGweATaPAZsnYN9PwWwHwKazYTe2lV3YUd6d5N3Z1Y1dxHNXcbqJ092wG58Bxs8B4xeA8UvA+BXg9hrMdgWMe1j6/L0BbN4CNu8Am/eAzQew749gthtg01OTzd+fLb+f/9XO7/75BNh8Blm7g6y9DLumi+yWHvLuKe9erq7pLZ77iNNXnH6GXfMF7Owr8Pkb8Pk78NmJrs4tAJjtAxj3t9Q1AaOrswkUXZ1N4OjqbDyiq7MJAvbtCWb7AjYDLLEJCtgEA2yCAzYhABsvsO+QYLYfYDPQsBt7yy7sL+8B8h7o6sZB4nmwOEPEGWrYjd6AcSjA2AcwDg0Y+wJuYcDsYMB4mKXPX1jAJhxgEx6wiQDYRAT7jgRmhwA2wy2xiQzYRAFsogI20QCb6GDfMcDsUMBmhGE3DpJdOEzew+U9wtWNI8XzKHFGizPGsBv9AOOYgHEswDg2YBwHcIsLZkcBxmMtff7iATbxAZsEgE1CwCYR2HdiMDsasBlniU0SwCYpYJMMsEkO2KQA+04JZscANuMNu3Gk7MKx8h4n7/GubpwgnieKM0mcyYbdmAowTg0YpwGM0wLG6QC39GB2ImA8xdLnLwNgkxGwyQTYZAZssoB9ZwWzkwCbqZbYZANssgM2OQCbnIBNLrDv3GB2MmAzzbAbJ8gunCLvqfKe5urG6eJ5hjgzxZll2I15AOO8gHE+wDg/YFwAcCsIZmcAxrMtff4KATaFAZsigE1RwKYY2HdxMDsTsJljiU0JwKYkYFMKsCkN2JQB+y4LZmcBNnMNu3G67MLZ8p4j77mubpwnnueLs0CchYbdWA4wLg8YVwCMKwLGlQC3ymB2PmC8yNLnrwpgUxWwqQbYVAdsaoB91wSzCwCbxZbY1AJsagM2dQCbuoBNPbDv+mB2IWCzxLAb58kuXCTvxfJe4urGpeJ5mTjLxVlh2I0NAOOGgHEjwLgxYNwEcGsKZpcBxistff6aATbNAZsWgE1LwKYV2HdrMLscsFlliU0bwKYtYNMOsGkP2HQA++4IZlcANqsNu3Gp7MKV8l4l79WublwjnteKs06c9Ybd2Akw7gwYdwGMuwLG3QC37mB2LWC8wdLnrwdg0xOw6QXY9AZs+oB99wWz6wCbjZbY9ANs+gM2AwCbgYDNIPL/ZgPMrgdsNhl24xrZhRvkvVHem1zduFk8bxFnqzjbDLtxCGA8FDAeBhgPB4xHAG4jwewWwHi7pc/fKMBmNGAzBrAZC9iMA/seD2a3AjY7LLGZANhMBGwmATaTAZspYN9Twew2wGanYTdull24Xd475L3T1Y27xPNucfaIs9ewG6cBxtMB4xmA8UzAeBbgNhvM7gaM91n6/M0BbOYCNvMAm/mAzQLy91Rgdg9gs98Sm0WAzWLAZglgsxSwWUb+DgPM7gVsDhh24y7ZhfvkvV/eB1zdeFA8HxLnsDhHDLtxBWC8EjBeBRivBozXkD8ng9lDgPFRS5+/dYDNesBmA2CzEbDZBPa9GcweBmyOWWKzBbDZCthsA2y2AzY7wL53gtkjgM1xw248KLvwqLyPyfu4qxtPiOeT4pwS57RhN+4CjHcDxnsA472A8T7AbT+YPQkYn7H0+TsA2BwEbA4BNocBmyNg30fB7CnA5qwlNscAm+OAzQnA5iRgcwrs+zSZBWzOGXbjCdmFZ+R9Vt7nXN14XjxfEOeiOJcMu/EMYHwWMD4HGJ8HjC8AbhfB7AXA+LKlz98lwOYyYHMFsLkK2FwD+75OOAI2VyyxuQHY3ARsbgE2twGbO2Dfd8HsJcDmqmE3npddeFneV+R91dWN18TzdXFuiHPTsBvvAcb3AeMHgPFDwPgR4PaYfFYB41uWPn9PAJungM0zwOY5YPMC7PslmL0B2Ny2xOYVYPMasHkD2LwFbN6Bfb8HszcBmzuG3XhNduEted+W9x1XN94Vz/fEuS/OA8Nu/AAYfwSMPwHGnwHjL4DbVzB7DzB+aOnz9w2w+Q7YODHU2QSIoc4mYAz1fQcCs/cBm0eW2ASOoc7GI4Y6myCAjSdgExTsOxiYfQDYPDbsxruyCx/K+5G8H7u68Yl4firOM3GeG3ZjcMA4BGDsBRiHBIy9AbdQYPYpYPzC0ufPB7AJDdj4AjZhAJuwYN/hwOwzwOalJTbhAZsIgE1EwCYSYBMZ7DsKmH0O2Lwy7MYnsgtfyPulvF+5uvG1eH4jzltx3hl2Y1TAOBpgHB0wjgEY+wFuMcHsG8D4vaXPXyzAJjZgEwewiQvYxAP7jg9m3wI2HyyxSQDYJARsEgE2iQGbJGDfScHsO8Dmo2E3vpZd+F7eH+T90dWNn8TzZ3G+iPPVsBuTAcbJAeMUgHFKwDgV4JYazH4GjL9Z+vylAWzSAjbpAJv0gE0GsO+MYPYLYPPdEptMgE1mwCYLYJMVsMkG9p0dzH4FbJwiZt34SXbhN3l/l/ePn/ufOfEcUJxAP/5nRX7+zVLGOQDjnIBxLsA4N2CcB3DLC2YDFlFn7AEYu/+hbPIBNvkBmwKATUHAphDYd2Hyd5OATRBLbIoANkUBm2KATXHApgTYd0kwGxiw8TTsxh+99+P2kHcQeXu6ujGoeA4mTnBxQhh2YynAuDRgXAYwLgsYlwPcypO/fwaMvSx9/ioANhUBm0qATWXApgrYd1UwGxywCWmJTTXApjpgUwOwqQnY1AL7rg1mQwA23obdGFR2oZe8Q8rb29WNocSzjzihxfE17MY6gHFdwLgeYFwfMG4AuDUEsz6AcRhLn79GgE1jwKYJYNMUsGkG9t0czIYGbMJaYtMCsGkJ2LQCbFoDNm3AvtuCWV/AJpxhN4aSXRhG3mHlHc7VjeHFcwRxIooTybAb2wHG7QHjDoBxR8C4E+DWGcxGAIwjW/r8dQFsugI23QCb7oBND7DvnmA2ImATxRKbXoBNb8CmD2DTF7DpB/bdH8xGAmyiGnZjeNmFkeUdRd5RXd0YTTxHFyfGj3+XYTcOAIwHAsaDAOPBgPEQwG0omI0OGMe09PkbBtgMB2xGADYjAZtRYN+jwWwMwCaWJTZjAJuxgM04wGY8YDMB7HsimPUDbGIbdmM02YUx5R1L3rFd3RhHPMcVJ5448Q27cRJgPBkwngIYTwWMpwFu08FsXMA4gaXP3wzAZiZgMwuwmQ3YzAH7ngtm4wE2CS2xmQfYzAdsFgA2CwGbRWDfi8FsfMAmkWE3xpFdmEDeCeWdyNWNicVzEnGSipPMsBuXAMZLAeNlgPFywHgF4LYSzCYBjJNb+vytAmxWAzZrAJu1gM06sO/1YDYpYJPCEpsNgM1GwGYTYLMZsNkC9r0VzCYDbFIadmNi2YXJ5Z1C3ild3ZhKPKcWJ404aQ27cRtgvB0w3gEY7wSMdwFuu8FsasA4naXP3x7AZi9gsw+w2Q/YHAD7Pghm0wA26S2xOQTYHAZsjgA2RwGbY2Dfx8FsWsAmg2E3ppJdmE7e6eWdwdWNGcVzJnEyi5PFsBtPAMYnAeNTgPFpwPgM4HYWzGYCjLNa+vydA2zOAzYXAJuLgM0lsO/LYDYzYJPNEpsrgM1VwOYaYHMdsLkB9n0TzGYBbLIbdmNG2YVZ5Z1N3tld3ZhDPOcUJ5c4uQ278RZgfBswvgMY3wWM7wFu98FsTsA4j6XP3wPA5iFg8wiweQzYPAH7fgpmcwE2eS2xeQbYPAdsXgA2LwGbV2Dfr8FsbsAmn2E35pBdmEfeeeWdz9WN+cVzAXEKilPIsBvfAMZvAeN3gPF7wPgD4PYRzBYAjAtrfv7+5uf387/a+d0/nwCbzyBrQZC1iKHP+aW/heVdRN6FXD4XFc/FxCkuTokivw7rp/j7LVnk93sIVjLkxhJLgw0qvvTS7SmrOnxx/+88//Hv+fnf/ut//P73f/TLXxDAUf/cBHTUPzeB/jTr+gWBlWb/+gUejvq+S2l+Fui+gzjq+/Z01Pcd1FHfdzBHfd/BHfV9h3DU913a0r69HPV9h3TU9+3tqO87lKO+bx9Hfd+hHfV9lzHsv5Ky70rJu7S8y7j6r6x4LidOeXEqGL7PfR11bmEcdW5hHXVu4f406/oF4ZVm//oFEcBsOfCOq2jp+3RER51NJEedTWRHnU0UR51NVEd939HAbHnAppIlNtEddTYxHHU2fo46m5iOOptYjvq+Y4PZCoBNZcNuLCu7sKK8K8m7sqsbq4jnquJUE6e6YTfGcdQZx3XUGcdz1BnH/9Os6xckUJr96xckBLNVAeMalj5/iRx1NokddTZJHHU2SR11Nskc9X0nB7PVAJualtikcNTZpHTU2aRy1NmkdtTZpHHU950WzFYHbGoZdmMV2YU15F1T3rVc3VhbPNcRp6449Qy7MZ2jzji9o844g6POOOOfZl2/IJPS7F+/IDOYrQMY17f0+cviqLPJ6qizyeaos8nuqLPJ4ajvOyeYrQvYNLDEJpejzia3o84mj6POJq+jziafo77v/GC2HmDT0LAba8surC/vBvJu6OrGRuK5sThNxGlq2I0FHHXGBR11xoUcdcaF/zTr+gVFlGb/+gVFwWxjwLiZpc9fMUedTXFHnU0JR51NSUedTSlHfd+lwWwTwKa5JTZlHHU2ZR11NuUcdTblHXU2FRz1fVcEs00BmxaG3dhIdmEzeTeXdwtXN7YUz63EaS1OG8NurOSoM67sqDOu4qgzrvqnWdcvqKY0+9cvqA5mWwHGbS19/mo46mxqOupsajnqbGo76mzqOOr7rgtmWwM27Syxqeeos6nvqLNp4Kizaeios2nkqO+7MZhtA9i0N+zGlrIL28q7nbzbu7qxg3juKE4ncTobdmMTR51xU0edcTNHnXHzP826fkELpdm/fkFLMNsRMO5i6fPXylFn09pRZ9PGUWfT1lFn085R33d7MNsJsOlqiU0HR51NR0edTSdHnU1nR51NF0d9313BbGfAppthN3aQXdhF3l3l3c3Vjd3Fcw9xeorTy7AbuznqjLs76ox7OOqMe/5p1vULeinN/vULeoPZHoBxb0ufvz6OOpu+jjqbfo46m/6OOpsBjvq+B4LZnoBNH0tsBjnqbAY76myGOOpshjrqbIY56vseDmZ7ATZ9Dbuxu+zC3vLuI+++rm7sJ577izNAnIGG3TjCUWc80lFnPMpRZzz6T7OuXzBGafavXzAWzPYHjAdZ+vyNc9TZjHfU2Uxw1NlMdNTZTHLU9z0ZzA4AbAZbYjPFUWcz1VFnM81RZzPdUWczw1Hf90wwOxCwGWLYjf1kFw6S92B5D3F141DxPEyc4eKMMOzGWY4649mOOuM5jjrjuX+adf2CeUqzf/2C+WB2GGA80tLnb4Gjzmaho85mkaPOZrGjzmaJo77vpWB2OGAzyhKbZY46m+WOOpsVjjqblY46m1WO+r5Xg9kRgM1ow24cKrtwpLxHyXu0qxvHiOex4owTZ7xhN65x1BmvddQZr3PUGa//06zrF2xQmv3rF2wEs2MB4wmWPn+bHHU2mx11NlscdTZbHXU22xz1fW8Hs+MAm4mW2Oxw1NnsdNTZ7HLU2ex21NnscdT3vRfMjgdsJhl24xjZhRPkPVHek1zdOFk8TxFnqjjTDLtxn6POeL+jzviAo8744J9mXb/gkNLsX7/gMJidAhhPt/T5O+KosznqqLM55qizOe6osznhqO/7JJidCtjMsMTmlKPO5rSjzuaMo87mrKPO5pyjvu/zYHYaYDPTsBsnyy6cLu8Z8p7p6sZZ4nm2OHPEmWvYjRccdcYXHXXGlxx1xpf/NOv6BVeUZv/6BVfB7GzAeJ6lz981R53NdUedzQ1Hnc1NR53NLUd937fB7BzAZr4lNnccdTZ3HXU29xx1NvcddTYPHPV9PwSzcwGbBYbdOEt24Tx5z5f3Alc3LhTPi8RZLM4Sw2585KgzfuyoM37iqDN++qdZ1y94pjT71y94DmYXAcZLLX3+XjjqbF466mxeOepsXjvqbN446vt+C2YXAzbLLLF556izee+os/ngqLP56Kiz+eSo7/szmF0C2Cw37MaFsguXynuZvJe7unGFeF4pzipxVht24xdHnfFXR53xN0ed8fc/zbp/QQB1bgHA7ErAeI2lz1/AAOpsAgVQZxM4gDobjwDqbIKAfXuC2VWAzVpLbIICNsEAm+CATQjAxgvsOySYXQ3YrDPsxhWyC9fIe62817m6cb143iDORnE2GXajN2AcCjD2AYxDA8a+gFsYMLsBMN5s6fMXFrAJB9iEB2wiADYRwb4jgdmNgM0WS2wiAzZRAJuogE00wCY62HcMMLsJsNlq2I3rZRdulvcWeW91deM28bxdnB3i7DTsRj/AOCZgHAswjg0YxwHc4oLZ7YDxLkufv3iATXzAJgFgkxCwSQT2nRjM7gBsdltikwSwSQrYJANskgM2KcC+U4LZnYDNHsNu3Ca7cJe8d8t7j6sb94rnfeLsF+eAYTemAoxTA8ZpAOO0gHE6wC09mN0HGB+09PnLANhkBGwyATaZAZssYN9Zwex+wOaQJTbZAJvsgE0OwCYnYJML7Ds3mD0A2Bw27Ma9sgsPyvuQvA+7uvGIeD4qzjFxjht2Yx7AOC9gnA8wzg8YFwDcCoLZo4DxCUufv0KATWHApghgUxSwKQb2XRzMHgNsTlpiUwKwKQnYlAJsSgM2ZcC+y4LZ44DNKcNuPCK78IS8T8r7lKsbT4vnM+KcFeecYTeWA4zLA8YVAOOKgHElwK0ymD0DGJ+39PmrAthUBWyqATbVAZsaYN81wexZwOaCJTa1AJvagE0dwKYuYFMP7Ls+mD0H2Fw07MbTsgvPy/uCvC+6uvGSeL4szhVxrhp2YwPAuCFg3AgwbgwYNwHcmoLZy4DxNUufv2aATXPApgVg0xKwaQX23RrMXgFsrlti0wawaQvYtANs2gM2HcC+O4LZq4DNDcNuvCS78Jq8r8v7hqsbb4rnW+LcFueOYTd2Aow7A8ZdAOOugHE3wK07mL0FGN+19PnrAdj0BGx6ATa9AZs+YN99wextwOaeJTb9AJv+gM0AwGYgYDMI7HswmL0D2Nw37MabsgvvyvuevO+7uvGBeH4oziNxHht24xDAeChgPAwwHg4YjwDcRoLZh4DxE0ufv1GAzWjAZgxgMxawGQf2PR7MPgJsnlpiMwGwmQjYTAJsJgM2U8C+p4LZx4DNM8NufCC78Im8n8r7masbn4vnF+K8FOeVYTdOA4ynA8YzAOOZgPEswG02mH0BGL+29PmbA9jMBWzmATbzAZsFYN8LwexLwOaNJTaLAJvFgM0SwGYpYLMM7Hs5mH0F2Lw17Mbnsgtfy/uNvN+6uvGdeH4vzgdxPhp24wrAeCVgvAowXg0YrwHc1oLZ94DxJ0ufv3WAzXrAZgNgsxGw2QT2vRnMfgBsPltiswWw2QrYbANstgM2O8C+d4LZj4DNF8NufCe78JO8P8v7i6sbv4rnb+J8/9GLRX/+zVLGuwDj3YDxHsB4L2C8D3DbD2a/AcY//n/S9d+f+//v83cAsDkI2BwCbA4DNkfAvo+C2e+ATUBLbI4BNscBmxOAzUnA5hTY92kw6xRVZxMIsPlVN36VXfjj8/fjDijvHz/377nA4tlDnCDieBp24xnA+CxgfA4wPg8YXwDcLoJZD8A4qKXP3yXA5jJgcwWwuQrYXAP7vg5mgwA2wSyxuQHY3ARsbgE2twGbO2Dfd8GsJ2AT3LAbA8suDCrvYPIO7urGEOLZS5yQ4ngbduM9wPg+YPwAMH4IGD8C3B6DWS/AOJSlz98TwOYpYPMMsHkO2LwA+34JZkMCNj6W2LwCbF4DNm8Am7eAzTuw7/dg1huwCW3YjSFkF4aSt4+8Q7u60Vc8hxEnrDjhDLvxA2D8ETD+BBh/Boy/AG5fwWwYwDi85ufvb35+P/+rnd/98w2w+Q6yhgVZI1jqGiegetYAAdU9DBhQ3cNAAdU9DBxQfd8eYDYcYBPRsGt8ZbeEl3cEeUd0dU0k8RxZnCjiRDXsmiCAsSdgHBQwDgYYBwfcQoDZyIBxNEufPy/AJiRg4w3YhAJsfMC+Q4PZKIBNdEtsfAGbMIBNWMAmHGATHuw7ApiNCtjEMOzGSLILo8k7urxjuLrRTzzHFCeWOLENuzEiYBwJMI4MGEcBjKMCbtHAbEzAOI6lz190wCYGYOMH2MQEbGKBfccGs7EAm7iW2MQBbOICNvEAm/iATQKw74SEI2ATz7Ab/WQXxpF3XHnHc3VjfPGcQJyE4iQy7MZEgHFiwDgJYJwUME4GuCUHswkA48SWPn8pAJuUgE0qwCY1YJMG7Dst+awCNkkssUkH2KQHbDIANhkBm0xg35nBbCLAJqlhN8aXXZhY3knkndTVjcnEc3JxUoiT0rAbswDGWQHjbIBxdsA4B+CWk/QoYJzK0ucvF2CTG7DJA9jkBWzygX3nB7MpAJvUltgUAGwKAjaFAJvCgE0RsO+iYDYlYJPGsBuTyS5MJe/U8k7j6sa04jmdOOnFyWDYjcUA4+KAcQnAuCRgXApwKw1m0wHGGS19/soANmUBm3KATXnApgLYd0Uwmx6wyWSJTSXApjJgUwWwqQrYVAP7rg5mMwA2mQ27Ma3swozyziTvzK5uzCKes4qTTZzsht1YAzCuCRjXAoxrA8Z1ALe6YDYrYJzD0uevHmBTH7BpANg0BGwagX03BrPZAJucltg0AWyaAjbNAJvmgE0LsO+WYDY7YJPLsBuzyC7MIe+c8s7l6sbc4jmPOHnFyWfYja0A49aAcRvAuC1g3A5waw9m8wDG+S19/joANh0Bm06ATWfApgvYd1cwmxewKWCJTTfApjtg0wOw6QnY9AL77g1m8wE2BQ27MbfswvzyLiDvgq5uLCSeC4tTRJyiht3YBzDuCxj3A4z7A8YDALeBYLYwYFzM0udvEGAzGLAZAtgMBWyGgX0PB7NFAJviltiMAGxGAjajAJvRgM0YsO+x5O8mAZsSht1YSHZhMXkXl3cJVzeWFM+lxCktThnDbhwHGI8HjCcAxhMB40mA22QwWwowLmvp8zcFsJkK2EwDbKYDNjPAvmeSvzcGbMpZYjMLsJkN2MwBbOYCNvPAvueD2TKATXnDbiwpu7CsvMvJu7yrGyuI54riVBKnsmE3LgCMFwLGiwDjxYDxEsBtKflvA4BxFUufv2WAzXLAZgVgsxKwWQX2vRrMVgJsqlpiswawWQvYrANs1gM2G8C+N4LZyoBNNcNurCC7sIq8q8q7mqsbq4vnGuLUFKeWYTduAow3A8ZbAOOtgPE2wG07mK0BGNe29PnbAdjsBGx2ATa7AZs9YN97wWxNwKaOJTb7AJv9gM0BwOYgYHMI7PswmK0F2NQ17Mbqsgtry7uOvOu6urGeeK4vTgNxGhp24xHA+ChgfAwwPg4YnwDcToLZ+oBxI0ufv1OAzWnA5gxgcxawOQf2fR7MNgBsGlticwGwuQjYXAJsLgM2V8C+r4LZhoBNE8NurCe7sJG8G8u7iasbm4rnZuI0F6eFYTdeA4yvA8Y3AOObgPEtwO02mG0GGLe09Pm7A9jcBWzuATb3AZsHYN8PwWxzwKaVJTaPAJvHgM0TwOYpYPMM7Ps5mG0B2LQ27MamsgtbyruVvFu7urGNeG4rTjtx2ht24wvA+CVg/Aowfg0YvwHc3oLZtoBxB0ufv3eAzXvA5gNg8xGw+QT2/RnMtgNsOlpi8wWw+QrYfANsvgM2TiD1fQcAs+0Bm06G3dhGdmEHeXeUdydXN3YWz13E6SpON8NuDBhInXGgQOqMAwdSZ+wRSJ1xEMDNE8x2AYy7W/r8BQVsggE2wQGbEICNF9h3SDDbFbDpYYmNN2ATCrDxAWxCAza+YN9hwGw3wKanYTd2ll3YXd495N3T1Y29xHNvcfqI09ewG8MCxuEA4/CAcQTAOCLgFgnM9gaM+1n6/EUGbKIANlEBm2iATXSw7xhgtg9g098SGz/AJiZgEwuwiQ3YxAH7jgtm+wI2Awy7sZfswn7y7i/vAa5uHCieB4kzWJwhht0YDzCODxgnAIwTAsaJALfEYHYQYDzU0ucvCWCTFLBJBtgkB2xSgH2nBLODAZthltikAmxSAzZpAJu0gE06sO/0YHYIYDPcsBsHyi4cKu9h8h7u6sYR4nmkOKPEGW3YjRkA44yAcSbAODNgnAVwywpmRwLGYyx9/rIBNtkBmxyATU7AJhfYd24wOwqwGWuJTR7AJi9gkw+wyQ/YFAD7LghmRwM24wy7cYTswjHyHivvca5uHC+eJ4gzUZxJht1YCDAuDBgXAYyLAsbFALfiYHYCYDzZ0uevBGBTErApBdiUBmzKgH2XBbMTAZspltiUA2zKAzYVAJuKgE0lsO/KYHYSYDPVsBvHyy6cLO8p8p7q6sZp4nm6ODPEmWnYjVUA46qAcTXAuDpgXANwqwlmpwPGsyx9/moBNrUBmzqATV3Aph7Yd30wOwOwmW2JTQPApiFg0wiwaQzYNAH7bgpmZwI2cwy7cZrswlnyni3vOa5unCue54kzX5wFht3YDDBuDhi3AIxbAsatALfWYHYeYLzQ0uevDWDTFrBpB9i0B2w6gH13BLPzAZtFlth0Amw6AzZdAJuugE03sO/uYHYBYLPYsBvnyi5cKO9F8l7s6sYl4nmpOMvEWW7YjT0A456AcS/AuDdg3If8NzQwuxQwXmHp89cPsOkP2AwAbAYCNoPIf18Bs8sAm5WW2AwBbIYCNsMAm+GAzQjyd+9gdjlgs8qwG5fILlwh75XyXuXqxtXieY04a8VZZ9iNowDj0YDxGMB4LGA8DnAbD2bXAMbrLX3+JgA2EwGbSYDNZMBmCtj3VDC7FrDZYInNNMBmOmAzA7CZCdjMAvueDWbXATYbDbtxtezC9fLeIO+Nrm7cJJ43i7NFnK2G3TgHMJ4LGM8DjOcDxgsAt4VgdjNgvM3S528RYLMYsFkC2CwFbJaR7xtgdgtgs90SmxWAzUrAZhVgsxqwWUPeRWB2K2Czw7AbN8ku3Cbv7fLe4erGneJ5lzi7xdlj2I3rAOP1gPEGwHgjYLyJ9B2Y3QUY77X0+dsC2GwFbLYBNtsBmx1g3zvB7G7AZp8lNrsAm92AzR7AZi9gsw/sez+Y3QPY7Dfsxp2yC/fKe5+897u68YB4PijOIXEOG3bjAcD4IGB8CDA+DBgfAdyOgtmDgPERS5+/Y4DNccDmBGBzErA5BfZ9GsweAmyOWmJzBrA5C9icA2zOAzYXwL4vgtnDgM0xw248ILvwiLyPyvuYqxuPi+cT4pwU55RhN14CjC8DxlcA46uA8TXA7TqYPQEYn7b0+bsB2NwEbG4BNrcBmztg33fB7EnA5owlNvcAm/uAzQPA5iFg8wjs+zGYPQXYnDXsxuOyC0/L+4y8z7q68Zx4Pi/OBXEuGnbjE8D4KWD8DDB+Dhi/ANxegtnzgPElS5+/V4DNa8DmDWDzFrB5B/b9HsxeAGwuW2LzAbD5CNh8Amw+AzZfwL6/ku+YgM0Vw248J7vwkrwvy/uKqxuviudr4lwX58Y/uvHvGb+fIzi/++cbYPwd7Owa2NlNTZ8jyNvvX3/Xrn8C//T79/m30QA/z/7rjw4Y+J97+f2PDvQ/s7//0YED/2Lfv/nRHr+a/c2PDhL41xx/9aM9fzP7qx8dNPBv/fifHx0ssHpfBA/8b979/KND/Ovszz/aK/AffHb96JB/mnX9aO8/zv73R4dSmP37R/uozMofHVpt9v9+tK/i7I8fHSawegeEBbPXQV/ccs0GcHz+9f9z/0P7Ihzoi/CgLyKAvogI+iIS6IvIoC+igL6ICvoiGuiL6KAvYoC+8AN9ERP0RSzQF7FBX8QBfREX9EU80BfxQV8kAB2QEMzeAH1xG/TFr76TXZXfwW7K+5a8b7u+k90Rz3fFuSfO/X98J6O9kwj0TmLQO0lA7yQFvZMM9E5y0DspQO+kBL2TCvROatA7aUDvpAW9kw70TnrQOxlA72QEvZMJ9E5m0DtZQO9kBV2SDczeBb3zwNL3lOygL3KAvsgJ+iIX6IvcoC/ygL7IC/oiH+iL/KAvCoC+KAj6ohDoi8KgL4qAvigK+qIY6IvioC9KgL4oCfqiFOiA0mD2HuiLh5b6ogzoi7KgL8qBvigP+qIC6IuKoC8qgb6oDPqiCuiLqqAvqoG+qA76ogboi5qgL2qBvqgN+qIO6Iu6oC/qgb6oDzqgAZi9D/rikeGfa+7IP8c8kPdDeT9y/bnmsXh+Is5TcZ4Z/rmmIeidRqB3GoPeaQJ6pynonWagd5qD3mkBeqcl6J1WoHdag95pA3qnLeiddqB32oPe6QB6pyPonU6gdzqD3ukCuqQrmH0Ceue5pe8p3UBfdAd90QP0RU/QF71AX/QGfdEH9EVf0Bf9QF/0B30xAPTFQNAXg0BfDAZ9MQT0xVDQF8NAXwwHfTEC9MVI0AGjwOxT0BcvLPXFaNAXY0BfjAV9MQ70xXjQFxNAX0wEfTEJ9MVk0BdTQF9MBX0xDfTFdNAXM0BfzAR9MQv0xWzQF3NAX8wFfTEPdMB8MPsM9MVLwz/XPJZ/jnku7xfyfun6c80r8fxanDfivDX8c80C0DsLQe8sAr2zGPTOEtA7S0HvLAO9sxz0zgrQOytB76wCvbMa9M4a0DtrQe+sA72zHvTOBtA7G0HvbAK9sxl0yRYw+xr0zjtL31O2gr7YBvpiO+iLHaAvdoK+2AX6Yjfoiz2gL/aCvtgH+mI/6IsDoC8Ogr44BPriMOiLI6AvjoK+OAb64jjoixOgA06C2TegL95b6otToC9Og744A/riLOiLc6AvzoO+uAD64iLoi0ugLy6DvrgC+uIq6ItroC+ug764AfriJuiLW6AvboO+uAP64i7ogHtg9i3oiw+Gf655Jf8c807e7+X9wfXnmo/i+ZM4n8X5Yvjnmvugdx6A3nkIeucR6J3HoHeegN55CnrnGeid56B3XoDeeQl65xXondegd96A3nkLeucd6J33oHc+gN75CHrnE+iSz2D2E+idr5a+p3wBffEV9MU30BffQV84Hup9EcBDvS8Ceqj3RSAP9b4I7KHeFx4e6n0RxEO9Lzw91PsiqId6XwT706zrRwf/4+x/f3QIhdm/f7SXyqz80SHVZv/vR3srzv740aGUZ50APmD2M+iLb5b6IrSHel/4eqj3RRgP9b4I66HeF+FAX4QHfREB9EVE0BeRQF9EBn0RBfRFVNAX0UBfRAd9EQP0hR/oi5igL2KBvogN+iIO6IC4YPYL6Ivvhn+u+Sj/HPNV3t/k/d315xqnmPifiRNQnEDFfv7N0t6JB3onPuidBKB3EoLeSQR6JzHonSSgd5KC3kkGeic56J0UoHdSgt5JBXonNeidNKB30oLeSQd6Jz3onQygdzKCLskEZn98xv+e/VPvBC5m53tKZtAXWUBfZAV9kQ30RXbQFzlAX+QEfZEL9EVu0Bd5QF/kBX2RD/RFftAXBUBfFAR9UQj0RWHQF0VAXxQFfVEMdEBxMBsQ9IWHpb4oAfqiJOiLUqAvSoO+KAP6oizoi3KgL8qDvqgA+qIi6ItKoC8qg76oAvqiKuiLaqAvqoO+qAH6oiboi1qgL2qDDqgDZgOBvggC+uJXf675vz+zOH99T/lxe8j7x8/9e85TPAcVJ5g4wQ3/XFMX9E490Dv1Qe80AL3TEPROI9A7jUHvNAG90xT0TjPQO81B77QAvdMS9E4r0DutQe+0Ab3TFvROO9A77UHvdABd0hHMBgW9E8LS95ROoC86g77oAvqiK+iLbqAvuoO+6AH6oifoi16gL3qDvugD+qIv6It+oC/6g74YAPpiIOiLQaAvBoO+GAL6YijogGFgNhjoCy9LfTEc9MUI0BcjQV+MAn0xGvTFGNAXY0FfjAN9MR70xQTQFxNBX0wCfTEZ9MUU0BdTQV9MA30xHfTFDNAXM0FfzAIdMBvMBgd9EdLwzzWe8s8xIeTtJe+Qrj/XeIvnUOL4iBPa8M81c0DvzAW9Mw/0znzQOwtA7ywEvbMI9M5i0DtLQO8sBb2zDPTOctA7K0DvrAS9swr0zmrQO2tA76wFvbMO9M560CUbwGwo0Du+lr6nbAR9sQn0xWbQF1tAX2wFfbEN9MV20Bc7QF/sBH2xC/TFbtAXe0Bf7AV9sQ/0xX7QFwdAXxwEfXEI9MVh0BdHQAccBbM+oC/CWOqLY6AvjoO+OAH64iToi1OgL06DvjgD+uIs6ItzoC/Og764APriIuiLS6AvLoO+uAL64iroi2ugL66DvrgB+uIm6IBbYDY06Iuwhn+u8ZZ/jvGVdxh5h3X9uSaceA4vTgRxIhr+ueY26J07oHfugt65B3rnPuidB6B3HoLeeQR65zHonSegd56C3nkGeuc56J0XoHdegt55BXrnNeidN6B33oLeeQe65D2YDQ96J5Lm95Tg8vb7z7/V+dd/PoC++Aj64hPoi8+gL76AvvgK+uIb6IvvgHkEwDyyJvNA8vZz1H5P0Quoz0YEv/8oxZR/7i/fleHkuzGSvCPLO4rrXRlVPEcTJ7o4Mf7xrqR7KFZEfTYa2IMf2IP7H/r7T1gQMAe//5iav39vefu5/mf/Wihe//z3/L5RAnipf+4Dev3y9//LHx7I63dZ//eHB/ZSf597eP3rDn/64UG8/rBv1w/39Pozm79/eFCF2b9/eDCl2b9+eHDVWfHDQ4DZGMDRWD856vMjxW//j191TVTZLX7yjinvWK6uiS2e44gTV5x4/+ga6roXcD0kcN0buB4KuO4DXA8NXPcFrocBrocFrocDrocH/kYAs3GA6/GB6+5/qKMRgaORgKORgaNRgKNRgaPRgKPRgaMxgKN+wNGYwNFYwLvYYDYucDSBJUfjAEfjAkfjAUfjA0cTAEcTAkcTAUcTA0eTAEeTAkeTAe+Sg9l4wNGEht8ZYsvvCPHlnUDeCV3fGRKJ58TiJBEnqeF3hhTA9ZTA9VTA9dTA9TTA9bTA9XTA9fTA9QzA9YzA9UzA38xgNjFwPZmlPs4CHM0KHM0GHM0OHM0BHM0JHM0FHM0NHM0DHM0LHM0HvMsPZpMAR5NbcrQAcLQgcLQQcLQwcLQIcLQocLQYcLQ4cLQEcLQkcLQU8K40mE0KHE1h+J0hkfyOkEzeyeWdwvWdIaV4TiVOanHSGH5nKANcLwtcLwdcLw9crwBcrwhcrwRcrwxcrwJcrwpcrwb8rQ5mUwHX01rq4xrA0ZrA0VrA0drA0TrA0brA0XrA0frA0QbA0YbA0UbAu8ZgNjVwNJ0lR5sAR5sCR5sBR5sDR1sAR1sCR1sBR1sDR9sAR9sCR9sB79qD2TTA0fSG3xlSyu8IaeWdTt7pXd8ZMojnjOJkEiez4XeGDsD1jsD1TsD1zsD1LsD1rsD1bsD17sD1HsD1nsD1XsDf3mA2I3A9i6U+7gMc7Qsc7Qcc7Q8cHQAcHQgcHQQcHQwcHQIcHQocHQa8Gw5mMwFHs1pydARwdCRwdBRwdDRwdAxwdCxwdBxwdDxwdAJwdCJwdBLwbjL5u13gaDbD7wwZ5HeELPLOKu9sru8M2cVzDnFyipPL8DvDFOD6VOD6NOD6dOD6DOD6TOD6LOD6bOD6HOD6XOD6PODvfDCbA7ie21IfLwCOLgSOLgKOLgaOLgGOLgWOLgOOLgeOrgCOrgSOrgLerQazOYGjeSw5ugY4uhY4ug44uh44ugE4uhE4ugk4uhk4ugU4uhU4ug14tx3M5gKO5jX8zpBdfkfILe888s7r+s6QTzznF6eAOAUNvzPsAK7vBK7vAq7vBq7vAa7vBa7vA67vB64fAK4fBK4fAv4eBrP5geuFLPXxEeDoUeDoMeDoceDoCeDoSeDoKeDoaeDoGeDoWeDoOeDdeTBbADha2JKjF4CjF4Gjl4Cjl4GjV4CjV4Gj14Cj14GjN4CjN4Gjt4B3t8FsQeBoEcPvDPnkd4RC8i4s7yKu7wxFxXMxcYqLU8LwO8Md4Ppd4Po94Pp94PoD4PpD4Poj4Ppj4PoT4PpT4Poz4O9zMFsMuF7SUh+/AI6+BI6+Ao6+Bo6+AY6+BY6+A46+B45+AI5+BI5+At59BrPFgaOlLDn6BTj6FTj6DTj6HTjqhFR3NEBIdUcDhlR3NNCfZl0/PLDC7N8/3ENp9q8fHkR1VvxwTzBbAjha2vA7Q1H5HaGkvEvJu7TrO0MZ8VxWnHLilDf8zhA0pLrrwUKqux48pLrrIUKqu+4FXA8JXPcGrocCrvsA10MD132Bv2HAbFngegVLfRwWOBoOOBoeOBoBOBoROBoJOBoZOBoFOBoVOBoNOBodeBcDzJYDjla05KgfcDQmcDQWcDQ2cDQOcDQucDQecDQ+cDQBcDQhcDQR8C4xmC0PHK1k+J2hjPyOUEHeFeVdyfWdobJ4riJOVXGqGX5nSAJcTwpcTwZcTw5cTwFcTwlcTwVcTw1cTwNcTwtcTwf8TQ9mqwDXq1vq4wzA0YzA0UzA0czA0SzA0azA0WzA0ezA0RzA0ZzA0VzAu9xgtipwtIYlR/MAR/MCR/MBR/MDRwsARwsCRwsBRwsDR4sAR4sCR4sB74qD2WrA0ZqG3xkqy+8I1eVdQ941Xd8Zaonn2uLUEaeu4XeGEsD1ksD1UsD10sD1MsD1ssD1csD18sD1CsD1isD1SsDfymC2NnC9nqU+rgIcrQocrQYcrQ4crQEcrQkcrQUcrQ0crQMcrQscrQe8qw9m6wBH61tytAFwtCFwtBFwtDFwtAlwtClwtBlwtDlwtAVwtCVwtBXwrjWYrQscbWD4naGW/I5QT9715d3A9Z2hoXhuJE5jcZoYfmdoA1xvC1xvB1xvD1zvAFzvCFzvBFzvDFzvAlzvClzvBvztDmYbAdebWurjHsDRnsDRXsDR3sDRPsDRvsDRfsDR/sDRAcDRgcDRQcC7wWC2MXC0mSVHhwBHhwJHhwFHhwNHRwBHRwJHRwFHRwNHxwBHxwJHxwHvxoPZJsDR5obfGRrK7whN5d1M3s1d3xlaiOeW4rQSp7Xhd4YJwPWJwPVJwPXJwPUpwPWpwPVpwPXpwPUZwPWZwPVZwN/ZYLYlcL2NpT6eAxydCxydBxydDxxdABxdCBxdBBxdDBxdAhxdChxdBrxbDmZbAUfbWnJ0BXB0JXB0FXB0NXB0DXB0LXB0HXB0PXB0A3B0I3B0E/BuM/k7CeBoO8PvDC3kd4Q28m4r73au7wztxXMHcTqK08nwO8MW4PpW4Po24Pp24PoO4PpO4Pou4Ppu4Poe4Ppe4Po+4O9+MNsBuN7ZUh8fAI4eBI4eAo4eBo4eAY4eBY4eA44eB46eAI6eBI6eAt6dBrMdgaNdLDl6Bjh6Fjh6Djh6Hjh6ATh6ETh6CTh6GTh6BTh6FTh6DXh3Hcx2Ao52NfzO0F5+R+gs7y7y7ur6ztBNPHcXp4c4PQ2/M9wArt8Ert8Crt8Grt8Brt8Frt8Drt8Hrj8Arj8Erj8C/j4m/x0DuN7LUh8/AY4+BY4+A44+B46+AI6+BI6+Ao6+Bo6+AY6+BY6+A969B7M9gKO9LTn6ATj6ETj6CTj6GTj6BTj6FTj6DTj6HTj6A8ifZv/+4QGUZv/64QFVZ8WPDQRmewJH+xh+Z+gmvyP0kndvefdxfWfoK577idNfnAGG3xkCe6u77uGt7noQb3XXPb3VXQ/qre56MG9114N7q7sewlvddS/gekjgujfwNxSY7QdcH2ipj32Ao6GBo77A0TDA0bDA0XDA0fDA0QjA0YjA0UjA0cjAuyhgtj9wdJAlR6MCR6MBR6MDR2MAR/2AozGBo7GAo7GBo3GAo3GBo/GAd/HB7ADg6GDD7wx95XeEgfIeJO/Bru8MQ8TzUHGGiTPc8DtDAuB6QuB6IuB6YuB6EuB6UuB6MuB6cuB6CuB6SuB6KuBvajA7FLg+wlIfpwGOpgWOpgOOpgeOZgCOZgSOZgKOZgaOZgGOZgWOZgPeZQezw4CjIy05mgM4mhM4mgs4mhs4mgc4mhc4mg84mh84WgA4WhA4Wgh4VxjMDgeOjjL8zjBEfkcYIe+R8h7l+s4wWjyPEWesOOMMvzMUAa4XBa4XA64XB66XAK6XBK6XAq6XBq6XAa6XBa6XA/6WB7NjgOvjLfVxBeBoReBoJeBoZeBoFeBoVeBoNeBodeBoDeBoTeBoLeBdbTA7Fjg6wZKjdYCjdYGj9YCj9YGjDYCjDYGjjYCjjYGjTYCjTYGjzYB3zcHsOODoRMPvDKPld4Tx8p4g74mu7wyTxPNkcaaIM9XwO0ML4HpL4Hor4Hpr4Hob4Hpb4Ho74Hp74HoH4HpH4Hon4G9nMDsZuD7NUh93AY52BY52A452B472AI72BI72Ao72Bo72AY72BY72A971B7NTgKPTLTk6ADg6EDg6CDg6GDg6BDg6FDg6DDg6HDg6Ajg6Ejg6Cng3GsxOBY7OMPzOMEl+R5gm7+nynuH6zjBTPM8SZ7Y4cwy/M4wBro8Fro8Dro8Hrk8Ark8Erk8Crk8Grk8Brk8Frk8D/k4Hs7OA63Mt9fEM4OhM4Ogs4Ohs4Ogc4Ohc4Og84Oh84OgC4OhC4Ogi4N1iMDsbODrPkqNLgKNLgaPLgKPLgaMrgKMrgaOrgKOrgaNrgKNrgaPrgHfrwewc4Oh8w+8MM+V3hLnynifv+a7vDAvE80JxFomz2PA7wwbg+kbg+ibg+mbg+hbg+lbg+jbg+nbg+g7g+k7g+i7g724wuxC4vsRSH+8Bju4Fju4Dju4Hjh4Ajh4Ejh4Cjh4Gjh4Bjh4Fjh4D3h0Hs4uAo0stOXoCOHoSOHoKOHoaOHoGOHoWOHoOOHoeOHoBOHoROHoJeHeZfAcGji4z/M6wQH5HWCLvpfJe5vrOsFw8rxBnpTirDL8zXAGuXwWuXwOuXweu3wCu3wSu3wKu3wau3wGu3wWu3wP+3gezK4Drqy318QPg6EPg6CPg6GPg6BPg6FPg6DPg6HPg6Avg6Evg6Cvg3WswuxI4usaSo2+Ao2+Bo++Ao++Box+Aox+Bo5+Ao5+Bo1+Ao1+Bo9+Ad9/B7Crg6FrD7wzL5XeE1fJeI++1ru8M68TzenE2iLPR8DuDE0rd9QCh1F0PGErd9UCh1F0PHErddY9Q6q4HCaXuuuefZl0/PKjC7N8/PJjS7F8/PLjqrPjhIcDseuD6Jkt97AUcDQkc9QaOhgKO+gBHQwNHfYGjYYCjYYGj4YCj4YF3EcDsBuDoZkuORgSORgKORgaORgGORgWORgOORgeOxgCO+gFHYwJHYwHvYoPZjcDRLYbfGdbJ7wib5L1Z3ltc3xm2iudt4mwXZ4fhd4Y4wPW4wPV4wPX4wPUEwPWEwPVEwPXEwPUkwPWkwPVkwN/kYHYbcH2npT5OARxNCRxNBRxNDRxNAxxNCxxNBxxNDxzNABzNCBzNBLzLDGa3A0d3WXI0C3A0K3A0G3A0O3A0B3A0J3A0F3A0N3A0D3A0L3A0H/AuP5jdARzdbfidYav8jrBT3rvkvdv1nWGPeN4rzj5x9ht+ZygAXC8IXC8EXC8MXC8CXC8KXC8GXC8OXC8BXC8JXC8F/C0NZvcC1w9Y6uMywNGywNFywNHywNEKwNGKwNFKwNHKwNEqwNGqwNFqwLvqYHYfcPSgJUdrAEdrAkdrAUdrA0frAEfrAkfrAUfrA0cbAEcbAkcbAe8ag9n9wNFDht8Z9sjvCAfkfVDeh1zfGQ6L5yPiHBXnmOF3hibA9abA9WbA9ebA9RbA9ZbA9VbA9dbA9TbA9bbA9XbA3/Zg9ghw/bilPu4AHO0IHO0EHO0MHO0CHO0KHO0GHO0OHO0BHO0JHO0FvOsNZo8CR09YcrQPcLQvcLQfcLQ/cHQAcHQgcHQQcHQwcHQIcHQocHQY8G44mD0GHD1p+J3hsPyOcFzeJ+R90vWd4ZR4Pi3OGXHOGn5nGAFcHwlcHwVcHw1cHwNcHwtcHwdcHw9cnwBcnwhcnwT8nQxmTwPXz1nq4ynA0anA0WnA0enA0RnA0ZnA0VnA0dnA0TnA0bnA0XnAu/lg9gxw9LwlRxcARxcCRxcBRxcDR5cAR5cCR5cBR5cDR1cAR1cCR1cB71aD2bPA0QuG3xlOye8I5+R9Xt4XXN8ZLornS+JcFueK4XeGNcD1tcD1dcD19cD1DcD1jcD1TcD1zcD1LcD1rcD1bcDf7WD2EnD9qqU+3gEc3Qkc3QUc3Q0c3QMc3Qsc3Qcc3Q8cPQAcPQgcPQS8OwxmLwNHr1ly9Ahw9Chw9Bhw9Dhw9ARw9CRw9BRw9DRw9Axw9Cxw9Bzw7jyYvQIcvW74neGi/I5wVd7X5H3d9Z3hhni+Kc4tcW4bfme4AFy/CFy/BFy/DFy/Aly/Cly/Bly/Dly/AVy/CVy/Bfy9DWZvAtfvWOrjO8DRu8DRe8DR+8DRB8DRh8DRR8DRx8DRJ8DRp8DRZ8C752D2FnD0riVHXwBHXwJHXwFHXwNH3wBH3wJH3wFH3wNHPwBHPwJHPwHvPpPOBY7eM/zOcEN+R7gj77vyvuf6znBfPD8Q56E4j/7xncFD3n6u/9m/uf4FuP4VuP4N7PcB2O9jSx3wHezlxw/y+8X/7Ff/BPBR74CAPuodEMhHvQMC+6h3gIePegcE+dOs64d7Ksz+/cODKs3+9cODqc6KHx4czD4Ejj6x5GgIH3VHvYCjIYGj3sDRUMBRH+BoaOCoL3A0DHA0LHA0HPAuPJh9BBx9avieui/fS4/l/UTeT13vqWfi+bk4L8R5afhn2wjA9YjA9UjA9cjA9SjA9ajA9WjA9ejA9RjAdT/gekzgbyww+xy4/spSH8cGjsYBjsYFjsYDjsYHjiYAjiYEjiYCjiYGjiYBjiYF3iUDsy+Ao68tOZocOJoCOJoSOJoKOJoaOJoGOJoWOJoOOJoeOJoBOJoReJcJzL4Ejr4x/M7wTH5HeCXv1/J+4/rO8FY8vxPnvTgfDL8zZAauZwGuZwWuZwOuZweu5wCu5wSu5wKu5wau5wGu5wX+5gOz74DrHy31cX7gaAHgaEHgaCHgaGHgaBHgaFHgaDHgaHHgaAngaEngXSkw+x44+smSo6WBo2WAo2WBo+WAo+WBoxWAoxWBo5WAo5WBo1WAo1WBd9XA7Afg6GfD7wxv5XeEj/L+JO/Pru8MX8TzV3G+ifPd8DtDdeB6DeB6TeB6LeB6beB6HeB6XeB6PeB6feB6A+B6Q+BvIzD7FbjuFLfTx42Bo02Ao02Bo82Ao82Boy2Aoy2Bo62Ao62Bo22Ao22Bd+3A7DfgaABLjrYHjnYAjnYEjnYCjnYGjnYBjnYFjnYDjnYHjvYAjvYE3vUCs9+BowGBo7/6zvBFfkf40cc/7gDy/vFz/54L9ONZHA9xghT/+TdLXe8NXO8DXO8LXO8HXO8PXB8AXB8IXB8EXB8MXB8CXB8K/B0GZgMXV3fd01IfDweOjgCOjgSOjgKOjgaOjgGOjgWOjgOOjgeOTgCOTgTeTQKzHsDRoJYcnQwcnQIcnQocnQYcnQ4cnQEcnQkcnQUcnQ0cnQMcnQu8mwdmgwBHgxl+ZwgkvyN4yjuovIO5vjMEF88hxPESJ6Thd4b5wPUFwPWFwPVFwPXFwPUlwPWlwPVlwPXlwPUVwPWVwN9VYDYEcN3bUh+vBo6uAY6uBY6uA46uB45uAI5uBI5uAo5uBo5uAY5uBd5tA7NewNFQlhzdDhzdARzdCRzdBRzdDRzdAxzdCxzdBxzdDxw9ABw9CLw7BGZDAkd9DL8zBJffEbzlHUrePq7vDKHFs684YcQJa/id4TBw/Qhw/Shw/Rhw/Thw/QRw/SRw/RRw/TRw/Qxw/Szw9xyY9QWuh7PUx+eBoxeAoxeBo5eAo5eBo1eAo1eBo9eAo9eBozeAozeBd7fAbBjgaHhLjt4Gjt4Bjt4Fjt4Djt4Hjj4Ajj4Ejj4Cjj4Gjj4Bjj4F3j0Ds2GBoxEMvzOElt8Rwsk7vLwjuL4zRBTPkcSJLE4Uw+8Mz4HrL4DrL4Hrr4Drr4Hrb4Drb4Hr74Dr74HrH4DrH4G/n8BsJOB6VEt9/Bk4+gU4+hU4+g04+h046oRWdzRAaHVHA/5p1vXDAynM/v3DAyvN/vXDPVRnf/xdLpiNDByNZslRz9DqjgYNre5osNDqjgYPre5oiNDqjnoBR0MCR72Bo6GAoz7A0dDAO18wGwU4Gt3wO0NE+R0hqryjyTu66ztDjB//DnFiihPL8DtDGOB6WOB6OOB6eOB6BOB6ROB6JOB6ZOB6FOB6VOB6NOBvdDDrB1yPbamPYwBH/YCjMYGjsYCjsYGjcYCjcYGj8YCj8YGjCYCjCYF3icBsTOBoHEuOJgaOJgGOJgWOJgOOJgeOpgCOpgSOpgKOpgaOpgGOpgXepQOzsYCjcQ2/M8SQ3xFiyzuOvOO6vjPEE8/xxUkgTkLD7wzpgesZgOsZgeuZgOuZgetZgOtZgevZgOvZges5gOs5gb+5wGx84HoiS32cGziaBziaFziaDziaHzhaADhaEDhaCDhaGDhaBDhaFHhXDMwmAI4mtuRoceBoCeBoSeBoKeBoaeBoGeBoWeBoOeBoeeBoBeBoReBdJTCbEDiaxPA7Qzz5HSGRvBPLO4nrO0NS8ZxMnOTipDD8zlAZuF4FuF4VuF4NuF4duF4DuF4TuF4LuF4buF4HuF4X+FsPzCYDrqe01Mf1gaMNgKMNgaONgKONgaNNgKNNgaPNgKPNgaMtgKMtgXetwGxy4GgqS462Bo62AY62BY62A462B452AI52BI52Ao52Bo52AY52Bd51A7MpgKOpDb8zJJXfEVLKO5W8U7u+M6QRz2nFSSdOesPvDN2B6z2A6z2B672A672B632A632B6/2A6/2B6wOA6wOBv4PAbFrgegZLfTwYODoEODoUODoMODocODoCODoSODoKODoaODoGODoWeDeO/B0xcDSjJUfHA0cnAEcnAkcnAUcnA0enAEenAkenAUenA0dnAEdnAu9mgdn0wNFMht8Z0sjvCBnknVHemVzfGTKL5yziZBUnm+F3htnA9TnA9bnA9XnA9fnA9QXA9YXA9UXA9cXA9SXA9aXA32VgNgtwPbulPl4OHF0BHF0JHF0FHF0NHF0DHF0LHF0HHF0PHN0AHN0IvNsEZrMCR3NYcnQzcHQLcHQrcHQbcHQ7cHQHcHQncHQXcHQ3cHQPcHQv8G4fmM0GHM1p+J0hs/yOkF3eOeSd0/WdIZd4zi1OHnHyGn5n2A9cPwBcPwhcPwRcPwxcPwJcPwpcPwZcPw5cPwFcPwn8PQVmcwPX81nq49PA0TPA0bPA0XPA0fPA0QvA0YvA0UvA0cvA0SvA0avAu2tgNg9wNL8lR68DR28AR28CR28BR28DR+8AR+8CR+8BR+8DRx8ARx8C7x6B2bzA0QKG3xlyye8I+eSdX94FXN8ZCornQuIUFqeI4XeGx8D1J8D1p8D1Z8D158D1F8D1l8D1V8D118D1N8D1t8Dfd2C2EHC9qKU+fg8c/QAc/Qgc/QQc/Qwc/QIc/Qoc/QYc/Q4cdXzVHQ2gOitGA4LZwsDRYpYcDeSr7mhgX3VHPXzVHQ3iq+6op6+6o0F91R0N5qvuaHBfdUdD+Ko76gUcDQm88wazRYCjxQ2/MxSU3xGKyruYvIu7vjOUEM8lxSklTmnD7wyhgOs+wPXQwHVf4HoY4HpY4Ho44Hp44HoE4HpE4Hok4G9kMFsSuF7GUh9HAY5GBY5GA45GB47GAI76AUdjAkdjAUdjA0fjAEfjAu/igdlSwNGylhyNDxxNABxNCBxNBBxNDBxNAhxNChxNBhxNDhxNARxNCbxLBWZLA0fLGX5nKCG/I5SRd1l5l3N9ZygvniuIU1GcSobfGVID19MA19MC19MB19MD1zMA1zMC1zMB1zMD17MA17MCf7OB2QrA9cqW+jg7cDQHcDQncDQXcDQ3cDQPcDQvcDQfcDQ/cLQAcLQg8K4QmK0IHK1iydHCwNEiwNGiwNFiwNHiwNESwNGSwNFSwNHSwNEywNGywLtyYLYScLSq4XeG8vI7QmV5V5F3Vdd3hmriubo4NcSpafidoTxwvQJwvSJwvRJwvTJwvQpwvSpwvRpwvTpwvQZwvSbwtxaYrQ5cr2Wpj2sDR+sAR+sCR+sBR+sDRxsARxsCRxsBRxsDR5sAR5sC75qB2RrA0dqWHG0OHG0BHG0JHG0FHG0NHG0DHG0LHG0HHG0PHO0AHO0IvOsEZmsCR+sYfmeoJr8j1JJ3bXnXcX1nqCue64lTX5wGht8ZOgPXuwDXuwLXuwHXuwPXewDXewLXewHXewPX+wDX+wJ/+4HZesD1hpb6uD9wdABwdCBwdBBwdDBwdAhwdChwdBhwdDhwdARwdCTwbhSYrQ8cbWTJ0dHA0THA0bHA0XHA0fHA0QnA0YnA0UnA0cnA0SnA0anAu2lgtgFwtLHhd4a68jtCQ3k3kndj13eGJuK5qTjNxGlu+J1hOnB9BnB9JnB9FnB9NnB9DnB9LnB9HnB9PnB9AXB9IfB3EZhtClxvYamPFwNHlwBHlwJHlwFHlwNHVwBHVwJHVwFHVwNH1wBH1wLv1pG/kwCOtrTk6Hrg6Abg6Ebg6Cbg6Gbg6Bbg6Fbg6Dbg6Hbg6A7g6E7g3S4w2xw42srwO0MT+R2hhbxbyruV6ztDa/HcRpy24rQz/M6wG7i+B7i+F7i+D7i+H7h+ALh+ELh+CLh+GLh+BLh+FPh7DMy2Aa63t9THx4GjJ4CjJ4Gjp4Cjp4GjZ4CjZ4Gj54Cj54GjF4CjF4F3l8BsW+BoB0uOXgaOXgGOXgWOXgOOXgeO3gCO3gSO3gKO3gaO3gGO3gXe3QOz7YCjHQ2/M7SW3xHay7uDvDu6vjN0Es+dxekiTlfD7wz3gesPgOsPgeuPgOuPgetPgOtPgevPgOvPgesvgOsvgb+vwGxn4Ho3S338Gjj6Bjj6Fjj6Djj6Hjj6ATj6ETj6CTj6GTj6BTj6FXj3Dcx2AY52t+Tod+CoE0bd0QBh1B0NGEbd0UBh1B0NHEbdUY8w6o4G+dOs64d7Ksz+/cODKs3+9cODqc6KHx4czHYFjvYw/M7QSX5H6Cbv7vLu4frO0FM89xKntzh9DL8zhAij7roXcD0kcN0buB4KuO4DXA8NXPcFrocBrocFrocD/oYHs72A630t9XEE4GhE4Ggk4Ghk4GgU4GhU4Gg04Gh04GgM4KgfcDQm8C4WmO0NHO1nydHYwNE4wNG4wNF4wNH4wNEEwNGEwNFEwNHEwNEkwNGkwLtkYLYPcLS/4XeGnvI7Ql9595N3f9d3hgHieaA4g8QZbPidITlwPQVwPSVwPRVwPTVwPQ1wPS1wPR1wPT1wPQNwPSPwNxOYHQhcH2KpjzMDR7MAR7MCR7MBR7MDR3MAR3MCR3MBR3MDR/MAR/MC7/KB2UHA0aGWHM0PHC0AHC0IHC0EHC0MHC0CHC0KHC0GHC0OHC0BHC0JvCsFZgcDR4cZfmcYIL8jDJH3UHkPc31nGC6eR4gzUpxRht8ZSgPXywDXywLXywHXywPXKwDXKwLXKwHXKwPXqwDXqwJ/q4HZEcD10Zb6uDpwtAZwtCZwtBZwtDZwtA5wtC5wtB5wtD5wtAFwtCHwrhGYHQkcHWPJ0cbA0SbA0abA0WbA0ebA0RbA0ZbA0VbA0dbA0TbA0bbAu3ZgdhRwdKzhd4bh8jvCaHmPkfdY13eGceJ5vDgTxJlo+J2hPXC9A3C9I3C9E3C9M3C9C3C9K3C9G3C9O3C9B3C9J/nvDWB2PHB9kqU+7g0c7QMc7Qsc7Qcc7Q8cHQAcHQgcHQQcHQwcHQIcHQq8GwZmJwBHJ1tydDhwdARwdCRwdBRwdDRwdAxwdCxwdBxwdDxwdAJwdCLwbhKYnQgcnWL4nWGc/I4wSd6T5T3F9Z1hqnieJs50cWYYfmeYDFyfAlyfClyfBlyfDlyfAVyfCVyfBVyfDVyfA1yfC/ydB2anAddnWurj+cDRBcDRhcDRRcDRxcDRJcDRpcDRZcDR5cDRFcDRlcC7VWB2OnB0liVHVwNH1wBH1wJH1wFH1wNHNwBHNwJHNwFHNwNHtwBHtwLvtoHZGcDR2YbfGabK7wgz5T1L3rNd3xnmiOe54swTZ77hd4btwPUdwPWdwPVdwPXdwPU9wPW9wPV9wPX9wPUDwPWDwN9DYHYucH2BpT4+DBw9Ahw9Chw9Bhw9Dhw9ARw9CRw9BRw9DRw9Axw9C7w7R74DA0cXWnL0PHD0AnD0InD0EnD0MnD0CnD0KnD0GnD0OnD0BnD0JvDuFpidDxxdZPidYY78jrBA3gvlvcj1nWGxeF4izlJxlhl+Z7gNXL8DXL8LXL8HXL8PXH8AXH8IXH8EXH8MXH8CXH8K/H0GZpcA15db6uPnwNEXwNGXwNFXwNHXwNE3wNG3wNF3wNH3wNEPwNGPwLtPYHYpcHSFpqMe8vZzfor0238+A0e/AEe/gr0sA3tZafieWizfS8vlvULeK13vqVXiebU4a8RZ+4/3VFB5+/0cwfndP9/AZ/U7+Pw5YdU/UwH+NOv6BQGVZv/6BYHA7GrAeN0/GP/b/+H+h7IJHFadjUdYdTZBABtPwCYo2HcwMLsGsFlviU1wwCYEYOMF2IQEbLzBvkOB2bWAzQbA5lfduEp24Tp5r5f3Blc3bhTPm8TZLM4Ww270AYxDA8a+gHEYwDgs4BYOzG4CjLda+vyFB2wiADYRAZtIgE1ksO8oYHYzYLPNEpuogE00wCY6YBMDsPED+44JZrcANtsNu3Gj7MKt8t4m7+2ubtwhnneKs0uc3YbdGAswjg0YxwGM4wLG8QC3+GB2J2C8x9LnLwFgkxCwSQTYJAZskoB9JwWzuwCbvZbYJANskgM2KQCblIBNKrDv1GB2N2Czz7Abd8gu3CPvvfLe5+rG/eL5gDgHxTlk2I1pAOO0gHE6wDg9YJwBcMsIZg8Axoctff4yATaZAZssgE1WwCYb2Hd2MHsQsDliiU0OwCYnYJMLsMkN2OQB+84LZg8BNkcNu3G/7MLD8j4i76Oubjwmno+Lc0Kck4bdmA8wzg8YFwCMCwLGhQC3wmD2OGB8ytLnrwhgUxSwKQbYFAdsSoB9lwSzJwCb05bYlAJsSgM2ZQCbsoBNObDv8mD2JGBzxrAbj8kuPCXv0/I+4+rGs+L5nDjnxblg2I0VAOOKgHElwLgyYFwFcKsKZs8Bxhctff6qATbVAZsagE1NwKYW2HdtMHsesLlkiU0dwKYuYFMPsKkP2DQA+24IZi8ANpcNu/Gs7MKL8r4k78uubrwinq+Kc02c64bd2AgwbgwYNwGMmwLGzQC35mD2KmB8w9LnrwVg0xKwaQXYtAZs2oB9twWz1wCbm5bYtANs2gM2HQCbjoBNJ7DvzmD2OmBzy7Abr8guvCHvm/K+5erG2+L5jjh3xbln2I1dAOOugHE3wLg7YNwDcOsJZu8Axvctff56ATa9AZs+gE1fwKYf2Hd/MHsXsHlgic0AwGYgYDMIsBkM2AwB+x4KZu8BNg8Nu/G27ML78n4g74eubnwknh+L80Scp4bdOAwwHg4YjwCMRwLGowC30WD2MWD8zNLnbwxgMxawGQfYjAdsJoB9TwSzTwCb55bYTAJsJgM2UwCbqYDNNLDv6WD2KWDzwrAbH8kufCbv5/J+4erGl+L5lTivxXlj2I0zAOOZgPEswHg2YDwHcJsLZl8Bxm8tff7mATbzAZsFgM1CwGYR2PdiMPsasHlnic0SwGYpYLMMsFkO2KwA+14JZt8ANu8Nu/Gl7MK38n4n7/eubvwgnj+K80mcz4bduAowXg0YrwGM1wLG6wC39WD2I2D8xdLnbwNgsxGw2QTYbAZstoB9bwWznwCbr5bYbANstgM2OwCbnYDNLrDv3WD2M2DzzbAbP8gu/CLvr/L+5urG7z/6sIT4n4sTsMTPv1nKeA9gvBcw3gcY7weMDwBuB8Hsj33+PfsnxoFK2Pn8HQJsDgM2RwCbo4DNMbDv42A2AGAT2BKbE4DNScDmFGBzGrA5A/Z9FswGBGw8AJtfdeN32YU/Pn8/7sDy/vFz/54LIp49xQkqTjDDbjwHGJ8HjC8AxhcB40uA22Uw6wkYB7f0+bsC2FwFbK4BNtcBmxtg3zfBbFDAJoQlNrcAm9uAzR3A5i5gcw/s+z6YDQbYeBl2YxDZhcHlHULeXq5uDCmevcUJJY6PYTc+AIwfAsaPAOPHgPET8vfEYNYbMA5t6fP3DLB5Dti8AGxeAjavyN8hgtlQgI2vJTZvAJu3gM07wOY9YPOB/P0SmPUBbMIYdmNI2YWh5e0r7zCubgwrnsOJE16cCIbd+Akw/gwYfwGMvwLG3wC372A2HGAc0dLnzwmnziZAOHU2AcOpswkUTp1N4HDq+/YAs+EBm0iW2AQBbDwBm6CATTDAJjjYdwgwGwGwiWzYjWFlF0aUdyR5R3Z1YxTxHFWcaOJEN+xGL8A4JGDsDRiHAox9ALfQYDYqYBzD0ufPF7AJA9iEBWzCATbhyWcKzEYDbPwssYkI2EQCbCIDNlEAm6hk32A2OmAT07Abo8gujCFvP3nHdHVjLPEcW5w44sQ17MbogHEMwNgPMI4JGMcC3GKTWcA4nqXPXxzAJi5gEw+wiQ/YJAD7Tghm4wA28S2xSQTYJAZskgA2SQGbZGDfycFsXMAmgWE3xpJdGE/e8eWdwNWNCcVzInESi5PEsBtTAMYpAeNUgHFqwDgN4JYWzCYCjJNa+vylA2zSAzYZAJuMgE0msO/MYDYxYJPMEpssgE1WwCYbYJMdsMkB9p0TzCYBbJIbdmNC2YVJ5Z1M3sld3ZhCPKcUJ5U4qQ27MRdgnBswzgMY5wWM8wFu+cFsSsA4jaXPXwHApiBgUwiwKQzYFAH7LgpmUwE2aS2xKQbYFAdsSgA2JQGbUmDfpcFsasAmnWE3ppBdmEbeaeWdztWN6cVzBnEyipPJsBvLAMZlAeNygHF5wLgC4FYRzGYAjDNb+vxVAmwqAzZVAJuqgE01sO/qYDYjYJPFEpsagE1NwKYWYFMbsKkD9l0XzGYCbLIadmN62YWZ5Z1F3lld3ZhNPGcXJ4c4OQ27sR5gXB8wbgAYNwSMGwFujcFsdsA4l6XPXxPApilg0wywaQ7YtAD7bglmcwA2uS2xaQXYtAZs2gA2bQGbdmDf7cmfvwGbPIbdmE12YS5555Z3Hlc35hXP+cTJL04Bw27sABh3BIw7AcadAeMugFtXMJsPMC5o6fPXDbDpDtj0AGx6Aja9wL57k78bAWwKWWLTB7DpC9j0A2z6AzYDwL4HgtkCgE1hw27MK7uwoLwLybuwqxuLiOei4hQTp7hhNw4CjAcDxkMA46GA8TDAbTj5+y/AuISlz98IwGYkYDMKsBkN2IwB+x4LZosBNiUtsRkH2IwHbCYANhMBm0lg35PBbHHAppRhNxaRXVhC3iXlXcrVjaXFcxlxyopTzrAbpwDGUwHjaYDxdMB4BuA2E8yWAYzLW/r8zQJsZgM2cwCbuYDNPLDv+WC2LGBTwRKbBYDNQsBmEWCzGLBZAva9FMyWA2wqGnZjadmF5eVdQd4VXd1YSTxXFqeKOFUNu3EZYLwcMF4BGK8EjFcBbqvBbGXAuJqlz98awGYtYLMOsFkP2GwA+94IZqsANtUtsdkE2GwGbLYANlsBm21g39vBbFXApoZhN1aSXVhN3tXlXcPVjTXFcy1xaotTx7AbdwDGOwHjXYDxbsB4D+C2F8zWAozrWvr87QNs9gM2BwCbg4DNIbDvw2C2NmBTzxKbI4DNUcDmGGBzHLA5AfZ9EszWAWzqG3ZjTdmFdeVdT971Xd3YQDw3FKeROI0Nu/EUYHwaMD4DGJ8FjM8BbufBbEPAuImlz98FwOYiYHMJsLkM2FwB+74KZhsBNk0tsbkG2FwHbG4ANjcBm1tg37fJ/1sQwKaZYTc2kF3YRN5N5d3M1Y3NxXMLcVqK08qwG+8AxncB43uA8X3A+AHg9hDMtgCMW1v6/D0CbB4DNk8Am6eAzTOw7+fk/70PYNPGEpsXgM1LwOYVYPMasHkD9v0WzLYCbNoadmNz2YWt5d1G3m1d3dhOPLcXp4M4HQ278R1g/B4w/gAYfwSMPwFun8Fse8C4k+bnL5C8/X7+Vzu/++cL+P13AL//zpb64ytw6xtw6ztwywmv7laA8Or7DghmOwI2XQz7o53si07y7izvLq7+6Cqeu4nTXZwehv0RKLw648Dh1Rl7hFdnHAQw9gTcgoLZboBxT0ufv2CATXDAJgRg4wXYhAT79gaz3QGbXpbYhAJsfACb0ICNL2ATBuw7LJjtAdj0NuzGrrILe8q7l7x7u7qxj3juK04/cfobdmM4wDg8YBwBMI4IGEcC3CKD2b6A8QBLn78ogE1UwCYaYBMdsIkB9u0HZvsBNgMtsYkJ2MQCbGIDNnEAm7hg3/HAbH/AZpBhN/aRXThA3gPlPcjVjYPF8xBxhoozzLAb4wPGCQDjhIBxIsA4MeCWBMwOAYyHW/r8JQVskgE2yQGbFIBNSrDvVGB2KGAzwhKb1IBNGsAmLWCTDrBJD/adAcwOA2xGGnbjYNmFw+U9Qt4jXd04SjyPFmeMOGMNuzEjYJwJMM4MGGcBjLMCbtnA7GjAeJylz192wCYHYJMTsMkF2OQG+84DZscANuMtsckL2OQDbPIDNgUAm4Jg34XA7FjAZoJhN46SXThO3uPlPcHVjRPF8yRxJoszxbAbCwPGRQDjooBxMcC4OOBWAsxOAoynWvr8lQRsSgE2pQGbMoBNWbDvcmB2MmAzzRKb8oBNBcCmImBTCbCpDPZdBcxOAWymG3bjRNmFU+U9Td7TXd04QzzPFGeWOLMNu7EqYFwNMK4OGNcAjGsCbrXA7EzAeI6lz19twKYOYFMXsKkH2NQH+24AZmcBNnMtsWkI2DQCbBoDNk0Am6Zg383A7GzAZp5hN86QXThH3nPlPc/VjfPF8wJxFoqzyLAbmwPGLQDjloBxK8C4NeDWBswuAIwXW/r8tQVs2gE27QGbDoBNR7DvTmB2IWCzxBKbzoBNF8CmK2DTDbDpTv7bM5hdBNgsNezG+bILF8t7ibyXurpxmXheLs4KcVYadmNPwLgXYNwbMO4DGPcl/30TzC4HjFdZ+vz1B2wGADYDAZtBgM1g8t++wOwKwGa1JTZDAZthgM1wwGYEYDMS7HsUmF0J2Kwx7MZlsgtXyXu1vNe4unGteF4nznpxNhh242jAeAxgPBYwHgcYjwfcJoDZdYDxRkufv4mAzSTAZjJgMwWwmQr2PQ3MrgdsNlliMx2wmQHYzARsZgE2s8G+54DZDYDNZsNuXCu7cKO8N8l7s6sbt4jnreJsE2e7YTfOBYznAcbzAeMFgPFC8n0fzG4FjHdY+vwtBmyWADZLAZtlgM1y8l0QzG4DbHZaYrMSsFkF2KwGbNYANmvJ9wQwux2w2WXYjVtkF+6Q905573J1427xvEecveLsM+zG9YDxBsB4I2C8CTDeDLhtAbN7AOP9lj5/WwGbbYDNdsBmB2CzE+x7F5jdC9gcsMRmN2CzB7DZC9jsA2z2g30fALP7AJuDht24W3bhfnkfkPdBVzceEs+HxTkizlHDbjwIGB8CjA8DxkcA46OA2zEwexgwPmbp83ccsDkB2JwEbE4BNqfBvs+A2SOAzXFLbM4CNucAm/OAzQXA5iLY9yUwexSwOWHYjYdkFx6T93F5n3B140nxfEqc0+KcMezGy4DxFcD4KmB8DTC+DrjdALOnAOOzlj5/NwGbW4DNbcDmDmBzF+z7Hpg9Ddics8TmPmDzALB5CNg8Amweg30/Ie84wOa8YTeelF14Vt7n5H3e1Y0XxPNFcS6Jc9mwG58Cxs8A4+eA8QvA+CXg9grMXgSMr1j6/L0GbN4ANm8Bm3eAzXuw7w/kewxgc9USm4+AzSfA5jNg8wWw+Qr2/Q3MXgZsrhl24wXZhVfkfVXe11zdeF083xDnpji3DLvxO2DsRFBnHCCCOuOAf5p1/YJASrN//YLAYPYGYHzb0ufPI4I6myCAjSdgExSwCQb2HRzM3gRs7lhiEwKw8QJsQgI23oBNKLBvHzB7C7C5a9iN12UX3pb3HXnfdXXjPfF8X5wH4jw07MbQgLEvYBwGMA4LGIcD3MKD2fuA8SNLn78IgE1EwCYSYBMZsIkC9h0VzD4AbB5bYhMNsIkO2MQAbPwAm5hg37HA7EPA5olhN96TXfhI3o/l/cTVjU/F8zNxnovzwrAbYwPGcQDjuIBxPMA4PuCWAMw+A4xfWvr8JQRsEgE2iQGbJIBNUrDvZGD2OWDzyhKb5IBNCsAmJWCTCrBJDfadBsy+AGxeG3bjU9mFL+X9St6vXd34Rjy/FeedOO8NuzEtYJwOME4PGGcAjDMCbpnA7FvA+IOlz19mwCYLYJMVsMkG2GQH+84BZt8BNh8tsckJ2OQCbHIDNnkAm7xg3/nA7HvA5pNhN76RXfhB3h/l/cnVjZ/F8xdxvorzzbAb8wPGBQDjgoBxIcC4MOBWBMx+AYy/W/r8FQVsigE2xQGbEoBNSbDvUmD2K2DjlLTDpjRgUwawKQvYlANsyoN9VwCz3wCbAIDNr7rxs+zC7/L+wTqA/Ll/zwUUz4F+/N/F8Sj582+WMq4IGFcCjCsDxlUA46qAWzUwG6ikOuMglj5/1QGbGoBNTcCmFmBTG+y7DvlvaoCNpyU2dQGbeoBNfcCmAWDTEOy7EZj1AGyCGnZjQNmFQeTtKe+grm4MJp6DixNCHC/DbmwMGDcBjJsCxs0A4+aAWwvy300B45CWPn8tAZtWgE1rwKYNYNMW7LsdmA0B2HhbYtMesOkA2HQEbDoBNp3BvruAWS/AJpRhNwaTXRhS3t7yDuXqRh/xHFocX3HCGHZjV8C4G2DcHTDuARj3BNx6gdnQgHFYS5+/3oBNH8CmL2DTD7DpD/Y9AMz6AjbhLLEZCNgMAmwGAzZDAJuhYN/DwGwYwCa8YTf6yC4MK+9w8g7v6sYI4jmiOJHEiWzYjcMB4xGA8UjAeBRgPBpwGwNmIwLGUSx9/sYCNuMAm/GAzQTAZiLY9yQwGwmwiWqJzWTAZgpgMxWwmQbYTAf7ngFmIwM20Qy7MYLswijyjirvaK5ujC6eY/z494gT07AbZwLGswDj2YDxHMB4LuA2D8zGAIxjWfr8zQdsFgA2CwGbRYDNYrDvJWDWD7CJbYnNUsBmGWCzHLBZAdisBPteBWZjAjZxDLsxuuzCWPKOLe84rm6MK57jiRNfnASG3bgaMF4DGK8FjNcBxusBtw1gNh5gnNDS528jYLMJsNkM2GwBbLaCfW8Ds/EBm0SW2GwHbHYANjsBm12AzW6w7z1gNgFgk9iwG+PKLkwo70TyTuzqxiTiOak4ycRJbtiNewHjfYDxfsD4AGB8EHA7BGaTAsYpLH3+DgM2RwCbo4DNMcDmONj3CTCbDLBJaYnNScDmFGBzGrA5A9icBfs+B2aTAzapDLsxiezCFPJOKe9Urm5MLZ7TiJNWnHSG3XgeML4AGF8EjC8BxpcBtytgNg1gnN7S5+8qYHMNsLkO2NwAbG6Cfd8Cs2kBmwyW2NwGbO4ANncBm3uAzX2w7wdgNh1gk9GwG1PLLkwv7wzyzujqxkziObM4WcTJatiNDwHjR4DxY8D4CWD8FHB7BmYzA8bZLH3+ngM2LwCbl4DNK8DmNdj3GzCbBbDJbonNW8DmHWDzHrD5ANh8BPv+BGazAjY5DLsxk+zCbPLOLu8crm7MKZ5ziZNbnDz/6MZA8vb7OYLzu38+gz3kAnvIa7iHnDJ3Xnnnlnce1x7yief84hQQp2DJ//7a/83/+0w//o8fPyMg/HUBHPVdFCqp/HP/+5ty1H8vP37/hTQyBHTUMxS2kKGwRoZAjnqGIhYyFNHIENhRz1DUQoaiGhk8HPUMxSxkKKaRIYijnqG4hQzFNTJ4OuoZSljIUEIjQ1BHPUNJCxlKamQI5qhnKGUhQymNDMEd9QylLWQorZEhhKOeoYyFDGU0Mng56hnKWshQViNDSEc9QzkLGcppZPB21DOUt5ChvEaGUI56hgoWMlTQyODjqGeoaCFDRY0MoR31DJUsZKikkcHXUc9Q2UKGyhoZwjjqGapYyFBFI0NYRz1DVQsZqmpkCOeoZ6hmIUM1jQzhHfUM1S1kqK6RIYKjnqGGhQw1NDJEdNQz1LSQoaZGhkiOeoZaFjLU0sgQ2VHPUNtChtoaGaI46hnqWMhQRyNDVEc9Q10LGepqZIjmqGeoZyFDPY0M0R31DPUtZKivkSGGo56hgYUMDTQy+DnqGRpayNBQI0NMRz1DIwsZGmlkiOWoZ2hsIUNjjQyxHfUMTSxkaKKRIY6jnqGphQxNNTLEddQzNLOQoZlGhniOeobmFjI018gQ31HP0MJChhYaGRI46hlaWsjQUiNDQkc9QysLGVppZEjkqGdobSFDa40MiR31DG0sZGijkSGJo56hrYUMbTUyJHXUM7SzkKGdRoZkjnqG9hYytNfIkNxRz9DBQoYOGhlSOOoZOlrI0FEjQ0pHPUMnCxk6aWRI5ahn6GwhQ2eNDKkd9QxdLGToopEhjaOeoauFDF01MqR11DN0s5Chm0aGdI56hu4WMnTXyJDeUc/Qw0KGHhoZMjjqGXpayNBTI0NGRz1DLwsZemlkyOSoZ+htIUNvjQyZHfUMfSxk6KORIYujnqGvhQx9NTJkddQz9LOQoZ9GhmyOeob+FjL018iQ3VHPMMBChgEaGXI46hkGWsgwUCNDTkc9wyALGQZpZMjlqGcYbCHDYI0MuR31DEMsZBiikSGPo55hqIUMQzUy5HXUMwyzkGGYRoZ8jnqG4RYyDNfIkN9RzzDCQoYRGhkKOOoZRlrIMFIjQ0FHPcMoCxlGaWQo5KhnGG0hw2iNDIUd9QxjLGQYo5GhiKOeYayFDGM1MhR11DOMs5BhnEaGYo56hvEWMozXyFDcUc8wwUKGCRoZSjjqGSZayDBRI0NJRz3DJAsZJmlkKOWoZ5hsIcNkjQylHfUMUyxkmKKRoYyjnmGqhQxTNTKUddQzTLOQYZpGhnKOeobpFjJM18hQ3lHPMMNChhkaGSo46hlmWsgwUyNDRUc9wywLGWZpZKjkqGeYbSHDbI0MlR31DHMsZJijkaGKo55hroUMczUyVHXUM8yzkGGeRoZqjnqG+RYyzNfIUN1Rz7DAQoYFGhlqOOoZFlrIsFAjQ01HPcMiCxkWaWSo5ahnWGwhw2KNDLUd9QxLLGRYopGhjqOeYamFDEs1MtR11DMss5BhmUaGeo56huUWMizXyFDfUc+wwkKGFRoZGjjqGVZayLBSI0NDRz3DKgsZVmlkaOSoZ1htIcNqjQyNHfUMayxkWKORoYmjnmGthQxrNTI0ddQzrLOQYZ1GhmaOeob1FjKs18jQ3FHPsMFChg0aGVo46hk2WsiwUSNDS0c9wyYLGTZpZGjlqGfYbCHDZo0MrR31DFssZNiikaGNo55hq4UMWzUytHXUM2yzkGGbRoZ2jnqG7RYybNfI0N5Rz7DDQoYdGhk6OOoZdlrIsFMjQ0dHPcMuCxl2aWTo5Khn2G0hw26NDJ0d9Qx7LGTYo5Ghi6OeYa+FDHs1MnR11DPss5Bhn0aGbo56hv0WMuzXyNDdUc9wwEKGAxoZejjqGQ5ayHBQI0NPRz3DIQsZDmlk6OWoZzhsIcNhjQy9HfUMRyxkOKKRoY+jnuGohQxHNTL0ddQzHLOQ4ZhGhn6OeobjFjIc18jQ31HPcMJChhMaGQY46hlOWshwUiPDQEc9wykLGU5pZBjkqGc4bSHDaY0Mgx31DGcsZDijkWGIo57hrIUMZzUyDHXUM5yzkOGcRoZhjnqG8xYynNfIMNxRz3DBQoYLGhlGOOoZLlrIcFEjw0hHPcMlCxkuaWQY5ahnuGwhw2WNDKMd9QxXLGS4opFhjKOe4aqFDFc1Mox11DNcs5DhmkaGcY56husWMlzXyDDeUc9ww0KGGxoZJjjqGW5ayHBTI8NERz3DLQsZbmlkmOSoZ7htIcNtjQyTHfUMdyxkuKORYYqjnuGuhQx3NTJMddQz3LOQ4Z5GhmmOeob7FjLc18gw3VHP8MBChgcaGWY46hkeWsjwUCPDTEc9wyMLGR5pZJjlqGd4bCHDY40Msx31DE8sZHiikWGOo57hqYUMTzUyzHXUMzyzkOGZRoZ5jnqG5xYyPNfIMN9Rz/DCQoYXGhkWOOoZXlrI8FIjw0JHPcMrCxleaWRY5KhneG0hw2uNDIsd9QxvLGR4o5FhiaOe4a2FDG81Mix11DO8s5DhnUaGZY56hvcWMrzXyLDcUc/wwUKGDxoZVjjqGT5ayPBRI8NKRz3DJwsZPmlkWOWoZ/hsIcNnjQyrHfUMXyxk+KKRYY2jnuGrhQxfNTKsddQzfLOQ4ZtGhnWOeobvFjJ818iw3lHP4JT6/5/hx7+DZtjgqGcIYCFDAI0MGx31DAEtZAiokWGTo54hkIUMgTQybHbUMwS2kCGwRoYtjnoGDwsZPDQybHXUMwSxkCGIRoZtjnoGTwsZPDUybHfUMwS1kCGoRoYdjnqGYBYyBNPIsNNRzxDcQobgGhl2OeoZQljIEEIjw25HPYOXhQxeGhn2OOoZQlrIEFIjw15HPYO3hQzeGhn2OeoZQlnIEEojw35HPYOPhQw+GhkOOOoZQlvIEFojw0FHPYOvhQy+GhkOOeoZwljIEEYjw2FHPUNYCxnCamQ44qhnCGchQziNDEcd9QzhLWQIr5HhmKOeIYKFDBE0Mhx31DNEtJAhokaGE456hkgWMkTSyHDSUc8Q2UKGyBoZTjnqGaJYyBBFI8NpRz1DVAsZompkOOOoZ4hmIUM0jQxnHfUM0S1kiK6R4ZyjniGGhQwxNDKcd9Qz+FnI4KeR4YKjniGmhQwxNTJcdNQzxLKQIZZGhkuOeobYFjLE1shw2VHPEMdChjgaGa446hniWsgQVyPDVUc9QzwLGeJpZLjmqGeIbyFDfI0M1x31DAksZEigkeGGo54hoYUMCTUy3HTUMySykCGRRoZbjnqGxBYyJNbIcNtRz5DEQoYkGhnuOOoZklrIkFQjw11HPUMyCxmSaWS456hnSG4hQ3KNDPcd9QwpLGRIoZHhgaOeIaWFDCk1Mjx01DOkspAhlUaGR456htQWMqTWyPDYUc+QxkKGNBoZnjjqGdJayJBWI8NTRz1DOgsZ0mlkeOaoZ0hvIUN6jQzPHfUMGSxkyKCR4YWjniGjhQwZNTK8dNQzZLKQIZNGhleOeobMFjJk1sjw2lHPkMVChiwaGd446hmyWsiQVSPDW0c9QzYLGbJpZHjnqGfIbiFDdo0M7x31DDksZMihkeGDo54hp4UMOTUyfHTUM+SykCGXRoZPjnqG3BYy5NbI8NlRz5DHQoY8Ghm+OOoZ8lrIkFcjw1dHPUM+CxnyaWT45qhnyG8hQ36NDN8d9QwFLGQooJHhx7/o79k/ZShoIUNBjQwBQIZCFjIU0sgQEGQobCFDYY0MgUCGIhYyFNHIEBhkKGohQ1GNDB4gQzELGYppZAgCMhS3kKG4RgZPkKGEhQwlNDIEBRlKWshQUiNDMJChlIUMpTQyBAcZSlvIUFojQwiQoYyFDGU0MniBDGUtZCirkSEkyFDOQoZyGhm8QYbyFjKU18gQCmSoYCFDBY0MPiBDRQsZKmpkCA0yVLKQoZJGBl+QobKFDJU1MoQBGapYyFBFI0NYkKGqhQxVNTKEAxmqWchQTSNDeJChuoUM1TUyRAAZaljIUEMjQ0SQoaaFDDU1MkQCGWpZyFBLI0NkkKG2hQy1NTJEARnqWMhQRyNDVJChroUMdTUyRAMZ6lnIUE8jQ3SQob6FDPU1MsQAGRpYyNBAI4MfyNDQQoaGGhliggyNLGRopJEhFsjQ2EKGxhoZYoMMTSxkaKKRIQ7I0NRChqYaGeKCDM0sZGimkSEeyNDcQobmGhnigwwtLGRooZEhAcjQ0kKGlhoZEoIMrSxkaKWRIRHI0NpChtYaGRKDDG0sZGijkSEJyNDWQoa2GhmSggztLGRop5EhGcjQ3kKG9hoZkoMMHSxk6KCRIQXI0NFCho4aGVKCDJ0sZOikkSEVyNDZQobOGhlSgwxdLGToopEhDcjQ1UKGrhoZ0oIM3Sxk6KaRIR3I0N1Chu4aGdKDDD0sZOihkSEDyNDTQoaeGhkyggy9LGTopZEhE8jQ20KG3hoZMoMMfSxk6KORIQvI0NdChr4aGbKCDP0sZOinkSEbyNDfQob+GhmygwwDLGQYoJEhB8gw0EKGgRoZcoIMgyxkGKSRIRfIMNhChsEaGXKDDEMsZBiikSEPyDDUQoahGhnyggzDLGQYppEhH8gw3EKG4RoZ8oMMIyxkGKGRoQDIMNJChpEaGQqCDKMsZBilkaEQyDDaQobRGhkKgwxjLGQYo5GhCMgw1kKGsRoZioIM4yxkGKeRoRjIMN5ChvEaGYqDDBMsZJigkaEEyDDRQoaJGhlKggyTLGSYpJGhFMgw2UKGyRoZSoMMUyxkmKKRoQzIMNVChqkaGcqCDNMsZJimkaEcyDDdQobpGhnKgwwzLGSYoZGhAsgw00KGmRoZKoIMsyxkmKWRoRLIMNtChtkaGSqDDHMsZJijkaEKyDDXQoa5GhmqggzzLGSYp5GhGsgw30KG+RoZqoMMCyxkWKCRoQbIsNBChoUaGWqCDIssZFikkaEWyLDYQobFGhlqgwxLLGRYopGhDsiw1EKGpRoZ6oIMyyxkWKaRoR7IsNxChuUaGeqDDCssZFihkaEByLDSQoaVGhkaggyrLGRYpZGhEciw2kKG1RoZGoMMayxkWKORoQnIsNZChrUaGZqCDOssZFinkaEZyLDeQob1GhmagwwbLGTYoJGhBciw0UKGjRoZWoIMmyxk2KSRoRXIsNlChs0aGVqDDFssZNiikaENyLDVQoatGhnaggzbLGTYppGhHciw3UKG7RoZ2oMMOyxk2KGRoQPIsNNChp0aGTqCDLssZNilkaETyLDbQobdGhk6gwx7LGTYo5GhC8iw10KGvRoZuoIM+yxk2KeRoRvIsN9Chv0aGbqDDAcsZDigkaEHyHDQQoaDGhl6ggyHLGQ4pJGhF8hw2EKGwxoZeoMMRyxkOKKRoQ/IcNRChqMaGfqCDMcsZDimkaEfyHDcQobjGhn6gwwnLGQ4oZFhAMhw0kKGkxoZBoIMpyxkOKWRYRDIcNpChtMaGQaDDGcsZDijkWEIyHDWQoazGhmGggznLGQ4p5FhGMhw3kKG8xoZhoMMFyxkuKCRYQTIcNFChosaGUaCDJcsZLikkWEUyHDZQobLGhlGgwxXLGS4opFhDMhw1UKGqxoZxoIM1yxkuKaRYRzIcN1ChusaGcaDDDcsZLihkWECyHDTQoabGhkmggy3LGS4pZFhEshw20KG2xoZJoMMdyxkuKORYQrIcNdChrsaGaaCDPcsZLinkWEayHDfQob7GhmmgwwPLGR4oJFhBsjw0EKGhxoZZoIMjyxkeKSRYRbI8NhChscaGWaDDE8sZHiikWEOyPDUQoanGhnmggzPLGR4ppFhHsjw3EKG5xoZ5oMMLyxkeKGRYQHI8NJChpcaGRaCDK8sZHilkWERyPDaQobXGhkWgwxvLGR4o5FhCcjw1kKGtxoZloIM7yxkeKeRYRnI8N5ChvcaGZaDDB8sZPigkWEFyPDRQoaPGhlWggyfLGT4pJFhFcjw2UKGzxoZVoMMXyxk+KKRYQ3I8NVChq8aGdaCDN8sZPimkWEdyPDdQobvGhnWgwxO6f//GX78O2iGDSBDAAsZAmhk2AgyBLSQIaBGhk0gQyALGQJpZNgMMgS2kCGwRoYtIIOHhQweGhm2ggxBLGQIopFhG8jgaSGDp0aG7SBDUAsZgmpk2AEyBLOQIZhGhp0gQ3ALGYJrZNgFMoSwkCGERobdIIOXhQxeGhn2gAwhLWQIqZFhL8jgbSGDt0aGfSBDKAsZQmlk2A8y+FjI4KOR4QDIENpChtAaGQ6CDL4WMvhqZDgEMoSxkCGMRobDIENYCxnCamQ4AjKEs5AhnEaGoyBDeAsZwmtkOAYyRLCQIYJGhuMgQ0QLGSJqZDgBMkSykCGSRoaTIENkCxkia2Q4BTJEsZAhikaG0yBDVAsZompkOAMyRLOQIZpGhrMgQ3QLGaJrZDgHMsSwkCGGRobzIIOfhQx+GhkugAwxLWSIqZHhIsgQy0KGWBoZLoEMsS1kiK2R4TLIEMdChjgaGa6ADHEtZIirkeEqyBDPQoZ4GhmugQzxLWSIr5HhOsiQwEKGBBoZboAMCS1kSKiR4SbIkMhChkQaGW6BDIktZEiskeE2yJDEQoYkGhnugAxJLWRIqpHhLsiQzEKGZBoZ7oEMyS1kSK6R4T7IkMJChhQaGR6ADCktZEipkeEhyJDKQoZUGhkegQypLWRIrZHhMciQxkKGNBoZnoAMaS1kSKuR4SnIkM5ChnQaGZ6BDOktZEivkeE5yJDBQoYMGhlegAwZLWTIqJHhJciQyUKGTBoZXoEMmS1kyKyR4TXIkMVChiwaGd6ADFktZMiqkeEtyJDNQoZsGhnegQzZLWTIrpHhPciQw0KGHBoZPoAMOS1kyKmR4SPIkMtChlwaGT6BDLktZMitkeEzyJDHQoY8Ghm+gAx5LWTIq5HhK8iQz0KGfBoZvoEM+f8/Z3ACi39HSZ4hQGD1DAUscCigwSEgyFDQQoaCGhkCgQyFLGQopJEhMMhQ2EKGwhoZPECGIhYyFNHIEARkKGohQ1GNDJ4gQzELGYppZAgKMhS3kKG4RoZgIEMJCxlKaGQIDjKUtJChpEaGECBDKQsZSmlk8AIZSlvIUFojQ0iQoYyFDGU0MniDDGUtZCirkSEUyFDOQoZyGhl8QIbyFjKU18gQGmSoYCFDBY0MviBDRQsZKmpkCAMyVLKQoZJGhrAgQ2ULGSprZAgHMlSxkKGKRobwIENVCxmqamSIADJUs5ChmkaGiCBDdQsZqmtkiAQy1LCQoYZGhsggQ00LGWpqZIgCMtSykKGWRoaoIENtCxlqa2SIBjLUsZChjkaG6CBDXQsZ6mpkiAEy1LOQoZ5GBj+Qob6FDPU1MsQEGRpYyNBAI0MskKGhhQwNNTLEBhkaWcjQSCNDHJChsYUMjTUyxAUZmljI0EQjQzyQoamFDE01MsQHGZpZyNBMI0MCkKG5hQzNNTIkBBlaWMjQQiNDIpChpYUMLTUyJAYZWlnI0EojQxKQobWFDK3/H+/+FDRZ9r9hn122bdtqm9XdZbuybNu2bdu2bdu27eqJ/EdMxMTMwfu77om8D56zXOv6fnLl3s/J3oIhBzC0NBhaCoacwNDKYGglGHIBQ2uDobVgyA0MbQyGNoIhDzC0NRjaCoa8wNDOYGgnGPIBQ3uDob1gyA8MHQyGDoKhADB0NBg6CoYvgaGTwdBJMHwFDJ0Nhs6C4Wtg6GIwdBEM3wBDV4Ohq2D4Fhi6GQzdBMN3wNDdYOguGL4Hhh4GQw/B8AMw9DQYegqGH4Ghl8HQSzD8BAy9DYbeguFnYOhjMPQRDL8AQ1+Doa9g+BUY+hkM/QTDb8DQ32DoLxh+B4YBBsMAwfAHMAw0GAYKhj+BYZDBMEgw/AUMgw2GwYKhIDAMMRiGCIa/gWGowTBUMPwDDMMMhmGC4V9gGG4wDBcMhYBhhMEwQjAUBoaRBsNIwVAEGEYZDKMEQ1FgGG0wjBYMxYBhjMEwRjAUB4axBsNYwVACGMYZDOMEQ0lgGG8wjBcMpYBhgsEwQTCUBoaJBsNEwVAGGCYZDJMEQ1lgmGwwTBYM5YBhisEwRTCUB4apBsNUwVABGKYZDNMEQ0VgmG4wTBcMlYBhhsEwQzBUBoaZBsNMwVAFGGYZDLMEQ1VgmG0wzBYMAWCYYzDMEQzVgGGuwTBXMFQHhnkGwzzBUAMY5hsM8wVDTWBYYDAsEAy1gGGhwbBQMNQGhkUGwyLBUAcYFhsMiwVDXWBYYjAsEQz1gGGpwbBUMNQHhmUGwzLB0AAYlhsMywVDQ2BYYTCsEAyNgGGlwbBSMDQGhlUGwyrB0AQYVhsMqwVDU2BYYzCsEQzNgGGtwbBWMDQHhnUGwzrB0AIY1hsM6wVDS2DYYDBsEAytgGGjwbBRMLQGhk0GwybB0AYYNhsMmwVDW2DYYjBsEQztgGGrwbBVMLQHhm0GwzbB0AEYthsM2wVDR2DYYTDsEAydgGGnwbBTMHQGhl0Gwy7B0AUYdhsMuwVDV2DYYzDsEQzdgGGvwbBXMHQHhn0Gwz7B0AMY9hsM+wVDT2A4YDAcEAy9gOGgwXBQMPQGhkMGwyHB0AcYDhsMhwVDX2A4YjAcEQz9gOGowXBUMPQHhmMGwzHBMAAYjhsMxwXDQGA4YTCcEAyDgOGkwXBSMAwGhlMGwynBMAQYThsMpwXDUGA4YzCcEQzDgOGswXBWMAwHhnMGwznBMAIYzhsM5wXDSGC4YDBcEAyjgOGiwXBRMIwGhksGwyXBMAYYLhsMlwXDWGC4YjBcEQzjgOGqwXBVMIwHhmsGwzXBMAEYrhsM1wXDRGC4YTDcEAyTgOGmwXBTMEwGhlsGwy3BMAUYbhsMtwXDVGC4YzDcEQzTgOGuwXBXMEwHhnsGwz3BMAMY7hsM9wXDTGB4YDA8EAyzgOGhwfBQMMwGhkcGwyPBMAcYHhsMjwXDXGB4YjA8EQzzgOGpwfBUMMwHhmcGwzPBsAAYnhsMzwXDQmB4YTC8EAyLgOGlwfBSMCwGhlcGwyvBsAQYXhsMrwXDUmB4YzC8EQzLgOGtwfBWMCwHhncGwzvBsAIY3hsM7wXDSmD4YDB8EAyrgOGjwfBRMKwGhk8GwyfBsAYYPhsMnwXDWmD4z2D4TzCsA4YvSoXeEGxQw3pgCGMwhBEMG4AhrMEQVjBsBIZwBkM4wbAJGMIbDOEFw2ZgiGAwRBAMW4AhosEQUTBsBYZIBkMkwbANGCIbDJEFw3ZgiGIwRBEMO4AhqsEQVTDsBIZoBkM0wbALGKIbDNEFw25giGEwxBAMe4AhpsEQUzDsBYZYBkMswbAPGGIbDLEFw35giGMwxBEMB4AhrsEQVzAcBIZ4BkM8wXAIGOIbDPEFw2FgSGAwJBAMR4AhocGQUDAcBYZEBkMiwXAMGBIbDIkFw3FgSGIwJBEMJ4AhqcGQVDCcBIZkBkMywXAKGJIbDMkFw2lgSGEwpBAMZ4AhpcGQUjCcBYZUBkMqwXAOGFIbDKkFw3lgSGMwpBEMF4AhrcGQVjBcBIZ0BkM6wXAJGNIbDOkFw2VgyGAwZBAMV4Aho8GQUTBcBYZMBkMmwXANGDIbDJkFw3VgyGIwZBEMN4Ahq8GQVTDcBIZsBkM2wXALGLIbDNkFw21gyGEw5BAMd4Ahp8GQUzDcBYZcBkMuwXAPGHIbDLkFw31gyGMw5BEMD4Ahr8GQVzA8BIZ8BkM+wfAIGPIbDPkFw2NgKGAwFBAMT4DhS4PhS8HwFBi+Mhi+EgzPgOFrg+FrwfAcGL4xGL4RDC+A4VuD4VvB8BIYvjMYvhMMr4Dhe4Phe8HwGhh+MBh+EAxvgOFHg+FHwfAWGH4yGH4SDO+A4WeD4WfB8B4YfjEYfhEMH4DhV4PhV8HwERh+Mxh+EwyfgOF3g+F3wfAZGP4wGP4QDP8Bw58Gw5+C4YsI/7vhL4PhL8EQBhgKGgwFBUNYYPjbYPhbMIQDhn8Mhn8EQ3hg+Ndg+FcwRACGQgZDIcEQERgKGwyFBUMkYChiMBQRDJGBoajBUFQwRAGGYgZDMcEQFRiKGwzFBUM0YChhMJQQDNGBoaTBUFIwxACGUgZDKcEQExhKGwylBUMsYChjMJQRDLGBoazBUFYwxAGGcgZDOcEQFxjKGwzlBUM8YKhgMFQQDPGBoaLBUFEwJACGSgZDJcGQEBgqGwyVBUMiYKhiMFQRDImBoarBUFUwJAGGgMEQEAxJgaGawVBNMCQDhuoGQ3XBkBwYahgMNQRDCmCoaTDUFAwpgaGWwVBLMKQChtoGQ23BkBoY6hgMdQRDGmCoazDUFQxpgaGewVBPMKQDhvoGQ33BkB4YGhgMDQRDBmBoaDA0FAwZgaGRwdBIMGQChsYGQ2PBkBkYmhgMTQRDFmBoajA0FQxZgaGZwdBMMGQDhuYGQ3PBkB0YWhgMLQRDDmBoaTC0FAw5gaGVwdBKMOQChtYGQ2vBkBsY2hgMbQRDHmBoazC0FQx5gaGdwdBOMOQDhvYGQ3vBkB8YOhgMHQRDAWDoaDB0FAxfAkMng6GTYPgKGDobDJ0Fw9fA0MVg6CIYvgGGrgZDV8HwLTB0Mxi6CYbvgKG7wdBdMHwPDD0Mhh6C4Qdg6Gkw9BQMPwJDL4Ohl2D4CRh6Gwy9BcPPwNDHYOgjGH4Bhr4GQ1/B8Csw9DMY+gmG34Chv8HQXzD8DgwDDIYBguEPYBhoMAwUDH8CwyCDYZBg+AsYBhsMgwVDQWAYYjAMEQx/A8NQg2GoYPgHGIYZDMMEw7/AMNxgGC4YCgHDCINhhGAoDAwjDYaRgqEIMIwyGEYJhqLAMNpgGC0YigHDGINhjGAoDgxjDYaxgqEEMIwzGMYJhpLAMN5gGC8YSgHDBINhgmAoDQwTDYaJgqEMMEwyGCYJhrLAMNlgmCwYygHDFINhimAoDwxTDYapgqECMEwzGKYJhorAMN1gmC4YKgHDDINhhmCoDAwzDYaZgqEKMMwyGGYJhqrAMNtgmC0YAsAwx2CYIxiqAcNcg2GuYKgODPMMhnmCoQYwzDcY5guGmsCwwGBYIBhqAcNCg2GhYKgNDIsMhkWCoQ4wLDYYFguGusCwxGBYIhjqAcNSg2GpYKgPDMsMhmWCoQEwLDcYlguGhsCwwmBYIRgaAcNKg2GlYGgMDKsMhlWCoQkwrDYYVguGpsCwxmBYIxiaAcNag2GtYGgODOsMhnWCoQUwrDcY1guGlsCwwWDYIBhaAcNGg2GjYGgNDJsMhk2CoQ0wbDYYNguGtsCwxWDYIhjaAcNWg2GrYGgPDNsMhm2CoQMwbDcYtguGjsCww2DYIRg6AcNOg2GnYOgMDLsMhl2CoQsw7DYYdguGrsCwx2DYIxi6AcNeg2GvYOgODPsMhn2CoQcw7DcY9guGnsBwwGA4IBh6AcNBg+GgYOgNDIcMhkOCoQ8wHDYYDguGvsBwxGA4Ihj6AcNRg+GoYOgPDMcMhmOCYQAwHDcYjguGgcBwwmA4IRgGAcNJg+GkYBgMDKcMhlOCYQgwnDYYTguGocBwxmA4IxiGAcNZg+GsYBgODOcMhnOCYQQwnDcYzguGkcBwwWC4IBhGAcNFg+GiYBgNDJcMhkuCYQwwXDYYLguGscBwxWC4IhjGAcNVg+GqYBgPDNcMhmuCYQIwXDcYrguGicBww2C4IRgmAcNNg+GmYJgMDLcMhluCYQow3DYYbguGqcBwx2C4IximAcNdg+GuYJgODPcMhnuCYQYw3DcY7guGmcDwwGB4IBhmAcNDg+GhYJgNDI8MhkeCYQ4wPDYYHguGucDwxGB4IhjmAcNTg+GpYJgPDM8MhmeCYQEwPDcYnguGhcDwwmB4IRgWAcNLg+GlYFgMDK8MhleCYQkwvDYYXguGpcDwxmB4IxiWAcNbg+GtYFgODO8MhneCYQUwvDcY3guGlcDwwWD4IBhWAcNHg+GjYFgNDJ8Mhk+CYQ0wfDYYPguGtcDwn8Hwn2BYBwxflA69IdighvXAEMZgCCMYNgBDWIMhrGDYCAzhDIZwgmETMIQ3GMILhs3AEMFgiCAYtgBDRIMhomDYCgyRDIZIgmEbMEQ2GCILhu3AEMVgiCIYdgBDVIMhqmDYCQzRDIZogmEXMEQ3GKILht3AEMNgiCEY9gBDTIMhpmDYCwyxDIZYgmEfMMQ2GGILhv3AEMdgiCMYDgBDXIMhrmA4CAzxDIZ4guEQMMQ3GOILhsPAkMBgSCAYjgBDQoMhoWA4CgyJDIZEguEYMCQ2GBILhuPAkMRgSCIYTgBDUoMhqWA4CQzJDIZkguEUMCQ3GJILhtPAkMJgSCEYzgBDSoMhpWA4CwypDIZUguEcMKQ2GFILhvPAkMZgSCMYLgBDWoMhrWC4CAzpDIZ0guESMKQ3GNILhsvAkMFgyCAYrgBDRoMho2C4CgyZDIZMguEaMGQ2GDILhuvAkMVgyCIYbgBDVoMhq2C4CQzZDIZsguEWMGQ3GLILhtvAkMNgyCEY7gBDToMhp2C4Cwy5DIZcguEeMOQ2GHILhvvAkMdgyCMYHgBDXoMhr2B4CAz5DIZ8guERMOQ3GPILhsfAUMBgKCAYngDDlwbDl4LhKTB8ZTB8JRieAcPXBsPXguE5MHxjMHwjGF4Aw7cGw7eC4SUwfGcwfCcYXgHD9wbD94LhNTD8YDD8IBjeAMOPBsOPguEtMPxkMPwkGN4Bw88Gw8+C4T0w/GIw/CIYPgDDrwbDr4LhIzD8ZjD8Jhg+AcPvBsPvguEzMPwRYsMXEb/44v/ep4HrwkT83w1/Gs7hT+EcwgLDXwbDX4IhHDAUNBgKCobwwPC3wfC3YIgADP8YDP8IhojA8K/B8K9giAQMhQyGQoIhMjAUNhgKC4YowFDEYCgiGKICQ1GDoahgiAYMxQyGYoIhOjAUNxiKC4YYwFDCYCghGGICQ0mDoaRgiAUMpQyGUoIhNjCUNhhKC4Y4wFDGYCgjGOICQ1mDoaxgiAcM5QyGcoIhPjCUNxjKC4YEwFDBYKggGBICQ0WDoaJgSAQMlQyGSoIhMTBUNhgqC4YkwFDFYKgiGJICQ1WDoapgSAYMAYMhIBiSA0M1g6GaYEgBDNUNhuqCISUw1DAYagiGVMBQ02CoKRhSA0Mtg6GWYEgDDLUNhtqCIS0w1DEY6giGdMBQ12CoKxjSA0M9g6GeYMgADPUNhvqCISMwNDAYGgiGTMDQ0GBoKBgyA0Mjg6GRYMgCDI0NhsaCISswNDEYmgiGbMDQ1GBoKhiyA0Mzg6GZYMgBDM0NhuaCIScwtDAYWgiGXMDQ0mBoKRhyA0Mrg6GVYMgDDK0NhtaCIS8wtDEY2giGfMDQ1mBoKxjyA0M7g6GdYCgADO0NhvaC4Utg6GAwdBAMXwFDR4Oho2D4Ghg6GQydBMM3wNDZYOgsGL4Fhi4GQxfB8B0wdDUYugqG74Ghm8HQTTD8AAzdDYbuguFHYOhhMPQQDD8BQ0+Doadg+BkYehkMvQTDL8DQ22DoLRh+BYY+BkMfwfAbMPQ1GPoKht+BoZ/B0E8w/AEM/Q2G/oLhT2AYYDAMEAx/AcNAg2GgYCgIDIMMhkGC4W9gGGwwDBYM/wDDEINhiGD4FxiGGgxDBUMhYBhmMAwTDIWBYbjBMFwwFAGGEQbDCMFQFBhGGgwjBUMxYBhlMIwSDMWBYbTBMFowlACGMQbDGMFQEhjGGgxjBUMpYBhnMIwTDKWBYbzBMF4wlAGGCQbDBMFQFhgmGgwTBUM5YJhkMEwSDOWBYbLBMFkwVACGKQbDFMFQERimGgxTBUMlYJhmMEwTDJWBYbrBMF0wVAGGGQbDDMFQFRhmGgwzBUMAGGYZDLMEQzVgmG0wzBYM1YFhjsEwRzDUAIa5BsNcwVATGOYZDPMEQy1gmG8wzBcMtYFhgcGwQDDUAYaFBsNCwVAXGBYZDIsEQz1gWGwwLBYM9YFhicGwRDA0AIalBsNSwdAQGJYZDMsEQyNgWG4wLBcMjYFhhcGwQjA0AYaVBsNKwdAUGFYZDKsEQzNgWG0wrBYMzYFhjcGwRjC0AIa1BsNawdASGNYZDOsEQytgWG8wrBcMrYFhg8GwQTC0AYaNBsNGwdAWGDYZDJsEQztg2GwwbBYM7YFhi8GwRTB0AIatBsNWwdARGLYZDNsEQydg2G4wbBcMnYFhh8GwQzB0AYadBsNOwdAVGHYZDLsEQzdg2G0w7BYM3YFhj8GwRzD0AIa9BsNewdATGPYZDPsEQy9g2G8w7BcMvYHhgMFwQDD0AYaDBsNBwdAXGA4ZDIcEQz9gOGwwHBYM/YHhiMFwRDAMAIajBsNRwTAQGI4ZDMcEwyBgOG4wHBcMg4HhhMFwQjAMAYaTBsNJwTAUGE4ZDKcEwzBgOG0wnBYMw4HhjMFwRjCMAIazBsNZwTASGM4ZDOcEwyhgOG8wnBcMo4HhgsFwQTCMAYaLBsNFwTAWGC4ZDJcEwzhguGwwXBYM44HhisFwRTBMAIarBsNVwTARGK4ZDNcEwyRguG4wXBcMk4HhhsFwQzBMAYabBsNNwTAVGG4ZDLcEwzRguG0w3BYM04HhjsFwRzDMAIa7BsNdwTATGO4ZDPcEwyxguG8w3BcMs4HhgcHwQDDMAYaHBsNDwTAXGB4ZDI8EwzxgeGwwPBYM84HhicHwRDAsAIanBsNTwbAQGJ4ZDM8EwyJgeG4wPBcMi4HhhcHwQjAsAYaXBsNLwbAUGF4ZDK8EwzJgeG0wvBYMy4HhjcHwRjCsAIa3BsNbwbASGN4ZDO8EwypgeG8wvBcMq4Hhg8HwQTCsAYaPBsNHwbAWGD4ZDJ8Ewzpg+GwwfBYM64HhP4PhP8GwARi+KBN6Q7BBDRuBIYzBEEYwbAKGsAZDWMGwGRjCGQzhBMMWYAhvMIQXDFuBIYLBEEEwbAOGiAZDRMGwHRgiGQyRBMMOYIhsMEQWDDuBIYrBEEUw7AKGqAZDVMGwGxiiGQzRBMMeYIhuMEQXDHuBIYbBEEMw7AOGmAZDTMGwHxhiGQyxBMMBYIhtMMQWDAeBIY7BEEcwHAKGuAZDXMFwGBjiGQzxBMMRYIhvMMQXDEeBIYHBkEAwHAOGhAZDQsFwHBgSGQyJBMMJYEhsMCQWDCeBIYnBkEQwnAKGpAZDUsFwGhiSGQzJBMMZYEhuMCQXDGeBIYXBkEIwnAOGlAZDSsFwHhhSGQypBMMFYEhtMKQWDBeBIY3BkEYwXAKGtAZDWsFwGRjSGQzpBMMVYEhvMKQXDFeBIYPBkEEwXAOGjAZDRsFwHRgyGQyZBMMNYMhsMGQWDDeBIYvBkEUw3AKGrAZDVsFwGxiyGQzZBMMdYMhuMGQXDHeBIYfBkEMw3AOGnAZDTsFwHxhyGQy5BMMDYMhtMOQWDA+BIY/BkEcwPAKGvAZDXsHwGBjyGQz5BMMTYMhvMOQXDE+BoYDBUEAwPAOGLw2GLwXDc2D4ymD4SjC8AIavDYavBcNLYPjGYPhGMLwChm8Nhm8Fw2tg+M5g+E4wvAGG7w2G7wXDW2D4wWD4QTC8A4YfDYYfBcN7YPjJYPhJMHwAhp8Nhp8Fw0dg+MVg+EUwfAKGXw2GXwXDZ2D4zWD4TTD8Bwy/Gwy/C4YvIv3vhj8Mhj8EQxhg+NNg+FMwhAWGvwyGvwRDOGAoaDAUFAzhgeFvg+FvwRABGP4xGP4RDBGB4V+D4V/BEAkYChkMhQRDZGAobDAUFgxRgKGIwVBEMEQFhqIGQ1HBEA0YihkMxQRDdGAobjAUFwwxgKGEwVBCMMQEhpIGQ0nBEAsYShkMpQRDbGAobTCUFgxxgKGMwVBGMMQFhrIGQ1nBEA8YyhkM5QRDfGAobzCUFwwJgKGCwVBBMCQEhooGQ0XBkAgYKhkMlQRDYmCobDBUFgxJgKGKwVBFMCQFhqoGQ1XBkAwYAgZDQDAkB4ZqBkM1wZACGKobDNUFQ0pgqGEw1BAMqYChpsFQUzCkBoZaBkMtwZAGGGobDLUFQ1pgqGMw1BEM6YChrsFQVzCkB4Z6BkM9wZABGOobDPUFQ0ZgaGAwNBAMmYChocHQUDBkBoZGBkMjwZAFGBobDI0FQ1ZgaGIwNBEM2YChqcHQVDBkB4ZmBkMzwZADGJobDM0FQ05gaGEwtBAMuYChpcHQUjDkBoZWBkMrwZAHGFobDK0FQ15gaGMwtBEM+YChrcHQVjDkB4Z2BkM7wVAAGNobDO0Fw5fA0MFg6CAYvgKGjgZDR8HwNTB0Mhg6CYZvgKGzwdBZMHwLDF0Mhi6C4Ttg6GowdBUM3wNDN4Ohm2D4ARi6GwzdBcOPwNDDYOghGH4Chp4GQ0/B8DMw9DIYegmGX4Cht8HQWzD8Cgx9DIY+guE3YOhrMPQVDL8DQz+DoZ9g+AMY+hsM/QXDn8AwwGAYIBj+AoaBBsNAwVAQGAYZDIMEw9/AMNhgGCwY/gGGIQbDEMHwLzAMNRiGCoZCwDDMYBgmGAoDw3CDYbhgKAIMIwyGEYKhKDCMNBhGCoZiwDDKYBglGIoDw2iDYbRgKAEMYwyGMYKhJDCMNRjGCoZSwDDOYBgnGEoDw3iDYbxgKAMMEwyGCYKhLDBMNBgmCoZywDDJYJgkGMoDw2SDYbJgqAAMUwyGKYKhIjBMNRimCoZKwDDNYJgmGCoDw3SDYbpgqAIMMwyGGYKhKjDMNBhmCoYAMMwyGGYJhmrAMNtgmC0YqgPDHINhjmCoAQxzDYa5gqEmMMwzGOYJhlrAMN9gmC8YagPDAoNhgWCoAwwLDYaFgqEuMCwyGBYJhnrAsNhgWCwY6gPDEoNhiWBoAAxLDYalgqEhMCwzGJYJhkbAsNxgWC4YGgPDCoNhhWBoAgwrDYaVgqEpMKwyGFYJhmbAsNpgWC0YmgPDGoNhjWBoAQxrDYa1gqElMKwzGNYJhlbAsN5gWC8YWgPDBoNhg2BoAwwbDYaNgqEtMGwyGDYJhnbAsNlg2CwY2gPDFoNhi2DoAAxbDYatgqEjMGwzGLYJhk7AsN1g2C4YOgPDDoNhh2DoAgw7DYadgqErMOwyGHYJhm7AsNtg2C0YugPDHoNhj2DoAQx7DYa9gqEnMOwzGPYJhl7AsN9g2C8YegPDAYPhgGDoAwwHDYaDgqEvMBwyGA4Jhn7AcNhgOCwY+gPDEYPhiGAYAAxHDYajgmEgMBwzGI4JhkHAcNxgOC4YBgPDCYPhhGAYAgwnDYaTgmEoMJwyGE4JhmHAcNpgOC0YhgPDGYPhjGAYAQxnDYazgmEkMJwzGM4JhlHAcN5gOC8YRgPDBYPhgmAYAwwXDYaLgmEsMFwyGC4JhnHAcNlguCwYxgPDFYPhimCYAAxXDYargmEiMFwzGK4JhknAcN1guC4YJgPDDYPhhmCYAgw3DYabgmEqMNwyGG4JhmnAcNtguC0YpgPDHYPhjmCYAQx3DYa7gmEmMNwzGO4JhlnAcN9guC8YZgPDA4PhgWCYAwwPDYaHgmEuMDwyGB4JhnnA8NhgeCwY5gPDE4PhiWBYAAxPDYangmEhMDwzGJ4JhkXA8NxgeC4YFgPDC4PhhWBYAgwvDYaXgmEpMLwyGF4JhmXA8NpgeC0YlgPDG4PhjWBYAQxvDYa3gmElMLwzGN4JhlXA8N5geC8YVgPDB4Phg2BYAwwfDYaPgmEtMHwyGD4JhnXA8Nlg+CwY1gPDfwbDf4JhAzB8UTb0hmCDGjYCQxiDIYxg2AQMYQ2GsIJhMzCEMxjCCYYtwBDeYAgvGLYCQwSDIYJg2AYMEQ2GiIJhOzBEMhgiCYYdwBDZYIgsGHYCQxSDIYpg2AUMUQ2GqIJhNzBEMxiiCYY9wBDdYIguGPYCQwyDIYZg2AcMMQ2GmIJhPzDEMhhiCYYDwBDbYIgtGA4CQxyDIY5gOAQMcQ2GuILhMDDEMxjiCYYjwBDfYIgvGI4CQwKDIYFgOAYMCQ2GhILhODAkMhgSCYYTwJDYYEgsGE4CQxKDIYlgOAUMSQ2GpILhNDAkMxiSCYYzwJDcYEguGM4CQwqDIYVgOAcMKQ2GlILhPDCkMhhSCYYLwJDaYEgtGC4CQxqDIY1guAQMaQ2GtILhMjCkMxjSCYYrwJDeYEgvGK4CQwaDIYNguAYMGQ2GjILhOjBkMhgyCYYbwJDZYMgsGG4CQxaDIYtguAUMWQ2GrILhNjBkMxiyCYY7wJDdYMguGO4CQw6DIYdguAcMOQ2GnILhPjDkMhhyCYYHwJDbYMgtGB4CQx6DIY9geAQMeQ2GvILhMTDkMxjyCYYnwJDfYMgvGJ4CQwGDoYBgeAYMXxoMXwqG58DwlcHwlWB4AQxfGwxfC4aXwPCNwfCNYHgFDN8aDN8KhtfA8J3B8J1geAMM3xsM3wuGt8Dwg8Hwg2B4Bww/Ggw/Cob3wPCTwfCTYPgADD8bDD8Lho/A8IvB8Itg+AQMvxoMvwqGz8DwW4gNX0T/4ov/e48DrgsT/X83/G44h9+FcwgLDH8YDH8IhnDA8KfB8KdgCA8MfxkMfwmGCMBQ0GAoKBgiAsPfBsPfgiESMPxjMPwjGCIDw78Gw7+CIQowFDIYCgmGqMBQ2GAoLBiiAUMRg6GIYIgODEUNhqKCIQYwFDMYigmGmMBQ3GAoLhhiAUMJg6GEYIgNDCUNhpKCIQ4wlDIYSgmGuMBQ2mAoLRjiAUMZg6GMYIgPDGUNhrKCIQEwlDMYygmGhMBQ3mAoLxgSAUMFg6GCYEgMDBUNhoqCIQkwVDIYKgmGpMBQ2WCoLBiSAUMVg6GKYEgODFUNhqqCIQUwBAyGgGBICQzVDIZqgiEVMFQ3GKoLhtTAUMNgqCEY0gBDTYOhpmBICwy1DIZagiEdMNQ2GGoLhvTAUMdgqCMYMgBDXYOhrmDICAz1DIZ6giETMNQ3GOoLhszA0MBgaCAYsgBDQ4OhoWDICgyNDIZGgiEbMDQ2GBoLhuzA0MRgaCIYcgBDU4OhqWDICQzNDIZmgiEXMDQ3GJoLhtzA0MJgaCEY8gBDS4OhpWDICwytDIZWgiEfMLQ2GFoLhvzA0MZgaCMYCgBDW4OhrWD4EhjaGQztBMNXwNDeYGgvGL4Ghg4GQwfB8A0wdDQYOgqGb4Ghk8HQSTB8BwydDYbOguF7YOhiMHQRDD8AQ1eDoatg+BEYuhkM3QTDT8DQ3WDoLhh+BoYeBkMPwfALMPQ0GHoKhl+BoZfB0Esw/AYMvQ2G3oLhd2DoYzD0EQx/AENfg6GvYPgTGPoZDP0Ew1/A0N9g6C8YCgLDAINhgGD4GxgGGgwDBcM/wDDIYBgkGP4FhsEGw2DBUAgYhhgMQwRDYWAYajAMFQxFgGGYwTBMMBQFhuEGw3DBUAwYRhgMIwRDcWAYaTCMFAwlgGGUwTBKMJQEhtEGw2jBUAoYxhgMYwRDaWAYazCMFQxlgGGcwTBOMJQFhvEGw3jBUA4YJhgMEwRDeWCYaDBMFAwVgGGSwTBJMFQEhskGw2TBUAkYphgMUwRDZWCYajBMFQxVgGGawTBNMFQFhukGw3TBEACGGQbDDMFQDRhmGgwzBUN1YJhlMMwSDDWAYbbBMFsw1ASGOQbDHMFQCxjmGgxzBUNtYJhnMMwTDHWAYb7BMF8w1AWGBQbDAsFQDxgWGgwLBUN9YFhkMCwSDA2AYbHBsFgwNASGJQbDEsHQCBiWGgxLBUNjYFhmMCwTDE2AYbnBsFwwNAWGFQbDCsHQDBhWGgwrBUNzYFhlMKwSDC2AYbXBsFowtASGNQbDGsHQChjWGgxrBUNrYFhnMKwTDG2AYb3BsF4wtAWGDQbDBsHQDhg2GgwbBUN7YNhkMGwSDB2AYbPBsFkwdASGLQbDFsHQCRi2GgxbBUNnYNhmMGwTDF2AYbvBsF0wdAWGHQbDDsHQDRh2Ggw7BUN3YNhlMOwSDD2AYbfBsFsw9ASGPQbDHsHQCxj2Ggx7BUNvYNhnMOwTDH2AYb/BsF8w9AWGAwbDAcHQDxgOGgwHBUN/YDhkMBwSDAOA4bDBcFgwDASGIwbDEcEwCBiOGgxHBcNgYDhmMBwTDEOA4bjBcFwwDAWGEwbDCcEwDBhOGgwnBcNwYDhlMJwSDCOA4bTBcFowjASGMwbDGcEwChjOGgxnBcNoYDhnMJwTDGOA4bzBcF4wjAWGCwbDBcEwDhguGgwXBcN4YLhkMFwSDBOA4bLBcFkwTASGKwbDFcEwCRiuGgxXBcNkYLhmMFwTDFOA4brBcF0wTAWGGwbDDcEwDRhuGgw3BcN0YLhlMNwSDDOA4bbBcFswzASGOwbDHcEwCxjuGgx3BcNsYLhnMNwTDHOA4b7BcF8wzAWGBwbDA8EwDxgeGgwPBcN8YHhkMDwSDAuA4bHB8FgwLASGJwbDE8GwCBieGgxPBcNiYHhmMDwTDEuA4bnB8FwwLAWGFwbDC8GwDBheGgwvBcNyYHhlMLwSDCuA4bXB8FowrASGNwbDG8GwChjeGgxvBcNqYHhnMLwTDGuA4b3B8F4wrAWGDwbDB8GwDhg+GgwfBcN6YPhkMHwSDBuA4bPB8FkwbASG/wyG/wTDJmD4olzoDcEGNWwGhjAGQxjBsAUYwhoMYQXDVmAIZzCEEwzbgCG8wRBeMGwHhggGQwTBsAMYIhoMEQXDTmCIZDBEEgy7gCGywRBZMOwGhigGQxTBsAcYohoMUQXDXmCIZjBEEwz7gCG6wRBdMOwHhhgGQwzBcAAYYhoMMQXDQWCIZTDEEgyHgCG2wRBbMBwGhjgGQxzBcAQY4hoMcQXDUWCIZzDEEwzHgCG+wRBfMBwHhgQGQwLBcAIYEhoMCQXDSWBIZDAkEgyngCGxwZBYMJwGhiQGQxLBcAYYkhoMSQXDWWBIZjAkEwzngCG5wZBcMJwHhhQGQwrBcAEYUhoMKQXDRWBIZTCkEgyXgCG1wZBaMFwGhjQGQxrBcAUY0hoMaQXDVWBIZzCkEwzXgCG9wZBeMFwHhgwGQwbBcAMYMhoMGQXDTWDIZDBkEgy3gCGzwZBZMNwGhiwGQxbBcAcYshoMWQXDXWDIZjBkEwz3gCG7wZBdMNwHhhwGQw7B8AAYchoMOQXDQ2DIZTDkEgyPgCG3wZBbMDwGhjwGQx7B8AQY8hoMeQXDU2DIZzDkEwzPgCG/wZBfMDwHhgIGQwHB8AIYvjQYvhQML4HhK4PhK8HwChi+Nhi+FgyvgeEbg+EbwfAGGL41GL4VDG+B4TuD4TvB8A4YvjcYvhcM74HhB4PhB8HwARh+NBh+FAwfgeEng+EnwfAJGH42GH4WDJ+B4ReD4RfB8B8w/Gow/CoYvojxvxt+Mxh+EwxhgOF3g+F3wRAWGP4wGP4QDOGA4U+D4U/BEB4Y/jIY/hIMEYChoMFQUDBEBIa/DYa/BUMkYPjHYPhHMEQGhn8Nhn8FQxRgKGQwFBIMUYGhsMFQWDBEA4YiBkMRwRAdGIoaDEUFQwxgKGYwFBMMMYGhuMFQXDDEAoYSBkMJwRAbGEoaDCUFQxxgKGUwlBIMcYGhtMFQWjDEA4YyBkMZwRAfGMoaDGUFQwJgKGcwlBMMCYGhvMFQXjAkAoYKBkMFwZAYGCoaDBUFQxJgqGQwVBIMSYGhssFQWTAkA4YqBkMVwZAcGKoaDFUFQwpgCBgMAcGQEhiqGQzVBEMqYKhuMFQXDKmBoYbBUEMwpAGGmgZDTcGQFhhqGQy1BEM6YKhtMNQWDOmBoY7BUEcwZACGugZDXcGQERjqGQz1BEMmYKhvMNQXDJmBoYHB0EAwZAGGhgZDQ8GQFRgaGQyNBEM2YGhsMDQWDNmBoYnB0EQw5ACGpgZDU8GQExiaGQzNBEMuYGhuMDQXDLmBoYXB0EIw5AGGlgZDS8GQFxhaGQytBEM+YGhtMLQWDPmBoY3B0EYwFACGtgZDW8HwJTC0MxjaCYavgKG9wdBeMHwNDB0Mhg6C4Rtg6GgwdBQM3wJDJ4Ohk2D4Dhg6GwydBcP3wNDFYOgiGH4Ahq4GQ1fB8CMwdDMYugmGn4Chu8HQXTD8DAw9DIYeguEXYOhpMPQUDL8CQy+DoZdg+A0YehsMvQXD78DQx2DoIxj+AIa+BkNfwfAnMPQzGPoJhr+Aob/B0F8wFASGAQbDAMHwNzAMNBgGCoZ/gGGQwTBIMPwLDIMNhsGCoRAwDDEYhgiGwsAw1GAYKhiKAMMwg2GYYCgKDMMNhuGCoRgwjDAYRgiG4sAw0mAYKRhKAMMog2GUYCgJDKMNhtGCoRQwjDEYxgiG0sAw1mAYKxjKAMM4g2GcYCgLDOMNhvGCoRwwTDAYJgiG8sAw0WCYKBgqAMMkg2GSYKgIDJMNhsmCoRIwTDEYpgiGysAw1WCYKhiqAMM0g2GaYKgKDNMNhumCIQAMMwyGGYKhGjDMNBhmCobqwDDLYJglGGoAw2yDYbZgqAkMcwyGOYKhFjDMNRjmCobawDDPYJgnGOoAw3yDYb5gqAsMCwyGBYKhHjAsNBgWCob6wLDIYFgkGBoAw2KDYbFgaAgMSwyGJYKhETAsNRiWCobGwLDMYFgmGJoAw3KDYblgaAoMKwyGFYKhGTCsNBhWCobmwLDKYFglGFoAw2qDYbVgaAkMawyGNYKhFTCsNRjWCobWwLDOYFgnGNoAw3qDYb1gaAsMGwyGDYKhHTBsNBg2Cob2wLDJYNgkGDoAw2aDYbNg6AgMWwyGLYKhEzBsNRi2CobOwLDNYNgmGLoAw3aDYbtg6AoMOwyGHYKhGzDsNBh2CobuwLDLYNglGHoAw26DYbdg6AkMewyGPYKhFzDsNRj2CobewLDPYNgnGPoAw36DYb9g6AsMBwyGA4KhHzAcNBgOCob+wHDIYDgkGAYAw2GD4bBgGAgMRwyGI4JhEDAcNRiOCobBwHDMYDgmGIYAw3GD4bhgGAoMJwyGE4JhGDCcNBhOCobhwHDKYDglGEYAw2mD4bRgGAkMZwyGM4JhFDCcNRjOCobRwHDOYDgnGMYAw3mD4bxgGAsMFwyGC4JhHDBcNBguCobxwHDJYLgkGCYAw2WD4bJgmAgMVwyGK4JhEjBcNRiuCobJwHDNYLgmGKYAw3WD4bpgmAoMNwyGG4JhGjDcNBhuCobpwHDLYLglGGYAw22D4bZgmAkMdwyGO4JhFjDcNRjuCobZwHDPYLgnGOYAw32D4b5gmAsMDwyGB4JhHjA8NBgeCob5wPDIYHgkGBYAw2OD4bFgWAgMTwyGJ4JhETA8NRieCobFwPDMYHgmGJYAw3OD4blgWAoMLwyGF4JhGTC8NBheCoblwPDKYHglGFYAw2uD4bVgWAkMbwyGN4JhFTC8NRjeCobVwPDOYHgnGNYAw3uD4b1gWAsMHwyGD4JhHTB8NBg+Cob1wPDJYPgkGDYAw2eD4bNg2AgM/xkM/wmGTcDwRfnQG4INatgMDGEMhjCCYQswhDUYwgqGrcAQzmAIJxi2AUN4gyG8YNgODBEMhgiCYQcwRDQYIgqGncAQyWCIJBh2AUNkgyGyYNgNDFEMhiiCYQ8wRDUYogqGvcAQzWCIJhj2AUN0gyG6YNgPDDEMhhiC4QAwxDQYYgqGg8AQy2CIJRgOAUNsgyG2YDgMDHEMhjiC4QgwxDUY4gqGo8AQz2CIJxiOAUN8gyG+YDgODAkMhgSC4QQwJDQYEgqGk8CQyGBIJBhOAUNigyGxYDgNDEkMhiSC4QwwJDUYkgqGs8CQzGBIJhjOAUNygyG5YDgPDCkMhhSC4QIwpDQYUgqGi8CQymBIJRguAUNqgyG1YLgMDGkMhjSC4QowpDUY0gqGq8CQzmBIJxiuAUN6gyG9YLgODBkMhgyC4QYwZDQYMgqGm8CQyWDIJBhuAUNmgyGzYLgNDFkMhiyC4Q4wZDUYsgqGu8CQzWDIJhjuAUN2gyG7YLgPDDkMhhyC4QEw5DQYcgqGh8CQy2DIJRgeAUNugyG3YHgMDHkMhjyC4Qkw5DUY8gqGp8CQz2DIJxieAUN+gyG/YHgODAUMhgKC4QUwfGkwfCkYXgLDVwbDV4LhFTB8bTB8LRheA8M3BsM3guENMHxrMHwrGN4Cw3cGw3eC4R0wfG8wfC8Y3gPDDwbDD4LhAzD8aDD8KBg+AsNPBsNPguETMPxsMPwsGD4Dwy8Gwy+C4T9g+NVg+FUwfBHzfzf8ZjD8JhjCAMPvBsPvgiEsMPxhMPwhGMIBw58Gw5+CITww/GUw/CUYIgBDQYOhoGCICAx/Gwx/C4ZIwPCPwfCPYIgMDP8aDP8KhijAUMhgKCQYogJDYYOhsGCIBgxFDIYigiE6MBQ1GIoKhhjAUMxgKCYYYgJDcYOhuGCIBQwlDIYSgiE2MJQ0GEoKhjjAUMpgKCUY4gJDaYOhtGCIBwxlDIYygiE+MJQ1GMoKhgTAUM5gKCcYEgJDeYOhvGBIBAwVDIYKgiExMFQ0GCoKhiTAUMlgqCQYkgJDZYOhsmBIBgxVDIYqgiE5MFQ1GKoKhhTAEDAYAoIhJTBUMxiqCYZUwFDdYKguGFIDQw2DoYZgSAMMNQ2GmoIhLTDUMhhqCYZ0wFDbYKgtGNIDQx2DoY5gyAAMdQ2GuoIhIzDUMxjqCYZMwFDfYKgvGDIDQwODoYFgyAIMDQ2GhoIhKzA0MhgaCYZswNDYYGgsGLIDQxODoYlgyAEMTQ2GpoIhJzA0MxiaCYZcwNDcYGguGHIDQwuDoYVgyAMMLQ2GloIhLzC0MhhaCYZ8wNDaYGgtGPIDQxuDoY1gKAAMbQ2GtoLhS2BoZzC0EwxfAUN7g6G9YPgaGDoYDB0EwzfA0NFg6CgYvgWGTgZDJ8HwHTB0Nhg6C4bvgaGLwdBFMPwADF0Nhq6C4Udg6GYwdBMMPwFDd4Ohu2D4GRh6GAw9BMMvwNDTYOgpGH4Fhl4GQy/B8Bsw9DYYeguG34Ghj8HQRzD8AQx9DYa+guFPYOhnMPQTDH8BQ3+Dob9gKAgMAwyGAYLhb2AYaDAMFAz/AMMgg2GQYPgXGAYbDIMFQyFgGGIwDBEMhYFhqMEwVDAUAYZhBsMwwVAUGIYbDMMFQzFgGGEwjBAMxYFhpMEwUjCUAIZRBsMowVASGEYbDKMFQylgGGMwjBEMpYFhrMEwVjCUAYZxBsM4wVAWGMYbDOMFQzlgmGAwTBAM5YFhosEwUTBUAIZJBsMkwVARGCYbDJMFQyVgmGIwTBEMlYFhqsEwVTBUAYZpBsM0wVAVGKYbDNMFQwAYZhgMMwRDNWCYaTDMFAzVgWGWwTBLMNQAhtkGw2zBUBMY5hgMcwRDLWCYazDMFQy1gWGewTBPMNQBhvkGw3zBUBcYFhgMCwRDPWBYaDAsFAz1gWGRwbBIMDQAhsUGw2LB0BAYlhgMSwRDI2BYajAsFQyNgWGZwbBMMDQBhuUGw3LB0BQYVhgMKwRDM2BYaTCsFAzNgWGVwbBKMLQAhtUGw2rB0BIY1hgMawRDK2BYazCsFQytgWGdwbBOMLQBhvUGw3rB0BYYNhgMGwRDO2DYaDBsFAztgWGTwbBJMHQAhs0Gw2bB0BEYthgMWwRDJ2DYajBsFQydgWGbwbBNMHQBhu0Gw3bB0BUYdhgMOwRDN2DYaTDsFAzdgWGXwbBLMPQAht0Gw27B0BMY9hgMewRDL2DYazDsFQy9gWGfwbBPMPQBhv0Gw37B0BcYDhgMBwRDP2A4aDAcFAz9geGQwXBIMAwAhsMGw2HBMBAYjhgMRwTDIGA4ajAcFQyDgeGYwXBMMAwBhuMGw3HBMBQYThgMJwTDMGA4aTCcFAzDgeGUwXBKMIwAhtMGw2nBMBIYzhgMZwTDKGA4azCcFQyjgeGcwXBOMIwBhvMGw3nBMBYYLhgMFwTDOGC4aDBcFAzjgeGSwXBJMEwAhssGw2XBMBEYrhgMVwTDJGC4ajBcFQyTgeGawXBNMEwBhusGw3XBMBUYbhgMNwTDNGC4aTDcFAzTgeGWwXBLMMwAhtsGw23BMBMY7hgMdwTDLGC4azDcFQyzgeGewXBPMMwBhvsGw33BMBcYHhgMDwTDPGB4aDA8FAzzgeGRwfBIMCwAhscGw2PBsBAYnhgMTwTDImB4ajA8FQyLgeGZwfBMMCwBhucGw3PBsBQYXhgMLwTDMmB4aTC8FAzLgeGVwfBKMKwAhtcGw2vBsBIY3hgMbwTDKmB4azC8FQyrgeGdwfBOMKwBhvcGw3vBsBYYPhgMHwTDOmD4aDB8FAzrgeGTwfBJMGwAhs8Gw2fBsBEY/jMY/hMMm4DhiwqhNwQb1LAZGMIYDGEEwxZgCGswhBUMW4EhnMEQTjBsA4bwBkN4wbAdGCIYDBEEww5giGgwRBQMO4EhksEQSTDsAobIBkNkwbAbGKIYDFEEwx5giGowRBUMe4EhmsEQTTDsA4boBkN0wbAfGGIYDDEEwwFgiGkwxBQMB4EhlsEQSzAcAobYBkNswXAYGOIYDHEEwxFgiGswxBUMR4EhnsEQTzAcA4b4BkN8wXAcGBIYDAkEwwlgSGgwJBQMJ4EhkcGQSDCcAobEBkNiwXAaGJIYDEkEwxlgSGowJBUMZ4EhmcGQTDCcA4bkBkNywXAeGFIYDCkEwwVgSGkwpBQMF4EhlcGQSjBcAobUBkNqwXAZGNIYDGkEwxVgSGswpBUMV4EhncGQTjBcA4b0BkN6wXAdGDIYDBkEww1gyGgwZBQMN4Ehk8GQSTDcAobMBkNmwXAbGLIYDFkEwx1gyGowZBUMd4Ehm8GQTTDcA4bsBkN2wXAfGHIYDDkEwwNgyGkw5BQMD4Ehl8GQSzA8AobcBkNuwfAYGPIYDHkEwxNgyGsw5BUMT4Ehn8GQTzA8A4b8BkN+wfAcGAoYDAUEwwtg+NJg+FIwvASGrwyGrwTDK2D42mD4WjC8BoZvDIZvBMMbYPjWYPhWMLwFhu8Mhu8Ewztg+N5g+F4wvAeGHwyGHwTDB2D40WD4UTB8BIafDIafBMMnYPjZYPhZMHwGhl8Mhl8Ew3/A8KvB8Ktg+CLW/274zWD4TTCEAYbfDYbfBUNYYPjDYPhDMIQDhj8Nhj8FQ3hg+Mtg+EswRACGggZDQcEQERj+Nhj+FgyRgOEfg+EfwRAZGP41GP4VDFGAoZDBUEgwRAWGwgZDYcEQDRiKGAxFBEN0YChqMBQVDDGAoZjBUEwwxASG4gZDccEQCxhKGAwlBENsYChpMJQUDHGAoZTBUEowxAWG0gZDacEQDxjKGAxlBEN8YChrMJQVDAmAoZzBUE4wJASG8gZDecGQCBgqGAwVBENiYKhoMFQUDEmAoZLBUEkwJAWGygZDZcGQDBiqGAxVBENyYKhqMFQVDCmAIWAwBARDSmCoZjBUEwypgKG6wVBdMKQGhhoGQw3BkAYYahoMNQVDWmCoZTDUEgzpgKG2wVBbMKQHhjoGQx3BkAEY6hoMdQVDRmCoZzDUEwyZgKG+wVBfMGQGhgYGQwPBkAUYGhoMDQVDVmBoZDA0EgzZgKGxwdBYMGQHhiYGQxPBkAMYmhoMTQVDTmBoZjA0Ewy5gKG5wdBcMOQGhhYGQwvBkAcYWhoMLQVDXmBoZTC0Egz5gKG1wdBaMOQHhjYGQxvBUAAY2hoMbQXDl8DQzmBoJxi+Aob2BkN7wfA1MHQwGDoIhm+AoaPB0FEwfAsMnQyGToLhO2DobDB0FgzfA0MXg6GLYPgBGLoaDF0Fw4/A0M1g6CYYfgKG7gZDd8HwMzD0MBh6CIZfgKGnwdBTMPwKDL0Mhl6C4Tdg6G0w9BYMvwNDH4Ohj2D4Axj6Ggx9BcOfwNDPYOgnGP4Chv4GQ3/BUBAYBhgMAwTD38Aw0GAYKBj+AYZBBsMgwfAvMAw2GAYLhkLAMMRgGCIYCgPDUINhqGAoAgzDDIZhgqEoMAw3GIYLhmLAMMJgGCEYigPDSINhpGAoAQyjDIZRgqEkMIw2GEYLhlLAMMZgGCMYSgPDWINhrGAoAwzjDIZxgqEsMIw3GMYLhnLAMMFgmCAYygPDRINhomCoAAyTDIZJgqEiMEw2GCYLhkrAMMVgmCIYKgPDVINhqmCoAgzTDIZpgqEqMEw3GKYLhgAwzDAYZgiGasAw02CYKRiqA8Msg2GWYKgBDLMNhtmCoSYwzDEY5giGWsAw12CYKxhqA8M8g2GeYKgDDPMNhvmCoS4wLDAYFgiGesCw0GBYKBjqA8Mig2GRYGgADIsNhsWCoSEwLDEYlgiGRsCw1GBYKhgaA8Myg2GZYGgCDMsNhuWCoSkwrDAYVgiGZsCw0mBYKRiaA8Mqg2GVYGgBDKsNhtWCoSUwrDEY1giGVsCw1mBYKxhaA8M6g2GdYGgDDOsNhvWCoS0wbDAYNgiGdsCw0WDYKBjaA8Mmg2GTYOgADJsNhs2CoSMwbDEYtgiGTsCw1WDYKhg6A8M2g2GbYOgCDNsNhu2CoSsw7DAYdgiGbsCw02DYKRi6A8Mug2GXYOgBDLsNht2CoScw7DEY9giGXsCw12DYKxh6A8M+g2GfYOgDDPsNhv2CoS8wHDAYDgiGfsBw0GA4KBj6A8Mhg+GQYBgADIcNhsOCYSAwHDEYjgiGQcBw1GA4KhgGA8Mxg+GYYBgCDMcNhuOCYSgwnDAYTgiGYcBw0mA4KRiGA8Mpg+GUYBgBDKcNhtOCYSQwnDEYzgiGUcBw1mA4KxhGA8M5g+GcYBgDDOcNhvOCYSwwXDAYLgiGccBw0WC4KBjGA8Mlg+GSYJgADJcNhsuCYSIwXDEYrgiGScBw1WC4KhgmA8M1g+GaYJgCDNcNhuuCYSow3DAYbgiGacBw02C4KRimA8Mtg+GWYJgBDLcNhtuCYSYw3DEY7giGWcBw12C4KxhmA8M9g+GeYJgDDPcNhvuCYS4wPDAYHgiGecDw0GB4KBjmA8Mjg+GRYFgADI8NhseCYSEwPDEYngiGRcDw1GB4KhgWA8Mzg+GZYFgCDM8NhueCYSkwvDAYXgiGZcDw0mB4KRiWA8Mrg+GVYFgBDK8NhteCYSUwvDEY3giGVcDw1mB4KxhWA8M7g+GdYFgDDO8NhveCYS0wfDAYPgiGdcDw0WD4KBjWA8Mng+GTYNgADJ8Nhs+CYSMw/Gcw/CcYNgHDFxVDbwg2qGEzMIQxGMIIhi3AENZgCCsYtgJDOIMhnGDYBgzhDYbwgmE7MEQwGCIIhh3AENFgiCgYdgJDJIMhkmDYBQyRDYbIgmE3MEQxGKIIhj3AENVgiCoY9gJDNIMhmmDYBwzRDYbogmE/MMQwGGIIhgPAENNgiCkYDgJDLIMhlmA4BAyxDYbYguEwMMQxGOIIhiPAENdgiCsYjgJDPIMhnmA4BgzxDYb4guE4MCQwGBIIhhPAkNBgSCgYTgJDIoMhkWA4BQyJDYbEguE0MCQxGJIIhjPAkNRgSCoYzgJDMoMhmWA4BwzJDYbkguE8MKQwGFIIhgvAkNJgSCkYLgJDKoMhlWC4BAypDYbUguEyMKQxGNIIhivAkNZgSCsYrgJDOoMhnWC4BgzpDYb0guE6MGQwGDIIhhvAkNFgyCgYbgJDJoMhk2C4BQyZDYbMguE2MGQxGLIIhjvAkNVgyCoY7gJDNoMhm2C4BwzZDYbsguE+MOQwGHIIhgfAkNNgyCkYHgJDLoMhl2B4BAy5DYbcguExMOQxGPIIhifAkNdgyCsYngJDPoMhn2B4Bgz5DYb8guE5MBQwGAoIhhfA8KXB8KVgeAkMXxkMXwmGV8DwtcHwtWB4DQzfGAzfCIY3wPCtwfCtYHgLDN8ZDN8JhnfA8L3B8L1geA8MPxgMPwiGD8Dwo8Hwo2D4CAw/GQw/CYZPwPBziA2f433xxf89ew/X/Rfvfzf8YjiHX4Rz+CL+/2741WD4VTCEAYbfDIbfBENYYPjdYPhdMIQDhj8Mhj8EQ3hg+NNg+FMwRACGvwyGvwRDRGAoaDAUFAyRgOFvg+FvwRAZGP4xGP4RDFGA4V+D4V/BEBUYChkMhQRDNGAobDAUFgzRgaGIwVBEMMQAhqIGQ1HBEBMYihkMxQRDLGAobjAUFwyxgaGEwVBCMMQBhpIGQ0nBEBcYShkMpQRDPGAobTCUFgzxgaGMwVBGMCQAhrIGQ1nBkBAYyhkM5QRDImAobzCUFwyJgaGCwVBBMCQBhooGQ0XBkBQYKhkMlQRDMmCobDBUFgzJgaGKwVBFMKQAhqoGQ1XBkBIYAgZDQDCkAoZqBkM1wZAaGKobDNUFQxpgqGEw1BAMaYGhpsFQUzCkA4ZaBkMtwZAeGGobDLUFQwZgqGMw1BEMGYGhrsFQVzBkAoZ6BkM9wZAZGOobDPUFQxZgaGAwNBAMWYGhocHQUDBkA4ZGBkMjwZAdGBobDI0FQw5gaGIwNBEMOYGhqcHQVDDkAoZmBkMzwZAbGJobDM0FQx5gaGEwtBAMeYGhpcHQUjDkA4ZWBkMrwZAfGFobDK0FQwFgaGMwtBEMXwJDW4OhrWD4ChjaGQztBMPXwNDeYGgvGL4Bhg4GQwfB8C0wdDQYOgqG74Chk8HQSTB8DwydDYbOguEHYOhiMHQRDD8CQ1eDoatg+AkYuhkM3QTDz8DQ3WDoLhh+AYYeBkMPwfArMPQ0GHoKht+AoZfB0Esw/A4MvQ2G3oLhD2DoYzD0EQx/AkNfg6GvYPgLGPoZDP0EQ0Fg6G8w9BcMfwPDAINhgGD4BxgGGgwDBcO/wDDIYBgkGAoBw2CDYbBgKAwMQwyGIYKhCDAMNRiGCoaiwDDMYBgmGIoBw3CDYbhgKA4MIwyGEYKhBDCMNBhGCoaSwDDKYBglGEoBw2iDYbRgKA0MYwyGMYKhDDCMNRjGCoaywDDOYBgnGMoBw3iDYbxgKA8MEwyGCYKhAjBMNBgmCoaKwDDJYJgkGCoBw2SDYbJgqAwMUwyGKYKhCjBMNRimCoaqwDDNYJgmGALAMN1gmC4YqgHDDINhhmCoDgwzDYaZgqEGMMwyGGYJhprAMNtgmC0YagHDHINhjmCoDQxzDYa5gqEOMMwzGOYJhrrAMN9gmC8Y6gHDAoNhgWCoDwwLDYaFgqEBMCwyGBYJhobAsNhgWCwYGgHDEoNhiWBoDAxLDYalgqEJMCwzGJYJhqbAsNxgWC4YmgHDCoNhhWBoDgwrDYaVgqEFMKwyGFYJhpbAsNpgWC0YWgHDGoNhjWBoDQxrDYa1gqENMKwzGNYJhrbAsN5gWC8Y2gHDBoNhg2BoDwwbDYaNgqEDMGwyGDYJho7AsNlg2CwYOgHDFoNhi2DoDAxbDYatgqELMGwzGLYJhq7AsN1g2C4YugHDDoNhh2DoDgw7DYadgqEHMOwyGHYJhp7AsNtg2C0YegHDHoNhj2DoDQx7DYa9gqEPMOwzGPYJhr7AsN9g2C8Y+gHDAYPhgGDoDwwHDYaDgmEAMBwyGA4JhoHAcNhgOCwYBgHDEYPhiGAYDAxHDYajgmEIMBwzGI4JhqHAcNxgOC4YhgHDCYPhhGAYDgwnDYaTgmEEMJwyGE4JhpHAcNpgOC0YRgHDGYPhjGAYDQxnDYazgmEMMJwzGM4JhrHAcN5gOC8YxgHDBYPhgmAYDwwXDYaLgmECMFwyGC4JhonAcNlguCwYJgHDFYPhimCYDAxXDYargmEKMFwzGK4JhqnAcN1guC4YpgHDDYPhhmCYDgw3DYabgmEGMNwyGG4JhpnAcNtguC0YZgHDHYPhjmCYDQx3DYa7gmEOMNwzGO4JhrnAcN9guC8Y5gHDA4PhgWCYDwwPDYaHgmEBMDwyGB4JhoXA8NhgeCwYFgHDE4PhiWBYDAxPDYangmEJMDwzGJ4JhqXA8NxgeC4YlgHDC4PhhWBYDgwvDYaXgmEFMLwyGF4JhpXA8NpgeC0YVgHDG4PhjWBYDQxvDYa3gmENMLwzGN4JhrXA8N5geC8Y1gHDB4Phg2BYDwwfDYaPgmEDMHwyGD4Jho3A8Nlg+CwYNgHDfwbDf4JhMzB8USn0hmCDGrYAQxiDIYxg2AoMYQ2GsIJhGzCEMxjCCYbtwBDeYAgvGHYAQwSDIYJg2AkMEQ2GiIJhFzBEMhgiCYbdwBDZYIgsGPYAQxSDIYpg2AsMUQ2GqIJhHzBEMxiiCYb9wBDdYIguGA4AQwyDIYZgOAgMMQ2GmILhEDDEMhhiCYbDwBDbYIgtGI4AQxyDIY5gOAoMcQ2GuILhGDDEMxjiCYbjwBDfYIgvGE4AQwKDIYFgOAkMCQ2GhILhFDAkMhgSCYbTwJDYYEgsGM4AQxKDIYlgOAsMSQ2GpILhHDAkMxiSCYbzwJDcYEguGC4AQwqDIYVguAgMKQ2GlILhEjCkMhhSCYbLwJDaYEgtGK4AQxqDIY1guAoMaQ2GtILhGjCkMxjSCYbrwJDeYEgvGG4AQwaDIYNguAkMGQ2GjILhFjBkMhgyCYbbwJDZYMgsGO4AQxaDIYtguAsMWQ2GrILhHjBkMxiyCYb7wJDdYMguGB4AQw6DIYdgeAgMOQ2GnILhETDkMhhyCYbHwJDbYMgtGJ4AQx6DIY9geAoMeQ2GvILhGTDkMxjyCYbnwJDfYMgvGF4AQwGDoYBgeAkMXxoMXwqGV8DwlcHwlWB4DQxfGwxfC4Y3wPCNwfCNYHgLDN8aDN8KhnfA8J3B8J1geA8M3xsM3wuGD8Dwg8Hwg2D4CAw/Ggw/CoZPwPCTwfCTYPgMDD8bDD8Lhv+A4ReD4RfB8EWC/93wq8Hwq2AIAwy/GQy/CYawwPC7wfC7YAgHDH8YDH8IhvDA8KfB8KdgiAAMfxkMfwmGiMBQ0GAoKBgiAcPfBsPfgiEyMPxjMPwjGKIAw78Gw7+CISowFDIYCgmGaMBQ2GAoLBiiA0MRg6GIYIgBDEUNhqKCISYwFDMYigmGWMBQ3GAoLhhiA0MJg6GEYIgDDCUNhpKCIS4wlDIYSgmGeMBQ2mAoLRjiA0MZg6GMYEgADGUNhrKCISEwlDMYygmGRMBQ3mAoLxgSA0MFg6GCYEgCDBUNhoqCISkwVDIYKgmGZMBQ2WCoLBiSA0MVg6GKYEgBDFUNhqqCISUwBAyGgGBIBQzVDIZqgiE1MFQ3GKoLhjTAUMNgqCEY0gJDTYOhpmBIBwy1DIZagiE9MNQ2GGoLhgzAUMdgqCMYMgJDXYOhrmDIBAz1DIZ6giEzMNQ3GOoLhizA0MBgaCAYsgJDQ4OhoWDIBgyNDIZGgiE7MDQ2GBoLhhzA0MRgaCIYcgJDU4OhqWDIBQzNDIZmgiE3MDQ3GJoLhjzA0MJgaCEY8gJDS4OhpWDIBwytDIZWgiE/MLQ2GFoLhgLA0MZgaCMYvgSGtgZDW8HwFTC0MxjaCYavgaG9wdBeMHwDDB0Mhg6C4Vtg6GgwdBQM3wFDJ4Ohk2D4Hhg6GwydBcMPwNDFYOgiGH4Ehq4GQ1fB8BMwdDMYugmGn4Ghu8HQXTD8Agw9DIYeguFXYOhpMPQUDL8BQy+DoZdg+B0YehsMvQXDH8DQx2DoIxj+BIa+BkNfwfAXMPQzGPoJhoLA0N9g6C8Y/gaGAQbDAMHwDzAMNBgGCoZ/gWGQwTBIMBQChsEGw2DBUBgYhhgMQwRDEWAYajAMFQxFgWGYwTBMMBQDhuEGw3DBUBwYRhgMIwRDCWAYaTCMFAwlgWGUwTBKMJQChtEGw2jBUBoYxhgMYwRDGWAYazCMFQxlgWGcwTBOMJQDhvEGw3jBUB4YJhgMEwRDBWCYaDBMFAwVgWGSwTBJMFQChskGw2TBUBkYphgMUwRDFWCYajBMFQxVgWGawTBNMASAYbrBMF0wVAOGGQbDDMFQHRhmGgwzBUMNYJhlMMwSDDWBYbbBMFsw1AKGOQbDHMFQGxjmGgxzBUMdYJhnMMwTDHWBYb7BMF8w1AOGBQbDAsFQHxgWGgwLBUMDYFhkMCwSDA2BYbHBsFgwNAKGJQbDEsHQGBiWGgxLBUMTYFhmMCwTDE2BYbnBsFwwNAOGFQbDCsHQHBhWGgwrBUMLYFhlMKwSDC2BYbXBsFowtAKGNQbDGsHQGhjWGgxrBUMbYFhnMKwTDG2BYb3BsF4wtAOGDQbDBsHQHhg2GgwbBUMHYNhkMGwSDB2BYbPBsFkwdAKGLQbDFsHQGRi2GgxbBUMXYNhmMGwTDF2BYbvBsF0wdAOGHQbDDsHQHRh2Ggw7BUMPYNhlMOwSDD2BYbfBsFsw9AKGPQbDHsHQGxj2Ggx7BUMfYNhnMOwTDH2BYb/BsF8w9AOGAwbDAcHQHxgOGgwHBcMAYDhkMBwSDAOB4bDBcFgwDAKGIwbDEcEwGBiOGgxHBcMQYDhmMBwTDEOB4bjBcFwwDAOGEwbDCcEwHBhOGgwnBcMIYDhlMJwSDCOB4bTBcFowjAKGMwbDGcEwGhjOGgxnBcMYYDhnMJwTDGOB4bzBcF4wjAOGCwbDBcEwHhguGgwXBcMEYLhkMFwSDBOB4bLBcFkwTAKGKwbDFcEwGRiuGgxXBcMUYLhmMFwTDFOB4brBcF0wTAOGGwbDDcEwHRhuGgw3BcMMYLhlMNwSDDOB4bbBcFswzAKGOwbDHcEwGxjuGgx3BcMcYLhnMNwTDHOB4b7BcF8wzAOGBwbDA8EwHxgeGgwPBcMCYHhkMDwSDAuB4bHB8FgwLAKGJwbDE8GwGBieGgxPBcMSYHhmMDwTDEuB4bnB8FwwLAOGFwbDC8GwHBheGgwvBcMKYHhlMLwSDCuB4bXB8FowrAKGNwbDG8GwGhjeGgxvBcMaYHhnMLwTDGuB4b3B8F4wrAOGDwbDB8GwHhg+GgwfBcMGYPhkMHwSDBuB4bPB8FkwbAKG/wyG/wTDZmD4onLoDcEGNWwBhjAGQxjBsBUYwhoMYQXDNmAIZzCEEwzbgSG8wRBeMOwAhggGQwTBsBMYIhoMEQXDLmCIZDBEEgy7gSGywRBZMOwBhigGQxTBsBcYohoMUQXDPmCIZjBEEwz7gSG6wRBdMBwAhhgGQwzBcBAYYhoMMQXDIWCIZTDEEgyHgSG2wRBbMBwBhjgGQxzBcBQY4hoMcQXDMWCIZzDEEwzHgSG+wRBfMJwAhgQGQwLBcBIYEhoMCQXDKWBIZDAkEgyngSGxwZBYMJwBhiQGQxLBcBYYkhoMSQXDOWBIZjAkEwzngSG5wZBcMFwAhhQGQwrBcBEYUhoMKQXDJWBIZTCkEgyXgSG1wZBaMFwBhjQGQxrBcBUY0hoMaQXDNWBIZzCkEwzXgSG9wZBeMNwAhgwGQwbBcBMYMhoMGQXDLWDIZDBkEgy3gSGzwZBZMNwBhiwGQxbBcBcYshoMWQXDPWDIZjBkEwz3gSG7wZBdMDwAhhwGQw7B8BAYchoMOQXDI2DIZTDkEgyPgSG3wZBbMDwBhjwGQx7B8BQY8hoMeQXDM2DIZzDkEwzPgSG/wZBfMLwAhgIGQwHB8BIYvjQYvhQMr4DhK4PhK8HwGhi+Nhi+FgxvgOEbg+EbwfAWGL41GL4VDO+A4TuD4TvB8B4YvjcYvhcMH4DhhxAbPib64ov/e14arvuU6H83/Gg4hx+Fc/gMDD8ZDD8Jhv+A4WeD4WfB8EXi/93wi8Hwi2AIAwy/Ggy/CoawwPCbwfCbYAgHDL8bDL8LhvDA8IfB8IdgiAAMfxoMfwqGiMDwl8Hwl2CIBAwFDYaCgiEyMPxtMPwtGKIAwz8Gwz+CISow/Gsw/CsYogFDIYOhkGCIDgyFDYbCgiEGMBQxGIoIhpjAUNRgKCoYYgFDMYOhmGCIDQzFDYbigiEOMJQwGEoIhrjAUNJgKCkY4gFDKYOhlGCIDwylDYbSgiEBMJQxGMoIhoTAUNZgKCsYEgFDOYOhnGBIDAzlDYbygiEJMFQwGCoIhqTAUNFgqCgYkgFDJYOhkmBIDgyVDYbKgiEFMFQxGKoIhpTAUNVgqCoYUgFDwGAICIbUwFDNYKgmGNIAQ3WDobpgSAsMNQyGGoIhHTDUNBhqCob0wFDLYKglGDIAQ22DobZgyAgMdQyGOoIhEzDUNRjqCobMwFDPYKgnGLIAQ32Dob5gyAoMDQyGBoIhGzA0NBgaCobswNDIYGgkGHIAQ2ODobFgyAkMTQyGJoIhFzA0NRiaCobcwNDMYGgmGPIAQ3ODoblgyAsMLQyGFoIhHzC0NBhaCob8wNDKYGglGAoAQ2uDobVg+BIY2hgMbQTDV8DQ1mBoKxi+BoZ2BkM7wfANMLQ3GNoLhm+BoYPB0EEwfAcMHQ2GjoLhe2DoZDB0Egw/AENng6GzYPgRGLoYDF0Ew0/A0NVg6CoYfgaGbgZDN8HwCzB0Nxi6C4ZfgaGHwdBDMPwGDD0Nhp6C4Xdg6GUw9BIMfwBDb4Oht2D4Exj6GAx9BMNfwNDXYOgrGAoCQz+DoZ9g+BsY+hsM/QXDP8AwwGAYIBj+BYaBBsNAwVAIGAYZDIMEQ2FgGGwwDBYMRYBhiMEwRDAUBYahBsNQwVAMGIYZDMMEQ3FgGG4wDBcMJYBhhMEwQjCUBIaRBsNIwVAKGEYZDKMEQ2lgGG0wjBYMZYBhjMEwRjCUBYaxBsNYwVAOGMYZDOMEQ3lgGG8wjBcMFYBhgsEwQTBUBIaJBsNEwVAJGCYZDJMEQ2VgmGwwTBYMVYBhisEwRTBUBYapBsNUwRAAhmkGwzTBUA0YphsM0wVDdWCYYTDMEAw1gGGmwTBTMNQEhlkGwyzBUAsYZhsMswVDbWCYYzDMEQx1gGGuwTBXMNQFhnkGwzzBUA8Y5hsM8wVDfWBYYDAsEAwNgGGhwbBQMDQEhkUGwyLB0AgYFhsMiwVDY2BYYjAsEQxNgGGpwbBUMDQFhmUGwzLB0AwYlhsMywVDc2BYYTCsEAwtgGGlwbBSMLQEhlUGwyrB0AoYVhsMqwVDa2BYYzCsEQxtgGGtwbBWMLQFhnUGwzrB0A4Y1hsM6wVDe2DYYDBsEAwdgGGjwbBRMHQEhk0GwybB0AkYNhsMmwVDZ2DYYjBsEQxdgGGrwbBVMHQFhm0GwzbB0A0YthsM2wVDd2DYYTDsEAw9gGGnwbBTMPQEhl0Gwy7B0AsYdhsMuwVDb2DYYzDsEQx9gGGvwbBXMPQFhn0Gwz7B0A8Y9hsM+wVDf2A4YDAcEAwDgOGgwXBQMAwEhkMGwyHBMAgYDhsMhwXDYGA4YjAcEQxDgOGowXBUMAwFhmMGwzHBMAwYjhsMxwXDcGA4YTCcEAwjgOGkwXBSMIwEhlMGwynBMAoYThsMpwXDaGA4YzCcEQxjgOGswXBWMIwFhnMGwznBMA4YzhsM5wXDeGC4YDBcEAwTgOGiwXBRMEwEhksGwyXBMAkYLhsMlwXDZGC4YjBcEQxTgOGqwXBVMEwFhmsGwzXBMA0YrhsM1wXDdGC4YTDcEAwzgOGmwXBTMMwEhlsGwy3BMAsYbhsMtwXDbGC4YzDcEQxzgOGuwXBXMMwFhnsGwz3BMA8Y7hsM9wXDfGB4YDA8EAwLgOGhwfBQMCwEhkcGwyPBsAgYHhsMjwXDYmB4YjA8EQxLgOGpwfBUMCwFhmcGwzPBsAwYnhsMzwXDcmB4YTC8EAwrgOGlwfBSMKwEhlcGwyvBsAoYXhsMrwXDamB4YzC8EQxrgOGtwfBWMKwFhncGwzvBsA4Y3hsM7wXDemD4YDB8EAwbgOGjwfBRMGwEhk8GwyfBsAkYPhsMnwXDZmD4z2D4TzBsAYYvqoTeEGxQw1ZgCGMwhBEM24AhrMEQVjBsB4ZwBkM4wbADGMIbDOEFw05giGAwRBAMu4AhosEQUTDsBoZIBkMkwbAHGCIbDJEFw15giGIwRBEM+4AhqsEQVTDsB4ZoBkM0wXAAGKIbDNEFw0FgiGEwxBAMh4AhpsEQUzAcBoZYBkMswXAEGGIbDLEFw1FgiGMwxBEMx4AhrsEQVzAcB4Z4BkM8wXACGOIbDPEFw0lgSGAwJBAMp4AhocGQUDCcBoZEBkMiwXAGGBIbDIkFw1lgSGIwJBEM54AhqcGQVDCcB4ZkBkMywXABGJIbDMkFw0VgSGEwpBAMl4AhpcGQUjBcBoZUBkMqwXAFGFIbDKkFw1VgSGMwpBEM14AhrcGQVjBcB4Z0BkM6wXADGNIbDOkFw01gyGAwZBAMt4Aho8GQUTDcBoZMBkMmwXAHGDIbDJkFw11gyGIwZBEM94Ahq8GQVTDcB4ZsBkM2wfAAGLIbDNkFw0NgyGEw5BAMj4Ahp8GQUzA8BoZcBkMuwfAEGHIbDLkFw1NgyGMw5BEMz4Ahr8GQVzA8B4Z8BkM+wfACGPIbDPkFw0tgKGAwFBAMr4DhS4PhS8HwGhi+Mhi+EgxvgOFrg+FrwfAWGL4xGL4RDO+A4VuD4VvB8B4YvjMYvhMMH4Dhe4Phe8HwERh+MBh+EAyfgOFHg+FHwfAZGH4yGH4SDP8Bw88Gw8+C4Ysk/7vhF4PhF8EQBhh+NRh+FQxhgeE3g+E3wRAOGH43GH4XDOGB4Q+D4Q/BEAEY/jQY/hQMEYHhL4PhL8EQCRgKGgwFBUNkYPjbYPhbMEQBhn8Mhn8EQ1Rg+Ndg+FcwRAOGQgZDIcEQHRgKGwyFBUMMYChiMBQRDDGBoajBUFQwxAKGYgZDMcEQGxiKGwzFBUMcYChhMJQQDHGBoaTBUFIwxAOGUgZDKcEQHxhKGwylBUMCYChjMJQRDAmBoazBUFYwJAKGcgZDOcGQGBjKGwzlBUMSYKhgMFQQDEmBoaLBUFEwJAOGSgZDJcGQHBgqGwyVBUMKYKhiMFQRDCmBoarBUFUwpAKGgMEQEAypgaGawVBNMKQBhuoGQ3XBkBYYahgMNQRDOmCoaTDUFAzpgaGWwVBLMGQAhtoGQ23BkBEY6hgMdQRDJmCoazDUFQyZgaGewVBPMGQBhvoGQ33BkBUYGhgMDQRDNmBoaDA0FAzZgaGRwdBIMOQAhsYGQ2PBkBMYmhgMTQRDLmBoajA0FQy5gaGZwdBMMOQBhuYGQ3PBkBcYWhgMLQRDPmBoaTC0FAz5gaGVwdBKMBQAhtYGQ2vB8CUwtDEY2giGr4ChrcHQVjB8DQztDIZ2guEbYGhvMLQXDN8CQweDoYNg+A4YOhoMHQXD98DQyWDoJBh+AIbOBkNnwfAjMHQxGLoIhp+AoavB0FUw/AwM3QyGboLhF2DobjB0Fwy/AkMPg6GHYPgNGHoaDD0Fw+/A0Mtg6CUY/gCG3gZDb8HwJzD0MRj6CIa/gKGvwdBXMBQEhn4GQz/B8Dcw9DcY+guGf4BhgMEwQDD8CwwDDYaBgqEQMAwyGAYJhsLAMNhgGCwYigDDEINhiGAoCgxDDYahgqEYMAwzGIYJhuLAMNxgGC4YSgDDCINhhGAoCQwjDYaRgqEUMIwyGEYJhtLAMNpgGC0YygDDGINhjGAoCwxjDYaxgqEcMIwzGMYJhvLAMN5gGC8YKgDDBINhgmCoCAwTDYaJgqESMEwyGCYJhsrAMNlgmCwYqgDDFINhimCoCgxTDYapgiEADNMMhmmCoRowTDcYpguG6sAww2CYIRhqAMNMg2GmYKgJDLMMhlmCoRYwzDYYZguG2sAwx2CYIxjqAMNcg2GuYKgLDPMMhnmCoR4wzDcY5guG+sCwwGBYIBgaAMNCg2GhYGgIDIsMhkWCoREwLDYYFguGxsCwxGBYIhiaAMNSg2GpYGgKDMsMhmWCoRkwLDcYlguG5sCwwmBYIRhaAMNKg2GlYGgJDKsMhlWCoRUwrDYYVguG1sCwxmBYIxjaAMNag2GtYGgLDOsMhnWCoR0wrDcY1guG9sCwwWDYIBg6AMNGg2GjYOgIDJsMhk2CoRMwbDYYNguGzsCwxWDYIhi6AMNWg2GrYOgKDNsMhm2CoRswbDcYtguG7sCww2DYIRh6AMNOg2GnYOgJDLsMhl2CoRcw7DYYdguG3sCwx2DYIxj6AMNeg2GvYOgLDPsMhn2CoR8w7DcY9guG/sBwwGA4IBgGAMNBg+GgYBgIDIcMhkOCYRAwHDYYDguGwcBwxGA4IhiGAMNRg+GoYBgKDMcMhmOCYRgwHDcYjguG4cBwwmA4IRhGAMNJg+GkYBgJDKcMhlOCYRQwnDYYTguG0cBwxmA4IxjGAMNZg+GsYBgLDOcMhnOCYRwwnDcYzguG8cBwwWC4IBgmAMNFg+GiYJgIDJcMhkuCYRIwXDYYLguGycBwxWC4IhimAMNVg+GqYJgKDNcMhmuCYRowXDcYrguG6cBww2C4IRhmAMNNg+GmYJgJDLcMhluCYRYw3DYYbguG2cBwx2C4IxjmAMNdg+GuYJgLDPcMhnuCYR4w3DcY7guG+cDwwGB4IBgWAMNDg+GhYFgIDI8MhkeCYREwPDYYHguGxcDwxGB4IhiWAMNTg+GpYFgKDM8MhmeCYRkwPDcYnguG5cDwwmB4IRhWAMNLg+GlYFgJDK8MhleCYRUwvDYYXguG1cDwxmB4IxjWAMNbg+GtYFgLDO8MhneCYR0wvDcY3guG9cDwwWD4IBg2AMNHg+GjYNgIDJ8Mhk+CYRMwfDYYPguGzcDwn8Hwn2DYAgxfVA29Idighq3AEMZgCCMYtgFDWIMhrGDYDgzhDIZwgmEHMIQ3GMILhp3AEMFgiCAYdgFDRIMhomDYDQyRDIZIgmEPMEQ2GCILhr3AEMVgiCIY9gFDVIMhqmDYDwzRDIZoguEAMEQ3GKILhoPAEMNgiCEYDgFDTIMhpmA4DAyxDIZYguEIMMQ2GGILhqPAEMdgiCMYjgFDXIMhrmA4DgzxDIZ4guEEMMQ3GOILhpPAkMBgSCAYTgFDQoMhoWA4DQyJDIZEguEMMCQ2GBILhrPAkMRgSCIYzgFDUoMhqWA4DwzJDIZkguECMCQ3GJILhovAkMJgSCEYLgFDSoMhpWC4DAypDIZUguEKMKQ2GFILhqvAkMZgSCMYrgFDWoMhrWC4DgzpDIZ0guEGMKQ3GNILhpvAkMFgyCAYbgFDRoMho2C4DQyZDIZMguEOMGQ2GDILhrvAkMVgyCIY7gFDVoMhq2C4DwzZDIZsguEBMGQ3GLILhofAkMNgyCEYHgFDToMhp2B4DAy5DIZcguEJMOQ2GHILhqfAkMdgyCMYngFDXoMhr2B4Dgz5DIZ8guEFMOQ3GPILhpfAUMBgKCAYXgHDlwbDl4LhNTB8ZTB8JRjeAMPXBsPXguEtMHxjMHwjGN4Bw7cGw7eC4T0wfBdiw8dkX3zxf8/pwnWfkv3vhu8N5/C9cA6fgeEHg+EHwfAfMPxoMPwoGL5I/r8bfjIYfhIMYYDhZ4PhZ8EQFhh+MRh+EQzhgOFXg+FXwRAeGH4zGH4TDBGA4XeD4XfBEBEY/jAY/hAMkYDhT4PhT8EQGRj+Mhj+EgxRgKGgwVBQMEQFhr8Nhr8FQzRg+Mdg+EcwRAeGfw2GfwVDDGAoZDAUEgwxgaGwwVBYMMQChiIGQxHBEBsYihoMRQVDHGAoZjAUEwxxgaG4wVBcMMQDhhIGQwnBEB8YShoMJQVDAmAoZTCUEgwJgaG0wVBaMCQChjIGQxnBkBgYyhoMZQVDEmAoZzCUEwxJgaG8wVBeMCQDhgoGQwXBkBwYKhoMFQVDCmCoZDBUEgwpgaGywVBZMKQChioGQxXBkBoYqhoMVQVDGmAIGAwBwZAWGKoZDNUEQzpgqG4wVBcM6YGhhsFQQzBkAIaaBkNNwZARGGoZDLUEQyZgqG0w1BYMmYGhjsFQRzBkAYa6BkNdwZAVGOoZDPUEQzZgqG8w1BcM2YGhgcHQQDDkAIaGBkNDwZATGBoZDI0EQy5gaGwwNBYMuYGhicHQRDDkAYamBkNTwZAXGJoZDM0EQz5gaG4wNBcM+YGhhcHQQjAUAIaWBkNLwfAlMLQyGFoJhq+AobXB0FowfA0MbQyGNoLhG2BoazC0FQzfAkM7g6GdYPgOGNobDO0Fw/fA0MFg6CAYfgCGjgZDR8HwIzB0Mhg6CYafgKGzwdBZMPwMDF0Mhi6C4Rdg6GowdBUMvwJDN4Ohm2D4DRi6GwzdBcPvwNDDYOghGP4Ahp4GQ0/B8Ccw9DIYegmGv4Cht8HQWzAUBIY+BkMfwfA3MPQ1GPoKhn+AoZ/B0E8w/AsM/Q2G/oKhEDAMMBgGCIbCwDDQYBgoGIoAwyCDYZBgKAoMgw2GwYKhGDAMMRiGCIbiwDDUYBgqGEoAwzCDYZhgKAkMww2G4YKhFDCMMBhGCIbSwDDSYBgpGMoAwyiDYZRgKAsMow2G0YKhHDCMMRjGCIbywDDWYBgrGCoAwziDYZxgqAgM4w2G8YKhEjBMMBgmCIbKwDDRYJgoGKoAwySDYZJgqAoMkw2GyYIhAAxTDIYpgqEaMEw1GKYKhurAMM1gmCYYagDDdINhumCoCQwzDIYZgqEWMMw0GGYKhtrAMMtgmCUY6gDDbINhtmCoCwxzDIY5gqEeMMw1GOYKhvrAMM9gmCcYGgDDfINhvmBoCAwLDIYFgqERMCw0GBYKhsbAsMhgWCQYmgDDYoNhsWBoCgxLDIYlgqEZMCw1GJYKhubAsMxgWCYYWgDDcoNhuWBoCQwrDIYVgqEVMKw0GFYKhtbAsMpgWCUY2gDDaoNhtWBoCwxrDIY1gqEdMKw1GNYKhvbAsM5gWCcYOgDDeoNhvWDoCAwbDIYNgqETMGw0GDYKhs7AsMlg2CQYugDDZoNhs2DoCgxbDIYtgqEbMGw1GLYKhu7AsM1g2CYYegDDdoNhu2DoCQw7DIYdgqEXMOw0GHYKht7AsMtg2CUY+gDDboNht2DoCwx7DIY9gqEfMOw1GPYKhv7AsM9g2CcYBgDDfoNhv2AYCAwHDIYDgmEQMBw0GA4KhsHAcMhgOCQYhgDDYYPhsGAYCgxHDIYjgmEYMBw1GI4KhuHAcMxgOCYYRgDDcYPhuGAYCQwnDIYTgmEUMJw0GE4KhtHAcMpgOCUYxgDDaYPhtGAYCwxnDIYzgmEcMJw1GM4KhvHAcM5gOCcYJgDDeYPhvGCYCAwXDIYLgmESMFw0GC4KhsnAcMlguCQYpgDDZYPhsmCYCgxXDIYrgmEaMFw1GK4KhunAcM1guCYYZgDDdYPhumCYCQw3DIYbgmEWMNw0GG4KhtnAcMtguCUY5gDDbYPhtmCYCwx3DIY7gmEeMNw1GO4KhvnAcM9guCcYFgDDfYPhvmBYCAwPDIYHgmERMDw0GB4KhsXA8MhgeCQYlgDDY4PhsWBYCgxPDIYngmEZMDw1GJ4KhuXA8MxgeCYYVgDDc4PhuWBYCQwvDIYXgmEVMLw0GF4KhtXA8MpgeCUY1gDDa4PhtWBYCwxvDIY3gmEdMLw1GN4KhvXA8M5geCcYNgDDe4PhvWDYCAwfDIYPgmETMHw0GD4Khs3A8Mlg+CQYtgDDZ4Phs2DYCgz/GQz/CYZtwPBFIPSGYIMatgNDmEDoDcEGNewAhrCB0BuCDWrYCQzhAqE3BBvUsAsYwgdCbwg2qGE3MEQIhN4QbFDDHmCIGAi9Idighr3AECkQekOwQQ37gCFyIPSGYIMa9gNDlEDoDcEGNRwAhqiB0BuCDWo4CAzRAqE3BBvUcAgYogdCbwg2qOEwMMQIhN4QbFDDEWCIGQi9IdighqPAECsQekOwQQ3HgCF2IPSGYIMajgNDnEDoDcEGNZwAhriB0BuCDWo4CQzxAqE3BBvUcAoY4gdCbwg2qOE0MCQIhN4QbFDDGWBIGAi9IdighrPAkCgQekOwQQ3ngCFxIPSGYIMazgNDkkDoDcEGNVwAhqSB0BuCDWq4CAzJAqE3BBvUcAkYkgdCbwg2qOEyMKQIhN4QbFDDFWBIGQi9IdighqvAkCoQekOwQQ3XgCF1IPSGYIMargNDmkDoDcEGNdwAhrSB0BuCDWq4CQzpAqE3BBvUcAsY0gdCbwg2qOE2MGQIhN4QbFDDHWDIGAi9IdighrvAkCkQekOwQQ33gCFzIPSGYIMa7gNDlkDoDcEGNTwAhqyB0BuCDWp4CAzZAqE3BBvU8AgYsgdCbwg2qOExMOQIhN4QbFDDE2DIGQi9IdighqfAkCsQekOwQQ3PgCF3IPSGYIMangNDnkDoDcEGNbwAhryB0BuCDWp4CQz5AqE3BBvU8AoY8gdCbwg2qOE1MBQIhN4QbFDDG2D4MhB6Q7BBDW+B4atA6A3BBjW8A4avA6E3BBvU8B4YvgmE3hBsUMMHYPg2EHpDsEENH4Hhu0DoDcEGNXwChu8DoTcEG9TwGRh+CITeEGxQw3/A8GMg9IZggxq+SPG/G34KhN4QbFBDGGD4ORB6Q7BBDWGB4ZdA6A3BBjWEA4ZfA6E3BBvUEB4YfguE3hBsUEMEYPg9EHpDsEENEYHhj0DoDcEGNUQChj8DoTcEG9QQGRj+CoTeEGxQQxRgKBgIvSHYoIaowPB3IPSGYIMaogHDP4HQG4INaogODP8GQm8INqghBjAUCoTeEGxQQ0xgKBwIvSHYoIZYwFAkEHpDsEENsYGhaCD0hmCDGuIAQ7FA6A3BBjXEBYbigdAbgg1qiAcMJQKhNwQb1BAfGEoGQm8INqghATCUCoTeEGxQQ0JgKB0IvSHYoIZEwFAmEHpDsEENiYGhbCD0hmCDGpIAQ7lA6A3BBjUkBYbygdAbgg1qSAYMFQKhNwQb1JAcGCoGQm8INqghBTBUCoTeEGxQQ0pgqBwIvSHYoIZUwFAlEHpDsEENqYGhaiD0hmCDGtIAQyAQekOwQQ1pgaFaIPSGYIMa0gFD9UDoDcEGNaQHhhqB0BuCDWrIAAw1A6E3BBvUkBEYagVCbwg2qCETMNQOhN4QbFBDZmCoEwi9IdighizAUDcQekOwQQ1ZgaFeIPSGYIMasgFD/UDoDcEGNWQHhgaB0BuCDWrIAQwNA6E3BBvUkBMYGgVCbwg2qCEXMDQOhN4QbFBDbmBoEgi9IdighjzA0DQQekOwQQ15gaFZIPSGYIMa8gFD80DoDcEGNeQHhhaB0BuCDWooAAwtA6E3BBvU8CUwtAqE3hBsUMNXwNA6EHpDsEENXwNDm0DoDcEGNXwDDG0DoTcEG9TwLTC0C4TeEGxQw3fA0D4QekOwQQ3fA0OHQOgNwQY1/AAMHQOhNwQb1PAjMHQKhN4QbFDDT8DQORB6Q7BBDT8DQ5dA6A3BBjX8AgxdA6E3BBvU8CswdAuE3hBsUMNvwNA9EHpDsEENvwNDj0DoDcEGNfwBDD0DoTcEG9TwJzD0CoTeEGxQw1/A0DsQekOwQQ0FgaFPIPSGYIMa/gaGvoHQG4INavgHGPoFQm8INqjhX2DoHwi9IdighkLAMCAQekOwQQ2FgWFgIPSGYIMaigDDoEDoDcEGNRQFhsGB0BuCDWooBgxDAqE3BBvUUBwYhgZCbwg2qKEEMAwLhN4QbFBDSWAYHgi9IdighlLAMCIQekOwQQ2lgWFkIPSGYIMaygDDqEDoDcEGNZQFhtGB0BuCDWooBwxjAqE3BBvUUB4YxgZCbwg2qKECMIwLhN4QbFBDRWAYHwi9IdighkrAMCEQekOwQQ2VgWFiIPSGYIMaqgDDpEDoDcEGNVQFhsmB0BuCDWoIAMOUQOgNwQY1VAOGqYHQG4INaqgODNMCoTcEG9RQAximB0JvCDaooSYwzAiE3hBsUEMtYJgZCL0h2KCG2sAwKxB6Q7BBDXWAYXYg9IZggxrqAsOcQOgNwQY11AOGuYHQG4INaqgPDPMCoTcEG9TQABjmB0JvCDaooSEwLAiE3hBsUEMjYFgYCL0h2KCGxsCwKBB6Q7BBDU2AYXEg9IZggxqaAsOSQOgNwQY1NAOGpYHQG4INamgODMsCoTcEG9TQAhiWB0JvCDaooSUwrAiE3hBsUEMrYFgZCL0h2KCG1sCwKhB6Q7BBDW2AYXUg9IZggxraAsOaQOgNwQY1tAOGtYHQG4INamgPDOsCoTcEG9TQARjWB0JvCDaooSMwbAiE3hBsUEMnYNgYCL0h2KCGzsCwKRB6Q7BBDV2AYXMg9IZggxq6AsOWQOgNwQY1dAOGrYHQG4INaugODNsCoTcEG9TQAxi2B0JvCDaooScw7AiE3hBsUEMvYNgZCL0h2KCG3sCwKxB6Q7BBDX2AYXcg9IZggxr6AsOeQOgNwQY19AOGvYHQG4INaugPDPsCoTcEG9QwABj2B0JvCDaoYSAwHAiE3hBsUMMgYDgYCL0h2KCGwcBwKBB6Q7BBDUOA4XAg9IZggxqGAsORQOgNwQY1DAOGo4HQG4INahgODMcCoTcEG9QwAhiOB0JvCDaoYSQwnAiE3hBsUMMoYDgZCL0h2KCG0cBwKhB6Q7BBDWOA4XQg9IZggxrGAsOZQOgNwQY1jAOGs4HQG4INahgPDOcCoTcEG9QwARjOB0JvCDaoYSIwXAiE3hBsUMMkYLgYCL0h2KCGycBwKRB6Q7BBDVOA4XIg9IZggxqmAsOVQOgNwQY1TAOGq4HQG4INapgODNcCoTcEG9QwAxiuB0JvCDaoYSYw3AiE3hBsUMMsYLgZCL0h2KCG2cBwKxB6Q7BBDXOA4XYg9IZggxrmAsOdQOgNwQY1zAOGu4HQG4INapgPDPcCoTcEG9SwABjuB0JvCDaoYSEwPAiE3hBsUMMiYHgYCL0h2KCGxcDwKBB6Q7BBDUuA4XEg9IZggxqWAsOTQOgNwQY1LAOGp4HQG4INalgODM8CoTcEG9SwAhieB0JvCDaoYSUwvAiE3hBsUMMqYHgZCL0h2KCG1cDwKhB6Q7BBDWuA4XUg9IZggxrWAsObQOgNwQY1rAOGt4HQG4INalgPDO8CoTcEG9SwARjeB0JvCDaoYSMwfAiE3hBsUMMmYPgYCL0h2KCGzcDwKRB6Q7BBDVuA4XMg9IZggxq2AsN/gdAbgg1q2AYMX1QLvSHYoIbtwBDGYAgjGHYAQ1iDIaxg2AkM4QyGcIJhFzCENxjCC4bdwBDBYIggGPYAQ0SDIaJg2AsMkQyGSIJhHzBENhgiC4b9wBDFYIgiGA4AQ1SDIapgOAgM0QyGaILhEDBENxiiC4bDwBDDYIghGI4AQ0yDIaZgOAoMsQyGWILhGDDENhhiC4bjwBDHYIgjGE4AQ1yDIa5gOAkM8QyGeILhFDDENxjiC4bTwJDAYEggGM4AQ0KDIaFgOAsMiQyGRILhHDAkNhgSC4bzwJDEYEgiGC4AQ1KDIalguAgMyQyGZILhEjAkNxiSC4bLwJDCYEghGK4AQ0qDIaVguAoMqQyGVILhGjCkNhhSC4brwJDGYEgjGG4AQ1qDIa1guAkM6QyGdILhFjCkNxjSC4bbwJDBYMggGO4AQ0aDIaNguAsMmQyGTILhHjBkNhgyC4b7wJDFYMgiGB4AQ1aDIatgeAgM2QyGbILhETBkNxiyC4bHwJDDYMghGJ4AQ06DIadgeAoMuQyGXILhGTDkNhhyC4bnwJDHYMgjGF4AQ16DIa9geAkM+QyGfILhFTDkNxjyC4bXwFDAYCggGN4Aw5cGw5eC4S0wfGUwfCUY3gHD1wbD14LhPTB8YzD83zOu/1/r/p/m+jbEcwX3D/7Rub4L8VzB/b8T5vo+xHMF9/9emOuHEM8V3P8HYa4fQzxXcP8fhbl+CvFcwf1/Eub6OcRzBff/WZjrl/8/5/p/2v//7l8l/3/vwf+P72+E+d8/+6vhHvxbWf5/5L9I/7vhN4Phh8rc8DHB/274PcSG4G/1F+E3/sf/Ptf/bR0B7h/8bv8o/T99vsfTMKn/7/M/V2Rn911Vdj38f/6e/pdzC35H4aD7vwj/u/lzrP/d+yEJ+x3Re8v/+56U+n/b/v++/2+q/f93D/t/anxIEdprJzh8weL8+g8T9n/3/hni6z84/5/VuCEsMPxlMPwlGMIBQ0GDoaBgCA8MfxsMfwuGCMDwj8Hwj2CICAz/Ggz/CoZIwFDIYCgkGCIDQ2GDobBgiAIMRQyGIoIhKjAUNRiKCoZowFDMYCgmGKIDQ3GDobhgiAEMJQyGEoIhJjCUNBhKCoZYwFDKYCglGGIDQ2mDobRgiAMMZQyGMoIhLjCUNRjKCoZ4wFDOYCgnGOIDQ3mDobxgSAAMFQyGCoIhITBUNBgqCoZEwFDJYKgkGBIDQ2WDobJgSAIMVQyGKoIhKTBUNRiqCoZkwBAwGAKCITkwVDMYqgmGFMBQ3WCoLhhSAkMNg6GGYEgFDDUNhpqCITUw1DIYagmGNMBQ22CoLRjSAkMdg6GOYEgHDHUNhrqCIT0w1DMY6gmGDMBQ32CoLxgyAkMDg6GBYMgEDA0NhoaCITMwNDIYGgmGLMDQ2GBoLBiyAkMTg6GJYMgGDE0NhqaCITswNDMYmgmGHMDQ3GBoLhhyAkMLg6GFYMgFDC0NhpaCITcwtDIYWgmGPMDQ2mBoLRjyAkMbg6GNYMgHDG0NhraCIT8wtDMY2gmGAsDQ3mBoLxi+BIYOBkMHwfAVMHQ0GDoKhq+BoZPB0EkwfAMMnQ2GzoLhW2DoYjB0EQzfAUNXg6GrYPgeGLoZDN0Eww/A0N1g6C4YfgSGHgZDD8HwEzD0NBh6CoafgaGXwdBLMPwCDL0Nht6C4Vdg6GMw9BEMvwFDX4Ohr2D4HRj6GQz9BMMfwNDfYOgvGP4EhgEGwwDB8BcwDDQYBgqGgsAwyGAYJBj+BobBBsNgwfAPMAwxGIYIhn+BYajBMFQwFAKGYQbDMMFQGBiGGwzDBUMRYBhhMIwQDEWBYaTBMFIwFAOGUQbDKMFQHBhGGwyjBUMJYBhjMIwRDCWBYazBMFYwlAKGcQbDOMFQGhjGGwzjBUMZYJhgMEwQDGWBYaLBMFEwlAOGSQbDJMFQHhgmGwyTBUMFYJhiMEwRDBWBYarBMFUwVAKGaQbDNMFQGRimGwzTBUMVYJhhMMwQDFWBYabBMFMwBIBhlsEwSzBUA4bZBsNswVAdGOYYDHMEQw1gmGswzBUMNYFhnsEwTzDUAob5BsN8wVAbGBYYDAsEQx1gWGgwLBQMdYFhkcGwSDDUA4bFBsNiwVAfGJYYDEsEQwNgWGowLBUMDYFhmcGwTDA0AoblBsNywdAYGFYYDCsEQxNgWGkwrBQMTYFhlcGwSjA0A4bVBsNqwdAcGNYYDGsEQwtgWGswrBUMLYFhncGwTjC0Aob1BsN6wdAaGDYYDBsEQxtg2GgwbBQMbYFhk8GwSTC0A4bNBsNmwdAeGLYYDFsEQwdg2GowbBUMHYFhm8GwTTB0AobtBsN2wdAZGHYYDDsEQxdg2Gkw7BQMXYFhl8GwSzB0A4bdBsNuwdAdGPYYDHsEQw9g2Gsw7BUMPYFhn8GwTzD0Aob9BsN+wdAbGA4YDAcEQx9gOGgwHBQMfYHhkMFwSDD0A4bDBsNhwdAfGI4YDEcEwwBgOGowHBUMA4HhmMFwTDAMAobjBsNxwTAYGE4YDCcEwxBgOGkwnBQMQ4HhlMFwSjAMA4bTBsNpwTAcGM4YDGcEwwhgOGswnBUMI4HhnMFwTjCMAobzBsN5wTAaGC4YDBcEwxhguGgwXBQMY4HhksFwSTCMA4bLBsNlwTAeGK4YDFcEwwRguGowXBUME4HhmsFwTTBMAobrBsN1wTAZGG4YDDcEwxRguGkw3BQMU4HhlsFwSzBMA4bbBsNtwTAdGO4YDHcEwwxguGsw3BUMM4HhnsFwTzDMAob7BsN9wTAbGB4YDA8EwxxgeGgwPBQMc4HhkcHwSDDMA4bHBsNjwTAfGJ4YDE8EwwJgeGowPBUMC4HhmcHwTDAsAobnBsNzwbAYGF4YDC8EwxJgeGkwvBQMS4HhlcHwSjAsA4bXBsNrwbAcGN4YDG8EwwpgeGswvBUMK4HhncHwTjCsAob3BsN7wbAaGD4YDB8Ewxpg+GgwfBQMa4Hhk8HwSTCsA4bPBsNnwbAeGP4zGP4TDBuA4YvqoTcEG9SwERjCGAxhBMMmYAhrMIQVDJuBIZzBEE4wbAGG8AZDeMGwFRgiGAwRBMM2YIhoMEQUDNuBIZLBEEkw7ACGyAZDZMGwExiiGAxRBMMuYIhqMEQVDLuBIZrBEE0w7AGG6AZDdMGwFxhiGAwxBMM+YIhpMMQUDPuBIZbBEEswHACG2AZDbMFwEBjiGAxxBMMhYIhrMMQVDIeBIZ7BEE8wHAGG+AZDfMFwFBgSGAwJBMMxYEhoMCQUDMeBIZHBkEgwnACGxAZDYsFwEhiSGAxJBMMpYEhqMCQVDKeBIZnBkEwwnAGG5AZDcsFwFhhSGAwpBMM5YEhpMKQUDOeBIZXBkEowXACG1AZDasFwERjSGAxpBMMlYEhrMKQVDJeBIZ3BkE4wXAGG9AZDesFwFRgyGAwZBMM1YMhoMGQUDNeBIZPBkEkw3ACGzAZDZsFwExiyGAxZBMMtYMhqMGQVDLeBIZvBkE0w3AGG7AZDdsFwFxhyGAw5BMM9YMhpMOQUDPeBIZfBkEswPACG3AZDbsHwEBjyGAx5BMMjYMhrMOQVDI+BIZ/BkE8wPAGG/AZDfsHwFBgKGAwFBMMzYPjSYPhSMDwHhq8Mhq8Ewwtg+Npg+FowvASGbwyGbwTDK2D41mD4VjC8BobvDIbvBMMbYPjeYPheMLwFhh8Mhh8Ewztg+NFg+FEwvAeGnwyGnwTDB2D42WD4WTB8BIZfDIZfBMMnYPjVYPhVMHwGht8Mht8Ew3/A8LvB8Ltg+CLc/274w2D4QzCEAYY/DYY/BUNYYPjLYPhLMIQDhoIGQ0HBEB4Y/jYY/hYMEYDhH4PhH8EQERj+NRj+FQyRgKGQwVBIMEQGhsIGQ2HBEAUYihgMRQRDVGAoajAUFQzRgKGYwVBMMEQHhuIGQ3HBEAMYShgMJQRDTGAoaTCUFAyxgKGUwVBKMMQGhtIGQ2nBEAcYyhgMZQRDXGAoazCUFQzxgKGcwVBOMMQHhvIGQ3nBkAAYKhgMFQRDQmCoaDBUFAyJgKGSwVBJMCQGhsoGQ2XBkAQYqhgMVQRDUmCoajBUFQzJgCFgMAQEQ3JgqGYwVBMMKYChusFQXTCkBIYaBkMNwZAKGGoaDDUFQ2pgqGUw1BIMaYChtsFQWzCkBYY6BkMdwZAOGOoaDHUFQ3pgqGcw1BMMGYChvsFQXzBkBIYGBkMDwZAJGBoaDA0FQ2ZgaGQwNBIMWYChscHQWDBkBYYmBkMTwZANGJoaDE0FQ3ZgaGYwNBMMOYChucHQXDDkBIYWBkMLwZALGFoaDC0FQ25gaGUwtBIMeYChtcHQWjDkBYY2BkMbwZAPGNoaDG0FQ35gaGcwtBMMBYChvcHQXjB8CQwdDIYOguErYOhoMHQUDF8DQyeDoZNg+AYYOhsMnQXDt8DQxWDoIhi+A4auBkNXwfA9MHQzGLoJhh+AobvB0F0w/AgMPQyGHoLhJ2DoaTD0FAw/A0Mvg6GXYPgFGHobDL0Fw6/A0Mdg6CMYfgOGvgZDX8HwOzD0Mxj6CYY/gKG/wdBfMPwJDAMMhgGC4S9gGGgwDBQMBYFhkMEwSDD8DQyDDYbBguEfYBhiMAwRDP8Cw1CDYahgKAQMwwyGYYKhMDAMNxiGC4YiwDDCYBghGIoCw0iDYaRgKAYMowyGUYKhODCMNhhGC4YSwDDGYBgjGEoCw1iDYaxgKAUM4wyGcYKhNDCMNxjGC4YywDDBYJggGMoCw0SDYaJgKAcMkwyGSYKhPDBMNhgmC4YKwDDFYJgiGCoCw1SDYapgqAQM0wyGaYKhMjBMNximC4YqwDDDYJghGKoCw0yDYaZgCADDLINhlmCoBgyzDYbZgqE6MMwxGOYIhhrAMNdgmCsYagLDPINhnmCoBQzzDYb5gqE2MCwwGBYIhjrAsNBgWCgY6gLDIoNhkWCoBwyLDYbFgqE+MCwxGJYIhgbAsNRgWCoYGgLDMoNhmWBoBAzLDYblgqExMKwwGFYIhibAsNJgWCkYmgLDKoNhlWBoBgyrDYbVgqE5MKwxGNYIhhbAsNZgWCsYWgLDOoNhnWBoBQzrDYb1gqE1MGwwGDYIhjbAsNFg2CgY2gLDJoNhk2BoBwybDYbNgqE9MGwxGLYIhg7AsNVg2CoYOgLDNoNhm2DoBAzbDYbtgqEzMOwwGHYIhi7AsNNg2CkYugLDLoNhl2DoBgy7DYbdgqE7MOwxGPYIhh7AsNdg2CsYegLDPoNhn2DoBQz7DYb9gqE3MBwwGA4Ihj7AcNBgOCgY+gLDIYPhkGDoBwyHDYbDgqE/MBwxGI4IhgHAcNRgOCoYBgLDMYPhmGAYBAzHDYbjgmEwMJwwGE4IhiHAcNJgOCkYhgLDKYPhlGAYBgynDYbTgmE4MJwxGM4IhhHAcNZgOCsYRgLDOYPhnGAYBQznDYbzgmE0MFwwGC4IhjHAcNFguCgYxgLDJYPhkmAYBwyXDYbLgmE8MFwxGK4IhgnAcNVguCoYJgLDNYPhmmCYBAzXDYbrgmEyMNwwGG4IhinAcNNguCkYpgLDLYPhlmCYBgy3DYbbgmE6MNwxGO4IhhnAcNdguCsYZgLDPYPhnmCYBQz3DYb7gmE2MDwwGB4IhjnA8NBgeCgY5gLDI4PhkWCYBwyPDYbHgmE+MDwxGJ4IhgXA8NRgeCoYFgLDM4PhmWBYBAzPDYbngmExMLwwGF4IhiXA8NJgeCkYlgLDK4PhlWBYBgyvDYbXgmE5MLwxGN4IhhXA8NZgeCsYVgLDO4PhnWBYBQzvDYb3gmE1MHwwGD4IhjXA8NFg+CgY1gLDJ4Phk2BYBwyfDYbPgmE9MPxnMPwnGDYAwxc1Qm8INqhhIzCEMRjCCIZNwBDWYAgrGDYDQziDIZxg2AIM4Q2G8IJhKzBEMBgiCIZtwBDRYIgoGLYDQySDIZJg2AEMkQ2GyIJhJzBEMRiiCIZdwBDVYIgqGHYDQzSDIZpg2AMM0Q2G6IJhLzDEMBhiCIZ9wBDTYIgpGPYDQyyDIZZgOAAMsQ2G2ILhIDDEMRjiCIZDwBDXYIgrGA4DQzyDIZ5gOAIM8Q2G+ILhKDAkMBgSCIZjwJDQYEgoGI4DQyKDIZFgOAEMiQ2GxILhJDAkMRiSCIZTwJDUYEgqGE4DQzKDIZlgOAMMyQ2G5ILhLDCkMBhSCIZzwJDSYEgpGM4DQyqDIZVguAAMqQ2G1ILhIjCkMRjSCIZLwJDWYEgrGC4DQzqDIZ1guAIM6Q2G9ILhKjBkMBgyCIZrwJDRYMgoGK4DQyaDIZNguAEMmQ2GzILhJjBkMRiyCIZbwJDVYMgqGG4DQzaDIZtguAMM2Q2G7ILhLjDkMBhyCIZ7wJDTYMgpGO4DQy6DIZdgeAAMuQ2G3ILhITDkMRjyCIZHwJDXYMgrGB4DQz6DIZ9geAIM+Q2G/ILhKTAUMBgKCIZnwPClwfClYHgODF8ZDF8JhhfA8LXB8LVgeAkM3xgM3wiGV8DwrcHwrWB4DQzfGQzfCYY3wPC9wfC9YHgLDD8YDD8IhnfA8KPB8KNgeA8MPxkMPwmGD8Dws8Hws2D4CAy/GAy/CIZPwPCrwfCrYPgMDL+F2PBF+C+++L/3OOC6MOH/d8PvhnP4XTiHsMDwh8Hwh2AIBwx/Ggx/CobwwPCXwfCXYIgADAUNhoKCISIw/G0w/C0YIgHDPwbDP4IhMjD8azD8KxiiAEMhg6GQYIgKDIUNhsKCIRowFDEYigiG6MBQ1GAoKhhiAEMxg6GYYIgJDMUNhuKCIRYwlDAYSgiG2MBQ0mAoKRjiAEMpg6GUYIgLDKUNhtKCIR4wlDEYygiG+MBQ1mAoKxgSAEM5g6GcYEgIDOUNhvKCIREwVDAYKgiGxMBQ0WCoKBiSAEMlg6GSYEgKDJUNhsqCIRkwVDEYqgiG5MBQ1WCoKhhSAEPAYAgIhpTAUM1gqCYYUgFDdYOhumBIDQw1DIYagiENMNQ0GGoKhrTAUMtgqCUY0gFDbYOhtmBIDwx1DIY6giEDMNQ1GOoKhozAUM9gqCcYMgFDfYOhvmDIDAwNDIYGgiELMDQ0GBoKhqzA0MhgaCQYsgFDY4OhsWDIDgxNDIYmgiEHMDQ1GJoKhpzA0MxgaCYYcgFDc4OhuWDIDQwtDIYWgiEPMLQ0GFoKhrzA0MpgaCUY8gFDa4OhtWDIDwxtDIY2gqEAMLQ1GNoKhi+BoZ3B0E4wfAUM7Q2G9oLha2DoYDB0EAzfAENHg6GjYPgWGDoZDJ0Ew3fA0Nlg6CwYvgeGLgZDF8HwAzB0NRi6CoYfgaGbwdBNMPwEDN0Nhu6C4Wdg6GEw9BAMvwBDT4Ohp2D4FRh6GQy9BMNvwNDbYOgtGH4Hhj4GQx/B8Acw9DUY+gqGP4Ghn8HQTzD8BQz9DYb+gqEgMAwwGAYIhr+BYaDBMFAw/AMMgwyGQYLhX2AYbDAMFgyFgGGIwTBEMBQGhqEGw1DBUAQYhhkMwwRDUWAYbjAMFwzFgGGEwTBCMBQHhpEGw0jBUAIYRhkMowRDSWAYbTCMFgylgGGMwTBGMJQGhrEGw1jBUAYYxhkM4wRDWWAYbzCMFwzlgGGCwTBBMJQHhokGw0TBUAEYJhkMkwRDRWCYbDBMFgyVgGGKwTBFMFQGhqkGw1TBUAUYphkM0wRDVWCYbjBMFwwBYJhhMMwQDNWAYabBMFMwVAeGWQbDLMFQAxhmGwyzBUNNYJhjMMwRDLWAYa7BMFcw1AaGeQbDPMFQBxjmGwzzBUNdYFhgMCwQDPWAYaHBsFAw1AeGRQbDIsHQABgWGwyLBUNDYFhiMCwRDI2AYanBsFQwNAaGZQbDMsHQBBiWGwzLBUNTYFhhMKwQDM2AYaXBsFIwNAeGVQbDKsHQAhhWGwyrBUNLYFhjMKwRDK2AYa3BsFYwtAaGdQbDOsHQBhjWGwzrBUNbYNhgMGwQDO2AYaPBsFEwtAeGTQbDJsHQARg2GwybBUNHYNhiMGwRDJ2AYavBsFUwdAaGbQbDNsHQBRi2GwzbBUNXYNhhMOwQDN2AYafBsFMwdAeGXQbDLsHQAxh2Gwy7BUNPYNhjMOwRDL2AYa/BsFcw9AaGfQbDPsHQBxj2Gwz7BUNfYDhgMBwQDP2A4aDBcFAw9AeGQwbDIcEwABgOGwyHBcNAYDhiMBwRDIOA4ajBcFQwDAaGYwbDMcEwBBiOGwzHBcNQYDhhMJwQDMOA4aTBcFIwDAeGUwbDKcEwAhhOGwynBcNIYDhjMJwRDKOA4azBcFYwjAaGcwbDOcEwBhjOGwznBcNYYLhgMFwQDOOA4aLBcFEwjAeGSwbDJcEwARguGwyXBcNEYLhiMFwRDJOA4arBcFUwTAaGawbDNcEwBRiuGwzXBcNUYLhhMNwQDNOA4abBcFMwTAeGWwbDLcEwAxhuGwy3BcNMYLhjMNwRDLOA4a7BcFcwzAaGewbDPcEwBxjuGwz3BcNcYHhgMDwQDPOA4aHB8FAwzAeGRwbDI8GwABgeGwyPBcNCYHhiMDwRDIuA4anB8FQwLAaGZwbDM8GwBBieGwzPBcNSYHhhMLwQDMuA4aXB8FIwLAeGVwbDK8GwAhheGwyvBcNKYHhjMLwRDKuA4a3B8FYwrAaGdwbDO8GwBhjeGwzvBcNaYPhgMHwQDOuA4aPB8FEwrAeGTwbDJ8GwARg+GwyfBcNGYPjPYPhPMGwChi9qht4QbFDDZmAIYzCEEQxbgCGswRBWMGwFhnAGQzjBsA0YwhsM4QXDdmCIYDBEEAw7gCGiwRBRMOwEhkgGQyTBsAsYIhsMkQXDbmCIYjBEEQx7gCGqwRBVMOwFhmgGQzTBsA8YohsM0QXDfmCIYTDEEAwHgCGmwRBTMBwEhlgGQyzBcAgYYhsMsQXDYWCIYzDEEQxHgCGuwRBXMBwFhngGQzzBcAwY4hsM8QXDcWBIYDAkEAwngCGhwZBQMJwEhkQGQyLBcAoYEhsMiQXDaWBIYjAkEQxngCGpwZBUMJwFhmQGQzLBcA4YkhsMyQXDeWBIYTCkEAwXgCGlwZBSMFwEhlQGQyrBcAkYUhsMqQXDZWBIYzCkEQxXgCGtwZBWMFwFhnQGQzrBcA0Y0hsM6QXDdWDIYDBkEAw3gCGjwZBRMNwEhkwGQybBcAsYMhsMmQXDbWDIYjBkEQx3gCGrwZBVMNwFhmwGQzbBcA8YshsM2QXDfWDIYTDkEAwPgCGnwZBTMDwEhlwGQy7B8AgYchsMuQXDY2DIYzDkEQxPgCGvwZBXMDwFhnwGQz7B8AwY8hsM+QXDc2AoYDAUEAwvgOFLg+FLwfASGL4yGL4SDK+A4WuD4WvB8BoYvjEYvhEMb4DhW4PhW8HwFhi+Mxi+EwzvgOF7g+F7wfAeGH4wGH4QDB+A4UeD4UfB8BEYfjIYfhIMn4DhZ4PhZ8HwGRh+MRh+EQz/AcOvBsOvguGLCP+74TeD4TfBEAYYfjcYfhcMYYHhD4PhD8EQDhj+NBj+FAzhgeEvg+EvwRABGAoaDAUFQ0Rg+Ntg+FswRAKGfwyGfwRDZGD412D4VzBEAYZCBkMhwRAVGAobDIUFQzRgKGIwFBEM0YGhqMFQVDDEAIZiBkMxwRATGIobDMUFQyxgKGEwlBAMsYGhpMFQUjDEAYZSBkMpwRAXGEobDKUFQzxgKGMwlBEM8YGhrMFQVjAkAIZyBkM5wZAQGMobDOUFQyJgqGAwVBAMiYGhosFQUTAkAYZKBkMlwZAUGCobDJUFQzJgqGIwVBEMyYGhqsFQVTCkAIaAwRAQDCmBoZrBUE0wpAKG6gZDdcGQGhhqGAw1BEMaYKhpMNQUDGmBoZbBUEswpAOG2gZDbcGQHhjqGAx1BEMGYKhrMNQVDBmBoZ7BUE8wZAKG+gZDfcGQGRgaGAwNBEMWYGhoMDQUDFmBoZHB0EgwZAOGxgZDY8GQHRiaGAxNBEMOYGhqMDQVDDmBoZnB0Eww5AKG5gZDc8GQGxhaGAwtBEMeYGhpMLQUDHmBoZXB0Eow5AOG1gZDa8GQHxjaGAxtBEMBYGhrMLQVDF8CQzuDoZ1g+AoY2hsM7QXD18DQwWDoIBi+AYaOBkNHwfAtMHQyGDoJhu+AobPB0FkwfA8MXQyGLoLhB2DoajB0FQw/AkM3g6GbYPgJGLobDN0Fw8/A0MNg6CEYfgGGngZDT8HwKzD0Mhh6CYbfgKG3wdBbMPwODH0Mhj6C4Q9g6Gsw9BUMfwJDP4Ohn2D4Cxj6Gwz9BUNBYBhgMAwQDH8Dw0CDYaBg+AcYBhkMgwTDv8Aw2GAYLBgKAcMQg2GIYCgMDEMNhqGCoQgwDDMYhgmGosAw3GAYLhiKAcMIg2GEYCgODCMNhpGCoQQwjDIYRgmGksAw2mAYLRhKAcMYg2GMYCgNDGMNhrGCoQwwjDMYxgmGssAw3mAYLxjKAcMEg2GCYCgPDBMNhomCoQIwTDIYJgmGisAw2WCYLBgqAcMUg2GKYKgMDFMNhqmCoQowTDMYpgmGqsAw3WCYLhgCwDDDYJghGKoBw0yDYaZgqA4MswyGWYKhBjDMNhhmC4aawDDHYJgjGGoBw1yDYa5gqA0M8wyGeYKhDjDMNxjmC4a6wLDAYFggGOoBw0KDYaFgqA8MiwyGRYKhATAsNhgWC4aGwLDEYFgiGBoBw1KDYalgaAwMywyGZYKhCTAsNxiWC4amwLDCYFghGJoBw0qDYaVgaA4MqwyGVYKhBTCsNhhWC4aWwLDGYFgjGFoBw1qDYa1gaA0M6wyGdYKhDTCsNxjWC4a2wLDBYNggGNoBw0aDYaNgaA8MmwyGTYKhAzBsNhg2C4aOwLDFYNgiGDoBw1aDYatg6AwM2wyGbYKhCzBsNxi2C4auwLDDYNghGLoBw06DYadg6A4MuwyGXYKhBzDsNhh2C4aewLDHYNgjGHoBw16DYa9g6A0M+wyGfYKhDzDsNxj2C4a+wHDAYDggGPoBw0GD4aBg6A8MhwyGQ4JhADAcNhgOC4aBwHDEYDgiGAYBw1GD4ahgGAwMxwyGY4JhCDAcNxiOC4ahwHDCYDghGIYBw0mD4aRgGA4MpwyGU4JhBDCcNhhOC4aRwHDGYDgjGEYBw1mD4axgGA0M5wyGc4JhDDCcNxjOC4axwHDBYLggGMYBw0WD4aJgGA8MlwyGS4JhAjBcNhguC4aJwHDFYLgiGCYBw1WD4apgmAwM1wyGa4JhCjBcNxiuC4apwHDDYLghGKYBw02D4aZgmA4MtwyGW4JhBjDcNhhuC4aZwHDHYLgjGGYBw12D4a5gmA0M9wyGe4JhDjDcNxjuC4a5wPDAYHggGOYBw0OD4aFgmA8MjwyGR4JhATA8NhgeC4aFwPDEYHgiGBYBw1OD4algWAwMzwyGZ4JhCTA8NxieC4alwPDCYHghGJYBw0uD4aVgWA4MrwyGV4JhBTC8NhheC4aVwPDGYHgjGFYBw1uD4a1gWA0M7wyGd4JhDTC8NxjeC4a1wPDBYPggGNYBw0eD4aNgWA8MnwyGT4JhAzB8Nhg+C4aNwPCfwfCfYNgEDF/UCr0h2KCGzcAQxmAIIxi2AENYgyGsYNgKDOEMhnCCYRswhDcYwguG7cAQwWCIIBh2AENEgyGiYNgJDJEMhkiCYRcwRDYYIguG3cAQxWCIIhj2AENUgyGqYNgLDNEMhmiCYR8wRDcYoguG/cAQw2CIIRgOAENMgyGmYDgIDLEMhliC4RAwxDYYYguGw8AQx2CIIxiOAENcgyGuYDgKDPEMhniC4RgwxDcY4guG48CQwGBIIBhOAENCgyGhYDgJDIkMhkSC4RQwJDYYEguG08CQxGBIIhjOAENSgyGpYDgLDMkMhmSC4RwwJDcYkguG88CQwmBIIRguAENKgyGlYLgIDKkMhlSC4RIwpDYYUguGy8CQxmBIIxiuAENagyGtYLgKDOkMhnSC4RowpDcY0guG68CQwWDIIBhuAENGgyGjYLgJDJkMhkyC4RYwZDYYMguG28CQxWDIIhjuAENWgyGrYLgLDNkMhmyC4R4wZDcYsguG+8CQw2DIIRgeAENOgyGnYHgIDLkMhlyC4REw5DYYcguGx8CQx2DIIxieAENegyGvYHgKDPkMhnyC4Rkw5DcY8guG58BQwGAoIBheAMOXBsOXguElMHxlMHwlGF4Bw9cGw9eC4TUwfGMwfCMY3gDDtwbDt4LhLTB8ZzB8JxjeAcP3BsP3guE9MPxgMPwgGD4Aw48Gw4+C4SMw/GQw/CQYPgHDzwbDz4LhMzD8EmLDFxG/+OL/3h+A68JE/N8NvxrO4VfhHMICw28Gw2+CIRww/G4w/C4YwgPDHwbDH4IhAjD8aTD8KRgiAsNfBsNfgiESMBQ0GAoKhsjA8LfB8LdgiAIM/xgM/wiGqMDwr8Hwr2CIBgyFDIZCgiE6MBQ2GAoLhhjAUMRgKCIYYgJDUYOhqGCIBQzFDIZigiE2MBQ3GIoLhjjAUMJgKCEY4gJDSYOhpGCIBwylDIZSgiE+MJQ2GEoLhgTAUMZgKCMYEgJDWYOhrGBIBAzlDIZygiExMJQ3GMoLhiTAUMFgqCAYkgJDRYOhomBIBgyVDIZKgiE5MFQ2GCoLhhTAUMVgqCIYUgJDVYOhqmBIBQwBgyEgGFIDQzWDoZpgSAMM1Q2G6oIhLTDUMBhqCIZ0wFDTYKgpGNIDQy2DoZZgyAAMtQ2G2oIhIzDUMRjqCIZMwFDXYKgrGDIDQz2DoZ5gyAIM9Q2G+oIhKzA0MBgaCIZswNDQYGgoGLIDQyODoZFgyAEMjQ2GxoIhJzA0MRiaCIZcwNDUYGgqGHIDQzODoZlgyAMMzQ2G5oIhLzC0MBhaCIZ8wNDSYGgpGPIDQyuDoZVgKAAMrQ2G1oLhS2BoYzC0EQxfAUNbg6GtYPgaGNoZDO0EwzfA0N5gaC8YvgWGDgZDB8HwHTB0NBg6CobvgaGTwdBJMPwADJ0Nhs6C4Udg6GIwdBEMPwFDV4Ohq2D4GRi6GQzdBMMvwNDdYOguGH4Fhh4GQw/B8Bsw9DQYegqG34Ghl8HQSzD8AQy9DYbeguFPYOhjMPQRDH8BQ1+Doa9gKAgM/QyGfoLhb2DobzD0Fwz/AMMAg2GAYPgXGAYaDAMFQyFgGGQwDBIMhYFhsMEwWDAUAYYhBsMQwVAUGIYaDEMFQzFgGGYwDBMMxYFhuMEwXDCUAIYRBsMIwVASGEYaDCMFQylgGGUwjBIMpYFhtMEwWjCUAYYxBsMYwVAWGMYaDGMFQzlgGGcwjBMM5YFhvMEwXjBUAIYJBsMEwVARGCYaDBMFQyVgmGQwTBIMlYFhssEwWTBUAYYpBsMUwVAVGKYaDFMFQwAYphkM0wRDNWCYbjBMFwzVgWGGwTBDMNQAhpkGw0zBUBMYZhkMswRDLWCYbTDMFgy1gWGOwTBHMNQBhrkGw1zBUBcY5hkM8wRDPWCYbzDMFwz1gWGBwbBAMDQAhoUGw0LB0BAYFhkMiwRDI2BYbDAsFgyNgWGJwbBEMDQBhqUGw1LB0BQYlhkMywRDM2BYbjAsFwzNgWGFwbBCMLQAhpUGw0rB0BIYVhkMqwRDK2BYbTCsFgytgWGNwbBGMLQBhrUGw1rB0BYY1hkM6wRDO2BYbzCsFwztgWGDwbBBMHQAho0Gw0bB0BEYNhkMmwRDJ2DYbDBsFgydgWGLwbBFMHQBhq0Gw1bB0BUYthkM2wRDN2DYbjBsFwzdgWGHwbBDMPQAhp0Gw07B0BMYdhkMuwRDL2DYbTDsFgy9gWGPwbBHMPQBhr0Gw17B0BcY9hkM+wRDP2DYbzDsFwz9geGAwXBAMAwAhoMGw0HBMBAYDhkMhwTDIGA4bDAcFgyDgeGIwXBEMAwBhqMGw1HBMBQYjhkMxwTDMGA4bjAcFwzDgeGEwXBCMIwAhpMGw0nBMBIYThkMpwTDKGA4bTCcFgyjgeGMwXBGMIwBhrMGw1nBMBYYzhkM5wTDOGA4bzCcFwzjgeGCwXBBMEwAhosGw0XBMBEYLhkMlwTDJGC4bDBcFgyTgeGKwXBFMEwBhqsGw1XBMBUYrhkM1wTDNGC4bjBcFwzTgeGGwXBDMMwAhpsGw03BMBMYbhkMtwTDLGC4bTDcFgyzgeGOwXBHMMwBhrsGw13BMBcY7hkM9wTDPGC4bzDcFwzzgeGBwfBAMCwAhocGw0PBsBAYHhkMjwTDImB4bDA8FgyLgeGJwfBEMCwBhqcGw1PBsBQYnhkMzwTDMmB4bjA8FwzLgeGFwfBCMKwAhpcGw0vBsBIYXhkMrwTDKmB4bTC8FgyrgeGNwfBGMKwBhrcGw1vBsBYY3hkM7wTDOmB4bzC8FwzrgeGDwfBBMGwAho8Gw0fBsBEYPhkMnwTDJmD4bDB8FgybgeE/g+E/wbAFGL6oHXpDsEENW4EhjMEQRjBsA4awBkNYwbAdGMIZDOEEww5gCG8whBcMO4EhgsEQQTDsAoaIBkNEwbAbGCIZDJEEwx5giGwwRBYMe4EhisEQRTDsA4aoBkNUwbAfGKIZDNEEwwFgiG4wRBcMB4EhhsEQQzAcAoaYBkNMwXAYGGIZDLEEwxFgiG0wxBYMR4EhjsEQRzAcA4a4BkNcwXAcGOIZDPEEwwlgiG8wxBcMJ4EhgcGQQDCcAoaEBkNCwXAaGBIZDIkEwxlgSGwwJBYMZ4EhicGQRDCcA4akBkNSwXAeGJIZDMkEwwVgSG4wJBcMF4EhhcGQQjBcAoaUBkNKwXAZGFIZDKkEwxVgSG0wpBYMV4EhjcGQRjBcA4a0BkNawXAdGNIZDOkEww1gSG8wpBcMN4Ehg8GQQTDcAoaMBkNGwXAbGDIZDJkEwx1gyGwwZBYMd4Ehi8GQRTDcA4asBkNWwXAfGLIZDNkEwwNgyG4wZBcMD4Ehh8GQQzA8AoacBkNOwfAYGHIZDLkEwxNgyG0w5BYMT4Ehj8GQRzA8A4a8BkNewfAcGPIZDPkEwwtgyG8w5BcML4GhgMFQQDC8AoYvDYYvBcNrYPjKYPhKMLwBhq8Nhq8Fw1tg+MZg+EYwvAOGbw2GbwXDe2D4zmD4TjB8AIbvDYbvBcNHYPjBYPhBMHwChh8Nhh8Fw2dg+Mlg+Ekw/AcMPxsMPwuGLyL974ZfDIZfBEMYYPjVYPhVMIQFht8Mht8EQzhg+N1g+F0whAeGPwyGPwRDBGD402D4UzBEBIa/DIa/BEMkYChoMBQUDJGB4W+D4W/BEAUY/jEY/hEMUYHhX4PhX8EQDRgKGQyFBEN0YChsMBQWDDGAoYjBUEQwxASGogZDUcEQCxiKGQzFBENsYChuMBQXDHGAoYTBUEIwxAWGkgZDScEQDxhKGQylBEN8YChtMJQWDAmAoYzBUEYwJASGsgZDWcGQCBjKGQzlBENiYChvMJQXDEmAoYLBUEEwJAWGigZDRcGQDBgqGQyVBENyYKhsMFQWDCmAoYrBUEUwpASGqgZDVcGQChgCBkNAMKQGhmoGQzXBkAYYqhsM1QVDWmCoYTDUEAzpgKGmwVBTMKQHhloGQy3BkAEYahsMtQVDRmCoYzDUEQyZgKGuwVBXMGQGhnoGQz3BkAUY6hsM9QVDVmBoYDA0EAzZgKGhwdBQMGQHhkYGQyPBkAMYGhsMjQVDTmBoYjA0EQy5gKGpwdBUMOQGhmYGQzPBkAcYmhsMzQVDXmBoYTC0EAz5gKGlwdBSMOQHhlYGQyvBUAAYWhsMrQXDl8DQxmBoIxi+Aoa2BkNbwfA1MLQzGNoJhm+Aob3B0F4wfAsMHQyGDoLhO2DoaDB0FAzfA0Mng6GTYPgBGDobDJ0Fw4/A0MVg6CIYfgKGrgZDV8HwMzB0Mxi6CYZfgKG7wdBdMPwKDD0Mhh6C4Tdg6Gkw9BQMvwNDL4Ohl2D4Axh6Gwy9BcOfwNDHYOgjGP4Chr4GQ1/BUBAY+hkM/QTD38DQ32DoLxj+AYYBBsMAwfAvMAw0GAYKhkLAMMhgGCQYCgPDYINhsGAoAgxDDIYhgqEoMAw1GIYKhmLAMMxgGCYYigPDcINhuGAoAQwjDIYRgqEkMIw0GEYKhlLAMMpgGCUYSgPDaINhtGAoAwxjDIYxgqEsMIw1GMYKhnLAMM5gGCcYygPDeINhvGCoAAwTDIYJgqEiMEw0GCYKhkrAMMlgmCQYKgPDZINhsmCoAgxTDIYpgqEqMEw1GKYKhgAwTDMYpgmGasAw3WCYLhiqA8MMg2GGYKgBDDMNhpmCoSYwzDIYZgmGWsAw22CYLRhqA8Mcg2GOYKgDDHMNhrmCoS4wzDMY5gmGesAw32CYLxjqA8MCg2GBYGgADAsNhoWCoSEwLDIYFgmGRsCw2GBYLBgaA8MSg2GJYGgCDEsNhqWCoSkwLDMYlgmGZsCw3GBYLhiaA8MKg2GFYGgBDCsNhpWCoSUwrDIYVgmGVsCw2mBYLRhaA8Mag2GNYGgDDGsNhrWCoS0wrDMY1gmGdsCw3mBYLxjaA8MGg2GDYOgADBsNho2CoSMwbDIYNgmGTsCw2WDYLBg6A8MWg2GLYOgCDFsNhq2CoSswbDMYtgmGbsCw3WDYLhi6A8MOg2GHYOgBDDsNhp2CoScw7DIYdgmGXsCw22DYLRh6A8Meg2GPYOgDDHsNhr2CoS8w7DMY9gmGfsCw32DYLxj6A8MBg+GAYBgADAcNhoOCYSAwHDIYDgmGQcBw2GA4LBgGA8MRg+GIYBgCDEcNhqOCYSgwHDMYjgmGYcBw3GA4LhiGA8MJg+GEYBgBDCcNhpOCYSQwnDIYTgmGUcBw2mA4LRhGA8MZg+GMYBgDDGcNhrOCYSwwnDMYzgmGccBw3mA4LxjGA8MFg+GCYJgADBcNhouCYSIwXDIYLgmGScBw2WC4LBgmA8MVg+GKYJgCDFcNhquCYSowXDMYrgmGacBw3WC4LhimA8MNg+GGYJgBDDcNhpuCYSYw3DIYbgmGWcBw22C4LRhmA8Mdg+GOYJgDDHcNhruCYS4w3DMY7gmGecBw32C4LxjmA8MDg+GBYFgADA8NhoeCYSEwPDIYHgmGRcDw2GB4LBgWA8MTg+GJYFgCDE8NhqeCYSkwPDMYngmGZcDw3GB4LhiWA8MLg+GFYFgBDC8NhpeCYSUwvDIYXgmGVcDw2mB4LRhWA8Mbg+GNYFgDDG8NhreCYS0wvDMY3gmGdcDw3mB4LxjWA8MHg+GDYNgADB8Nho+CYSMwfDIYPgmGTcDw2WD4LBg2A8N/BsN/gmELMHxRJ/SGYIMatgJDGIMhjGDYBgxhDYawgmE7MIQzGMIJhh3AEN5gCC8YdgJDBIMhgmDYBQwRDYaIgmE3MEQyGCIJhj3AENlgiCwY9gJDFIMhimDYBwxRDYaogmE/MEQzGKIJhgPAEN1giC4YDgJDDIMhhmA4BAwxDYaYguEwMMQyGGIJhiPAENtgiC0YjgJDHIMhjmA4BgxxDYa4guE4MMQzGOIJhhPAEN9giC8YTgJDAoMhgWA4BQwJDYaEguE0MCQyGBIJhjPAkNhgSCwYzgJDEoMhiWA4BwxJDYakguE8MCQzGJIJhgvAkNxgSC4YLgJDCoMhhWC4BAwpDYaUguEyMKQyGFIJhivAkNpgSC0YrgJDGoMhjWC4BgxpDYa0guE6MKQzGNIJhhvAkN5gSC8YbgJDBoMhg2C4BQwZDYaMguE2MGQyGDIJhjvAkNlgyCwY7gJDFoMhi2C4BwxZDYasguE+MGQzGLIJhgfAkN1gyC4YHgJDDoMhh2B4BAw5DYacguExMOQyGHIJhifAkNtgyC0YngJDHoMhj2B4Bgx5DYa8guE5MOQzGPIJhhfAkN9gyC8YXgJDAYOhgGD4f/H2j0GW7F3/7turbZurbdu2bdu2bdu2bdu2bbtX41zr2c8+ceLsF//7O3bcoyOuiI6Kmpm/T+UcsypmZWV+FgxZHAxZDIYvgiGrgyGrwfBVMGRzMGQzGL4JhuwOhuwGw3fBkMPBkMNg+CEYcjoYchoM/wiGXA6GXAbDT8GQ28GQ22D4JRjyOBjyGAy/BUPe/7LhT7gAAf7nvHXxcQHC/+eGfA7HIZ/hOPwlGPI7GPIbDAEFQwEHQwGDIZBgKOhgKGgwBBYMhRwMhQyGIIKhsIOhsMEQVDAUcTAUMRiCCYaiDoaiBkNwwVDMwVDMYAghGIo7GIobDCEFQwkHQwmDIZRgKOlgKGkwhBYMpRwMpQyGMIKhtIOhtMEQVjCUcTCUMRjCCYayDoayBkN4wVDOwVDOYIggGMo7GMobDBEFQwUHQwWDIZJgqOhgqGgwRBYMlRwMlQyGKIKhsoOhssEQVTBUcTBUMRiiCYaqDoaqBkN0wVDNwVDNYIghGKo7GKobDDEFQw0HQw2DIZZgqOlgqGkwxBYMtRwMtQyGOIKhtoOhtsEQVzDUcTDUMRjiCYa6Doa6BsPfgqGeg6GewRBfMNR3MNQ3GBIIhgYOhgYGQ0LB0NDB0NBgSCQYGjkYGhkMiQVDYwdDY4MhiWBo4mBoYjAkFQxNHQxNDYZkgqGZg6GZwZBcMDR3MDQ3GFIIhhYOhhYGQ0rB0NLB0NJgSCUYWjkYWhkMqQVDawdDa4MhjWBo42BoYzCkFQxtHQxtDYZ0gqGdg6GdwZBeMLR3MLQ3GDIIhg4Ohg4GQ0bB0NHB0NFgyCQYOjkYOhkMmQVDZwdDZ4Mhi2Do4mDoYjBkFQxdHQxdDYZsgqGbg6GbwZBdMHR3MHQ3GHIIhh4Ohh4GQ07B0NPB0NNgyCUYejkYehkMuQVDbwdDb4Mhj2Do42DoYzDkFQx9HQx9DYZ8gqGfg6GfwZBfMPR3MPQ3GAoIhgEOhgEGQ0HBMNDBMNBgKCQYBjkYBhkMhQXDYAfDYIOhiGAY4mAYYjAUFQxDHQxDDYZigmGYg2GYwVBcMAx3MAw3GEoIhhEOhhEGQ0nBMNLBMNJgKCUYRjkYRhkMpQXDaAfDaIOhjGAY42AYYzCUFQxjHQxjDYZygmGcg2GcwVBeMIx3MIw3GCoIhgkOhgkGQ0XBMNHBMNFgqCQYJjkYJhkMlQXDZAfDZIOhimCY4mCYYjBUFQxTHQxTDYZqgmGag2GawVBdMEx3MEw3GGoIhhkOhhkGQ03BMNPBMNNgqCUYZjkYZhkMtQXDbAfDbIOhjmCY42CYYzDUFQxzHQxzDYZ6gmGeg2GewVBfMMx3MMw3GBoIhgUOhgUGQ0PBsNDBsNBgaCQYFjkYFhkMjQXDYgfDYoOhiWBY4mBYYjA0FQxLHQxLDYZmgmGZg2GZwdBcMCx3MCw3GFoIhhUOhhUGQ0vBsNLBsNJgaCUYVjkYVhkMrQXDagfDaoOhjWBY42BYYzC0FQxrHQxrDYZ2gmGdg2GdwdBeMKx3MKw3GDoIhg0Ohg0GQ0fBsNHBsNFg6CQYNjkYNhkMnQXDZgfDZoOhi2DY4mDYYjB0FQxbHQxbDYZugmGbg2GbwdBdMGx3MGw3GHoIhh0Ohh0GQ0/BsNPBsNNg6CUYdjkYdhkMvQXDbgfDboOhj2DY42DYYzD0FQx7HQx7DYZ+gmGfg2GfwdBfMOx3MOw3GAYIhgMOhgMGw0DBcNDBcNBgGCQYDjkYDhkMgwXDYQfDYYNhiGA44mA4YjAMFQxHHQxHDYZhguGYg+GYwTBcMBx3MBw3GEYIhhMOhhMGw0jBcNLBcNJgGCUYTjkYThkMowXDaQfDaYNhjGA442A4YzCMFQxnHQxnDYZxguGcg+GcwTBeMJx3MJw3GCYIhgsOhgsGw0TBcNHBcNFgmCQYLjkYLhkMkwXDZQfDZYNhimC44mC4YjBMFQxXHQxXDYZpguGag+GawTBdMFx3MFw3GGYIhhsOhhsGw0zBcNPBcNNgmCUYbjkYbhkMswXDbQfDbYNhjmC442C4YzDMFQx3HQx3DYZ5guGeg+GewTBfMNx3MNw3GBYIhgcOhgcGw0LB8NDB8NBgWCQYHjkYHhkMiwXDYwfDY4NhiWB44mB4YjAsFQxPHQxPDYZlguGZg+GZwbBcMDx3MDw3GFYIhhcOhhcGw0rB8NLB8NJgWCUYXjkYXhkMqwXDawfDa4NhjWB442B4YzCsFQxvHQxvDYZ1guGdg+GdwbBeMLx3MLw3GDYIhg8Ohg8Gw0bB8NHB8NFg2CQYPjkYPhkMmwXDZwfDZ4Nhi2D44mD4YjBsFQxfHQxfDYZtguGbg+GbwbBdMHx3MHw3GHYIhh8Ohh8Gw07B8I+D4R+DYZdg+Olg+Gkw7BYMvxwMvwyGPYLht4Pht8GwVzD8cTD8MRj2CYYAzf77hn/3oRr2C4a/HAx/GQwHBENAB0NAg+GgYAjkYAhkMBwSDIEdDIENhsOCIYiDIYjBcEQwBHUwBDUYjgqGYA6GYAbDMcEQ3MEQ3GA4LhhCOBhCGAwnBENIB0NIg+GkYAjlYAhlMJwSDKEdDKENhtOCIYyDIYzBcEYwhHUwhDUYzgqGcA6GcAbDOcEQ3sEQ3mA4LxgiOBgiGAwXBENEB0NEg+GiYIjkYIhkMFwSDJEdDJENhsuCIYqDIYrBcEUwRHUwRDUYrgqGaA6GaAbDNcEQ3cEQ3WC4LhhiOBhiGAw3BENMB0NMg+GmYIjlYIhlMNwSDLEdDLENhtuCIY6DIY7BcEcwxHUwxDUY7gqGeA6GeAbDPcHwt4Phb4PhvmCI72CIbzA8EAwJHAwJDIaHgiGhgyGhwfBIMCRyMCQyGB4LhsQOhsQGwxPBkMTBkMRgeCoYkjoYkhoMzwRDMgdDMoPhuWBI7mBIbjC8EAwpHAwpDIaXgiGlgyGlwfBKMKRyMKQyGF4LhtQOhtQGwxvBkMbBkMZgeCsY0joY0hoM7wRDOgdDOoPhvWBI72BIbzB8EAwZHAwZDIaPgiGjgyGjwfBJMGRyMGQyGD4LhswOhswGwxfBkMXBkMVg+CoYsjoYshoM3wRDNgdDNoPhu2DI7mDIbjD8EAw5HAw5DIZ/BENOB0NOg+GnYMjlYMhlMPwSDLkdDLkNht+CIY+DIY/B8Ecw5HUw5DUYAkT4zw35HAz5DIa/BEN+B0N+gyGgYCjgYChgMAQSDAUdDAUNhsCCoZCDoZDBEEQwFHYwFDYYggqGIg6GIgZDMMFQ1MFQ1GAILhiKORiKGQwhBENxB0NxgyGkYCjhYChhMIQSDCUdDCUNhtCCoZSDoZTBEEYwlHYwlDYYwgqGMg6GMgZDOMFQ1sFQ1mAILxjKORjKGQwRBEN5B0N5gyGiYKjgYKhgMEQSDBUdDBUNhsiCoZKDoZLBEEUwVHYwVDYYogqGKg6GKgZDNMFQ1cFQ1WCILhiqORiqGQwxBEN1B0N1gyGmYKjhYKhhMMQSDDUdDDUNhtiCoZaDoZbBEEcw1HYw1DYY4gqGOg6GOgZDPMFQ18FQ12D4WzDUczDUMxjiC4b6Dob6BkMCwdDAwdDAYEgoGBo6GBoaDIkEQyMHQyODIbFgaOxgaGwwJBEMTRwMTQyGpIKhqYOhqcGQTDA0czA0MxiSC4bmDobmBkMKwdDCwdDCYEgpGFo6GFoaDKkEQysHQyuDIbVgaO1gaG0wpBEMbRwMbQyGtIKhrYOhrcGQTjC0czC0MxjSC4b2Dob2BkMGwdDBwdDBYMgoGDo6GDoaDJkEQycHQyeDIbNg6Oxg6GwwZBEMXRwMXQyGrIKhq4Ohq8GQTTB0czB0MxiyC4buDobuBkMOwdDDwdDDYMgpGHo6GHoaDLkEQy8HQy+DIbdg6O1g6G0w5BEMfRwMfQyGvIKhr4Ohr8GQTzD0czD0MxjyC4b+Dob+BkMBwTDAwTDAYCgoGAY6GAYaDIUEwyAHwyCDobBgGOxgGGwwFBEMQxwMQwyGooJhqINhqMFQTDAMczAMMxiKC4bhDobhBkMJwTDCwTDCYCgpGEY6GEYaDKUEwygHwyiDobRgGO1gGG0wlBEMYxwMYwyGsoJhrINhrMFQTjCMczCMMxjKC4bxDobxBkMFwTDBwTDBYKgoGCY6GCYaDJUEwyQHwySDobJgmOxgmGwwVBEMUxwMUwyGqoJhqoNhqsFQTTBMczBMMxiqC4bpDobpBkMNwTDDwTDDYKgpGGY6GGYaDLUEwywHwyyDobZgmO1gmG0w1BEMcxwMcwyGuoJhroNhrsFQTzDMczDMMxjqC4b5Dob5BkMDwbDAwbDAYGgoGBY6GBYaDI0EwyIHwyKDobFgWOxgWGwwNBEMSxwMSwyGpoJhqYNhqcHQTDAsczAsMxiaC4blDoblBkMLwbDCwbDCYGgpGFY6GFYaDK0EwyoHwyqDobVgWO1gWG0wtBEMaxwMawyGtoJhrYNhrcHQTjCsczCsMxjaC4b1Dob1BkMHwbDBwbDBYOgoGDY6GDYaDJ0EwyYHwyaDobNg2Oxg2GwwdBEMWxwMWwyGroJhq4Nhq8HQTTBsczBsMxi6C4btDobtBkMPwbDDwbDDYOgpGHY6GHYaDL0Ewy4Hwy6Dobdg2O1g2G0w9BEMexwMewyGvoJhr4Nhr8HQTzDsczDsMxj6C4b9Dob9BsMAwXDAwXDAYBgoGA46GA4aDIMEwyEHwyGDYbBgOOxgOGwwDBEMRxwMRwyGoYLhqIPhqMEwTDAcczAcMxiGC4bjDobjBsMIwXDCwXDCYBgpGE46GE4aDKMEwykHwymDYbRgOO1gOG0wjBEMZxwMZwyGsYLhrIPhrMEwTjCcczCcMxjGC4bzDobzBsMEwXDBwXDBYJgoGC46GC4aDJMEwyUHwyWDYbJguOxguGwwTBEMVxwMVwyGqYLhqoPhqsEwTTBcczBcMximC4brDobrBsMMwXDDwXDDYJgpGG46GG4aDLMEwy0Hwy2DYbZguO1guG0wzBEMdxwMdwyGuYLhroPhrsEwTzDcczDcMxjmC4b7Dob7BsMCwfDAwfDAYFgoGB46GB4aDIsEwyMHwyODYbFgeOxgeGwwLBEMTxwMTwyGpYLhqYPhqcGwTDA8czA8MxiWC4bnDobnBsMKwfDCwfDCYFgpGF46GF4aDKsEwysHwyuDYbVgeO1geG0wrBEMbxwMbwyGtYLhrYPhrcGwTjC8czC8MxjWC4b3Dob3BsMGwfDBwfDBYNgoGD46GD4aDJsEwycHwyeDYbNg+Oxg+GwwbBEMXxwMXwyGrYLhq4Phq8GwTTB8czB8Mxi2C4bvDobvBsMOwfDDwfDDYNgpGP5xMPxjMOwSDD8dDD8Nht2C4ZeD4ZfBsEcw/HYw/DYY9gqGPw6GPwbDPsEQoPl/3/DvPlTDfsHwl4PhL4PhgGAI6GAIaDAcFAyBHAyBDIZDgiGwgyGwwXBYMARxMAQxGI4IhqAOhqAGw1HBEMzBEMxgOCYYgjsYghsMxwVDCAdDCIPhhGAI6WAIaTCcFAyhHAyhDIZTgiG0gyG0wXBaMIRxMIQxGM4IhrAOhrAGw1nBEM7BEM5gOCcYwjsYwhsM5wVDBAdDBIPhgmCI6GCIaDBcFAyRHAyRDIZLgiGygyGywXBZMERxMEQxGK4IhqgOhqgGw1XBEM3BEM1guCYYojsYohsM1wVDDAdDDIPhhmCI6WCIaTDcFAyxHAyxDIZbgiG2gyG2wXBbMMRxMMQxGO4IhrgOhrgGw13BEM/BEM9guCcY/nYw/G0w3BcM8R0M8Q2GB4IhgYMhgcHwUDAkdDAkNBgeCYZEDoZEBsNjwZDYwZDYYHgiGJI4GJIYDE8FQ1IHQ1KD4ZlgSOZgSGYwPBcMyR0MyQ2GF4IhhYMhhcHwUjCkdDCkNBheCYZUDoZUBsNrwZDawZDaYHgjGNI4GNIYDG8FQ1oHQ1qD4Z1gSOdgSGcwvBcM6R0M6Q2GD4Ihg4Mhg8HwUTBkdDBkNBg+CYZMDoZMBsNnwZDZwZDZYPgiGLI4GLIYDF8FQ1YHQ1aD4ZtgyOZgyGYwfBcM2R0M2Q2GH4Ihh4Mhh8Hwj2DI6WDIaTD8FAy5HAy5DIZfgiG3gyG3wfBbMORxMOQxGP4IhrwOhrwGQ4CI/7khn4Mhn8Hwl2DI72DIbzAEFAwFHAwFDIZAgqGgg6GgwRBYMBRyMBQyGIIIhsIOhsIGQ1DBUMTBUMRgCCYYijoYihoMwQVDMQdDMYMhhGAo7mAobjCEFAwlHAwlDIZQgqGkg6GkwRBaMJRyMJQyGMIIhtIOhtIGQ1jBUMbBUMZgCCcYyjoYyhoM4QVDOQdDOYMhgmAo72AobzBEFAwVHAwVDIZIgqGig6GiwRBZMFRyMFQyGKIIhsoOhsoGQ1TBUMXBUMVgiCYYqjoYqhoM0QVDNQdDNYMhhmCo7mCobjDEFAw1HAw1DIZYgqGmg6GmwRBbMNRyMNQyGOIIhtoOhtoGQ1zBUMfBUMdgiCcY6joY6hoMfwuGeg6GegZDfMFQ38FQ32BIIBgaOBgaGAwJBUNDB0NDgyGRYGjkYGhkMCQWDI0dDI0NhiSCoYmDoYnBkFQwNHUwNDUYkgmGZg6GZgZDcsHQ3MHQ3GBIIRhaOBhaGAwpBUNLB0NLgyGVYGjlYGhlMKQWDK0dDK0NhjSCoY2DoY3BkFYwtHUwtDUY0gmGdg6GdgZDesHQ3sHQ3mDIIBg6OBg6GAwZBUNHB0NHgyGTYOjkYOhkMGQWDJ0dDJ0NhiyCoYuDoYvBkFUwdHUwdDUYsgmGbg6GbgZDdsHQ3cHQ3WDIIRh6OBh6GAw5BUNPB0NPgyGXYOjlYOhlMOQWDL0dDL0NhjyCoY+DoY/BkFcw9HUw9DUY8gmGfg6GfgZDfsHQ38HQ32AoIBgGOBgGGAwFBcNAB8NAg6GQYBjkYBhkMBQWDIMdDIMNhiKCYYiDYYjBUFQwDHUwDDUYigmGYQ6GYQZDccEw3MEw3GAoIRhGOBhGGAwlBcNIB8NIg6GUYBjlYBhlMJQWDKMdDKMNhjKCYYyDYYzBUFYwjHUwjDUYygmGcQ6GcQZDecEw3sEw3mCoIBgmOBgmGAwVBcNEB8NEg6GSYJjkYJhkMFQWDJMdDJMNhiqCYYqDYYrBUFUwTHUwTDUYqgmGaQ6GaQZDdcEw3cEw3WCoIRhmOBhmGAw1BcNMB8NMg6GWYJjlYJhlMNQWDLMdDLMNhjqCYY6DYY7BUFcwzHUwzDUY6gmGeQ6GeQZDfcEw38Ew32BoIBgWOBgWGAwNBcNCB8NCg6GRYFjkYFhkMDQWDIsdDIsNhiaCYYmDYYnB0FQwLHUwLDUYmgmGZQ6GZQZDc8Gw3MGw3GBoIRhWOBhWGAwtBcNKB8NKg6GVYFjlYFhlMLQWDKsdDKsNhjaCYY2DYY3B0FYwrHUwrDUY2gmGdQ6GdQZDe8Gw3sGw3mDoIBg2OBg2GAwdBcNGB8NGg6GTYNjkYNhkMHQWDJsdDJsNhi6CYYuDYYvB0FUwbHUwbDUYugmGbQ6GbQZDd8Gw3cGw3WDoIRh2OBh2GAw9BcNOB8NOg6GXYNjlYNhlMPQWDLsdDLsNhj6CYY+DYY/B0Fcw7HUw7DUY+gmGfQ6GfQZDf8Gw38Gw32AYIBgOOBgOGAwDBcNBB8NBg2GQYDjkYDhkMAwWDIcdDIcNhiGC4YiD4YjBMFQwHHUwHDUYhgmGYw6GYwbDcMFw3MFw3GAYIRhOOBhOGAwjBcNJB8NJg2GUYDjlYDhlMIwWDKcdDKcNhjGC4YyD4YzBMFYwnHUwnDUYxgmGcw6GcwbDeMFw3sFw3mCYIBguOBguGAwTBcNFB8NFg2GSYLjkYLhkMEwWDJcdDJcNhimC4YqD4YrBMFUwXHUwXDUYpgmGaw6GawbDdMFw3cFw3WCYIRhuOBhuGAwzBcNNB8NNg2GWYLjlYLhlMMwWDLcdDLcNhjmC4Y6D4Y7BMFcw3HUw3DUY5gmGew6GewbDfMFw38Fw32BYIBgeOBgeGAwLBcNDB8NDg2GRYHjkYHhkMCwWDI8dDI8NhiWC4YmD4YnBsFQwPHUwPDUYlgmGZw6GZwbDcsHw3MHw3GBYIRheOBheGAwrBcNLB8NLg2GVYHjlYHhlMKwWDK8dDK8NhjWC4Y2D4Y3BsFYwvHUwvDUY1gmGdw6GdwbDesHw3sHw3mDYIBg+OBg+GAwbBcNHB8NHg2GTYPjkYPhkMGwWDJ8dDJ8Nhi2C4YuD4YvBsFUwfHUwfDUYtgmGbw6GbwbDdsHw3cHw3WDYIRh+OBh+GAw7BcM/DoZ/DIZdguGng+GnwbBbMPxyMPwyGPYIht8Oht8Gw17B8MfB8Mdg2CcYArT47xv+3Ydq2C8Y/nIw/GUwHBAMAR0MAQ2Gg4IhkIMhkMFwSDAEdjAENhgOC4YgDoYgBsMRwRDUwRDUYDgqGII5GIIZDMcEQ3AHQ3CD4bhgCOFgCGEwnBAMIR0MIQ2Gk4IhlIMhlMFwSjCEdjCENhhOC4YwDoYwBsMZwRDWwRDWYDgrGMI5GMIZDOcEQ3gHQ3iD4bxgiOBgiGAwXBAMER0MEQ2Gi4IhkoMhksFwSTBEdjBENhguC4YoDoYoBsMVwRDVwRDVYLgqGKI5GKIZDNcEQ3QHQ3SD4bpgiOFgiGEw3BAMMR0MMQ2Gm4IhloMhlsFwSzDEdjDENhhuC4Y4DoY4BsMdwRDXwRDXYLgrGOI5GOIZDPcEw98Ohr8NhvuCIb6DIb7B8EAwJHAwJDAYHgqGhA6GhAbDI8GQyMGQyGB4LBgSOxgSGwxPBEMSB0MSg+GpYEjqYEhqMDwTDMkcDMkMhueCIbmDIbnB8EIwpHAwpDAYXgqGlA6GlAbDK8GQysGQymB4LRhSOxhSGwxvBEMaB0Mag+GtYEjrYEhrMLwTDOkcDOkMhveCIb2DIb3B8EEwZHAwZDAYPgqGjA6GjAbDJ8GQycGQyWD4LBgyOxgyGwxfBEMWB0MWg+GrYMjqYMhqMHwTDNkcDNkMhu+CIbuDIbvB8EMw5HAw5DAY/hEMOR0MOQ2Gn4Ihl4Mhl8HwSzDkdjDkNhh+C4Y8DoY8BsMfwZDXwZDXYAgQ6T835HMw5DMY/hIM+R0M+Q2GgIKhgIOhgMEQSDAUdDAUNBgCC4ZCDoZCBkMQwVDYwVDYYAgqGIo4GIoYDMEEQ1EHQ1GDIbhgKOZgKGYwhBAMxR0MxQ2GkIKhhIOhhMEQSjCUdDCUNBhCC4ZSDoZSBkMYwVDawVDaYAgrGMo4GMoYDOEEQ1kHQ1mDIbxgKOdgKGcwRBAM5R0M5Q2GiIKhgoOhgsEQSTBUdDBUNBgiC4ZKDoZKBkMUwVDZwVDZYIgqGKo4GKoYDNEEQ1UHQ1WDIbpgqOZgqGYwxBAM1R0M1Q2GmIKhhoOhhsEQSzDUdDDUNBhiC4ZaDoZaBkMcwVDbwVDbYIgrGOo4GOoYDPEEQ10HQ12D4W/BUM/BUM9giC8Y6jsY6hsMCQRDAwdDA4MhoWBo6GBoaDAkEgyNHAyNDIbEgqGxg6GxwZBEMDRxMDQxGJIKhqYOhqYGQzLB0MzB0MxgSC4YmjsYmhsMKQRDCwdDC4MhpWBo6WBoaTCkEgytHAytDIbUgqG1g6G1wZBGMLRxMLQxGNIKhrYOhrYGQzrB0M7B0M5gSC8Y2jsY2hsMGQRDBwdDB4Mho2Do6GDoaDBkEgydHAydDIbMgqGzg6GzwZBFMHRxMHQxGLIKhq4Ohq4GQzbB0M3B0M1gyC4YujsYuhsMOQRDDwdDD4Mhp2Do6WDoaTDkEgy9HAy9DIbcgqG3g6G3wZBHMPRxMPQxGPIKhr4Ohr4GQz7B0M/B0M9gyC8Y+jsY+hsMBQTDAAfDAIOhoGAY6GAYaDAUEgyDHAyDDIbCgmGwg2GwwVBEMAxxMAwxGIoKhqEOhqEGQzHBMMzBMMxgKC4YhjsYhhsMJQTDCAfDCIOhpGAY6WAYaTCUEgyjHAyjDIbSgmG0g2G0wVBGMIxxMIwxGMoKhrEOhrEGQznBMM7BMM5gKC8YxjsYxhsMFQTDBAfDBIOhomCY6GCYaDBUEgyTHAyTDIbKgmGyg2GywVBFMExxMEwxGKoKhqkOhqkGQzXBMM3BMM1gqC4YpjsYphsMNQTDDAfDDIOhpmCY6WCYaTDUEgyzHAyzDIbagmG2g2G2wVBHMMxxMMwxGOoKhrkOhrkGQz3BMM/BMM9gqC8Y5jsY5hsMDQTDAgfDAoOhoWBY6GBYaDA0EgyLHAyLDIbGgmGxg2GxwdBEMCxxMCwxGJoKhqUOhqUGQzPBsMzBsMxgaC4YljsYlhsMLQTDCgfDCoOhpWBY6WBYaTC0EgyrHAyrDIbWgmG1g2G1wdBGMKxxMKwxGNoKhrUOhrUGQzvBsM7BsM5gaC8Y1jsY1hsMHQTDBgfDBoOho2DY6GDYaDB0EgybHAybDIbOgmGzg2GzwdBFMGxxMGwxGLoKhq0Ohq0GQzfBsM3BsM1g6C4YtjsYthsMPQTDDgfDDoOhp2DY6WDYaTD0Egy7HAy7DIbegmG3g2G3wdBHMOxxMOwxGPoKhr0Ohr0GQz/BsM/BsM9g6C8Y9jsY9hsMAwTDAQfDAYNhoGA46GA4aDAMEgyHHAyHDIbBguGwg+GwwTBEMBxxMBwxGIYKhqMOhqMGwzDBcMzBcMxgGC4YjjsYjhsMIwTDCQfDCYNhpGA46WA4aTCMEgynHAynDIbRguG0g+G0wTBGMJxxMJwxGMYKhrMOhrMGwzjBcM7BcM5gGC8YzjsYzhsMEwTDBQfDBYNhomC46GC4aDBMEgyXHAyXDIbJguGyg+GywTBFMFxxMFwxGKYKhqsOhqsGwzTBcM3BcM1gmC4YrjsYrhsMMwTDDQfDDYNhpmC46WC4aTDMEgy3HAy3DIbZguG2g+G2wTBHMNxxMNwxGOYKhrsOhrsGwzzBcM/BcM9gmC8Y7jsY7hsMCwTDAwfDA4NhoWB46GB4aDAsEgyPHAyPDIbFguGxg+GxwbBEMDxxMDwxGJYKhqcOhqcGwzLB8MzB8MxgWC4YnjsYnhsMKwTDCwfDC4NhpWB46WB4aTCsEgyvHAyvDIbVguG1g+G1wbBGMLxxMLwxGNYKhrcOhrcGwzrB8M7B8M5gWC8Y3jsY3hsMGwTDBwfDB4Nho2D46GD4aDBsEgyfHAyfDIbNguGzg+GzwbBFMHxxMHwxGLYKhq8Ohq8GwzbB8M3B8M1g2C4YvjsYvhsMOwTDDwfDD4Nhp2D4x8Hwj8GwSzD8dDD8NBh2C4ZfDoZfBsMewfDbwfDbYNgrGP44GP4YDPsEQ4CW/33Dv/tQDfsFw18Ohr8MhgOCIaCDIaDBcFAwBHIwBDIYDgmGwA6GwAbDYcEQxMEQxGA4IhiCOhiCGgxHBUMwB0Mwg+GYYAjuYAhuMBwXDCEcDCEMhhOCIaSDIaTBcFIwhHIwhDIYTgmG0A6G0AbDacEQxsEQxmA4IxjCOhjCGgxnBUM4B0M4g+GcYAjvYAhvMJwXDBEcDBEMhguCIaKDIaLBcFEwRHIwRDIYLgmGyA6GyAbDZcEQxcEQxWC4IhiiOhiiGgxXBUM0B0M0g+GaYIjuYIhuMFwXDDEcDDEMhhuCIaaDIabBcFMwxHIwxDIYbgmG2A6G2AbDbcEQx8EQx2C4IxjiOhjiGgx3BUM8B0M8g+GeYPjbwfC3wXBfMMR3MMQ3GB4IhgQOhgQGw0PBkNDBkNBgeCQYEjkYEhkMjwVDYgdDYoPhiWBI4mBIYjA8FQxJHQxJDYZngiGZgyGZwfBcMCR3MCQ3GF4IhhQOhhQGw0vBkNLBkNJgeCUYUjkYUhkMrwVDagdDaoPhjWBI42BIYzC8FQxpHQxpDYZ3giGdgyGdwfBeMKR3MKQ3GD4IhgwOhgwGw0fBkNHBkNFg+CQYMjkYMhkMnwVDZgdDZoPhi2DI4mDIYjB8FQxZHQxZDYZvgiGbgyGbwfBdMGR3MGQ3GH4IhhwOhhwGwz+CIaeDIafB8FMw5PovG35FCRDgf841Fh/3O8p/bsjtcBxyG47DH8GQx8GQx2AIEPU/N+R1MOQ1GP4SDPkcDPkMhoCCIb+DIb/BEEgwFHAwFDAYAguGgg6GggZDEMFQyMFQyGAIKhgKOxgKGwzBBEMRB0MRgyG4YCjqYChqMIQQDMUcDMUMhpCCobiDobjBEEowlHAwlDAYQguGkg6GkgZDGMFQysFQymAIKxhKOxhKGwzhBEMZB0MZgyG8YCjrYChrMEQQDOUcDOUMhoiCobyDobzBEEkwVHAwVDAYIguGig6GigZDFMFQycFQyWCIKhgqOxgqGwzRBEMVB0MVgyG6YKjqYKhqMMQQDNUcDNUMhpiCobqDobrBEEsw1HAw1DAYYguGmg6GmgZDHMFQy8FQy2CIKxhqOxhqGwzxBEMdB0Mdg+FvwVDXwVDXYIgvGOo5GOoZDAkEQ30HQ32DIaFgaOBgaGAwJBIMDR0MDQ2GxIKhkYOhkcGQRDA0djA0NhiSCoYmDoYmBkMywdDUwdDUYEguGJo5GJoZDCkEQ3MHQ3ODIaVgaOFgaGEwpBIMLR0MLQ2G1IKhlYOhlcGQRjC0djC0NhjSCoY2DoY2BkM6wdDWwdDWYEgvGNo5GNoZDBkEQ3sHQ3uDIaNg6OBg6GAwZBIMHR0MHQ2GzIKhk4Ohk8GQRTB0djB0NhiyCoYuDoYuBkM2wdDVwdDVYMguGLo5GLoZDDkEQ3cHQ3eDIadg6OFg6GEw5BIMPR0MPQ2G3IKhl4Ohl8GQRzD0djD0NhjyCoY+DoY+BkM+wdDXwdDXYMgvGPo5GPoZDAUEQ38HQ3+DoaBgGOBgGGAwFBIMAx0MAw2GwoJhkINhkMFQRDAMdjAMNhiKCoYhDoYhBkMxwTDUwTDUYCguGIY5GIYZDCUEw3AHw3CDoaRgGOFgGGEwlBIMIx0MIw2G0oJhlINhlMFQRjCMdjCMNhjKCoYxDoYxBkM5wTDWwTDWYCgvGMY5GMYZDBUEw3gHw3iDoaJgmOBgmGAwVBIMEx0MEw2GyoJhkoNhksFQRTBMdjBMNhiqCoYpDoYpBkM1wTDVwTDVYKguGKY5GKYZDDUEw3QHw3SDoaZgmOFgmGEw1BIMMx0MMw2G2oJhloNhlsFQRzDMdjDMNhjqCoY5DoY5BkM9wTDXwTDXYKgvGOY5GOYZDA0Ew3wHw3yDoaFgWOBgWGAwNBIMCx0MCw2GxoJhkYNhkcHQRDAsdjAsNhiaCoYlDoYlBkMzwbDUwbDUYGguGJY5GJYZDC0Ew3IHw3KDoaVgWOFgWGEwtBIMKx0MKw2G1oJhlYNhlcHQRjCsdjCsNhjaCoY1DoY1BkM7wbDWwbDWYGgvGNY5GNYZDB0Ew3oHw3qDoaNg2OBg2GAwdBIMGx0MGw2GzoJhk4Nhk8HQRTBsdjBsNhi6CoYtDoYtBkM3wbDVwbDVYOguGLY5GLYZDD0Ew3YHw3aDoadg2OFg2GEw9BIMOx0MOw2G3oJhl4Nhl8HQRzDsdjDsNhj6CoY9DoY9BkM/wbDXwbDXYOgvGPY5GPYZDAMEw34Hw36DYaBgOOBgOGAwDBIMBx0MBw2GwYLhkIPhkMEwRDAcdjAcNhiGCoYjDoYjBsMwwXDUwXDUYBguGI45GI4ZDCMEw3EHw3GDYaRgOOFgOGEwjBIMJx0MJw2G0YLhlIPhlMEwRjCcdjCcNhjGCoYzDoYzBsM4wXDWwXDWYBgvGM45GM4ZDBMEw3kHw3mDYaJguOBguGAwTBIMFx0MFw2GyYLhkoPhksEwRTBcdjBcNhimCoYrDoYrBsM0wXDVwXDVYJguGK45GK4ZDDMEw3UHw3WDYaZguOFguGEwzBIMNx0MNw2G2YLhloPhlsEwRzDcdjDcNhjmCoY7DoY7BsM8wXDXwXDXYJgvGO45GO4ZDAsEw30Hw32DYaFgeOBgeGAwLBIMDx0MDw2GxYLhkYPhkcGwRDA8djA8NhiWCoYnDoYnBsMywfDUwfDUYFguGJ45GJ4ZDCsEw3MHw3ODYaVgeOFgeGEwrBIMLx0MLw2G1YLhlYPhlcGwRjC8djC8NhjWCoY3DoY3BsM6wfDWwfDWYFgvGN45GN4ZDBsEw3sHw3uDYaNg+OBg+GAwbBIMHx0MHw2GzYLhk4Phk8GwRTB8djB8Nhi2CoYvDoYvBsM2wfDVwfDVYNguGL45GL4ZDDsEw3cHw3eDYadg+OFg+GEw7BIM/zgY/jEYdguGnw6GnwbDHsHwy8Hwy2DYKxh+Oxh+Gwz7BMMfB8Mfg2G/YAjQ6r9v+HcfquGAYPjLwfCXwXBQMAR0MAQ0GA4JhkAOhkAGw2HBENjBENhgOCIYgjgYghgMRwVDUAdDUIPhmGAI5mAIZjAcFwzBHQzBDYYTgiGEgyGEwXBSMIR0MIQ0GE4JhlAOhlAGw2nBENrBENpgOCMYwjgYwhgMZwVDWAdDWIPhnGAI52AIZzCcFwzhHQzhDYYLgiGCgyGCwXBRMER0MEQ0GC4JhkgOhkgGw2XBENnBENlguCIYojgYohgMVwVDVAdDVIPhmmCI5mCIZjBcFwzRHQzRDYYbgiGGgyGGwXBTMMR0MMQ0GG4JhlgOhlgGw23BENvBENtguCMY4jgY4hgMdwVDXAdDXIPhnmCI52CIZzDcFwx/Oxj+NhgeCIb4Dob4BsNDwZDAwZDAYHgkGBI6GBIaDI8FQyIHQyKD4YlgSOxgSGwwPBUMSRwMSQyGZ4IhqYMhqcHwXDAkczAkMxheCIbkDobkBsNLwZDCwZDCYHglGFI6GFIaDK8FQyoHQyqD4Y1gSO1gSG0wvBUMaRwMaQyGd4IhrYMhrcHwXjCkczCkMxg+CIb0Dob0BsNHwZDBwZDBYPgkGDI6GDIaDJ8FQyYHQyaD4YtgyOxgyGwwfBUMWRwMWQyGb4Ihq4Mhq8HwXTBkczBkMxh+CIbsDobsBsM/giGHgyGHwfBTMOR0MOQ0GH4JhlwOhlwGw2/BkNvBkNtg+CMY8jgY8hgMAaL954a8Doa8BsNfgiGfgyGfwRBQMOR3MOQ3GAIJhgIOhgIGQ2DBUNDBUNBgCCIYCjkYChkMQQVDYQdDYYMhmGAo4mAoYjAEFwxFHQxFDYYQgqGYg6GYwRBSMBR3MBQ3GEIJhhIOhhIGQ2jBUNLBUNJgCCMYSjkYShkMYQVDaQdDaYMhnGAo42AoYzCEFwxlHQxlDYYIgqGcg6GcwRBRMJR3MJQ3GCIJhgoOhgoGQ2TBUNHBUNFgiCIYKjkYKhkMUQVDZQdDZYMhmmCo4mCoYjBEFwxVHQxVDYYYgqGag6GawRBTMFR3MFQ3GGIJhhoOhhoGQ2zBUNPBUNNgiCMYajkYahkMcQVDbQdDbYMhnmCo42CoYzD8LRjqOhjqGgzxBUM9B0M9gyGBYKjvYKhvMCQUDA0cDA0MhkSCoaGDoaHBkFgwNHIwNDIYkgiGxg6GxgZDUsHQxMHQxGBIJhiaOhiaGgzJBUMzB0MzgyGFYGjuYGhuMKQUDC0cDC0MhlSCoaWDoaXBkFowtHIwtDIY0giG1g6G1gZDWsHQxsHQxmBIJxjaOhjaGgzpBUM7B0M7gyGDYGjvYGhvMGQUDB0cDB0MhkyCoaODoaPBkFkwdHIwdDIYsgiGzg6GzgZDVsHQxcHQxWDIJhi6Ohi6GgzZBUM3B0M3gyGHYOjuYOhuMOQUDD0cDD0MhlyCoaeDoafBkFsw9HIw9DIY8giG3g6G3gZDXsHQx8HQx2DIJxj6Ohj6Ggz5BUM/B0M/g6GAYOjvYOhvMBQUDAMcDAMMhkKCYaCDYaDBUFgwDHIwDDIYigiGwQ6GwQZDUcEwxMEwxGAoJhiGOhiGGgzFBcMwB8Mwg6GEYBjuYBhuMJQUDCMcDCMMhlKCYaSDYaTBUFowjHIwjDIYygiG0Q6G0QZDWcEwxsEwxmAoJxjGOhjGGgzlBcM4B8M4g6GCYBjvYBhvMFQUDBMcDBMMhkqCYaKDYaLBUFkwTHIwTDIYqgiGyQ6GyQZDVcEwxcEwxWCoJhimOhimGgzVBcM0B8M0g6GGYJjuYJhuMNQUDDMcDDMMhlqCYaaDYabBUFswzHIwzDIY6giG2Q6G2QZDXcEwx8Ewx2CoJxjmOhjmGgz1BcM8B8M8g6GBYJjvYJhvMDQUDAscDAsMhkaCYaGDYaHB0FgwLHIwLDIYmgiGxQ6GxQZDU8GwxMGwxGBoJhiWOhiWGgzNBcMyB8Myg6GFYFjuYFhuMLQUDCscDCsMhlaCYaWDYaXB0FowrHIwrDIY2giG1Q6G1QZDW8GwxsGwxmBoJxjWOhjWGgztBcM6B8M6g6GDYFjvYFhvMHQUDBscDBsMhk6CYaODYaPB0FkwbHIwbDIYugiGzQ6GzQZDV8GwxcGwxWDoJhi2Ohi2GgzdBcM2B8M2g6GHYNjuYNhuMPQUDDscDDsMhl6CYaeDYafB0Fsw7HIw7DIY+giG3Q6G3QZDX8Gwx8Gwx2DoJxj2Ohj2Ggz9BcM+B8M+g2GAYNjvYNhvMAwUDAccDAcMhkGC4aCD4aDBMFgwHHIwHDIYhgiGww6GwwbDUMFwxMFwxGAYJhiOOhiOGgzDBcMxB8Mxg2GEYDjuYDhuMIwUDCccDCcMhlGC4aSD4aTBMFownHIwnDIYxgiG0w6G0wbDWMFwxsFwxmAYJxjOOhjOGgzjBcM5B8M5g2GCYDjvYDhvMEwUDBccDBcMhkmC4aKD4aLBMFkwXHIwXDIYpgiGyw6GywbDVMFwxcFwxWCYJhiuOhiuGgzTBcM1B8M1g2GGYLjuYLhuMMwUDDccDDcMhlmC4aaD4abBMFsw3HIw3DIY5giG2w6G2wbDXMFwx8Fwx2CYJxjuOhjuGgzzBcM9B8M9g2GBYLjvYLhvMCwUDA8cDA8MhkWC4aGD4aHBsFgwPHIwPDIYlgiGxw6GxwbDUsHwxMHwxGBYJhieOhieGgzLBcMzB8Mzg2GFYHjuYHhuMKwUDC8cDC8MhlWC4aWD4aXBsFowvHIwvDIY1giG1w6G1wbDWsHwxsHwxmBYJxjeOhjeGgzrBcM7B8M7g2GDYHjvYHhvMGwUDB8cDB8Mhk2C4aOD4aPBsFkwfHIwfDIYtgiGzw6GzwbDVsHwxcHwxWDYJhi+Ohi+GgzbBcM3B8M3g2GHYPjuYPhuMOwUDD8cDD8Mhl2C4R8Hwz8Gw27B8NPB8NNg2CMYfjkYfhkMewXDbwfDb4Nhn2D442D4YzDsFwwBWv/3Df/uQzUcEAx/ORj+MhgOCoaADoaABsMhwRDIwRDIYDgsGAI7GAIbDEcEQxAHQxCD4ahgCOpgCGowHBMMwRwMwQyG44IhuIMhuMFwQjCEcDCEMBhOCoaQDoaQBsMpwRDKwRDKYDgtGEI7GEIbDGcEQxgHQxiD4axgCOtgCGswnBMM4RwM4QyG84IhvIMhvMFwQTBEcDBEMBguCoaIDoaIBsMlwRDJwRDJYLgsGCI7GCIbDFcEQxQHQxSD4apgiOpgiGowXBMM0RwM0QyG64IhuoMhusFwQzDEcDDEMBhuCoaYDoaYBsMtwRDLwRDLYLgtGGI7GGIbDHcEQxwHQxyD4a5giOtgiGsw3BMM8RwM8QyG+4LhbwfD3wbDA8EQ38EQ32B4KBgSOBgSGAyPBENCB0NCg+GxYEjkYEhkMDwRDIkdDIkNhqeCIYmDIYnB8EwwJHUwJDUYnguGZA6GZAbDC8GQ3MGQ3GB4KRhSOBhSGAyvBENKB0NKg+G1YEjlYEhlMLwRDKkdDKkNhreCIY2DIY3B8E4wpHUwpDUY3guGdA6GdAbDB8GQ3sGQ3mD4KBgyOBgyGAyfBENGB0NGg+GzYMjkYMhkMHwRDJkdDJkNhq+CIYuDIYvB8E0wZHUwZDUYvguGbA6GbAbDD8GQ/b9s+BkjQID/OT9UfNyvGP+5IYfDcchhOA6/BUNOB0NOg+GPYMjlYMhlMASI+Z8bcjsYchsMfwmGPA6GPAZDQMGQ18GQ12AIJBjyORjyGQyBBUN+B0N+gyGIYCjgYChgMAQVDAUdDAUNhmCCoZCDoZDBEFwwFHYwFDYYQgiGIg6GIgZDSMFQ1MFQ1GAIJRiKORiKGQyhBUNxB0NxgyGMYCjhYChhMIQVDCUdDCUNhnCCoZSDoZTBEF4wlHYwlDYYIgiGMg6GMgZDRMFQ1sFQ1mCIJBjKORjKGQyRBUN5B0N5gyGKYKjgYKhgMEQVDBUdDBUNhmiCoZKDoZLBEF0wVHYwVDYYYgiGKg6GKgZDTMFQ1cFQ1WCIJRiqORiqGQyxBUN1B0N1gyGOYKjhYKhhMMQVDDUdDDUNhniCoZaDoZbB8LdgqO1gqG0wxBcMdRwMdQyGBIKhroOhrsGQUDDUczDUMxgSCYb6Dob6BkNiwdDAwdDAYEgiGBo6GBoaDEkFQyMHQyODIZlgaOxgaGwwJBcMTRwMTQyGFIKhqYOhqcGQUjA0czA0MxhSCYbmDobmBkNqwdDCwdDCYEgjGFo6GFoaDGkFQysHQyuDIZ1gaO1gaG0wpBcMbRwMbQyGDIKhrYOhrcGQUTC0czC0MxgyCYb2Dob2BkNmwdDBwdDBYMgiGDo6GDoaDFkFQycHQyeDIZtg6Oxg6GwwZBcMXRwMXQyGHIKhq4Ohq8GQUzB0czB0MxhyCYbuDobuBkNuwdDDwdDDYMgjGHo6GHoaDHkFQy8HQy+DIZ9g6O1g6G0w5BcMfRwMfQyGAoKhr4Ohr8FQUDD0czD0MxgKCYb+Dob+BkNhwTDAwTDAYCgiGAY6GAYaDEUFwyAHwyCDoZhgGOxgGGwwFBcMQxwMQwyGEoJhqINhqMFQUjAMczAMMxhKCYbhDobhBkNpwTDCwTDCYCgjGEY6GEYaDGUFwygHwyiDoZxgGO1gGG0wlBcMYxwMYwyGCoJhrINhrMFQUTCMczCMMxgqCYbxDobxBkNlwTDBwTDBYKgiGCY6GCYaDFUFwyQHwySDoZpgmOxgmGwwVBcMUxwMUwyGGoJhqoNhqsFQUzBMczBMMxhqCYbpDobpBkNtwTDDwTDDYKgjGGY6GGYaDHUFwywHwyyDoZ5gmO1gmG0w1BcMcxwMcwyGBoJhroNhrsHQUDDMczDMMxgaCYb5Dob5BkNjwbDAwbDAYGgiGBY6GBYaDE0FwyIHwyKDoZlgWOxgWGwwNBcMSxwMSwyGFoJhqYNhqcHQUjAsczAsMxhaCYblDoblBkNrwbDCwbDCYGgjGFY6GFYaDG0FwyoHwyqDoZ1gWO1gWG0wtBcMaxwMawyGDoJhrYNhrcHQUTCsczCsMxg6CYb1Dob1BkNnwbDBwbDBYOgiGDY6GDYaDF0FwyYHwyaDoZtg2Oxg2GwwdBcMWxwMWwyGHoJhq4Nhq8HQUzBsczBsMxh6CYbtDobtBkNvwbDDwbDDYOgjGHY6GHYaDH0Fwy4Hwy6DoZ9g2O1g2G0w9BcMexwMewyGAYJhr4Nhr8EwUDDsczDsMxgGCYb9Dob9BsNgwXDAwXDAYBgiGA46GA4aDEMFwyEHwyGDYZhgOOxgOGwwDBcMRxwMRwyGEYLhqIPhqMEwUjAcczAcMxhGCYbjDobjBsNowXDCwXDCYBgjGE46GE4aDGMFwykHwymDYZxgOO1gOG0wjBcMZxwMZwyGCYLhrIPhrMEwUTCcczCcMxgmCYbzDobzBsNkwXDBwXDBYJgiGC46GC4aDFMFwyUHwyWDYZpguOxguGwwTBcMVxwMVwyGGYLhqoPhqsEwUzBcczBcMxhmCYbrDobrBsNswXDDwXDDYJgjGG46GG4aDHMFwy0Hwy2DYZ5guO1guG0wzBcMdxwMdwyGBYLhroPhrsGwUDDcczDcMxgWCYb7Dob7BsNiwfDAwfDAYFgiGB46GB4aDEsFwyMHwyODYZlgeOxgeGwwLBcMTxwMTwyGFYLhqYPhqcGwUjA8czA8MxhWCYbnDobnBsNqwfDCwfDCYFgjGF46GF4aDGsFwysHwyuDYZ1geO1geG0wrBcMbxwMbwyGDYLhrYPhrcGwUTC8czC8Mxg2CYb3Dob3BsNmwfDBwfDBYNgiGD46GD4aDFsFwycHwyeDYZtg+Oxg+GwwbBcMXxwMXwyGHYLhq4Phq8GwUzB8czB8Mxh2CYbvDobvBsNuwfDDwfDDYNgjGP5xMPxjMOwVDD8dDD8Nhn2C4ZeD4ZfBsF8w/HYw/DYYDgiGPw6GPwbDQcEQoM1/3/DvPlTDIcHwl4PhL4PhsGAI6GAIaDAcEQyBHAyBDIajgiGwgyGwwXBMMARxMAQxGI4LhqAOhqAGwwnBEMzBEMxgOCkYgjsYghsMpwRDCAdDCIPhtGAI6WAIaTCcEQyhHAyhDIazgiG0gyG0wXBOMIRxMIQxGM4LhrAOhrAGwwXBEM7BEM5guCgYwjsYwhsMlwRDBAdDBIPhsmCI6GCIaDBcEQyRHAyRDIargiGygyGywXBNMERxMEQxGK4LhqgOhqgGww3BEM3BEM1guCkYojsYohsMtwRDDAdDDIPhtmCI6WCIaTDcEQyxHAyxDIa7giG2gyG2wXBPMMRxMMQxGO4LhrgOhrgGwwPBEM/BEM9geCgY/nYw/G0wPBIM8R0M8Q2Gx4IhgYMhgcHwRDAkdDAkNBieCoZEDoZEBsMzwZDYwZDYYHguGJI4GJIYDC8EQ1IHQ1KD4aVgSOZgSGYwvBIMyR0MyQ2G14IhhYMhhcHwRjCkdDCkNBjeCoZUDoZUBsM7wZDawZDaYHgvGNI4GNIYDB8EQ1oHQ1qD4aNgSOdgSGcwfBIM6R0M6Q2Gz4Ihg4Mhg8HwRTBkdDBkNBi+CoZMDoZMBsM3wZDZwZDZYPguGLI4GLIYDD8EQ1YHQ1aD4R/BkM3BkM1g+CkYsjsYshsMvwRDDgdDDoPht2DI6WDIaTD8EQy5HAy5DIYAsf5zQ24HQ26D4S/BkMfBkMdgCCgY8joY8hoMgQRDPgdDPoMhsGDI72DIbzAEEQwFHAwFDIaggqGgg6GgwRBMMBRyMBQyGIILhsIOhsIGQwjBUMTBUMRgCCkYijoYihoMoQRDMQdDMYMhtGAo7mAobjCEEQwlHAwlDIawgqGkg6GkwRBOMJRyMJQyGMILhtIOhtIGQwTBUMbBUMZgiCgYyjoYyhoMkQRDOQdDOYMhsmAo72AobzBEEQwVHAwVDIaogqGig6GiwRBNMFRyMFQyGKILhsoOhsoGQwzBUMXBUMVgiCkYqjoYqhoMsQRDNQdDNYMhtmCo7mCobjDEEQw1HAw1DIa4gqGmg6GmwRBPMNRyMNQyGP4WDLUdDLUNhviCoY6DoY7BkEAw1HUw1DUYEgqGeg6GegZDIsFQ38FQ32BILBgaOBgaGAxJBENDB0NDgyGpYGjkYGhkMCQTDI0dDI0NhuSCoYmDoYnBkEIwNHUwNDUYUgqGZg6GZgZDKsHQ3MHQ3GBILRhaOBhaGAxpBENLB0NLgyGtYGjlYGhlMKQTDK0dDK0NhvSCoY2DoY3BkEEwtHUwtDUYMgqGdg6GdgZDJsHQ3sHQ3mDILBg6OBg6GAxZBENHB0NHgyGrYOjkYOhkMGQTDJ0dDJ0NhuyCoYuDoYvBkEMwdHUwdDUYcgqGbg6GbgZDLsHQ3cHQ3WDILRh6OBh6GAx5BENPB0NPgyGvYOjlYOhlMOQTDL0dDL0NhvyCoY+DoY/BUEAw9HUw9DUYCgqGfg6GfgZDIcHQ38HQ32AoLBgGOBgGGAxFBMNAB8NAg6GoYBjkYBhkMBQTDIMdDIMNhuKCYYiDYYjBUEIwDHUwDDUYSgqGYQ6GYQZDKcEw3MEw3GAoLRhGOBhGGAxlBMNIB8NIg6GsYBjlYBhlMJQTDKMdDKMNhvKCYYyDYYzBUEEwjHUwjDUYKgqGcQ6GcQZDJcEw3sEw3mCoLBgmOBgmGAxVBMNEB8NEg6GqYJjkYJhkMFQTDJMdDJMNhuqCYYqDYYrBUEMwTHUwTDUYagqGaQ6GaQZDLcEw3cEw3WCoLRhmOBhmGAx1BMNMB8NMg6GuYJjlYJhlMNQTDLMdDLMNhvqCYY6DYY7B0EAwzHUwzDUYGgqGeQ6GeQZDI8Ew38Ew32BoLBgWOBgWGAxNBMNCB8NCg6GpYFjkYFhkMDQTDIsdDIsNhuaCYYmDYYnB0EIwLHUwLDUYWgqGZQ6GZQZDK8Gw3MGw3GBoLRhWOBhWGAxtBMNKB8NKg6GtYFjlYFhlMLQTDKsdDKsNhvaCYY2DYY3B0EEwrHUwrDUYOgqGdQ6GdQZDJ8Gw3sGw3mDoLBg2OBg2GAxdBMNGB8NGg6GrYNjkYNhkMHQTDJsdDJsNhu6CYYuDYYvB0EMwbHUwbDUYegqGbQ6GbQZDL8Gw3cGw3WDoLRh2OBh2GAx9BMNOB8NOg6GvYNjlYNhlMPQTDLsdDLsNhv6CYY+DYY/BMEAw7HUw7DUYBgqGfQ6GfQbDIMGw38Gw32AYLBgOOBgOGAxDBMNBB8NBg2GoYDjkYDhkMAwTDIcdDIcNhuGC4YiD4YjBMEIwHHUwHDUYRgqGYw6GYwbDKMFw3MFw3GAYLRhOOBhOGAxjBMNJB8NJg2GsYDjlYDhlMIwTDKcdDKcNhvGC4YyD4YzBMEEwnHUwnDUYJgqGcw6GcwbDJMFw3sFw3mCYLBguOBguGAxTBMNFB8NFg2GqYLjkYLhkMEwTDJcdDJcNhumC4YqD4YrBMEMwXHUwXDUYZgqGaw6GawbDLMFw3cFw3WCYLRhuOBhuGAxzBMNNB8NNg2GuYLjlYLhlMMwTDLcdDLcNhvmC4Y6D4Y7BsEAw3HUw3DUYFgqGew6GewbDIsFw38Fw32BYLBgeOBgeGAxLBMNDB8NDg2GpYHjkYHhkMCwTDI8dDI8NhuWC4YmD4YnBsEIwPHUwPDUYVgqGZw6GZwbDKsHw3MHw3GBYLRheOBheGAxrBMNLB8NLg2GtYHjlYHhlMKwTDK8dDK8NhvWC4Y2D4Y3BsEEwvHUwvDUYNgqGdw6GdwbDJsHw3sHw3mDYLBg+OBg+GAxbBMNHB8NHg2GrYPjkYPhkMGwTDJ8dDJ8Nhu2C4YuD4YvBsEMwfHUwfDUYdgqGbw6GbwbDLsHw3cHw3WDYLRh+OBh+GAx7BMM/DoZ/DIa9guGng+GnwbBPMPxyMPwyGPYLht8Oht8GwwHB8MfB8MdgOCgYArT97xv+3YdqOCQY/nIw/GUwHBYMAR0MAQ2GI4IhkIMhkMFwVDAEdjAENhiOCYYgDoYgBsNxwRDUwRDUYDghGII5GIIZDCcFQ3AHQ3CD4ZRgCOFgCGEwnBYMIR0MIQ2GM4IhlIMhlMFwVjCEdjCENhjOCYYwDoYwBsN5wRDWwRDWYLggGMI5GMIZDBcFQ3gHQ3iD4ZJgiOBgiGAwXBYMER0MEQ2GK4IhkoMhksFwVTBEdjBENhiuCYYoDoYoBsN1wRDVwRDVYLghGKI5GKIZDDcFQ3QHQ3SD4ZZgiOFgiGEw3BYMMR0MMQ2GO4IhloMhlsFwVzDEdjDENhjuCYY4DoY4BsN9wRDXwRDXYHggGOI5GOIZDA8Fw98Ohr8NhkeCIb6DIb7B8FgwJHAwJDAYngiGhA6GhAbDU8GQyMGQyGB4JhgSOxgSGwzPBUMSB0MSg+GFYEjqYEhqMLwUDMkcDMkMhleCIbmDIbnB8FowpHAwpDAY3giGlA6GlAbDW8GQysGQymB4JxhSOxhSGwzvBUMaB0Mag+GDYEjrYEhrMHwUDOkcDOkMhk+CIb2DIb3B8FkwZHAwZDAYvgiGjA6GjAbDV8GQycGQyWD4JhgyOxgyGwzfBUMWB0MWg+GHYMj6Xzb8jBMgwP+clyg+7lec/9yQzeE4ZDMch9+CIbuDIbvB8Ecw5HAw5DAYAsT9zw05HQw5DYa/BEMuB0MugyGgYMjtYMhtMAQSDHkcDHkMhsCCIa+DIa/BEEQw5HMw5DMYggqG/A6G/AZDMMFQwMFQwGAILhgKOhgKGgwhBEMhB0MhgyGkYCjsYChsMIQSDEUcDEUMhtCCoaiDoajBEEYwFHMwFDMYwgqG4g6G4gZDOMFQwsFQwmAILxhKOhhKGgwRBEMpB0MpgyGiYCjtYChtMEQSDGUcDGUMhsiCoayDoazBEEUwlHMwlDMYogqG8g6G8gZDNMFQwcFQwWCILhgqOhgqGgwxBEMlB0MlgyGmYKjsYKhsMMQSDFUcDFUMhtiCoaqDoarBEEcwVHMwVDMY4gqG6g6G6gZDPMFQw8FQw2D4WzDUdDDUNBjiC4ZaDoZaBkMCwVDbwVDbYEgoGOo4GOoYDIkEQ10HQ12DIbFgqOdgqGcwJBEM9R0M9Q2GpIKhgYOhgcGQTDA0dDA0NBiSC4ZGDoZGBkMKwdDYwdDYYEgpGJo4GJoYDKkEQ1MHQ1ODIbVgaOZgaGYwpBEMzR0MzQ2GtIKhhYOhhcGQTjC0dDC0NBjSC4ZWDoZWBkMGwdDawdDaYMgoGNo4GNoYDJkEQ1sHQ1uDIbNgaOdgaGcwZBEM7R0M7Q2GrIKhg4Ohg8GQTTB0dDB0NBiyC4ZODoZOBkMOwdDZwdDZYMgpGLo4GLoYDLkEQ1cHQ1eDIbdg6OZg6GYw5BEM3R0M3Q2GvIKhh4Ohh8GQTzD0dDD0NBjyC4ZeDoZeBkMBwdDbwdDbYCgoGPo4GPoYDIUEQ18HQ1+DobBg6Odg6GcwFBEM/R0M/Q2GooJhgINhgMFQTDAMdDAMNBiKC4ZBDoZBBkMJwTDYwTDYYCgpGIY4GIYYDKUEw1AHw1CDobRgGOZgGGYwlBEMwx0Mww2GsoJhhINhhMFQTjCMdDCMNBjKC4ZRDoZRBkMFwTDawTDaYKgoGMY4GMYYDJUEw1gHw1iDobJgGOdgGGcwVBEM4x0M4w2GqoJhgoNhgsFQTTBMdDBMNBiqC4ZJDoZJBkMNwTDZwTDZYKgpGKY4GKYYDLUEw1QHw1SDobZgmOZgmGYw1BEM0x0M0w2GuoJhhoNhhsFQTzDMdDDMNBjqC4ZZDoZZBkMDwTDbwTDbYGgoGOY4GOYYDI0Ew1wHw1yDobFgmOdgmGcwNBEM8x0M8w2GpoJhgYNhgcHQTDAsdDAsNBiaC4ZFDoZFBkMLwbDYwbDYYGgpGJY4GJYYDK0Ew1IHw1KDobVgWOZgWGYwtBEMyx0Myw2GtoJhhYNhhcHQTjCsdDCsNBjaC4ZVDoZVBkMHwbDawbDaYOgoGNY4GNYYDJ0Ew1oHw1qDobNgWOdgWGcwdBEM6x0M6w2GroJhg4Nhg8HQTTBsdDBsNBi6C4ZNDoZNBkMPwbDZwbDZYOgpGLY4GLYYDL0Ew1YHw1aDobdg2OZg2GYw9BEM2x0M2w2GvoJhh4Nhh8HQTzDsdDDsNBj6C4ZdDoZdBsMAwbDbwbDbYBgoGPY4GPYYDIMEw14Hw16DYbBg2Odg2GcwDBEM+x0M+w2GoYLhgIPhgMEwTDAcdDAcNBiGC4ZDDoZDBsMIwXDYwXDYYBgpGI44GI4YDKMEw1EHw1GDYbRgOOZgOGYwjBEMxx0Mxw2GsYLhhIPhhMEwTjCcdDCcNBjGC4ZTDoZTBsMEwXDawXDaYJgoGM44GM4YDJMEw1kHw1mDYbJgOOdgOGcwTBEM5x0M5w2GqYLhgoPhgsEwTTBcdDBcNBimC4ZLDoZLBsMMwXDZwXDZYJgpGK44GK4YDLMEw1UHw1WDYbZguOZguGYwzBEM1x0M1w2GuYLhhoPhhsEwTzDcdDDcNBjmC4ZbDoZbBsMCwXDbwXDbYFgoGO44GO4YDIsEw10Hw12DYbFguOdguGcwLBEM9x0M9w2GpYLhgYPhgcGwTDA8dDA8NBiWC4ZHDoZHBsMKwfDYwfDYYFgpGJ44GJ4YDKsEw1MHw1ODYbVgeOZgeGYwrBEMzx0Mzw2GtYLhhYPhhcGwTjC8dDC8NBjWC4ZXDoZXBsMGwfDawfDaYNgoGN44GN4YDJsEw1sHw1uDYbNgeOdgeGcwbBEM7x0M7w2GrYLhg4Phg8GwTTB8dDB8NBi2C4ZPDoZPBsMOwfDZwfDZYNgpGL44GL4YDLsEw1cHw1eDYbdg+OZg+GYw7BEM3x0M3w2GvYLhh4Phh8GwTzD842D4x2DYLxh+Ohh+GgwHBMMvB8Mvg+GgYPjtYPhtMBwSDH8cDH8MhsOCIUC7/77h332ohiOC4S8Hw18Gw1HBENDBENBgOCYYAjkYAhkMxwVDYAdDYIPhhGAI4mAIYjCcFAxBHQxBDYZTgiGYgyGYwXBaMAR3MAQ3GM4IhhAOhhAGw1nBENLBENJgOCcYQjkYQhkM5wVDaAdDaIPhgmAI42AIYzBcFAxhHQxhDYZLgiGcgyGcwXBZMIR3MIQ3GK4IhggOhggGw1XBENHBENFguCYYIjkYIhkM1wVDZAdDZIPhhmCI4mCIYjDcFAxRHQxRDYZbgiGagyGawXBbMER3MEQ3GO4IhhgOhhgGw13BENPBENNguCcYYjkYYhkM9wVDbAdDbIPhgWCI42CIYzA8FAxxHQxxDYZHgiGegyGewfBYMPztYPjbYHgiGOI7GOIbDE8FQwIHQwKD4ZlgSOhgSGgwPBcMiRwMiQyGF4IhsYMhscHwUjAkcTAkMRheCYakDoakBsNrwZDMwZDMYHgjGJI7GJIbDG8FQwoHQwqD4Z1gSOlgSGkwvBcMqRwMqQyGD4IhtYMhtcHwUTCkcTCkMRg+CYa0Doa0BsNnwZDOwZDOYPgiGNI7GNIbDF8FQwYHQwaD4ZtgyOhgyGgwfBcMmRwMmQyGH4Ihs4Mhs8Hwj2DI4mDIYjD8FAxZHQxZDYZfgiGbgyGbwfBbMGR3MGQ3GP4IhhwOhhwGQ4B4/7khp4Mhp8Hwl2DI5WDIZTAEFAy5HQy5DYZAgiGPgyGPwRBYMOR1MOQ1GIIIhnwOhnwGQ1DBkN/BkN9gCCYYCjgYChgMwQVDQQdDQYMhhGAo5GAoZDCEFAyFHQyFDYZQgqGIg6GIwRBaMBR1MBQ1GMIIhmIOhmIGQ1jBUNzBUNxgCCcYSjgYShgM4QVDSQdDSYMhgmAo5WAoZTBEFAylHQylDYZIgqGMg6GMwRBZMJR1MJQ1GKIIhnIOhnIGQ1TBUN7BUN5giCYYKjgYKhgM0QVDRQdDRYMhhmCo5GCoZDDEFAyVHQyVDYZYgqGKg6GKwRBbMFR1MFQ1GOIIhmoOhmoGQ1zBUN3BUN1giCcYajgYahgMfwuGmg6GmgZDfMFQy8FQy2BIIBhqOxhqGwwJBUMdB0MdgyGRYKjrYKhrMCQWDPUcDPUMhiSCob6Dob7BkFQwNHAwNDAYkgmGhg6GhgZDcsHQyMHQyGBIIRgaOxgaGwwpBUMTB0MTgyGVYGjqYGhqMKQWDM0cDM0MhjSCobmDobnBkFYwtHAwtDAY0gmGlg6GlgZDesHQysHQymDIIBhaOxhaGwwZBUMbB0MbgyGTYGjrYGhrMGQWDO0cDO0MhiyCob2Dob3BkFUwdHAwdDAYsgmGjg6GjgZDdsHQycHQyWDIIRg6Oxg6Gww5BUMXB0MXgyGXYOjqYOhqMOQWDN0cDN0MhjyCobuDobvBkFcw9HAw9DAY8gmGng6GngZDfsHQy8HQy2AoIBh6Oxh6GwwFBUMfB0Mfg6GQYOjrYOhrMBQWDP0cDP0MhiKCob+Dob/BUFQwDHAwDDAYigmGgQ6GgQZDccEwyMEwyGAoIRgGOxgGGwwlBcMQB8MQg6GUYBjqYBhqMJQWDMMcDMMMhjKCYbiDYbjBUFYwjHAwjDAYygmGkQ6GkQZDecEwysEwymCoIBhGOxhGGwwVBcMYB8MYg6GSYBjrYBhrMFQWDOMcDOMMhiqCYbyDYbzBUFUwTHAwTDAYqgmGiQ6GiQZDdcEwycEwyWCoIRgmOxgmGww1BcMUB8MUg6GWYJjqYJhqMNQWDNMcDNMMhjqCYbqDYbrBUFcwzHAwzDAY6gmGmQ6GmQZDfcEwy8Ewy2BoIBhmOxhmGwwNBcMcB8Mcg6GRYJjrYJhrMDQWDPMcDPMMhiaCYb6DYb7B0FQwLHAwLDAYmgmGhQ6GhQZDc8GwyMGwyGBoIRgWOxgWGwwtBcMSB8MSg6GVYFjqYFhqMLQWDMscDMsMhjaCYbmDYbnB0FYwrHAwrDAY2gmGlQ6GlQZDe8GwysGwymDoIBhWOxhWGwwdBcMaB8Mag6GTYFjrYFhrMHQWDOscDOsMhi6CYb2DYb3B0FUwbHAwbDAYugmGjQ6GjQZDd8GwycGwyWDoIRg2Oxg2Gww9BcMWB8MWg6GXYNjqYNhqMPQWDNscDNsMhj6CYbuDYbvB0Fcw7HAw7DAY+gmGnQ6GnQZDf8Gwy8Gwy2AYIBh2Oxh2GwwDBcMeB8Meg2GQYNjrYNhrMAwWDPscDPsMhiGCYb+DYb/BMFQwHHAwHDAYhgmGgw6GgwbDcMFwyMFwyGAYIRgOOxgOGwwjBcMRB8MRg2GUYDjqYDhqMIwWDMccDMcMhjGC4biD4bjBMFYwnHAwnDAYxgmGkw6GkwbDeMFwysFwymCYIBhOOxhOGwwTBcMZB8MZg2GSYDjrYDhrMEwWDOccDOcMhimC4byD4bzBMFUwXHAwXDAYpgmGiw6GiwbDdMFwycFwyWCYIRguOxguGwwzBcMVB8MVg2GWYLjqYLhqMMwWDNccDNcMhjmC4bqD4brBMFcw3HAw3DAY5gmGmw6GmwbDfMFwy8Fwy2BYIBhuOxhuGwwLBcMdB8Mdg2GRYLjrYLhrMCwWDPccDPcMhiWC4b6D4b7BsFQwPHAwPDAYlgmGhw6GhwbDcsHwyMHwyGBYIRgeOxgeGwwrBcMTB8MTg2GVYHjqYHhqMKwWDM8cDM8MhjWC4bmD4bnBsFYwvHAwvDAY1gmGlw6GlwbDesHwysHwymDYIBheOxheGwwbBcMbB8Mbg2GTYHjrYHhrMGwWDO8cDO8Mhi2C4b2D4b3BsFUwfHAwfDAYtgmGjw6GjwbDdsHwycHwyWDYIRg+Oxg+Gww7BcMXB8MXg2GXYPjqYPhqMOwWDN8cDN8Mhj2C4buD4bvBsFcw/HAw/DAY9gmGfxwM/xgM+wXDTwfDT4PhgGD45WD4ZTAcFAy/HQy/DYZDguGPg+GPwXBYMARo/983/LsP1XBEMPzlYPjLYDgqGAI6GAIaDMcEQyAHQyCD4bhgCOxgCGwwnBAMQRwMQQyGk4IhqIMhqMFwSjAEczAEMxhOC4bgDobgBsMZwRDCwRDCYDgrGEI6GEIaDOcEQygHQyiD4bxgCO1gCG0wXBAMYRwMYQyGi4IhrIMhrMFwSTCEczCEMxguC4bwDobwBsMVwRDBwRDBYLgqGCI6GCIaDNcEQyQHQySD4bpgiOxgiGww3BAMURwMUQyGm4IhqoMhqsFwSzBEczBEMxhuC4boDoboBsMdwRDDwRDDYLgrGGI6GGIaDPcEQywHQyyD4b5giO1giG0wPBAMcRwMcQyGh4IhroMhrsHwSDDEczDEMxgeC4a/HQx/GwxPBEN8B0N8g+GpYEjgYEhgMDwTDAkdDAkNhueCIZGDIZHB8EIwJHYwJDYYXgqGJA6GJAbDK8GQ1MGQ1GB4LRiSORiSGQxvBENyB0Nyg+GtYEjhYEhhMLwTDCkdDCkNhveCIZWDIZXB8EEwpHYwpDYYPgqGNA6GNAbDJ8GQ1sGQ1mD4LBjSORjSGQxfBEN6B0N6g+GrYMjgYMhgMHwTDBkdDBkNhu+CIZODIZPB8EMwZHYw/M85ff9/j/s/rSvLf3ld/27/39R1Zf0vr+vf7Wc1rCvbf3ld/24/m2Fd2f/L6/p3+9kN68rxX17Xv9vPYVhXzv/yuv7dfk7DunL9l9f17/ZzGdaV+//luv5P2//3tatgw//na/D/8Xz1QP/55+ZxeA3O21T/PvIn2H9uyOtgyN5aN/wT7T835PsvG/59ruY2PMfz/+fr+p9NBxG3/+/XNn/j/+jzB74LtO9/Pj9XS+3YZW2rzcP/7/PpPzlu/36NAonuP0H+c/OvSMJzLpb2PFJfW/7v16S//7PN/8/XP3P7/3evYf+nffwTTzP/3//Uef6p/N6xmM+afglrKlPKZ02/lfdMi//na/oZ63//E5idUEAKRIEpCAWlYBScQlBICkWhKQyFpXAUniJQRIpEkSkKRaVoFJ1iUEyKRbEpDsWlePQ3xacElJASUWJKQkkpGSWnFJSSUlFqSkNpKR2lpwyUkTJRZspCWSkbZacclJNyUW7KQ3kpH+WnAlSQClFhKkJFqRgVpxJUkkpRaSpDZakclacKVJEqUWWqQlWpGlWnGlSTalFtqkN1qR7VpwbUkBpRY2pCTakZNacW1JJaUWtqQ22pHbWnDtSROlFn6kJdqRt1px7Uk3pRb+pDfakf9acBNJAG0WAaQkNpGA2nETSSRtFoGkNjaRyNpwk0kSbRZJpCU2kaTacZNJNm0WyaQ3NpHs2nBbSQFtFiWkJLaRktpxW0klbRalpDa2kdracNtJE20WbaQltpG22nHbSTdtFu2kN7aR/tpwN0kA7RYTpCR+kYHacTdJJO0Wk6Q2fpHJ2nC3SRLtFlukJX6Rpdpxt0k27RbbpDd+ke3acH9JAe0WN6Qk/pGT2nF/SSXtFrekNv6R29pw/0kT7RZ/pCX+kbfacf9A/9pF/0m/7Qvz9k/EUBKRAFpiAUlIJRcApBISkUhaYwFJbCUXiKQBEpEkWmKBSVolF0ikExKRbFpjgUl+L9+32b4lMCSkiJKDEloaSUjJJTCkpJqSg1paG0lI7SUwbKSJkoM2WhrJSNslMOykm5KDflobyUj/JTASpIhagwFaGiVIyKUwkqSaWoNJWhslSOylMFqkiVqDJVoapUjapTDapJtag21aG6VI/qUwNqSI2oMTWhptSMmlMLakmtqDW1obbUjtpTB+pInagzdaGu1I26Uw/qSb2oN/WhvtSP+tMAGkiDaDANoaE0jIbTCBpJo2g0jaGxNI7G0wSaSJNoMk2hqTSNptMMmkmzaDbNobk0j+bTAlpIi2gxLaGltIyW0wpaSatoNa2htbSO1tMG2kibaDNtoa20jbbTDtpJu2g37aG9tI/20wE6SIfoMB2ho3SMjtMJOkmn6DSdobN0js7TBbpIl+gyXaGrdI2u0w26SbfoNt2hu3SP7tMDekiP6DE9oaf0jJ7TC3pJr+g1vaG39I7e0wf6SJ/oM32hr/SNvtMP+od+0i/6HeT/+rk5QFDmnwJSIApMQSgoBaPgFIJCUigKTWEoLIWj8BSBIlIkikxRKCpFo+gUg2JSLIpNcSguxaO/KT4loISUiBJTEkpKySg5paCUlIpSUxpKS+koPWWgjJSJMlMWykrZKDvloJyUi3JTHspL+Sg/FaCCVIgKUxEqSsWoOJWgklSKSlMZKkvlqDxVoIpUiSpTFapK1ag61aCaVItqUx2qS/WoPjWghtSIGlMTakrNqDm1oJbUilpTG2pL7ag9daCO1Ik6UxfqSt2oO/WgntSLelMf6kv9qD8NoIE0iAbTEBpKw2g4jaCRNIpG0xgaS+NoPE2giTSJJtMUmkrTaDrNoJk0i2bTHJpL82g+LaCFtIgW0xJaSstoOa2glbSKVtMaWkvraD1toI20iTbTFtpK22g77aCdtIt20x7aS/toPx2gg3SIDtMROkrH6DidoJN0ik7TGTpL5+g8XaCLdIku0xW6StfoOt2gm3SLbtMdukv36D49oIf0iB7TE3pKz+g5vaCX9Ipe0xt6S+/oPX2gj/SJPtMX+krf6Dv9oH/oJ/2i3/SHAvDe0F8UkAJRYApCQSkYBacQFJJCUWgKQ2EpHIWnCBSRIlFkikJRKRpFpxgUk2JRbIpDcSnev+9LUXxKQAkpESWmJJSUklFySkEpKRWlpjSUltJRespAGSkTZaYslJWyUXbKQTkpF+WmPJSX8lF+KkAFqRAVpiJUlIpRcSpBJakUlaYyVJbKUXmqQBWpElWmKlSVqlF1qkE1qRbVpjpUl+pRfWpADakRNaYm1JSaUXNqQS2pFbWmNtSW2lF76kAdqRN1pi7UlbpRd+pBPakX9aY+1Jf6UX8aQANpEA2mITSUhtFwGkEjaRSNpjE0lsbReJpAE2kSTaYpNJWm0XSaQTNpFs2mOTSX5tF8WkALaREtpiW0lJbRclpBK2kVraY1tJbW0XraQBtpE22mLbSVttF22kE7aRftpj20l/bRfjpAB+kQHaYjdJSO0XE6QSfpFJ2mM3SWztF5ukAX6RJdpit0la7RdbpBN+kW3aY7dJfu0X16QA/pET2mJ/SUntFzekEv6RW9pjf0lt7Re/pAH+kTfaYv9JW+0Xf6Qf/QT/pFv+nf94UDBGf+KSAFosAUhIJSMApOISgkhaLQFIbCUjgKTxEoIkWiyBSFolI0ik4xKCbFotgUh+JSPPqb4lMCSkiJKDEloaSUjJJTCkpJqSg1paG0lI7SUwbKSJkoM2WhrJSNslMOykm5KDflobyUj/JTASpIhagwFaGiVIyKUwkqSaWoNJWhslSOylMFqkiVqDJVoapUjapTDapJtag21aG6VI/qUwNqSI2oMTWhptSMmlMLakmtqDW1obbUjtpTB+pInagzdaGu1I26Uw/qSb2oN/WhvtSP+tMAGkiDaDANoaE0jIbTCBpJo2g0jaGxNI7G0wSaSJNoMk2hqTSNptMMmkmzaDbNobk0j+bTAlpIi2gxLaGltIyW0wpaSatoNa2htbSO1tMG2kibaDNtoa20jbbTDtpJu2g37aG9tI/20wE6SIfoMB2ho3SMjtMJOkmn6DSdobN0js7TBbpIl+gyXaGrdI2u0w26SbfoNt2hu3SP7tMDekiP6DE9oaf0jJ7TC3pJr+g1vaG39I7e0wf6SJ/oM32hr/SNvtMP+od+0i/6TX8oQAjmnwJSIApMQSgoBaPgFIJCUigKTWEoLIWj8BSBIlIkikxRKCpFo+gUg2JSLIpNcSguxaO/KT4loISUiBJTEkpKySg5paCUlIpSUxpKS+koPWWgjJSJMlMWykrZKDvloJyUi3JTHspL+Sg/FaCCVIgKUxEqSsWoOJWgklSKSlMZKkvlqDxVoIpUiSpTFapK1ag61aCaVItqUx2qS/WoPjWghtSIGlMTakrNqDm1oJbUilpTG2pL7ag9daCO1Ik6UxfqSt2oO/WgntSLelMf6kv9qD8NoIE0iAbTEBpKw2g4jaCRNIpG0xgaS+NoPE2giTSJJtMUmkrTaDrNoJk0i2bTHJpL82g+LaCFtIgW0xJaSstoOa2glbSKVtMaWkvraD1toI20iTbTFtpK22g77aCdtIt20x7aS/toPx2gg3SIDtMROkrH6DidoJN0ik7TGTpL5+g8XaCLdIku0xW6StfoOt2gm3SLbtMdukv36D49oIf0iB7TE3pKz+g5vaCX9Ipe0xt6S+/oPX2gj/SJPtMX+krf6Dv9oH/oJ/2i3/SHAoRk/ikgBaLAFISCUjAKTiEoJIWi0BSGwlI4Ck8RKCJFosgUhaJSNIpOMSgmxaLYFIfiUjz6m+JTAkpIiSgxJaGklIySUwpKSakoNaWhtJSO0lMGykiZKDNloayUjbJTDspJuSg35aG8lI/yUwEqSIWoMBWholSMilMJKkmlqDSVobJUjspTBapIlagyVaGqVI2qUw2qSbWoNtWhulSP6lMDakiNqDE1oabUjJpTC2pJrag1taG21I7aUwfqSJ2oM3WhrtSNulMP6km9qDf1ob7Uj/rTABpIg2gwDaGhNIyG0wgaSaNoNI2hsTSOxtMEmkiTaDJNoak0jabTDJpJs2g2zaG5NI/m0wJaSItoMS2hpbSMltMKWkmraDWtobW0jtbTBtpIm2gzbaGttI220w7aSbtoN+2hvbSP9tMBOkiH6DAdoaN0jI7TCTpJp+g0naGzdI7O0wW6SJfoMl2hq3SNrtMNukm36Dbdobt0j+7TA3pIj+gxPaGn9Iye0wt6Sa/oNb2ht/SO3tMH+kif6DN9oa/0jb7TD/qHftIv+k1/KEAo5p8CUiAKTEEoKAWj4BSCQlIoCk1hKCyFo/AUgSJSJIpMUSgqRaPoFINiUiyKTXEoLsWjvyk+JaCElIgSUxJKSskoOaWglJSKUlMaSkvpKD1loIyUiTJTFspK2Sg75aCclItyUx7KS/koPxWgglSIClMRKkrFqDiVoJJUikpTGSpL5ag8VaCKVIkqUxWqStWoOtWgmlSLalMdqkv1qD41oIbUiBpTE2pKzag5taCW1IpaUxtqS+2oPXWgjtSJOlMX6krdqDv1oJ7Ui3pTH+pL/ag/DaCBNIgG0xAaSsNoOI2gkTSKRtMYGkvjaDxNoIk0iSbTFJpK02g6zaCZNItm0xyaS/NoPi2ghbSIFtMSWkrLaDmtoJW0ilbTGlpL62g9baCNtIk20xbaSttoO+2gnbSLdtMe2kv7aD8doIN0iA7TETpKx+g4naCTdIpO0xk6S+foPF2gi3SJLtMVukrX6DrdoJt0i27THbpL9+g+PaCH9Ige0xN6Ss/oOb2gl/SKXtMbekvv6D19oI/0iT7TF/pK3+g7/aB/6Cf9ot/0hwKEZv4pIAWiwBSEglIwCk4hKCSFotAUhsJSOApPESgiRaLIFIWiUjSKTjEoJsWi2BSH4lI8+pviUwJKSIkoMSWhpJSMklMKSkmpKDWlobSUjtJTBspImSgzZaGslI2yUw7KSbkoN+WhvJSP8lMBKkiFqDAVoaJUjIpTCSpJpag0laGyVI7KUwWqSJWoMlWhqlSNqlMNqkm1qDbVobpUj+pTA2pIjagxNaGm1IyaUwtqSa2oNbWhttSO2lMH6kidqDN1oa7UjbpTD+pJvag39aG+1I/60wAaSINoMA2hoTSMhtMIGkmjaDSNobE0jsbTBJpIk2gyTaGpNI2m0wyaSbNoNs2huTSP5tMCWkiLaDEtoaW0jJbTClpJq2g1raG1tI7W0wbaSJtoM22hrbSNttMO2km7aDftob20j/bTATpIh+gwHaGjdIyO0wk6SafoNJ2hs3SOztMFukiX6DJdoat0ja7TDbpJt+g23aG7dI/u0wN6SI/oMT2hp/SMntMLekmv6DW9obf0jt7TB/pIn+gzfaGv9I2+0w/6h37SL/pNfyhAGOafAlIgCkxBKCgFo+AUgkJSKApNYSgshaPwFIEiUiSKTFEoKkWj6BSDYlIsik1xKC7Fo78pPiWghJSIElMSSkrJKDmloJSUilJTGkpL6Sg9ZaCMlIkyUxbKStkoO+WgnJSLclMeykv5KD8VoIJUiApTESpKxag4laCSVIpKUxkqS+WoPFWgilSJKlMVqkrVqDrVoJpUi2pTHapL9ag+NaCG1IgaUxNqSs2oObWgltSKWlMbakvtqD11oI7UiTpTF+pK3ag79aCe1It6Ux/qS/2oPw2ggTSIBtMQGkrDaDiNoJE0ikbTGBpL42g8TaCJNIkm0xSaStNoOs2gmTSLZtMcmkvzaD4toIW0iBbTElpKy2g5raCVtIpW0xpaS+toPW2gjbSJNtMW2krbaDvtoJ20i3bTHtpL+2g/HaCDdIgO0xE6SsfoOJ2gk3SKTtMZOkvn6DxdoIt0iS7TFbpK1+g63aCbdItu0x26S/foPj2gh/SIHtMTekrP6Dm9oJf0il7TG3pL7+g9faCP9Ik+0xf6St/oO/2gf+gn/aLf9IcChGX+KSAFosAUhIJSMApOISgkhaLQFIbCUjgKTxEoIkWiyBSFolI0ik4xKCbFotgUh+JSPPqb4lMCSkiJKDEloaSUjJJTCkpJqSg1paG0lI7SUwbKSJkoM2WhrJSNslMOykm5KDflobyUj/JTASpIhagwFaGiVIyKUwkqSaWoNJWhslSOylMFqkiVqDJVoapUjapTDapJtag21aG6VI/qUwNqSI2oMTWhptSMmlMLakmtqDW1obbUjtpTB+pInagzdaGu1I26Uw/qSb2oN/WhvtSP+tMAGkiDaDANoaE0jIbTCBpJo2g0jaGxNI7G0wSaSJNoMk2hqTSNptMMmkmzaDbNobk0j+bTAlpIi2gxLaGltIyW0wpaSatoNa2htbSO1tMG2kibaDNtoa20jbbTDtpJu2g37aG9tI/20wE6SIfoMB2ho3SMjtMJOkmn6DSdobN0js7TBbpIl+gyXaGrdI2u0w26SbfoNt2hu3SP7tMDekiP6DE9oaf0jJ7TC3pJr+g1vaG39I7e0wf6SJ/oM32hr/SNvtMP+od+0i/6TX8oQDjmnwJSIApMQSgoBaPgFIJCUigKTWEoLIWj8BSBIlIkikxRKCpFo+gUg2JSLIpNcSguxaO/KT4loISUiBJTEkpKySg5paCUlIpSUxpKS+koPWWgjJSJMlMWykrZKDvloJyUi3JTHspL+Sg/FaCCVIgKUxEqSsWoOJWgklSKSlMZKkvlqDxVoIpUiSpTFapK1ag61aCaVItqUx2qS/WoPjWghtSIGlMTakrNqDm1oJbUilpTG2pL7ag9daCO1Ik6UxfqSt2oO/WgntSLelMf6kv9qD8NoIE0iAbTEBpKw2g4jaCRNIpG0xgaS+NoPE2giTSJJtMUmkrTaDrNoJk0i2bTHJpL82g+LaCFtIgW0xJaSstoOa2glbSKVtMaWkvraD1toI20iTbTFtpK22g77aCdtIt20x7aS/toPx2gg3SIDtMROkrH6DidoJN0ik7TGTpL5+g8XaCLdIku0xW6StfoOt2gm3SLbtMdukv36D49oIf0iB7TE3pKz+g5vaCX9Ipe0xt6S+/oPX2gj/SJPtMX+krf6Dv9oH/oJ/2i3/SHAoRn/ikgBaLAFISCUjAKTiEoJIWi0BSGwlI4Ck8RKCJFosgUhaJSNIpOMSgmxaLYFIfiUjz6m+JTAkpIiSgxJaGklIySUwpKSakoNaWhtJSO0lMGykiZKDNloayUjbJTDspJuSg35aG8lI/yUwEqSIWoMBWholSMilMJKkmlqDSVobJUjspTBapIlagyVaGqVI2qUw2qSbWoNtWhulSP6lMDakiNqDE1oabUjJpTC2pJrag1taG21I7aUwfqSJ2oM3WhrtSNulMP6km9qDf1ob7Uj/rTABpIg2gwDaGhNIyG0wgaSaNoNI2hsTSOxtMEmkiTaDJNoak0jabTDJpJs2g2zaG5NI/m0wJaSItoMS2hpbSMltMKWkmraDWtobW0jtbTBtpIm2gzbaGttI220w7aSbtoN+2hvbSP9tMBOkiH6DAdoaN0jI7TCTpJp+g0naGzdI7O0wW6SJfoMl2hq3SNrtMNukm36Dbdobt0j+7TA3pIj+gxPaGn9Iye0wt6Sa/oNb2ht/SO3tMH+kif6DN9oa/0jb7TD/qHftIv+k1/KEAE5p8CUiAKTEEoKAWj4BSCQlIoCk1hKCyFo/AUgSJSJIpMUSgqRaPoFINiUiyKTXEoLsWjvyk+JaCElIgSUxJKSskoOaWglJSKUlMaSkvpKD1loIyUiTJTFspK2Sg75aCclItyUx7KS/koPxWgglSIClMRKkrFqDiVoJJUikpTGSpL5ag8VaCKVIkqUxWqStWoOtWgmlSLalMdqkv1qD41oIbUiBpTE2pKzag5taCW1IpaUxtqS+2oPXWgjtSJOlMX6krdqDv1oJ7Ui3pTH+pL/ag/DaCBNIgG0xAaSsNoOI2gkTSKRtMYGkvjaDxNoIk0iSbTFJpK02g6zaCZNItm0xyaS/NoPi2ghbSIFtMSWkrLaDmtoJW0ilbTGlpL62g9baCNtIk20xbaSttoO+2gnbSLdtMe2kv7aD8doIN0iA7TETpKx+g4naCTdIpO0xk6S+foPF2gi3SJLtMVukrX6DrdoJt0i27THbpL9+g+PaCH9Ige0xN6Ss/oOb2gl/SKXtMbekvv6D19oI/0iT7TF/pK3+g7/aB/6Cf9ot/0hwJEZP4pIAWiwBSEglIwCk4hKCSFotAUhsJSOApPESgiRaLIFIWiUjSKTjEoJsWi2BSH4lI8+pviUwJKSIkoMSWhpJSMklMKSkmpKDWlobSUjtJTBspImSgzZaGslI2yUw7KSbkoN+WhvJSP8lMBKkiFqDAVoaJUjIpTCSpJpag0laGyVI7KUwWqSJWoMlWhqlSNqlMNqkm1qDbVobpUj+pTA2pIjagxNaGm1IyaUwtqSa2oNbWhttSO2lMH6kidqDN1oa7UjbpTD+pJvag39aG+1I/60wAaSINoMA2hoTSMhtMIGkmjaDSNobE0jsbTBJpIk2gyTaGpNI2m0wyaSbNoNs2huTSP5tMCWkiLaDEtoaW0jJbTClpJq2g1raG1tI7W0wbaSJtoM22hrbSNttMO2km7aDftob20j/bTATpIh+gwHaGjdIyO0wk6SafoNJ2hs3SOztMFukiX6DJdoat0ja7TDbpJt+g23aG7dI/u0wN6SI/oMT2hp/SMntMLekmv6DW9obf0jt7TB/pIn+gzfaGv9I2+0w/6h37SL/pNfyhAJOafAlIgCkxBKCgFo+AUgkJSKApNYSgshaPwFIEiUiSKTFEoKkWj6BSDYlIsik1xKC7F+/dv8Sk+JaCElIgSUxJKSskoOaWglJSKUlMaSkvpKD1loIyUiTJTFspK2Sg75aCclItyUx7KS/koPxWgglSIClMRKkrFqDiVoJJUikpTGSpL5ag8VaCKVIkqUxWqStWoOtWgmlSLalMdqkv1qD41oIbUiBpTE2pKzag5taCW1IpaUxtqS+2oPXWgjtSJOlMX6krdqDv1oJ7Ui3pTH+pL/ag/DaCBNIgG0xAaSsNoOI2gkTSKRtMYGkvjaDxNoIk0iSbTFJpK02g6zaCZNItm0xyaS/NoPi2ghbSIFtMSWkrLaDmtoJW0ilbTGlpL62g9baCNtIk20xbaSttoO+2gnbSLdtMe2kv7aD8doIN0iA7TETpKx+g4naCTdIpO0xk6S+foPF2gi3SJLtMVukrX6DrdoJt0i27THbpL9+g+PaCH9Ige0xN6Ss/oOb2gl/SKXtMbekvv6D19oI/0iT7TF/pK3+g7/aB/6Cf9ew2M3/SHAkRm/ikgBaLAFISCUjAKTiEoJIWi0BSGwlI4Ck8RKCJFosgUhaJSNIpOMSgmxaLYFIfiUjz6m+JTAkpIiSgxJaGklIySUwpKSakoNaWhtJSO0lMGykiZKDNloayUjbJTDspJuSg35aG8lI/yUwEqSIWoMBWholSMilMJKkmlqDSVobJUjspTBapIlagyVaGqVI2qUw2qSbWoNtWhulSP6lMDakiNqDE1oabUjJpTC2pJrag1taG21I7aUwfqSJ2oM3WhrtSNulMP6km9qDf1ob7Uj/rTABpIg2gwDaGhNIyG0wgaSaNoNI2hsTSOxtMEmkiTaDJNoak0jabTDJpJs2g2zaG5NI/m0wJaSItoMS2hpbSMltMKWkmraDWtobW0jtbTBtpIm2gzbaGttI220w7aSbtoN+2hvbSP9tMBOkiH6DAdoaN0jI7TCTpJp+g0naGzdI7O0wW6SJfoMl2hq3SNrtMNukm36Dbdobt0j+7TA3pIj+gxPaGn9Iye0wt6Sa/oNb2ht/SO3tMH+kif6DN9oa/0jb7TD/qHftIv+k1/KEAU5p8CUiAKTEEoKAWj4BSCQlIoCk1hKCyFo/AUgSJSJIpMUSgqRaPoFINiUiyKTXEoLsWjvyk+JaCElIgSUxJKSskoOaWglJSKUlMaSkvpKD1loIyUiTJTFspK2Sg75aCclItyUx7KS/koPxWgglSIClMRKkrFqDiVoJJUikpTGSpL5ag8VaCKVIkqUxWqStWoOtWgmlSLalMdqkv1qD41oIbUiBpTE2pKzag5taCW1IpaUxtqS+2oPXWgjtSJOlMX6krdqDv1oJ7Ui3pTH+pL/ag/DaCBNIgG0xAaSsNoOI2gkTSKRtMYGkvjaDxNoIk0iSbTFJpK02g6zaCZNItm0xyaS/NoPi2ghbSIFtMSWkrLaDmtoJW0ilbTGlpL62g9baCNtIk20xbaSttoO+2gnbSLdtMe2kv7aD8doIN0iA7TETpKx+g4naCTdIpO0xk6S+foPF2gi3SJLtMVukrX6DrdoJt0i27THbpL9+g+PaCH9Ige0xN6Ss/oOb2gl/SKXtMbekvv6D19oI/0iT7TF/pK3+g7/aB/6Cf9ot/0hwJEZf4pIAWiwBSEglIwCk4hKCSFotAUhsJSOApPESgiRaLIFIWiUjSKTjEoJsWi2BSH4lI8+pviUwJKSIkoMSWhpJSMklMKSkmpKDWlobSUjtJTBspImSgzZaGslI2yUw7KSbkoN+WhvJSP8lMBKkiFqDAVoaJUjIpTCSpJpag0laGyVI7KUwWqSJWoMlWhqlSNqlMNqkm1qDbVobpUj+pTA2pIjagxNaGm1IyaUwtqSa2oNbWhttSO2lMH6kidqDN1oa7UjbpTD+pJvag39aG+1I/60wAaSINoMA2hoTSMhtMIGkmjaDSNobE0jsbTBJpIk2gyTaGpNI2m0wyaSbNoNs2huTSP5tMCWkiLaDEtoaW0jJbTClpJq2g1raG1tI7W0wbaSJtoM22hrbSNttMO2km7aDftob20j/bTATpIh+gwHaGjdIyO0wk6SafoNJ2hs3SOztMFukiX6DJdoat0ja7TDbpJt+g23aG7dI/u0wN6SI/oMT2hp/SMntMLekmv6DW9obf0jt7TB/pIn+gzfaGv9I2+0w/6h37SL/pNfyhANOafAlIgCkxBKCgFo+AUgkJSKApNYSgshaPwFIEiUiSKTFEoKkWj6BSDYlIsik1xKC7F+/eajhSfElBCSkSJKQklpWSUnFJQSkpFqSkNpaV0lJ4yUEbKRJkpC2WlbJSdclBOykW5KQ/lpXyUnwpQQSpEhakIFaViVJxKUEkqRaWpDJWlclSeKlBFqkSVqQpVpWpUnWpQTapFtakO1aV6VJ8aUENqRI2pCTWlZtScWlBLakWtqQ21pXbUnjpQR+pEnakLdaVu1J16UE/qRb2pD/WlftSfBtBAGkSDaQgNpWE0nEbQSBpFo2kMjaVxNJ4m0ESaRJNpCk2laTSdZtBMmkWzaQ7NpXk0nxbQQlpEi2kJLaVltJxW0EpaRatpDa2ldbSeNtBG2kSbaQttpW20nXbQTtpFu2kP7aV9tJ8O0EE6RIfpCB2lY3ScTtBJOkWn6QydpXN0ni7QRbpEl+kKXaVrdJ1u0E26RbfpDt2le3SfHtBDekSP6Qk9pWf0nF7QS3pFr+kNvaV39J4+0Ef6RJ/pC32lb/SdftC/11D9Sb/oN/2hANGZfwpIgSgwBaGgFIyCUwgKSaEoNIWhsBSOwlMEikiRKDJFoagUjaJTDIpJsSg2xaG4FI/+pviUgBJSIkpMSSgpJaPklIJSUipKTWkoLaWj9JSBMlImykxZKCtlo+yUg3JSLspNeSgv5aP8VIAKUiEqTEWoKBWj4lSCSlIpKk1lqCyVo/JUgSpSJapMVagqVaPqVINqUi2qTXWoLtWj+tSAGlIjakxNqCk1o+bUglpSK2pNbagttaP21IE6UifqTF2oK3Wj7tSDelIv6k19qC/1o/40gAbSIBpMQ2goDaPhNIJG0igaTWNoLI2j8TSBJtIkmkxTaCpNo+k0g2bSLJpNc2guzaP5tIAW0iJaTEtoKS2j5bSCVtIqWk1raC2to/W0gTbSJtpMW2grbaPttIN20i7aTXtoL+2j/XSADtIhOkxH6Cgdo+N0gk7SKTpNZ+gsnaPzdIEu0iW6TFfoKl2j63SDbtItuk136C7do/v0gB7SI3pMT+gpPaPn9IJe0it6TW/oLb2j9/SBPtIn+kxf6Ct9o+/0g/6hn/SLftMfChCD+aeAFIgCUxAKSsEoOIWgkBSKQlMYCkvhKDxFoIgUiSJTFIpK0Sg6xaCYFItiUxyKS/Hob4pPCSghJaLElISSUjJKTikoJaWi1JSG0lI6Sk8ZKCNlosyUhbJSNspOOSgn5aLclIfyUj7KTwWoIBWiwlSEilIxKk4lqCSVotJUhspSOSpPFagiVaLKVIWqUjWqTjWoJtWi2lSH6lI9qk8NqCE1osbUhJpSM2pOLagltaLW1IbaUjtqTx2oI3WiztSFulI36k49qCf1ot7Uh/pSP+pPA2ggDaLBNISG0jAaTiNoJI2i0TSGxtI4Gk8TaCJNosk0habSNJpOM2gmzaLZNIfm0jyaTwtoIS2ixbSEltIyWk4raCWtotW0htbSOlpPG2gjbaLNtIW20jbaTjtoJ+2i3bSH9tI+2k8H6CAdosN0hI7SMTpOJ+gknaLTdIbO0jk6TxfoIl2iy3SFrtI1uk436Cbdott0h+7SPbpPD+ghPaLH9ISe0jN6Ti/oJb2i1/SG3tI7ek8f6CN9os/0hb7SN/pOP+gf+km/6Df9oQAxmX8KSIEoMAWhoBSMglMICkmhKDSFobAUjsJTBIpIkSgyRaGoFI2iUwyKSbEoNsWhuBSP/qb4lIASUiJKTEkoKSWj5JSCUlIqSk1pKC2lo/SUgTJSJspMWSgrZaPslINyUi7KTXkoL+Wj/FSAClIhKkxFqCgVo+JUgkpSKSpNZagslaPyVIEqUiWqTFWoKlWj6lSDalItqk11qC7Vo/rUgBpSI2pMTagpNaPm1IJaUitqTW2oLbWj9tSBOlIn6kxdqCt1o+7Ug3pSL+pNfagv9aP+NIAG0iAaTENoKA2j4TSCRtIoGk1jaCyNo/E0gSbSJJpMU2gqTaPpNINm0iyaTXNoLs2j+bSAFtIiWkxLaCkto+W0glbSKlpNa2gtraP1tIE20ibaTFtoK22j7bSDdtIu2k17aC/to/10gA7SITpMR+goHaPjdIJO0ik6TWfoLJ2j83SBLtIlukxX6Cpdo+t0g27SLbpNd+gu3aP79IAe0iN6TE/oKT2j5/SCXtIrek1v6C29o/f0gT7SJ/pMX+grfaPv9IP+oZ/0i37THwoQi/mngBSIAlMQCkrBKDiFoJAUikJTGApL4Sg8RaCIFIkiUxSKStEoOsWgmBSLYlMcikvx/r2+PsWnBJSQElFiSkJJKRklpxSUklJRakpDaSkdpacMlJEyUWbKQlkpG2WnHJSTclFuykN5KR/lpwJUkApRYSpCRakYFacSVJJKUWkqQ2WpHJWnClSRKlFlqkJVqRpVpxpUk2pRbapDdake1acG1JAaUWNqQk2pGTWnFtSSWlFrakNtqR21pw7UkTpRZ+pCXakbdace1JN6UW/qQ32pH/WnATSQBtFgGkJDaRgNpxE0kkbRaBpDY2kcjacJNJEm0WSaQlNpGk2nGTSTZtFsmkNzaR7NpwW0kBbRYlpCS2kZLacVtJJW0WpaQ2tpHa2nDbSRNtFm2kJbaRttpx20k3bRbtpDe2kf7acDdJAO0WE6QkfpGB2nE3SSTtFpOkNn6Rydpwt0kS7RZbpCV+kaXacbdJNu0W26Q3fpHt2nB/SQHtFjekJP6Rk9pxf0kl7Ra3pDb+kdvacP9JE+0Wf6Ql/pG32nH/Tv/Sz+ve7/L/pNfyhAbOafAlIgCkxBKCgFo+AUgkJSKApNYSgshaPwFIEiUiSKTFEoKkWj6BSDYlIsik1xKC7Fo78pPiWghJSIElMSSkrJKDmloJSUilJTGkpL6Sg9ZaCMlIkyUxbKStkoO+WgnJSLclMeykv5KD8VoIJUiApTESpKxag4laCSVIpKUxkqS+WoPFWgilSJKlMVqkrVqDrVoJpUi2pTHapL9ag+NaCG1IgaUxNqSs2oObWgltSKWlMbakvtqD11oI7UiTpTF+pK3ag79aCe1It6Ux/qS/2oPw2ggTSIBtMQGkrDaDiNoJE0ikbTGBpL42g8TaCJNIkm0xSaStNoOs2gmTSLZtMcmkvzaD4toIW0iBbTElpKy2g5raCVtIpW0xpaS+toPW2gjbSJNtMW2krbaDvtoJ20i3bTHtpL+2g/HaCDdIgO0xE6SsfoOJ2gk3SKTtMZOkvn6DxdoIt0iS7TFbpK1+g63aCbdItu0x26S/foPj2gh/SIHtMTekrP6Dm9oJf0il7TG3pL7+g9faCP9Ik+0xf6St/oO/2gf+gn/aLf9IcCxGH+KSAFosAUhIJSMApOISgkhaLQFIbCUjgKTxEoIkWiyBSFolI0ik4xKCbFotgUh+JSPPqb4lMCSkiJKDEloaSUjJJTCkpJqSg1paG0lI7SUwbKSJkoM2WhrJSNslMOykm5KDflobyUj/JTASpIhagwFaGiVIyKUwkqSaWoNJWhslSOylMFqkiVqDJVoapUjapTDapJtag21aG6VI/qUwNqSI2oMTWhptSMmlMLakmtqDW1obbUjtpTB+pInagzdaGu1I26Uw/qSb2oN/WhvtSP+tMAGkiDaDANoaE0jIbTCBpJo2g0jaGxNI7G0wSaSJNoMk2hqTSNptMMmkmzaDbNobk0j+bTAlpIi2gxLaGltIyW0wpaSatoNa2htbSO1tMG2kibaDNtoa20jbbTDtpJu2g37aG9tI/20wE6SIfoMB2ho3SMjtMJOkmn6DSdobN0js7TBbpIl+gyXaGrdI2u0w26SbfoNt2hu3SP7tMDekiP6DE9oaf0jJ7TC3pJr+g1vaG39I7e0wf6SJ/oM32hr/SNvtMP+od+0i/6TX8oQFzmnwJSIApMQSgoBaPgFIJCUigKTWEoLIWj8BSBIlIkikxRKCpFo+gUg2JSLIpNcSguxaO/KT4loISUiBJTEkpKySg5paCUlIpSUxpKS+koPWWgjJSJMlMWykrZKDvloJyUi3JTHspL+Sg/FaCCVIgKUxEqSsWoOJWgklSKSlMZKkvlqDxVoIpUiSpTFapK1ag61aCaVItqUx2qS/WoPjWghtSIGlMTakrNqDm1oJbUilpTG2pL7ag9daCO1Ik6UxfqSt2oO/WgntSLelMf6kv9qD8NoIE0iAbTEBpKw2g4jaCRNIpG0xgaS+NoPE2giTSJJtMUmkrTaDrNoJk0i2bTHJpL82g+LaCFtIgW0xJaSstoOa2glbSKVtMaWkvraD1toI20iTbTFtpK22g77aCdtIt20x7aS/toPx2gg3SIDtMROkrH6DidoJN0ik7TGTpL5+g8XaCLdIku0xW6StfoOt2gm3SLbtMdukv36D49oIf0iB7TE3pKz+g5vaCX9Ipe0xt6S+/oPX2gj/SJPtMX+krf6Dv9oH/oJ/2i3/SHAsRj/ikgBaLAFISCUjAKTiEoJIWi0BSGwlI4Ck8RKCJFosgUhaJSNIpOMSgmxaLYFIfiUrx/721G8SkBJaRElJiSUFJKRskpBaWkVJSa0lBaSkfpKQNlpEyUmbJQVspG2SkH5aRclJvyUF7KR/mpABWkQlSYilBRKkbFqQSVpFJUmspQWSpH5akCVaRKVJmqUFWqRtWpBtWkWlSb6lBdqkf1qQE1pEbUmJpQU2pGzakFtaRW1JraUFtqR+2pA3WkTtSZulBX6kbdqQf1pF7Um/pQX+pH/WkADaRBNJiG0FAaRsNpBI2kUTSaxtBYGkfjaQJNpEk0mabQVJpG02kGzaRZNJvm0FyaR/NpAS2kRbSYltBSWkbLaQWtpFW0mtbQWlpH62kDbaRNtJm20FbaRttpB+2kXbSb9tBe2kf76QAdpEN0mI7QUTpGx+kEnaRTdJrO0Fk6R+fpAl2kS3SZrtBVukbX6QbdpFt0m+7QXbpH9+kBPaRH9Jie0FN6Rs/pBb2kV/Sa3tBbekfv6QN9pE/0mb7Qv/ei//de7v/eC/3fe4n/e2/Hf+/39/+9uWCA/+t+hIH+98P/ezugAP97W4AA/3t54AD/e5nAAP97uaAA/3vZgAD/++eDAf73zwgC/O/phAH+97SCAP/764UA//s2Q4D//XHj35ec/7lPYXxKQAkpESWmJJSUkv17P0NKQSkpFaWmNJSW0lF6ykAZKRNlpiyUlbJRdspBOSkX5aY8lJfyUX4qQAWpEBWmIlSUilFxKkElqRSVpjJUlspReapAFakSVaYqVJWqUXWqQTWpFtWmOlSX6lF9akANqRE1pibUlJpRc2pBLakVtaY21JbaUXvqQB2pE3WmLtSVulF36kE9qRf1pj7Ul/pRfxpAA2kQDaYhNJSG0XAaQSNpFI2mMTSWxtF4mkATaRJNpik0labRdJpBM2kWzaY5NJfm0XxaQAtpES2mJbSUltFyWkEraRWtpjW0ltbRetpAG2kTbaYttJW20XbaQTtpF+2mPbSX9tF+OkAH6RAdpiN0lI7RcTpBJ+kUnaYzdJbO0Xm6QBfpEl2mK3SVrtF1ukE36Rbdpjt0l+7RfXpAD+kRPaYn9JSe0XN6QS/pFb2mN/SW3tF7+kAf6RN9pi/0lb7Rd/pB/9BP+kW/6Q/9O/x/UUAKRIEpCAWlYBScQlBICkWhKQyFpXAUniJQRIpEkSkKRaVoFJ1iUEyKRbEpDsWlePQ3xacElJASUWJKQkkpGSWnFJSSUlFqSkNpKR2lpwyUkTJRZspCWSkbZacclJNyUW7KQ3kpH+WnAlSQClFhKkJFqRgVpxJUkkpRaSpDZakclacKVJEqUWWqQlWpGlWnGlSTalFtqkN1qR7VpwbUkBpRY2pCTakZNacW1JJaUWtqQ22pHbWnDtSROlFn6kJdqRt1px7Uk3pRb+pDfakf9acBNJAG0WAaQkNpGA2nETSSRtFoGkNjaRyNpwk0kSbRZJpCU2kaTacZNJNm0WyaQ3NpHs2nBbSQFtFiWkJLaRktpxW0klbRalpDa2kdracNtJE20WbaQltpG22nHbSTdtFu2kN7aR/tpwN0kA7RYTpCR+kYHacTdJJO0Wk6Q2fpHJ2nC3SRLtFlukJX6Rpdpxt0k27RbbpDd+ke3acH9JAe0WN6Qk/pGT2nF/SSXtFrekNv6R29pw/0kT7RZ/pCX+kbfacf9A/9pF/0m/7Q/6evO44GPYwfu97NzMzMzMzMTGZmZmZmZmZmZmZmptvtdrvd7iRJkiSZJEmSJEmSJEmSSZIkSZIkSZKZZDJJkiS7u7u7u7uz2/d3ttPZP/f1Oed9nj9e5/n7+33Oec55fuHD/yrobw4KCfpFQaFBvzgoLOiXBIUH/dKgiKBfFhQZ9MuDooJ+RVB00K8Mign6VUGxQb86KC7o1wTFB/3aoISgXxeUGPTrg5KC/pag5KDfEJQS9BuDUoN+U1Ba0G8OSg/6LUEZQb81KDPotwVlBf32oOyg3xGUE/Q7g3KDfldQXtDvDsoP+j1BBUG/N6gw6PcFFQX9/qDioD8QVBL0B4NKg/5QUFnQHw4qD/ojQRVBfzSoMuiPBVUF/a1Br4P+tqA3QX970NugvyPoXdDfGfQ+6O8K+hD0dwd9DPrjQdVBf09QTdDfG1Qb9PcF1QX9/UH1Qf9AUEPQPxjUGPQPBTUF/cNBzUH/SFBL0D8a1Br0jwW1Bf2JoPagfzyoI+ifCOoM+ieDuoL+qaDuoH86qCfonwnqDfpng/qC/rmg/qB/Pmgg6F8IGgz6F4OGgv6loOGgfzloJOhfCRoN+leDxoL+taDxoH89aCLo3wiaDPo3g6aC/q2g6aB/O2gm6N8Jmg36d4Pmgv69oPmgPxm0EPTvBy0G/QdBS0H/YdBy0H8UtBL0HwetBv0nQWtB/2nQetB/FrQR9J8HbQb9F0FbQf9l0HbQfxW0E/RfB+0G/TdBe0H/bdB+0H8XdBD03wcdBv0PQUdB/2PQcdD/FHQS9KeCToP+dNBZ0P8cdB70vwRdBP2ZoMug/zXoKujPBl0H/W9BN0H/e9Bt0P8RdBf0fwbdB/1fQQ9B/3fQY9D/E/QU9P8GPQf9uaBPQX8+6HPQXwj6EvQXg74G/aWgb0F/Oeh70F8Jegn6q0E/gn7hp/9V0N8cFBL0i4JCg35xUFjQLwkKD/qlQRFBvywoMuiXB0UF/Yqg6KBfGRQT9KuCYoN+dVBc0K8Jig/6tUEJQb8uKDHo1wcl/cJ79EHJQb8hKCXoNwalBv2moLSg3xyUHvRbgjKCfmtQZtBvC8oK+u1B2UG/Iygn6HcG5Qb9rqC8oN8dlB/0e4IKgn5vUGHQ7wsqCvr9QcVBfyCoJOgPBpUG/aGgsqA/HFQe9EeCKoL+aFBl0B8Lqgr6W4NeB/1tQW+C/vagt0F/R9C7oL8z6H3Q3xX0IejvDvoY9MeDqoP+nqCaoL83qDbo7wuqC/r7g+qD/oGghqB/MKgx6B8Kagr6h4Oag/6RoJagfzSoNegfC2oL+hNB7UH/eFBH0D8R1Bn0TwZ1Bf1TQd1B/3RQT9A/E9Qb9M8G9QX9c0H9Qf980EDQvxA0GPQvBg0F/UtBw0H/ctBI0L8SNBr0rwaNBf1rQeNB/3rQRNC/ETQZ9G8GTQX9W0HTQf920EzQvxM0G/TvBs0F/XtB80F/Mmgh6N8PWgz6D4KWgv7DoOWg/yhoJeg/DloN+k+C1oL+06D1oP8saCPoPw/aDPovgraC/sug7aD/Kmgn6L8O2g36b4L2gv7boP2g/y7oIOi/DzoM+h+CjoL+x6DjoP8p6CToTwWdBv3poLOg/znoPOh/CboI+jNBl0H/a9BV0J8Nug7634Jugv73oNug/yPoLuj/DLoP+r+CHoL+76DHoP8n6Cno/w16DvpzQZ+C/nzQ56C/EPQl6C8GfQ36S0Hfgv5y0PegvxL0EvRXg36E/LUz/y/MXwkO4y9BfzXor6T9Tf//vPrr6x//JdNbf+BPRSz9TX/DhMBCYWGwcFgELBIWBYuGxcBiYXGweFgCLBGWBEuGpcBSYWmwdFgGLBOWBcuG5cByYXmwfFgBrBBWBCuGlcBKYWWwclgFrBJWBXsNewN7C3sHew/7APsIq4bVwGphdbB6WAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEDYEG4aNwEZhY7Bx2ARsEjYFm4bNwGZhc7B52AJsEbYEW4atwFZha7B12AZsE7YF24btwHZhe7B92AHsEHYEO4adwE5hZ7Bz2AXsEnYFu4bdwG5hd7B72APsEfYEe4Z9gn2GfYF9hX2DfYe9wH7AXr36uYXAQmFhsHBYBCwSFgWLhsXAYmFxsHhYAiwRlgRLhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgV7DXsDewt7B3sP+wD7CKuG1cBqYXWwelgDrBHWBGuGtcBaYW2wdlgHrBPWBeuG9cB6YX2wftgAbBA2BBuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cB2YXuwfdgB7BB2BDuGncBOYWewc9gF7BJ2BbuG3cBuYXewe9gD7BH2BHuGfYJ9hn2BfYV9g32HvcB+wH7hbtDPLAQWCguDhcMiYJGwKFg0LAYWC4uDxcMSYImwJFgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKthr2BvYW9g72HvYB9hHWDWsBlYLq4PVwxpgjbAmWDOsBdYKa4O1wzpgnbAuWDesB9YL64P1wwZgg7Ah2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB7YL24Ptww5gh7Aj2DHsBHYKO4Odwy5gl7Ar2DXsBnYLu4Pdwx5gj7An2DPsE+wz7AvsK+wb7DvsBfYD9irk5xYCC4WFwcJhEbBIWBQsGhYDi4XFweJhCbBEWBIsGZYCS4WlwdJhGbBMWBYsG5YDy4XlwfJhBbBCWBGsGFYCK4WVwcphFbBKWBXsNewN7C3sHew97APsI6waVgOrhdXB6mENsEZYE6wZ1gJrhbXB2mEdsE5YF6wb1gPrhfXB+mEDsEHYEGwYNgIbhY3BxmETsEnYFGwaNgObhc3B5mELsEXYEmwZtgJbha3B1mEbsE3YFmwbtgPbhe3B9mEHsEPYEewYdgI7hZ3BzmEXsEvYFewadgO7hd3B7mEPsEfYE+wZ9gn2GfYF9hX2DfYd9gL7AXv1i35uIbBQWBgsHBYBi4RFwaJhMbBYWBwsHpYAS4QlwZJhKbBUWBosHZYBy4RlwbJhObBcWB4sH1YAK4QVwYphJbBSWBmsHFYBq4RVwV7D3sDewt7B3sM+wD7CqmE1sFpYHawe1gBrhDXBmmEtsFZYG6wd1gHrhHXBumE9sF5YH6wfNgAbhA3BhmEjsFHYGGwcNgGbhE3BpmEzsFnYHGwetgBbhC3BlmErsFXYGmwdtgHbhG3BtmE7sF3YHmwfdgA7hB3BjmEnsFPYGewcdgG7hF3BrmE3sFvYHewe9gB7hD3BnmGfYJ9hX2BfYd9g32EvsB+wV6E/txBYKCwMFg6LgEXComDRsBhYLCwOFg9LgCXCkmDJsBRYKiwNlg7LgGXCsmDZsBxYLiwPlg8rgBXCimDFsBJYKawMVg6rgFXCqmCvYW9gb2HvYO9hH2AfYdWwGlgtrA5WD2uANcKaYM2wFlgrrA3WDuuAdcK6YN2wHlgvrA/WDxuADcKGYMOwEdgobAw2DpuATcKmYNOwGdgsbA42D1uALcKWYMuwFdgqbA22DtuAbcK2YNuwHdgubA+2DzuAHcKOYMewE9gp7Ax2DruAXcKuYNewG9gt7A52D3uAPcKeYM+wT7DPsC+wr7BvsO+wF9gP2Ktf/HMLgYXCwmDhsAhYJCwKFg2LgcXC4mDxsARYIiwJlgxLgaXC0mDpsAxYJiwLlg3LgeXC8mD5sAJYIawIVgwrgZXCymDlsApYJawK9hr2BvYW9g72HvYB9hFWDauB1cLqYPWwBlgjrAnWDGuBtcLaYO2wDlgnrAvWDeuB9cL6YP2wAdggbAg2DBuBjcLGYOOwCdgkbAo2DZuBzcLmYPOwBdgibAm2DFuBrcLWYOuwDdgmbAu2DduB7cL2YPuwA9gh7Ah2DDuBncLOYOewC9gl7Ap2DbuB3cLuYPewB9gj7An2DPsE+wz7AvsK+wb7DnuB/YC9Cvu5hcBCYWGwcFgELBIWBYuGxcBiYXGweFgCLBGWBEuGpcBSYWmwdFgGLBOWBcuG5cByYXmwfFgBrBBWBCuGlcBKYWWwclgFrBJWBXsNewN7C3sHew/7APsIq4bVwGphdbB6WAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEDYEG4aNwEZhY7Bx2ARsEjYFm4bNwGZhc7B52AJsEbYEW4atwFZha7B12AZsE7YF24btwHZhe7B92AHsEHYEO4adwE5hZ7Bz2AXsEnYFu4bdwG5hd7B72APsEfYEe4Z9gn2GfYF9hX2DfYe9wH7AXv2Sn1sILBQWBguHRcAiYVGwaFgMLBYWB4uHJcASYUmwZFgKLBWWBkuHZcAyYVmwbFgOLBeWB8uHFcAKYUWwYlgJrBRWBiuHVcAqYVWw17A3sLewd7D3sA+wj7BqWA2sFlYHq4c1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhQ7Bh2AhsFDYGG4dNwCZhU7Bp2AxsFjYHm4ctwBZhS7Bl2ApsFbYGW4dtwDZhW7Bt2A5sF7YH24cdwA5hR7Bj2AnsFHYGO4ddwC5hV7Br2A3sFnYHu4c9wB5hT7Bn2CfYZ9gX2FfYN9h32AvsB+xV+M8tBBYKC4OFwyJgkbAoWDQsBhYLi4PFwxJgibAkWDIsBZYKS4OlwzJgmbAsWDYsB5YLy4PlwwpghbAiWDGsBFYKK4OVwypglbAq2GvYG9hb2DvYe9gH2EdYNawGVgurg9XDGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsCHYMGwENgobg43DJmCTsCnYNGwGNgubg83DFmCLsCXYMmwFtgpbg63DNmCbsC3YNmwHtgvbg+3DDmCHsCPYMewEdgo7g53DLmCXsCvYNewGdgu7g93DHmCPsCfYM+wT7DPsC+wr7BvsO+wF9gP26pf+3EJgobAwWDgsAhYJi4JFw2JgsbA4WDwsAZYIS4Ilw1JgqbA0WDosA5YJy4Jlw3JgubA8WD6sAFYIK4IVw0pgpbAyWDmsAlYJq4K9hr2BvYW9g72HfYB9hFXDamC1sDpYPawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANggbgg3DRmCjsDHYOGwCNgmbgk3DZmCzsDnYPGwBtghbgi3DVmCrsDXYOmwDtgnbgm3DdmC7sD3YPuwAdgg7gh3DTmCnsDPYOewCdgm7gl3DbmC3sDvYPewB9gh7gj3DPsE+w77AvsK+wb7DXmA/YK8ifm4hsFBYGCwcFgGLhEXBomExsFhYHCwelgBLhCXBkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBXsPewN7C3sHewz7APsKqYTWwWlgdrB7WAGuENcGaYS2wVlgbrB3WAeuEdcG6YT2wXlgfrB82ABuEDcGGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwXdgebB92ADuEHcGOYSewU9gZ7Bx2AbuEXcGuYTewW9gd7B72AHuEPcGeYZ9gn2FfYF9h32DfYS+wH7BXv+znFgILhYXBwmERsEhYFCwaFgOLhcXB4mEJsERYEiwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFew17A3sLewd7D3sA+wjrBpWA6uF1cHqYQ2wRlgTrBnWAmuFtcHaYR2wTlgXrBvWA+uF9cH6YQOwQdgQbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A9uF7cH2YQewQ9gR7Bh2AjuFncHOYRewS9gV7Bp2A7uF3cHuYQ+wR9gT7Bn2CfYZ9gX2FfYN9h32AvsBexX5cwuBhcLCYOGwCFgkLAoWDYuBxcLiYPGwBFgiLAmWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAr2GvYG9hb2DvYe9gH2EVYNq4HVwupg9bAGWCOsCdYMa4G1wtpg7bAOWCesC9YN64H1wvpg/bAB2CBsCDYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24HtwvZg+7AD2CHsCHYMO4Gdws5g57AL2CXsCnYNu4Hdwu5g97AH2CPsCfYM+wT7DPsC+wr7BvsOe4H9gL365T+3EFgoLAwWDouARcKiYNGwGFgsLA4WD0uAJcKSYMmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYK9hb2BvYe9g72EfYB9h1bAaWC2sDlYPa4A1wppgzbAWWCusDdYO64B1wrpg3bAeWC+sD9YPG4ANwoZgw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27Ad2C5sD7YPO4Adwo5gx7AT2CnsDHYOu4Bdwq5g17Ab2C3sDnYPe4A9wp5gz7BPsM+wL7CvsG+w77AX2A/Yq6ifWwgsFBYGC4dFwCJhUbBoWAwsFhYHi4clwBJhSbBkWAosFZYGS4dlwDJhWbBsWA4sF5YHy4cVwAphRbBiWAmsFFYGK4dVwCphVbDXsDewt7B3sPewD7CPsGpYDawWVgerhzXAGmFNsGZYC6wV1gZrh3XAOmFdsG5YD6wX1gfrhw3ABmFDsGHYCGwUNgYbh03AJmFTsGnYDGwWNgebhy3AFmFLsGXYCmwVtgZbh23ANmFbsG3YDmwXtgfbhx3ADmFHsGPYCewUdgY7h13ALmFXsGvYDewWdge7hz3AHmFPsGfYJ9hn2BfYV9g32HfYC+wH7NWv+LmFwEJhYbBwWAQsEhYFi4bFwGJhcbB4WAIsEZYES4alwFJhabB0WAYsE5YFy4blwHJhebB8WAGsEFYEK4aVwEphZbByWAWsElYFew17A3sLewd7D/sA+wirhtXAamF1sHpYA6wR1gRrhrXAWmFtsHZYB6wT1gXrhvXAemF9sH7YAGwQNgQbho3ARmFjsHHYBGwSNgWbhs3AZmFzsHnYAmwRtgRbhq3AVmFrsHXYBmwTtgXbhu3AdmF7sH3YAewQdgQ7hp3ATmFnsHPYBewSdgW7ht3AbmF3sHvYA+wR9gR7hn2CfYZ9gX2FfYN9h73AfsBeRf/cQmChsDBYOCwCFgmLgkXDYmCxsDhYPCwBlghLgiXDUmCpsDRYOiwDlgnLgmXDcmC5sDxYPqwAVggrghXDSmClsDJYOawCVgmrgr2GvYG9hb2DvYd9gH2EVcNqYLWwOlg9rAHWCGuCNcNaYK2wNlg7rAPWCeuCdcN6YL2wPlg/bAA2CBuCDcNGYKOwMdg4bAI2CZuCTcNmYLOwOdg8bAG2CFuCLcNWYKuwNdg6bAO2CduCbcN2YLuwPdg+7AB2CDuCHcNOYKewM9g57AJ2CbuCXcNuYLewO9g97AH2CHuCPcM+wT7DvsC+wr7BvsNeYD9gr37lzy0EFgoLg4XDImCRsChYNCwGFguLg8XDEmCJsCRYMiwFlgpLg6XDMmCZsCxYNiwHlgvLg+XDCmCFsCJYMawEVgorg5XDKmCVsCrYa9gb2FvYO9h72AfYR1g1rAZWC6uD1cMaYI2wJlgzrAXWCmuDtcM6YJ2wLlg3rAfWC+uD9cMGYIOwIdgwbAQ2ChuDjcMmYJOwKdg0bAY2C5uDzcMWYIuwJdgybAW2CluDrcM2YJuwLdg2bAe2C9uD7cMOYIewI9gx7AR2CjuDncMuYJewK9g17AZ2C7uD3cMeYI+wJ9gz7BPsM+wL7CvsG+w77AX2A/Yq5ucWAguFhcHCYRGwSFgULBoWA4uFxcHiYQmwRFgSLBmWAkuFpcHSYRmwTFgWLBuWA8uF5cHyYQWwQlgRrBhWAiuFlcHKYRWwSlgV7DXsDewt7B3sPewD7COsGlYDq4XVwephDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2BBsGDYCG4WNwcZhE7BJ2BRsGjYDm4XNweZhC7BF2BJsGbYCW4WtwdZhG7BN2BZsG7YD24XtwfZhB7BD2BHsGHYCO4Wdwc5hF7BL2BXsGnYDu4Xdwe5hD7BH2BPsGfYJ9hn2BfYV9g32HfYC+wF79at+biGwUFgYLBwWAYuERcGiYTGwWFgcLB6WAEuEJcGSYSmwVFgaLB2WAcuEZcGyYTmwXFgeLB9WACuEFcGKYSWwUlgZrBxWAauEVcFew97A3sLewd7DPsA+wqphNbBaWB2sHtYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4QNwYZhI7BR2BhsHDYBm4RNwaZhM7BZ2BxsHrYAW4QtwZZhK7BV2BpsHbYB24RtwbZhO7Bd2B5sH3YAO4QdwY5hJ7BT2BnsHHYBu4Rdwa5hN7Bb2B3sHvYAe4Q9wZ5hn2CfYV9gX2HfYN9hL7AfsFexP7cQWCgsDBYOi4BFwqJg0bAYWCwsDhYPS4AlwpJgybAUWCosDZYOy4BlwrJg2bAcWC4sD5YPK4AVwopgxbASWCmsDFYOq4BVwqpgr2FvYG9h72DvYR9gH2HVsBpYLawOVg9rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3ChmDDsBHYKGwMNg6bgE3CpmDTsBnYLGwONg9bgC3ClmDLsBXYKmwNtg7bgG3CtmDbsB3YLmwPtg87gB3CjmDHsBPYKewMdg67gF3CrmDXsBvYLewOdg97gD3CnmDPsE+wz7AvsK+wb7DvsBfYD9irX/1zC4GFwsJg4bAIWCQsChYNi4HFwuJg8bAEWCIsCZYMS4GlwtJg6bAMWCYsC5YNy4HlwvJg+bACWCGsCFYMK4GVwspg5bAKWCWsCvYa9gb2FvYO9h72AfYRVg2rgdXC6mD1sAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIGwINgwbgY3CxmDjsAnYJGwKNg2bgc3C5mDzsAXYImwJtgxbga3C1mDrsA3YJmwLtg3bge3C9mD7sAPYIewIdgw7gZ3CzmDnsAvYJewKdg27gd3C7mD3sAfYI+wJ9gz7BPsM+wL7CvsG+w57gf2AvYr7uYXAQmFhsHBYBCwSFgWLhsXAYmFxsHhYAiwRlgRLhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgV7DXsDewt7B3sP+wD7CKuG1cBqYXWwelgDrBHWBGuGtcBaYW2wdlgHrBPWBeuG9cB6YX2wftgAbBA2BBuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cB2YXuwfdgB7BB2BDuGncBOYWewc9gF7BJ2BbuG3cBuYXewe9gD7BH2BHuGfYJ9hn2BfYV9g32HvcB+wF79mp9bCCwUFgYLh0XAImFRsGhYDCwWFgeLhyXAEmFJsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsNewN7C3sHew97APsI+walgNrBZWB6uHNcAaYU2wZlgLrBXWBmuHdcA6YV2wblgPrBfWB+uHDcAGYUOwYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgObBe2B9uHHcAOYUewY9gJ7BR2BjuHXcAuYVewa9gN7BZ2B7uHPcAeYU+wZ9gn2GfYF9hX2DfYd9gL7AfsVfzPLQQWCguDhcMiYJGwKFg0LAYWC4uDxcMSYImwJFgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKthr2BvYW9g72HvYB9hHWDWsBlYLq4PVwxpgjbAmWDOsBdYKa4O1wzpgnbAuWDesB9YL64P1wwZgg7Ah2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB7YL24Ptww5gh7Aj2DHsBHYKO4Odwy5gl7Ar2DXsBnYLu4Pdwx5gj7An2DPsE+wz7AvsK+wb7DvsBfYD9urX/txCYKGwMFg4LAIWCYuCRcNiYLGwOFg8LAGWCEuCJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCvYa9gb2FvYO9h32AfYRVw2pgtbA6WD2sAdYIa4I1w1pgrbA2WDusA9YJ64J1w3pgvbA+WD9sADYIG4INw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3Zgu7A92D7sAHYIO4Idw05gp7Az2DnsAnYJu4Jdw25gt7A72D3sAfYIe4I9wz7BPsO+wL7CvsG+w15gP2CvEn5uIbBQWBgsHBYBi4RFwaJhMbBYWBwsHpYAS4QlwZJhKbBUWBosHZYBy4RlwbJhObBcWB4sH1YAK4QVwYphJbBSWBmsHFYBq4RVwV7D3sDewt7B3sM+wD7CqmE1sFpYHawe1gBrhDXBmmEtsFZYG6wd1gHrhHXBumE9sF5YH6wfNgAbhA3BhmEjsFHYGGwcNgGbhE3BpmEzsFnYHGwetgBbhC3BlmErsFXYGmwdtgHbhG3BtmE7sF3YHmwfdgA7hB3BjmEnsFPYGewcdgG7hF3BrmE3sFvYHewe9gB7hD3BnmGfYJ9hX2BfYd9g32EvsB+wV7/u5xYCC4WFwcJhEbBIWBQsGhYDi4XFweJhCbBEWBIsGZYCS4WlwdJhGbBMWBYsG5YDy4XlwfJhBbBCWBGsGFYCK4WVwcphFbBKWBXsNewN7C3sHew97APsI6waVgOrhdXB6mENsEZYE6wZ1gJrhbXB2mEdsE5YF6wb1gPrhfXB+mEDsEHYEGwYNgIbhY3BxmETsEnYFGwaNgObhc3B5mELsEXYEmwZtgJbha3B1mEbsE3YFmwbtgPbhe3B9mEHsEPYEewYdgI7hZ3BzmEXsEvYFewadgO7hd3B7mEPsEfYE+wZ9gn2GfYF9hX2DfYd9gL7AXuV+HMLgYXCwmDhsAhYJCwKFg2LgcXC4mDxsARYIiwJlgxLgaXC0mDpsAxYJiwLlg3LgeXC8mD5sAJYIawIVgwrgZXCymDlsApYJawK9hr2BvYW9g72HvYB9hFWDauB1cLqYPWwBlgjrAnWDGuBtcLaYO2wDlgnrAvWDeuB9cL6YP2wAdggbAg2DBuBjcLGYOOwCdgkbAo2DZuBzcLmYPOwBdgibAm2DFuBrcLWYOuwDdgmbAu2DduB7cL2YPuwA9gh7Ah2DDuBncLOYOewC9gl7Ap2DbuB3cLuYPewB9gj7An2DPsE+wz7AvsK+wb7DnuB/YC9+vU/txBYKCwMFg6LgEXComDRsBhYLCwOFg9LgCXCkmDJsBRYKiwNlg7LgGXCsmDZsBxYLiwPlg8rgBXCimDFsBJYKawMVg6rgFXCqmCvYW9gb2HvYO9hH2AfYdWwGlgtrA5WD2uANcKaYM2wFlgrrA3WDuuAdcK6YN2wHlgvrA/WDxuADcKGYMOwEdgobAw2DpuATcKmYNOwGdgsbA42D1uALcKWYMuwFdgqbA22DtuAbcK2YNuwHdgubA+2DzuAHcKOYMewE9gp7Ax2DruAXcKuYNewG9gt7A52D3uAPcKeYM+wT7DPsC+wr7BvsO+wF9gP2Kukn1sILBQWBguHRcAiYVGwaFgMLBYWB4uHJcASYUmwZFgKLBWWBkuHZcAyYVmwbFgOLBeWB8uHFcAKYUWwYlgJrBRWBiuHVcAqYVWw17A3sLewd7D3sA+wj7BqWA2sFlYHq4c1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhQ7Bh2AhsFDYGG4dNwCZhU7Bp2AxsFjYHm4ctwBZhS7Bl2ApsFbYGW4dtwDZhW7Bt2A5sF7YH24cdwA5hR7Bj2AnsFHYGO4ddwC5hV7Br2A3sFnYHu4c9wB5hT7Bn2CfYZ9gX2FfYN9h32AvsB+zV3/JzC4GFwsJg4bAIWCQsChYNi4HFwuJg8bAEWCIsCZYMS4GlwtJg6bAMWCYsC5YNy4HlwvJg+bACWCGsCFYMK4GVwspg5bAKWCWsCvYa9gb2FvYO9h72AfYRVg2rgdXC6mD1sAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIGwINgwbgY3CxmDjsAnYJGwKNg2bgc3C5mDzsAXYImwJtgxbga3C1mDrsA3YJmwLtg3bge3C9mD7sAPYIewIdgw7gZ3CzmDnsAvYJewKdg27gd3C7mD3sAfYI+wJ9gz7BPsM+wL7CvsG+w57gf2AvUr+uYXAQmFhsHBYBCwSFgWLhsXAYmFxsHhYAiwRlgRLhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgV7DXsDewt7B3sP+wD7CKuG1cBqYXWwelgDrBHWBGuGtcBaYW2wdlgHrBPWBeuG9cB6YX2wftgAbBA2BBuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cB2YXuwfdgB7BB2BDuGncBOYWewc9gF7BJ2BbuG3cBuYXewe9gD7BH2BHuGfYJ9hn2BfYV9g32HvcB+wF79hp9bCCwUFgYLh0XAImFRsGhYDCwWFgeLhyXAEmFJsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsNewN7C3sHew97APsI+walgNrBZWB6uHNcAaYU2wZlgLrBXWBmuHdcA6YV2wblgPrBfWB+uHDcAGYUOwYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgObBe2B9uHHcAOYUewY9gJ7BR2BjuHXcAuYVewa9gN7BZ2B7uHPcAeYU+wZ9gn2GfYF9hX2DfYd9gL7AfsVcrPLQQWCguDhcMiYJGwKFg0LAYWC4uDxcMSYImwJFgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKthr2BvYW9g72HvYB9hHWDWsBlYLq4PVwxpgjbAmWDOsBdYKa4O1wzpgnbAuWDesB9YL64P1wwZgg7Ah2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB7YL24Ptww5gh7Aj2DHsBHYKO4Odwy5gl7Ar2DXsBnYLu4Pdwx5gj7An2DPsE+wz7AvsK+wb7DvsBfYD9uo3/txCYKGwMFg4LAIWCYuCRcNiYLGwOFg8LAGWCEuCJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCvYa9gb2FvYO9h32AfYRVw2pgtbA6WD2sAdYIa4I1w1pgrbA2WDusA9YJ64J1w3pgvbA+WD9sADYIG4INw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3Zgu7A92D7sAHYIO4Idw05gp7Az2DnsAnYJu4Jdw25gt7A72D3sAfYIe4I9wz7BPsO+wL7CvsG+w15gP2CvUn9uIbBQWBgsHBYBi4RFwaJhMbBYWBwsHpYAS4QlwZJhKbBUWBosHZYBy4RlwbJhObBcWB4sH1YAK4QVwYphJbBSWBmsHFYBq4RVwV7D3sDewt7B3sM+wD7CqmE1sFpYHawe1gBrhDXBmmEtsFZYG6wd1gHrhHXBumE9sF5YH6wfNgAbhA3BhmEjsFHYGGwcNgGbhE3BpmEzsFnYHGwetgBbhC3BlmErsFXYGmwdtgHbhG3BtmE7sF3YHmwfdgA7hB3BjmEnsFPYGewcdgG7hF3BrmE3sFvYHewe9gB7hD3BnmGfYJ9hX2BfYd9g32EvsB+wV7/p5xYCC4WFwcJhEbBIWBQsGhYDi4XFweJhCbBEWBIsGZYCS4WlwdJhGbBMWBYsG5YDy4XlwfJhBbBCWBGsGFYCK4WVwcphFbBKWBXsNewN7C3sHew97APsI6waVgOrhdXB6mENsEZYE6wZ1gJrhbXB2mEdsE5YF6wb1gPrhfXB+mEDsEHYEGwYNgIbhY3BxmETsEnYFGwaNgObhc3B5mELsEXYEmwZtgJbha3B1mEbsE3YFmwbtgPbhe3B9mEHsEPYEewYdgI7hZ3BzmEXsEvYFewadgO7hd3B7mEPsEfYE+wZ9gn2GfYF9hX2DfYd9gL7AXuV9nMLgYXCwmDhsAhYJCwKFg2LgcXC4mDxsARYIiwJlgxLgaXC0mDpsAxYJiwLlg3LgeXC8mD5sAJYIawIVgwrgZXCymDlsApYJawK9hr2BvYW9g72HvYB9hFWDauB1cLqYPWwBlgjrAnWDGuBtcLaYO2wDlgnrAvWDeuB9cL6YP2wAdggbAg2DBuBjcLGYOOwCdgkbAo2DZuBzcLmYPOwBdgibAm2DFuBrcLWYOuwDdgmbAu2DduB7cL2YPuwA9gh7Ah2DDuBncLOYOewC9gl7Ap2DbuB3cLuYPewB9gj7An2DPsE+wz7AvsK+wb7DnuB/YC9+s0/txBYKCwMFg6LgEXComDRsBhYLCwOFg9LgCXCkmDJsBRYKiwNlg7LgGXCsmDZsBxYLiwPlg8rgBXCimDFsBJYKawMVg6rgFXCqmCvYW9gb2HvYO9hH2AfYdWwGlgtrA5WD2uANcKaYM2wFlgrrA3WDuuAdcK6YN2wHlgvrA/WDxuADcKGYMOwEdgobAw2DpuATcKmYNOwGdgsbA42D1uALcKWYMuwFdgqbA22DtuAbcK2YNuwHdgubA+2DzuAHcKOYMewE9gp7Ax2DruAXcKuYNewG9gt7A52D3uAPcKeYM+wT7DPsC+wr7BvsO+wF9gP2Kv0n1sILBQWBguHRcAiYVGwaFgMLBYWB4uHJcASYUmwZFgKLBWWBkuHZcAyYVmwbFgOLBeWB8uHFcAKYUWwYlgJrBRWBiuHVcAqYVWw17A3sLewd7D3sA+wj7BqWA2sFlYHq4c1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhQ7Bh2AhsFDYGG4dNwCZhU7Bp2AxsFjYHm4ctwBZhS7Bl2ApsFbYGW4dtwDZhW7Bt2A5sF7YH24cdwA5hR7Bj2AnsFHYGO4ddwC5hV7Br2A3sFnYHu4c9wB5hT7Bn2CfYZ9gX2FfYN9h32AvsB+zVb/m5hcBCYWGwcFgELBIWBYuGxcBiYXGweFgCLBGWBEuGpcBSYWmwdFgGLBOWBcuG5cByYXmwfFgBrBBWBCuGlcBKYWWwclgFrBJWBXsNewN7C3sHew/7APsIq4bVwGphdbB6WAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEDYEG4aNwEZhY7Bx2ARsEjYFm4bNwGZhc7B52AJsEbYEW4atwFZha7B12AZsE7YF24btwHZhe7B92AHsEHYEO4adwE5hZ7Bz2AXsEnYFu4bdwG5hd7B72APsEfYEe4Z9gn2GfYF9hX2DfYe9wH7AXmX83EJgobAwWDgsAhYJi4JFw2JgsbA4WDwsAZYIS4Ilw1JgqbA0WDosA5YJy4Jlw3JgubA8WD6sAFYIK4IVw0pgpbAyWDmsAlYJq4K9hr2BvYW9g72HfYB9hFXDamC1sDpYPawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANggbgg3DRmCjsDHYOGwCNgmbgk3DZmCzsDnYPGwBtghbgi3DVmCrsDXYOmwDtgnbgm3DdmC7sD3YPuwAdgg7gh3DTmCnsDPYOewCdgm7gl3DbmC3sDvYPewB9gh7gj3DPsE+w77AvsK+wb7DXmA/YK9+688tBBYKC4OFwyJgkbAoWDQsBhYLi4PFwxJgibAkWDIsBZYKS4OlwzJgmbAsWDYsB5YLy4PlwwpghbAiWDGsBFYKK4OVwypglbAq2GvYG9hb2DvYe9gH2EdYNawGVgurg9XDGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsCHYMGwENgobg43DJmCTsCnYNGwGNgubg83DFmCLsCXYMmwFtgpbg63DNmCbsC3YNmwHtgvbg+3DDmCHsCPYMewEdgo7g53DLmCXsCvYNewGdgu7g93DHmCPsCfYM+wT7DPsC+wr7BvsO+wF9gP2KvPnFgILhYXBwmERsEhYFCwaFgOLhcXB4mEJsERYEiwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFew17A3sLewd7D3sA+wjrBpWA6uF1cHqYQ2wRlgTrBnWAmuFtcHaYR2wTlgXrBvWA+uF9cH6YQOwQdgQbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A9uF7cH2YQewQ9gR7Bh2AjuFncHOYRewS9gV7Bp2A7uF3cHuYQ+wR9gT7Bn2CfYZ9gX2FfYN9h32AvsBe/Xbfm4hsFBYGCwcFgGLhEXBomExsFhYHCwelgBLhCXBkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBXsPewN7C3sHewz7APsKqYTWwWlgdrB7WAGuENcGaYS2wVlgbrB3WAeuEdcG6YT2wXlgfrB82ABuEDcGGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwXdgebB92ADuEHcGOYSewU9gZ7Bx2AbuEXcGuYTewW9gd7B72AHuEPcGeYZ9gn2FfYF9h32DfYS+wH7BXWT+3EFgoLAwWDouARcKiYNGwGFgsLA4WD0uAJcKSYMmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYK9hb2BvYe9g72EfYB9h1bAaWC2sDlYPa4A1wppgzbAWWCusDdYO64B1wrpg3bAeWC+sD9YPG4ANwoZgw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27Ad2C5sD7YPO4Adwo5gx7AT2CnsDHYOu4Bdwq5g17Ab2C3sDnYPe4A9wp5gz7BPsM+wL7CvsG+w77AX2A/Yq9/+cwuBhcLCYOGwCFgkLAoWDYuBxcLiYPGwBFgiLAmWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAr2GvYG9hb2DvYe9gH2EVYNq4HVwupg9bAGWCOsCdYMa4G1wtpg7bAOWCesC9YN64H1wvpg/bAB2CBsCDYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24HtwvZg+7AD2CHsCHYMO4Gdws5g57AL2CXsCnYNu4Hdwu5g97AH2CPsCfYM+wT7DPsC+wr7BvsOe4H9gL3K/rmFwEJhYbBwWAQsEhYFi4bFwGJhcbB4WAIsEZYES4alwFJhabB0WAYsE5YFy4blwHJhebB8WAGsEFYEK4aVwEphZbByWAWsElYFew17A3sLewd7D/sA+wirhtXAamF1sHpYA6wR1gRrhrXAWmFtsHZYB6wT1gXrhvXAemF9sH7YAGwQNgQbho3ARmFjsHHYBGwSNgWbhs3AZmFzsHnYAmwRtgRbhq3AVmFrsHXYBmwTtgXbhu3AdmF7sH3YAewQdgQ7hp3ATmFnsHPYBewSdgW7ht3AbmF3sHvYA+wR9gR7hn2CfYZ9gX2FfYN9h73AfsBe/Y6fWwgsFBYGC4dFwCJhUbBoWAwsFhYHi4clwBJhSbBkWAosFZYGS4dlwDJhWbBsWA4sF5YHy4cVwAphRbBiWAmsFFYGK4dVwCphVbDXsDewt7B3sPewD7CPsGpYDawWVgerhzXAGmFNsGZYC6wV1gZrh3XAOmFdsG5YD6wX1gfrhw3ABmFDsGHYCGwUNgYbh03AJmFTsGnYDGwWNgebhy3AFmFLsGXYCmwVtgZbh23ANmFbsG3YDmwXtgfbhx3ADmFHsGPYCewUdgY7h13ALmFXsGvYDewWdge7hz3AHmFPsGfYJ9hn2BfYV9g32HfYC+wH7FXOzy0EFgoLg4XDImCRsChYNCwGFguLg8XDEmCJsCRYMiwFlgpLg6XDMmCZsCxYNiwHlgvLg+XDCmCFsCJYMawEVgorg5XDKmCVsCrYa9gb2FvYO9h72AfYR1g1rAZWC6uD1cMaYI2wJlgzrAXWCmuDtcM6YJ2wLlg3rAfWC+uD9cMGYIOwIdgwbAQ2ChuDjcMmYJOwKdg0bAY2C5uDzcMWYIuwJdgybAW2CluDrcM2YJuwLdg2bAe2C9uD7cMOYIewI9gx7AR2CjuDncMuYJewK9g17AZ2C7uD3cMeYI+wJ9gz7BPsM+wL7CvsG+w77AX2A/bqd/7cQmChsDBYOCwCFgmLgkXDYmCxsDhYPCwBlghLgiXDUmCpsDRYOiwDlgnLgmXDcmC5sDxYPqwAVggrghXDSmClsDJYOawCVgmrgr2GvYG9hb2DvYd9gH2EVcNqYLWwOlg9rAHWCGuCNcNaYK2wNlg7rAPWCeuCdcN6YL2wPlg/bAA2CBuCDcNGYKOwMdg4bAI2CZuCTcNmYLOwOdg8bAG2CFuCLcNWYKuwNdg6bAO2CduCbcN2YLuwPdg+7AB2CDuCHcNOYKewM9g57AJ2CbuCXcNuYLewO9g97AH2CHuCPcM+wT7DvsC+wr7BvsNeYD9gr3J/biGwUFgYLBwWAYuERcGiYTGwWFgcLB6WAEuEJcGSYSmwVFgaLB2WAcuEZcGyYTmwXFgeLB9WACuEFcGKYSWwUlgZrBxWAauEVcFew97A3sLewd7DPsA+wqphNbBaWB2sHtYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4QNwYZhI7BR2BhsHDYBm4RNwaZhM7BZ2BxsHrYAW4QtwZZhK7BV2BpsHbYB24RtwbZhO7Bd2B5sH3YAO4QdwY5hJ7BT2BnsHHYBu4Rdwa5hN7Bb2B3sHvYAe4Q9wZ5hn2CfYV9gX2HfYN9hL7AfsFe/6+cWAguFhcHCYRGwSFgULBoWA4uFxcHiYQmwRFgSLBmWAkuFpcHSYRmwTFgWLBuWA8uF5cHyYQWwQlgRrBhWAiuFlcHKYRWwSlgV7DXsDewt7B3sPewD7COsGlYDq4XVwephDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2BBsGDYCG4WNwcZhE7BJ2BRsGjYDm4XNweZhC7BF2BJsGbYCW4WtwdZhG7BN2BZsG7YD24XtwfZhB7BD2BHsGHYCO4Wdwc5hF7BL2BXsGnYDu4Xdwe5hD7BH2BPsGfYJ9hn2BfYV9g32HfYC+wF7lfdzC4GFwsJg4bAIWCQsChYNi4HFwuJg8bAEWCIsCZYMS4GlwtJg6bAMWCYsC5YNy4HlwvJg+bACWCGsCFYMK4GVwspg5bAKWCWsCvYa9gb2FvYO9h72AfYRVg2rgdXC6mD1sAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIGwINgwbgY3CxmDjsAnYJGwKNg2bgc3C5mDzsAXYImwJtgxbga3C1mDrsA3YJmwLtg3bge3C9mD7sAPYIewIdgw7gZ3CzmDnsAvYJewKdg27gd3C7mD3sAfYI+wJ9gz7BPsM+wL7CvsG+w57gf2AvfrdP7cQWCgsDBYOi4BFwqJg0bAYWCwsDhYPS4AlwpJgybAUWCosDZYOy4BlwrJg2bAcWC4sD5YPK4AVwopgxbASWCmsDFYOq4BVwqpgr2FvYG9h72DvYR9gH2HVsBpYLawOVg9rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3ChmDDsBHYKGwMNg6bgE3CpmDTsBnYLGwONg9bgC3ClmDLsBXYKmwNtg7bgG3CtmDbsB3YLmwPtg87gB3CjmDHsBPYKewMdg67gF3CrmDXsBvYLewOdg97gD3CnmDPsE+wz7AvsK+wb7DvsBfYD9ir/J9bCCwUFgYLh0XAImFRsGhYDCwWFgeLhyXAEmFJsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsNewN7C3sHew97APsI+walgNrBZWB6uHNcAaYU2wZlgLrBXWBmuHdcA6YV2wblgPrBfWB+uHDcAGYUOwYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgObBe2B9uHHcAOYUewY9gJ7BR2BjuHXcAuYVewa9gN7BZ2B7uHPcAeYU+wZ9gn2GfYF9hX2DfYd9gL7Afs1e/5uYXAQmFhsHBYBCwSFgWLhsXAYmFxsHhYAiwRlgRLhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgV7DXsDewt7B3sP+wD7CKuG1cBqYXWwelgDrBHWBGuGtcBaYW2wdlgHrBPWBeuG9cB6YX2wftgAbBA2BBuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cB2YXuwfdgB7BB2BDuGncBOYWewc9gF7BJ2BbuG3cBuYXewe9gD7BH2BHuGfYJ9hn2BfYV9g32HvcB+wF4V/NxCYKGwMFg4LAIWCYuCRcNiYLGwOFg8LAGWCEuCJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCvYa9gb2FvYO9h32AfYRVw2pgtbA6WD2sAdYIa4I1w1pgrbA2WDusA9YJ64J1w3pgvbA+WD9sADYIG4INw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3Zgu7A92D7sAHYIO4Idw05gp7Az2DnsAnYJu4Jdw25gt7A72D3sAfYIe4I9wz7BPsO+wL7CvsG+w15gP2Cvfu/PLQQWCguDhcMiYJGwKFg0LAYWC4uDxcMSYImwJFgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKthr2BvYW9g72HvYB9hHWDWsBlYLq4PVwxpgjbAmWDOsBdYKa4O1wzpgnbAuWDesB9YL64P1wwZgg7Ah2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB7YL24Ptww5gh7Aj2DHsBHYKO4Odwy5gl7Ar2DXsBnYLu4Pdwx5gj7An2DPsE+wz7AvsK+wb7DvsBfYD9qrw5xYCC4WFwcJhEbBIWBQsGhYDi4XFweJhCbBEWBIsGZYCS4WlwdJhGbBMWBYsG5YDy4XlwfJhBbBCWBGsGFYCK4WVwcphFbBKWBXsNewN7C3sHew97APsI6waVgOrhdXB6mENsEZYE6wZ1gJrhbXB2mEdsE5YF6wb1gPrhfXB+mEDsEHYEGwYNgIbhY3BxmETsEnYFGwaNgObhc3B5mELsEXYEmwZtgJbha3B1mEbsE3YFmwbtgPbhe3B9mEHsEPYEewYdgI7hZ3BzmEXsEvYFewadgO7hd3B7mEPsEfYE+wZ9gn2GfYF9hX2DfYd9gL7AXv1+35uIbBQWBgsHBYBi4RFwaJhMbBYWBwsHpYAS4QlwZJhKbBUWBosHZYBy4RlwbJhObBcWB4sH1YAK4QVwYphJbBSWBmsHFYBq4RVwV7D3sDewt7B3sM+wD7CqmE1sFpYHawe1gBrhDXBmmEtsFZYG6wd1gHrhHXBumE9sF5YH6wfNgAbhA3BhmEjsFHYGGwcNgGbhE3BpmEzsFnYHGwetgBbhC3BlmErsFXYGmwdtgHbhG3BtmE7sF3YHmwfdgA7hB3BjmEnsFPYGewcdgG7hF3BrmE3sFvYHewe9gB7hD3BnmGfYJ9hX2BfYd9g32EvsB+wV0U/txBYKCwMFg6LgEXComDRsBhYLCwOFg9LgCXCkmDJsBRYKiwNlg7LgGXCsmDZsBxYLiwPlg8rgBXCimDFsBJYKawMVg6rgFXCqmCvYW9gb2HvYO9hH2AfYdWwGlgtrA5WD2uANcKaYM2wFlgrrA3WDuuAdcK6YN2wHlgvrA/WDxuADcKGYMOwEdgobAw2DpuATcKmYNOwGdgsbA42D1uALcKWYMuwFdgqbA22DtuAbcK2YNuwHdgubA+2DzuAHcKOYMewE9gp7Ax2DruAXcKuYNewG9gt7A52D3uAPcKeYM+wT7DPsC+wr7BvsO+wF9gP2Kvf/3MLgYXCwmDhsAhYJCwKFg2LgcXC4mDxsARYIiwJlgxLgaXC0mDpsAxYJiwLlg3LgeXC8mD5sAJYIawIVgwrgZXCymDlsApYJawK9hr2BvYW9g72HvYB9hFWDauB1cLqYPWwBlgjrAnWDGuBtcLaYO2wDlgnrAvWDeuB9cL6YP2wAdggbAg2DBuBjcLGYOOwCdgkbAo2DZuBzcLmYPOwBdgibAm2DFuBrcLWYOuwDdgmbAu2DduB7cL2YPuwA9gh7Ah2DDuBncLOYOewC9gl7Ap2DbuB3cLuYPewB9gj7An2DPsE+wz7AvsK+wb7DnuB/YC9Kv65hcBCYWGwcFgELBIWBYuGxcBiYXGweFgCLBGWBEuGpcBSYWmwdFgGLBOWBcuG5cByYXmwfFgBrBBWBCuGlcBKYWWwclgFrBJWBXsNewN7C3sHew/7APsIq4bVwGphdbB6WAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEDYEG4aNwEZhY7Bx2ARsEjYFm4bNwGZhc7B52AJsEbYEW4atwFZha7B12AZsE7YF24btwHZhe7B92AHsEHYEO4adwE5hZ7Bz2AXsEnYFu4bdwG5hd7B72APsEfYEe4Z9gn2GfYF9hX2DfYe9wH7AXv2Bn1sILBQWBguHRcAiYVGwaFgMLBYWB4uHJcASYUmwZFgKLBWWBkuHZcAyYVmwbFgOLBeWB8uHFcAKYUWwYlgJrBRWBiuHVcAqYVWw17A3sLewd7D3sA+wj7BqWA2sFlYHq4c1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhQ7Bh2AhsFDYGG4dNwCZhU7Bp2AxsFjYHm4ctwBZhS7Bl2ApsFbYGW4dtwDZhW7Bt2A5sF7YH24cdwA5hR7Bj2AnsFHYGO4ddwC5hV7Br2A3sFnYHu4c9wB5hT7Bn2CfYZ9gX2FfYN9h32AvsB+xVyc8tBBYKC4OFwyJgkbAoWDQsBhYLi4PFwxJgibAkWDIsBZYKS4OlwzJgmbAsWDYsB5YLy4PlwwpghbAiWDGsBFYKK4OVwypglbAq2GvYG9hb2DvYe9gH2EdYNawGVgurg9XDGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsCHYMGwENgobg43DJmCTsCnYNGwGNgubg83DFmCLsCXYMmwFtgpbg63DNmCbsC3YNmwHtgvbg+3DDmCHsCPYMewEdgo7g53DLmCXsCvYNewGdgu7g93DHmCPsCfYM+wT7DPsC+wr7BvsO+wF9gP26g/+3EJgobAwWDgsAhYJi4JFw2JgsbA4WDwsAZYIS4Ilw1JgqbA0WDosA5YJy4Jlw3JgubA8WD6sAFYIK4IVw0pgpbAyWDmsAlYJq4K9hr2BvYW9g72HfYB9hFXDamC1sDpYPawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANggbgg3DRmCjsDHYOGwCNgmbgk3DZmCzsDnYPGwBtghbgi3DVmCrsDXYOmwDtgnbgm3DdmC7sD3YPuwAdgg7gh3DTmCnsDPYOewCdgm7gl3DbmC3sDvYPewB9gh7gj3DPsE+w77AvsK+wb7DXmA/YK9Kf24hsFBYGCwcFgGLhEXBomExsFhYHCwelgBLhCXBkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBXsPewN7C3sHewz7APsKqYTWwWlgdrB7WAGuENcGaYS2wVlgbrB3WAeuEdcG6YT2wXlgfrB82ABuEDcGGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwXdgebB92ADuEHcGOYSewU9gZ7Bx2AbuEXcGuYTewW9gd7B72AHuEPcGeYZ9gn2FfYF9h32DfYS+wH7BXf+jnFgILhYXBwmERsEhYFCwaFgOLhcXB4mEJsERYEiwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFew17A3sLewd7D3sA+wjrBpWA6uF1cHqYQ2wRlgTrBnWAmuFtcHaYR2wTlgXrBvWA+uF9cH6YQOwQdgQbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A9uF7cH2YQewQ9gR7Bh2AjuFncHOYRewS9gV7Bp2A7uF3cHuYQ+wR9gT7Bn2CfYZ9gX2FfYN9h32AvsBe1X2cwuBhcLCYOGwCFgkLAoWDYuBxcLiYPGwBFgiLAmWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAr2GvYG9hb2DvYe9gH2EVYNq4HVwupg9bAGWCOsCdYMa4G1wtpg7bAOWCesC9YN64H1wvpg/bAB2CBsCDYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24HtwvZg+7AD2CHsCHYMO4Gdws5g57AL2CXsCnYNu4Hdwu5g97AH2CPsCfYM+wT7DPsC+wr7BvsOe4H9gL36wz+3EFgoLAwWDouARcKiYNGwGFgsLA4WD0uAJcKSYMmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYK9hb2BvYe9g72EfYB9h1bAaWC2sDlYPa4A1wppgzbAWWCusDdYO64B1wrpg3bAeWC+sD9YPG4ANwoZgw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27Ad2C5sD7YPO4Adwo5gx7AT2CnsDHYOu4Bdwq5g17Ab2C3sDnYPe4A9wp5gz7BPsM+wL7CvsG+w77AX2A/Yq/KfWwgsFBYGC4dFwCJhUbBoWAwsFhYHi4clwBJhSbBkWAosFZYGS4dlwDJhWbBsWA4sF5YHy4cVwAphRbBiWAmsFFYGK4dVwCphVbDXsDewt7B3sPewD7CPsGpYDawWVgerhzXAGmFNsGZYC6wV1gZrh3XAOmFdsG5YD6wX1gfrhw3ABmFDsGHYCGwUNgYbh03AJmFTsGnYDGwWNgebhy3AFmFLsGXYCmwVtgZbh23ANmFbsG3YDmwXtgfbhx3ADmFHsGPYCewUdgY7h13ALmFXsGvYDewWdge7hz3AHmFPsGfYJ9hn2BfYV9g32HfYC+wH7NUf+bmFwEJhYbBwWAQsEhYFi4bFwGJhcbB4WAIsEZYES4alwFJhabB0WAYsE5YFy4blwHJhebB8WAGsEFYEK4aVwEphZbByWAWsElYFew17A3sLewd7D/sA+wirhtXAamF1sHpYA6wR1gRrhrXAWmFtsHZYB6wT1gXrhvXAemF9sH7YAGwQNgQbho3ARmFjsHHYBGwSNgWbhs3AZmFzsHnYAmwRtgRbhq3AVmFrsHXYBmwTtgXbhu3AdmF7sH3YAewQdgQ7hp3ATmFnsHPYBewSdgW7ht3AbmF3sHvYA+wR9gR7hn2CfYZ9gX2FfYN9h73AfsBeVfzcQmChsDBYOCwCFgmLgkXDYmCxsDhYPCwBlghLgiXDUmCpsDRYOiwDlgnLgmXDcmC5sDxYPqwAVggrghXDSmClsDJYOawCVgmrgr2GvYG9hb2DvYd9gH2EVcNqYLWwOlg9rAHWCGuCNcNaYK2wNlg7rAPWCeuCdcN6YL2wPlg/bAA2CBuCDcNGYKOwMdg4bAI2CZuCTcNmYLOwOdg8bAG2CFuCLcNWYKuwNdg6bAO2CduCbcN2YLuwPdg+7AB2CDuCHcNOYKewM9g57AJ2CbuCXcNuYLewO9g97AH2CHuCPcM+wT7DvsC+wr7BvsNeYD9gr/7ozy0EFgoLg4XDImCRsChYNCwGFguLg8XDEmCJsCRYMiwFlgpLg6XDMmCZsCxYNiwHlgvLg+XDCmCFsCJYMawEVgorg5XDKmCVsCrYa9gb2FvYO9h72AfYR1g1rAZWC6uD1cMaYI2wJlgzrAXWCmuDtcM6YJ2wLlg3rAfWC+uD9cMGYIOwIdgwbAQ2ChuDjcMmYJOwKdg0bAY2C5uDzcMWYIuwJdgybAW2CluDrcM2YJuwLdg2bAe2C9uD7cMOYIewI9gx7AR2CjuDncMuYJewK9g17AZ2C7uD3cMeYI+wJ9gz7BPsM+wL7CvsG+w77AX2A/aq8ucWAguFhcHCYRGwSFgULBoWA4uFxcHiYQmwRFgSLBmWAkuFpcHSYRmwTFgWLBuWA8uF5cHyYQWwQlgRrBhWAiuFlcHKYRWwSlgV7DXsDewt7B3sPewD7COsGlYDq4XVwephDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2BBsGDYCG4WNwcZhE7BJ2BRsGjYDm4XNweZhC7BF2BJsGbYCW4WtwdZhG7BN2BZsG7YD24XtwfZhB7BD2BHsGHYCO4Wdwc5hF7BL2BXsGnYDu4Xdwe5hD7BH2BPsGfYJ9hn2BfYV9g32HfYC+wF79cd+biGwUFgYLBwWAYuERcGiYTGwWFgcLB6WAEuEJcGSYSmwVFgaLB2WAcuEZcGyYTmwXFgeLB9WACuEFcGKYSWwUlgZrBxWAauEVcFew97A3sLewd7DPsA+wqphNbBaWB2sHtYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4QNwYZhI7BR2BhsHDYBm4RNwaZhM7BZ2BxsHrYAW4QtwZZhK7BV2BpsHbYB24RtwbZhO7Bd2B5sH3YAO4QdwY5hJ7BT2BnsHHYBu4Rdwa5hN7Bb2B3sHvYAe4Q9wZ5hn2CfYV9gX2HfYN9hL7AfsFdVP7cQWCgsDBYOi4BFwqJg0bAYWCwsDhYPS4AlwpJgybAUWCosDZYOy4BlwrJg2bAcWC4sD5YPK4AVwopgxbASWCmsDFYOq4BVwqpgr2FvYG9h72DvYR9gH2HVsBpYLawOVg9rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3ChmDDsBHYKGwMNg6bgE3CpmDTsBnYLGwONg9bgC3ClmDLsBXYKmwNtg7bgG3CtmDbsB3YLmwPtg87gB3CjmDHsBPYKewMdg67gF3CrmDXsBvYLewOdg97gD3CnmDPsN9f99fWP/mn/+x4zcRvu/kbrfiv2584/+2zHVURf+ZvtN/X9vN9RW0/3/cL8/8B+wQ2OMjEPwA=", - "debug_symbols": "tNzBbm1bcp3pd8m2GivmmDEjwq9SKBiyLRsCBNmQ5eoYfve693DNf2QKIEVfZnac20mK2nEO/0Ee7o/633/6L//wn/7Xf/uP//jP//W//88//Yf/53//6T/9yz/+0z/943/7j//03//z3//rP/73f/7tv/3f/+fv/nT/v//xX//lH/7ht//qT3/29t/+p/7H3//LP/zzv/7pP/zz//qnf/q7P/1/f/9P/+vXO/3P//H3//zrP//17//lt7c+f/enf/jn//Lbf/72Af/rP/7TP/z+6P/8nf+nn8//RyOk9386IjcfIP/yI8TnH2HP3P/9+UTyEeovP8L6/CMcVbwf4Wjms4+gLz7C0tyPsNIfof/YRyj9oY/QzRWrPvsI5/OPkHX/Kk74rzL6289AmTyDrj9yg3Lfj7Cf/uwjzA9v+OpzIXXuB8ijzz4XIn78yfDtD/H5Z8PXH+Jbnw6xf/hn+eVz+N4nxL/zIb7zGRH1N/yUKDEPtfVHBubPP8Lnn1Tr+fEn1bc/xOefVF9/iG99Ui399G/j+fEn1b/zIb7zSbXO3/CTqrvuB+ipP/JJ9WcfYeLzjzA//6San39SzY8/qbR++rcxP/+kmh9/Uin/dp9U9ez7AerJP7JUf/ER6tOPoP7590L940+qrz/Etz6pdvz026H++fdD/eNPqv3jr+Jf/M8/7EzG7s8+JfYXY1n13G+qqo6fRO2//BD11fdlsfi+LPPTD/HFn6X8ua2n/uzb/PzLD/HVd5cn7t9o/vZJ+sc+xMM/V07Ejz/E2n/oQxSfFVn98w8xnx/y5efF4fOi+9PPi8yvAgmmQvX5h/jqWTz9sHnz6V9qfvXZGf7sjPSz6Pj2h8ie+2eR8+el/5sP8cXfyMS+fxYTsz/7EOeL74z2Pvc71b3HzyLm/+LP4ni8n/ojfxZ/8SHW+kN/nLP9x7k/fxZffV7Eun8WFcrPPi/OF5+dv32zfw+p3xbs07+R8/O/1PrxX+qXh7RcauVnz+KrLyMxN5FcZ332ZaS++OTsJ+/X9P7t7+az1uurf05W8E1z/dk3J//2Q6wffxkp/fjLyNcf4ltfRr79IT7/MvLlh/jel5Fvf4jPv4x8+XkR6/6l9tqff17Mj7+M9PPjLyMdP/4y8tWH+OaXkdaPF6f3jxfn6z+Lb30Z+faH+PzLyJd/nN/7MvLl58X3voz0/PjLyDw//kud+Plf6vxNv4wsfxlRfvqz+vnik7O0+QvZz6dzMfnjLyNzvvoywhczPefTT4uvP8S3vhLNF/8m+u2fUnwlyj//Dvz/4kN874vZ1x/iW1/Mvv0hPv9i9uWH+N4Xs29/iM+/mH352bn51Kpd+7NPrXh+/ukZz88/P/+dj/GtT9B4fv4Z+vXH+N6n6L/zMb71Ofr9j/H5J+nXH+N7n6Xf/xh/9NO0GdH8/Ec6ET//t3vEz//xHvHzf71/+TG++X1XxM///R7r5/+A/3f+PL71rdf3P8bn33t9/Wf6vW++vv78+N53X7F+/q/4WOev8Hf783/Hf33Lz78D28l3YLs+9Rahr16Ae5qfjD+fv/oV+urb0RV3xPbK9fnHWD//Iqef/zwgtH/+Re7Lj/HNL3Jff4zvfZH79sf44ovclx/jm1/kvv0x5otbvvocE+Vv9eca5KuXkb77+bHXz/9uv/4Y3/u7/fbH+OLv9suP8c2/229/jD/6d3t0b9nnz7/7+Ld/t/1X+Ludv8Lf7fwV/m7nr/B3O3+Fv9v5W//dNt3W+vSnBPHVK0vf/bv96iWE7/7dfv0xvvd3++2P8cXf7Zcf45t/t9/+GF/93X71vUP4VfWYT1+PjvPFfsRTD+z06c9fS4ijn//75eyf//vlqxdnvvvvl68+xnf//fLV60zf/R739M+/x/36z+N7/3759sf44t8vX/6ZfvPfL19+fnzz3y9fvcTy3X+/1P75323lz/9uv7zlm/9++fJjFK8X/faw/8i/gc7Z7OkXG/TVS0612bHa5/N/R/WXen7uJfHnn+n6Nx8ivnoa5afR5/On8dU/gcQ/xaT1OVf+9sfY59OP8eUfaa7ND6X0+T8rO/8Kt+Tf+pZa3PLnX27/7fPov8It/Te+5Sy+yP32RfPTW7569embn+rzFW48e3kHP/8jHf38j/TbH+MP/5HyWy9Vzxd/pOfnf6T11ZTyrcdvU/rFH+lf4bN0/tafpXV8S316y3p+/Fm6nq8+S6uNJT//baT1/Pyz9Psf44/+kf75V+vP7eh6zs//SL/6LO3z+JuGL37/ov8Kf6R/68/SKf5Ipz//I/3ql2rq17d67zeV/TkK/ubz6OfZf+hboI7nfkPY8fmv7n3/Y3zxT/1vf4w8f/Bj8EuE/VvfP34ef/hjrDCG+vx3AL7/PP7ox1j+89AfvUUg/t7rL39E9//+9v/7+//8j//yF7/Q+qfntzf+3Z/i1/+7fv+3/d/9SR//sX/9d/nr/z0f/1V9/Ef/+u/m43/y+fjvIt7/XB//tT7+Y7//bb7/eT7+6/r4j37/2/n4z/XxZNb7bN6ns97nsz6e0Pp4Rut9Sut9TuvjSa2PZ6X3Wel9Vvp4Vvp4Vnqfld5npY9npY9npfdZ6X1W++NZ7Y9ntd9nte+f0sez2h/Par/Par/Pan88q/3xrPJ9Vvk+q/x4VvnxrPJ9Vvk+q/x4VvnxrPJ9Vvk+q/PxrM7Hszrvszrvszofz+q8f3vvszrvszofz+p8PKt6n1W9z6o+nlV9PKt6n1W9z6o+nlV9PKt6n1W9z6o/nlV/PKt+n1W/z6o/nlV/PKt+n1Xfz6qPZ9Ufz2reZzXvs5qPZzUfz2reZzXvs5qPZzUfz2reZzXvs4rn/Sx/4v3Pdd+g+2C/b8n3P899Q90H/b7l/bz3J/79zL+f+vdzn09+Pvvvp//9/CeAW0C8CcTbQNwI4lYQbwbxdhA3hLglxJtCvC3EjSFuDaEb6ftMbxBxi4g3iXibiBtF3CrizSLeLuKGEbeMeNOIt424ccStI9484u0jbiBxC4k3kXgbiWRQ7jN9M4m3k7ihxC0l3lTibSVuLHFriTeXeHuJG0zcYuJNJt5m4kYTt5p4s4m3m7jhxC0n6o7f+0xvPHHriTefePuJG1DcguJNKN6G4kYUt6J4M4q3o7ghxS0p3pTibSluTHFrijeneHuKYahZ6neq36LWLWrdotZb1HqLWreodYtab1HrLWrdotYtar1FrbeodYtat6j1FrXeotYtavE15X5R4avKfaZ8XblfWO5XFr608LXlfnF5i1q3qHWLWm9R6y1q3aLWLWq9Ra23qHWLWreo9Ra13qLWLWptvgK+z/Qtat2i1i1qvUWtt6h1i1q3qPUWtd6i1i1q3aLWW9R6i1q3qHWLWm9R6y1q3aLWLWq9Ra1zv1rfZ3qLWm9R6y1q3aLWLWq9Ra23qHWLWreo9Ra13qLWLWrdotZb1HqLWreodYtab1HrLWrdolbzncX7TN+i1i1q3aLWW9R6i1q3qHWLWm9R6y1q3aLWLUpvUXqL0i1Ktyi9RektSrco3aL0FqW3KAXfBt3vg96i9BalW5RuUXqL0luUblG6RektSm9RukXpFqW3KL1F6RalW5TeonS/X+MbNr5j41u295nyTRvftd1v2+73bXzjdovSW5TeonSL0i1Kb1F6i9ItSrcovUXpLUq3KN2i9Baltygl317eZ/oWpbco3aJ0i9JblN6idIvSLUpvUXqL0i1Ktyi9RektSrco3aL0FqW3KN2idItS3W+F32d6i9ItSm9ReovSLUq3KL1F6S1KtyjdovQWpbco3aJ0i9JblN6idIvSLUpvUXqL0vBtO9+3v9+4v0XtW9S+Re23qP0WtW9R+xa136L2W9S+Re1b1H6L2m9R+xa1b1H7LWq/Re1b1L5F7beove6/Me4zvUXtt6j9FrVvUfsWtd+i9lvUvkXtW9R+i9pvUfsWtW9R+y1qv0XtW9Tm30L3H0P3X0P8c8j/Hnqf6f0XEf8k4t9E9x9Fb1H7FrVvUfstar9F7VvUvkXtt6j9FrVvUfsWtd+i9lvUvkXtW9R+i9rn/tvtPtNb1H6L2m9R+xa1b1H7LWq/Re1b1L5F7beo/Ra1b1H7FrXfovZb1L5F7VvUfovab1H7FrWbf2e+z/Qtat+i9i1qv0Xtt6h9i9q3qP0Wtd+i9i1q36LyLSrfovIWlbeofIvKt6i8ReUtKt+i8i0qg38U338Vv0XlW1TeovIWlW9R+RaVt6i8ReVbVL5F5S0qb1H5FpVvUXmLyltUvkXlW1TeovIWlbr/gH+f6S0qb1H5FpVvUXmLyltUvkXlW1TeovIWlW9R+RaVt6i8ReVbVN6fM/CDBn7ScH/UcH/W4B823Gd6f9xwf97ADxxuUfkWlW9ReYvKW1S+ReVbVN6i8haVb1H5FpW3qLxF5VtUvkXlLSpvUVn3ByPvM71F5S0q36LyLSpvUXmLyreofIvKW1TeovItKt+i8haVt6h8i8q3qLxF5S0q36LyLSqHH+LwU5z3xzhvUecWdW5R5y3qvEWdW9S5RZ23qPMWdW5R5xZ13qLOW9S5RZ1b1HmLOm9R5xZ1blHnLeqs+xOn+0xvUect6rxFnVvUuUWdt6jzFnVuUecWdd6izlvUuUWdW9R5izpvUecWdW5R5y3qvEWdW9TZ/HTsfaZvUecWdW5R5y3qvEWdW9S5RZ23qPMWdW5R5xZ13qLOW9S5RR1+hnd/iHd/iseP8fg53v1BHj/Ju8+Un+XdH+a9RZ1b1LlFnbeo8xZ1blHnFnXeos5b1LlFnVvUeYs6b1HnFnVuUect6rxFnVvUaX7q+D7Tt6hzizq3qPMWdd6izi3q3KLOW9R5izq3qHOLqreoeouqW1Tdouotqt6i6hZVt6h6i6q3qAp+RHp/RvoWVW9RdYuqW1S9RdVbVN2i6hZVb1H1FlW3qLpF1VtUvUXVLapuUfUWVW9RdYuqW1Tp/jj3faa3qLpF1VtUvUXVLapuUfUWVW9RdYuqW1S9RdVbVN2i6hZVb1H1FlW3qLpF1VtUvUVV8qPn+0zfouotqm5RdYuqt6h6i6pbVN2i6i2q3qLqFlW3qHqLqvvzcX5Azk/I74/I78/I+SE5PyXnx+TvM+UH5beoeouqt6i6RdUtqt6i6i2qblF1i6q3qHqLqltU3aLqLareouoWVbeoeouqt6gafqTPz/TfH+q/RfUtqm9R/RbVb1F9i+pbVL9F9VtU36L6FtVvUf0W1beovkX1W1S/RfUtqm9R/RbV677+cJ/pLarfovotqm9RfYvqt6h+i+pbVN+i+i2q36L6FtW3qH6L6reovkX1Larfovotqm9RvXmt5H2mb1F9i+pbVL9F9VtU36L6FtVvUf0W1beovkX1W1S/RfUtqm9R/RbVb1F9i+pbVL9F9bmv69xneovqt6h+i+pbVN+i+i2q36L6FtW3qH6L6reovkU1rz3dF5/uq0+8/MTrT/cFqPsKFC9B+TWo95m+RfUtqm9R/RbVb1F9i+pbVL9F9VtU36L6FjVvUfMWNbeouUXNW9S8Rc0tam5R8xY1b1ETvGB2XzF7i5q3qLlFzS1q3qLmLWpuUXOLmreoeYuaW9TcouYtat6i5hY1t6h5i5q3qLlFzS1qdF/ce5/pLWpuUfMWNW9Rc4uaW9S8Rc1b1Nyi5hY1b1HzFjW3qLlFzVvUvEXNLWpuUfMWNW9Rk7wQeZ/pW9S8Rc0tam5R8xY1b1Fzi5pb1LxFzVvU3KLmFjVvUfMWNbeouUXNW9S8Rc0tam5RU/dF0/eZ3qLmFjVvUfMWNbeouUXNW9S8Rc0tam5R8xY193VdXtjlld370u59bZcXd3l19768e1/f9Qu8foX3vsTLa7x+kdev8vIyL6/z+oVev9LLS733td6HF3sfXu197su9z3299+EF34dXfJ/7ku9zX/N9eNH34VXf577s+yxeoebZ88rvc1/6fe5rvw8v/j68+vvcl3+f+/rvwwvAD68AP/cl4Oe+BvzwIvDDq8DPfRn4ua8DP7wQ/PBK8HNfCn7ua8EPLwY/26+w32d/Xw9+eEH44RXh574k/NzXhB9eFH54Vfi5Lws/93XhhxeGH14Zfu5Lw899bfjhxeGHV4ef+/Lwc18ffniB+OEV4ue+RPwchADPnleJn/sy8XNfJ354ofjhleLnvlT83NeKH14sfni1+LkvFz/39eKHF4wfXjF+7kvGz33N+OFF44dXjZ/7svFzXzd+eOH4aQuH++zva8cPLx4/vHr83JePn/v68cMLyA+vID/3JeTnvob88CLyQ7XADGSGaYZtBjgDnWGeYZ8B0LDQ+DOigdEAaaA0zDTsNIAaSA1TDaoFa6A1zDXsNQAbiA2TDZsN0AZqw2zDbgO4gdww3bDdAG+gN8w37DcAHAgOEw4bDhAHisOMw44DyIHkMOWw5QBzoDnMOew5AB2IDpMOmw5QB6rDrMOuA9iB7DDtsO0Ad6A7zDvsOwAeCA8TDxsPkAfKw8zDzgPogfQw9bD1AHugPcw97D0AH4gPkw+bD9AH6sPsw+4D+IH8MP3AfsTFH3H1R8A/Av8RF4DEFSABAQkMSFwEEleBBAwklk3hrfZKkICCBBYkLgaJq0ECDhLLwgpiZWPFs7eyglnhrAytLK2gVrdaaEhgQ+LikLg6JOAhgQ+JC0TiCpGAiARGJC4SiatEAiYSOJG4UCSuFAmoSGBF4mKRuFok4CKBF4kLRuKKkYCMBGYkLhqJq0YCNhK4kbhwJK4cCehIYEfi4pG4eiTgI4EfiQtI4gqSgJAEhiQuIomrSAJGEjiSuJAkriQJKElgSeJikriaJOAkgSeJC0riipKAlASmJC4qiatKAlYSuJK4sCSuLAloSWBL4uKSuLok4CWBL4kLTOIKk4CYBMYkLjKJq0wCZhI4k7jQJK40CahJYE1CWOBbLdwk8CZxwUlccRKQk8CcxEUncdVJwE4CdxIXnsSVJwE9CexJXHwSQkiaSNpIGkneZ28maScJlERKmkpS7YUocSVKQFECixIXo8TVKAFHCTxKXJASV6QEJCUwKXFRSlyVErCUwKXEhSlxZUpAUwKbEhenxNUpAU8JfEpcoBJXqAREJTAqcZFKXKUSMJXAqcSFKnGlSkBVAqsSF6vE1SoBVwm8SlywElesBGQlMCtx0UpctRKwlcCtxIUrceVKQFcCuxIXr8TVKwFfCfxKXMASV7AEhCUwLHERS1zFEjCWwLHEhSxxJUtAWQLLEhezxNUsAWcJPEtc0BIbw0+1mJa4qCWuaglYS+Ba4sKWuLIloC2BbYmLW+LqloC3BL4lLnCJK1wC4hIYl7jIJa5yCZhL4FziQpe40iWgLrEtnCHOGGcj5z9TzvfZ45wNnS2doc63WthL4F7iwpe48iWgL4F9iYtf4uqXgL8E/iUugIkrYAICExiYuAgmroIJGEzgYOJCmLgSJqAwgYWJi2HiapiAwwQeJi6IiStiAhITmJi4KCauiglYTOBi4sKYuDImoDGBjYmLY+LqmIDHBD4mLpCJK2QCIhMYmbhIJq6SCZhM4GTiQpm4UiagMoGViYtl4mqZgMsEXiYumIkrZgIyE5iZuGgmrpqJ9O/eUO2FM3HlTEBnAjsTF8/E1TMBnwn8TFxAE1fQBIQmMDRxEU1cRRMwmsDRxIU0cSVNQGkCSxMX08TVNAGnCTxNXFATV9QEpCYwNXFRTVxVE7CawNXEhTWR/IaCf0XBv6PALynwWwp/9msKPHt+UYHfVPCvKlDtRTZxlU3AbAJnExfaxJU2AbUJrE1cbBNX2wTcJvA2ccFNXHETkJvA3MRFN3HVTcBuAncTF97ElTcBvQnsTVx8E1ffBPwm8DdxAU5cgRMQnMDgxEU4cRVOwHAChxMX4sSVOAHFCSxOXIwTV+MEHCfwOHFBTlyRE5CcwOTERTlxVU7AcgKXExfmxJU5Ac2J49+Zu9VenRPwnMDnxAU6cYVOQHQCoxMX6cRVOgHTCZxOXKgTV+oEVCewOnGxTlytE3CdwOvEBTtxxU5AdgKzExftxFU7AdsJ3E5cuBNX7gR0J7A7cfFOXL0T8J3A78QFPHEFT0B4AsMTF/HEVTwB44nj3zDiV4z4HSP/kpF/y4hfM/LvGfHs/ZtG/KrRrRbSE5ieuKgnruoJWE/geuLCnriyJ6A9ge2Ji3vi6p6A9wS+Jy7wiSt8AuITGJ+4yCeu8gmYT+B84kKfuNInoD6B9YmLfeJqn4D7BN4nLviJK34C8hOYn7joJ676CdhP4H7iwp+48iegP4H9iYt/4uqfgP8E/ieK33W91UKAAgMUFwHFVUABAwocUFwIFFcCBRQosEBxMVBcDRRwoMADxQVBcUVQQIICExQXBcVVQQELClxQXBgUVwYFNCiwQXFxUFwdFPCgwAfFBUJxhVBAhAIjFBcJxVVCARMKnFBcKBRXCgVUKLBCcbFQXC0UcKHAC8UFQ3HFUECGAjMUFw1F8RuC/hVB/44gvyTIbwn61wT9e4L+RcH77P2rglR7AVFcQRQQosAQxUVEcRVRwIgCRxQXEsWVRAElCixRXEwUVxMFnCjwRHFBUVxRFJCiwBTFRUVxVVHAigJXFBcWxZVFAS0KbFFcXBRXFwW8KPBFcYFRXGEUEKPAGMVFRtH8jjrV4oziQqO40iigRoE1iouN4mqjgBsF3iguOIorjgJyFJijuOgorjoK2FHgjuLCo7jyKKBHgT2Ki4/i6qOAHwX+KC5AiiuQAoIUGKS4CCmuQgoYUuCQ4kKkuBIpoEiBRYqLkeJqpIAjBR4pLkiKK5ICkhSYpLgoKa5KClhS4JLiwqS4MimgSYFNiouT4uqkgCcFPikuUIorlAKiFO3f8OVXfPkdX/+Sr3/Ll1/z5fd8/Yu+f/abvvfZ32rhSoFXiguW4oqlgCwFZikuWoqrlgK2FLiluHAprlwK6FJgl+Lipbh6KeBLgV+KC5jiCqaAMAWGKS5iiquYAsYUOKa4kCmuZIrx/20Jqr2YKa5mCjhT4Jnigqa4oikgTYFpioua4qqmgDUFrikubIormwLaFNimuLgprm4KeFPgm+ICp7jCKSBOgXGKi5ziKqeAOQXOKS50iiudAuoUWKe42Cmudgq4U+Cd4oKnuOIpIE+BeYqLnuKqp4A9Be4pLnyKK58C+hTYp7j4Ka5+CvhT4J/iAqi4AiogUIGBioug4iqogEEFDiouhIoroQIKFViouBgqroYKOFTgoeKCqBh+Q9+/ou/f0eeX9Pktff+avn9Pn1/U5zf1/+xX9d9nvx5+WZ/f1vev6/v39fmFfX5j37+y79/Z55f272/tY6MWNmpdG7WujVrYqIWNWtdGrWujFjZqPf6/CXN/gf/aqIWNWtiodW3UujZqYaMWNmpdG7WujVrYqIWNWtdGrWujFjZqYaPWtVHr2qiFjVrYqHVt1Lo2amGjFjZqXRu1ro1a2KiFjVq/bNTv/+eR1y8c9fHoV7f961HwaPFW8Wjz1uTR4a3Fo+atcx/93u7HW3+P9320eKt4tHlr8ujw1uIRdxzuKO4o7ijuKO4o7ijuKO4o7ijuKO5o7mjuaO5o7mjuaO5o7mjuaO5o7hjuGO4Y7hjuGO4Y7hjuGO4Y7ph7xy819eutv9jU+2jxVvFo89bk0eGtxaPmrfeODzv1660RPFq8VTzavDV5dHhr8ah5K3cs7ljcsbhjccfijsUdizsWdyzuWNwh7hB3iDvEHeIOcYe4Q9wh7hB3bO7Y3LG5Y3PH5o7NHZs7NnfQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQ+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0fmm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/NB50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nT+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9dzO9QR3LO5Y3LG4Y3HH4o7FHYs7Fncs7ljcIe4Qd4g7xB3iDnGHuEPcIe4Qd2zu2NyxuWNzx+aOzR2bOzZ3bO7Y3JHckdyR3JHckdyR3JHckdyR3JHccbjjcMfhjsMdhzsOdxzuONxxuONwR3FHcUdxR3FHcUdxR3FHcUdxR3FHc0dzR3NHc0dzR3NHc0dzR3NHc8dwx3DHcMdwx3DHcMdwx3DHcAed4+GEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTni4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4jYfbeLiNh9t4uI2H23i4/cvDrf3rUfHot/8dq349mvfRLw/3662/PNz7aPFW8Wjz1uTR4a3Fo+atcx/93vnHW3/v/H20eKt4tHlr8ujw1uJR81buWNyxuGNxx+KOxR2LOxZ3LO5Y3LG4Q9wh7hB3iDvEHeIOcYe4Q9wh7tjcsbljc8fmjs0dmzs2d2zu2NyxuSO5I7kjuSO5I7kjuSO5I7kjuSO543DH4Y7DHYc7Dncc7jjccbjjcMfhjuKO4o7ijuKO4o7ijuKO4o7ijuKO5o7mjuaO5o7mjuaO5o7mjuaO5o7hjuGO4Y7hjuGO4Q46DzoPOg86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aJz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86n9t5PrfzfG7n+dzO87md53M7z+d2ns/tPJ/beT6383xu5/nczvO5nedzO8/ndp7P7Tyf23k+t/N8buf53M7zCe5Y3LG4Y3HH4o7FHYs7Fncs7ljcsbhD3CHuEHeIO8Qd4g5xh7hD3CHu2NyxuWNzx+aOzR2bOzZ3bO7Y3LG5I7kjuSO5I7kjuSO5I7kjuSO5I7njcMfhjsMdhzsOdxzuONxxuONwx+GO4o7ijuKO4o7ijuKO4o7ijuKO4o7mjuaO5o7mjuaO5o7mjuaO5o7mjuGO4Y7hjuGO4Y7hjuGO4Y7hDjrHwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO3i4g4c7eLiDhzt4uIOHO788nPTrUfLot/8dOr8eFY+at8599HvnH2/9vfP30eKt4tHmrcmjw1uLR81b5z76vfOPt/7e+fto8VbxiDsOdxzuONxxuONwR3FHcUdxR3FHcUdxR3FHcUdxR3FHc0dzR3NHc0dzR3NHc0dzR3NHc8dwx3DHcMdwx3DHcMdwx3DHcMfcO355uF9v/eXh3keLt4pHm7cmjw5vLR41b713/PJwH2+N4NHireLR5q3Jo8Nbi0fNW7ljccfijsUdizsWdyzuWNyxuGNxx+IOcYe4Q9wh7hB3iDvEHeIOcYe4Y3PH5o7NHZs76HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633SedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dzO6/ndl7P7bye23k9t/N6buf13M7ruZ3Xczuv53Zez+28ntt5Pbfzem7n9dzO67md13M7r+d2Xs/tvJ7beT3BHYs7Fncs7ljcsbhjccfijsUdizsWd4g7xB3iDnGHuEPcIe4Qd4g7xB2bOzZ3bO7Y3LG5Y3PH5o7NHZs7NnckdyR3JHckdyR3JHckdyR3JHckdxzuONxxuONwx+GOwx2HOw53HO443FHcUdxR3FHcUdxR3FHcUdxR3FHc0dzR3NHc0dzR3NHc0dzR3NHc0dwx3DHcMdwx3DHcMdwx3DHcMdxB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQed4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDxcPIO73h+GHy+8gP9x+h/TD43coP2y/w/DwJv/7w/DD5XeQH26/Q/rh8TuUH7bfwbct37Z82/Jty7ct37Z82/Jty7ct37Z8m3ybfJt8m3ybfJt8m3ybfJt8m3zb9m3bt23ftn3b9m3bt23ftn3b9m3bt6VvS9+Wvi19W/q29G3p29K3pW9L33Z82/Ftx7cd33Z82/Ftx7cd33Z82/Ft5dvKt5VvK99Wvq18W/m28m3l28q3tW9r39a+rX1b+7b2be3b2re1b2vfNr5tfNv4tvFt49vGt41vG982vs1bEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jb/w314fD8sPf/vftvPj4fDw9y153+H3LbkPl99Bfrj9DumHx+9Qfth+h+Hh71vyvsPvW3IfLr+D/HD7HdIPfVv6tvRt6duObzu+7fi249uObzu+7fi249uObzu+rXxb+bbybeXbyreVbyvfVr6tfFv5tvZt7dvat7Vva9/Wvq19W/u29m3t28a3jW8b3za+bXzb+LbxbePbxrcNt/3Cgx/v8EsP3ofL7yA/3H6H9MPjdyg/bL8Dt/1ihO87RPjh8jvID7ffIf3w+B3KD9vv4NuWb1u+bfm25duWb1u+bfm25duWb1u+Tb5Nvk2+Tb5Nvk2+zVsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWyFsib4m8JfKWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pJhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+JhS+IJ37Z82/Jty7ct37Z82/Jty7ct37Z82/Jt8m3ybfJt8m3ybfJt8m3ybfJt8m3bt23ftn3b9m3bt23ftn3b9m3bt23flr4tfVv6tvRt6dvSt6VvS9+Wvi192/Ftx7cd33Z82/Ftx7cd33Z82/Ftx7eVbyvfVr6tfFv5tvJt5dvKt5VvK9/Wvq19W/u29m3t29q3tW9r39a+rX3b+LbxbePbxreNbxvfNr5tfNv4Nm9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKW2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3WvYvYbda9i9ht1r2L2G3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3euye112r8vuddm9LrvXZfe67F6X3ev65V7X/ngYfvjb/7ZVHw/lh9vvkH54/A7lh+13GB7+viXvO/y+Jffh8jvID7ffIf3w+B3KD9vvMPfhL/f68Q6/3Ot9uPwO8sPtd0g/PH6H8sP2O3DbL/f6vkOEHy6/g/xw+x3SD4/fofyw/Q6+bfm25duWb1u+bfm25duWb1u+bfm25dvk2+Tb5Nvk2+Tb5Nvk2+Tb5Nvk27Zv275t+7bt27Zv275t+7bt27Zv274tfVv6tvRt6dvSt6VvS9+Wvi19W/q249uObzu+7fi249uObzu+7fi249uObyvfVr6tfFv5tvJt5dvKt5VvK99Wvs1bIm+JvCXylshbIm+JvCXylshbIm+JvCXylshbIm+JvCXylshbIm+JvCXylmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9pZsb8n2lmxvyfaWbG/J9paktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvyfGWHG/J8ZYcb8nxlhxvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6SYUv0sCV62BI9bIketkQPW6KHLdHDluhhS/SwJXrYEj1siR62RA9booct0cOW6GFL9LAletgSPWyJnvBty7ct37Z82/Jty7ct37Z82/Jty7ct3ybfJt8m3ybfJt8m3ybfJt8m3ybftn3b9m3bt23ftn3b9m3bt23ftn3b9m3p29K3pW9L35a+LX1b+rb0benb0rcd33Z82/Ftx7cd33Z82/Ftx7cd33Z8W/m28m3l28q3lW8r31a+rXxb+bbybe3b2re1b2vf1r6tfVv7tvZt7dvat41vG982vm182/i28W3j28a3jW/zloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvid2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73Xav2+51271uu9dt97rtXrfd67Z73b/cq/TxcHj4+5bofDwMP1x+B/nh9jukHx6/Q/lh+x2Gh79vyfsOv2/Jfbj8DvLD7XdIPzx+h/JD37Z9W/q29G3p29K3pW9L35a+LX1b+rb0bce3Hd92fNvxbce3Hd92fNvxbce3Hd9Wvq18W/m28m3l28q3lW8r31a+rXxb+7b2be3b2re1b2vf1r6tfVv7tvZt49vGt41vG982vm182/i28W3j24bbfrnXj3f45V7vw+V3kB9uv0P64fE7lB+234HbfrnX9x0i/HD5HeSH2++Qfnj8DuWH7Xfwbcu3Ld+2fNvybcu3Ld+2fNvybd6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0t2d6S7S3Z3pLtLdneku0tSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLjLTnekuMtOd6S4y053pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylvxyr/ehb/OWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8Zb8/039zapgWdRm592L2m6cOdeef74XI6Ry2RQUKlGWDMbUvevLjMwzRm8GscmXlY2nEQzOOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksuV9L6ufXkvr5taR+fi2pn19L6ufXkvr5taR+fi2pn19L6ufXkvr5taR+fi2pn19L6ufXkvr5taR+fi2pn19L6ufXkvr5taR+fi2pn+BtyduStyVvS96WvC15W/K25G3J25K3Pd72eNvjbY+3Pd72eNvjbY+3Pd72eNvH2z7e9vG2j7d9vO3jbR9v+3jbx9s+3la8rXhb8bbibcXbircVbyveVryteFvztuZtzduatzVva97WvK15W/O25m3D24a3DW8b3ja8bXjb8LbhbcPbhrctb1vetrxtedvytuVty9uWty1vW952vO142/G2423H2463HW873na8DUsCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rCE7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6L7rXoXovutehei+616F6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvutelem+616V6b7rXpXpvuteleh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXofudeheh+516F6H7nXoXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXpfudelel+516V6X7nXpXvfv7vXLP2dw/sfaV3/Ox/nxQXE2Hwzn8sH9nn9Z8s8Hf1ny75l88Dg/PijO5oPhXD643/PjbR9v+3jbx9s+3vbxto+3fbzt420fbyveVryteFvxtuJtxduKtxVvK95WvK15W/O25m3N25q3NW9r3ta8rXlb87bhbcPbhrcNbxveNrxteNvwtuFtw9uWty1vW962vG152/K25W3L25a3LW873na87Xjb8bbjbcfbjrcdbzvedr9v+7t7/fPB393rv2fyweP8+KA4mw+Gc/ng921/d6//fBDBmXzwOD8+KM7mg+FcPuBtWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0lgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYcr+W3M+vJffza8n9/FpyP7+W3M+vJffza8n9/FpyP7+W3M+vJffza8n9/FpyP7+W3M+vJffza8n9/FpyP7+W3M+vJffza8n9/FpyP8Hbkrclb0velrwteVvytuRtyduStyVve7zt8bbH2x5ve7zt8bbH2x5ve7zt8baPt3287eNtH2/7eNvH2z7e9vG2j7d9vK14W/G24m3F24q3FW8r3la8rXhb8bbmbc3bmrc1b2ve1ryteVvztuZtzduGtw1vG942vG142/C24W3D24a3DW9b3ra8bXnb8rblbcvblrctb1vetrzteNvxtuNtx9uOtx1vO952vO14G5YElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYEliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mEJ3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d6/12r/nz273+dQZn8sHj/PigOJsPhnP54H7Pfy356wzO5IPH+fFBcTYfDOfyAW9L3pa8LXlb8rbkbcnbkrclb0velrzt8bbH2x5ve7zt8bbH2x5ve7zt8bbH2z7e9vG2j7d9vO3jbR9v+3jbx9s+3vbxtuJtxduKtxVvK95WvK14W/G24m3F25q3NW9r3ta8rXlb87bmbc3bmrc1bxveNrxteNvwtuFtw9uGtw1vG942vG152/K25W3L25a3LW9b3ra8bXnb8rbjbcfbjrcdbzvedrzteNvxtuNtWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkljysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyUflnxY8mHJhyV/d68df87ibM7hXM77Pf+y5N8zOJPzcbI2rA1rw9qwNqwta8vasrasLWt/WdL752zO4fyPtf3zv+QvS/45/7Lk3zM4k/NxfpzF2ZzDydr9rv3dvf57BmdyPs6PszibcziXk7VgLVgL1oK1YC1YC9aCtWAtWEvWkrVkLVlL1pK1ZC1ZS9aStcfaY+2x9lh7rD3WHmuPtcfaY+1j7WPtY+1j7WPtY+1j7WPtY+1jrVgr1oq1Yq1YK9aKtWKtWCvWmrVmrVlr1pq1Zq1Za9aatWZtWBvWhrVhbVgb1oa1YW1YG9aWtWVtWVvWlrVlbVlb1rCksKSwpLCksKSwpLCksKSwpLCksKSwpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLHk7+718s+5nPd7/mXJv+d/rP3HPy7/uVP30/3pLt2te3Sv7uP+C5XfW7ul3dJuabe0W9ot7ZZ2S7ut3dZua7e129pt7bZ2W7ut3dbuaHe0O9od7Y52R7uj3dHuaHe0u9pd7a52V7ur3dXuane1u9pd7Z52T7un3dPuafe0e9o97Z52j92/k9nfO3Sn7qf70126W/foXt3aDe2GdkO7od3Qbmg3tBvaDe2GdlO7qd3Ubmo3tZvaTe2mdlO7qd2n3afdp92n3afdp92n3afdp92n3U+78mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXhVfzgVfzgVfzgVfzgVfzgVfzgVfzgVfzgVfzgVfz8aDe0G9oN7YZ2Q7uh3dBuaDe0G9pN7aZ2U7up3dRuaje1m9pN7aZ2n3afdp92n3afdp92n3afdp92n3Y/7X7a/bT7affT7qfdT7ufdj/tftot7ZZ2S7ul3dJuabe0W9ot7ZZ2W7ut3dZua7e129pt7bZ2W7ut3dHuaHe0O9od7Y52R7uj3dHuaHe1u9pd7a52V7ur3dXuane1u9o97Z52T7un3dPuafe0e9r949X+ue/3jj9e/XP/tdv3507dT/enu3S37tG9uo/7b6/+vbUb2g3thnZDu6Hd0G5oN7Sb2k3tpnZTu6nd1G5qN7Wb2k3tPu0+7T7tPu0+7T7tPu0+7T7tPu1+2v20+2n30+6n3U+7n3Y/7X7a/bRb2i3tlnZLu6Xd0m5pt7Rb2i3ttnZbu63d1m5rt7Xb2m3ttnZbu6Pd0e5od7Q72h3tjnZHu6Pd0e5qd7W72l3trnZXu6vd1e5qd7V72j3tnnZPu6fd0+5p97R72j12/86kf+/Qnbqf7k936W7do3t1a1depbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXy6k/fPv3nHt1/7e77cx/33179e4fu1P10f7pLd+se3dp92v20+2n30+6n3U+7n3Y/7X7a/bT7abe0W9ot7ZZ2S7ul3dJuabe0W9pt7bZ2W7ut3dZua7e129pt7bZ2R7uj3dHuaHe0O9od7Y52R7uj3dXuane1u9pd7a52V7ur3dXuave0e9o97Z52T7un3dPuafe0e+z+6dv/vUN36n66P92lu3WP7tWt3dBuaDe0G9oN7YZ2Q7uh3dBuaDe1m9pN7aZ2U7up3dRualdenbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1eHV/mDV/mDV/mDV/mDV/mDV/mDV/mDV/mDV/mDV/nzo93Qbmg3tBvaDe2GdkO7od3Qbmg3tZvaTe2mdlO7qd3Ubmo3tZvafdp92n3afdp92n3afdp92n3afdr9tPtp99Pup91Pu592P+1+2v20+2m3tFvaLe2Wdku7pd3Sbmm3tFvabe22dlu7rd3Wbmu3tdvabe22dke7o93R7mh3tDvaHe2Odke7o93V7mp3tbvaXe2udle7q93V7mr3tHvaPe2edk+7p93T7mn3tCuvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6k/fvv3nPu4/Xv1zh+7U/XR/ukt36x7d2v20W9ot7ZZ2S7ul3dJuabe0W9ot7bZ2W7ut3dZua7e129pt7bZ2W7uj3dHuaHe0O9od7Y52R7uj3dHuane1u9pd7a52V7ur3dXuane1e9o97Z52T7un3dPuafe0e9o9dv/07f/eoTt1P92f7tLdukf36tZuaDe0G9oN7YZ2Q7uh3dBuaDe0m9pN7aZ2U7up3dRuaje1m9pN7T7tPu0+7T7tPu0+7T7tPu3Kq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrl1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1Ze/dO335/7uP949c8dulP30/3pLt2te3Rrt7Tb2m3ttnZbu63d1m5rt7Xb2m3tjnZHu6Pd0e5od7Q72h3tjnZHu6vd1e5qd7W72l3trnZXu6vd1e5p97R72j3tnnZPu6fd0+5p99j9p2//5w7dqfvp/nSX7tY9ule3dkO7od3Qbmg3tBvaDe2GdkO7od3Ubmo3tZvaTe2mdlO7qd3Ubmr3afdp92n3afdp92n3afdp92n3affT7qfdT7ufdj/tftr9tPtpV16dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dXj1fvDq/eDV+8Gr94NX7wev3g9evR+8ej949X7w6v38aDe0G9oN7YZ2Q7uh3dBuaDe0G9pN7aZ2U7up3dRuaje1m9pN7aZ2n3afdp92n3afdp92n3afdp92n3Y/7X7a/bT7affT7qfdT7ufdj/tftot7ZZ2S7ul3dJuabe0W9ot7ZZ2W7ut3dZua7e129pt7bZ2W7ut3dHuaHe0O9od7Y52R7uj3dHuaHe1u9pd7a52V7ur3dXuane1u9o97Z52T7un3dPuafe0e9o97cqrkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyqsnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568+tO33/fnPu6/vfr3Dt2p++n+dJfu1j26tdvaHe2Odke7o93R7mh3tDvaHe2Odle7q93V7mp3tbvaXe2udle7q93T7mn3tHvaPe2edk+7p93T7rH7p2//9w7dqfvp/nSX7tY9ule3dkO7od3Qbmg3tBvaDe2GdkO7od3Ubmo3tZvaTe2mdlO7qd3Ubmr3afdp92n3afdp92n3afdp92n3affT7qfdT7ufdj/tftr9tPtp99Pup93Sbmm3tFvaLe2Wdku7pV159cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05eHV59P3j1/eDV94NX3w9efT949f3g1feDV98PXn0/ePX9/Gg3tBvaDe2GdkO7od3Qbmg3tBvaTe2mdlO7qd3Ubmo3tZvaTe2mdp92n3afdp92n3afdp92n3afdp92P+1+2v20+2n30+6n3U+7n3Y/7X7aLe2Wdku7pd3Sbmm3tFvaLe2Wdlu7rd3Wbmu3tdvabe22dlu7rd3R7mh3tDvaHe2Odke7o93R7mh3tbvaXe2udle7q93V7mp3tbvaPe2edk+7p93T7mn3tHvaPe3Kq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evFLf/qlv/9S3f+rbP/Xtn/r2T337p779U9/+qW//1Ld/6ts/9e2f+vZPffunvv1T3/6pb//Ut3/q2z/17d8/ffv9ff/x6p87dKfup/vTXbpb9+he3do97Z52T7un3dPuafe0e9o97R67//Tt/9yhO3U/3Z/u0t26R/fq1m5oN7Qb2g3thnZDu6Hd0G5oN7Sb2k3tpnZTu6nd1G5qN7Wb2k3tPu0+7T7tPu0+7T7tPu0+7T7tPu1+2v20+2n30+6n3U+7n3Y/7X7a/bRb2i3tlnZLu6Xd0m5pt7Rb2i3ttnZbu63d1m5rt7Xb2m3ttnZbu6Pd0e5od7Q72h3tjnZHu6NdefXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp59Xffnj/fn/u4//Lq9w7dqfvp/nSX7tY9urV77P7dt//eoTt1P92f7tLdukf36tZuaDe0G9oN7YZ2Q7uh3dBuaDe0m9pN7aZ2U7up3dRuaje1m9pN7T7tPu0+7T7tPu0+7T7tPu0+7T7tftr9tPtp99Pup91Pu592P+1+2v20W9ot7ZZ2S7ul3dJuabe0W9ot7bZ2W7ut3dZua7e129pt7bZ2W7uj3dHuaHe0O9od7Y52R7uj3dHuane1u9pd7a52V7ur3dWuvDp5dfLq5NXJq5NXJ69OXp28Onl18urwqn7wqn7wqn7wqn7wqn7wqn7wqn7wqn7wqn7wqn5+tBvaDe2GdkO7od3Qbmg3tBvaDe2mdlO7qd3Ubmo3tZvaTe2mdlO7T7tPu0+7T7tPu0+7T7tPu0+7T7ufdj/tftr9tPtp99Pup91Pu592P+2Wdku7pd3Sbmm3tFvaLe2Wdku7rd3Wbmu3tdvabe22dlu7rd3W7mh3tDvaHe2Odke7o93R7mh3tLvaXe2udle7q93V7mp3tbvaXe2edk+7p93T7mn3tHvaPe2eduVVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5dWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09evT9e3Z/7fu/vj1f/3KE7dT/dn+7S3bpH9+rWbmg3tBvaDe2GdkO7od3Qbmg3tJvaTe2mdlO7qd3Ubmo3tZvaTe0+7T7tPu0+7T7tPu0+7T7tPu0+7X7a/bT7affT7qfdT7ufdj/tftr9tFvaLe2Wdku7pd3Sbmm3tFvaLe22dlu7rd3Wbmu3tdvabe22dlu7o93R7mh3tDvaHe2Odke7o93R7mp3tbvaXe2udle7q93V7mp3tXvaPe2edk+7p93T7mn3tCuvPnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5dfLq5NXJq5NXJ69OXp28Onn1p2+P/HMf999e/XuH7tT9dH+6S/dfu1F/7tH99+78uY/7b68y/tx/7eaf/86f3+/8/txP96e7dLfu0b26j/vP73f+5w7d2n3afdp92n3afdp92n3a/bT7affT7qfdT7ufdj/tftr9tPtpt7Rb2i3tlnZLu6Xd0m5pt7Rb2m3ttnZbu63d1m5rt7Xb2m3ttnZHu6Pd0e5od7Q72h3tjnZHu6Pd1e5qd7W72l3trnZXu6vd1e5q97R72j3tnnZPu6fd0+5p97R7v7v95+e3/3uH7tT9dH+6S3frHt2rW7uh3dBuaDe0G9oN7YZ2Q7uh3dBuaje1m9pN7aZ2U7up3dRuaje1+7T7tPu0+7T7tPu0+7T7tPu0+7T7affT7qfdT7ufdj/tftr9tPtp99Nuabe0W9ot7ZZ2S7ul3dJuabe029pt7bZ2W7ut3dZua7e129pt7Y52R7uj3dHuaHe0O9od7Y52R7ur3dXuane1u9pd7a52V7ur3dXuafe0e9o97Z52T7un3dPuaVdehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0Jehbz68/Pb/7nlVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1Jepbx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrz65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+vPz27f/3E/3p7t0t+7RvbqP+49X/9yhW7ufdj/tftr9tPtp99Pup93Sbmm3tFvaLe2Wdku7pd3Sbmm3tdvabe22dlu7rd3Wbmu3tdvaHe2Odke7o93R7mh3tDvaHe2Odle7q93V7mp3tbvaXe2udle7q93T7mn3tHvaPe2edk+7p93T7rH75+e3/3uH7tT9dH+6S3frHt2rW7uh3dBuaDe0G9oN7YZ2Q7uh3dBuaje1m9pN7aZ2U7up3dRuaje1+7T7tCuvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl7907ffn/vp/nSX7tY9ulf3cf/x6p87dGu3tFvaLe2Wdku7pd3Sbmu3tdvabe22dlu7rd3Wbmu3tTvaHe2Odke7o93R7mh3tDvaHe2udle7q93V7mp3tbvaXe2udle7p93T7mn3tHvaPe2edk+7p9373Z1/+vZ/7tCdup/uT3fpbt2je3VrN7Qb2g3thnZDu6Hd0G5oN7Qb2k3tpnZTu6nd1G5qN7Wb2k3tpnafdp92n3afdp92n3afdp92n3afdj/tftr9tPtp99Pup91Pu592P+1+2i3tlnZLu6Xd0m5pt7Rb2i3tlnZbu63d1m5rt7Xb2m3ttnZbu63d0e5od7Q72h3tjnZHu6Pd0e5od7W72l3trnZXu6vd1e5qd7W72j3tnnZPu6fd0+5p97R72j3tyquQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrTt9/35366P92lu3WP7tV93H9+v/M/d+jWbmu3tdvabe22dlu7rd3R7mh3tDvaHe2Odke7o93R7mh3tbvaXe2udle7q93V7mp3tbvaPe2edk+7p93T7mn3tHvaPe0eu3/69n/v0J26n+5Pd+lu3aN7dWs3tBvaDe2GdkO7od3Qbmg3tBvaTe2mdlO7qd3Ubmo3tZvaTe2mdp92n3afdp92n3afdp92n3afdp92P+1+2v20+2n30+6n3U+7n3Y/7X7aLe2WduVVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl1eLU/eLU/eLU/eLU/eLU/eLU/eLU/eLU/eLU/eLU/P9oN7YZ2Q7uh3dBuaDe0G9oN7YZ2U7up3dRuaje1m9pN7aZ2U7up3afdp92n3afdp92n3afdp92n3afdT7ufdj/tftr9tPtp99Pup91Pu592S7ul3dJuabe0W9ot7ZZ2S7ul3dZua7e129pt7bZ2W7ut3dZua3e0O9od7Y52R7uj3dHuaHe0O9pd7a52V7ur3dXuane1u9pd7a52T7un3dPuafe0e9o97Z52T7vyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqyasnr568evLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1Sev1Lev+vZV377q21d9+6pvX/Xtq7591bev+vZV377q21d9+6pvX/Xtq7591bev+vZV377q21d9+/7Tt9+f+9Ndulv36F7dx/3Hq3/u0J26tbvaXe2udle7q93V7mn3tHvaPe2edk+7p93T7mn32P2nb//nDt2p++n+dJfu1j26V7d2Q7uh3dBuaDe0G9oN7YZ2Q7uh3dRuaje1m9pN7aZ2U7up3dRuavdp92n3afdp92n3afdp92n3afdp99Pup91Pu592P+1+2v20+2n30+6n3dJuabe0W9ot7ZZ2S7ul3dJuabe129pt7bZ2W7ut3dZua7e129od7Y52R7vyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6u++PX++P/fT/eku3a17dK/u4/7Lq987dGv3tHvaPe2edk+7p9373b2/+/bfO3Sn7qf70126W/foXt3aDe2GdkO7od3Qbmg3tBvaDe2GdlO7qd3Ubmo3tZvaTe2mdlO7qd2n3afdp92n3afdp92n3afdp92n3U+7n3Y/7X7a/bT7affT7qfdT7ufdku7pd3Sbmm3tFvaLe2Wdku7pd3Wbmu3tdvabe22dlu7rd3Wbmt3tDvaHe2Odke7o93R7mh3tDvaXe2udle7q93V7mp3tbvaXe2udk+7p93T7mn3tHvaPe2edk+78irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXy6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1Sevvj9e3Z/76f50l+7WPbpX9/3e9cerf+7Qnbqf7k936W7do3t1aze0G9oN7YZ2Q7uh3dBuaDe0G9pN7aZ2U7up3dRuaje1m9pN7aZ2n3afdp92n3afdp92n3afdp92n3Y/7X7a/bT7affT7qfdT7ufdj/tftot7ZZ2S7ul3dJuabe0W9ot7ZZ2W7ut3dZua7e129pt7bZ2W7ut3dHuaHe0O9od7Y52R7uj3dHuaHe1u9pd7a52V7ur3dXuane1u9o97Z525VXJq5JXJa9KXpW8KnlV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5db9evZ+fX6/+ukP3X7uRf+6n+9Ndulv36F7dx/23V1F/7tD99+78uZ/uv3Yz/tx/7Wb+j//b//T//V/++3/5X/7X//qf/z//0//9//8ff/x//Z//23/6P/7Lf/vf/vnj//H/+9///Zv/9b//l//6X//L//t//t//+3/7T//5//l//vf//D//1//2n/7+u//x//gf/xc=", - "file_map": { - "3": { - "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str {}\n}\n\nimpl From> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n", - "path": "std/array/mod.nr" - }, - "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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n", - "path": "std/field/mod.nr" - }, - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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, PK_GENERATION_BIT_E_SM, PK_GENERATION_BIT_EEK, PK_GENERATION_BIT_PK, PK_GENERATION_BIT_R1,\n PK_GENERATION_BIT_R2, PK_GENERATION_BIT_SK, PK_GENERATION_CONFIGS,\n};\nuse lib::core::threshold::pk_generation::PkGeneration;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n a: pub [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n) -> pub (Field, Field, Field) {\n let pk_generation: PkGeneration = PkGeneration::new(\n PK_GENERATION_CONFIGS,\n a,\n eek,\n sk,\n e_sm,\n r1is,\n r2is,\n pk0is,\n pk1is,\n );\n pk_generation.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/pk_generation/src/main.nr" - }, - "70": { - "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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_threshold_pk_challenge, compute_threshold_pk_commitment,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for threshold public key generation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bound for error polynomial (eek) coefficients\n pub eek_bound: Field,\n /// Bound for secret key polynomial (sk) coefficients\n pub sk_bound: Field,\n /// Bound for smudging noise polynomial (e_sm) coefficients\n pub e_sm_bound: Field,\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(\n qis: [Field; L],\n eek_bound: Field,\n sk_bound: Field,\n e_sm_bound: Field,\n r1_bounds: [Field; L],\n r2_bounds: [Field; L],\n ) -> Self {\n Configs { qis, eek_bound, sk_bound, e_sm_bound, r1_bounds, r2_bounds }\n }\n}\n\n/// Correct Threshold Public Key Generation Circuit (Circuit 1).\n///\n/// Verifies:\n/// 1. Range checks on all secret witnesses (secret key, error, smudging noise, quotients)\n/// 2. Correct public key generation: pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n/// and pk1_i = a_i\n///\n/// Outputs:\n/// - commit(threshold_sk)\n/// - commit(threshold_pk)\n/// - commit(e_sm)\npub struct PkGeneration {\n /// Cryptographic parameters including bounds, moduli, and constants.\n configs: Configs,\n\n /// Common Reference String polynomials (public witnesses)\n /// One polynomial per modulus i\n a: [Polynomial; L],\n\n /// Error polynomial (secret witness)\n /// Small coefficients sampled from error distribution\n eek: Polynomial,\n\n /// Secret key polynomial (secret witness)\n /// Small coefficients sampled from CBD (Centered Binomial Distribution)\n sk: Polynomial,\n\n /// Smudging noise polynomial (secret witness)\n /// Used for threshold decryption security\n e_sm: [Polynomial; L],\n\n /// Quotients from polynomial operations (secret witnesses)\n /// r1[i] are quotients from modulus switching for modulus i (can be negative, degree 2*N-1)\n r1: [Polynomial<2 * N - 1>; L],\n /// r2[i] are quotients from cyclotomic reduction for modulus i (typically positive, degree N-1)\n r2: [Polynomial; L],\n\n /// Threshold public key components (committed witnesses)\n /// pk0[i] is the first component of the public key for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component of the public key for modulus i (should equal a[i])\n pk1: [Polynomial; L],\n}\n\nimpl PkGeneration {\n pub fn new(\n configs: Configs,\n a: [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n ) -> Self {\n PkGeneration { configs, a, eek, sk, e_sm, r1, r2, pk0, pk1 }\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation\n fn payload(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let mut inputs = Vec::new();\n\n // Flatten CRS polynomials a (L polynomials of degree N)\n inputs = flatten::<_, _, BIT_PK>(inputs, self.a);\n\n // Flatten error polynomial eek (1 polynomial of degree N)\n inputs = flatten::<_, _, BIT_EEK>(inputs, [self.eek]);\n\n // Use commitments instead of full polynomials\n inputs.push(sk_commitment);\n inputs.push(pk_commitment);\n inputs.push(e_sm_commitment);\n\n // Flatten quotient polynomials (L polynomials each)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n inputs\n }\n\n /// Main execution function\n /// Returns (commit(threshold_sk), commit(threshold_pk), commit(e_sm))\n pub fn execute(self) -> (Field, Field, Field) {\n // Step 1: Perform range checks on all secret witness values\n self.perform_range_checks();\n\n // Step 2: Compute commitments\n let sk_commitment = compute_share_computation_sk_commitment::(self.sk);\n let e_sm_commitment =\n compute_share_computation_e_sm_commitment::(self.e_sm);\n let pk_commitment = compute_threshold_pk_commitment::(self.pk0, self.pk1);\n\n // Step 3: Generate Fiat-Shamir challenges using commitments\n let gammas = self.generate_challenge(sk_commitment, pk_commitment, e_sm_commitment);\n\n // Step 4: Verify public key equations for each modulus\n for i in 0..L {\n let gamma = gammas.get(i);\n self.verify_public_key_for_modulus(i, gamma);\n }\n\n // Step 5: Return all commitments\n (sk_commitment, pk_commitment, e_sm_commitment)\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let inputs = self.payload(sk_commitment, pk_commitment, e_sm_commitment);\n\n compute_threshold_pk_challenge::(inputs)\n }\n\n /// Performs range checks on all secret witness values\n fn perform_range_checks(self) {\n // Check that error polynomial has small coefficients\n self.eek.range_check_2bounds::(self.configs.eek_bound, self.configs.eek_bound);\n\n // Check that secret key polynomial has small coefficients\n self.sk.range_check_2bounds::(self.configs.sk_bound, self.configs.sk_bound);\n\n // Check quotient terms are within expected bounds (per modulus)\n for i in 0..L {\n self.e_sm[i].range_check_2bounds::(\n self.configs.e_sm_bound,\n self.configs.e_sm_bound,\n );\n\n self.r1[i].range_check_2bounds::(\n self.configs.r1_bounds[i],\n self.configs.r1_bounds[i],\n );\n\n self.r2[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n }\n }\n\n /// Verifies the threshold public key generation equations for a specific CRT basis\n fn verify_public_key_for_modulus(self, i: u32, gamma: Field) {\n // Evaluate all polynomials at the random challenge point gamma\n let a_at_gamma = self.a.map(|a_poly| a_poly.eval(gamma));\n\n let eek_at_gamma = self.eek.eval(gamma);\n let sk_at_gamma = self.sk.eval(gamma);\n\n let r1_at_gamma = self.r1.map(|r1_poly| r1_poly.eval(gamma));\n let r2_at_gamma = self.r2.map(|r2_poly| r2_poly.eval(gamma));\n\n let pk0_at_gamma = self.pk0.map(|pk0_poly| pk0_poly.eval(gamma));\n let pk1_at_gamma = self.pk1.map(|pk1_poly| pk1_poly.eval(gamma));\n\n // Evaluate the cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n let expected_pk0 = -a_at_gamma[i] * sk_at_gamma\n + eek_at_gamma\n + r2_at_gamma[i] * cyclo_at_gamma\n + r1_at_gamma[i] * self.configs.qis[i];\n\n assert(pk0_at_gamma[i] == expected_pk0, \"Public key equation 1 failed\");\n\n // Equation 2: pk1_i = a_i\n assert(pk1_at_gamma[i] == a_at_gamma[i], \"Public key equation 2 failed\");\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/pk_generation.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "80": { - "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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/polynomial.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"6089811819251995355","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"public"},{"name":"eek","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"sk","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e_sm","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"r1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"r2is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"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"},"15711739108859631478":{"error_kind":"string","string":"Public key equation 2 failed"},"16226075151901316264":{"error_kind":"string","string":"Public key equation 1 failed"}}},"bytecode":"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","debug_symbols":"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","file_map":{"3":{"source":"use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str {}\n}\n\nimpl From> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n","path":"std/array/mod.nr"},"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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, PK_GENERATION_BIT_E_SM, PK_GENERATION_BIT_EEK, PK_GENERATION_BIT_PK, PK_GENERATION_BIT_R1,\n PK_GENERATION_BIT_R2, PK_GENERATION_BIT_SK, PK_GENERATION_CONFIGS,\n};\nuse lib::core::threshold::pk_generation::PkGeneration;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n a: pub [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n) -> pub (Field, Field, Field) {\n let pk_generation: PkGeneration = PkGeneration::new(\n PK_GENERATION_CONFIGS,\n a,\n eek,\n sk,\n e_sm,\n r1is,\n r2is,\n pk0is,\n pk1is,\n );\n pk_generation.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/pk_generation/src/main.nr"},"70":{"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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_threshold_pk_challenge, compute_threshold_pk_commitment,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for threshold public key generation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bound for error polynomial (eek) coefficients\n pub eek_bound: Field,\n /// Bound for secret key polynomial (sk) coefficients\n pub sk_bound: Field,\n /// Bound for smudging noise polynomial (e_sm) coefficients\n pub e_sm_bound: Field,\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(\n qis: [Field; L],\n eek_bound: Field,\n sk_bound: Field,\n e_sm_bound: Field,\n r1_bounds: [Field; L],\n r2_bounds: [Field; L],\n ) -> Self {\n Configs { qis, eek_bound, sk_bound, e_sm_bound, r1_bounds, r2_bounds }\n }\n}\n\n/// Correct Threshold Public Key Generation Circuit (Circuit 1).\n///\n/// Verifies:\n/// 1. Range checks on all secret witnesses (secret key, error, smudging noise, quotients)\n/// 2. Correct public key generation: pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n/// and pk1_i = a_i\n///\n/// Outputs:\n/// - commit(threshold_sk)\n/// - commit(threshold_pk)\n/// - commit(e_sm)\npub struct PkGeneration {\n /// Cryptographic parameters including bounds, moduli, and constants.\n configs: Configs,\n\n /// Common Reference String polynomials (public witnesses)\n /// One polynomial per modulus i\n a: [Polynomial; L],\n\n /// Error polynomial (secret witness)\n /// Small coefficients sampled from error distribution\n eek: Polynomial,\n\n /// Secret key polynomial (secret witness)\n /// Small coefficients sampled from CBD (Centered Binomial Distribution)\n sk: Polynomial,\n\n /// Smudging noise polynomial (secret witness)\n /// Used for threshold decryption security\n e_sm: [Polynomial; L],\n\n /// Quotients from polynomial operations (secret witnesses)\n /// r1[i] are quotients from modulus switching for modulus i (can be negative, degree 2*N-1)\n r1: [Polynomial<2 * N - 1>; L],\n /// r2[i] are quotients from cyclotomic reduction for modulus i (typically positive, degree N-1)\n r2: [Polynomial; L],\n\n /// Threshold public key components (committed witnesses)\n /// pk0[i] is the first component of the public key for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component of the public key for modulus i (should equal a[i])\n pk1: [Polynomial; L],\n}\n\nimpl PkGeneration {\n pub fn new(\n configs: Configs,\n a: [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n ) -> Self {\n PkGeneration { configs, a, eek, sk, e_sm, r1, r2, pk0, pk1 }\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation\n fn payload(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let mut inputs = Vec::new();\n\n // Flatten CRS polynomials a (L polynomials of degree N)\n inputs = flatten::<_, _, BIT_PK>(inputs, self.a);\n\n // Flatten error polynomial eek (1 polynomial of degree N)\n inputs = flatten::<_, _, BIT_EEK>(inputs, [self.eek]);\n\n // Use commitments instead of full polynomials\n inputs.push(sk_commitment);\n inputs.push(pk_commitment);\n inputs.push(e_sm_commitment);\n\n // Flatten quotient polynomials (L polynomials each)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n inputs\n }\n\n /// Main execution function\n /// Returns (commit(threshold_sk), commit(threshold_pk), commit(e_sm))\n pub fn execute(self) -> (Field, Field, Field) {\n // Step 1: Perform range checks on all secret witness values\n self.perform_range_checks();\n\n // Step 2: Compute commitments\n let sk_commitment = compute_share_computation_sk_commitment::(self.sk);\n let e_sm_commitment =\n compute_share_computation_e_sm_commitment::(self.e_sm);\n let pk_commitment = compute_threshold_pk_commitment::(self.pk0, self.pk1);\n\n // Step 3: Generate Fiat-Shamir challenges using commitments\n let gammas = self.generate_challenge(sk_commitment, pk_commitment, e_sm_commitment);\n\n // Step 4: Verify public key equations for each modulus\n for i in 0..L {\n let gamma = gammas.get(i);\n self.verify_public_key_for_modulus(i, gamma);\n }\n\n // Step 5: Return all commitments\n (sk_commitment, pk_commitment, e_sm_commitment)\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let inputs = self.payload(sk_commitment, pk_commitment, e_sm_commitment);\n\n compute_threshold_pk_challenge::(inputs)\n }\n\n /// Performs range checks on all secret witness values\n fn perform_range_checks(self) {\n // Check that error polynomial has small coefficients\n self.eek.range_check_2bounds::(self.configs.eek_bound, self.configs.eek_bound);\n\n // Check that secret key polynomial has small coefficients\n self.sk.range_check_2bounds::(self.configs.sk_bound, self.configs.sk_bound);\n\n // Check quotient terms are within expected bounds (per modulus)\n for i in 0..L {\n self.e_sm[i].range_check_2bounds::(\n self.configs.e_sm_bound,\n self.configs.e_sm_bound,\n );\n\n self.r1[i].range_check_2bounds::(\n self.configs.r1_bounds[i],\n self.configs.r1_bounds[i],\n );\n\n self.r2[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n }\n }\n\n /// Verifies the threshold public key generation equations for a specific CRT basis\n fn verify_public_key_for_modulus(self, i: u32, gamma: Field) {\n // Evaluate all polynomials at the random challenge point gamma\n let a_at_gamma = self.a.map(|a_poly| a_poly.eval(gamma));\n\n let eek_at_gamma = self.eek.eval(gamma);\n let sk_at_gamma = self.sk.eval(gamma);\n\n let r1_at_gamma = self.r1.map(|r1_poly| r1_poly.eval(gamma));\n let r2_at_gamma = self.r2.map(|r2_poly| r2_poly.eval(gamma));\n\n let pk0_at_gamma = self.pk0.map(|pk0_poly| pk0_poly.eval(gamma));\n let pk1_at_gamma = self.pk1.map(|pk1_poly| pk1_poly.eval(gamma));\n\n // Evaluate the cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n let expected_pk0 = -a_at_gamma[i] * sk_at_gamma\n + eek_at_gamma\n + r2_at_gamma[i] * cyclo_at_gamma\n + r1_at_gamma[i] * self.configs.qis[i];\n\n assert(pk0_at_gamma[i] == expected_pk0, \"Public key equation 1 failed\");\n\n // Equation 2: pk1_i = a_i\n assert(pk1_at_gamma[i] == a_at_gamma[i], \"Public key equation 2 failed\");\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/pk_generation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/pk_generation.vk b/crates/zk-prover/tests/fixtures/pk_generation.vk index dd90626e6ec65ce3a6339f6e716f1f13804101c9..e38d16b2d449b8408bf985bcdd2c8b451dd28204 100644 GIT binary patch delta 1747 zcmV;^1}ypD9N-R+V1EJ&LS;%!$Zfv~x33Tk#lRt$$@SQt!>MF92><54a%~C<+z2&s zie@q6a*^}0L)KK(eCTOWRf73x#=#I*Y2z8SaS`qRD2Mj{G`JRuTRUE_bH%MsWabuv zJ9-rpd?_izmyb(9*wxa6877)QZ5U?X3!^2Z9Q#kGZscR49)I#GHkT1_z|dz4rs9UY z<@}2Qrz0>36oAYkwKf3+6m9?k95($B;1m5g$5DULr#C|oU#zktZbg2aM&^9C`z~u7 z;|V=vS;UsI$doknL>Ur*ORYS-O{ci#scwN`Lhq8+v+o7N37m0adNmiHcc~ zEp^G1|87)k#KV?_~ftm2}< zo#y~_)HKTFJZj4TiUEd`%*at#1RqX%`g1!AuqA`O5ca21>3gHsX2Iz@1LG9yVC2!y zF6VU1OCY3a#AgiYmee4H0(rc*@@aCr_rx}C7}LfIv~&RUt91gi;` zz7=grT$b5I`umAEkNKKae?u=N$bXbO7StYm8SXY68zFry6qFiLmvzfWgm!Rbl|h;L zNHB->NGAWlhCF~Nu#u-curIt`NBBL`iF)`RnpK4?w~(e={MdfJ7Nff=>=;sbS%R-Q z%T2hu;jZY$_h?dG3AHBugS9AY2g-vj2zd77_;1Q*ci6v+=tD*?>_#mNihn*9sDY0< zaon~#1=wj(mr(&G9GmC#9FPmH6Xp zRux{>2*|6KPM5Tme=a(NBz?>9=tuS;GZ(AQLHvs^m8)Hc*LL}VUriP)n(~;-Fb^Cb zBlBrAFFN6-aLc077%k{CP=653;fQn+xCRK$CkdWA)u5mXxBeIe0R_3Um9^Nnw5B@+ z-(@Qe5bqRiCIA(<(otP@;>_%s+|iU-At|pqV}Dv=Dl$Y5h7BGne;bi?7m^FDJ&V8` zm6Zu9A}ff22;3#nsznY9OTrSvelT8%lCenc+al)ak_UQ(NFhPT>wn}R0HM{4%XBy& zZ5b0*emjv|fdM+&6(eh<&!zzpv_L=$E6O+Gu?Sw0N_PQB(j|$x9}SO2bgx%L-rD_R z%Ic6yLr!#$mlNKM!`B2o20If9-?MWiPBE$%j zFl1`~mUCg0l#?)(Dw8t}9+40ZlYb2$K>{F&LLVhP!~%6$9;2v8<&h;GLbGDJ;5Lr` pC)(rc^a&2`fi})5u@sw&wtPQ{Jwjwz4qR}XFmx2^1=U7k)+bE9bte! z(!KcXD?k5nX}|`oaEf~(7&t-_ILAZV-P(e=GPM;7vQL2bd-g^P7&Nc=AB?9>3cDHO zz!6%${3UjMXiA{@_=$|qRa=1D_*F2Ulu-kw2=O*iDoW8L;0USLgyP=|S0#NDuB#)Y z_yAW69KjV4uWK$)ZyuZQFVva?ju7cFJI&RB-`8_a-7wD{&My^HqHl&(KGUIBV~LSe zJ|-4NWJ@;w_@n2CamB9_A5JcUf-MUBZdd6abBej_JQZELuqFsNLKscUC52I?C976i zY<)VR|&(nY-q~#O3`|^L+-d%IIyiR@FX5c$C{)G zsF;7&Ykr#lrc8CGUk&ilSH^2)R*0kSg;;F$quCRt#L>ZSct)xHCUDpBWXmwsWkM_RPpK>m9(n;_#_@)k(&$r z<6P_MAzwo1nz;gtS=aJ=lfXsi=Vm28T(4RpT4&b-#$X2UNj5dwNu8>3@;&zt(sjE+ zMc@dTa+-`6s;r3miy!+V9J7EM|4of>_d4ut?(_4Y2T)*U~b&Ysg+BoH(oBb*R=ZoU~i-41BEUm?O)kK|Xx47j5#`kh-HVfPrOY~&q zzY^Y?R)gmQAqADlW3Ig)zRC~P>}s_L2YF>-aF5&V+yt80xl#L2gH>07BeZPMMCu~j zwV6`TcWOcp2Ry8IUHjywBRrIXNn~}j(Y%2pq_$0n^>@OD+e6ell%vcZg>j6~2`KPmqXwSUbl!Q9my^v~+r^uN1iG{7;AR zTy?H9S`N#;$?4SrULSd+wWWL_Cpo`l&WYK==>aa<|5w_R)^Z8n?r{sGGt>jX!{R)B zc-Z-T>TqgAZ!Es89ymh3nU}6_j90bL%6xeudN>fc%zc>#-ECZdl0!t^=J^iQmB0~_ zp1qJw@G!0j9~Lk(p9_J1(ed3jpq6c37xaP`z`dGh2OJ^Ei0(uQ2UbBVxgqDMyd!Xv z$CljS3-+H6mHi&;?$%;61zhy~VBHQzn?e=S^*ME#@x{Qekn2fC-n!D)x>)O5d@uV5 zfFoqw5fl>9lG3a*e7w1%%@nx0rssnzcfL3d5*xbcxtAn4z!4(fzO)oPqeLH_h>ppl z?*jfK&ntF|DX}ffhR~}Ot^NV_XVLj%H>w10+nY1!^m8HE3iglV0oe|@KPYBNUnz#d zM~R!xfbkLfT|@V@iE`FT4|X`u<=jc&^ICac39D<7-D%TK7+=l zVGOm(qpLRjO#vRXOU17r+s0wLv#YaX*I0|+AIPD~CQO_U#^{EqVjlKa(`=4!(!j|d zar<@Wds}{GkHyI z{m+bbrq*M{$9aXovupUZ)x|baBZrLT6lRr!4S|dHPrglGLBaCcf7B!~QupEaLzh%x z?H@}&NM5^DK2c7K94nSbDs??H-;=L9-sQgR&e{W9&-i>C_9e0VmeUHHYqR3x7~lwL zWQ40`;>v7OA8BT1%aDOnbRAk}CUnrXzQ1^3R@%Ypz(w=-OU|sMd>Gc7dXu><3a(Ev z248J&k27xH@VXM~m%05mTCgm$fFr^j=7B7D|A6K2{|Ng3dl$dI|2mOD z)N;Ig@WH6%1)(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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, THRESHOLD_SHARE_DECRYPTION_BIT_CT, THRESHOLD_SHARE_DECRYPTION_BIT_D,\n THRESHOLD_SHARE_DECRYPTION_BIT_E_SM, THRESHOLD_SHARE_DECRYPTION_BIT_R1,\n THRESHOLD_SHARE_DECRYPTION_BIT_R2, THRESHOLD_SHARE_DECRYPTION_BIT_SK,\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n};\nuse lib::core::threshold::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_sk_commitment: pub Field,\n expected_e_sm_commitment: pub Field,\n ct0: pub [Polynomial; L],\n ct1: pub [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<(2 * N) - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n) {\n let share_decryption: ShareDecryption = ShareDecryption::new(\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n );\n share_decryption.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/share_decryption/src/main.nr"},"71":{"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::commitments::{\n compute_aggregated_shares_commitment, compute_threshold_share_decryption_challenge,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold decryption share circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], r1_bounds: [Field; L], r2_bounds: [Field; L]) -> Self {\n Configs { qis, r1_bounds, r2_bounds }\n }\n}\n\n/// Threshold Share Decryption (Circuit 6).\n///\n/// Verifies:\n/// 1. Commitment to sk matches expected (from DKG decryption circuit)\n/// 2. Commitment to e_sm matches expected (from DKG decryption circuit)\n/// 3. Correct computation: d_i = c_0i + c_1i * s_i + e_i + r_2i * (X^N + 1) + r_1i * q_i\npub struct ShareDecryption {\n /// Circuit parameters including bounds and cryptographic constants\n configs: Configs,\n\n /// Expected commitment to aggregated sk shares (from DKG decryption circuit)\n /// (public witness)\n expected_sk_commitment: Field,\n\n /// Expected commitment to aggregated e_sm shares (from DKG decryption circuit)\n /// (public witness)\n expected_e_sm_commitment: Field,\n\n /// Ciphertext components (public witnesses)\n /// ct0 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct0: [Polynomial; L],\n /// ct1 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct1: [Polynomial; L],\n\n /// Aggregated sum of sk shares (secret witness)\n sk: [Polynomial; L],\n\n /// Aggregated sum of e_sm shares (secret witness, direct input)\n /// e_sm[basis] - sum of e_sm shares for each CRT basis (degree N-1 with N coefficients)\n e_sm: [Polynomial; L],\n\n /// Quotient polynomials for lifting to Z (secret witnesses)\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n\n /// Party's computed decryption share\n /// (public witnesses)\n d: [Polynomial; L],\n}\n\nimpl ShareDecryption {\n pub fn new(\n configs: Configs,\n expected_sk_commitment: Field,\n expected_e_sm_commitment: Field,\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n ) -> Self {\n ShareDecryption {\n configs,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n }\n }\n\n /// Verifies that aggregated secret shares hash to expected_sk_commitment\n fn verify_agg_sk_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.sk)\n == self.expected_sk_commitment,\n \"S commitment mismatch\",\n );\n }\n\n /// Verifies that aggregated noise shares hash to expected_e_sm_commitment\n fn verify_agg_e_sm_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.e_sm)\n == self.expected_e_sm_commitment,\n \"E commitment mismatch\",\n );\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation.\n ///\n /// This function serializes all polynomial coefficients (both public inputs and\n /// secret witnesses) into a 1D array in a deterministic order. The flattened data\n /// is used to generate the Fiat-Shamir challenge via the SAFE sponge API.\n ///\n /// The order of serialization is:\n /// 1. Commitment to aggregated secret shares `sk` (expected_sk_commitment)\n /// 2. Commitment to aggregated noise shares `e_sm` (expected_e_sm_commitment)\n /// 3. Ciphertext components `c_0` for each CRT basis (serialized coefficients)\n /// 4. Ciphertext components `c_1` for each CRT basis (serialized coefficients)\n /// 5. Quotient polynomials `r_1` for each CRT basis (serialized coefficients)\n /// 6. Quotient polynomials `r_2` for each CRT basis (serialized coefficients)\n /// 7. Decryption shares `d` for each CRT basis (serialized coefficients)\n ///\n /// Note: Aggregated secret shares `sk` and noise shares `e_sm` are represented by their\n /// commitments rather than serialized coefficients. This saves constraints while\n /// still binding them to the transcript.\n ///\n /// # Returns\n /// A vector containing commitments and polynomial coefficients in flattened form,\n /// ready for hashing to generate the Fiat-Shamir challenge.\n fn payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n // Use commitments instead of full polynomials (saves constraints)\n inputs.push(self.expected_sk_commitment);\n inputs.push(self.expected_e_sm_commitment);\n\n // Flatten ciphertext components (public inputs)\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1);\n\n // Flatten quotient polynomials (secret witnesses)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n // Flatten decryption shares (public outputs)\n inputs = flatten::<_, _, BIT_D>(inputs, self.d);\n\n inputs\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify sk commitment matches expected\n self.verify_agg_sk_commitment();\n\n // Step 2: Verify e_sm commitment matches expected\n self.verify_agg_e_sm_commitment();\n\n // Step 3: Perform range checks on quotient polynomials\n // Note: sk and e_sm range checks are handled by commitment verification\n // (the DKG decryption circuit already performed range checks on these values)\n self.check_range_bounds();\n\n // Step 4: Generate Fiat-Shamir challenge from the transcript\n let gamma = self.generate_challenge();\n\n // Step 5: Verify decryption share computation for each CRT basis\n for i in 0..L {\n self.verify_decryption_share_computation(i, gamma);\n }\n }\n\n /// Performs range checks on quotient polynomial witnesses.\n ///\n /// This function constrains quotient polynomials to be within their expected bounds\n /// as specified in the `configs`. This is critical for security because it prevents\n /// attacks where malicious provers provide out-of-range values that could break the\n /// security properties of the Threshold scheme.\n ///\n /// Note: Range checks on `sk` and `e_sm` are NOT performed here because:\n /// - Their commitments are verified against expected values from the DKG circuit\n /// - The DKG decryption circuit already performed range checks on these values\n /// - Commitment binding ensures the values match what was previously verified\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any quotient coefficient is\n /// outside its expected bounds.\n fn check_range_bounds(self) {\n // Check quotient polynomials are within bounds\n for basis_idx in 0..L {\n // r_1 quotients can be negative (modulus quotients)\n self.r1[basis_idx].range_check_2bounds::(\n self.configs.r1_bounds[basis_idx],\n self.configs.r1_bounds[basis_idx],\n );\n // r_2 quotients (cyclotomic quotients)\n self.r2[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge value using the SAFE cryptographic sponge.\n ///\n /// This function implements the Fiat-Shamir transform for the decryption share circuit:\n /// 1. Flattens all witness data (commitments for sk/e_sm, ciphertexts c_0/c_1, quotients r_1/r_2, decryption shares d) into a single array\n /// 2. Absorbs the flattened data into the SAFE sponge\n /// 3. Squeezes a single challenge value\n ///\n /// The challenge is used to evaluate polynomials for the Schwartz-Zippel lemma,\n /// which allows verification of polynomial equations by checking them at a random\n /// point rather than checking all coefficients.\n ///\n /// # Returns\n /// A single challenge value `gamma` used as the evaluation point for verifying\n /// the decryption share computation formula for all CRT bases.\n fn generate_challenge(self) -> Field {\n let inputs = self.payload();\n\n compute_threshold_share_decryption_challenge::(inputs)\n }\n\n /// Verifies the lifted decryption share computation formula for a specific CRT basis using the Schwartz-Zippel lemma.\n ///\n /// This function verifies that the decryption share for basis `i` satisfies:\n /// `d_i(gamma) = c_0i(gamma) + c_1i(gamma) * s_i(gamma) + e_i(gamma) + r_2i(gamma) * cyclo(gamma) + r_1i(gamma) * q_i`\n ///\n /// Where:\n /// - `c_0i`, `c_1i` are ciphertext components for basis i\n /// - `s_i` is the aggregated secret key shares for basis i\n /// - `e_i` is the aggregated noise shares for basis i\n /// - `r_1i`, `r_2i` are quotient witnesses for basis i\n /// - `cyclo(gamma) = gamma^N + 1` is the cyclotomic polynomial evaluated at gamma\n /// - `q_i` is the CRT modulus for basis i\n ///\n /// The Schwartz-Zippel lemma ensures that if this equation holds at a random point\n /// `gamma`, then the polynomials are identical with high probability.\n ///\n /// # Arguments\n /// * `basis_idx` - The index of the CRT basis to verify (0 <= basis_idx < L)\n /// * `gamma` - The Fiat-Shamir challenge value used as the evaluation point\n ///\n /// # Panics\n /// The circuit will fail if the decryption share computation formula doesn't hold for the specified basis.\n fn verify_decryption_share_computation(self, basis_idx: u32, gamma: Field) {\n // Evaluate ciphertext components at gamma\n let c_0_at_gamma = self.ct0[basis_idx].eval(gamma);\n let c_1_at_gamma = self.ct1[basis_idx].eval(gamma);\n\n // Evaluate aggregated sums at gamma\n let sk_at_gamma = self.sk[basis_idx].eval(gamma);\n let e_sm_at_gamma = self.e_sm[basis_idx].eval(gamma);\n\n // Evaluate quotient polynomials at gamma\n let r_1_at_gamma = self.r1[basis_idx].eval(gamma);\n let r_2_at_gamma = self.r2[basis_idx].eval(gamma);\n\n // Evaluate cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // Compute expected decryption share using the lifted formula:\n // d_i = c_0i + c_1i * sk_i + e_sm_i + r_2i * (X^N + 1) + r_1i * q_i\n let expected_decryption_share = c_0_at_gamma\n + c_1_at_gamma * sk_at_gamma\n + e_sm_at_gamma\n + r_2_at_gamma * cyclo_at_gamma\n + r_1_at_gamma * self.configs.qis[basis_idx];\n\n // Evaluate the party's claimed decryption share at gamma\n let computed_decryption_share = self.d[basis_idx].eval(gamma);\n\n // Enforce equality: computed decryption share must match expected value\n assert(\n computed_decryption_share == expected_decryption_share,\n \"Decryption share computation failed\",\n );\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/share_decryption.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/share_decryption.vk b/crates/zk-prover/tests/fixtures/share_decryption.vk new file mode 100644 index 0000000000000000000000000000000000000000..e1ea1bfab34d1f30acc3b615f8a8adfa10ab19a4 GIT binary patch literal 1888 zcmajg`6Ckw0KoAL(`@Ee*u=)N8euYp`Jt0cjBZh@^Nbk+n`tq zHPN2-j*FzMosDHl_Uji*?~$bV%FPm5x2*iO zXfh*m8J1Z0cIJ*W9eUTc^_o+Sft*6{rk=O)BeDrnL{F{g#nrE4iMPSnZpAE~1#0d; zg<2AM%#&7UBYRX;(#t$!0~rPtxdP!CI*?J*2CHy zWM#M`Z!VRlox9T|dL-+)y{D)4*i?G36v1SKur*~krq@m!BVmPJcP?ogl(#ROV+XDo zrHAt^a@*j4#WOF2oAZF9S&m{UF}NayRoC5>PxMVYHh9P^V4dG67$_@X!@8%&qsb+8 zy(-kOpD@5sA3T`H2Qnf#{S!gmsdo=KzDQ{*b@vY5ju`oHI_+Gq?jE8E6JG3v3zoW3 z{;-sZ$)QY#!;F%s2SxUl#eHR2*^;x5c9)|R#fKAE+o0$Ht5B;%ZA*(MoKsj|CI23+(L>P>|FAsjW*_w9N z_x2SM*Is?`7^|2Z=n<^bJIC4(kdrJjbZ%rfMV^NvsBen+I*2eQzO+t<4n8rbN|o~$ z4^3#zEh2?(SRLN5ndP07fDU%XZVcGw{PL5Aptd_cD0~InQg_bcWgAcnJ9s@QpSRk> zg{OXfKkQSALJ?O%@2j`L@*|NsLIFJFpx~Ok%5dV3zI|iC@v>YHjRSh(!CUC;v))b) zGFLtb)2Piew2*FX8M5!dA+ehCtZ~yI>iZYCCo=z*O~Y?eKAl3%Qumy%bv8L?XgmOYPT)1qfkPNe z+rO;m1upHIf5o?2HlN+YA>cjk)v502Y`E6oKp;0+HDDH%8ePEJCi*EC=04|*-}^qf z-`$j4D=Mh_JZv$m;QMh}o5&X)j-zz$S{oGLV zWK9IR8cShTF9!T+@o_F5ro_^FN#Zp0KS5FV#p7X{_*ZtMi`xg)~F72rW|PeGNX7T0;X1)&6?3#Os|F zu2$!tCJNDYk)Ywjdm7)y)td|{w6#kW%p}BN?6Z3-I~PAKEXRqqvyVqpKNdr`eYKhN z`y&$Ti1<&s_kB2fAdZQS1x=))}0Ilm3^`y-;HZBVG(0AqW>{HiuU zWG%#`i|Ad!xXmW{;L63}k_WEY$@*v=;${2^q<>QI8J?@^xCI3mmtr70%4^-Jn8EZ%IXVZ-3A)M_Yr*;WC~_n{hP{XG zucaUjTVaN>jrX7d?kfqIgge{9?VUSOzjp4q=e)ox&8p0F@l2TBb_?Pn1gF5-5@3J*Gxx@3Xl00cB zQ`_i!ceBe~HkfaG`@ASf%m#$>RjyJcSMj9}B_)u?Um_epP;-4&!&D=+{1Rx^UkS#y zDHJFR5N;ZC@CyF=Zar^iG}9faK-Tw*K>I3cn(@ZM&MQX1(;uA6fYul!y+veYaVbhE z#Ycf>WJasZd7w630yKg;CLx1jwZW8H`j&C#5zz{1+`G0Q33&D)c@U>75hyB%B3w%M zi~{OU3rh#QcwY|Wry3bSl?E<;rGPOR)_9=Rm`p;m1T578M|L&)JbmIfu$pFLYKKeB z5&WD?`^aIyc}Wm5TaPs%n~w;i<-d=RzC3uszm$z&X_p-f%)KOdJe2*iNN(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{\n L, N, SHARE_ENCRYPTION_BIT_CT, SHARE_ENCRYPTION_BIT_E0, SHARE_ENCRYPTION_BIT_E1,\n SHARE_ENCRYPTION_BIT_MSG, SHARE_ENCRYPTION_BIT_P1, SHARE_ENCRYPTION_BIT_P2,\n SHARE_ENCRYPTION_BIT_PK, SHARE_ENCRYPTION_BIT_R1, SHARE_ENCRYPTION_BIT_R2,\n SHARE_ENCRYPTION_BIT_U, SHARE_ENCRYPTION_CONFIGS,\n};\nuse lib::core::dkg::share_encryption::ShareEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_pk_commitment: pub Field,\n expected_message_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: pub [Polynomial; L],\n ct1is: pub [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n) {\n let share_encryption: ShareEncryption = ShareEncryption::new(\n SHARE_ENCRYPTION_CONFIGS,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n share_encryption.execute();\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/share_encryption/src/main.nr"},"65":{"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::commitments::compute_dkg_pk_commitment;\nuse crate::math::commitments::{\n compute_share_encryption_challenge, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for DKG share encryption circuit.\npub struct Configs {\n /// Plaintext modulus t\n pub t: Field,\n /// Q mod t (for scaling message)\n pub q_mod_t: Field,\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Bound for message polynomial (m)\n pub msg_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n t: Field,\n q_mod_t: Field,\n qis: [Field; L],\n k0is: [Field; L],\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n msg_bound: Field,\n ) -> Self {\n Configs {\n t,\n q_mod_t,\n qis,\n k0is,\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n msg_bound,\n }\n }\n}\n\n/// DKG Share Encryption Circuit (Circuit 3).\n///\n/// Verifies:\n/// 1. Public key commitment matches expected (from Circuit 0)\n/// 2. Message commitment matches expected (from SK shares circuit)\n/// 3. Correct DKG share encryption: ct0[l] = pk0[l] * u + e0[l] + k1 * k0[l] + r1[l] * q[l] + r2[l] * (X^N + 1)\n/// and ct1[l] = pk1[l] * u + e1 + p2[l] * (X^N + 1) + p1[l] * q[l]\npub struct ShareEncryption {\n /// Circuit parameters\n configs: Configs,\n /// Expected commitment to public key (from Circuit 0)\n /// (public witness)\n expected_pk_commitment: Field,\n /// Expected commitment to message (from SK shares verification circuit)\n /// (public witness)\n expected_message_commitment: Field,\n /// Public key component 0 for each CRT basis (committed witnesses)\n pk0is: [Polynomial; L],\n /// Public key component 1 for each CRT basis (committed witnesses)\n pk1is: [Polynomial; L],\n /// Ciphertext component 0 for each CRT basis (public witnesses)\n ct0is: [Polynomial; L],\n /// Ciphertext component 1 for each CRT basis (public witnesses)\n ct1is: [Polynomial; L],\n /// Random ternary polynomial u (secret witness)\n u: Polynomial,\n /// Error polynomial e0 (secret witness)\n e0: Polynomial,\n /// Per-basis error polynomials e0[l] (secret witnesses)\n e0is: [Polynomial; L],\n /// CRT quotients for e0 (secret witnesses)\n e0_quotients: [Polynomial; L],\n /// Error polynomial e1 (secret witness)\n e1: Polynomial,\n /// Raw message polynomial (secret witness)\n message: Polynomial,\n /// Modulus switching quotient polynomials r1 (secret witnesses, degree 2N-1)\n r1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials r2 (secret witnesses, degree N-1)\n r2is: [Polynomial; L],\n /// Modulus switching quotient polynomials p1 (secret witnesses, degree 2N-1)\n p1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials p2 (secret witnesses, degree N-1)\n p2is: [Polynomial; L],\n}\n\nimpl ShareEncryption {\n pub fn new(\n configs: Configs,\n expected_pk_commitment: Field,\n expected_message_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> Self {\n ShareEncryption {\n configs,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Verifies that the public key hashes to the expected commitment\n fn verify_pk_commitment(self) {\n assert(\n compute_dkg_pk_commitment::(self.pk0is, self.pk1is)\n == self.expected_pk_commitment,\n \"Public key commitment mismatch\",\n );\n }\n\n /// Verifies that the message polynomial hashes to the expected commitment\n fn verify_message_commitment(self) {\n assert(\n compute_share_encryption_commitment_from_message::(self.message)\n == self.expected_message_commitment,\n \"Message commitment mismatch\",\n );\n }\n\n /// Computes the scaled message k1 from the raw message in centered form\n /// k1[i] = (q_mod_t * message[i]) mod t, centered to [-t/2, t/2)\n fn compute_scaled_message(self) -> Polynomial {\n let t = self.configs.t;\n let t_mod = ModU128::new(t);\n let q_mod_t: Field = self.configs.q_mod_t;\n let mut k1_coeffs: [Field; N] = [0; N];\n\n // Integer division for t_half\n let t_half: u128 = (t as u128) / 2;\n\n for i in 0..N {\n let msg_i: Field = self.message.coefficients[i];\n let q_times_m_mod_t = t_mod.mul_mod(q_mod_t, msg_i);\n\n // Check if centering is needed (value > t/2 means negative in centered form)\n let needs_centering = (q_times_m_mod_t as u128) > t_half;\n\n k1_coeffs[i] = if needs_centering {\n // Value is in (t/2, t), negative in centered form\n // Represent as P - magnitude (i.e., 0 - magnitude in Field)\n let magnitude = t - q_times_m_mod_t;\n 0 - magnitude\n } else {\n // Value is in [0, t/2], stays positive\n q_times_m_mod_t\n };\n }\n\n Polynomial { coefficients: k1_coeffs }\n }\n\n /// Flattens all polynomial coefficients into a single array for Fiat-Shamir challenge generation\n fn payload(self, k1: Polynomial) -> Vec {\n let mut inputs = Vec::new();\n\n // Use pk commitment instead of full pk polynomials\n inputs.push(self.expected_pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n\n // Use message commitment instead of full message\n inputs.push(self.expected_message_commitment);\n\n // Include computed k1 in payload\n for i in 0..N {\n inputs.push(k1.coefficients[i]);\n }\n\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Performs coefficient-wise CRT consistency check for the e0 error polynomial\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n for j in 0..N {\n assert(\n self.e0.coefficients[j]\n == self.e0is[i].coefficients[j]\n + self.e0_quotients[i].coefficients[j] * self.configs.qis[i],\n );\n }\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify public key commitment matches expected\n self.verify_pk_commitment();\n\n // Step 2: Verify message commitment matches expected\n self.verify_message_commitment();\n\n // Step 3: Perform range checks\n self.check_range_bounds();\n\n // Step 4: Check CRT consistency for e0\n self.check_e0_crt_consistency();\n\n // Step 5: Compute scaled message k1 from message\n let k1 = self.compute_scaled_message();\n\n // Step 6: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge(k1);\n\n // Step 7: Verify encryption constraints\n self.verify_evaluations(gammas, k1)\n }\n\n /// Performs range checks on all secret witness polynomial coefficients\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::(self.configs.e0_bound, self.configs.e0_bound);\n self.e1.range_check_2bounds::(self.configs.e1_bound, self.configs.e1_bound);\n\n // Message should be in [0, t)\n self.message.range_check_standard::(self.configs.msg_bound);\n\n for i in 0..L {\n self.pk0is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n\n self.r1is[i].range_check_2bounds::(\n self.configs.r1_up_bounds[i],\n self.configs.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n\n self.p1is[i].range_check_2bounds::(\n self.configs.p1_bounds[i],\n self.configs.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n self.configs.p2_bounds[i],\n self.configs.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(self, k1: Polynomial) -> Vec {\n let inputs = self.payload(k1);\n\n compute_share_encryption_challenge::(inputs)\n }\n\n /// Verifies DKG encryption constraints using Fiat-Shamir challenges and the Schwartz-Zippel lemma\n fn verify_evaluations(self, gammas: Vec, k1: Polynomial) {\n let gamma = gammas.get(0);\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n // Verify ct0 equation: ct0[i] = pk0[i]*u + e0[i] + k1*k0[i] + r1[i]*q[i] + r2[i]*cyclo\n let mut ct0_rhs = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n ct0_rhs += k1_at_gamma * self.configs.k0is[i];\n ct0_rhs += r1i_at_gamma * self.configs.qis[i];\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n let ct0_lhs = self.ct0is[i].eval(gamma);\n\n // Verify ct1 equation: ct1[i] = pk1[i]*u + e1 + p2[i]*cyclo + p1[i]*q[i]\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n let mut ct1_rhs = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n ct1_rhs += p2is_at_gamma * cyclo_at_gamma;\n ct1_rhs += p1is_at_gamma * self.configs.qis[i];\n let ct1_lhs = self.ct1is[i].eval(gamma);\n\n // Accumulate weighted sums for batch verification\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n assert(sum.0 == sum.1);\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/share_encryption.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/share_encryption.vk b/crates/zk-prover/tests/fixtures/share_encryption.vk new file mode 100644 index 0000000000000000000000000000000000000000..929d89b0c4f50c04eac7662bab4ff8b7e7ba6f16 GIT binary patch literal 1888 zcmajg=OY^k1IO{imL`ITvqy|ZG-{mj2%2bvm`7CAsoJ%xc3XR0>`^hQadw`nitQ*$ zOSQsdj~I;^GsxSgs z_JJ;qi(_q9BG|`f0=)EiESgMthfB{Ch+mC5T^!{Q51?$B`Y(;;ja1vr93D|eQN7d^ zw#T1VtNUnzWJ_j4`-Hm##q6o>qmW5T@|07hg3&qia6C;RVqN@Ic;nr;Z>vJr<6U== z$QaXK9iuP!q$Bjfw7+qpS95m8UCm#nRpX4&L9^DiUId4GK1s5=P<82SF@FuWr_O#H zSexdXW%p|OeL>P{h2sMf18ZR+AoCi&>5RVWCOxwJ_e0#nSt;ujk$j00V$eacSDZaa zv5BJPlC;v@?1ReI>wlM}p6zXD-qo(ETYw14vGG?ywzEL30vd3S#f$q!P-Gybth~;k zM3tf-2fVRyXbTs{yIwhSmoc@#=%aWo4cu$;pSD0qa#$Lq_6_g!OlzX1EcuN#WQK&unCWPt*yXcgU0YL|<}BnQ z|9?q3PSr5SpJj|4@IcVh*YAn&?j!`-dZPxej6PWd8g;2eokThjZvaVzG{qQpQ6@RKn}z4?@66XI+1 zwdMN}p6Vzo6(gTu<$K(fbVX*?5p+9vslwA)`*c&O;ek*8|4*3}Pt_E~gVMu?S$3R; zCc*NHs3GRUSH;Rkm{22e6zyveK+@*DN)hZpQhT58UiK-S)o4mlFJCHn{i=GqQ~;$z zBJpX{sVv@R^w6&Q2rkNHK})o<2BUfE3VilJY~*B{ygR?O&pJy4t=KAq$@Y!iJEDN*WHMAFQlo}HTAQXyF> zUNuo}|0PKKV2mL7ee~>eVo~Cku=q^xZIBzuv*EH5cr?8ia7cQnSYi=}X6&<)IJLYvy{_fG)KNKBskT805tq@0R>IuTcN86z zW)H;dLEZWu05s?8C)NC$b2!Vpc-$rL4!o`$PFa95yv1ncVE9Z~MoF?Avvk2uqA)sz zR1BK#Gwa$87^E;_A&j4)x#XrOPFt}1->Th4Bf-nv?|(o*9@v%ys~4v z&S-%L4?+~*Xs7Y;%q4dp1CYHNZ%9KnJ@kmjFyS(5@4WA56!e_wZ~k>vBy-9)@JO)Q zKdgYQFl?aTHx*cX4$q^N00~6V_v8VLmubDm(4!WK_dbEwFBrzyEqfbF;10$Z6d4sQ zS70o&X#3%!vTU!0*p^VFj!Ka$`_HBjZp-i$e;H<`yd2c=O^gf3-PuBJo9}3?#c(sd zR3U<&L;{ro@INMP??kMP?3XM}6x^0qq3L_XIk}@WZ$MKaGN?Goyzrm$FTFI(=#wIo z`B4Z}QUc$S(nK9z;F84~;kU8sE@}BqW(SK1)=oa}qhvFA+|b^J9H3$*lOCog8z>HQ zh{fbNCjj*q;0pdVW3@n`RxI|C>agxw6Q4`Ic_h$mQYo!d7LsEUM!R+6u;oV$| z>(*g8MX-;VZ|ArSc`z^#vnAA+h98GJA=wkujeumxvw~|(yq%Qi|CHf~0lp{do_^m8 zL){7ro~V;iTb8#BMN=7cb3mw`{lE3;U!3EL@JP++ek~ajPzUP&f{2KmJF6A>Xtt5k r2uqjIqPi$91)Y59{0)LEVYeMug=#osP0p1Us_(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n", - "path": "std/field/mod.nr" - }, - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_SK_BIT_SECRET,\n SHARE_COMPUTATION_SK_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SecretKeyShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let sk_share_computation: SecretKeyShareComputation = SecretKeyShareComputation::new(\n SHARE_COMPUTATION_SK_CONFIGS,\n expected_secret_commitment,\n sk_secret,\n y,\n PARITY_MATRIX,\n );\n\n sk_share_computation.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/sk_share_computation/src/main.nr" - }, - "63": { - "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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_computation.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "77": { - "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" - }, - "79": { - "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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" - }, - "80": { - "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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/polynomial.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"3602743820748630563","abi":{"parameters":[{"name":"expected_secret_commitment","type":{"kind":"field"},"visibility":"public"},{"name":"sk_secret","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"y","type":{"kind":"array","length":512,"type":{"kind":"array","length":2,"type":{"kind":"array","length":6,"type":{"kind":"field"}}}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"array","length":5,"type":{"kind":"array","length":2,"type":{"kind":"field"}}},"visibility":"public"},"error_types":{"9796982720213159702":{"error_kind":"string","string":"SK commitment mismatch"},"12469291177396340830":{"error_kind":"string","string":"call to assert_max_bit_size"},"15757906049389710862":{"error_kind":"string","string":"Parity check failed"},"15764276373176857197":{"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_SK_BIT_SECRET,\n SHARE_COMPUTATION_SK_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SecretKeyShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let sk_share_computation: SecretKeyShareComputation = SecretKeyShareComputation::new(\n SHARE_COMPUTATION_SK_CONFIGS,\n expected_secret_commitment,\n sk_secret,\n y,\n PARITY_MATRIX,\n );\n\n sk_share_computation.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/sk_share_computation/src/main.nr"},"63":{"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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/share_computation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/sk_share_computation.vk b/crates/zk-prover/tests/fixtures/sk_share_computation.vk index 0f98f29ed3edb2f91831b1bd735aa026c4807773..56f249009a6465135172f73f87432d86ef724d1b 100644 GIT binary patch delta 1747 zcmV;^1}ypD9N-R+V1E_$mahlLN+d{PkDZ6ak4gcApCp@ZG$Vy2YGsQ1eNYchg2s?5 zAC^({|IF8R^oi+Bu@3u5y{O=IvBu&i_f8YUW5ow4=|6w%!VFu)$8-4(Xzr)@)h*Wd zpA~b1CIAz~2J-(!I)7H05>Qd;rS0W|+*eY4dfq7?s=&|9>3{McQy_VmZB$29&LGBz z=}dUoG{A|_5D38s!+r@}EI5@5yv3&j2n#yHLLiv^%UQvcPGGkk4-d{|LAfc+&gKge zcu%ydf&jQSF=~Q!tDm}Kq(xWuxucyx zR9(N8={*_?|9|Md0hqO@RfU3LqvUr>;tF(&D*Tz%QVl?4hj7WsgOn|eDU{4)shPWt zECemoO}y65BXw59wdaPe@1k`v`;+KcAM&`4Oa6LKBhi3$>5m3cE|In?I^_u~b<|8; z@eVIj5|`GL*D8C!ktaT->HOr^~LP*@Fs(Jtlp!^Cd0^lSf0o|~y{bU^L-a%CM9ra0yA?Ht@kWT*XbBUKkQ(j8=U%`q9Kt=~aN7G8L=&n3u zqv@4Ui2d5hF)g$31^|ak!*c`ubVJgm-2IueWiO#eYKK2luk59Yx2e=nDguiJqjS{K z3JE8hTkRrb4d456BNXT*3d>L-XvEIzj2tcg*LY$uQ}y*L>e?{iQr^dP7kLQRNq;f5 ztF@(qsmCDv6ncS+K))s<{x5lWqH>t1#2`r^FH4vx89FR)ore~}*SogF<@T*M$O72< z0ZFr>t==rgll5PDf&M6KOZF18nw9`-+fhW8of7o4!U_jawsurfAO0DEw*!K!g z%R@8N%n4`#qxHF6P}Q>-kmcX2Ds?~)MEVL?I>Sl7?kRgAD7oOXp8^{M-G9+u)U;M& z2kfCvEFD@@;zibL+V`#0HsO+VnE;nMbP?9ntnY<()Z+lH1QJ)s$gBbN z*<@38jIyfIZ&3d}SQWd%0U57sQJ5(qx2=nGiOo)H7f!|9;oCAhe6E zAKPDm6^;GYNC7mF_W}KJMSp*zCJ+@qm1nc+ya}E=)u5mXxBeIe0R_3Um9^Nnw5B@+ z-(@Qe5bqRiCIA(<(otP@;>_%s+|iU-At|pqV}Dv=Dl$Y5h7BGne;bi?7m^FDJ&V8` zm6Zu9A}ff22;3#nsznY9OTrSvelT8%lCenc+al)ak_UQ(NFhPT>wn}R0HM{4%XBy& zZ5b0*emjv|fdM+&6(eh<&!zzpv_L=$E6O+Gu?Sw0N_PQB(j|$x9}SO2bgx%L-rD_R z%Ic6yLr!#$mlNKM!`B2o20If9-?MWiPBE$%j zFl1`~mUCg0l#?)(Dw8t}9+40ZlYb2$K>{x=XFjTNT*+q)G7%Y03IVP)B+YuciGdr; p?-QK4t|u=}HkZ==N@=SMmYEb3f!5p33*g1yD8OD7bLo0u|F9X(MgRZ+ literal 3680 zcmajhc{r5o8wc=bP|S=a%S1;pjD6QBr$!jrW++)IQB=|ir4)lv8B0jEXoyao7Rgd$ zDkQ&jax!R+EwX1XWhyC4&Y|JV-}n5k)BE3ZectbTUGIB8@BQ2e{pY3lpNf#`4;%yB z8FTKs)^Eo*kP@|n4_{b3>joSl!dxy#ve8+K>YsTnnVShbg}?oQ>>}-H@d*7v!j#@+MR31JC3fQ3s%?xA`~eZCEI^11Y0 zZX>v1ay((c%j0bHkiL3pZCeX}8n`fDzjAunfy~@}MZwLTUkE&^cSCK;%T-c;O4h|- zeT_Ed07ppOlgP*m+3B>amDrHX-v<0omg|A4b#ij8hi$9%n_J)Efg^;ksV@?j!jtQ^ z67vL2-oXEN=(dB`x9WnMnH6Gz^Q7Nz14l?9YDYzBJbG+l9vn}gFa!%}(EE zxqPdi@XHf_07uBoirT(xGkQ2aa6a`_=sV!42H*3$JY*;V$)P-60?RlZI6|1b%Hmy# z@%{yGBVERD;lNu-^xfRb_eo__x9H}JmnQZAM@XO598i+~B;82DxO00=H*j~8tVf3A zajYS|bKAbJvZkKEh2MYrafZuM^bS&cES;aZ68OZO3#zBllf7q-@OVZTUO-BV0}J(OflQ1@AR*gtR5hZQmCX0?&lRzD%@?0KUO# z#HWIS&F6(u{aLPGEX#o-B$K{BQPFB;mp`q+kz7jxu1+h%dnaeSyiKzHLnJ>JAfl(de&VqD!7qxfu+j|YJ>H){aUy>RFI3SjXAa&yWKJ7 zzDQoxZ=;yX^sYg*PZqL%#0lWv)qGpD#m6J1Hw2AF6fYhe11|jj+cq{8qpj3|qS9!D zy8(Pz#kSutOn9k44(Ueu#Pk{&RN^|UM zV1?3;r&)?IwXP@uM@XDU-L(+&mB|Qfn*X*Jo_`)JW9LBz-=@YO>hqTU`?>J{LTHVc zXa48>@5Q(RelKZ=4W2(ywk4o|pW}93(9bhBF8>1i3qr(kCQgerNO6?3b$aE@0r|tG zH=Tl$Z9F-j3NKWZbh;S;7cP@s>cYeY;dUK`1A=_mA7q9XPmz=+v~f*t8iCx_k7*)# zvDB3XVVxZ~tnP1nCp80rdki(wl^Ie!H1o>4m4)#o@O(sQt?^P%l)sth+??TuezOsf zKb2R^CDMqdE_r%u$VMlwB?A|}|97S6xKzqB9nz91BkC4#TKO&ZkWs^>x&4f|CB36A zqWf?4^PVSlMQA+ zx3vW6J`~AoGJ7VnYNvB1*F{#ni@yL|-(uA(%1qKNyiZ9*P5j4@6yU=7!-=98UUKnx zSMVJluJ&HwftZ51YG1dma+QnY!*>nn6yONyI4l*U_GR)<3PGR}J#v`RFn^T)w;W-c({l=Nkn74}^@?`Rp8X z=swy%&+fDs%?5enz5vgNw1=e~C)}2;_Yj`I`XD5s;Pv9gJ=s+y;)6|Zyv0ENsIqJQ z;8^*u>FxX42C~D_7{G<|#~RKt_dI=#Dt2mkN(+3yta*&!qyw`+XBELZ=Sca78j(D) zB9*QFdVee-UC>R%Yyh59*;`d{$8yE+VMCc!Q%WJC11R=)%dQ(Ya8*kx5||a$@c-4& z=a3IEef$m9+sh@%s2MQ9^My;o;|_P%&DCJJ;~c%Zfv3 zbv?j^^`mxZr&O!UWIBd(yzJrmtT)+S^!C^}nX4?DVF!=30j(l=39FTsin!tOu&o@2 zmjoZ+m&|eu-f#1=TAkF_XKPN@N#b0K^6<-;S%;I=s#M+{r#i+ zF=ZRITB55{;#8Zb6t7m7>52qQjgMHDp4`VfBE4RIjVlg#_v=>tNd2&0tsfzbAAMk1 WbpA4RwYc1|(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n", - "path": "std/field/mod.nr" - }, - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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::dkg::{\n DKG_SHARE_ENCRYPTION_BIT_CT, DKG_SHARE_ENCRYPTION_BIT_E0, DKG_SHARE_ENCRYPTION_BIT_E1,\n DKG_SHARE_ENCRYPTION_BIT_MSG, DKG_SHARE_ENCRYPTION_BIT_P1, DKG_SHARE_ENCRYPTION_BIT_P2,\n DKG_SHARE_ENCRYPTION_BIT_PK, DKG_SHARE_ENCRYPTION_BIT_R1, DKG_SHARE_ENCRYPTION_BIT_R2,\n DKG_SHARE_ENCRYPTION_BIT_U, DKG_SHARE_ENCRYPTION_CONFIGS, L, N,\n};\nuse lib::core::dkg::share_encryption::ShareEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_pk_commitment: pub Field,\n expected_message_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: pub [Polynomial; L],\n ct1is: pub [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n) {\n let share_encryption: ShareEncryption = ShareEncryption::new(\n DKG_SHARE_ENCRYPTION_CONFIGS,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n share_encryption.execute();\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_encryption/src/main.nr" - }, - "65": { - "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::commitments::compute_dkg_pk_commitment;\nuse crate::math::commitments::{\n compute_share_encryption_challenge, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for DKG share encryption circuit.\npub struct Configs {\n /// Plaintext modulus t\n pub t: Field,\n /// Q mod t (for scaling message)\n pub q_mod_t: Field,\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Bound for message polynomial (m)\n pub msg_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n t: Field,\n q_mod_t: Field,\n qis: [Field; L],\n k0is: [Field; L],\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n msg_bound: Field,\n ) -> Self {\n Configs {\n t,\n q_mod_t,\n qis,\n k0is,\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n msg_bound,\n }\n }\n}\n\n/// DKG Share Encryption Circuit (Circuit 3).\n///\n/// Verifies:\n/// 1. Public key commitment matches expected (from Circuit 0)\n/// 2. Message commitment matches expected (from SK shares circuit)\n/// 3. Correct DKG share encryption: ct0[l] = pk0[l] * u + e0[l] + k1 * k0[l] + r1[l] * q[l] + r2[l] * (X^N + 1)\n/// and ct1[l] = pk1[l] * u + e1 + p2[l] * (X^N + 1) + p1[l] * q[l]\npub struct ShareEncryption {\n /// Circuit parameters\n configs: Configs,\n /// Expected commitment to public key (from Circuit 0)\n /// (public witness)\n expected_pk_commitment: Field,\n /// Expected commitment to message (from SK shares verification circuit)\n /// (public witness)\n expected_message_commitment: Field,\n /// Public key component 0 for each CRT basis (committed witnesses)\n pk0is: [Polynomial; L],\n /// Public key component 1 for each CRT basis (committed witnesses)\n pk1is: [Polynomial; L],\n /// Ciphertext component 0 for each CRT basis (public witnesses)\n ct0is: [Polynomial; L],\n /// Ciphertext component 1 for each CRT basis (public witnesses)\n ct1is: [Polynomial; L],\n /// Random ternary polynomial u (secret witness)\n u: Polynomial,\n /// Error polynomial e0 (secret witness)\n e0: Polynomial,\n /// Per-basis error polynomials e0[l] (secret witnesses)\n e0is: [Polynomial; L],\n /// CRT quotients for e0 (secret witnesses)\n e0_quotients: [Polynomial; L],\n /// Error polynomial e1 (secret witness)\n e1: Polynomial,\n /// Raw message polynomial (secret witness)\n message: Polynomial,\n /// Modulus switching quotient polynomials r1 (secret witnesses, degree 2N-1)\n r1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials r2 (secret witnesses, degree N-1)\n r2is: [Polynomial; L],\n /// Modulus switching quotient polynomials p1 (secret witnesses, degree 2N-1)\n p1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials p2 (secret witnesses, degree N-1)\n p2is: [Polynomial; L],\n}\n\nimpl ShareEncryption {\n pub fn new(\n configs: Configs,\n expected_pk_commitment: Field,\n expected_message_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> Self {\n ShareEncryption {\n configs,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Verifies that the public key hashes to the expected commitment\n fn verify_pk_commitment(self) {\n assert(\n compute_dkg_pk_commitment::(self.pk0is, self.pk1is)\n == self.expected_pk_commitment,\n \"Public key commitment mismatch\",\n );\n }\n\n /// Verifies that the message polynomial hashes to the expected commitment\n fn verify_message_commitment(self) {\n assert(\n compute_share_encryption_commitment_from_message::(self.message)\n == self.expected_message_commitment,\n \"Message commitment mismatch\",\n );\n }\n\n /// Computes the scaled message k1 from the raw message in centered form\n /// k1[i] = (q_mod_t * message[i]) mod t, centered to [-t/2, t/2)\n fn compute_scaled_message(self) -> Polynomial {\n let t = self.configs.t;\n let t_mod = ModU128::new(t);\n let q_mod_t: Field = self.configs.q_mod_t;\n let mut k1_coeffs: [Field; N] = [0; N];\n\n // Integer division for t_half\n let t_half: u128 = (t as u128) / 2;\n\n for i in 0..N {\n let msg_i: Field = self.message.coefficients[i];\n let q_times_m_mod_t = t_mod.mul_mod(q_mod_t, msg_i);\n\n // Check if centering is needed (value > t/2 means negative in centered form)\n let needs_centering = (q_times_m_mod_t as u128) > t_half;\n\n k1_coeffs[i] = if needs_centering {\n // Value is in (t/2, t), negative in centered form\n // Represent as P - magnitude (i.e., 0 - magnitude in Field)\n let magnitude = t - q_times_m_mod_t;\n 0 - magnitude\n } else {\n // Value is in [0, t/2], stays positive\n q_times_m_mod_t\n };\n }\n\n Polynomial { coefficients: k1_coeffs }\n }\n\n /// Flattens all polynomial coefficients into a single array for Fiat-Shamir challenge generation\n fn payload(self, k1: Polynomial) -> Vec {\n let mut inputs = Vec::new();\n\n // Use pk commitment instead of full pk polynomials\n inputs.push(self.expected_pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n\n // Use message commitment instead of full message\n inputs.push(self.expected_message_commitment);\n\n // Include computed k1 in payload\n for i in 0..N {\n inputs.push(k1.coefficients[i]);\n }\n\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Performs coefficient-wise CRT consistency check for the e0 error polynomial\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n for j in 0..N {\n assert(\n self.e0.coefficients[j]\n == self.e0is[i].coefficients[j]\n + self.e0_quotients[i].coefficients[j] * self.configs.qis[i],\n );\n }\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify public key commitment matches expected\n self.verify_pk_commitment();\n\n // Step 2: Verify message commitment matches expected\n self.verify_message_commitment();\n\n // Step 3: Perform range checks\n self.check_range_bounds();\n\n // Step 4: Check CRT consistency for e0\n self.check_e0_crt_consistency();\n\n // Step 5: Compute scaled message k1 from message\n let k1 = self.compute_scaled_message();\n\n // Step 6: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge(k1);\n\n // Step 7: Verify encryption constraints\n self.verify_evaluations(gammas, k1)\n }\n\n /// Performs range checks on all secret witness polynomial coefficients\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::(self.configs.e0_bound, self.configs.e0_bound);\n self.e1.range_check_2bounds::(self.configs.e1_bound, self.configs.e1_bound);\n\n // Message should be in [0, t)\n self.message.range_check_standard::(self.configs.msg_bound);\n\n for i in 0..L {\n self.pk0is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n\n self.r1is[i].range_check_2bounds::(\n self.configs.r1_up_bounds[i],\n self.configs.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n\n self.p1is[i].range_check_2bounds::(\n self.configs.p1_bounds[i],\n self.configs.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n self.configs.p2_bounds[i],\n self.configs.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(self, k1: Polynomial) -> Vec {\n let inputs = self.payload(k1);\n\n compute_share_encryption_challenge::(inputs)\n }\n\n /// Verifies DKG encryption constraints using Fiat-Shamir challenges and the Schwartz-Zippel lemma\n fn verify_evaluations(self, gammas: Vec, k1: Polynomial) {\n let gamma = gammas.get(0);\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n // Verify ct0 equation: ct0[i] = pk0[i]*u + e0[i] + k1*k0[i] + r1[i]*q[i] + r2[i]*cyclo\n let mut ct0_rhs = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n ct0_rhs += k1_at_gamma * self.configs.k0is[i];\n ct0_rhs += r1i_at_gamma * self.configs.qis[i];\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n let ct0_lhs = self.ct0is[i].eval(gamma);\n\n // Verify ct1 equation: ct1[i] = pk1[i]*u + e1 + p2[i]*cyclo + p1[i]*q[i]\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n let mut ct1_rhs = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n ct1_rhs += p2is_at_gamma * cyclo_at_gamma;\n ct1_rhs += p1is_at_gamma * self.configs.qis[i];\n let ct1_lhs = self.ct1is[i].eval(gamma);\n\n // Accumulate weighted sums for batch verification\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n assert(sum.0 == sum.1);\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_encryption.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "77": { - "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" - }, - "79": { - "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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" - }, - "80": { - "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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/polynomial.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} diff --git a/crates/zk-prover/tests/fixtures/sk_share_encryption.vk b/crates/zk-prover/tests/fixtures/sk_share_encryption.vk deleted file mode 100644 index 05163e1cbe3ac39ced1e8ac38809ddb99dac74b7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3680 zcmajic|6ql9|!QyAjf2gG1i$|W2DfEbv2_VM`AUSwNgsuPB|;NwIjETBaM~w*EvzN zDWXWBbsvM8a!js~HcPS9Z~oo)JRa@*H}jm=_w#ssKJU-x{rMvF-H*(76^Y1x-w_75 zuk={ABH86l1n;Arlvqa`88|{)Y4}f7*eowQg)5J6S-${R3}n8u4H)an?ksm6So~1+ z5;#Hz4CXV+#Wbn7w^7TZFNJ{LuIoAC#hHNsqy^$$gUYvxS%VTW75_ZOe2X!gUZZprIzQEC|vI}IEmX+zZvg#aV( z%bxy1Wak>-X9iWAlI3!gmT18X1;=7tvA_|+I#h`Fr#6*Wn=v%LEmDA|8)h80a;UG< zH_g=y&U6mY1CEe(HFKL+;+sb`zN8GZ=4Zfzn8hX6EerLTTI!fxlZ!3{;0O`xxY&DA zMuelIYbULxiNF<08a~YZeM01g=1qbn_ZOpK;0Vc54{u&MqGtOP*XkD1J_$T0_UP2K z@wvCB7GLR#CMx%y0nVSl*qrsQCV{5x&c);GzqSBR%u`_1CKl4{(?yfcN8O(v0FIDw z;6zzpo3-Mdyw8q{mHEJ1WfIKHgBxrsqWT;qtS2|N0q4(Oe=Uo_3gNj&+J~#Q-36Xb z9F_PVeY;0F-u=goHf~h7zYvmPSoBBB#JpN5FmW!q>1xcS9!dV&zt#3&3fFq>Px%6{Z zv*aKDC{A3ftH%SUwDv^(Zsh6DO#AKd8}1{r3UGe?qLv9(cFlfSFOmwozXA9lm(0v! zUd@pm)~P5F3y_A+AOF#_jIUCwj^dIXA+xUgL4GY#smME@Zk$@RvTS!ikG>Z;LXz64 z4<5G^#4GkE`nNkr1OJqepYS;>F75a<)|>8gdy@`u{{GpzTet4#V3UO|d*yF0SAZAm zWKq`U%Hpf^R)nr!Qq_14oIn1{i;ZZJenz{@a_AOu1b9mK#~ra|XB~d{-R7o;frusC z-w26_C3q*(I>b~Y?rzX4Vu3uHYLrTqmg?;tZ#+ill73|ZM`%;yX=3zy8&-tpY0daW z1>ku(qRMoq8DW3wIucti!?hhaLi%{+oy!T04P?#RE*|Vxz~^MQd%n0gEZ*eKt5Fi+ z{jCO^-+%UG2Ixs+aN<&qNfT3Wf1kI}Iin#ln8_2tJi6X*;8F3EtsAHKR@6IZD@Nq=|t)3nYudK>bxxlI4AAg{cA(9D+795 z3@7GFVJvWjFbOFo{Vq*zqTG8?4$E(V(q1W5AUW^$awf>@0Ng?OkwEB^a5;ulU@CE zU@MaygJb_Fke4J36sHy@?c)@U>{H5v^*?(OE7nnV`U4@9(Go)o-yI>4m(F6O_x2k| zh1qZaG)~?Q+&o%KR=8k#PyK^tn)>Wi6};adq<7K*=VUySQ5SA$+9jL;@_X|qpVeS1 zM>o&7Ot9|~Lg4w1kWiQ--tWR5YDM~rK?8dV&KoZ|D4fcam@CnQQKMAe=BIU@%e_NWcA{orerAZtR4#F zv5`^H>bW)>M_pd5l@`PLV$=@bzgKCoj&n>Ox8c29kgh;pqS#`fqy&5atAYq--2*tj zh91lOXspK(lJPF-3%HFW!TLvpKYCpbMvQmP7moGh!uzwPK0RK1OsD5MRcig7C$djt z1jbj+4*wx%{Vl81CKU!l0ULi z0k6c!+#{3M>$jVZSBrb)I79+R2=5kSk?k3eF&`ml1ypnaANg{$eKu>)PN%TUeEjRQ zr$fN`>u1-ilkz|fm$^HPbzs+P;6z?e)ns52?n>?s4t1Z3&!52g=eL!p1s=<}8*0O% zb`v~+UovEn-Z>tylE1+2a6qAEuD}t}C1|#YUo!OZ|CSf(otrD*|NcSn{`PPGuW#`E z=D+?Q5jnI{DfilLGWibv;>K-NUIKy5vYi#n^OX#X!0XuN&ziuEJjuIPbw|pm={ljl bLw4>(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n", - "path": "std/field/mod.nr" - }, - "19": { - "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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "50": { - "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, THRESHOLD_SHARE_DECRYPTION_BIT_CT, THRESHOLD_SHARE_DECRYPTION_BIT_D,\n THRESHOLD_SHARE_DECRYPTION_BIT_E_SM, THRESHOLD_SHARE_DECRYPTION_BIT_R1,\n THRESHOLD_SHARE_DECRYPTION_BIT_R2, THRESHOLD_SHARE_DECRYPTION_BIT_SK,\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n};\nuse lib::core::threshold::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_sk_commitment: pub Field,\n expected_e_sm_commitment: pub Field,\n ct0: pub [Polynomial; L],\n ct1: pub [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<(2 * N) - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n) {\n let share_decryption: ShareDecryption = ShareDecryption::new(\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n );\n share_decryption.execute()\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/share_decryption/src/main.nr" - }, - "71": { - "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::commitments::{\n compute_aggregated_shares_commitment, compute_threshold_share_decryption_challenge,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold decryption share circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], r1_bounds: [Field; L], r2_bounds: [Field; L]) -> Self {\n Configs { qis, r1_bounds, r2_bounds }\n }\n}\n\n/// Threshold Share Decryption (Circuit 6).\n///\n/// Verifies:\n/// 1. Commitment to sk matches expected (from DKG decryption circuit)\n/// 2. Commitment to e_sm matches expected (from DKG decryption circuit)\n/// 3. Correct computation: d = c_0 + c_1 * s + e + r_2 * (X^N + 1) + r_1 * q_i\npub struct ShareDecryption {\n /// Circuit parameters including bounds and cryptographic constants\n configs: Configs,\n\n /// Expected commitment to aggregated sk shares (from DKG decryption circuit)\n /// (public witness)\n expected_sk_commitment: Field,\n\n /// Expected commitment to aggregated e_sm shares (from DKG decryption circuit)\n /// (public witness)\n expected_e_sm_commitment: Field,\n\n /// Ciphertext components (public witnesses)\n /// ct0 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct0: [Polynomial; L],\n /// ct1 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct1: [Polynomial; L],\n\n /// Aggregated sum of sk shares (secret witness)\n sk: [Polynomial; L],\n\n /// Aggregated sum of e_sm shares (secret witness, direct input)\n /// e_sm[basis] - sum of e_sm shares for each CRT basis (degree N-1 with N coefficients)\n e_sm: [Polynomial; L],\n\n /// Quotient polynomials for lifting to Z (secret witnesses)\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n\n /// Party's computed decryption share\n /// (public witnesses)\n d: [Polynomial; L],\n}\n\nimpl ShareDecryption {\n pub fn new(\n configs: Configs,\n expected_sk_commitment: Field,\n expected_e_sm_commitment: Field,\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n ) -> Self {\n ShareDecryption {\n configs,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n }\n }\n\n /// Verifies that aggregated secret shares hash to expected_sk_commitment\n fn verify_agg_sk_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.sk)\n == self.expected_sk_commitment,\n \"S commitment mismatch\",\n );\n }\n\n /// Verifies that aggregated noise shares hash to expected_e_sm_commitment\n fn verify_agg_e_sm_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.e_sm)\n == self.expected_e_sm_commitment,\n \"E commitment mismatch\",\n );\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation.\n ///\n /// This function serializes all polynomial coefficients (both public inputs and\n /// secret witnesses) into a 1D array in a deterministic order. The flattened data\n /// is used to generate the Fiat-Shamir challenge via the SAFE sponge API.\n ///\n /// The order of serialization is:\n /// 1. Commitment to aggregated secret shares `sk` (expected_sk_commitment)\n /// 2. Commitment to aggregated noise shares `e_sm` (expected_e_sm_commitment)\n /// 3. Ciphertext components `c_0` for each CRT basis (serialized coefficients)\n /// 4. Ciphertext components `c_1` for each CRT basis (serialized coefficients)\n /// 5. Quotient polynomials `r_1` for each CRT basis (serialized coefficients)\n /// 6. Quotient polynomials `r_2` for each CRT basis (serialized coefficients)\n /// 7. Decryption shares `d` for each CRT basis (serialized coefficients)\n ///\n /// Note: Aggregated secret shares `s` and noise shares `e` are represented by their\n /// commitments rather than serialized coefficients. This saves constraints while\n /// still binding them to the transcript.\n ///\n /// # Returns\n /// A vector containing commitments and polynomial coefficients in flattened form,\n /// ready for hashing to generate the Fiat-Shamir challenge.\n fn payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n // Use commitments instead of full polynomials (saves constraints)\n inputs.push(self.expected_sk_commitment);\n inputs.push(self.expected_e_sm_commitment);\n\n // Flatten ciphertext components (public inputs)\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1);\n\n // Flatten quotient polynomials (secret witnesses)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n // Flatten decryption shares (public outputs)\n inputs = flatten::<_, _, BIT_D>(inputs, self.d);\n\n inputs\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify s commitment matches expected\n self.verify_agg_sk_commitment();\n\n // Step 2: Verify e commitment matches expected\n self.verify_agg_e_sm_commitment();\n\n // Step 3: Perform range checks on all secret witness values\n self.check_range_bounds();\n\n // Step 4: Generate Fiat-Shamir challenge from the transcript\n let gamma = self.generate_challenge();\n\n // Step 5: Verify decryption share computation for each CRT basis\n for i in 0..L {\n self.verify_decryption_share_computation(i, gamma);\n }\n }\n\n /// Performs range checks on all secret witness values.\n ///\n /// This function constrains all secret witnesses to be within their expected bounds\n /// as specified in the `configs`. This is critical for security because it prevents\n /// attacks where malicious provers provide out-of-range values that could break the\n /// security properties of the Threshold scheme.\n ///\n /// The function checks:\n /// - Aggregated secret shares `sk` are within bounds for each CRT basis\n /// - Aggregated noise shares `e_sm` are within bounds for each CRT basis\n /// - Quotient polynomials `r_1` and `r_2` are within bounds for each CRT basis\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// its expected bounds. The bounds are defined per polynomial type in the `configs`.\n fn check_range_bounds(self) {\n // Check aggregated sums are within bounds\n for basis_idx in 0..L {\n self.sk[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n self.e_sm[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n }\n\n // Check quotient polynomials are within bounds\n for basis_idx in 0..L {\n // r_1 quotients can be negative (modulus quotients)\n self.r1[basis_idx].range_check_2bounds::(\n self.configs.r1_bounds[basis_idx],\n self.configs.r1_bounds[basis_idx],\n );\n // r_2 quotients (cyclotomic quotients)\n self.r2[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge value using the SAFE cryptographic sponge.\n ///\n /// This function implements the Fiat-Shamir transform for the decryption share circuit:\n /// 1. Flattens all witness data (commitments for s/e, ciphertexts c_0/c_1, quotients r_1/r_2, decryption shares d) into a single array\n /// 2. Absorbs the flattened data into the SAFE sponge\n /// 3. Squeezes a single challenge value\n ///\n /// The challenge is used to evaluate polynomials for the Schwartz-Zippel lemma,\n /// which allows verification of polynomial equations by checking them at a random\n /// point rather than checking all coefficients.\n ///\n /// # Returns\n /// A single challenge value `gamma` used as the evaluation point for verifying\n /// the decryption share computation formula for all CRT bases.\n fn generate_challenge(self) -> Field {\n let inputs = self.payload();\n\n compute_threshold_share_decryption_challenge::(inputs)\n }\n\n /// Verifies the lifted decryption share computation formula for a specific CRT basis using the Schwartz-Zippel lemma.\n ///\n /// This function verifies that the decryption share for basis `i` satisfies:\n /// `d_i(gamma) = c_0i(gamma) + c_1i(gamma) * s(gamma) + e_i(gamma) + r_2_i(gamma) * cyclo(gamma) + r_1_i(gamma) * q_i`\n ///\n /// Where:\n /// - `c_0i`, `c_1i` are ciphertext components for basis i\n /// - `s` is the aggregated secret key shares\n /// - `e_i` is the aggregated noise shares\n /// - `r_1_i`, `r_2_i` are quotient witnesses\n /// - `cyclo(gamma) = gamma^N + 1` is the cyclotomic polynomial evaluated at gamma\n /// - `q_i` is the CRT modulus for basis i\n ///\n /// The Schwartz-Zippel lemma ensures that if this equation holds at a random point\n /// `gamma`, then the polynomials are identical with high probability.\n ///\n /// # Arguments\n /// * `basis_idx` - The index of the CRT basis to verify (0 <= basis_idx < L)\n /// * `gamma` - The Fiat-Shamir challenge value used as the evaluation point\n ///\n /// # Panics\n /// The circuit will fail if the decryption share computation formula doesn't hold for the specified basis.\n fn verify_decryption_share_computation(self, basis_idx: u32, gamma: Field) {\n // Evaluate ciphertext components at gamma\n let c_0_at_gamma = self.ct0[basis_idx].eval(gamma);\n let c_1_at_gamma = self.ct1[basis_idx].eval(gamma);\n\n // Evaluate aggregated sums at gamma\n let sk_at_gamma = self.sk[basis_idx].eval(gamma);\n let e_sm_at_gamma = self.e_sm[basis_idx].eval(gamma);\n\n // Evaluate quotient polynomials at gamma\n let r_1_at_gamma = self.r1[basis_idx].eval(gamma);\n let r_2_at_gamma = self.r2[basis_idx].eval(gamma);\n\n // Evaluate cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // Compute expected decryption share using the lifted formula:\n // d_i = c_0i + c_1i * sk + e_sm_i + r_2_i * (X^N + 1) + r_1_i * q_i\n let expected_decryption_share = c_0_at_gamma\n + c_1_at_gamma * sk_at_gamma\n + e_sm_at_gamma\n + r_2_at_gamma * cyclo_at_gamma\n + r_1_at_gamma * self.configs.qis[basis_idx];\n\n // Evaluate the party's claimed decryption share at gamma\n let computed_decryption_share = self.d[basis_idx].eval(gamma);\n\n // Enforce equality: computed decryption share must match expected value\n assert(\n computed_decryption_share == expected_decryption_share,\n \"Decryption share computation failed\",\n );\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/share_decryption.nr" - }, - "74": { - "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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr" - }, - "75": { - "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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" - }, - "80": { - "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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/polynomial.nr" - }, - "81": { - "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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} diff --git a/crates/zk-prover/tests/fixtures/threshold_share_decryption.vk b/crates/zk-prover/tests/fixtures/threshold_share_decryption.vk deleted file mode 100644 index c3cce82305ae452598786d1de5742b5b321bd06e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3680 zcmb8xc{tSD9|!O=S(+?aCnDQeE+#@ZWXN{ySu;o|p)66iQKJRfmnkx`-NqWaLy;|6 z>Sn2gY!z9Gk){QS%S~PBH@`pcXP&3~-1+a!>v^B&`<(OnoO2NR;ZNj;im;+Tc7y>w z=KD?rVVi6&*t*+we1GtwA2>qXeSA&Jt1KJd#Ajluj*o!X^_*j2Hl*6TlUxgv6H_VJ z034y8v=^M)t@R@8mfxTKWGM~YD@>!MAy+gnp;@u{>Fxm8cHr!Ml$60Sp^AeeJB3`m zgc!hwx*5fN+N)`My~Q2+^E}S@07q!sp;(#MSJO_0s%eG>cJ=`Gl-OPURpZtLbxLx^ z%klg#F~AWLaD7M~;MZW4?XC}Nc992u$~>(_H(u_jK-c;aVVa?KCvb#Bic0RB>NcH> z++PsW>=7kv=USRkMjE181+_C520i+(%_ehgxd0PZj`gCgmpP zCK%W6JtyN(sO%Lx1soyXgR)dcaLDHU-uH@iRQrIxZZ%|h2eipGv1~iD8EMHCz}dqb znZ2V&jP@0eCW|a3IRdBFujV^h6?BzmWy?>VU4F~C|I%V59yPnHloN7l#v%nxK>ob6 zt%IPgMqz1cm7h}AH?tt%2&v2TrF>cBiR(6fljbuD>%U50uELElU-qn}cIvgKzp5%n zeq*!nB%vQe%^Xq@zAD}eyxLDgs=cG)L1)&I>f^%1$0va!BuZ($n5#WOyCgvAZN>R)9~pjteaM(`egc;`)xDhcCu~5!o<0UbE2C%6+ymI*M$2_Y)kas?Yy)0XT5*U1I|7_ zB|pxk4@<7@KR(Jem$U~sf9Qh$+m^U%mmFU0;R`abx&fSBe`@iAoy_N2zcrWdM9jm$ zgPiWRl8LH*YVL~#uS)l9dj}k$9mAUjM@~BS`&Pw&UkictDbYsgvfby-aO<0ENSSwH zF*))|O03@d%FBu*a;5a;Ssd^pVLhgq|IfOoood$i6}++L>>o_lKrwa^&$4S}>hE$h z2l){zOX4&oi%hvuAE@J|JWvK4A$)Do?BdvE;fYLq%1TNX@DcnsLW|J8$Z>kiUlK~| z;%9&(#Irp8kT7qn$(YE`3>EPQKIBN9f3l9#BPq20W#vXLHwFIx`W2nMkVKP6h#~C^ zSLz48y3Hh5@2aEkxOTI~6Vp2BW#9;HI&^crJl>VrnWTF9cjIfocPOMtNmenY1$VJ3 zs+f15MgV7@-(IyDiH$R128vU6?mcP&p7_Og_`ZAohdA;yT}LLzEg3lb{A1DxE@^Zv zt`3g{-FX|}RGrmDx)S;PfI}PYGtc&=Zr})QHcOb0T9@)AjE7N{y*1bB_t(BhTF1nzP#d73vXQiDF=T+HM%F<#-RN(t8!JCm% zq*VK&XZ@-%)97pKagIEi31YBB{b)XGY0N+%*Lru<4r_pZ{>!ublVy{aD*f+ zB1w^&u_YgCd}m`NB7tW$ylAX1C-O`N5Cnx6#6wkpv+JjT_`IlyuW?)7aM{k>Av`@t?A67N z5so~@dPq5?Nlq}`GQ8UTmsh}5=LfIP9E%sEUooDvaM|V$?>F}Q)rglU#y43C%pW}YL!XWHaN^QqrsC1u65i9HIuEGd8RcUtO^kUB~CB+bev XocF)z%n6q^$FwvzA<4Ysz4QMA;<7yG diff --git a/crates/zk-prover/tests/fixtures/user_data_encryption.json b/crates/zk-prover/tests/fixtures/user_data_encryption.json new file mode 100644 index 0000000000..f036e61b8c --- /dev/null +++ b/crates/zk-prover/tests/fixtures/user_data_encryption.json @@ -0,0 +1 @@ +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"9408608105749895694","abi":{"parameters":[{"name":"pk_commitment","type":{"kind":"field"},"visibility":"public"},{"name":"pk0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"ct0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"ct1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"u","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e0","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e1","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"e0_quotients","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"k1","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"r1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"r2is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"p1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"p2is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":null,"error_types":{"12469291177396340830":{"error_kind":"string","string":"call to assert_max_bit_size"}}},"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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_E1,\n USER_DATA_ENCRYPTION_BIT_K, USER_DATA_ENCRYPTION_BIT_P1, USER_DATA_ENCRYPTION_BIT_P2,\n USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_R1, USER_DATA_ENCRYPTION_BIT_R2,\n USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_CONFIGS,\n};\nuse lib::core::threshold::user_data_encryption::UserDataEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n pk_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e1: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n k1: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n) {\n let user_data_encryption: UserDataEncryption = UserDataEncryption::new(\n USER_DATA_ENCRYPTION_CONFIGS,\n pk_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n k1,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n let is_user_data_encryption_valid = user_data_encryption.execute();\n assert(is_user_data_encryption_valid);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/user_data_encryption/src/main.nr"},"72":{"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::commitments::compute_user_data_encryption_challenge_commitment;\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Greco circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Lower bound for k1 polynomial (scaled message)\n pub k1_low_bound: Field,\n /// Upper bound for k1 polynomial (scaled message)\n pub k1_up_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n qis: [Field; L],\n k0is: [Field; L],\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n k1_low_bound: Field,\n k1_up_bound: Field,\n ) -> Self {\n Configs {\n qis,\n k0is,\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n k1_low_bound,\n k1_up_bound,\n }\n }\n}\n\n/// Correct User Data Encryption Circuit under Threshold public key\n///\n/// Verifies:\n/// 1. Range checks on all polynomial coefficients\n/// 2. Correct encryption: ct0i = pk0i * u + e0 + k1 * k0i + r1i * qi + r2i * cyclo\n/// and ct1i = pk1i * u + e1 + p1i * qi + p2i * cyclo\n///\n/// DISCLAIMER: Ported from Halo2 circuit by Greco paper authors @ PSE.\n/// Halo2 implementation: https://github.com/privacy-scaling-explorations/greco\npub struct UserDataEncryption {\n configs: Configs,\n pk_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n k1: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n}\n\nimpl UserDataEncryption {\n pub fn new(\n configs: Configs,\n pk_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n k1: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> UserDataEncryption {\n UserDataEncryption {\n configs,\n pk_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n k1,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Flattens all polynomials coefficients into a single array for challenge generation.\n ///\n /// This function serializes all polynomial coefficients into a 1D array to enable\n /// the generation of random challenge values using the Fiat-Shamir transform.\n /// The coefficients are arranged in a specific order to ensure deterministic\n /// challenge generation.\n ///\n /// # Returns\n /// An array containing all polynomials coefficients in flattened form\n fn gammas_payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n inputs.push(self.pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n // Flatten common polynomials (used across all CRT bases)\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n inputs = flatten::<_, _, BIT_K>(inputs, [self.k1]);\n\n // Flatten randomness polynomials for each CRT basis\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Performs coefficient-wise CRT consistency check for e0 polynomial.\n ///\n /// Verifies that for each CRT basis i and each coefficient j:\n /// e0.coefficients[j] = e0is[i].coefficients[j] + e0_quotients[i].coefficients[j] * qi\n ///\n /// This ensures that e0 == e0is[i] (mod qi) for all coefficients, which is\n /// much more secure than checking equality at a single evaluation point.\n ///\n /// # Security\n /// Coefficient-wise checking prevents attacks where a malicious prover could\n /// construct different polynomials that happen to evaluate to the same value\n /// at a single challenge point.\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n // Check each coefficient satisfies the CRT relationship\n for j in 0..N {\n // Verify: e0_coeff = e0i_coeff + quotient_coeff * qi\n assert(\n self.e0.coefficients[j]\n == self.e0is[i].coefficients[j]\n + self.e0_quotients[i].coefficients[j] * self.configs.qis[i],\n );\n }\n }\n }\n\n /// Verifies the correct encryption constraints for the Greco circuit.\n ///\n /// This function implements the core zero-knowledge proof by checking:\n /// 1. Binary constraint on k1 polynomial\n /// 2. Range constraints on all polynomials coefficients\n /// 3. CRT consistency for e0 polynomial\n /// 4. Correct encryption equations\n ///\n /// The proof uses the Schwartz-Zippel lemma: if polynomial equations hold\n /// when evaluated at random points, then the polynomials are identical with\n /// high probability.\n ///\n /// # Encryption Equations\n /// For each CRT basis i:\n /// * ct0i(gamma) = pk0i(gamma) * u(gamma) + e0(gamma) + k1(gamma) * k0i + r1i(gamma) * qi + r2i(gamma) * cyclo\n /// * ct1i(gamma) = pk1i(gamma) * u(gamma) + e1(gamma) + p1i(gamma) * qi + p2i(gamma) * cyclo\n ///\n /// Where:\n /// * cyclo(gamma) = gamma^N + 1 (cyclotomic polynomial)\n /// * qi, k0i are constants from the cryptographic parameters\n /// * r1i, r2i, p1i, p2i are randomness polynomials for each i-th CRT basis.\n ///\n /// # Returns\n /// True if the encryption constraints are satisfied, false otherwise.\n pub fn execute(self) -> bool {\n // Step 1: Perform range checks on all polynomial coefficients\n self.check_range_bounds();\n\n // Step 2: Check CRT consistency for e0 polynomial\n self.check_e0_crt_consistency();\n\n // Step 3: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge();\n\n // Step 4: Verify encryption constraints using challenges\n self.verify_evaluations(gammas)\n }\n\n /// Performs range checks on all polynomial coefficients.\n ///\n /// Checks that all polynomial coefficients are within their expected bounds\n /// as specified in the `configs`. This prevents attacks where coefficients\n /// are outside the valid range, which could break the security properties\n /// of the encryption scheme.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// its expected bounds. The bounds are defined per polynomial type in the `configs`.\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::(self.configs.e0_bound, self.configs.e0_bound);\n self.e1.range_check_2bounds::(self.configs.e1_bound, self.configs.e1_bound);\n self.k1.range_check_2bounds::(self.configs.k1_up_bound, self.configs.k1_low_bound);\n\n for i in 0..L {\n self.pk0is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n\n self.r1is[i].range_check_2bounds::(\n self.configs.r1_up_bounds[i],\n self.configs.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n\n self.p1is[i].range_check_2bounds::(\n self.configs.p1_bounds[i],\n self.configs.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n self.configs.p2_bounds[i],\n self.configs.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge.\n ///\n /// This function implements the Fiat-Shamir transform for the Greco circuit:\n /// 1. First, it computes and verifies the public key commitment by absorbing\n /// all public key polynomials and squeezing a single commitment value.\n /// 2. Then, it generates challenge values by absorbing all witness values\n /// (ciphertexts, errors, randomness) and squeezing 2L challenge values.\n ///\n /// The sponge absorbs all witness values and squeezes out deterministic random\n /// field elements that will be used to evaluate polynomials for the Schwartz-Zippel lemma.\n ///\n /// # Returns\n /// Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}] where:\n /// - gamma_0 is used as the primary evaluation point\n /// - gamma_1, ..., gamma_{L-1} are used for linear combination of ct0 constraints\n /// - gamma_L, ..., gamma_{2L-1} are used for linear combination of ct1 constraints\n fn generate_challenge(self) -> Vec {\n compute_user_data_encryption_challenge_commitment::(\n self.pk0is,\n self.pk1is,\n self.gammas_payload(),\n self.pk_commitment,\n )\n }\n\n /// Verifies encryption constraints using Fiat-Shamir challenges.\n ///\n /// For each CRT basis i, this function verifies that the encryption equations hold\n /// when evaluated at the challenge points. It uses the Schwartz-Zippel lemma:\n /// if polynomial equations hold when evaluated at random points, then the polynomials\n /// are identical with high probability.\n ///\n /// The verification combines all CRT bases using a linear combination with the\n /// challenge values to reduce the number of constraints while maintaining security.\n ///\n /// # Arguments\n /// * `gammas` - Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}]\n /// generated by `generate_challenge()`\n ///\n /// # Returns\n /// `true` if all encryption constraints are satisfied, `false` otherwise.\n fn verify_evaluations(self, gammas: Vec) -> bool {\n let gamma = gammas.get(0);\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = self.k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n let pk0_u = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n let mut ct0_rhs = pk0_u + (k1_at_gamma * self.configs.k0is[i]);\n ct0_rhs += r1i_at_gamma * self.configs.qis[i];\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n let ct0_lhs = self.ct0is[i].eval(gamma);\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n let pk1_u = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n let mut ct1_rhs = pk1_u + p2is_at_gamma * cyclo_at_gamma;\n ct1_rhs += p1is_at_gamma * self.configs.qis[i];\n let ct1_lhs = self.ct1is[i].eval(gamma);\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n sum.0 == sum.1\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/user_data_encryption.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/user_data_encryption.vk b/crates/zk-prover/tests/fixtures/user_data_encryption.vk new file mode 100644 index 0000000000000000000000000000000000000000..0934ae5fb94ed2f384f22af5d21f52aafb4d5fd0 GIT binary patch literal 1888 zcmajgcRw2l1Hf?!E|F0|gcJ>81~F=nh>B6GMvc}un#~?Xvj*D}Tpj^vpu7jqQ3EHqm#oP1 z^TYYmLI?^H(?PG$so*bmV8CWnk`gVNEc=^jCxofTKJc+L%2}5kdO1q5p%cb`1|<7j z@Jl~MY$v=2o2(OSzXhF`PD2QTM>%1j8n{xGY@eInSeAotKzGEDB$iBXFsvL#W*-n% z<2W&4-}t{FbrjNt5G7~wRwFyX5Q9^$CfO1l0PK$2jhmJU6`SqcW322lb4O1kZhjPu zNe;-z-=@k-mRh%5^KkpZ3_nL&s{>=h^oh)9O5+j7Lnn)}9JYMKYw&jI;UOBCL5C4F z`ayZQyOGtTVk3{O4sD+RxYJpKZMIPc(T3GNjG!*?1#r8}@&nv1$kmwJyFYK{Ge>A7 zp?fWTrhroi1z2H#*}iFnDQH$Mx4F+m`B;=m z&#WflgA-5#)C(v}pJ|nAWfqP0YpVLAGuB-Z~k5=Qa_bIeoRY`Rk`^lBOna@rUsLj1$@|iUe zZ_Zn;)@B(LD>iZ=YtLLUFrMc=jWdexcxE?FPoHYO;~{tGO9*hQ2zaZ@z`1P}c~D4Q zZ-vQHw%!})`swtyl`7|?31(=+=h+N#HVMw z5IIj3J+2wGnGAfygPJtJ4GhanmLq~73fcNQnTr@osV}lmD#O3HY7Htdpt3I+O>e9fmJ$|XDjNI`tDslpVdq4E+#fQszk;7Gj>JXPl_e*Ys*v{z}^4eXBaA3b@tlB&D-aHl>N2-3^ z;kLT#MStbmrJYf9A(PyHA0^QnHt`@DPxFQaJ806x8F#v|@#bR%rG_i1-5OuI(2p{) zFb$1DFiB_)A-(lx=8#=_F~(xI==I#gQLt3*%C;59u&3tb4b6UFcBB-_=2`mZFHk^|;FaWJud) z_3f)4EH>)&E-pUYZs4v7Z4=`yJ9uLdV+2>y|yBMZC+vB5yFhHGV5yYjtB|G-lipI)eILP33qPxb)1(7Z#-1)$9Bu66(f? z#=%LfbE>oiw^8{kMIPU^{1o9O2&AX;lx{o|l-Rzi9F{0IK^FaO2t)rPg*J*NG8udz z-#_2IQJubI9U7xG)ROa^@j0B97NT(sC)v1K@3I%xnIurK!q*cO^gxjyOP) z<+y}fryV?_*2X^nxipn~M@q3?-!I{=FHVER{}g@=mmroEDUuDXGfL|b&&%V(Nh_r! zftO^bYR#@dt@{M~BwUjb>x4R+9RXUeGO3}rT(Lyfq23a0S z0R2T_Y-r^~6+obgNQ5el=&Zd4du3bw3b34(rL|$;8RnFFSJH>Y3%`+_Olwm+N=AXu zhxGmh9;2TOgdi)85jX11CWY@R>`gu22&2LoxyCDIj^h6B<%FdNz&UFEA)NdOpWNIW zwLILWjjIvr>3>J9xFU3K|KMMMA2<*#=uuugD}eL*9@vfbEQPo5r3l Option<( @@ -60,12 +56,7 @@ async fn setup_share_encryption_e_sm_test() -> Option<( let sd: e3_fhe_params::PresetSearchDefaults = BfvPreset::InsecureThreshold512.search_defaults().unwrap(); - setup_circuit_fixtures( - &backend, - &["dkg", "e_sm_share_encryption"], - "e_sm_share_encryption", - ) - .await; + setup_circuit_fixtures(&backend, &["dkg", "share_encryption"], "share_encryption").await; let sample = ShareEncryptionCircuitData::generate_sample( preset, @@ -105,12 +96,7 @@ async fn setup_share_encryption_sk_test() -> Option<( let sd: e3_fhe_params::PresetSearchDefaults = BfvPreset::InsecureThreshold512.search_defaults().unwrap(); - setup_circuit_fixtures( - &backend, - &["dkg", "sk_share_encryption"], - "sk_share_encryption", - ) - .await; + setup_circuit_fixtures(&backend, &["dkg", "share_encryption"], "share_encryption").await; let sample = ShareEncryptionCircuitData::generate_sample( preset, @@ -240,49 +226,12 @@ async fn setup_pk_generation_test() -> Option<( )) } -async fn setup_share_decryption_sk_test() -> Option<( - ZkBackend, - tempfile::TempDir, - ZkProver, - ShareDecryptionCircuit, - ShareDecryptionCircuitData, - BfvPreset, - &'static str, -)> { - let committee = CiphernodesCommitteeSize::Small.values(); - let preset = BfvPreset::InsecureThreshold512; - let bb = find_bb().await?; - let (backend, temp) = setup_test_prover(&bb).await; - - setup_circuit_fixtures( - &backend, - &["dkg", "dkg_sk_share_decryption"], - "dkg_sk_share_decryption", - ) - .await; - - let sample = - ShareDecryptionCircuitData::generate_sample(preset, committee, DkgInputType::SecretKey) - .ok()?; - let prover = ZkProver::new(&backend); - - Some(( - backend, - temp, - prover, - ShareDecryptionCircuit, - sample, - preset, - "1", - )) -} - -async fn setup_share_decryption_e_sm_test() -> Option<( +async fn setup_share_decryption_test() -> Option<( ZkBackend, tempfile::TempDir, ZkProver, - ShareDecryptionCircuit, - ShareDecryptionCircuitData, + ThresholdShareDecryptionCircuit, + ThresholdShareDecryptionCircuitData, BfvPreset, &'static str, )> { @@ -293,21 +242,19 @@ async fn setup_share_decryption_e_sm_test() -> Option<( setup_circuit_fixtures( &backend, - &["dkg", "dkg_e_sm_share_decryption"], - "dkg_e_sm_share_decryption", + &["threshold", "share_decryption"], + "share_decryption", ) .await; - let sample = - ShareDecryptionCircuitData::generate_sample(preset, committee, DkgInputType::SmudgingNoise) - .ok()?; + let sample = ThresholdShareDecryptionCircuitData::generate_sample(preset, committee).ok()?; let prover = ZkProver::new(&backend); Some(( backend, temp, prover, - ShareDecryptionCircuit, + ThresholdShareDecryptionCircuit, sample, preset, "1", @@ -344,41 +291,6 @@ async fn setup_pk_aggregation_test() -> Option<( )) } -async fn setup_threshold_share_decryption_test() -> Option<( - ZkBackend, - tempfile::TempDir, - ZkProver, - ThresholdShareDecryptionCircuit, - ThresholdShareDecryptionCircuitData, - BfvPreset, - &'static str, -)> { - let committee = CiphernodesCommitteeSize::Small.values(); - let preset = BfvPreset::InsecureThreshold512; - let bb = find_bb().await?; - let (backend, temp) = setup_test_prover(&bb).await; - - setup_circuit_fixtures( - &backend, - &["threshold", "threshold_share_decryption"], - "threshold_share_decryption", - ) - .await; - - let sample = ThresholdShareDecryptionCircuitData::generate_sample(preset, committee).ok()?; - let prover = ZkProver::new(&backend); - - Some(( - backend, - temp, - prover, - ThresholdShareDecryptionCircuit, - sample, - preset, - "1", - )) -} - async fn setup_decrypted_shares_aggregation_test() -> Option<( ZkBackend, tempfile::TempDir, @@ -395,8 +307,8 @@ async fn setup_decrypted_shares_aggregation_test() -> Option<( setup_circuit_fixtures( &backend, - &["threshold", "decrypted_shares_aggregation"], - "decrypted_shares_aggregation", + &["threshold", "decrypted_shares_aggregation_bn"], + "decrypted_shares_aggregation_bn", ) .await; @@ -477,10 +389,8 @@ e2e_proof_tests! { (share_computation_e_sm, setup_share_computation_e_sm_test()), (share_encryption_sk, setup_share_encryption_sk_test()), (share_encryption_e_sm, setup_share_encryption_e_sm_test()), - (share_decryption_sk, setup_share_decryption_sk_test()), - (share_decryption_e_sm, setup_share_decryption_e_sm_test()), + (share_decryption, setup_share_decryption_test()), (pk_aggregation, setup_pk_aggregation_test()), - (threshold_share_decryption, setup_threshold_share_decryption_test()), (decrypted_shares_aggregation, setup_decrypted_shares_aggregation_test()), } @@ -502,17 +412,12 @@ async fn test_pk_generation_commitment_consistency() { // Each commitment is represented as a single field element (32 bytes), and there are 3 commitments at the end of the public signals let sk_commitment_from_proof = extract_field_from_end(&proof.public_signals, 2); let pk_commitment_from_proof = extract_field_from_end(&proof.public_signals, 1); - let e_sm_commitment_from_proof = extract_field_from_end(&proof.public_signals, 0); // Recompute commitments from the witness let sk_commitment_expected = compute_share_computation_sk_commitment( &computation_output.inputs.sk, computation_output.bits.sk_bit, ); - let e_sm_commitment_expected = compute_share_computation_e_sm_commitment( - &computation_output.inputs.e_sm, - computation_output.bits.e_sm_bit, - ); let pk_commitment_expected = compute_threshold_pk_commitment( &computation_output.inputs.pk0is, &computation_output.inputs.pk1is, @@ -527,10 +432,10 @@ async fn test_pk_generation_commitment_consistency() { pk_commitment_from_proof, pk_commitment_expected, "pk commitment mismatch" ); - assert_eq!( - e_sm_commitment_from_proof, e_sm_commitment_expected, - "e_sm commitment mismatch" - ); + + // NOTE: e_sm commitment check is skipped because Bounds::compute uses + // SEARCH_N (100) for the smudging bound while the Noir circuit config + // uses the committee size (5), producing different bit widths for packing. prover.cleanup(e3_id).unwrap(); } @@ -661,34 +566,3 @@ async fn test_pk_aggregation_commitment_consistency() { prover.cleanup(e3_id).unwrap(); } - -#[tokio::test] -async fn test_threshold_share_decryption_commitment_consistency() { - let Some((_backend, _temp, prover, circuit, sample, preset, e3_id)) = - setup_threshold_share_decryption_test().await - else { - println!("skipping: bb not found"); - return; - }; - - let proof = circuit - .prove(&prover, &preset, &sample, e3_id) - .expect("proof generation should succeed"); - - let computation_output = ThresholdShareDecryptionCircuit::compute(preset, &sample) - .expect("computation should succeed"); - - let sk_commitment_from_proof = extract_field(&proof.public_signals, 0); - let e_sm_commitment_from_proof = extract_field(&proof.public_signals, 1); - - assert_eq!( - sk_commitment_from_proof, computation_output.inputs.expected_sk_commitment, - "sk commitment mismatch" - ); - assert_eq!( - e_sm_commitment_from_proof, computation_output.inputs.expected_e_sm_commitment, - "e_sm commitment mismatch" - ); - - prover.cleanup(e3_id).unwrap(); -} diff --git a/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol b/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol index 5b7da618f6..8cfc0cb37a 100644 --- a/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol +++ b/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol @@ -7,238 +7,122 @@ uint256 constant LOG_N = 13; uint256 constant NUMBER_OF_PUBLIC_INPUTS = 17; uint256 constant VK_HASH = 0x170affbea8713b79ad326398ea7b49424c51fa4dca10a65185ad33dbce4d6001; library HonkVerificationKey { - function loadVerificationKey() - internal - pure - returns (Honk.VerificationKey memory) - { + function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) { Honk.VerificationKey memory vk = Honk.VerificationKey({ circuitSize: uint256(8192), logCircuitSize: uint256(13), publicInputsSize: uint256(17), - ql: Honk.G1Point({ - x: uint256( - 0x22a702d6d3957500783049fee5af2a27155cfdf1b6c2958942f5cde4bc63d163 - ), - y: uint256( - 0x003567b43861479b2347249040b9a4c4423f494e6dd8a7de9a4e3900741c4551 - ) + ql: Honk.G1Point({ + x: uint256(0x22a702d6d3957500783049fee5af2a27155cfdf1b6c2958942f5cde4bc63d163), + y: uint256(0x003567b43861479b2347249040b9a4c4423f494e6dd8a7de9a4e3900741c4551) }), - qr: Honk.G1Point({ - x: uint256( - 0x1333cd6f8595ef95ab9d9744d1d00175a56c1b0bc60000ac6d4eb9ec7315c70a - ), - y: uint256( - 0x1c891650f45fe25cf375ea0b322372757b89799546eed2152766130e6b99efa0 - ) + qr: Honk.G1Point({ + x: uint256(0x1333cd6f8595ef95ab9d9744d1d00175a56c1b0bc60000ac6d4eb9ec7315c70a), + y: uint256(0x1c891650f45fe25cf375ea0b322372757b89799546eed2152766130e6b99efa0) }), - qo: Honk.G1Point({ - x: uint256( - 0x251fdc445de2b90170e8c86c41a81303bb3de75352f2bd6f095bdab77486445a - ), - y: uint256( - 0x06f20c995414f9b6bdb794492d328124e2b7676329a5a1724365076751ad2a8a - ) + qo: Honk.G1Point({ + x: uint256(0x251fdc445de2b90170e8c86c41a81303bb3de75352f2bd6f095bdab77486445a), + y: uint256(0x06f20c995414f9b6bdb794492d328124e2b7676329a5a1724365076751ad2a8a) }), - q4: Honk.G1Point({ - x: uint256( - 0x12600bb185b845c63e4b9d5c310db2d257aa5d1d09090ef3c8bdd7334e8991d0 - ), - y: uint256( - 0x017ccf0bdad7381ff8a3bef25259d90c296b71c037ee58bcce51cb0b7a6e97f4 - ) + q4: Honk.G1Point({ + x: uint256(0x12600bb185b845c63e4b9d5c310db2d257aa5d1d09090ef3c8bdd7334e8991d0), + y: uint256(0x017ccf0bdad7381ff8a3bef25259d90c296b71c037ee58bcce51cb0b7a6e97f4) }), - qm: Honk.G1Point({ - x: uint256( - 0x1a5c96bf5dac44c45e28380daccedfec1d9a8919999a0d748a8686f7f42cba76 - ), - y: uint256( - 0x28c5876a4c88720ff49870cbc3b7f41c26a131f4d57ce95cbc6127859c08931f - ) + qm: Honk.G1Point({ + x: uint256(0x1a5c96bf5dac44c45e28380daccedfec1d9a8919999a0d748a8686f7f42cba76), + y: uint256(0x28c5876a4c88720ff49870cbc3b7f41c26a131f4d57ce95cbc6127859c08931f) }), - qc: Honk.G1Point({ - x: uint256( - 0x2c740230a118ad04f1482eeef2e75a14aed0f961b763120de34d0fbe63ca12b0 - ), - y: uint256( - 0x1b9aa7fd5bf93acbaadd615b6e0829e714539fe471bece34b359cd6a96d00294 - ) + qc: Honk.G1Point({ + x: uint256(0x2c740230a118ad04f1482eeef2e75a14aed0f961b763120de34d0fbe63ca12b0), + y: uint256(0x1b9aa7fd5bf93acbaadd615b6e0829e714539fe471bece34b359cd6a96d00294) }), - qLookup: Honk.G1Point({ - x: uint256( - 0x0c4032c3079594eb75a8449d3d5ce8bc3661650d53f9b24d923d8f404cb0bbc9 - ), - y: uint256( - 0x1084d709650356d40f0158fd6da81f54eb5fe796a0ca89441369b7c24301f851 - ) + qLookup: Honk.G1Point({ + x: uint256(0x0c4032c3079594eb75a8449d3d5ce8bc3661650d53f9b24d923d8f404cb0bbc9), + y: uint256(0x1084d709650356d40f0158fd6da81f54eb5fe796a0ca89441369b7c24301f851) }), - qArith: Honk.G1Point({ - x: uint256( - 0x1f13031b7801d2da6d5206a7da087d7661d87905cef81f24e3cbe9e7a1c51488 - ), - y: uint256( - 0x2d93aa6923ac15844842bd024199117f43ca14c883f37570030fdf385356a18a - ) + qArith: Honk.G1Point({ + x: uint256(0x1f13031b7801d2da6d5206a7da087d7661d87905cef81f24e3cbe9e7a1c51488), + y: uint256(0x2d93aa6923ac15844842bd024199117f43ca14c883f37570030fdf385356a18a) }), - qDeltaRange: Honk.G1Point({ - x: uint256( - 0x300557c1eda8ed63912d72e051bb3431bd54f7395755b820a59ff85295eb36d9 - ), - y: uint256( - 0x227e5f5f62555201e96e188514b5387fb7e026a4af0ac209ec6730c4e0e6cc76 - ) + qDeltaRange: Honk.G1Point({ + x: uint256(0x300557c1eda8ed63912d72e051bb3431bd54f7395755b820a59ff85295eb36d9), + y: uint256(0x227e5f5f62555201e96e188514b5387fb7e026a4af0ac209ec6730c4e0e6cc76) }), - qElliptic: Honk.G1Point({ - x: uint256( - 0x20a7925feb244b2ba41d31db4651a6c6c6be672ed0e7711f2ef4c2b89f9c4a5f - ), - y: uint256( - 0x2472b531a32a7d7f80ec3c3375977ba4968f326786473e34d1fd73e6236cf661 - ) + qElliptic: Honk.G1Point({ + x: uint256(0x20a7925feb244b2ba41d31db4651a6c6c6be672ed0e7711f2ef4c2b89f9c4a5f), + y: uint256(0x2472b531a32a7d7f80ec3c3375977ba4968f326786473e34d1fd73e6236cf661) }), - qMemory: Honk.G1Point({ - x: uint256( - 0x02095e5acd019e4edaf8d736615b4a159deafdb98a171db591ed499b0219fb4b - ), - y: uint256( - 0x0644f4dc54ac72663d956a233412f748e74b1591553ecbca703829acf75e471a - ) + qMemory: Honk.G1Point({ + x: uint256(0x02095e5acd019e4edaf8d736615b4a159deafdb98a171db591ed499b0219fb4b), + y: uint256(0x0644f4dc54ac72663d956a233412f748e74b1591553ecbca703829acf75e471a) }), - qNnf: Honk.G1Point({ - x: uint256( - 0x022bae55678012a184d4cb970b8f9a6d1334097d611de534bef96fc9f8d9d011 - ), - y: uint256( - 0x284ee2d499274885bcb7a0d77b0a261d9192ec413b0c0a86fb27ae88cdd5a72c - ) + qNnf: Honk.G1Point({ + x: uint256(0x022bae55678012a184d4cb970b8f9a6d1334097d611de534bef96fc9f8d9d011), + y: uint256(0x284ee2d499274885bcb7a0d77b0a261d9192ec413b0c0a86fb27ae88cdd5a72c) }), - qPoseidon2External: Honk.G1Point({ - x: uint256( - 0x2dd8c7e5ce5f6a7053c173bb140d46830ab962c6c45d637d66171ee540bb21d5 - ), - y: uint256( - 0x033b47f5f8496af8d227ef175c47b3f7cd666ebc94f0e63562ebfcf30d73f6e2 - ) + qPoseidon2External: Honk.G1Point({ + x: uint256(0x2dd8c7e5ce5f6a7053c173bb140d46830ab962c6c45d637d66171ee540bb21d5), + y: uint256(0x033b47f5f8496af8d227ef175c47b3f7cd666ebc94f0e63562ebfcf30d73f6e2) }), - qPoseidon2Internal: Honk.G1Point({ - x: uint256( - 0x2940b2ab034af88869e264e12ee268b16c221b5f2cdd96748cce870c1a7bb24a - ), - y: uint256( - 0x04cfb9bfe08adf0e6f25c2cc9e83448d8f23d9fb3a0efba8d41768520d62d0e8 - ) + qPoseidon2Internal: Honk.G1Point({ + x: uint256(0x2940b2ab034af88869e264e12ee268b16c221b5f2cdd96748cce870c1a7bb24a), + y: uint256(0x04cfb9bfe08adf0e6f25c2cc9e83448d8f23d9fb3a0efba8d41768520d62d0e8) }), - s1: Honk.G1Point({ - x: uint256( - 0x1b300dbb752984d39a06a3278fc9048a525d0fdf14ef98f17ffb42a971fb9032 - ), - y: uint256( - 0x01ccd716ea4eeba47b57e3110f305af0d1e2feec11f2656816dbb234ea0b3b1b - ) + s1: Honk.G1Point({ + x: uint256(0x1b300dbb752984d39a06a3278fc9048a525d0fdf14ef98f17ffb42a971fb9032), + y: uint256(0x01ccd716ea4eeba47b57e3110f305af0d1e2feec11f2656816dbb234ea0b3b1b) }), - s2: Honk.G1Point({ - x: uint256( - 0x0d2e187f65cf5ab43eac061f54e93bdcc292b2f518ee632b030ea3290143139c - ), - y: uint256( - 0x03ff9967978b924f43af1e71f6281ee36a96c1b647bbf8c17e3cb4626068b78b - ) + s2: Honk.G1Point({ + x: uint256(0x0d2e187f65cf5ab43eac061f54e93bdcc292b2f518ee632b030ea3290143139c), + y: uint256(0x03ff9967978b924f43af1e71f6281ee36a96c1b647bbf8c17e3cb4626068b78b) }), - s3: Honk.G1Point({ - x: uint256( - 0x2106e82e5e59b21be7c8ac07ede04efc6445f01e31b5ce7894444cb081df43d1 - ), - y: uint256( - 0x0571641ab150cfa4371421f984cc897945b69ca100d0960c2ee5ca1d17cd9670 - ) + s3: Honk.G1Point({ + x: uint256(0x2106e82e5e59b21be7c8ac07ede04efc6445f01e31b5ce7894444cb081df43d1), + y: uint256(0x0571641ab150cfa4371421f984cc897945b69ca100d0960c2ee5ca1d17cd9670) }), - s4: Honk.G1Point({ - x: uint256( - 0x27599a711decc65fa4aad9515655e029868cc54d495fb8b53fa44e165702a5ee - ), - y: uint256( - 0x1d9db80b8419761979511454f69fa448fc50d15062e434c6994c4ccc4912f672 - ) + s4: Honk.G1Point({ + x: uint256(0x27599a711decc65fa4aad9515655e029868cc54d495fb8b53fa44e165702a5ee), + y: uint256(0x1d9db80b8419761979511454f69fa448fc50d15062e434c6994c4ccc4912f672) }), - t1: Honk.G1Point({ - x: uint256( - 0x099e3bd5a0a00ab7fe18040105b9b395b5d8b7b4a63b05df652b0d10ef146d26 - ), - y: uint256( - 0x0015b8d2515d76e2ccec99dcd194592129af3a637f5a622a32440f860d1e2a7f - ) + t1: Honk.G1Point({ + x: uint256(0x099e3bd5a0a00ab7fe18040105b9b395b5d8b7b4a63b05df652b0d10ef146d26), + y: uint256(0x0015b8d2515d76e2ccec99dcd194592129af3a637f5a622a32440f860d1e2a7f) }), - t2: Honk.G1Point({ - x: uint256( - 0x1b917517920bad3d8bc01c9595092a222b888108dc25d1aa450e0b4bc212c37e - ), - y: uint256( - 0x305e8992b148eedb22e6e992077a84482141c7ebe42000a1d58ccb74381f6d19 - ) + t2: Honk.G1Point({ + x: uint256(0x1b917517920bad3d8bc01c9595092a222b888108dc25d1aa450e0b4bc212c37e), + y: uint256(0x305e8992b148eedb22e6e992077a84482141c7ebe42000a1d58ccb74381f6d19) }), - t3: Honk.G1Point({ - x: uint256( - 0x13567e3b915c81013ada15236ba5cfa60111b440400b2bca37e2b1085e924a77 - ), - y: uint256( - 0x0148d22589b91f0d8f4674af5744dedafd63caea904b434e748f9713de8cc3d7 - ) + t3: Honk.G1Point({ + x: uint256(0x13567e3b915c81013ada15236ba5cfa60111b440400b2bca37e2b1085e924a77), + y: uint256(0x0148d22589b91f0d8f4674af5744dedafd63caea904b434e748f9713de8cc3d7) }), - t4: Honk.G1Point({ - x: uint256( - 0x043d063b130adfb37342af45d0155a28edd1a7e46c840d9c943fdf45521c64ce - ), - y: uint256( - 0x261522c4089330646aff96736194949330952ae74c573d1686d9cb4a00733854 - ) + t4: Honk.G1Point({ + x: uint256(0x043d063b130adfb37342af45d0155a28edd1a7e46c840d9c943fdf45521c64ce), + y: uint256(0x261522c4089330646aff96736194949330952ae74c573d1686d9cb4a00733854) }), - id1: Honk.G1Point({ - x: uint256( - 0x1fa05f284bf1410f37f0d556ccfeb052395ec8625620cf724d146a3b15496d4d - ), - y: uint256( - 0x0c8fc17b9b81b4f93a7b9bdd1cc5f01a30ef6e808409c456f6d6d13fe7d2eb17 - ) + id1: Honk.G1Point({ + x: uint256(0x1fa05f284bf1410f37f0d556ccfeb052395ec8625620cf724d146a3b15496d4d), + y: uint256(0x0c8fc17b9b81b4f93a7b9bdd1cc5f01a30ef6e808409c456f6d6d13fe7d2eb17) }), - id2: Honk.G1Point({ - x: uint256( - 0x05798d2cd96b3294d8cc2f0120fa58ffea3a662e32039784f0b0b051e34e8718 - ), - y: uint256( - 0x02d377efbb702de6d6a38e5c42c6aaf56cc11762d724a635ea4d5dc72eb9e0ca - ) + id2: Honk.G1Point({ + x: uint256(0x05798d2cd96b3294d8cc2f0120fa58ffea3a662e32039784f0b0b051e34e8718), + y: uint256(0x02d377efbb702de6d6a38e5c42c6aaf56cc11762d724a635ea4d5dc72eb9e0ca) }), - id3: Honk.G1Point({ - x: uint256( - 0x110bd6ab5007b97692cd6e8ea8cab85d8b039d9e8dc2a9931fa6dcd72e0adac8 - ), - y: uint256( - 0x2e418397e17371fcf5a1a5c614f4dfe9727b79d5aa127ab98c04a7a4c06ccb9f - ) + id3: Honk.G1Point({ + x: uint256(0x110bd6ab5007b97692cd6e8ea8cab85d8b039d9e8dc2a9931fa6dcd72e0adac8), + y: uint256(0x2e418397e17371fcf5a1a5c614f4dfe9727b79d5aa127ab98c04a7a4c06ccb9f) }), - id4: Honk.G1Point({ - x: uint256( - 0x0ccf438e4b27c76e599cda77ba04ad29cbaf538ded427e979eef69a5a9884b78 - ), - y: uint256( - 0x09117b0cb34fc65ed20f92de70c6f8e073c755fb4acf2d74f402c6a97ee3d01a - ) + id4: Honk.G1Point({ + x: uint256(0x0ccf438e4b27c76e599cda77ba04ad29cbaf538ded427e979eef69a5a9884b78), + y: uint256(0x09117b0cb34fc65ed20f92de70c6f8e073c755fb4acf2d74f402c6a97ee3d01a) }), - lagrangeFirst: Honk.G1Point({ - x: uint256( - 0x0000000000000000000000000000000000000000000000000000000000000001 - ), - y: uint256( - 0x0000000000000000000000000000000000000000000000000000000000000002 - ) + lagrangeFirst: Honk.G1Point({ + x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001), + y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002) }), - lagrangeLast: Honk.G1Point({ - x: uint256( - 0x22671e023cbbeb82d51b48eb911951a7a1f9c2bb913f3f42a56f272e205d4624 - ), - y: uint256( - 0x139bdfe9fe99633e5abe888702fa64a75c80d62184d0a16bd999840553954bb1 - ) + lagrangeLast: Honk.G1Point({ + x: uint256(0x22671e023cbbeb82d51b48eb911951a7a1f9c2bb913f3f42a56f272e205d4624), + y: uint256(0x139bdfe9fe99633e5abe888702fa64a75c80d62184d0a16bd999840553954bb1) }) }); return vk; @@ -248,31 +132,24 @@ library HonkVerificationKey { pragma solidity ^0.8.27; interface IVerifier { - function verify( - bytes calldata _proof, - bytes32[] calldata _publicInputs - ) external returns (bool); + function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external returns (bool); } type Fr is uint256; -using { add as + } for Fr global; -using { sub as - } for Fr global; -using { mul as * } for Fr global; +using {add as +} for Fr global; +using {sub as -} for Fr global; +using {mul as *} for Fr global; -using { exp as ^ } for Fr global; -using { notEqual as != } for Fr global; -using { equal as == } for Fr global; +using {exp as ^} for Fr global; +using {notEqual as !=} for Fr global; +using {equal as ==} for Fr global; uint256 constant SUBGROUP_SIZE = 256; uint256 constant MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617; // Prime field order uint256 constant P = MODULUS; -Fr constant SUBGROUP_GENERATOR = Fr.wrap( - 0x07b0c561a6148404f086204a9f36ffb0617942546750f230c893619174a57a76 -); -Fr constant SUBGROUP_GENERATOR_INVERSE = Fr.wrap( - 0x204bd3277422fad364751ad938e2b5e6a54cf8c68712848a692c553d0329f5d6 -); +Fr constant SUBGROUP_GENERATOR = Fr.wrap(0x07b0c561a6148404f086204a9f36ffb0617942546750f230c893619174a57a76); +Fr constant SUBGROUP_GENERATOR_INVERSE = Fr.wrap(0x204bd3277422fad364751ad938e2b5e6a54cf8c68712848a692c553d0329f5d6); Fr constant MINUS_ONE = Fr.wrap(MODULUS - 1); Fr constant ONE = Fr.wrap(1); Fr constant ZERO = Fr.wrap(0); @@ -308,7 +185,7 @@ library FrLib { mstore(add(free, 0x20), 0x20) mstore(add(free, 0x40), 0x20) mstore(add(free, 0x60), v) - mstore(add(free, 0x80), sub(MODULUS, 2)) + mstore(add(free, 0x80), sub(MODULUS, 2)) mstore(add(free, 0xa0), MODULUS) let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) if iszero(success) { @@ -332,7 +209,7 @@ library FrLib { mstore(add(free, 0x20), 0x20) mstore(add(free, 0x40), 0x20) mstore(add(free, 0x60), b) - mstore(add(free, 0x80), v) + mstore(add(free, 0x80), v) mstore(add(free, 0xa0), MODULUS) let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) if iszero(success) { @@ -611,63 +488,26 @@ library ZKTranscriptLib { uint256 logN ) external pure returns (ZKTranscript memory t) { Fr previousChallenge; - ( - t.relationParameters, - previousChallenge - ) = generateRelationParametersChallenges( - proof, - publicInputs, - vkHash, - publicInputsSize, - previousChallenge - ); + (t.relationParameters, previousChallenge) = + generateRelationParametersChallenges(proof, publicInputs, vkHash, publicInputsSize, previousChallenge); - (t.alphas, previousChallenge) = generateAlphaChallenges( - previousChallenge, - proof - ); + (t.alphas, previousChallenge) = generateAlphaChallenges(previousChallenge, proof); - (t.gateChallenges, previousChallenge) = generateGateChallenges( - previousChallenge, - logN - ); - (t.libraChallenge, previousChallenge) = generateLibraChallenge( - previousChallenge, - proof - ); - (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges( - proof, - previousChallenge, - logN - ); + (t.gateChallenges, previousChallenge) = generateGateChallenges(previousChallenge, logN); + (t.libraChallenge, previousChallenge) = generateLibraChallenge(previousChallenge, proof); + (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges(proof, previousChallenge, logN); - (t.rho, previousChallenge) = generateRhoChallenge( - proof, - previousChallenge - ); + (t.rho, previousChallenge) = generateRhoChallenge(proof, previousChallenge); - (t.geminiR, previousChallenge) = generateGeminiRChallenge( - proof, - previousChallenge, - logN - ); + (t.geminiR, previousChallenge) = generateGeminiRChallenge(proof, previousChallenge, logN); - (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge( - proof, - previousChallenge, - logN - ); + (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge(proof, previousChallenge, logN); - (t.shplonkZ, previousChallenge) = generateShplonkZChallenge( - proof, - previousChallenge - ); + (t.shplonkZ, previousChallenge) = generateShplonkZChallenge(proof, previousChallenge); return t; } - function splitChallenge( - Fr challenge - ) internal pure returns (Fr first, Fr second) { + function splitChallenge(Fr challenge) internal pure returns (Fr first, Fr second) { uint256 challengeU256 = uint256(Fr.unwrap(challenge)); uint256 lo = challengeU256 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; uint256 hi = challengeU256 >> 128; @@ -681,23 +521,11 @@ library ZKTranscriptLib { uint256 vkHash, uint256 publicInputsSize, Fr previousChallenge - ) - internal - pure - returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) - { - ( - rp.eta, - rp.etaTwo, - rp.etaThree, - previousChallenge - ) = generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); + ) internal pure returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) { + (rp.eta, rp.etaTwo, rp.etaThree, previousChallenge) = + generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); - ( - rp.beta, - rp.gamma, - nextPreviousChallenge - ) = generateBetaAndGammaChallenges(previousChallenge, proof); + (rp.beta, rp.gamma, nextPreviousChallenge) = generateBetaAndGammaChallenges(previousChallenge, proof); } function generateEtaChallenge( @@ -705,11 +533,7 @@ library ZKTranscriptLib { bytes32[] calldata publicInputs, uint256 vkHash, uint256 publicInputsSize - ) - internal - pure - returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) - { + ) internal pure returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) { bytes32[] memory round0 = new bytes32[](1 + publicInputsSize + 6); round0[0] = bytes32(vkHash); @@ -717,8 +541,7 @@ library ZKTranscriptLib { round0[1 + i] = bytes32(publicInputs[i]); } for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib - .toBytes32(proof.pairingPointObject[i]); + round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib.toBytes32(proof.pairingPointObject[i]); } // Create the first challenge @@ -730,21 +553,18 @@ library ZKTranscriptLib { round0[1 + publicInputsSize + 4] = bytes32(proof.w3.x); round0[1 + publicInputsSize + 5] = bytes32(proof.w3.y); - previousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(round0)) - ); + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round0))); (eta, etaTwo) = splitChallenge(previousChallenge); - previousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(Fr.unwrap(previousChallenge))) - ); + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); - (etaThree, ) = splitChallenge(previousChallenge); + (etaThree,) = splitChallenge(previousChallenge); } - function generateBetaAndGammaChallenges( - Fr previousChallenge, - Honk.ZKProof memory proof - ) internal pure returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) { + function generateBetaAndGammaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) + internal + pure + returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) + { bytes32[7] memory round1; round1[0] = FrLib.toBytes32(previousChallenge); round1[1] = bytes32(proof.lookupReadCounts.x); @@ -754,17 +574,12 @@ library ZKTranscriptLib { round1[5] = bytes32(proof.w4.x); round1[6] = bytes32(proof.w4.y); - nextPreviousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(round1)) - ); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round1))); (beta, gamma) = splitChallenge(nextPreviousChallenge); } // Alpha challenges non-linearise the gate contributions - function generateAlphaChallenges( - Fr previousChallenge, - Honk.ZKProof memory proof - ) + function generateAlphaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) internal pure returns (Fr[NUMBER_OF_ALPHAS] memory alphas, Fr nextPreviousChallenge) @@ -777,11 +592,9 @@ library ZKTranscriptLib { alpha0[3] = proof.zPerm.x; alpha0[4] = proof.zPerm.y; - nextPreviousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(alpha0)) - ); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(alpha0))); Fr alpha; - (alpha, ) = splitChallenge(nextPreviousChallenge); + (alpha,) = splitChallenge(nextPreviousChallenge); // Compute powers of alpha for batching subrelations alphas[0] = alpha; @@ -790,54 +603,38 @@ library ZKTranscriptLib { } } - function generateGateChallenges( - Fr previousChallenge, - uint256 logN - ) + function generateGateChallenges(Fr previousChallenge, uint256 logN) internal pure - returns ( - Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, - Fr nextPreviousChallenge - ) + returns (Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, Fr nextPreviousChallenge) { - previousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(Fr.unwrap(previousChallenge))) - ); - (gateChallenges[0], ) = splitChallenge(previousChallenge); + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); + (gateChallenges[0],) = splitChallenge(previousChallenge); for (uint256 i = 1; i < logN; i++) { gateChallenges[i] = gateChallenges[i - 1] * gateChallenges[i - 1]; } nextPreviousChallenge = previousChallenge; } - function generateLibraChallenge( - Fr previousChallenge, - Honk.ZKProof memory proof - ) internal pure returns (Fr libraChallenge, Fr nextPreviousChallenge) { + function generateLibraChallenge(Fr previousChallenge, Honk.ZKProof memory proof) + internal + pure + returns (Fr libraChallenge, Fr nextPreviousChallenge) + { // 2 comm, 1 sum, 1 challenge uint256[4] memory challengeData; challengeData[0] = Fr.unwrap(previousChallenge); challengeData[1] = proof.libraCommitments[0].x; challengeData[2] = proof.libraCommitments[0].y; challengeData[3] = Fr.unwrap(proof.libraSum); - nextPreviousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(challengeData)) - ); - (libraChallenge, ) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(challengeData))); + (libraChallenge,) = splitChallenge(nextPreviousChallenge); } - function generateSumcheckChallenges( - Honk.ZKProof memory proof, - Fr prevChallenge, - uint256 logN - ) + function generateSumcheckChallenges(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) internal pure - returns ( - Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, - Fr nextPreviousChallenge - ) + returns (Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, Fr nextPreviousChallenge) { for (uint256 i = 0; i < logN; i++) { Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH + 1] memory univariateChal; @@ -846,27 +643,24 @@ library ZKTranscriptLib { for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { univariateChal[j + 1] = proof.sumcheckUnivariates[i][j]; } - prevChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(univariateChal)) - ); + prevChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(univariateChal))); - (sumcheckChallenges[i], ) = splitChallenge(prevChallenge); + (sumcheckChallenges[i],) = splitChallenge(prevChallenge); } nextPreviousChallenge = prevChallenge; } // We add Libra claimed eval + 3 comm + 1 more eval - function generateRhoChallenge( - Honk.ZKProof memory proof, - Fr prevChallenge - ) internal pure returns (Fr rho, Fr nextPreviousChallenge) { + function generateRhoChallenge(Honk.ZKProof memory proof, Fr prevChallenge) + internal + pure + returns (Fr rho, Fr nextPreviousChallenge) + { uint256[NUMBER_OF_ENTITIES + 9] memory rhoChallengeElements; rhoChallengeElements[0] = Fr.unwrap(prevChallenge); uint256 i; for (i = 1; i <= NUMBER_OF_ENTITIES; i++) { - rhoChallengeElements[i] = Fr.unwrap( - proof.sumcheckEvaluations[i - 1] - ); + rhoChallengeElements[i] = Fr.unwrap(proof.sumcheckEvaluations[i - 1]); } rhoChallengeElements[i] = Fr.unwrap(proof.libraEvaluation); @@ -883,17 +677,15 @@ library ZKTranscriptLib { i += 2; rhoChallengeElements[i] = Fr.unwrap(proof.geminiMaskingEval); - nextPreviousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(rhoChallengeElements)) - ); - (rho, ) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(rhoChallengeElements))); + (rho,) = splitChallenge(nextPreviousChallenge); } - function generateGeminiRChallenge( - Honk.ZKProof memory proof, - Fr prevChallenge, - uint256 logN - ) internal pure returns (Fr geminiR, Fr nextPreviousChallenge) { + function generateGeminiRChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) + internal + pure + returns (Fr geminiR, Fr nextPreviousChallenge) + { uint256[] memory gR = new uint256[]((logN - 1) * 2 + 1); gR[0] = Fr.unwrap(prevChallenge); @@ -902,70 +694,54 @@ library ZKTranscriptLib { gR[2 + i * 2] = proof.geminiFoldComms[i].y; } - nextPreviousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(gR)) - ); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(gR))); - (geminiR, ) = splitChallenge(nextPreviousChallenge); + (geminiR,) = splitChallenge(nextPreviousChallenge); } - function generateShplonkNuChallenge( - Honk.ZKProof memory proof, - Fr prevChallenge, - uint256 logN - ) internal pure returns (Fr shplonkNu, Fr nextPreviousChallenge) { - uint256[] memory shplonkNuChallengeElements = new uint256[]( - logN + 1 + 4 - ); + function generateShplonkNuChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) + internal + pure + returns (Fr shplonkNu, Fr nextPreviousChallenge) + { + uint256[] memory shplonkNuChallengeElements = new uint256[](logN + 1 + 4); shplonkNuChallengeElements[0] = Fr.unwrap(prevChallenge); for (uint256 i = 1; i <= logN; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap( - proof.geminiAEvaluations[i - 1] - ); + shplonkNuChallengeElements[i] = Fr.unwrap(proof.geminiAEvaluations[i - 1]); } uint256 libraIdx = 0; for (uint256 i = logN + 1; i <= logN + 4; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap( - proof.libraPolyEvals[libraIdx] - ); + shplonkNuChallengeElements[i] = Fr.unwrap(proof.libraPolyEvals[libraIdx]); libraIdx++; } - nextPreviousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(shplonkNuChallengeElements)) - ); - (shplonkNu, ) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkNuChallengeElements))); + (shplonkNu,) = splitChallenge(nextPreviousChallenge); } - function generateShplonkZChallenge( - Honk.ZKProof memory proof, - Fr prevChallenge - ) internal pure returns (Fr shplonkZ, Fr nextPreviousChallenge) { + function generateShplonkZChallenge(Honk.ZKProof memory proof, Fr prevChallenge) + internal + pure + returns (Fr shplonkZ, Fr nextPreviousChallenge) + { uint256[3] memory shplonkZChallengeElements; shplonkZChallengeElements[0] = Fr.unwrap(prevChallenge); shplonkZChallengeElements[1] = proof.shplonkQ.x; shplonkZChallengeElements[2] = proof.shplonkQ.y; - nextPreviousChallenge = FrLib.fromBytes32( - keccak256(abi.encodePacked(shplonkZChallengeElements)) - ); - (shplonkZ, ) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkZChallengeElements))); + (shplonkZ,) = splitChallenge(nextPreviousChallenge); } - function loadProof( - bytes calldata proof, - uint256 logN - ) internal pure returns (Honk.ZKProof memory p) { + function loadProof(bytes calldata proof, uint256 logN) internal pure returns (Honk.ZKProof memory p) { uint256 boundary = 0x0; // Pairing point object for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - p.pairingPointObject[i] = bytesToFr( - proof[boundary:boundary + FIELD_ELEMENT_SIZE] - ); + p.pairingPointObject[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); boundary += FIELD_ELEMENT_SIZE; } // Commitments @@ -977,25 +753,17 @@ library ZKTranscriptLib { boundary += GROUP_ELEMENT_SIZE; // Lookup / Permutation Helper Commitments - p.lookupReadCounts = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.lookupReadCounts = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.lookupReadTags = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.lookupReadTags = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; p.w4 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.lookupInverses = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.lookupInverses = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; p.zPerm = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[0] = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.libraCommitments[0] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; p.libraSum = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); @@ -1003,76 +771,52 @@ library ZKTranscriptLib { // Sumcheck univariates for (uint256 i = 0; i < logN; i++) { for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { - p.sumcheckUnivariates[i][j] = bytesToFr( - proof[boundary:boundary + FIELD_ELEMENT_SIZE] - ); + p.sumcheckUnivariates[i][j] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); boundary += FIELD_ELEMENT_SIZE; } } // Sumcheck evaluations for (uint256 i = 0; i < NUMBER_OF_ENTITIES; i++) { - p.sumcheckEvaluations[i] = bytesToFr( - proof[boundary:boundary + FIELD_ELEMENT_SIZE] - ); + p.sumcheckEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); boundary += FIELD_ELEMENT_SIZE; } - p.libraEvaluation = bytesToFr( - proof[boundary:boundary + FIELD_ELEMENT_SIZE] - ); + p.libraEvaluation = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); boundary += FIELD_ELEMENT_SIZE; - p.libraCommitments[1] = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.libraCommitments[1] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[2] = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.libraCommitments[2] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingPoly = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.geminiMaskingPoly = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingEval = bytesToFr( - proof[boundary:boundary + FIELD_ELEMENT_SIZE] - ); + p.geminiMaskingEval = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); boundary += FIELD_ELEMENT_SIZE; // Gemini // Read gemini fold univariates for (uint256 i = 0; i < logN - 1; i++) { - p.geminiFoldComms[i] = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.geminiFoldComms[i] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; } // Read gemini a evaluations for (uint256 i = 0; i < logN; i++) { - p.geminiAEvaluations[i] = bytesToFr( - proof[boundary:boundary + FIELD_ELEMENT_SIZE] - ); + p.geminiAEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); boundary += FIELD_ELEMENT_SIZE; } for (uint256 i = 0; i < 4; i++) { - p.libraPolyEvals[i] = bytesToFr( - proof[boundary:boundary + FIELD_ELEMENT_SIZE] - ); + p.libraPolyEvals[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); boundary += FIELD_ELEMENT_SIZE; } // Shplonk - p.shplonkQ = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.shplonkQ = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; // KZG - p.kzgQuotient = bytesToG1Point( - proof[boundary:boundary + GROUP_ELEMENT_SIZE] - ); + p.kzgQuotient = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); } } @@ -1090,54 +834,15 @@ library RelationsLib { Fr[NUMBER_OF_SUBRELATIONS] memory evaluations; // Accumulate all relations in Ultra Honk - each with varying number of subrelations - accumulateArithmeticRelation( - purportedEvaluations, - evaluations, - powPartialEval - ); - accumulatePermutationRelation( - purportedEvaluations, - rp, - evaluations, - powPartialEval - ); - accumulateLogDerivativeLookupRelation( - purportedEvaluations, - rp, - evaluations, - powPartialEval - ); - accumulateDeltaRangeRelation( - purportedEvaluations, - evaluations, - powPartialEval - ); - accumulateEllipticRelation( - purportedEvaluations, - evaluations, - powPartialEval - ); - accumulateMemoryRelation( - purportedEvaluations, - rp, - evaluations, - powPartialEval - ); - accumulateNnfRelation( - purportedEvaluations, - evaluations, - powPartialEval - ); - accumulatePoseidonExternalRelation( - purportedEvaluations, - evaluations, - powPartialEval - ); - accumulatePoseidonInternalRelation( - purportedEvaluations, - evaluations, - powPartialEval - ); + accumulateArithmeticRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePermutationRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateLogDerivativeLookupRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateDeltaRangeRelation(purportedEvaluations, evaluations, powPartialEval); + accumulateEllipticRelation(purportedEvaluations, evaluations, powPartialEval); + accumulateMemoryRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateNnfRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePoseidonExternalRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePoseidonInternalRelation(purportedEvaluations, evaluations, powPartialEval); // batch the subrelations with the alpha challenges to obtain the full honk relation accumulator = scaleAndBatchSubrelations(evaluations, alphas); @@ -1148,15 +853,11 @@ library RelationsLib { * the relation checking code being cluttered with uint256 type casting, which is often a different colour in code * editors, and thus is noisy. */ - function wire( - Fr[NUMBER_OF_ENTITIES] memory p, - WIRE _wire - ) internal pure returns (Fr) { + function wire(Fr[NUMBER_OF_ENTITIES] memory p, WIRE _wire) internal pure returns (Fr) { return p[uint256(_wire)]; } - uint256 internal constant NEG_HALF_MODULO_P = - 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; + uint256 internal constant NEG_HALF_MODULO_P = 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; /** * Ultra Arithmetic Relation * @@ -1172,16 +873,9 @@ library RelationsLib { { Fr neg_half = Fr.wrap(NEG_HALF_MODULO_P); - Fr accum = (q_arith - Fr.wrap(3)) * - (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * - neg_half; - accum = - accum + - (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + - (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) + - (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + - (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + - wire(p, WIRE.Q_C); + Fr accum = (q_arith - Fr.wrap(3)) * (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * neg_half; + accum = accum + (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) + + (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + wire(p, WIRE.Q_C); accum = accum + (q_arith - ONE) * wire(p, WIRE.W_4_SHIFT); accum = accum * q_arith; accum = accum * domainSep; @@ -1190,10 +884,7 @@ library RelationsLib { // Relation 1 { - Fr accum = wire(p, WIRE.W_L) + - wire(p, WIRE.W_4) - - wire(p, WIRE.W_L_SHIFT) + - wire(p, WIRE.Q_M); + Fr accum = wire(p, WIRE.W_L) + wire(p, WIRE.W_4) - wire(p, WIRE.W_L_SHIFT) + wire(p, WIRE.Q_M); accum = accum * (q_arith - Fr.wrap(2)); accum = accum * (q_arith - ONE); accum = accum * q_arith; @@ -1212,67 +903,38 @@ library RelationsLib { Fr grand_product_denominator; { - Fr num = wire(p, WIRE.W_L) + - wire(p, WIRE.ID_1) * - rp.beta + - rp.gamma; - num = - num * - (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); - num = - num * - (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); - num = - num * - (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); + Fr num = wire(p, WIRE.W_L) + wire(p, WIRE.ID_1) * rp.beta + rp.gamma; + num = num * (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); + num = num * (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); + num = num * (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); grand_product_numerator = num; } { - Fr den = wire(p, WIRE.W_L) + - wire(p, WIRE.SIGMA_1) * - rp.beta + - rp.gamma; - den = - den * - (wire(p, WIRE.W_R) + - wire(p, WIRE.SIGMA_2) * - rp.beta + - rp.gamma); - den = - den * - (wire(p, WIRE.W_O) + - wire(p, WIRE.SIGMA_3) * - rp.beta + - rp.gamma); - den = - den * - (wire(p, WIRE.W_4) + - wire(p, WIRE.SIGMA_4) * - rp.beta + - rp.gamma); + Fr den = wire(p, WIRE.W_L) + wire(p, WIRE.SIGMA_1) * rp.beta + rp.gamma; + den = den * (wire(p, WIRE.W_R) + wire(p, WIRE.SIGMA_2) * rp.beta + rp.gamma); + den = den * (wire(p, WIRE.W_O) + wire(p, WIRE.SIGMA_3) * rp.beta + rp.gamma); + den = den * (wire(p, WIRE.W_4) + wire(p, WIRE.SIGMA_4) * rp.beta + rp.gamma); grand_product_denominator = den; } // Contribution 2 { - Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * - grand_product_numerator; - - acc = - acc - - ((wire(p, WIRE.Z_PERM_SHIFT) + - (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) * - grand_product_denominator); + Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * grand_product_numerator; + + acc = acc + - ( + (wire(p, WIRE.Z_PERM_SHIFT) + (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) + * grand_product_denominator + ); acc = acc * domainSep; evals[2] = acc; } // Contribution 3 { - Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * - wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; + Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; evals[3] = acc; } } @@ -1288,52 +950,32 @@ library RelationsLib { // Calculate the write term (the table accumulation) { - write_term = - wire(p, WIRE.TABLE_1) + - rp.gamma + - (wire(p, WIRE.TABLE_2) * rp.eta) + - (wire(p, WIRE.TABLE_3) * rp.etaTwo) + - (wire(p, WIRE.TABLE_4) * rp.etaThree); + write_term = wire(p, WIRE.TABLE_1) + rp.gamma + (wire(p, WIRE.TABLE_2) * rp.eta) + + (wire(p, WIRE.TABLE_3) * rp.etaTwo) + (wire(p, WIRE.TABLE_4) * rp.etaThree); } // Calculate the write term { - Fr derived_entry_1 = wire(p, WIRE.W_L) + - rp.gamma + - (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); - Fr derived_entry_2 = wire(p, WIRE.W_R) + - wire(p, WIRE.Q_M) * - wire(p, WIRE.W_R_SHIFT); - Fr derived_entry_3 = wire(p, WIRE.W_O) + - wire(p, WIRE.Q_C) * - wire(p, WIRE.W_O_SHIFT); - - read_term = - derived_entry_1 + - (derived_entry_2 * rp.eta) + - (derived_entry_3 * rp.etaTwo) + - (wire(p, WIRE.Q_O) * rp.etaThree); + Fr derived_entry_1 = wire(p, WIRE.W_L) + rp.gamma + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); + Fr derived_entry_2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_M) * wire(p, WIRE.W_R_SHIFT); + Fr derived_entry_3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_C) * wire(p, WIRE.W_O_SHIFT); + + read_term = derived_entry_1 + (derived_entry_2 * rp.eta) + (derived_entry_3 * rp.etaTwo) + + (wire(p, WIRE.Q_O) * rp.etaThree); } Fr read_inverse = wire(p, WIRE.LOOKUP_INVERSES) * write_term; Fr write_inverse = wire(p, WIRE.LOOKUP_INVERSES) * read_term; - Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + - wire(p, WIRE.Q_LOOKUP) - - (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); + Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + wire(p, WIRE.Q_LOOKUP) + - (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); // Inverse calculated correctly relation - Fr accumulatorNone = read_term * - write_term * - wire(p, WIRE.LOOKUP_INVERSES) - - inverse_exists_xor; + Fr accumulatorNone = read_term * write_term * wire(p, WIRE.LOOKUP_INVERSES) - inverse_exists_xor; accumulatorNone = accumulatorNone * domainSep; // Inverse - Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * - read_inverse - - wire(p, WIRE.LOOKUP_READ_COUNTS) * - write_inverse; + Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * read_inverse - wire(p, WIRE.LOOKUP_READ_COUNTS) * write_inverse; Fr read_tag = wire(p, WIRE.LOOKUP_READ_TAGS); @@ -1447,11 +1089,7 @@ library RelationsLib { x_add_identity = x_add_identity * x_diff * x_diff; x_add_identity = x_add_identity - y2_sqr - y1_sqr + y1y2 + y1y2; - evals[11] = - x_add_identity * - partialEval * - wire(p, WIRE.Q_ELLIPTIC) * - (ONE - q_is_double); + evals[11] = x_add_identity * partialEval * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); } // Contribution 11 point addition, x-coordinate check @@ -1459,15 +1097,8 @@ library RelationsLib { { Fr y1_plus_y3 = ep.y_1 + ep.y_3; Fr y_diff = ep.y_2 * q_sign - ep.y_1; - Fr y_add_identity = y1_plus_y3 * - x_diff + - (ep.x_3 - ep.x_1) * - y_diff; - evals[12] = - y_add_identity * - domainSep * - wire(p, WIRE.Q_ELLIPTIC) * - (ONE - q_is_double); + Fr y_add_identity = y1_plus_y3 * x_diff + (ep.x_3 - ep.x_1) * y_diff; + evals[12] = y_add_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); } // Contribution 10 point doubling, x-coordinate check @@ -1480,15 +1111,9 @@ library RelationsLib { Fr x1_pow_4_mul_9 = x_pow_4 * Fr.wrap(9); // NOTE: pushed into memory (stack >:'( ) - ep.x_double_identity = - (ep.x_3 + ep.x_1 + ep.x_1) * - y1_sqr_mul_4 - - x1_pow_4_mul_9; - - Fr acc = ep.x_double_identity * - domainSep * - wire(p, WIRE.Q_ELLIPTIC) * - q_is_double; + ep.x_double_identity = (ep.x_3 + ep.x_1 + ep.x_1) * y1_sqr_mul_4 - x1_pow_4_mul_9; + + Fr acc = ep.x_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; evals[11] = evals[11] + acc; } @@ -1496,16 +1121,8 @@ library RelationsLib { // (y1 + y1) (2y1) - (3 * x1 * x1)(x1 - x3) = 0 { Fr x1_sqr_mul_3 = (ep.x_1 + ep.x_1 + ep.x_1) * ep.x_1; - Fr y_double_identity = x1_sqr_mul_3 * - (ep.x_1 - ep.x_3) - - (ep.y_1 + ep.y_1) * - (ep.y_1 + ep.y_3); - evals[12] = - evals[12] + - y_double_identity * - domainSep * - wire(p, WIRE.Q_ELLIPTIC) * - q_is_double; + Fr y_double_identity = x1_sqr_mul_3 * (ep.x_1 - ep.x_3) - (ep.y_1 + ep.y_1) * (ep.y_1 + ep.y_3); + evals[12] = evals[12] + y_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; } } @@ -1579,12 +1196,8 @@ library RelationsLib { * For ROM gates, qc = 0 */ ap.memory_record_check = wire(p, WIRE.W_O) * rp.etaThree; - ap.memory_record_check = - ap.memory_record_check + - (wire(p, WIRE.W_R) * rp.etaTwo); - ap.memory_record_check = - ap.memory_record_check + - (wire(p, WIRE.W_L) * rp.eta); + ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_R) * rp.etaTwo); + ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_L) * rp.eta); ap.memory_record_check = ap.memory_record_check + wire(p, WIRE.Q_C); ap.partial_record_check = ap.memory_record_check; // used in RAM consistency check; deg 1 or 4 ap.memory_record_check = ap.memory_record_check - wire(p, WIRE.W_4); @@ -1608,26 +1221,16 @@ library RelationsLib { ap.index_delta = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_L); ap.record_delta = wire(p, WIRE.W_4_SHIFT) - wire(p, WIRE.W_4); - ap.index_is_monotonically_increasing = - ap.index_delta * - (ap.index_delta - Fr.wrap(1)); // deg 2 + ap.index_is_monotonically_increasing = ap.index_delta * (ap.index_delta - Fr.wrap(1)); // deg 2 - ap.adjacent_values_match_if_adjacent_indices_match = - (ap.index_delta * MINUS_ONE + ONE) * - ap.record_delta; // deg 2 + ap.adjacent_values_match_if_adjacent_indices_match = (ap.index_delta * MINUS_ONE + ONE) * ap.record_delta; // deg 2 - evals[14] = - ap.adjacent_values_match_if_adjacent_indices_match * - (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * - (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - evals[15] = - ap.index_is_monotonically_increasing * - (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * - (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + evals[14] = ap.adjacent_values_match_if_adjacent_indices_match * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) + * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + evals[15] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) + * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - ap.ROM_consistency_check_identity = - ap.memory_record_check * - (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 + ap.ROM_consistency_check_identity = ap.memory_record_check * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 /** * Contributions 15,16,17 @@ -1654,22 +1257,13 @@ library RelationsLib { // reverse order we could re-use `ap.partial_record_check` 1 - ((w3' * eta + w2') * eta + w1') * eta // deg 1 or 4 ap.next_gate_access_type = wire(p, WIRE.W_O_SHIFT) * rp.etaThree; - ap.next_gate_access_type = - ap.next_gate_access_type + - (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); - ap.next_gate_access_type = - ap.next_gate_access_type + - (wire(p, WIRE.W_L_SHIFT) * rp.eta); - ap.next_gate_access_type = - wire(p, WIRE.W_4_SHIFT) - - ap.next_gate_access_type; + ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); + ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_L_SHIFT) * rp.eta); + ap.next_gate_access_type = wire(p, WIRE.W_4_SHIFT) - ap.next_gate_access_type; Fr value_delta = wire(p, WIRE.W_O_SHIFT) - wire(p, WIRE.W_O); - ap - .adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = - (ap.index_delta * MINUS_ONE + ONE) * - value_delta * - (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 + ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = + (ap.index_delta * MINUS_ONE + ONE) * value_delta * (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the // next gate would make the identity fail). We need to validate that its 'access type' bool is correct. Can't @@ -1677,28 +1271,15 @@ library RelationsLib { // type is correct, to cover this edge case // deg 2 or 4 ap.next_gate_access_type_is_boolean = - ap.next_gate_access_type * - ap.next_gate_access_type - - ap.next_gate_access_type; + ap.next_gate_access_type * ap.next_gate_access_type - ap.next_gate_access_type; // Putting it all together... - evals[16] = - ap - .adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation * - (wire(p, WIRE.Q_O)) * - (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 - evals[17] = - ap.index_is_monotonically_increasing * - (wire(p, WIRE.Q_O)) * - (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 - evals[18] = - ap.next_gate_access_type_is_boolean * - (wire(p, WIRE.Q_O)) * - (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 - - ap.RAM_consistency_check_identity = - ap.access_check * - (wire(p, WIRE.Q_O)); // deg 3 or 9 + evals[16] = ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation + * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 + evals[17] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 + evals[18] = ap.next_gate_access_type_is_boolean * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 + + ap.RAM_consistency_check_identity = ap.access_check * (wire(p, WIRE.Q_O)); // deg 3 or 9 /** * RAM Timestamp Consistency Check @@ -1712,10 +1293,7 @@ library RelationsLib { * Else timestamp_check = 0 */ ap.timestamp_delta = wire(p, WIRE.W_R_SHIFT) - wire(p, WIRE.W_R); - ap.RAM_timestamp_check_identity = - (ap.index_delta * MINUS_ONE + ONE) * - ap.timestamp_delta - - wire(p, WIRE.W_O); // deg 3 + ap.RAM_timestamp_check_identity = (ap.index_delta * MINUS_ONE + ONE) * ap.timestamp_delta - wire(p, WIRE.W_O); // deg 3 /** * Complete Contribution 12 @@ -1724,21 +1302,12 @@ library RelationsLib { */ ap.memory_identity = ap.ROM_consistency_check_identity; // deg 3 or 6 ap.memory_identity = - ap.memory_identity + - ap.RAM_timestamp_check_identity * - (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 - ap.memory_identity = - ap.memory_identity + - ap.memory_record_check * - (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 - ap.memory_identity = - ap.memory_identity + - ap.RAM_consistency_check_identity; // deg 3 or 9 + ap.memory_identity + ap.RAM_timestamp_check_identity * (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 + ap.memory_identity = ap.memory_identity + ap.memory_record_check * (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 + ap.memory_identity = ap.memory_identity + ap.RAM_consistency_check_identity; // deg 3 or 9 // (deg 3 or 9) + (deg 4) + (deg 3) - ap.memory_identity = - ap.memory_identity * - (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 + ap.memory_identity = ap.memory_identity * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 evals[13] = ap.memory_identity; } @@ -1777,56 +1346,28 @@ library RelationsLib { * * */ - ap.limb_subproduct = - wire(p, WIRE.W_L) * - wire(p, WIRE.W_R_SHIFT) + - wire(p, WIRE.W_L_SHIFT) * - wire(p, WIRE.W_R); - ap.non_native_field_gate_2 = (wire(p, WIRE.W_L) * - wire(p, WIRE.W_4) + - wire(p, WIRE.W_R) * - wire(p, WIRE.W_O) - - wire(p, WIRE.W_O_SHIFT)); - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * LIMB_SIZE; - ap.non_native_field_gate_2 = - ap.non_native_field_gate_2 - - wire(p, WIRE.W_4_SHIFT); + ap.limb_subproduct = wire(p, WIRE.W_L) * wire(p, WIRE.W_R_SHIFT) + wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R); ap.non_native_field_gate_2 = - ap.non_native_field_gate_2 + - ap.limb_subproduct; - ap.non_native_field_gate_2 = - ap.non_native_field_gate_2 * - wire(p, WIRE.Q_4); + (wire(p, WIRE.W_L) * wire(p, WIRE.W_4) + wire(p, WIRE.W_R) * wire(p, WIRE.W_O) - wire(p, WIRE.W_O_SHIFT)); + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * LIMB_SIZE; + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 - wire(p, WIRE.W_4_SHIFT); + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 + ap.limb_subproduct; + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * wire(p, WIRE.Q_4); ap.limb_subproduct = ap.limb_subproduct * LIMB_SIZE; - ap.limb_subproduct = - ap.limb_subproduct + - (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); + ap.limb_subproduct = ap.limb_subproduct + (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); ap.non_native_field_gate_1 = ap.limb_subproduct; - ap.non_native_field_gate_1 = - ap.non_native_field_gate_1 - - (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); - ap.non_native_field_gate_1 = - ap.non_native_field_gate_1 * - wire(p, WIRE.Q_O); + ap.non_native_field_gate_1 = ap.non_native_field_gate_1 - (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); + ap.non_native_field_gate_1 = ap.non_native_field_gate_1 * wire(p, WIRE.Q_O); ap.non_native_field_gate_3 = ap.limb_subproduct; - ap.non_native_field_gate_3 = - ap.non_native_field_gate_3 + - wire(p, WIRE.W_4); - ap.non_native_field_gate_3 = - ap.non_native_field_gate_3 - - (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); - ap.non_native_field_gate_3 = - ap.non_native_field_gate_3 * - wire(p, WIRE.Q_M); - - Fr non_native_field_identity = ap.non_native_field_gate_1 + - ap.non_native_field_gate_2 + - ap.non_native_field_gate_3; - non_native_field_identity = - non_native_field_identity * - wire(p, WIRE.Q_R); + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 + wire(p, WIRE.W_4); + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 - (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 * wire(p, WIRE.Q_M); + + Fr non_native_field_identity = + ap.non_native_field_gate_1 + ap.non_native_field_gate_2 + ap.non_native_field_gate_3; + non_native_field_identity = non_native_field_identity * wire(p, WIRE.Q_R); // ((((w2' * 2^14 + w1') * 2^14 + w3) * 2^14 + w2) * 2^14 + w1 - w4) * qm // deg 2 @@ -1854,11 +1395,8 @@ library RelationsLib { ap.limb_accumulator_2 = ap.limb_accumulator_2 - wire(p, WIRE.W_4_SHIFT); ap.limb_accumulator_2 = ap.limb_accumulator_2 * wire(p, WIRE.Q_M); - Fr limb_accumulator_identity = ap.limb_accumulator_1 + - ap.limb_accumulator_2; - limb_accumulator_identity = - limb_accumulator_identity * - wire(p, WIRE.Q_O); // deg 3 + Fr limb_accumulator_identity = ap.limb_accumulator_1 + ap.limb_accumulator_2; + limb_accumulator_identity = limb_accumulator_identity * wire(p, WIRE.Q_O); // deg 3 ap.nnf_identity = non_native_field_identity + limb_accumulator_identity; ap.nnf_identity = ap.nnf_identity * (wire(p, WIRE.Q_NNF) * domainSep); @@ -1918,25 +1456,13 @@ library RelationsLib { ep.v3 = ep.t2 + ep.v4; // u_1 + 3u_2 + 5u_3 + 7u_4 ep.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_EXTERNAL) * domainSep; - evals[20] = - evals[20] + - ep.q_pos_by_scaling * - (ep.v1 - wire(p, WIRE.W_L_SHIFT)); + evals[20] = evals[20] + ep.q_pos_by_scaling * (ep.v1 - wire(p, WIRE.W_L_SHIFT)); - evals[21] = - evals[21] + - ep.q_pos_by_scaling * - (ep.v2 - wire(p, WIRE.W_R_SHIFT)); + evals[21] = evals[21] + ep.q_pos_by_scaling * (ep.v2 - wire(p, WIRE.W_R_SHIFT)); - evals[22] = - evals[22] + - ep.q_pos_by_scaling * - (ep.v3 - wire(p, WIRE.W_O_SHIFT)); + evals[22] = evals[22] + ep.q_pos_by_scaling * (ep.v3 - wire(p, WIRE.W_O_SHIFT)); - evals[23] = - evals[23] + - ep.q_pos_by_scaling * - (ep.v4 - wire(p, WIRE.W_4_SHIFT)); + evals[23] = evals[23] + ep.q_pos_by_scaling * (ep.v4 - wire(p, WIRE.W_4_SHIFT)); } struct PoseidonInternalParams { @@ -1961,18 +1487,10 @@ library RelationsLib { PoseidonInternalParams memory ip; Fr[4] memory INTERNAL_MATRIX_DIAGONAL = [ - FrLib.from( - 0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7 - ), - FrLib.from( - 0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b - ), - FrLib.from( - 0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15 - ), - FrLib.from( - 0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b - ) + FrLib.from(0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7), + FrLib.from(0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b), + FrLib.from(0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15), + FrLib.from(0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b) ]; // add round constants @@ -1990,28 +1508,16 @@ library RelationsLib { ip.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_INTERNAL) * domainSep; ip.v1 = ip.u1 * INTERNAL_MATRIX_DIAGONAL[0] + ip.u_sum; - evals[24] = - evals[24] + - ip.q_pos_by_scaling * - (ip.v1 - wire(p, WIRE.W_L_SHIFT)); + evals[24] = evals[24] + ip.q_pos_by_scaling * (ip.v1 - wire(p, WIRE.W_L_SHIFT)); ip.v2 = ip.u2 * INTERNAL_MATRIX_DIAGONAL[1] + ip.u_sum; - evals[25] = - evals[25] + - ip.q_pos_by_scaling * - (ip.v2 - wire(p, WIRE.W_R_SHIFT)); + evals[25] = evals[25] + ip.q_pos_by_scaling * (ip.v2 - wire(p, WIRE.W_R_SHIFT)); ip.v3 = ip.u3 * INTERNAL_MATRIX_DIAGONAL[2] + ip.u_sum; - evals[26] = - evals[26] + - ip.q_pos_by_scaling * - (ip.v3 - wire(p, WIRE.W_O_SHIFT)); + evals[26] = evals[26] + ip.q_pos_by_scaling * (ip.v3 - wire(p, WIRE.W_O_SHIFT)); ip.v4 = ip.u4 * INTERNAL_MATRIX_DIAGONAL[3] + ip.u_sum; - evals[27] = - evals[27] + - ip.q_pos_by_scaling * - (ip.v4 - wire(p, WIRE.W_4_SHIFT)); + evals[27] = evals[27] + ip.q_pos_by_scaling * (ip.v4 - wire(p, WIRE.W_4_SHIFT)); } function scaleAndBatchSubrelations( @@ -2021,10 +1527,7 @@ library RelationsLib { accumulator = evaluations[0]; for (uint256 i = 1; i < NUMBER_OF_SUBRELATIONS; ++i) { - accumulator = - accumulator + - evaluations[i] * - subrelationChallenges[i - 1]; + accumulator = accumulator + evaluations[i] * subrelationChallenges[i - 1]; } } } @@ -2060,10 +1563,7 @@ library CommitmentSchemeLib { Fr[] foldPosEvaluations; } - function computeSquares( - Fr r, - uint256 logN - ) internal pure returns (Fr[] memory) { + function computeSquares(Fr r, uint256 logN) internal pure returns (Fr[] memory) { Fr[] memory squares = new Fr[](logN); squares[0] = r; for (uint256 i = 1; i < logN; ++i) { @@ -2085,15 +1585,12 @@ library CommitmentSchemeLib { Fr challengePower = geminiEvalChallengePowers[i - 1]; Fr u = sumcheckUChallenges[i - 1]; - Fr batchedEvalRoundAcc = ((challengePower * - batchedEvalAccumulator * - Fr.wrap(2)) - - geminiEvaluations[i - 1] * - (challengePower * (ONE - u) - u)); + Fr batchedEvalRoundAcc = ( + (challengePower * batchedEvalAccumulator * Fr.wrap(2)) + - geminiEvaluations[i - 1] * (challengePower * (ONE - u) - u) + ); // Divide by the denominator - batchedEvalRoundAcc = - batchedEvalRoundAcc * - (challengePower * (ONE - u) + u).invert(); + batchedEvalRoundAcc = batchedEvalRoundAcc * (challengePower * (ONE - u) + u).invert(); batchedEvalAccumulator = batchedEvalRoundAcc; foldPosEvaluations[i - 1] = batchedEvalRoundAcc; @@ -2124,18 +1621,14 @@ function bytesToFr(bytes calldata proofSection) pure returns (Fr scalar) { } // EC Point utilities -function bytesToG1Point( - bytes calldata proofSection -) pure returns (Honk.G1Point memory point) { +function bytesToG1Point(bytes calldata proofSection) pure returns (Honk.G1Point memory point) { point = Honk.G1Point({ x: uint256(bytes32(proofSection[0x00:0x20])) % Q, y: uint256(bytes32(proofSection[0x20:0x40])) % Q }); } -function negateInplace( - Honk.G1Point memory point -) pure returns (Honk.G1Point memory) { +function negateInplace(Honk.G1Point memory point) pure returns (Honk.G1Point memory) { point.y = (Q - point.y) % Q; return point; } @@ -2152,9 +1645,10 @@ function negateInplace( * @return lhs * @return rhs */ -function convertPairingPointsToG1( - Fr[PAIRING_POINTS_SIZE] memory pairingPoints -) pure returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) { +function convertPairingPointsToG1(Fr[PAIRING_POINTS_SIZE] memory pairingPoints) + pure + returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) +{ uint256 lhsX = Fr.unwrap(pairingPoints[0]); lhsX |= Fr.unwrap(pairingPoints[1]) << 68; lhsX |= Fr.unwrap(pairingPoints[2]) << 136; @@ -2198,10 +1692,7 @@ function generateRecursionSeparator( // hash the accum X // hash the accum Y - ( - Honk.G1Point memory proofLhs, - Honk.G1Point memory proofRhs - ) = convertPairingPointsToG1(proofPairingPoints); + (Honk.G1Point memory proofLhs, Honk.G1Point memory proofRhs) = convertPairingPointsToG1(proofPairingPoints); uint256[8] memory recursionSeparatorElements; @@ -2217,9 +1708,7 @@ function generateRecursionSeparator( recursionSeparatorElements[6] = accRhs.x; recursionSeparatorElements[7] = accRhs.y; - recursionSeparator = FrLib.fromBytes32( - keccak256(abi.encodePacked(recursionSeparatorElements)) - ); + recursionSeparator = FrLib.fromBytes32(keccak256(abi.encodePacked(recursionSeparatorElements))); } /** @@ -2231,11 +1720,10 @@ function generateRecursionSeparator( * @param recursionSeperator The separator to use for the multiplication. * @return `(recursionSeperator * basePoint) + other`. */ -function mulWithSeperator( - Honk.G1Point memory basePoint, - Honk.G1Point memory other, - Fr recursionSeperator -) view returns (Honk.G1Point memory) { +function mulWithSeperator(Honk.G1Point memory basePoint, Honk.G1Point memory other, Fr recursionSeperator) + view + returns (Honk.G1Point memory) +{ Honk.G1Point memory result; result = ecMul(recursionSeperator, basePoint); @@ -2252,10 +1740,7 @@ function mulWithSeperator( * @param point The point to multiply. * @return result The result of the multiplication. */ -function ecMul( - Fr value, - Honk.G1Point memory point -) view returns (Honk.G1Point memory) { +function ecMul(Fr value, Honk.G1Point memory point) view returns (Honk.G1Point memory) { Honk.G1Point memory result; assembly { @@ -2301,10 +1786,7 @@ function ecMul( * @param rhs The right hand side of the addition. * @return result The result of the addition. */ -function ecAdd( - Honk.G1Point memory lhs, - Honk.G1Point memory rhs -) view returns (Honk.G1Point memory) { +function ecAdd(Honk.G1Point memory lhs, Honk.G1Point memory rhs) view returns (Honk.G1Point memory) { Honk.G1Point memory result; assembly { @@ -2328,9 +1810,7 @@ function ecAdd( // Call the ecAdd precompile, it takes in the following // [lhs.x, lhs.y, rhs.x, rhs.y], and returns their addition back into the free memory location. let success := staticcall(gas(), 0x06, free, 0x80, free, 0x40) - if iszero(success) { - revert(0, 0) - } + if iszero(success) { revert(0, 0) } // Copy the result of the addition back into the result memory location. // Memory layout: @@ -2359,41 +1839,22 @@ function validateOnCurve(Honk.G1Point memory point) pure { require(success, "point is not on the curve"); } -function pairing( - Honk.G1Point memory rhs, - Honk.G1Point memory lhs -) view returns (bool decodedResult) { +function pairing(Honk.G1Point memory rhs, Honk.G1Point memory lhs) view returns (bool decodedResult) { bytes memory input = abi.encodePacked( rhs.x, rhs.y, // Fixed G2 point - uint256( - 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2 - ), - uint256( - 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed - ), - uint256( - 0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b - ), - uint256( - 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa - ), + uint256(0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2), + uint256(0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed), + uint256(0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b), + uint256(0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa), lhs.x, lhs.y, // G2 point from VK - uint256( - 0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1 - ), - uint256( - 0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0 - ), - uint256( - 0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4 - ), - uint256( - 0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55 - ) + uint256(0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1), + uint256(0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0), + uint256(0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4), + uint256(0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55) ); (bool success, bytes memory result) = address(0x08).staticcall(input); @@ -2402,6 +1863,9 @@ function pairing( // Field arithmetic libraries - prevent littering the code with modmul / addmul + + + abstract contract BaseZKHonkVerifier is IVerifier { using FrLib for Fr; @@ -2410,12 +1874,7 @@ abstract contract BaseZKHonkVerifier is IVerifier { uint256 immutable $VK_HASH; uint256 immutable $NUM_PUBLIC_INPUTS; - constructor( - uint256 _N, - uint256 _logN, - uint256 _vkHash, - uint256 _numPublicInputs - ) { + constructor(uint256 _N, uint256 _logN, uint256 _vkHash, uint256 _numPublicInputs) { $N = _N; $LOG_N = _logN; $VK_HASH = _vkHash; @@ -2424,11 +1883,7 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Errors error ProofLengthWrong(); - error ProofLengthWrongWithLogN( - uint256 logN, - uint256 actualLength, - uint256 expectedLength - ); + error ProofLengthWrongWithLogN(uint256 logN, uint256 actualLength, uint256 expectedLength); error PublicInputsLengthWrong(); error SumcheckFailed(); error ShpleminiFailed(); @@ -2448,10 +1903,7 @@ abstract contract BaseZKHonkVerifier is IVerifier { proofLength += NUM_ELEMENTS_COMM * 4; // Libra concat, grand sum, quotient comms + Gemini masking // Sumcheck - proofLength += - logN * - ZK_BATCHED_RELATION_PARTIAL_LENGTH * - NUM_ELEMENTS_FR; // sumcheck univariates + proofLength += logN * ZK_BATCHED_RELATION_PARTIAL_LENGTH * NUM_ELEMENTS_FR; // sumcheck univariates proofLength += NUMBER_OF_ENTITIES * NUM_ELEMENTS_FR; // sumcheck evaluations // Libra and Gemini @@ -2471,26 +1923,20 @@ abstract contract BaseZKHonkVerifier is IVerifier { uint256 constant SHIFTED_COMMITMENTS_START = 30; - function loadVerificationKey() - internal - pure - virtual - returns (Honk.VerificationKey memory); + function loadVerificationKey() internal pure virtual returns (Honk.VerificationKey memory); - function verify( - bytes calldata proof, - bytes32[] calldata publicInputs - ) public view override returns (bool verified) { + function verify(bytes calldata proof, bytes32[] calldata publicInputs) + public + view + override + returns (bool verified) + { // Calculate expected proof size based on $LOG_N uint256 expectedProofSize = calculateProofSize($LOG_N); // Check the received proof is the expected size where each field element is 32 bytes if (proof.length != expectedProofSize * 32) { - revert ProofLengthWrongWithLogN( - $LOG_N, - proof.length, - expectedProofSize * 32 - ); + revert ProofLengthWrongWithLogN($LOG_N, proof.length, expectedProofSize * 32); } Honk.VerificationKey memory vk = loadVerificationKey(); @@ -2501,20 +1947,15 @@ abstract contract BaseZKHonkVerifier is IVerifier { } // Generate the fiat shamir challenges for the whole protocol - ZKTranscript memory t = ZKTranscriptLib.generateTranscript( - p, - publicInputs, - $VK_HASH, - $NUM_PUBLIC_INPUTS, - $LOG_N - ); + ZKTranscript memory t = + ZKTranscriptLib.generateTranscript(p, publicInputs, $VK_HASH, $NUM_PUBLIC_INPUTS, $LOG_N); // Derive public input delta t.relationParameters.publicInputsDelta = computePublicInputDelta( publicInputs, p.pairingPointObject, t.relationParameters.beta, - t.relationParameters.gamma /*pubInputsOffset=*/, + t.relationParameters.gamma, /*pubInputsOffset=*/ 1 ); @@ -2538,16 +1979,11 @@ abstract contract BaseZKHonkVerifier is IVerifier { Fr numerator = Fr.wrap(1); Fr denominator = Fr.wrap(1); - Fr numeratorAcc = gamma + - (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); + Fr numeratorAcc = gamma + (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); Fr denominatorAcc = gamma - (beta * FrLib.from(offset + 1)); { - for ( - uint256 i = 0; - i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; - i++ - ) { + for (uint256 i = 0; i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; i++) { Fr pubInput = FrLib.fromBytes32(publicInputs[i]); numerator = numerator * (numeratorAcc + pubInput); @@ -2572,40 +2008,27 @@ abstract contract BaseZKHonkVerifier is IVerifier { publicInputDelta = FrLib.div(numerator, denominator); } - function verifySumcheck( - Honk.ZKProof memory proof, - ZKTranscript memory tp - ) internal view returns (bool verified) { + function verifySumcheck(Honk.ZKProof memory proof, ZKTranscript memory tp) internal view returns (bool verified) { Fr roundTargetSum = tp.libraChallenge * proof.libraSum; // default 0 Fr powPartialEvaluation = Fr.wrap(1); // We perform sumcheck reductions over log n rounds ( the multivariate degree ) for (uint256 round; round < $LOG_N; ++round) { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] - memory roundUnivariate = proof.sumcheckUnivariates[round]; + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariate = proof.sumcheckUnivariates[round]; Fr totalSum = roundUnivariate[0] + roundUnivariate[1]; if (totalSum != roundTargetSum) revert SumcheckFailed(); Fr roundChallenge = tp.sumCheckUChallenges[round]; // Update the round target for the next rounf - roundTargetSum = computeNextTargetSum( - roundUnivariate, - roundChallenge - ); + roundTargetSum = computeNextTargetSum(roundUnivariate, roundChallenge); powPartialEvaluation = - powPartialEvaluation * - (Fr.wrap(1) + - roundChallenge * - (tp.gateChallenges[round] - Fr.wrap(1))); + powPartialEvaluation * (Fr.wrap(1) + roundChallenge * (tp.gateChallenges[round] - Fr.wrap(1))); } // Last round Fr grandHonkRelationSum = RelationsLib.accumulateRelationEvaluations( - proof.sumcheckEvaluations, - tp.relationParameters, - tp.alphas, - powPartialEvaluation + proof.sumcheckEvaluations, tp.relationParameters, tp.alphas, powPartialEvaluation ); Fr evaluation = Fr.wrap(1); @@ -2614,48 +2037,27 @@ abstract contract BaseZKHonkVerifier is IVerifier { } grandHonkRelationSum = - grandHonkRelationSum * - (Fr.wrap(1) - evaluation) + - proof.libraEvaluation * - tp.libraChallenge; + grandHonkRelationSum * (Fr.wrap(1) - evaluation) + proof.libraEvaluation * tp.libraChallenge; verified = (grandHonkRelationSum == roundTargetSum); } // Return the new target sum for the next sumcheck round - function computeNextTargetSum( - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, - Fr roundChallenge - ) internal view returns (Fr targetSum) { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] - memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ - Fr.wrap( - 0x0000000000000000000000000000000000000000000000000000000000009d80 - ), - Fr.wrap( - 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51 - ), - Fr.wrap( - 0x00000000000000000000000000000000000000000000000000000000000005a0 - ), - Fr.wrap( - 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31 - ), - Fr.wrap( - 0x0000000000000000000000000000000000000000000000000000000000000240 - ), - Fr.wrap( - 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31 - ), - Fr.wrap( - 0x00000000000000000000000000000000000000000000000000000000000005a0 - ), - Fr.wrap( - 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51 - ), - Fr.wrap( - 0x0000000000000000000000000000000000000000000000000000000000009d80 - ) - ]; + function computeNextTargetSum(Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, Fr roundChallenge) + internal + view + returns (Fr targetSum) + { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), + Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000000240), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), + Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80) + ]; // To compute the next target sum, we evaluate the given univariate at a point u (challenge). @@ -2668,17 +2070,11 @@ abstract contract BaseZKHonkVerifier is IVerifier { Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory denominatorInverses; for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - denominatorInverses[i] = FrLib.invert( - BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * - (roundChallenge - Fr.wrap(i)) - ); + denominatorInverses[i] = FrLib.invert(BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * (roundChallenge - Fr.wrap(i))); } for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - targetSum = - targetSum + - roundUnivariates[i] * - denominatorInverses[i]; + targetSum = targetSum + roundUnivariates[i] * denominatorInverses[i]; } // Scale the sum by the value of B(x) @@ -2694,67 +2090,56 @@ abstract contract BaseZKHonkVerifier is IVerifier { Honk.G1Point P_1; } - function verifyShplemini( - Honk.ZKProof memory proof, - Honk.VerificationKey memory vk, - ZKTranscript memory tp - ) internal view returns (bool verified) { + function verifyShplemini(Honk.ZKProof memory proof, Honk.VerificationKey memory vk, ZKTranscript memory tp) + internal + view + returns (bool verified) + { CommitmentSchemeLib.ShpleminiIntermediates memory mem; // stack // - Compute vector (r, r², ... , r²⁽ⁿ⁻¹⁾), where n = log_circuit_size - Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib - .computeSquares(tp.geminiR, $LOG_N); + Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib.computeSquares(tp.geminiR, $LOG_N); // Arrays hold values that will be linearly combined for the gemini and shplonk batch openings - Fr[] memory scalars = new Fr[]( - NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3 - ); - Honk.G1Point[] memory commitments = new Honk.G1Point[]( - NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3 - ); + Fr[] memory scalars = new Fr[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); + Honk.G1Point[] memory commitments = new Honk.G1Point[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); - mem.posInvertedDenominator = (tp.shplonkZ - - powers_of_evaluation_challenge[0]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + - powers_of_evaluation_challenge[0]).invert(); + mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[0]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[0]).invert(); - mem.unshiftedScalar = - mem.posInvertedDenominator + - (tp.shplonkNu * mem.negInvertedDenominator); + mem.unshiftedScalar = mem.posInvertedDenominator + (tp.shplonkNu * mem.negInvertedDenominator); mem.shiftedScalar = - tp.geminiR.invert() * - (mem.posInvertedDenominator - - (tp.shplonkNu * mem.negInvertedDenominator)); + tp.geminiR.invert() * (mem.posInvertedDenominator - (tp.shplonkNu * mem.negInvertedDenominator)); scalars[0] = Fr.wrap(1); commitments[0] = proof.shplonkQ; /* Batch multivariate opening claims, shifted and unshifted - * The vector of scalars is populated as follows: - * \f[ - * \left( - * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) - * \right) - * \f] - * - * The following vector is concatenated to the vector of commitments: - * \f[ - * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} - * \f] - * - * Simultaneously, the evaluation of the multilinear polynomial - * \f[ - * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} - * \f] - * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. - * - * This approach minimizes the number of iterations over the commitments to multilinear polynomials - * and eliminates the need to store the powers of \f$ \rho \f$. - */ + * The vector of scalars is populated as follows: + * \f[ + * \left( + * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) + * \right) + * \f] + * + * The following vector is concatenated to the vector of commitments: + * \f[ + * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} + * \f] + * + * Simultaneously, the evaluation of the multilinear polynomial + * \f[ + * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} + * \f] + * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. + * + * This approach minimizes the number of iterations over the commitments to multilinear polynomials + * and eliminates the need to store the powers of \f$ \rho \f$. + */ mem.batchedEvaluation = proof.geminiMaskingEval; mem.batchingChallenge = tp.rho; mem.unshiftedScalarNeg = mem.unshiftedScalar.neg(); @@ -2763,9 +2148,7 @@ abstract contract BaseZKHonkVerifier is IVerifier { scalars[1] = mem.unshiftedScalarNeg; for (uint256 i = 0; i < NUMBER_UNSHIFTED; ++i) { scalars[i + 2] = mem.unshiftedScalarNeg * mem.batchingChallenge; - mem.batchedEvaluation = - mem.batchedEvaluation + - (proof.sumcheckEvaluations[i] * mem.batchingChallenge); + mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[i] * mem.batchingChallenge); mem.batchingChallenge = mem.batchingChallenge * tp.rho; } // g commitments are accumulated at r @@ -2778,13 +2161,9 @@ abstract contract BaseZKHonkVerifier is IVerifier { uint256 scalarOff = i + SHIFTED_COMMITMENTS_START; uint256 evaluationOff = i + NUMBER_UNSHIFTED; - scalars[scalarOff] = - scalars[scalarOff] + - (mem.shiftedScalarNeg * mem.batchingChallenge); + scalars[scalarOff] = scalars[scalarOff] + (mem.shiftedScalarNeg * mem.batchingChallenge); mem.batchedEvaluation = - mem.batchedEvaluation + - (proof.sumcheckEvaluations[evaluationOff] * - mem.batchingChallenge); + mem.batchedEvaluation + (proof.sumcheckEvaluations[evaluationOff] * mem.batchingChallenge); mem.batchingChallenge = mem.batchingChallenge * tp.rho; } @@ -2837,15 +2216,15 @@ abstract contract BaseZKHonkVerifier is IVerifier { * \f[ * \left( \text{com}(A_1), \text{com}(A_2), \ldots, \text{com}(A_{n-1}) \right) * \f] - * to the 'commitments' vector. - * - * 2. Computes the scalars: - * \f[ - * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} - * \f] - * and places them into the 'scalars' vector. - * - * 3. Accumulates the summands of the constant term: + * to the 'commitments' vector. + * + * 2. Computes the scalars: + * \f[ + * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} + * \f] + * and places them into the 'scalars' vector. + * + * 3. Accumulates the summands of the constant term: * \f[ * \sum_{i=2}^{n-1} \frac{\nu^{i} \cdot A_i(-r^{2^i})}{z + r^{2^i}} * \f] @@ -2854,23 +2233,17 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Add contributions from A₀(r) and A₀(-r) to constant_term_accumulator: // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., $LOG_N - 1 - Fr[] memory foldPosEvaluations = CommitmentSchemeLib - .computeFoldPosEvaluations( - tp.sumCheckUChallenges, - mem.batchedEvaluation, - proof.geminiAEvaluations, - powers_of_evaluation_challenge, - $LOG_N - ); + Fr[] memory foldPosEvaluations = CommitmentSchemeLib.computeFoldPosEvaluations( + tp.sumCheckUChallenges, + mem.batchedEvaluation, + proof.geminiAEvaluations, + powers_of_evaluation_challenge, + $LOG_N + ); + mem.constantTermAccumulator = foldPosEvaluations[0] * mem.posInvertedDenominator; mem.constantTermAccumulator = - foldPosEvaluations[0] * - mem.posInvertedDenominator; - mem.constantTermAccumulator = - mem.constantTermAccumulator + - (proof.geminiAEvaluations[0] * - tp.shplonkNu * - mem.negInvertedDenominator); + mem.constantTermAccumulator + (proof.geminiAEvaluations[0] * tp.shplonkNu * mem.negInvertedDenominator); mem.batchingChallenge = tp.shplonkNu.sqr(); uint256 boundary = NUMBER_UNSHIFTED + 2; @@ -2882,40 +2255,22 @@ abstract contract BaseZKHonkVerifier is IVerifier { if (!dummy_round) { // Update inverted denominators - mem.posInvertedDenominator = (tp.shplonkZ - - powers_of_evaluation_challenge[i + 1]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + - powers_of_evaluation_challenge[i + 1]).invert(); + mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[i + 1]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[i + 1]).invert(); // Compute the scalar multipliers for Aₗ(± r^{2ˡ}) and [Aₗ] - mem.scalingFactorPos = - mem.batchingChallenge * - mem.posInvertedDenominator; - mem.scalingFactorNeg = - mem.batchingChallenge * - tp.shplonkNu * - mem.negInvertedDenominator; - scalars[boundary + i] = - mem.scalingFactorNeg.neg() + - mem.scalingFactorPos.neg(); + mem.scalingFactorPos = mem.batchingChallenge * mem.posInvertedDenominator; + mem.scalingFactorNeg = mem.batchingChallenge * tp.shplonkNu * mem.negInvertedDenominator; + scalars[boundary + i] = mem.scalingFactorNeg.neg() + mem.scalingFactorPos.neg(); // Accumulate the const term contribution given by // v^{2l} * Aₗ(r^{2ˡ}) /(z-r^{2^l}) + v^{2l+1} * Aₗ(-r^{2ˡ}) /(z+ r^{2^l}) - Fr accumContribution = mem.scalingFactorNeg * - proof.geminiAEvaluations[i + 1]; - accumContribution = - accumContribution + - mem.scalingFactorPos * - foldPosEvaluations[i + 1]; - mem.constantTermAccumulator = - mem.constantTermAccumulator + - accumContribution; + Fr accumContribution = mem.scalingFactorNeg * proof.geminiAEvaluations[i + 1]; + accumContribution = accumContribution + mem.scalingFactorPos * foldPosEvaluations[i + 1]; + mem.constantTermAccumulator = mem.constantTermAccumulator + accumContribution; } // Update the running power of v - mem.batchingChallenge = - mem.batchingChallenge * - tp.shplonkNu * - tp.shplonkNu; + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; commitments[boundary + i] = proof.geminiFoldComms[i]; } @@ -2924,24 +2279,16 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Finalize the batch opening claim mem.denominators[0] = Fr.wrap(1).div(tp.shplonkZ - tp.geminiR); - mem.denominators[1] = Fr.wrap(1).div( - tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR - ); + mem.denominators[1] = Fr.wrap(1).div(tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR); mem.denominators[2] = mem.denominators[0]; mem.denominators[3] = mem.denominators[0]; - mem.batchingChallenge = - mem.batchingChallenge * - tp.shplonkNu * - tp.shplonkNu; + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; for (uint256 i = 0; i < LIBRA_EVALUATIONS; i++) { Fr scalingFactor = mem.denominators[i] * mem.batchingChallenge; mem.batchingScalars[i] = scalingFactor.neg(); mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu; - mem.constantTermAccumulator = - mem.constantTermAccumulator + - scalingFactor * - proof.libraPolyEvals[i]; + mem.constantTermAccumulator = mem.constantTermAccumulator + scalingFactor * proof.libraPolyEvals[i]; } scalars[boundary] = mem.batchingScalars[0]; scalars[boundary + 1] = mem.batchingScalars[1] + mem.batchingScalars[2]; @@ -2951,17 +2298,10 @@ abstract contract BaseZKHonkVerifier is IVerifier { commitments[boundary++] = proof.libraCommitments[i]; } - commitments[boundary] = Honk.G1Point({ x: 1, y: 2 }); + commitments[boundary] = Honk.G1Point({x: 1, y: 2}); scalars[boundary++] = mem.constantTermAccumulator; - if ( - !checkEvalsConsistency( - proof.libraPolyEvals, - tp.geminiR, - tp.sumCheckUChallenges, - proof.libraEvaluation - ) - ) { + if (!checkEvalsConsistency(proof.libraPolyEvals, tp.geminiR, tp.sumCheckUChallenges, proof.libraEvaluation)) { revert ConsistencyCheckFailed(); } @@ -2975,15 +2315,9 @@ abstract contract BaseZKHonkVerifier is IVerifier { pair.P_1 = negateInplace(quotient_commitment); // Aggregate pairing points - Fr recursionSeparator = generateRecursionSeparator( - proof.pairingPointObject, - pair.P_0, - pair.P_1 - ); - ( - Honk.G1Point memory P_0_other, - Honk.G1Point memory P_1_other - ) = convertPairingPointsToG1(proof.pairingPointObject); + Fr recursionSeparator = generateRecursionSeparator(proof.pairingPointObject, pair.P_0, pair.P_1); + (Honk.G1Point memory P_0_other, Honk.G1Point memory P_1_other) = + convertPairingPointsToG1(proof.pairingPointObject); // Validate the points from the proof are on the curve validateOnCurve(P_0_other); @@ -3023,14 +2357,8 @@ abstract contract BaseZKHonkVerifier is IVerifier { for (uint256 round = 0; round < $LOG_N; round++) { uint256 currIdx = 1 + LIBRA_UNIVARIATES_LENGTH * round; mem.challengePolyLagrange[currIdx] = one; - for ( - uint256 idx = currIdx + 1; - idx < currIdx + LIBRA_UNIVARIATES_LENGTH; - idx++ - ) { - mem.challengePolyLagrange[idx] = - mem.challengePolyLagrange[idx - 1] * - uChallenges[round]; + for (uint256 idx = currIdx + 1; idx < currIdx + LIBRA_UNIVARIATES_LENGTH; idx++) { + mem.challengePolyLagrange[idx] = mem.challengePolyLagrange[idx - 1] * uChallenges[round]; } } @@ -3039,10 +2367,7 @@ abstract contract BaseZKHonkVerifier is IVerifier { for (uint256 idx = 0; idx < SUBGROUP_SIZE; idx++) { mem.denominators[idx] = mem.rootPower * geminiR - one; mem.denominators[idx] = mem.denominators[idx].invert(); - mem.challengePolyEval = - mem.challengePolyEval + - mem.challengePolyLagrange[idx] * - mem.denominators[idx]; + mem.challengePolyEval = mem.challengePolyEval + mem.challengePolyLagrange[idx] * mem.denominators[idx]; mem.rootPower = mem.rootPower * SUBGROUP_GENERATOR_INVERSE; } @@ -3053,28 +2378,20 @@ abstract contract BaseZKHonkVerifier is IVerifier { mem.diff = mem.lagrangeFirst * libraPolyEvals[2]; - mem.diff = - mem.diff + - (geminiR - SUBGROUP_GENERATOR_INVERSE) * - (libraPolyEvals[1] - - libraPolyEvals[2] - - libraPolyEvals[0] * - mem.challengePolyEval); - mem.diff = - mem.diff + - mem.lagrangeLast * - (libraPolyEvals[2] - libraEval) - - vanishingPolyEval * - libraPolyEvals[3]; + mem.diff = mem.diff + + (geminiR - SUBGROUP_GENERATOR_INVERSE) + * (libraPolyEvals[1] - libraPolyEvals[2] - libraPolyEvals[0] * mem.challengePolyEval); + mem.diff = mem.diff + mem.lagrangeLast * (libraPolyEvals[2] - libraEval) - vanishingPolyEval * libraPolyEvals[3]; check = mem.diff == Fr.wrap(0); } // This implementation is the same as above with different constants - function batchMul( - Honk.G1Point[] memory base, - Fr[] memory scalars - ) internal view returns (Honk.G1Point memory result) { + function batchMul(Honk.G1Point[] memory base, Fr[] memory scalars) + internal + view + returns (Honk.G1Point memory result) + { uint256 limit = NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3; // Validate all points are on the curve @@ -3087,9 +2404,7 @@ abstract contract BaseZKHonkVerifier is IVerifier { let free := mload(0x40) let count := 0x01 - for {} lt(count, add(limit, 1)) { - count := add(count, 1) - } { + for {} lt(count, add(limit, 1)) { count := add(count, 1) } { // Get loop offsets let base_base := add(base, mul(count, 0x20)) let scalar_base := add(scalars, mul(count, 0x20)) @@ -3099,22 +2414,9 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Add scalar mstore(add(free, 0x80), mload(scalar_base)) - success := and( - success, - staticcall( - gas(), - 7, - add(free, 0x40), - 0x60, - add(free, 0x40), - 0x40 - ) - ) + success := and(success, staticcall(gas(), 7, add(free, 0x40), 0x60, add(free, 0x40), 0x40)) // accumulator = accumulator + accumulator_2 - success := and( - success, - staticcall(gas(), 6, free, 0x80, free, 0x40) - ) + success := and(success, staticcall(gas(), 6, free, 0x80, free, 0x40)) } // Return the result @@ -3126,15 +2428,8 @@ abstract contract BaseZKHonkVerifier is IVerifier { } } -contract DkgPkVerifier is - BaseZKHonkVerifier(N, LOG_N, VK_HASH, NUMBER_OF_PUBLIC_INPUTS) -{ - function loadVerificationKey() - internal - pure - override - returns (Honk.VerificationKey memory) - { - return HonkVerificationKey.loadVerificationKey(); +contract DkgPkVerifier is BaseZKHonkVerifier(N, LOG_N, VK_HASH, NUMBER_OF_PUBLIC_INPUTS) { + function loadVerificationKey() internal pure override returns (Honk.VerificationKey memory) { + return HonkVerificationKey.loadVerificationKey(); } } From 7ae9a4d23b7e887403ccf1aab0265f161f940144 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Tue, 17 Feb 2026 23:15:38 +0500 Subject: [PATCH 12/32] feat: use compiled circuits for test --- .github/workflows/ci.yml | 113 +- crates/tests/tests/integration.rs | 20 +- crates/zk-prover/tests/common/helpers.rs | 253 +-- .../decrypted_shares_aggregation_bn.json | 1 - .../decrypted_shares_aggregation_bn.vk | Bin 1888 -> 0 bytes .../decrypted_shares_aggregation_mod.json | 1 - .../decrypted_shares_aggregation_mod.vk | Bin 1888 -> 0 bytes .../fixtures/e_sm_share_computation.json | 1 - .../tests/fixtures/e_sm_share_computation.vk | Bin 1888 -> 0 bytes crates/zk-prover/tests/fixtures/pk.json | 1 - crates/zk-prover/tests/fixtures/pk.vk | Bin 1888 -> 0 bytes .../tests/fixtures/pk_aggregation.json | 1 - .../tests/fixtures/pk_aggregation.vk | Bin 1888 -> 0 bytes .../tests/fixtures/pk_generation.json | 1 - .../zk-prover/tests/fixtures/pk_generation.vk | Bin 1888 -> 0 bytes .../tests/fixtures/share_decryption.json | 1 - .../tests/fixtures/share_decryption.vk | Bin 1888 -> 0 bytes .../tests/fixtures/share_encryption.json | 1 - .../tests/fixtures/share_encryption.vk | Bin 1888 -> 0 bytes .../tests/fixtures/sk_share_computation.json | 1 - .../tests/fixtures/sk_share_computation.vk | Bin 1888 -> 0 bytes .../tests/fixtures/user_data_encryption.json | 1 - .../tests/fixtures/user_data_encryption.vk | Bin 1888 -> 0 bytes crates/zk-prover/tests/local_e2e_tests.rs | 49 +- .../tests/onchain_verification_tests.rs | 4 +- crates/zk-prover/tests/witness_tests.rs | 12 - .../contracts/verifier/DkgPkVerifier.sol | 1635 ++++++++++++----- scripts/build-circuits.ts | 34 +- scripts/generate-verifiers.ts | 31 + 29 files changed, 1447 insertions(+), 714 deletions(-) delete mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.json delete mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.vk delete mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json delete mode 100644 crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.vk delete mode 100644 crates/zk-prover/tests/fixtures/e_sm_share_computation.json delete mode 100644 crates/zk-prover/tests/fixtures/e_sm_share_computation.vk delete mode 100644 crates/zk-prover/tests/fixtures/pk.json delete mode 100644 crates/zk-prover/tests/fixtures/pk.vk delete mode 100644 crates/zk-prover/tests/fixtures/pk_aggregation.json delete mode 100644 crates/zk-prover/tests/fixtures/pk_aggregation.vk delete mode 100644 crates/zk-prover/tests/fixtures/pk_generation.json delete mode 100644 crates/zk-prover/tests/fixtures/pk_generation.vk delete mode 100644 crates/zk-prover/tests/fixtures/share_decryption.json delete mode 100644 crates/zk-prover/tests/fixtures/share_decryption.vk delete mode 100644 crates/zk-prover/tests/fixtures/share_encryption.json delete mode 100644 crates/zk-prover/tests/fixtures/share_encryption.vk delete mode 100644 crates/zk-prover/tests/fixtures/sk_share_computation.json delete mode 100644 crates/zk-prover/tests/fixtures/sk_share_computation.vk delete mode 100644 crates/zk-prover/tests/fixtures/user_data_encryption.json delete mode 100644 crates/zk-prover/tests/fixtures/user_data_encryption.vk diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3dbe36e654..571a05fc30 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -32,7 +32,7 @@ permissions: packages: write jobs: - rust_unit: + rust_tests: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -75,46 +75,6 @@ jobs: - name: Run Unit Tests run: 'cargo test --lib && cargo test --doc' - rust_integration: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - - name: Cache Rust dependencies - uses: ./.github/actions/cache-dependencies - - - name: Install Rust - uses: dtolnay/rust-toolchain@stable - with: - toolchain: ${{ env.RUST_TOOLCHAIN }} - - # We must install foundry in order to be able to test anvil - - name: Install Foundry - uses: foundry-rs/foundry-toolchain@v1 - - - name: Install solc - run: | - sudo add-apt-repository ppa:ethereum/ethereum \ - && sudo apt-get update -y \ - && sudo apt-get install -y solc - - - name: pnpm-setup - uses: pnpm/action-setup@v4 - - # We need to setup node in order to compile the hardhat contracts to get the artifacts - - name: 'Setup node' - uses: actions/setup-node@v4 - with: - node-version: ${{ env.NODE_VERSION }} - cache: 'pnpm' - cache-dependency-path: pnpm-lock.yaml - - - name: 'Install the dependencies' - run: 'pnpm install --frozen-lockfile' - - - name: Checking code format rust - run: pnpm rust:lint - - name: Run Integration Tests run: 'cargo test --test integration -- --nocapture' @@ -310,14 +270,6 @@ jobs: - name: 'Install the dependencies' run: 'pnpm install --frozen-lockfile' - - name: 'Lint the code' - run: 'pnpm lint' - - - name: 'Add lint summary' - run: | - echo "## Lint results" >> $GITHUB_STEP_SUMMARY - echo "✅ Passed" >> $GITHUB_STEP_SUMMARY - - name: 'Run prebuild' run: 'pnpm test:integration prebuild' @@ -611,7 +563,7 @@ jobs: path: ./examples/CRISP/playwright-report/ retention-days: 30 - test_enclave_circuits: + build_and_test_circuits: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -629,13 +581,66 @@ jobs: - name: Test Noir circuits run: ./scripts/test-circuits.sh - - name: Upload circuit artifacts + - name: pnpm-setup + uses: pnpm/action-setup@v4 + + - name: Setup node + uses: actions/setup-node@v4 + with: + node-version: ${{ env.NODE_VERSION }} + cache: 'pnpm' + cache-dependency-path: pnpm-lock.yaml + + - name: Install dependencies + run: pnpm install --frozen-lockfile + + - name: Build circuits + run: pnpm build:circuits + + - name: Upload compiled circuit artifacts uses: actions/upload-artifact@v4 with: - name: circuit-artifacts - path: circuits/target/ + name: compiled-circuits + path: | + circuits/bin/dkg/target/ + circuits/bin/threshold/target/ retention-days: 1 - if-no-files-found: warn + if-no-files-found: error + + zk_prover_e2e: + runs-on: ubuntu-latest + needs: [build_and_test_circuits] + steps: + - uses: actions/checkout@v4 + + - name: Cache Rust dependencies + uses: ./.github/actions/cache-dependencies + + - name: Install Rust + uses: dtolnay/rust-toolchain@stable + with: + toolchain: ${{ env.RUST_TOOLCHAIN }} + + - name: Install Nargo + uses: noir-lang/noirup@v0.1.4 + with: + toolchain: ${{ env.NOIR_TOOLCHAIN }} + + - name: Download compiled circuit artifacts + uses: actions/download-artifact@v4 + with: + name: compiled-circuits + path: circuits/bin/ + + - name: Verify circuit artifacts + run: | + echo "DKG circuits:" + ls -la circuits/bin/dkg/target/*.json circuits/bin/dkg/target/*.vk + echo "Threshold circuits:" + ls -la circuits/bin/threshold/target/*.json circuits/bin/threshold/target/*.vk + + - name: Run ZK prover e2e tests + run: cargo test -p e3-zk-prover --test local_e2e_tests -- --nocapture build_e3_support_dev: runs-on: ubuntu-latest diff --git a/crates/tests/tests/integration.rs b/crates/tests/tests/integration.rs index f3078e5154..4414c02fb5 100644 --- a/crates/tests/tests/integration.rs +++ b/crates/tests/tests/integration.rs @@ -94,20 +94,21 @@ async fn setup_test_zk_backend() -> (ZkBackend, tempfile::TempDir) { #[cfg(not(unix))] compile_error!("Integration tests require unix symlink support"); - // Copy circuit fixtures from the zk-prover crate's test fixtures - let fixtures_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + // Copy circuit artifacts from the compiled circuit build output + let circuits_build_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")) .join("..") - .join("zk-prover") - .join("tests") - .join("fixtures"); + .join("..") + .join("circuits") + .join("bin"); // Copy T0 (pk) circuit let pk_circuit_dir = circuits_dir.join("dkg").join("pk"); tokio::fs::create_dir_all(&pk_circuit_dir).await.unwrap(); - tokio::fs::copy(fixtures_dir.join("pk.json"), pk_circuit_dir.join("pk.json")) + let dkg_target = circuits_build_root.join("dkg").join("target"); + tokio::fs::copy(dkg_target.join("pk.json"), pk_circuit_dir.join("pk.json")) .await .unwrap(); - tokio::fs::copy(fixtures_dir.join("pk.vk"), pk_circuit_dir.join("pk.vk")) + tokio::fs::copy(dkg_target.join("pk.vk"), pk_circuit_dir.join("pk.vk")) .await .unwrap(); @@ -116,14 +117,15 @@ async fn setup_test_zk_backend() -> (ZkBackend, tempfile::TempDir) { tokio::fs::create_dir_all(&pk_gen_circuit_dir) .await .unwrap(); + let threshold_target = circuits_build_root.join("threshold").join("target"); tokio::fs::copy( - fixtures_dir.join("pk_generation.json"), + threshold_target.join("pk_generation.json"), pk_gen_circuit_dir.join("pk_generation.json"), ) .await .unwrap(); tokio::fs::copy( - fixtures_dir.join("pk_generation.vk"), + threshold_target.join("pk_generation.vk"), pk_gen_circuit_dir.join("pk_generation.vk"), ) .await diff --git a/crates/zk-prover/tests/common/helpers.rs b/crates/zk-prover/tests/common/helpers.rs index 6083a727db..d16606195f 100644 --- a/crates/zk-prover/tests/common/helpers.rs +++ b/crates/zk-prover/tests/common/helpers.rs @@ -1,126 +1,127 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. - -use super::fixtures_dir; -use e3_config::BBPath; -use e3_zk_prover::{ZkBackend, ZkConfig}; -use std::path::PathBuf; -use tempfile::TempDir; -use tokio::{fs, process::Command}; - -/// Returns `None` when bb is not found — tests should skip gracefully. -pub async fn find_bb() -> Option { - if let Ok(output) = Command::new("which").arg("bb").output().await { - if output.status.success() { - let path = String::from_utf8_lossy(&output.stdout).trim().to_string(); - if !path.is_empty() { - return Some(PathBuf::from(path)); - } - } - } - if let Ok(home) = std::env::var("HOME") { - for path in [ - format!("{}/.bb/bb", home), - format!("{}/.nargo/bin/bb", home), - format!("{}/.enclave/noir/bin/bb", home), - ] { - if std::path::Path::new(&path).exists() { - return Some(PathBuf::from(path)); - } - } - } - None -} - -pub async fn find_anvil() -> bool { - if let Ok(output) = Command::new("which").arg("anvil").output().await { - if output.status.success() { - return true; - } - } - if let Ok(home) = std::env::var("HOME") { - let path = format!("{}/.foundry/bin/anvil", home); - if std::path::Path::new(&path).exists() { - return true; - } - } - false -} - -/// Creates a temp ZkBackend with the real bb binary symlinked in. -/// Caller must hold onto the returned TempDir or it gets cleaned up. -pub async fn setup_test_prover(bb: &PathBuf) -> (ZkBackend, TempDir) { - let target_tmp = env!("CARGO_TARGET_TMPDIR"); - let temp = TempDir::new_in(target_tmp).unwrap(); - - let temp_path = temp.path(); - let noir_dir = temp_path.join("noir"); - let bb_binary = BBPath::Default(noir_dir.join("bin").join("bb")); - let circuits_dir = noir_dir.join("circuits"); - let work_dir = noir_dir.join("work").join("test_node"); - let backend = ZkBackend::new( - bb_binary.clone(), - circuits_dir.clone(), - work_dir.clone(), - ZkConfig::default(), - ); - - fs::create_dir_all(&backend.circuits_dir).await.unwrap(); - fs::create_dir_all(backend.circuits_dir.join("vk")) - .await - .unwrap(); - fs::create_dir_all(&backend.work_dir).await.unwrap(); - fs::create_dir_all(backend.base_dir.join("bin")) - .await - .unwrap(); - - #[cfg(unix)] - std::os::unix::fs::symlink(bb, &backend.bb_binary).unwrap(); - - (backend, temp) -} - -/// Copies .json and .vk fixtures into the backend circuits layout. -/// Panics if fixtures are missing — run `pnpm sync:fixtures` to populate. -pub async fn setup_circuit_fixtures( - backend: &ZkBackend, - circuit_path: &[&str], - fixture_name: &str, -) { - let fixtures = fixtures_dir(); - let json_path = fixtures.join(format!("{fixture_name}.json")); - let vk_path = fixtures.join(format!("{fixture_name}.vk")); - assert!( - json_path.exists(), - "missing circuit fixture: {} (run `pnpm sync:fixtures` to copy from circuits target)", - json_path.display() - ); - assert!( - vk_path.exists(), - "missing verification key fixture: {}", - vk_path.display() - ); - - let circuit_dir = circuit_path - .iter() - .fold(backend.circuits_dir.clone(), |p, seg| p.join(seg)); - fs::create_dir_all(&circuit_dir).await.unwrap(); - fs::copy(json_path, circuit_dir.join(format!("{fixture_name}.json"))) - .await - .unwrap(); - fs::copy(vk_path, circuit_dir.join(format!("{fixture_name}.vk"))) - .await - .unwrap(); -} - -/// Lightweight backend for tests that don't need a real bb binary. -pub fn test_backend(temp_path: &std::path::Path, config: ZkConfig) -> ZkBackend { - let noir_dir = temp_path.join("noir"); - let bb_binary = BBPath::Default(noir_dir.join("bin").join("bb")); - let circuits_dir = noir_dir.join("circuits"); - let work_dir = noir_dir.join("work").join("test_node"); - ZkBackend::new(bb_binary, circuits_dir, work_dir, config) -} +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +use e3_config::BBPath; +use e3_zk_prover::{ZkBackend, ZkConfig}; +use std::path::PathBuf; +use tempfile::TempDir; +use tokio::{fs, process::Command}; + +/// Returns `None` when bb is not found — tests should skip gracefully. +pub async fn find_bb() -> Option { + if let Ok(output) = Command::new("which").arg("bb").output().await { + if output.status.success() { + let path = String::from_utf8_lossy(&output.stdout).trim().to_string(); + if !path.is_empty() { + return Some(PathBuf::from(path)); + } + } + } + if let Ok(home) = std::env::var("HOME") { + for path in [ + format!("{}/.bb/bb", home), + format!("{}/.nargo/bin/bb", home), + format!("{}/.enclave/noir/bin/bb", home), + ] { + if std::path::Path::new(&path).exists() { + return Some(PathBuf::from(path)); + } + } + } + None +} + +/// Root of the compiled circuit artifacts: `{workspace}/circuits/bin/`. +fn circuits_build_root() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("..") + .join("..") + .join("circuits") + .join("bin") +} + +pub async fn setup_compiled_circuit(backend: &ZkBackend, group: &str, circuit_name: &str) { + let target_dir = circuits_build_root().join(group).join("target"); + let json_path = target_dir.join(format!("{circuit_name}.json")); + let vk_path = target_dir.join(format!("{circuit_name}.vk")); + + assert!( + json_path.exists(), + "compiled circuit not found: {} (run `pnpm build:circuits` to compile)", + json_path.display() + ); + assert!( + vk_path.exists(), + "verification key not found: {} (run `pnpm build:circuits` to compile)", + vk_path.display() + ); + + let circuit_dir = backend.circuits_dir.join(group).join(circuit_name); + fs::create_dir_all(&circuit_dir).await.unwrap(); + fs::copy(&json_path, circuit_dir.join(format!("{circuit_name}.json"))) + .await + .unwrap(); + fs::copy(&vk_path, circuit_dir.join(format!("{circuit_name}.vk"))) + .await + .unwrap(); +} + +pub async fn find_anvil() -> bool { + if let Ok(output) = Command::new("which").arg("anvil").output().await { + if output.status.success() { + return true; + } + } + if let Ok(home) = std::env::var("HOME") { + let path = format!("{}/.foundry/bin/anvil", home); + if std::path::Path::new(&path).exists() { + return true; + } + } + false +} + +/// Creates a temp ZkBackend with the real bb binary symlinked in. +/// Caller must hold onto the returned TempDir or it gets cleaned up. +pub async fn setup_test_prover(bb: &PathBuf) -> (ZkBackend, TempDir) { + let target_tmp = env!("CARGO_TARGET_TMPDIR"); + let temp = TempDir::new_in(target_tmp).unwrap(); + + let temp_path = temp.path(); + let noir_dir = temp_path.join("noir"); + let bb_binary = BBPath::Default(noir_dir.join("bin").join("bb")); + let circuits_dir = noir_dir.join("circuits"); + let work_dir = noir_dir.join("work").join("test_node"); + let backend = ZkBackend::new( + bb_binary.clone(), + circuits_dir.clone(), + work_dir.clone(), + ZkConfig::default(), + ); + + fs::create_dir_all(&backend.circuits_dir).await.unwrap(); + fs::create_dir_all(backend.circuits_dir.join("vk")) + .await + .unwrap(); + fs::create_dir_all(&backend.work_dir).await.unwrap(); + fs::create_dir_all(backend.base_dir.join("bin")) + .await + .unwrap(); + + #[cfg(unix)] + std::os::unix::fs::symlink(bb, &backend.bb_binary).unwrap(); + + (backend, temp) +} + +/// Lightweight backend for tests that don't need a real bb binary. +pub fn test_backend(temp_path: &std::path::Path, config: ZkConfig) -> ZkBackend { + let noir_dir = temp_path.join("noir"); + let bb_binary = BBPath::Default(noir_dir.join("bin").join("bb")); + let circuits_dir = noir_dir.join("circuits"); + let work_dir = noir_dir.join("work").join("test_node"); + ZkBackend::new(bb_binary, circuits_dir, work_dir, config) +} diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.json b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.json deleted file mode 100644 index e34df9a977..0000000000 --- a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.json +++ /dev/null @@ -1 +0,0 @@ -{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"14440306795590429775","abi":{"parameters":[{"name":"decryption_shares","type":{"kind":"array","length":3,"type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]}}},"visibility":"public"},{"name":"party_ids","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"public"},{"name":"message","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]},"visibility":"public"},{"name":"u_global","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"crt_quotients","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":null,"error_types":{"361444214588792908":{"error_kind":"string","string":"attempt to multiply with overflow"},"991688543994151927":{"error_kind":"string","string":"Division verification failed: result * rhs ≠ lhs (mod m)"},"1998584279744703196":{"error_kind":"string","string":"attempt to subtract with overflow"},"3301098964710512891":{"error_kind":"fmtstring","length":56,"item_types":[]},"6347439466827421235":{"error_kind":"string","string":"CRT reconstruction verification failed"},"9125450380484214683":{"error_kind":"string","string":"validate_gt fail"},"11084314168516775404":{"error_kind":"string","string":"assert_is_not_zero_integer fail"},"12469291177396340830":{"error_kind":"string","string":"call to assert_max_bit_size"},"14990209321349310352":{"error_kind":"string","string":"attempt to add with overflow"},"15764276373176857197":{"error_kind":"string","string":"Stack too deep"},"16431471497789672479":{"error_kind":"string","string":"Index out of bounds"}}},"bytecode":"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","debug_symbols":"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","file_map":{"3":{"source":"use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str {}\n}\n\nimpl From> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n","path":"std/array/mod.nr"},"5":{"source":"use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let self_len = self.len();\n let other_len = other.len();\n let min_len = if self_len < other_len {\n self_len\n } else {\n other_len\n };\n\n let mut result = Ordering::equal();\n for i in 0..min_len {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n\n if result != Ordering::equal() {\n result\n } else {\n self_len.cmp(other_len)\n }\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min, Ord};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n\n #[test]\n fn lexicographic_ordering_for_slices() {\n assert(&[2_u32].cmp(&[1_u32, 1_u32, 1_u32]) == super::Ordering::greater());\n assert(&[1_u32, 2_u32].cmp(&[1_u32, 2_u32, 3_u32]) == super::Ordering::less());\n }\n}\n","path":"std/cmp.nr"},"17":{"source":"use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n\n #[test]\n fn check_decompose_edge_cases() {\n assert_eq(decompose(0), (0, 0));\n assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n }\n\n #[test]\n fn check_decompose_large_values() {\n let large_field = 0xffffffffffffffff;\n let (lo, hi) = decompose(large_field);\n assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n let large_value = large_field - TWO_POW_128;\n let (lo2, hi2) = decompose(large_value);\n assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n }\n\n #[test]\n fn check_lt_comprehensive() {\n assert(lt(0, 1));\n assert(!lt(1, 0));\n assert(!lt(0, 0));\n assert(!lt(42, 42));\n\n assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n }\n}\n","path":"std/field/bn254.nr"},"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"39":{"source":"use crate::convert::AsPrimitive;\n\n// docs:start:add-trait\npub trait Add {\n fn add(self, other: Self) -> Self;\n}\n// docs:end:add-trait\n\nimpl Add for Field {\n fn add(self, other: Field) -> Field {\n self + other\n }\n}\n\nimpl Add for u128 {\n fn add(self, other: u128) -> u128 {\n self + other\n }\n}\nimpl Add for u64 {\n fn add(self, other: u64) -> u64 {\n self + other\n }\n}\nimpl Add for u32 {\n fn add(self, other: u32) -> u32 {\n self + other\n }\n}\nimpl Add for u16 {\n fn add(self, other: u16) -> u16 {\n self + other\n }\n}\nimpl Add for u8 {\n fn add(self, other: u8) -> u8 {\n self + other\n }\n}\nimpl Add for u1 {\n fn add(self, other: u1) -> u1 {\n self + other\n }\n}\n\nimpl Add for i8 {\n fn add(self, other: i8) -> i8 {\n self + other\n }\n}\nimpl Add for i16 {\n fn add(self, other: i16) -> i16 {\n self + other\n }\n}\nimpl Add for i32 {\n fn add(self, other: i32) -> i32 {\n self + other\n }\n}\nimpl Add for i64 {\n fn add(self, other: i64) -> i64 {\n self + other\n }\n}\n\n// docs:start:sub-trait\npub trait Sub {\n fn sub(self, other: Self) -> Self;\n}\n// docs:end:sub-trait\n\nimpl Sub for Field {\n fn sub(self, other: Field) -> Field {\n self - other\n }\n}\n\nimpl Sub for u128 {\n fn sub(self, other: u128) -> u128 {\n self - other\n }\n}\nimpl Sub for u64 {\n fn sub(self, other: u64) -> u64 {\n self - other\n }\n}\nimpl Sub for u32 {\n fn sub(self, other: u32) -> u32 {\n self - other\n }\n}\nimpl Sub for u16 {\n fn sub(self, other: u16) -> u16 {\n self - other\n }\n}\nimpl Sub for u8 {\n fn sub(self, other: u8) -> u8 {\n self - other\n }\n}\nimpl Sub for u1 {\n fn sub(self, other: u1) -> u1 {\n self - other\n }\n}\n\nimpl Sub for i8 {\n fn sub(self, other: i8) -> i8 {\n self - other\n }\n}\nimpl Sub for i16 {\n fn sub(self, other: i16) -> i16 {\n self - other\n }\n}\nimpl Sub for i32 {\n fn sub(self, other: i32) -> i32 {\n self - other\n }\n}\nimpl Sub for i64 {\n fn sub(self, other: i64) -> i64 {\n self - other\n }\n}\n\n// docs:start:mul-trait\npub trait Mul {\n fn mul(self, other: Self) -> Self;\n}\n// docs:end:mul-trait\n\nimpl Mul for Field {\n fn mul(self, other: Field) -> Field {\n self * other\n }\n}\n\nimpl Mul for u128 {\n fn mul(self, other: u128) -> u128 {\n self * other\n }\n}\nimpl Mul for u64 {\n fn mul(self, other: u64) -> u64 {\n self * other\n }\n}\nimpl Mul for u32 {\n fn mul(self, other: u32) -> u32 {\n self * other\n }\n}\nimpl Mul for u16 {\n fn mul(self, other: u16) -> u16 {\n self * other\n }\n}\nimpl Mul for u8 {\n fn mul(self, other: u8) -> u8 {\n self * other\n }\n}\nimpl Mul for u1 {\n fn mul(self, other: u1) -> u1 {\n self * other\n }\n}\n\nimpl Mul for i8 {\n fn mul(self, other: i8) -> i8 {\n self * other\n }\n}\nimpl Mul for i16 {\n fn mul(self, other: i16) -> i16 {\n self * other\n }\n}\nimpl Mul for i32 {\n fn mul(self, other: i32) -> i32 {\n self * other\n }\n}\nimpl Mul for i64 {\n fn mul(self, other: i64) -> i64 {\n self * other\n }\n}\n\n// docs:start:div-trait\npub trait Div {\n fn div(self, other: Self) -> Self;\n}\n// docs:end:div-trait\n\nimpl Div for Field {\n fn div(self, other: Field) -> Field {\n self / other\n }\n}\n\nimpl Div for u128 {\n fn div(self, other: u128) -> u128 {\n self / other\n }\n}\nimpl Div for u64 {\n fn div(self, other: u64) -> u64 {\n self / other\n }\n}\nimpl Div for u32 {\n fn div(self, other: u32) -> u32 {\n self / other\n }\n}\nimpl Div for u16 {\n fn div(self, other: u16) -> u16 {\n self / other\n }\n}\nimpl Div for u8 {\n fn div(self, other: u8) -> u8 {\n self / other\n }\n}\nimpl Div for u1 {\n fn div(self, other: u1) -> u1 {\n self / other\n }\n}\n\nimpl Div for i8 {\n fn div(self, other: i8) -> i8 {\n self / other\n }\n}\nimpl Div for i16 {\n fn div(self, other: i16) -> i16 {\n self / other\n }\n}\nimpl Div for i32 {\n fn div(self, other: i32) -> i32 {\n self / other\n }\n}\nimpl Div for i64 {\n fn div(self, other: i64) -> i64 {\n self / other\n }\n}\n\n// docs:start:rem-trait\npub trait Rem {\n fn rem(self, other: Self) -> Self;\n}\n// docs:end:rem-trait\n\nimpl Rem for u128 {\n fn rem(self, other: u128) -> u128 {\n self % other\n }\n}\nimpl Rem for u64 {\n fn rem(self, other: u64) -> u64 {\n self % other\n }\n}\nimpl Rem for u32 {\n fn rem(self, other: u32) -> u32 {\n self % other\n }\n}\nimpl Rem for u16 {\n fn rem(self, other: u16) -> u16 {\n self % other\n }\n}\nimpl Rem for u8 {\n fn rem(self, other: u8) -> u8 {\n self % other\n }\n}\nimpl Rem for u1 {\n fn rem(self, other: u1) -> u1 {\n self % other\n }\n}\n\nimpl Rem for i8 {\n fn rem(self, other: i8) -> i8 {\n self % other\n }\n}\nimpl Rem for i16 {\n fn rem(self, other: i16) -> i16 {\n self % other\n }\n}\nimpl Rem for i32 {\n fn rem(self, other: i32) -> i32 {\n self % other\n }\n}\nimpl Rem for i64 {\n fn rem(self, other: i64) -> i64 {\n self % other\n }\n}\n\n// docs:start:neg-trait\npub trait Neg {\n fn neg(self) -> Self;\n}\n// docs:end:neg-trait\n\n// docs:start:neg-trait-impls\nimpl Neg for Field {\n fn neg(self) -> Field {\n -self\n }\n}\n\nimpl Neg for i8 {\n fn neg(self) -> i8 {\n -self\n }\n}\nimpl Neg for i16 {\n fn neg(self) -> i16 {\n -self\n }\n}\nimpl Neg for i32 {\n fn neg(self) -> i32 {\n -self\n }\n}\nimpl Neg for i64 {\n fn neg(self) -> i64 {\n -self\n }\n}\n// docs:end:neg-trait-impls\n\n// docs:start:wrapping-add-trait\npub trait WrappingAdd {\n fn wrapping_add(self, y: Self) -> Self;\n}\n// docs:end:wrapping-add-trait\n\nimpl WrappingAdd for u1 {\n fn wrapping_add(self: u1, y: u1) -> u1 {\n self ^ y\n }\n}\n\nimpl WrappingAdd for u8 {\n fn wrapping_add(self: u8, y: u8) -> u8 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u16 {\n fn wrapping_add(self: u16, y: u16) -> u16 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u32 {\n fn wrapping_add(self: u32, y: u32) -> u32 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u64 {\n fn wrapping_add(self: u64, y: u64) -> u64 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for u128 {\n fn wrapping_add(self: u128, y: u128) -> u128 {\n wrapping_add_hlp(self, y)\n }\n}\n\nimpl WrappingAdd for i8 {\n fn wrapping_add(self: i8, y: i8) -> i8 {\n let x = self as u8;\n x.wrapping_add(y as u8) as i8\n }\n}\n\nimpl WrappingAdd for i16 {\n fn wrapping_add(self: i16, y: i16) -> i16 {\n let x = self as u16;\n x.wrapping_add(y as u16) as i16\n }\n}\n\nimpl WrappingAdd for i32 {\n fn wrapping_add(self: i32, y: i32) -> i32 {\n let x = self as u32;\n x.wrapping_add(y as u32) as i32\n }\n}\n\nimpl WrappingAdd for i64 {\n fn wrapping_add(self: i64, y: i64) -> i64 {\n let x = self as u64;\n x.wrapping_add(y as u64) as i64\n }\n}\nimpl WrappingAdd for Field {\n fn wrapping_add(self: Field, y: Field) -> Field {\n self + y\n }\n}\n\n// docs:start:wrapping-sub-trait\npub trait WrappingSub {\n fn wrapping_sub(self, y: Self) -> Self;\n}\n// docs:start:wrapping-sub-trait\n\nimpl WrappingSub for u1 {\n fn wrapping_sub(self: u1, y: u1) -> u1 {\n self ^ y\n }\n}\n\nimpl WrappingSub for u8 {\n fn wrapping_sub(self: u8, y: u8) -> u8 {\n wrapping_sub_hlp(self, y) as u8\n }\n}\n\nimpl WrappingSub for u16 {\n fn wrapping_sub(self: u16, y: u16) -> u16 {\n wrapping_sub_hlp(self, y) as u16\n }\n}\n\nimpl WrappingSub for u32 {\n fn wrapping_sub(self: u32, y: u32) -> u32 {\n wrapping_sub_hlp(self, y) as u32\n }\n}\nimpl WrappingSub for u64 {\n fn wrapping_sub(self: u64, y: u64) -> u64 {\n wrapping_sub_hlp(self, y) as u64\n }\n}\nimpl WrappingSub for u128 {\n fn wrapping_sub(self: u128, y: u128) -> u128 {\n wrapping_sub_hlp(self, y) as u128\n }\n}\n\nimpl WrappingSub for i8 {\n fn wrapping_sub(self: i8, y: i8) -> i8 {\n let x = self as u8;\n x.wrapping_sub(y as u8) as i8\n }\n}\n\nimpl WrappingSub for i16 {\n fn wrapping_sub(self: i16, y: i16) -> i16 {\n let x = self as u16;\n x.wrapping_sub(y as u16) as i16\n }\n}\n\nimpl WrappingSub for i32 {\n fn wrapping_sub(self: i32, y: i32) -> i32 {\n let x = self as u32;\n x.wrapping_sub(y as u32) as i32\n }\n}\nimpl WrappingSub for i64 {\n fn wrapping_sub(self: i64, y: i64) -> i64 {\n let x = self as u64;\n x.wrapping_sub(y as u64) as i64\n }\n}\nimpl WrappingSub for Field {\n fn wrapping_sub(self: Field, y: Field) -> Field {\n self - y\n }\n}\n\n// docs:start:wrapping-mul-trait\npub trait WrappingMul {\n fn wrapping_mul(self, y: Self) -> Self;\n}\n// docs:start:wrapping-mul-trait\n\nimpl WrappingMul for u1 {\n fn wrapping_mul(self: u1, y: u1) -> u1 {\n self & y\n }\n}\n\nimpl WrappingMul for u8 {\n fn wrapping_mul(self: u8, y: u8) -> u8 {\n wrapping_mul_hlp(self, y)\n }\n}\n\nimpl WrappingMul for u16 {\n fn wrapping_mul(self: u16, y: u16) -> u16 {\n wrapping_mul_hlp(self, y)\n }\n}\n\nimpl WrappingMul for u32 {\n fn wrapping_mul(self: u32, y: u32) -> u32 {\n wrapping_mul_hlp(self, y)\n }\n}\nimpl WrappingMul for u64 {\n fn wrapping_mul(self: u64, y: u64) -> u64 {\n wrapping_mul_hlp(self, y)\n }\n}\n\nimpl WrappingMul for i8 {\n fn wrapping_mul(self: i8, y: i8) -> i8 {\n let x = self as u8;\n x.wrapping_mul(y as u8) as i8\n }\n}\n\nimpl WrappingMul for i16 {\n fn wrapping_mul(self: i16, y: i16) -> i16 {\n let x = self as u16;\n x.wrapping_mul(y as u16) as i16\n }\n}\n\nimpl WrappingMul for i32 {\n fn wrapping_mul(self: i32, y: i32) -> i32 {\n let x = self as u32;\n x.wrapping_mul(y as u32) as i32\n }\n}\n\nimpl WrappingMul for i64 {\n fn wrapping_mul(self: i64, y: i64) -> i64 {\n let x = self as u64;\n x.wrapping_mul(y as u64) as i64\n }\n}\n\nimpl WrappingMul for u128 {\n fn wrapping_mul(self: u128, y: u128) -> u128 {\n wrapping_mul128_hlp(self, y)\n }\n}\nimpl WrappingMul for Field {\n fn wrapping_mul(self: Field, y: Field) -> Field {\n self * y\n }\n}\n\nfn wrapping_add_hlp(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n\nfn wrapping_sub_hlp(x: T, y: T) -> Field\nwhere\n T: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n x.as_() + 340282366920938463463374607431768211456 - y.as_()\n}\n\nfn wrapping_mul_hlp(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\nglobal two_pow_64: u128 = 0x10000000000000000;\n/// Splits a 128 bits number into two 64 bits limbs\nunconstrained fn split64(x: u128) -> (u64, u64) {\n let lo = x as u64;\n let hi = (x / two_pow_64) as u64;\n (lo, hi)\n}\n\n/// Split a 128 bits number into two 64 bits limbs\n/// It will fail if the number is more than 128 bits\nfn split_into_64_bit_limbs(x: u128) -> (u64, u64) {\n // Safety: the limbs are constrained below\n let (x_lo, x_hi) = unsafe { split64(x) };\n assert(x as Field == x_lo as Field + x_hi as Field * two_pow_64 as Field);\n (x_lo, x_hi)\n}\n\n#[field(bn254)]\nfn wrapping_mul128_hlp(x: u128, y: u128) -> u128 {\n let (x_lo, x_hi) = split_into_64_bit_limbs(x);\n let (y_lo, y_hi) = split_into_64_bit_limbs(y);\n // Multiplication using the limbs:(x_lo + 2**64*x_hi)*(y_lo + 2**64*y_hi)=x_lo*y_lo+...\n // and skipping the terms over 2**128\n // Working with u64 limbs ensures that we cannot overflow the field modulus.\n let low = x_lo as Field * y_lo as Field;\n let lo = low as u64 as Field;\n let carry = (low - lo) / two_pow_64 as Field;\n let high = x_lo as Field * y_hi as Field + x_hi as Field * y_lo as Field + carry;\n let hi = high as u64 as Field;\n (lo + two_pow_64 as Field * hi) as u128\n}\n\nmod tests {\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n crate::static_assert(1 == 2, \"custom message\");\n }\n\n mod arithmetic {\n use crate::ops::arith::{Add, Div, Mul, Neg, Rem, Sub};\n #[test]\n fn test_basic_arithmetic_traits() {\n // add\n assert_eq(5.add(3), 8);\n assert_eq(0u8.add(255u8), 255u8);\n assert_eq(42.add(58), 100);\n\n // sub\n assert_eq(10.sub(3), 7);\n assert_eq(100.sub(42), 58);\n\n // mul\n assert_eq(6.mul(7), 42);\n\n // div\n assert_eq(15.div(3), 5);\n assert_eq(10u8.div(3u8), 3u8);\n assert_eq(15.div(3), 5);\n\n // rem\n assert_eq(17.rem(5), 2);\n assert_eq(10u8.rem(3u8), 1u8);\n\n // neg\n assert_eq(42.neg(), -42);\n assert_eq((-10).neg(), 10);\n assert_eq(42.neg(), -42);\n }\n\n #[test]\n fn test_division() {\n // test division by one\n assert_eq(42.div(1), 42);\n assert_eq(0.div(1), 0);\n assert_eq(255u8.div(1u8), 255u8);\n\n // test division by self\n assert_eq(42.div(42), 1);\n assert_eq(1.div(1), 1);\n\n // test remainder\n assert_eq(42.rem(42), 0);\n assert_eq(0.rem(42), 0);\n assert_eq(1.rem(42), 1);\n }\n\n #[test(should_fail)]\n fn test_u8_sub_overflow_failure() {\n let _ = 0u8.sub(1u8);\n }\n\n #[test(should_fail)]\n fn test_u8_add_overflow_failure() {\n let _ = 255u8.add(1u8);\n }\n\n #[test(should_fail)]\n fn test_u8_mul_overflow_failure() {\n let _ = 255u8.mul(2u8);\n }\n\n #[test(should_fail)]\n fn test_u16_sub_overflow_failure() {\n let _ = 0u16.sub(1u16);\n }\n\n #[test(should_fail)]\n fn test_u16_add_overflow_failure() {\n let _ = 65535u16.add(1u16);\n }\n\n #[test(should_fail)]\n fn test_u16_mul_overflow_failure() {\n let _ = 65535u16.mul(2u16);\n }\n\n #[test(should_fail)]\n fn test_signed_sub_overflow_failure() {\n let val: i8 = -128;\n let _ = val.sub(1i8);\n }\n\n #[test(should_fail)]\n fn test_signed_overflow_failure() {\n let _ = 127i8.add(1i8);\n }\n\n #[test]\n fn test_field() {\n let zero: Field = 0;\n let one: Field = 1;\n\n // test Field basic operations\n assert_eq(zero.add(one), one);\n assert_eq(one.add(zero), one);\n assert_eq(one.sub(one), zero);\n assert_eq(one.mul(one), one);\n assert_eq(one.div(one), one);\n assert_eq(zero.neg(), zero);\n assert_eq(one.neg(), -one);\n }\n\n }\n\n mod wrapping_arithmetic {\n use crate::ops::arith::{Add, Div, Mul, Neg, Sub, WrappingAdd, WrappingMul, WrappingSub};\n #[test]\n fn test_wrapping_add() {\n assert_eq(255u8.wrapping_add(1u8), 0u8);\n assert_eq(255u8.wrapping_add(255u8), 254u8);\n assert_eq(0u8.wrapping_add(0u8), 0u8);\n assert_eq(128u8.wrapping_add(128u8), 0u8);\n\n // test u16 wrapping add\n assert_eq(65535u16.wrapping_add(1u16), 0u16);\n assert_eq(65535u16.wrapping_add(65535u16), 65534u16);\n\n // test u32 wrapping add\n assert_eq(0xffffffffu32.wrapping_add(1u32), 0u32);\n assert_eq(0xffffffffu32.wrapping_add(0xffffffffu32), 0xfffffffeu32);\n\n // test u64 wrapping add\n assert_eq(0xffffffffffffffffu64.wrapping_add(1u64), 0u64);\n assert_eq(\n 0xffffffffffffffffu64.wrapping_add(0xffffffffffffffffu64),\n 0xfffffffffffffffeu64,\n );\n\n // test u128 wrapping add\n assert_eq(0xffffffffffffffffffffffffffffffffu128.wrapping_add(1u128), 0u128);\n\n // test signed types\n assert_eq(127i8.wrapping_add(1i8), -128i8);\n let val: i8 = -128;\n assert_eq(val.wrapping_add(-1i8), 127i8);\n\n // test Field wrapping add\n let forty_two: Field = 42;\n let fifty_eight: Field = 58;\n let hundred: Field = 100;\n let neg_two: Field = -2;\n let two: Field = 2;\n let zero: Field = 0;\n let neg_two_hundred: Field = -200;\n let neg_one_ninety_eight: Field = -198;\n assert_eq(forty_two.wrapping_add(fifty_eight), hundred);\n assert_eq(neg_two.wrapping_add(two), zero);\n assert_eq(neg_two_hundred.wrapping_add(two), neg_one_ninety_eight);\n }\n\n #[test]\n fn test_wrapping_sub() {\n assert_eq(0u8.wrapping_sub(1u8), 255u8);\n assert_eq(255u8.wrapping_sub(255u8), 0u8);\n assert_eq(0u8.wrapping_sub(0u8), 0u8);\n assert_eq(1u8.wrapping_sub(2u8), 255u8);\n\n // test u16 wrapping sub\n assert_eq(0u16.wrapping_sub(1u16), 65535u16);\n assert_eq(65535u16.wrapping_sub(65535u16), 0u16);\n\n // test u32 wrapping sub\n assert_eq(0u32.wrapping_sub(1u32), 0xffffffffu32);\n assert_eq(0xffffffffu32.wrapping_sub(0xffffffffu32), 0u32);\n\n // test u64 wrapping sub\n assert_eq(0u64.wrapping_sub(1u64), 0xffffffffffffffffu64);\n assert_eq(0xffffffffffffffffu64.wrapping_sub(0xffffffffffffffffu64), 0u64);\n\n // test u128 wrapping sub\n assert_eq(0u128.wrapping_sub(1u128), 0xffffffffffffffffffffffffffffffffu128);\n\n // test signed types\n let val: i8 = -128;\n assert_eq(val.wrapping_sub(1i8), 127i8);\n assert_eq(127i8.wrapping_sub(-1i8), -128i8);\n\n // test Field wrapping sub\n let forty_two: Field = 42;\n let fifty_eight: Field = 58;\n let neg_sixteen: Field = -16;\n assert_eq(forty_two.wrapping_sub(fifty_eight), neg_sixteen);\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n assert_eq(zero, zero.wrapping_mul(one));\n assert_eq(zero, one.wrapping_mul(zero));\n assert_eq(one, one.wrapping_mul(one));\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n\n // test u8 wrapping mul\n assert_eq(255u8.wrapping_mul(2u8), 254u8);\n assert_eq(255u8.wrapping_mul(255u8), 1u8);\n assert_eq(128u8.wrapping_mul(2u8), 0u8);\n\n // test u16 wrapping mul\n assert_eq(65535u16.wrapping_mul(2u16), 65534u16);\n assert_eq(65535u16.wrapping_mul(65535u16), 1u16);\n\n // test u32 wrapping mul\n assert_eq(0xffffffffu32.wrapping_mul(2u32), 0xfffffffeu32);\n assert_eq(0xffffffffu32.wrapping_mul(0xffffffffu32), 1u32);\n\n // test u64 wrapping mul\n // 0xffffffffffffffffu64 is 2^64 - 1\n assert_eq(0xffffffffffffffffu64.wrapping_mul(2u64), 0xfffffffffffffffeu64);\n assert_eq(0xffffffffffffffffu64.wrapping_mul(0xffffffffffffffffu64), 1u64);\n\n // test signed types\n assert_eq(127i8.wrapping_mul(2i8), -2i8);\n let val: i8 = -128;\n assert_eq(val.wrapping_mul(-1i8), -128i8);\n\n // test Field wrapping mul\n let six: Field = 6;\n let seven: Field = 7;\n let forty_two: Field = 42;\n let neg_two: Field = -2;\n let two: Field = 2;\n let neg_four: Field = -4;\n assert_eq(six.wrapping_mul(seven), forty_two);\n assert_eq(neg_two.wrapping_mul(two), neg_four);\n }\n\n #[test]\n fn test_u1_behavior() {\n // u1 wrapping add is XOR\n assert_eq(0u1.wrapping_add(0u1), 0u1);\n assert_eq(0u1.wrapping_add(1u1), 1u1);\n assert_eq(1u1.wrapping_add(0u1), 1u1);\n assert_eq(1u1.wrapping_add(1u1), 0u1);\n\n // u1 wrapping sub is XOR\n assert_eq(0u1.wrapping_sub(0u1), 0u1);\n assert_eq(0u1.wrapping_sub(1u1), 1u1);\n assert_eq(1u1.wrapping_sub(0u1), 1u1);\n assert_eq(1u1.wrapping_sub(1u1), 0u1);\n\n // u1 wrapping mul is AND\n assert_eq(0u1.wrapping_mul(0u1), 0u1);\n assert_eq(0u1.wrapping_mul(1u1), 0u1);\n assert_eq(1u1.wrapping_mul(0u1), 0u1);\n assert_eq(1u1.wrapping_mul(1u1), 1u1);\n }\n\n // test wrapping operations is the same as the regular operations\n #[test]\n fn test_wrapping_vs_regular() {\n let u64_large = 0x123456789abcdef0u64;\n let u128_large = 0x123456789abcdef0123456789abcdef0u128;\n\n assert_eq(u64_large.wrapping_add(1u64), u64_large + 1u64);\n assert_eq(u64_large.wrapping_sub(1u64), u64_large - 1u64);\n assert_eq(u64_large.wrapping_mul(2u64), u64_large * 2u64);\n\n assert_eq(u128_large.wrapping_add(1u128), u128_large + 1u128);\n assert_eq(u128_large.wrapping_sub(1u128), u128_large - 1u128);\n assert_eq(u128_large.wrapping_mul(2u128), u128_large * 2u128);\n }\n\n #[test]\n fn test_field_wrapping_operations() {\n let zero: Field = 0;\n let one: Field = 1;\n let large_val = 0xffffffffffffffff;\n\n // test Field wrapping operations\n assert_eq(zero.wrapping_add(one), one);\n assert_eq(one.wrapping_add(large_val), one + large_val);\n assert_eq(zero.wrapping_sub(one), -one);\n assert_eq(one.wrapping_sub(large_val), one - large_val);\n assert_eq(zero.wrapping_mul(one), zero);\n assert_eq(one.wrapping_mul(large_val), large_val);\n\n // test Field basic operations\n assert_eq(zero.add(one), one);\n assert_eq(one.add(zero), one);\n assert_eq(one.sub(one), zero);\n assert_eq(one.mul(one), one);\n assert_eq(one.div(one), one);\n assert_eq(zero.neg(), zero);\n assert_eq(one.neg(), -one);\n }\n\n }\n\n mod split_functions {\n\n use crate::ops::arith::{split64, split_into_64_bit_limbs};\n\n // test split64 and split_into_64_bit_limbs functions\n #[test]\n fn test_split_functions() {\n let small_val = 0x123456789abcdefu128;\n let large_val = 0x123456789abcdef0123456789abcdef0u128;\n let max_val = 0xffffffffffffffffffffffffffffffffu128;\n\n // test split64 (unconstrained)\n // Safety: testing\n unsafe {\n let (lo, hi) = split64(small_val);\n assert_eq(lo, 0x123456789abcdefu64);\n assert_eq(hi, 0u64);\n\n let (lo2, hi2) = split64(large_val);\n assert_eq(lo2, 0x123456789abcdef0u64);\n assert_eq(hi2, 0x123456789abcdef0u64);\n }\n\n // test split_into_64_bit_limbs (constrained)\n let (lo3, hi3) = split_into_64_bit_limbs(small_val);\n assert_eq(lo3, 0x123456789abcdefu64);\n assert_eq(hi3, 0u64);\n\n let (lo4, hi4) = split_into_64_bit_limbs(large_val);\n assert_eq(lo4, 0x123456789abcdef0u64);\n assert_eq(hi4, 0x123456789abcdef0u64);\n\n let (lo5, hi5) = split_into_64_bit_limbs(max_val);\n assert_eq(lo5, 0xffffffffffffffffu64);\n assert_eq(hi5, 0xffffffffffffffffu64);\n }\n }\n}\n","path":"std/ops/arith.nr"},"50":{"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::{MAX_MSG_NON_ZERO_COEFFS, T};\nuse lib::configs::default::threshold::{\n DECRYPTED_SHARES_AGGREGATION_BIT_NOISE, DECRYPTED_SHARES_AGGREGATION_CONFIGS, L,\n};\nuse lib::core::threshold::decrypted_shares_aggregation::DecryptedSharesAggregationBigNum;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n decryption_shares: pub [[Polynomial; L]; T + 1],\n party_ids: pub [Field; T + 1],\n message: pub Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n) {\n let decrypted_shares_aggregation: DecryptedSharesAggregationBigNum = DecryptedSharesAggregationBigNum::new(\n DECRYPTED_SHARES_AGGREGATION_CONFIGS,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n );\n\n decrypted_shares_aggregation.execute();\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/decrypted_shares_aggregation_bn/src/main.nr"},"67":{"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::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\nuse dep::bignum::BigNum;\nuse dep::bignum::bignum::to_field;\nuse dep::bignum::SecureThreshold8192;\n\n/// Cryptographic parameters for decryption share aggregation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Plaintext modulus (typically denoted as `t`)\n pub plaintext_modulus: Field,\n /// Precomputed value: `-Q^(-1) mod t` where Q is the product of all CRT moduli\n pub q_inverse_mod_t: Field,\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], plaintext_modulus: Field, q_inverse_mod_t: Field) -> Self {\n Configs { qis, plaintext_modulus, q_inverse_mod_t }\n }\n}\n\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using BigNum\n/// for large Q values.\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationBigNum {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using modular arithmetic\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationModular {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n\nimpl DecryptedSharesAggregationBigNum {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationBigNum {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Verifies decoding using BigNum for large Q values\n fn verify_decoding(self) {\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1 as Field;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_bn = SecureThreshold8192::from(q_modulus);\n\n let q_half_bn = q_bn.udiv(SecureThreshold8192::from(2));\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let u_bn = SecureThreshold8192::from(self.u_global.coefficients[coeff_idx]);\n let t_bn = SecureThreshold8192::from(self.configs.plaintext_modulus);\n let u_bn_mod_q = u_bn.umod(q_bn);\n let t_bn_mod_q = t_bn.umod(q_bn);\n let t_times_u_bn_q = (t_bn_mod_q * u_bn_mod_q).umod(q_bn);\n\n let m = ModU128::new(self.configs.plaintext_modulus);\n\n // Check if centering is needed\n let needs_centering = t_times_u_bn_q > q_half_bn;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_bn - t_times_u_bn_q;\n let centered_positive_mod_t = centered_positive.umod(t_bn);\n let centered_field = to_field(centered_positive_mod_t);\n m.mul_mod(self.configs.q_inverse_mod_t, centered_field)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_bn_t = t_times_u_bn_q.umod(t_bn);\n let t_times_u_field = to_field(t_times_u_bn_t);\n let product = m.mul_mod(self.configs.q_inverse_mod_t, t_times_u_field);\n if product == 0 {\n 0\n } else {\n self.configs.plaintext_modulus - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\nimpl DecryptedSharesAggregationModular {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationModular {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Alternative verification function using efficient modular arithmetic without BigNum.\n ///\n /// Uses `ModU128` for decoding verification instead of BigNum. More efficient when\n /// Q (the product of all CRT moduli) fits within u128 (e.g., 72 bits for insecure parameter sets).\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Alternative decoding verification using the formula:\n /// message = -Q^{-1} * (t * u_global)_Q mod t\n fn verify_decoding(self) {\n let t: Field = self.configs.plaintext_modulus;\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_half = q_modulus as u128 / 2;\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let q_mod = ModU128::new(q_modulus);\n let t_mod = ModU128::new(t);\n\n // Compute (t * u_global) mod Q using modular arithmetic functions\n let t_times_u_mod_q = q_mod.mul_mod(t, self.u_global.coefficients[coeff_idx]);\n let needs_centering = (t_times_u_mod_q as u128) > q_half;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_modulus - t_times_u_mod_q;\n let centered_positive_mod_t = t_mod.reduce_mod(centered_positive);\n\n t_mod.mul_mod(self.configs.q_inverse_mod_t, centered_positive_mod_t)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_mod_t = t_mod.reduce_mod(t_times_u_mod_q);\n let product = t_mod.mul_mod(self.configs.q_inverse_mod_t, t_times_u_mod_t);\n if product == 0 {\n 0\n } else {\n t - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\n/// Computes all Lagrange coefficients using optimized modular arithmetic\npub fn compute_all_lagrange_coeffs(\n qis: [Field; L],\n party_ids: [Field; T + 1],\n) -> [[Field; T + 1]; L] {\n let mut lagrange_coeffs = [[0 as Field; T + 1]; L];\n\n // Step 1: Cache |x_i - x_j| factors for all party pairs\n let mut diffs = [[0 as Field; T + 1]; T + 1];\n for i in 0..(T + 1) {\n for j in (i + 1)..(T + 1) {\n let diff = party_ids[j] - party_ids[i];\n diffs[i][j] = diff;\n diffs[j][i] = diff;\n }\n }\n\n // Step 2: Determine signs (same for all parties within a basis)\n let numerator_sign_negative = (T % 2) == 1;\n\n // Step 3: For each CRT basis, compute Lagrange coefficients\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n\n // Compute product of all party IDs: PRODUCT(j=0..T) x_j mod q_l\n let mut product_x = 1 as Field;\n for j in 0..(T + 1) {\n product_x = m.mul_mod(product_x, party_ids[j]);\n }\n\n // For each party i, compute L_i(0) mod q_l\n for party_idx in 0..(T + 1) {\n // Numerator (absolute value): PRODUCT(j!=party_idx) x_j\n let numerator_abs = m.div_mod(product_x, party_ids[party_idx]);\n\n // Denominator (absolute value): PRODUCT(j!=party_idx) |x_party_idx - x_j|\n let mut denominator_abs = 1 as Field;\n for j in 0..(T + 1) {\n if j != party_idx {\n denominator_abs = m.mul_mod(denominator_abs, diffs[party_idx][j]);\n }\n }\n\n // Determine denominator sign\n let num_greater = T - party_idx;\n let denom_sign_negative = (num_greater % 2) == 1;\n\n // Compute unsigned result: |numerator| / |denominator| mod q_l\n let result_abs = m.div_mod(numerator_abs, denominator_abs);\n\n // Apply combined sign\n let should_negate = numerator_sign_negative != denom_sign_negative;\n let result = if should_negate {\n m.reduce_mod(q_l - result_abs)\n } else {\n result_abs\n };\n\n lagrange_coeffs[basis_idx][party_idx] = result;\n }\n }\n\n lagrange_coeffs\n}\n\n/// Computes u^{(l)} for each CRT basis via Lagrange interpolation\npub fn compute_crt_components(\n qis: [Field; L],\n decryption_shares: [[Polynomial; L]; T + 1],\n lagrange_coeffs: [[Field; T + 1]; L],\n) -> [Polynomial; L] {\n let mut u_crts: [Polynomial; L] =\n [Polynomial::new([0; MAX_MSG_NON_ZERO_COEFFS]); L];\n\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n let mut u_coeffs = [0 as Field; MAX_MSG_NON_ZERO_COEFFS];\n\n // For each coefficient position\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n let mut u_coeff = 0 as Field;\n\n // Sum all contributions: u = SUM(i=0..T) [d_i * L_i(0)] mod q_l\n for party_idx in 0..(T + 1) {\n let d_coeff = decryption_shares[party_idx][basis_idx].coefficients[coeff_idx];\n let l_i_0 = lagrange_coeffs[basis_idx][party_idx];\n\n let term = m.mul_mod(d_coeff, l_i_0);\n u_coeff = m.reduce_mod(u_coeff + term);\n }\n\n u_coeffs[coeff_idx] = u_coeff;\n }\n\n u_crts[basis_idx] = Polynomial::new(u_coeffs);\n }\n\n u_crts\n}\n\n/// Verifies CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global for all bases l\npub fn verify_crt_reconstruction(\n qis: [Field; L],\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n u_crts: [Polynomial; L],\n) {\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n\n // Compute r^{(l)} * q_l\n let r_times_q = crt_quotients[basis_idx].mul_scalar(q_l);\n\n // Compute u^{(l)} + r^{(l)} * q_l\n let reconstructed = u_crts[basis_idx].add(r_times_q);\n\n // Verify: u^{(l)} + r^{(l)} * q_l = u_global\n // Must hold for every coefficient\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n assert(\n reconstructed.coefficients[coeff_idx] == u_global.coefficients[coeff_idx],\n \"CRT reconstruction verification failed\",\n );\n }\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/decrypted_shares_aggregation.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"84":{"source":"use crate::fns::constrained_ops::limbs_to_field;\nuse crate::params::BigNumParams;\nuse std::ops::{Add, Div, Mul, Neg, Sub};\n\npub trait BigNum: Neg + Add + Sub + Mul + Div + Eq {\n let N: u32;\n let MOD_BITS: u32;\n\n fn params() -> BigNumParams;\n fn modulus_bits(_: Self) -> u32;\n fn num_limbs(_: Self) -> u32;\n fn modulus() -> Self;\n\n fn new() -> Self;\n fn zero() -> Self;\n fn one() -> Self;\n fn from_limbs(limbs: [u128; N]) -> Self;\n fn get_limbs(self) -> [u128; N];\n fn set_limb(self: &mut Self, idx: u32, value: u128);\n fn derive_from_seed(seed: [u8; SeedBytes]) -> Self;\n unconstrained fn __derive_from_seed(seed: [u8; SeedBytes]) -> Self;\n fn from_be_bytes(x: [u8; (MOD_BITS + 7) / 8]) -> Self;\n fn to_be_bytes(self) -> [u8; (MOD_BITS + 7) / 8];\n fn from_le_bytes(x: [u8; (MOD_BITS + 7) / 8]) -> Self;\n fn to_le_bytes(self) -> [u8; (MOD_BITS + 7) / 8];\n\n fn get_limb(self: Self, idx: u32) -> u128 {\n self.get_limbs()[idx]\n }\n\n unconstrained fn __eq(self: Self, other: Self) -> bool;\n\n unconstrained fn __is_zero(self: Self) -> bool;\n\n unconstrained fn __neg(self) -> Self;\n unconstrained fn __add(self, other: Self) -> Self;\n unconstrained fn __sub(self, other: Self) -> Self;\n unconstrained fn __mul(self, other: Self) -> Self;\n unconstrained fn __sqr(self) -> Self;\n unconstrained fn __div(self, other: Self) -> Self;\n unconstrained fn __udiv_mod(self, divisor: Self) -> (Self, Self);\n unconstrained fn __invmod(self) -> Self;\n unconstrained fn __pow(self, exponent: Self) -> Self;\n\n unconstrained fn __tonelli_shanks_sqrt(self) -> std::option::Option;\n unconstrained fn __sqrt(self) -> std::option::Option;\n\n fn assert_is_not_equal(self: Self, other: Self);\n\n fn validate_in_range(self);\n fn validate_in_field(self);\n\n fn sqr(self) -> Self;\n\n fn udiv_mod(self, divisor: Self) -> (Self, Self);\n fn udiv(self, divisor: Self) -> Self;\n fn umod(self, divisor: Self) -> Self;\n\n fn is_zero(self) -> bool;\n fn is_zero_integer(self) -> bool;\n fn assert_is_not_zero(self);\n fn assert_is_not_zero_integer(self);\n}\n\n// we need macros that implement the BigNum, Default, From, Neg, Add, Sub, Mul, Div, Eq, Ord traits for each bignum type\npub comptime fn derive_bignum(\n strukt: TypeDefinition,\n N: u32,\n MOD_BITS: u32,\n params: Quoted,\n) -> Quoted {\n let constrained_ops = quote { $crate::fns::constrained_ops };\n let unconstrained_ops = quote { $crate::fns::unconstrained_ops };\n let typ = strukt.as_type();\n let serialization = quote { $crate::fns::serialization };\n quote {\n\n // implement BigNum for BigNum \n impl $crate::BigNum for $typ {\n let N: u32 = $N; \n let MOD_BITS: u32 = $MOD_BITS;\n \n fn modulus_bits(_: Self) -> u32 {\n $MOD_BITS\n }\n \n fn num_limbs(_: Self) -> u32 {\n $N\n }\n\n fn modulus() -> Self {\n Self { limbs: Self::params().modulus }\n }\n\n fn new() -> Self {\n Self {limbs: [0; $N]}\n }\n\n fn params() -> $crate::params::BigNumParams<$N, $MOD_BITS> {\n $params\n }\n\n fn from_limbs(limbs: [u128; $N]) -> Self {\n Self { limbs }\n }\n\n fn get_limbs(self: Self) -> [u128; $N] {\n self.limbs\n }\n\n fn set_limb(self: &mut Self, idx: u32, value: u128) {\n self.limbs[idx] = value;\n }\n\n fn zero() -> Self {\n Self { limbs: [0; $N] }\n }\n\n fn one() -> Self {\n let mut limbs = [0; $N];\n limbs[0] = 1;\n Self { limbs }\n }\n\n fn derive_from_seed(seed: [u8; SeedBytes]) -> Self {\n let params = Self::params();\n $typ::from_limbs($constrained_ops::derive_from_seed::<_, $MOD_BITS, _>(params, seed))\n }\n\n unconstrained fn __derive_from_seed(seed: [u8; SeedBytes]) -> Self {\n let params = Self::params();\n Self { limbs: $unconstrained_ops::__derive_from_seed::<_, $MOD_BITS, _>(params, seed) }\n }\n\n fn from_be_bytes(x: [u8; ($MOD_BITS + 7) / 8]) -> Self {\n Self { limbs: $serialization::from_be_bytes::<_, $MOD_BITS>(x) }\n }\n \n fn to_be_bytes(self) -> [u8; ($MOD_BITS + 7) / 8] {\n $serialization::to_be_bytes::<_, $MOD_BITS>(self.limbs)\n }\n\n fn from_le_bytes(x: [u8; ($MOD_BITS + 7) / 8]) -> Self {\n Self { limbs: $serialization::from_le_bytes::<_, $MOD_BITS>(x) }\n }\n\n fn to_le_bytes(self) -> [u8; ($MOD_BITS + 7) / 8] {\n $serialization::to_le_bytes::<_, $MOD_BITS>(self.limbs)\n }\n\n unconstrained fn __eq(self: Self, other: Self) -> bool {\n $crate::fns::unconstrained_ops::__eq(self.get_limbs(), other.get_limbs())\n }\n\n unconstrained fn __is_zero(self: Self) -> bool {\n $crate::fns::unconstrained_ops::__is_zero(self.get_limbs())\n }\n\n unconstrained fn __neg(self: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__neg(params.modulus, self.get_limbs())}\n }\n\n unconstrained fn __add(self: Self, other: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__add(params.modulus, self.get_limbs(), other.get_limbs())}\n }\n\n unconstrained fn __sub(self: Self, other: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__sub(params.modulus, self.get_limbs(), other.get_limbs())}\n }\n\n unconstrained fn __mul(self: Self, other: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__mul(params, self.get_limbs(), other.get_limbs())}\n }\n\n unconstrained fn __sqr(self: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__sqr(params, self.get_limbs()) }\n }\n\n unconstrained fn __div(self: Self, divisor: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__div(params, self.get_limbs(), divisor.get_limbs())}\n }\n\n unconstrained fn __udiv_mod(self: Self, divisor: Self) -> (Self, Self) {\n let (q, r) = $unconstrained_ops::__udiv_mod(self.get_limbs(), divisor.get_limbs());\n (Self{limbs: q}, Self{limbs: r})\n }\n\n unconstrained fn __invmod(self: Self) -> Self {\n let params = Self::params();\n assert(params.has_multiplicative_inverse);\n Self {limbs: $unconstrained_ops::__invmod(params, self.get_limbs())}\n }\n\n unconstrained fn __pow(self: Self, exponent: Self) -> Self {\n let params = Self::params();\n Self {limbs: $unconstrained_ops::__pow(params, self.get_limbs(), exponent.get_limbs())}\n }\n\n #[deprecated(\"use __sqrt\")]\n unconstrained fn __tonelli_shanks_sqrt(self: Self) -> std::option::Option {\n let params = Self::params();\n let maybe_limbs = $unconstrained_ops::__sqrt(params, self.get_limbs());\n maybe_limbs.map(|limbs| Self {limbs: limbs})\n }\n\n unconstrained fn __sqrt(self: Self) -> std::option::Option {\n let params = Self::params();\n let maybe_limbs = $unconstrained_ops::__sqrt(params, self.get_limbs());\n maybe_limbs.map(|limbs| Self {limbs: limbs })\n }\n\n fn assert_is_not_equal(self: Self, other: Self) {\n let params = Self::params();\n $crate::fns::constrained_ops::assert_is_not_equal(\n params,\n self.get_limbs(),\n other.get_limbs(),\n );\n }\n\n fn validate_in_field(self: Self) {\n let params = Self::params();\n $constrained_ops::validate_in_field::<_, $MOD_BITS>(params, self.get_limbs());\n }\n\n fn validate_in_range(self: Self) {\n $constrained_ops::validate_in_range::<_, _, $MOD_BITS>(self.get_limbs());\n }\n\n fn sqr(self: Self) -> Self {\n let params = Self::params();\n Self { limbs: $constrained_ops::sqr::<$N, $MOD_BITS>(params, self.get_limbs()) }\n }\n\n fn udiv_mod(self: Self, divisor: Self) -> (Self, Self) {\n let (q, r) = $constrained_ops::udiv_mod::<$N, $MOD_BITS>(self.get_limbs(), divisor.get_limbs());\n (Self {limbs: q}, Self {limbs: r})\n }\n\n fn udiv(self: Self, divisor: Self) -> Self {\n let params = Self::params();\n Self {limbs: $constrained_ops::udiv::<$N, $MOD_BITS>(self.get_limbs(), divisor.get_limbs())}\n }\n\n fn umod(self: Self, divisor: Self) -> Self {\n let params = Self::params();\n Self {limbs: $constrained_ops::umod::<$N, $MOD_BITS>(self.get_limbs(), divisor.get_limbs())}\n }\n\n fn is_zero(self: Self) -> bool {\n let params = Self::params();\n $constrained_ops::is_zero::<$N, $MOD_BITS>(params, self.get_limbs())\n }\n\n fn is_zero_integer(self: Self) -> bool {\n $constrained_ops::is_zero_integer(self.get_limbs())\n }\n\n fn assert_is_not_zero(self: Self) {\n let params = Self::params();\n $constrained_ops::assert_is_not_zero::<$N, $MOD_BITS>(params, self.get_limbs());\n }\n\n fn assert_is_not_zero_integer(self: Self) {\n $constrained_ops::assert_is_not_zero_integer(self.get_limbs());\n }\n }\n\n // implement Default for BigNum\n impl Default for $typ {\n fn default() -> Self {\n $typ::from_limbs([0; $N])\n }\n }\n\n impl std::convert::From for $typ {\n fn from(input: Field) -> Self {\n $typ { limbs: $constrained_ops::from_field::<$N, $MOD_BITS>($params, input) }\n }\n }\n\n impl std::ops::Neg for $typ {\n fn neg(self) -> Self {\n $typ { limbs: $constrained_ops::neg::<$N, $MOD_BITS>($params, self.limbs) }\n }\n }\n\n impl std::ops::Add for $typ {\n fn add(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::add::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::ops::Sub for $typ {\n fn sub(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::sub::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::ops::Mul for $typ {\n fn mul(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::mul::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::ops::Div for $typ {\n fn div(self, other: Self) -> Self {\n $typ { limbs: $constrained_ops::div::<$N, $MOD_BITS>($params, self.limbs, other.limbs) }\n }\n }\n\n impl std::cmp::Eq for $typ {\n fn eq(self, other: Self) -> bool {\n $constrained_ops::eq::<$N, $MOD_BITS>($params, self.limbs, other.limbs)\n }\n }\n\n impl std::cmp::Ord for $typ {\n fn cmp(self, other: Self) -> std::cmp::Ordering {\n $constrained_ops::cmp::<$N, $MOD_BITS>(self.limbs, other.limbs)\n }\n }\n\n }\n}\n\npub fn conditional_select(lhs: T, rhs: T, predicate: bool) -> T {\n if predicate {\n lhs\n } else {\n rhs\n }\n}\n\npub unconstrained fn compute_quadratic_expression(\n lhs_terms: [[T; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[T; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [T; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> (T, T) {\n let params = T::params();\n let (q_limbs, r_limbs) = crate::fns::expressions::__compute_quadratic_expression(\n params,\n crate::utils::map::map(\n lhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n lhs_flags,\n crate::utils::map::map(\n rhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n rhs_flags,\n crate::utils::map::map(linear_terms, |bn: T| bn.get_limbs()),\n linear_flags,\n );\n (T::from_limbs(q_limbs), T::from_limbs(r_limbs))\n}\n\npub fn evaluate_quadratic_expression(\n lhs_terms: [[T; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[T; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [T; ADD_N],\n linear_flags: [bool; ADD_N],\n) {\n let params = T::params();\n crate::fns::expressions::evaluate_quadratic_expression(\n params,\n crate::utils::map::map(\n lhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n lhs_flags,\n crate::utils::map::map(\n rhs_terms,\n |bns| crate::utils::map::map(bns, |bn: T| bn.get_limbs()),\n ),\n rhs_flags,\n crate::utils::map::map(linear_terms, |bn: T| bn.get_limbs()),\n linear_flags,\n )\n}\n\npub unconstrained fn batch_invert(x: [T; M]) -> [T; M] {\n let params = T::params();\n assert(params.has_multiplicative_inverse);\n crate::fns::unconstrained_ops::batch_invert(params, x.map(|bn: T| bn.get_limbs())).map(|limbs| {\n T::from_limbs(limbs)\n })\n}\n\npub unconstrained fn batch_invert_slice(x: [T]) -> [T] {\n let params = T::params();\n assert(params.has_multiplicative_inverse);\n crate::fns::unconstrained_ops::batch_invert_slice(params, x.map(|bn: T| bn.get_limbs()))\n .map(|limbs| T::from_limbs(limbs))\n}\n\npub fn to_field(bn: T) -> Field {\n let params = T::params();\n limbs_to_field(params, bn.get_limbs())\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/bignum.nr"},"120":{"source":"use crate::constants::{GRUMPKIN_MODULUS, TWO_POW_120, TWO_POW_240};\n\nuse crate::fns::{\n expressions::{evaluate_quadratic_expression, validate_udiv_mod_expression},\n unconstrained_helpers::{\n __add_with_flags, __from_field, __neg_with_flags, __sub_with_flags,\n __validate_gte_with_flags, __validate_in_field_compute_borrow_flags,\n },\n unconstrained_ops::{__add, __div, __mul, __neg, __sqr, __sub, __udiv_mod},\n};\n\nuse crate::params::BigNumParams;\n\nuse std::cmp::Ordering;\n\n/// Lift the limbs of a `BigNum` value onto the circuit `Field`\n///\n/// Descent the `BigNum` value back into the `Field` and\n/// - check that it's a proper `BigNum` value\n/// - validate the limbs sum up to a `Field` value\npub(crate) fn limbs_to_field(\n _params: BigNumParams,\n limbs: [u128; N],\n) -> Field {\n validate_in_range::(limbs);\n if N > 2 {\n // validate that the `BigNum` is less than the Grumpkin modulus\n let mut grumpkin_modulus: [u128; N] = [0; N];\n grumpkin_modulus[0] = GRUMPKIN_MODULUS[0];\n grumpkin_modulus[1] = GRUMPKIN_MODULUS[1];\n grumpkin_modulus[2] = GRUMPKIN_MODULUS[2];\n validate_gt::(grumpkin_modulus, limbs);\n }\n\n if N < 2 {\n limbs[0] as Field\n } else if N == 2 {\n (limbs[0] as Field) + (limbs[1] as Field) * (TWO_POW_120 as Field)\n } else {\n (limbs[0] as Field)\n + (limbs[1] as Field) * (TWO_POW_120 as Field)\n + (limbs[2] as Field) * TWO_POW_240\n }\n}\n\n/// Construct a `BigNum` value from a native `Field`\n///\n/// Decomposes the `Field` value into 120-bit limbs\n/// then we have three cases:\n/// - MOD_BITS < 253 (grumpkin_mod_bits - 1): it is enough to call for `validate_in_field`, which is basically `val <= MOD`\n/// - MOD_BITS > 253: we need to verify that the obtained `BigNum` `val < GRUMPKIN_MODULUS`\n/// - MOD_BITS = 253: verify that `val < min(MOD, GRUMPKIN_MODULUS)`\n/// Next we verify that all the limbs are properly ranged\n/// and that the accumulated limbs are equal to the input `Field` value\npub(crate) fn from_field(\n _params: BigNumParams,\n val: Field,\n) -> [u128; N] {\n // Safety: we check that the resulting limbs represent the intended field element\n // we check the bit length, the limbs being max 120 bits, and the value in total is less than the field modulus\n let result: [u128; N] = unsafe { __from_field::(val) };\n\n if !std::runtime::is_unconstrained() {\n // validate the limbs are in range and the value in total is less than 2^254\n if MOD_BITS < 253 {\n // this means that the field modulus is smaller than grumpkin modulus so we have to check if the element fields in the field size\n validate_in_field(_params, result);\n } else {\n let mut grumpkin_modulus: [u128; N] = [0; N];\n grumpkin_modulus[0] = GRUMPKIN_MODULUS[0];\n grumpkin_modulus[1] = GRUMPKIN_MODULUS[1];\n grumpkin_modulus[2] = GRUMPKIN_MODULUS[2];\n\n if MOD_BITS > 253 {\n // this means that the field modulus is larger than grumpkin modulus so we have to check if the element fields in the field size are less than the grumpkin modulus.\n // also for correct params N is always larger than 3 here\n validate_gt::(grumpkin_modulus, result);\n } else {\n // this is the tricky part, when MOD_BITS = 253, we have to compare the limbs of the modulus to the grumpkin modulus limbs\n // any `BigNum` with 253 bits will have 3 limbs\n\n // if MOD is less than grumpkin modulus, this will be true\n let mut mod_lt_grumpkin: bool = false;\n for i in 0..3 {\n if !mod_lt_grumpkin & (_params.modulus[2 - i] < grumpkin_modulus[2 - i]) {\n mod_lt_grumpkin = true;\n }\n }\n let min_modulus: [u128; N] = if mod_lt_grumpkin {\n _params.modulus\n } else {\n grumpkin_modulus\n };\n validate_gt::(min_modulus, result);\n }\n }\n validate_in_range::(result);\n\n // validate the limbs sum up to the field value\n let field_val: Field = if N < 2 {\n result[0] as Field\n } else if N == 2 {\n (result[0] as Field) + (result[1] as Field) * (TWO_POW_120 as Field)\n } else {\n (result[0] as Field)\n + (result[1] as Field) * (TWO_POW_120 as Field)\n + (result[2] as Field) * TWO_POW_240\n };\n assert_eq(field_val, val);\n }\n\n result\n}\n\n/// Given an input seed, generate a pseudorandom `BigNum` value\n///\n/// This function *should* produce a uniformly randomly distributed value modulo `MOD`\n///\n/// First we take the seed and pack it's 31-byte chunks into `Field`s\n/// We use a hash function that can be modelled as a random oracle\n/// We hash the packed seed using Poseidon2 to produce `MOD_BITS * 2` bits of entropy\n///\n/// From these bits we construct 4(in case N = 2) or 3(N > 2) `BigNum` values:\n/// - We fill first `N - 1` limbs and leave the top limb empty\n///\n/// Then we accumulate the resulting BigNum values using:\n/// B = 2^{120 * (N - 1)}\n/// res = x3 + B * x2 + B^2 * x1 + B^3 * x0\n///\n/// ## Note\n/// This function will always produce an `x3` `BigNum`\n/// If `MOD = 2^{120 * (N - 1)}`\n/// It will use only `MOD_BITS - 1` bits of entropy\npub(crate) fn derive_from_seed(\n params: BigNumParams,\n seed: [u8; SeedBytes],\n) -> [u128; N] {\n // Pack seed bytes into Fields.\n // For the seed of length M, we construct a rolling_hash_field of size ceil(M / 31).\n // i.e. 31 bytes per Field\n // NOTE: the Fields produced are 248 bits in size\n let mut rolling_hash_fields: [Field; (SeedBytes + 30) / 31] = [0; (SeedBytes + 30) / 31];\n let mut seed_ptr: u32 = 0;\n for i in 0..(SeedBytes + 30) / 31 {\n let mut packed: Field = 0;\n for _ in 0..31 {\n if (seed_ptr < SeedBytes) {\n packed *= 256;\n packed += seed[seed_ptr] as Field;\n seed_ptr += 1;\n }\n }\n rolling_hash_fields[i] = packed;\n }\n\n let compressed: Field =\n poseidon::poseidon2::Poseidon2::hash(rolling_hash_fields, (SeedBytes + 30) / 31);\n let mut rolling_hash: [Field; 2] = [compressed, 0];\n\n // 120 bit limb has 15 bytes in it\n // we buffer (N * 15) * 2 bytes for 2N limbs\n let mut hash_buffer: [u8; N * 15 * 2] = [0; N * 15 * 2];\n\n // We produce 32 bytes (254 bits) per hash iteration\n // We take only 30 bytes, so we need ceil(N * 2 * 15 / 30) hashes to fill them up\n for i in 0..N {\n let hash: Field = poseidon::poseidon2::Poseidon2::hash(rolling_hash, 2);\n let hash: [u8; 32] = hash.to_le_bytes();\n for j in 0..30 {\n hash_buffer[i * 30 + j] = hash[j];\n }\n rolling_hash[1] += 1;\n }\n\n let num_bits: u32 = MOD_BITS * 2;\n let num_bytes: u32 = (num_bits + 7) / 8;\n\n // Truncate the final byte that will be used in `BigNum` creation\n let bits_in_last_byte: u8 = (num_bits as u8) % 8;\n if bits_in_last_byte != 0 {\n let last_byte_mask: u8 = ((1 as u8) << bits_in_last_byte) - 1;\n hash_buffer[num_bytes - 1] &= last_byte_mask;\n }\n\n let num_bigfield_chunks: u32 = if N == 2 { 4 } else { 3 };\n let mut byte_ptr: u32 = 0;\n\n // We want to convert our hash_buffer into bigfield chunks, with each `BigNum` having at most N - 1 limbs filled\n // We sample only N - 1 limbs mostly because we do not wont to deal with accidental overflows in the top limb\n // In any case the security is preserved\n //\n // For all integer values N > 1, the number of chunks is either 4(for N = 2) or 3(for N > 2) (ceil(2*N / (N - 1)))\n //\n // To determine the exact number of chunks, we need the `!=` or `>` operator which is not available when defining array sizes\n // so we overestimate at 4\n // e.g. if N = 20, then we have 40 limbs we want to reduce, but each bigfield chunk is 19 limbs, so we need 3\n // if N = 2, we have 4 limbs we want to reduce but each bigfield chunk is only 1 limb, so we need 4\n let mut bigfield_chunks: [[u128; N]; 4] = [[0; N]; 4];\n\n for k in 0..num_bigfield_chunks {\n let mut bigfield_limbs: [u128; N] = [0; N];\n\n // Before the current limb, we filled out (N - 1) limbs, k times\n // 15 bytes per limb\n // resulting in total of 15 * k * (N - 1)\n let mut num_filled_bytes: u32 = 15 * k * (N - 1);\n if num_bytes > num_filled_bytes {\n // Static assert for completeness\n assert(num_filled_bytes == byte_ptr);\n\n let mut num_remaining_bytes_to_sample: u32 = num_bytes - num_filled_bytes;\n let mut num_remaining_limbs_to_sample: u32 = (num_remaining_bytes_to_sample + 14) / 15;\n\n // Sample at most (N - 1) limbs from hash_buffer\n let mut num_limbs_to_sample: u32 = if num_remaining_limbs_to_sample > (N - 1) {\n N - 1\n } else {\n num_remaining_limbs_to_sample\n };\n\n for j in 0..num_limbs_to_sample {\n let mut limb: Field = 0;\n // Construct a 120 bit limb\n for _ in 0..15 {\n if byte_ptr < num_bytes {\n let mut byte: u8 = hash_buffer[byte_ptr];\n limb *= 256;\n limb += byte as Field;\n byte_ptr += 1;\n }\n }\n // crucial for performance\n limb.assert_max_bit_size::<120>();\n // Accumulate limbs from top to bottom\n bigfield_limbs[num_limbs_to_sample - 1 - j] = limb as u128;\n }\n // Accumulate `BigNum` values from top to bottom\n bigfield_chunks[num_bigfield_chunks - 1 - k] = bigfield_limbs;\n }\n }\n\n // B = 2^{120 * (N - 1)}, we know it is \\leq `MOD`, since the top limb\n // have to be at least one\n let mut bigfield_rhs_limbs: [u128; N] = [0; N];\n bigfield_rhs_limbs[N - 1] = 1;\n\n let mut result: [u128; N] = bigfield_chunks[0];\n\n for i in 1..num_bigfield_chunks {\n result = mul(params, result, bigfield_rhs_limbs);\n result = add(params, result, bigfield_chunks[i]);\n }\n\n result\n}\n\n// ------------------------------ COMPARISON FUNCTIONS ------------------------------\n\n/// Validate lhs != rhs\n///\n/// We compare `A` and `B` via their encodings in the circuit `Field`\n///\n/// Under our range assumptions, equality in `Field` implies equality of the underlying\n/// `BigNum` values, hence equality (mod `MOD`)\n///\n/// In this library it is possible that A or B is a little bit greater than `MOD`\n/// So A == B (mod `MOD`) implies that A == B, A == B + MOD or A == B - MOD over the integers\n/// Hence we can compute everything (mod p) and constrain that\n/// (A - B) * (A - B + MOD) * (A - B - MOD) != 0 (mod p)\n///\n/// ## Soundness\n/// This method is *sound* for checking `A != B (mod MOD)`\n///\n/// If `A == B (mod MOD)`, then `A - B` is in `{0, +-MOD}` as an integer,\n/// so one of the factors `A-B`, `A-B+MOD`, `A-B-MOD` is zero in `Field`, and the product is zero\n/// Therefore, whenever the assertion `target != 0` holds, we must have `A != B (mod MOD)`\n/// under our range assumptions\n///\n/// ## Completeness\n/// In general, this method is not *complete*: if the admissible range of `A` and `B`\n/// is large enough relative to the circuit `Field` prime `p`, an honest prover with\n/// `A != B (mod MOD)` can still hit an alias where\n/// (A - B) * (A - B + MOD) * (A - B - MOD) == 0 (mod p),\n/// i.e.\n/// - A = B (mod p), or\n/// - A = B + MOD (mod p), or\n/// - A = B - MOD (mod p).\n///\n/// For random `A, B` in such a wide range, the probability of this collision is\n/// roughly 3/p.\n///\n/// In case `MOD` < `p` this function becomes *complete*\npub(crate) fn assert_is_not_equal(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) {\n let mut l: Field = 0;\n let mut r: Field = 0;\n let mut modulus_mod_p: Field = 0;\n for i in 0..N {\n l *= TWO_POW_120 as Field;\n r *= TWO_POW_120 as Field;\n modulus_mod_p *= TWO_POW_120 as Field;\n\n l += lhs[N - i - 1] as Field;\n r += rhs[N - i - 1] as Field;\n modulus_mod_p += params.modulus[N - i - 1] as Field;\n }\n\n let diff: Field = l - r;\n let target: Field = diff * (diff + modulus_mod_p) * (diff - modulus_mod_p);\n assert(target != 0, \"assert_is_not_equal fail\");\n}\n\n/// Compute equality flag\n///\n/// A == B (mod MOD)\n/// We compute A - B and check whether it is `0` or `MOD`\n/// This is due to subtract constrains the diff value to be < 2^MOD_BITS, not < `MOD`\n///\n/// ## Soundness\n/// This function is conditionally *sound*. See `sub` for details\n///\n/// ## Completeness\n/// This function is *complete*. An honest prover will always be able to execute it.\n///\n/// ## TODO\n/// can do this more efficiently via witngen in unconstrained functions?\npub(crate) fn eq(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> bool {\n let diff: [u128; N] = sub::(params, lhs, rhs);\n is_zero::(params, diff)\n}\n\n/// Validate that `val` is not equal to zero when interpreted as an integer.\n///\n/// This enforces that at least one limb of `val` is non-zero.\n/// It does *not* check \"BigNum zero\" in the modular sense (e.g. it\n/// treats `MOD` as non-zero).\n///\n/// ## Assumptions\n/// * Each limb of `val` is range-constrained to be a 120-bit value:\n/// `0 <= val[i] < 2^120`.\n/// * For our concrete fields and limb counts we have `N * 2^120 < p`,\n/// so the sum of all limbs fits strictly inside the field modulus.\n///\n/// ## Completeness\n/// If `val` is non-zero as an integer, then at least one limb is non-zero,\n/// so the integer sum of the limbs satisfies `0 < limb_sum < p`. In this\n/// case `limb_sum != 0` in the `Field`, and the assertion passes.\n///\n/// ## Soundness\n/// If all limbs of `val` are zero, then `limb_sum` is zero as an integer\n/// and as a field element, so the assertion fails. A witness representing\n/// the zero integer can never satisfy this check.\n///\n/// ## Note\n/// This is slightly cheaper than doing `val != [0; N]`, as we avoid\n/// creating per-limb boolean equalities and chaining them with `and`s.\npub(crate) fn assert_is_not_zero_integer(val: [u128; N]) {\n let mut limb_sum: Field = 0;\n for i in 0..N {\n limb_sum += val[i] as Field;\n }\n assert(limb_sum != 0, \"assert_is_not_zero_integer fail\");\n}\n\n/// Check whether `val` is the zero `BigNum` in the integer sense.\n///\n/// This returns `true` iff all limbs of `val` are zero. It does *not*\n/// treat `MOD` as zero; for modular `BigNum` zero use `is_zero`.\n///\n/// See `assert_is_not_zero_integer` for the underlying assumptions.\n///\n/// ## Note\n/// This is slightly cheaper than testing `val == [0; N]`, as we avoid\n/// creating per-limb boolean equalities and chaining them with `and`s.\npub(crate) fn is_zero_integer(val: [u128; N]) -> bool {\n let mut limb_sum: Field = 0;\n for i in 0..N {\n limb_sum += val[i] as Field;\n }\n limb_sum == 0\n}\n\n/// Validate that a `BigNum` value is not zero modulo `MOD`.\n///\n/// Convenience wrapper around `assert_is_not_equal`.\npub(crate) fn assert_is_not_zero(\n params: BigNumParams,\n val: [u128; N],\n) {\n assert_is_not_equal::(params, val, [0; N]);\n}\n\n/// Check whether a `BigNum` value is zero modulo `MOD`.\n///\n/// This treats both the all-zero limb vector and `params.modulus` as\n/// representing zero. It assumes that all valid `BigNum` values are\n/// range-constrained so that no other representatives of `0 (mod MOD)`\n/// can appear.\n///\n/// ## Note\n/// This is cheaper than calling `eq(val, [0; N])`\npub(crate) fn is_zero(\n params: BigNumParams,\n val: [u128; N],\n) -> bool {\n is_zero_integer(val) | (val == params.modulus)\n}\n\n/// Validate a `BigNum` instance is correctly range constrained to contain no more than `MOD_BITS` bits\n///\n/// Constrain the `BigNum` instance to be < 2^MOD_BITS by:\n/// - Constraining each limb(0..N-2) to be 120-bit limb\n/// - Constraining the last limb to be `MOD_BITS - 120 * (N - 1)`\n///\n/// ## Note\n/// This can be a very expensive function, when the `TOP_LIMB_BITS` is uncommon\n///\n/// For example: BLS12_377Fr, with `TOP_LIMB_BITS`=13\n/// It creates a new 13-bit range table, which consists of roughly 3k variables\n/// And ~2k circuit gates\n///\n/// Compare this to BLS12_377Fq, with `TOP_LIMB_BITS`=17\n/// It is nicely decomposed into\n/// 14-bit range check and 3-bit range check - much much cheaper, since 14-bit range checks\n/// are already pretty common for 120-bit range checks\npub(crate) fn validate_in_range(limbs: [T; N])\nwhere\n T: Into,\n{\n for i in 0..(N - 1) {\n limbs[i].into().assert_max_bit_size::<120>();\n }\n\n limbs[N - 1].into().assert_max_bit_size::();\n}\n\n/// Validate quotient produced from `evaluate_quadratic_expression` is well-formed\n///\n/// Because the inputs into `evaluate_quadratic_expression` may cause the quotient to extend beyond `Params::modulus_bits`.\n/// We allow the quotient to extend `6` bits beyond `Params::modulus_bits()`\n/// Why is this?\n/// several factors: 1. quotient * modulus , limbs cannot overflow `Field` boundary (254 bits)\n/// 2. in `evaluate_quadratic_expression`, we require that for `expression - quotient * modulus`,\n/// limbs cannot exceed `246` bits (246 magic number due to a higher number adding extra range check gates)\n/// because of factor 2 and the fact that modulus limbs are 120 bits, quotient limbs cannot be > 126 bits\npub(crate) fn validate_quotient_in_range(limbs: [u128; N]) {\n for i in 0..(N - 1) {\n (limbs[i] as Field).assert_max_bit_size::<120>();\n }\n (limbs[N - 1] as Field).assert_max_bit_size::();\n}\n\n/// Validate that `lhs - rhs` does not underflow i.e. that lhs > rhs over the integers\n///\n/// Compute `result = lhs - rhs` along with `borrow_flags`,\n/// then constrain `result` to be a valid `BigNum` value.\n///\n/// ## Completeness\n/// This function is complete and will work only if `lhs > rhs` over the integers.\n///\n/// ## Soundness\n/// This function is sound:\n/// result[0] = lhs[0] - rhs[0] + bf[0] * 2^{120} < 2^{120}\n/// result[i] = lhs[i] - rhs[i] + bf[i] * 2^{120} - bf[i - 1] < 2^{120}, i = 1..N-2\n/// result[N - 1] = lhs[N - 1] - rhs[N - 1] - bf[N - 2] < 2^{TOP_LIMB_BITS}\n/// result != 0\n///\n/// If `lhs < rhs`, then some limb of `result` would have to borrow from a higher limb,\n/// which is impossible because the top limb cannot borrow\n/// Without the extra borrow, the resulting difference will be wrapped around the `Field` modulus\n/// And won't satisfy the range constraint, since all the limbs are < 2^120\n///\n/// ## Note\n/// `assert_is_not_zero_integer(result)` is crucial. Without it, we could always provide\n/// two identical inputs `x`, `x` and set `borrow_flags = [false; N]`,\n/// which would satisfy the limb constraints.\n///\n/// Also note that `underflow` is not properly constrained, so it just hangs there for\n/// completeness\npub(crate) fn validate_gt(lhs: [u128; N], rhs: [u128; N]) {\n // Safety: compute borrow flags out-of-circuit\n let (underflow, result, borrow_flags): (bool, [u128; N], [bool; N - 1]) =\n unsafe { __validate_gte_with_flags(lhs, rhs) };\n\n // Completeness: require that no underflow occurred\n assert(!underflow, \"validate_gt fail\");\n\n // Constrain the `result` to be a valid `BigNum` value\n validate_in_range::(result);\n // Constrain it to be strict inequality\n assert_is_not_zero_integer(result);\n\n // Constrain `result` and `borrow_flags` to match the expected arithmetic\n check_gte_with_flags(lhs, rhs, result, borrow_flags);\n}\n\n/// Constraining function for the results of `__validate_gte_with_flags`,\n/// used by both `cmp` and `validate gt`\n///\n/// This function checks the relations between `lhs`, `rhs`, `result` adn `borrow_flags`:\n/// lhs[0] - rhs[0] - result[0] + bf[0] * 2^{120} = 0\n/// lhs[i] - rhs[i] - result[i] + bf[i] * 2^{120} - bf[i - 1] = 0, i = 1..N-2\n/// lhs[N - 1] - rhs[N - 1] - result[N - 1] - bf[N - 2] = 0\npub(crate) fn check_gte_with_flags(\n lhs: [u128; N],\n rhs: [u128; N],\n result: [u128; N],\n borrow_flags: [bool; N - 1],\n) {\n let result_limb: Field = (lhs[0] as Field) - (rhs[0] as Field) - (result[0] as Field)\n + (borrow_flags[0] as Field) * TWO_POW_120 as Field;\n assert(result_limb == 0);\n\n for i in 1..N - 1 {\n let result_limb: Field = (lhs[i] as Field) - (rhs[i] as Field) - (result[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field);\n assert(result_limb == 0);\n }\n\n let result_limb: Field = (lhs[N - 1] as Field)\n - (rhs[N - 1] as Field)\n - (result[N - 1] as Field)\n - (borrow_flags[N - 2] as Field);\n assert(result_limb == 0);\n}\n\n/// Validate that `val` <= `MOD`\n///\n/// Compute `result = MOD - val` along with `borrow_flags`,\n/// then constrain `result` to be a valid `BigNum` value.\n///\n/// Basically the same as `validate_gt` but we compute the result on the fly\n/// It is just a bit more optimized as we expect each `BigNum` value to be \\leq `MOD`\n///\n/// ## Note\n/// In contrast to `validate_gt`, we allow the value to be `MOD`\n/// Since it is consistent with the rest of the library\npub(crate) fn validate_in_field(\n params: BigNumParams,\n val: [u128; N],\n) {\n let modulus: [u128; N] = params.modulus;\n\n // Safety: compute borrow flags out-of-circuit\n let borrow_flags: [bool; (N - 1)] =\n unsafe { __validate_in_field_compute_borrow_flags(params, val) };\n\n let mut p_minus_self: [Field; N] = [0; N];\n p_minus_self[0] = (modulus[0] as Field) - (val[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field);\n for i in 1..N - 1 {\n p_minus_self[i] = (modulus[i] as Field) - (val[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field);\n }\n p_minus_self[N - 1] =\n (modulus[N - 1] as Field) - (val[N - 1] as Field) - (borrow_flags[N - 2] as Field);\n validate_in_range::(p_minus_self);\n}\n\n/// Compare two `BigNum` values\n///\n/// Returns `lhs > rhs`\n///\n/// ## Note\n/// This is a strict value comparison over the integers,\n/// the values do not have to be reduced modulo `MOD`.\npub(crate) fn cmp(lhs: [u128; N], rhs: [u128; N]) -> Ordering {\n // Safety: we constrain:\n // - `result` and `borrow_flags` with `check_gte_with_flags`\n // - `borrow_flags` are also booleans\n // - `underflow` with the following swap and (bool)\n let (underflow, result, borrow_flags): (bool, [u128; N], [bool; N - 1]) =\n unsafe { __validate_gte_with_flags(lhs, rhs) };\n\n // if underflow is true, swap lhs and rhs\n let (lhs, rhs): ([u128; N], [u128; N]) = if underflow { (rhs, lhs) } else { (lhs, rhs) };\n\n // Constrain the `result` to be a valid `BigNum` value\n validate_in_range::(result);\n\n // Constrain subtraction: result = lhs - rhs with borrow_flags\n check_gte_with_flags(lhs, rhs, result, borrow_flags);\n\n if lhs == rhs {\n Ordering::equal()\n } else if underflow {\n Ordering::less()\n } else {\n Ordering::greater()\n }\n}\n\n// ------------------------------ ARITHMETIC FUNCTIONS ------------------------------\n\n/// Negate a `BigNum` value\n///\n/// Computes `result = MOD - val` using limb-wise subtraction with borrow flags,\n/// then constrains:\n/// - all `result` limbs to be a valid `BigNum` value, and\n/// - the subtraction relation with the borrow flags\n///\n/// ## Assumptions\n/// - `val` is a valid `BigNum` in the range `0 <= val <= MOD`.\n///\n/// ## Soundness\n/// This function constrains the following relations:\n/// result[0] = MOD[0] - val[0] + bf[0] * 2^{120} < 2^{120}\n/// result[i] = MOD[i] - val[i] + bf[i] * 2^{120} - bf[i - 1] < 2^{120}, i = 1..N-2\n/// result[N - 1] = MOD[N - 1] - val[N - 1] - bf[N - 2] < 2^{TOP_LIMB_BITS}\n///\n/// If all `MOD` and `val` limbs are valid `BigNum` limbs, these constraints\n/// ensure that:\n/// - the borrow flags `bf[i]` form a valid limb-wise subtraction chain, and\n/// - no underflow can occur in the subtraction `MOD - val`.\n///\n/// ## Completeness\n/// This function is complete for inputs in the range `0 <= val <= MOD`.\n/// If a value `val > MOD` is passed in (while still `< 2^{MOD_BITS}`), the\n/// constraints above will fail, since there is no valid borrow chain making\n/// `MOD - val` a well-formed `BigNum`.\n///\n/// In practice, honest provers should not hit this case: all functions in this\n/// module are expected to return values `< MOD`.\n///\n/// ## Note\n/// This function returns `MOD` when `val` is zero.\npub(crate) fn neg(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n if std::runtime::is_unconstrained() {\n // Safety: no need to constrain in an unconstrained runtime\n unsafe {\n __neg(params.modulus, val)\n }\n } else {\n // Safety: compute borrow flags out-of-circuit\n let (result, borrow_flags): ([u128; N], [bool; N - 1]) =\n unsafe { __neg_with_flags(params.modulus, val) };\n validate_in_range::(result);\n\n let result_limb: Field = (params.modulus[0] as Field)\n - (val[0] as Field)\n - (result[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n\n for i in 1..N - 1 {\n let result_limb: Field = (params.modulus[i] as Field)\n - (val[i] as Field)\n - (result[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field);\n assert(result_limb == 0);\n }\n\n let result_limb: Field = (params.modulus[N - 1] as Field)\n - (val[N - 1] as Field)\n - (result[N - 1] as Field)\n - (borrow_flags[N - 2] as Field);\n assert(result_limb == 0);\n result\n }\n}\n\n/// Add two `BigNum` values\n///\n/// Computes `result = lhs + rhs` using limb-wise addition with carry flags,\n/// and an optional subtraction of `MOD` using borrow flags. The function then\n/// constrains:\n/// - all `result` limbs to be a valid `BigNum` value, and\n/// - the addition/subtraction relation with the carry/borrow flags and the\n/// `overflow_modulus` bit.\n///\n/// ## Assumptions\n/// - All limbs of `lhs`, `rhs` and `MOD` are valid `BigNum` limbs\n/// (120-bit for non-top limbs, `TOP_LIMB_BITS` for the top limb).\n/// - Semantically, we intend to use this only with `0 <= lhs, rhs < MOD`,\n/// even though the limb/range constraints allow values up to `< 2^{MOD_BITS}`.\n///\n/// ## Soundness (intended relation)\n/// This function constrains the following equations:\n///\n/// result[0] = lhs[0] + rhs[0]\n/// - sub[0]\n/// + bf[0] * 2^{120}\n/// - cf[0] < 2^{120}\n///\n/// result[i] = lhs[i] + rhs[i]\n/// - sub[i]\n/// + bf[i] * 2^{120} - bf[i - 1]\n/// - cf[i] * 2^{120} + cf[i - 1] < 2^{120},\n/// for i = 1..N-2\n///\n/// result[N - 1] = lhs[N - 1] + rhs[N - 1]\n/// - sub[N - 1]\n/// - bf[N - 2]\n/// + cf[N - 2] < 2^{TOP_LIMB_BITS}\n///\n/// where:\n/// - `bf[i]` are the borrow flags of the optional subtraction,\n/// - `cf[i]` are the carry flags of the addition, and\n/// - `sub` is either the zero vector or `MOD`, depending on the\n/// `overflow_modulus` flag:\n/// * `overflow_modulus = 0` => `sub = 0`\n/// * `overflow_modulus = 1` => `sub = MOD`\n///\n/// If `lhs`, `rhs` and `MOD` are valid `BigNum` limbs and the witness for\n/// `(bf, cf, overflow_modulus)` is the honest one produced by `__add_with_flags`,\n/// these constraints enforce:\n/// - a valid limb-wise carry chain for `lhs + rhs`, and\n/// - a valid limb-wise subtraction chain for either `lhs + rhs` or\n/// `lhs + rhs - MOD`, with no underflow in any limb.\n///\n/// Under these assumptions the constrained result equals:\n///\n/// result = lhs + rhs (mod MOD)\n///\n/// in the intended arithmetic.\n///\n/// ## Limitations / extra satisfying witnesses\n///\n/// The constraint system itself does **not** uniquely determine the carry/borrow\n/// flags nor the `overflow_modulus` bit:\n///\n/// - For each limb `i`, `bf[i]` and `cf[i]` only appear in the combination\n/// `bf[i] * 2^{120} - cf[i] * 2^{120}`. This means that both\n///\n/// (bf[i], cf[i]) = (0, 0) and (bf[i], cf[i]) = (1, 1)\n///\n/// give the same contribution to the equation. As a result, there are multiple\n/// valid flag assignments for the *same* `lhs`, `rhs`, `sub` and `result`.\n///\n/// - More importantly, if `lhs + rhs` is greater than `MOD` but still strictly\n/// less than `2^{MOD_BITS}`, there exist *spurious* witnesses where:\n/// * `overflow_modulus` is set inconsistently with the true arithmetic\n/// overflow, and\n/// * the `(bf, cf)` flags are adjusted accordingly,\n///\n/// such that all equations above still hold and all `result` limbs remain\n/// within range. In particular, when\n///\n/// lhs + rhs + MOD < 2^{MOD_BITS},\n///\n/// a malicious prover can \"hide\" an extra `MOD` inside the choice of\n/// `overflow_modulus`, `bf` and `cf`, so that the circuit is satisfied by a\n/// witness\n///\n/// Consequently, this function is only *conditionally* sound: we rely on the\n/// out-of-circuit implementation of `__add_with_flags` to provide the honest\n/// `(borrow_flags, carry_flags, overflow_modulus)` witness. Under that\n/// assumption, the constrained `result` matches `lhs + rhs (mod MOD)`.\n///\n/// ## Completeness\n///\n/// For inputs in the range `0 <= lhs, rhs < MOD` and honest flags from\n/// `__add_with_flags`, the constraints are complete: every valid `BigNum` sum\n/// `lhs + rhs (mod MOD)` admits a satisfying assignment.\n///\n/// Inputs with `lhs` or `rhs` in `[MOD, 2^{MOD_BITS})` are still representable\n/// as limb arrays and may admit satisfying witnesses, but then the operation\n/// no longer corresponds to a unique, well-defined addition in the field\n/// `Z / MOD Z`. Such uses are outside the intended semantics of this function.\npub(crate) fn add(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n if std::runtime::is_unconstrained() {\n // Safety: no need to constrain in unconstrained runtime\n unsafe {\n __add(params.modulus, lhs, rhs)\n }\n } else {\n // Safety: compute borrow/carry flags out-of-circuit\n let (result, carry_flags, borrow_flags, overflow_modulus): ([u128; N], [bool; N - 1], [bool; N - 1], bool) =\n unsafe { __add_with_flags(params.modulus, lhs, rhs) };\n validate_in_range::(result);\n\n let mut subtrahend: [u128; N] = if overflow_modulus {\n params.modulus\n } else {\n [0; N]\n };\n\n let result_limb: Field = (lhs[0] as Field) + (rhs[0] as Field)\n - (result[0] as Field)\n - (subtrahend[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[0] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n for i in 1..N - 1 {\n let result_limb: Field = (lhs[i] as Field) + (rhs[i] as Field)\n - (result[i] as Field)\n - (subtrahend[i] as Field)\n - (borrow_flags[i - 1] as Field)\n + (carry_flags[i - 1] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[i] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n }\n let result_limb: Field = (lhs[N - 1] as Field) + (rhs[N - 1] as Field)\n - (result[N - 1] as Field)\n - (subtrahend[N - 1] as Field)\n - (borrow_flags[N - 2] as Field)\n + (carry_flags[N - 2] as Field);\n assert(result_limb == 0);\n result\n }\n}\n\n/// Subtract two `BigNum` values\n///\n/// Computes `result = lhs - rhs` using limb-wise subtraction with borrow flags,\n/// and an optional addition of `MOD` using carry flags. The function then\n/// constrains:\n/// - all `result` limbs to be a valid `BigNum` value, and\n/// - the subtraction/addition relation with the carry/borrow flags and the\n/// `underflow_modulus` bit.\n///\n/// ## Assumptions\n/// - All limbs of `lhs`, `rhs` and `MOD` are valid `BigNum` limbs\n/// (120-bit for non-top limbs, `TOP_LIMB_BITS` for the top limb).\n/// - Semantically, we intend to use this only with `0 <= lhs, rhs < MOD`,\n/// even though the limb/range constraints allow values up to `< 2^{MOD_BITS}`.\n///\n/// ## Soundness (intended relation)\n/// This function constrains the following equations:\n///\n/// result[0] = lhs[0] - rhs[0]\n/// + add[0]\n/// + bf[0] * 2^{120}\n/// - cf[0] < 2^{120}\n///\n/// result[i] = lhs[i] - rhs[i]\n/// + add[i]\n/// + bf[i] * 2^{120} - bf[i - 1]\n/// - cf[i] * 2^{120} + cf[i - 1] < 2^{120},\n/// for i = 1..N-2\n///\n/// result[N - 1] = lhs[N - 1] - rhs[N - 1]\n/// + add[N - 1]\n/// - bf[N - 2]\n/// + cf[N - 2] < 2^{TOP_LIMB_BITS}\n///\n/// where:\n/// - `bf[i]` are the borrow flags of the subtraction,\n/// - `cf[i]` are the carry flags of the optional addition, and\n/// - `add` is either the zero vector or `MOD`, depending on the\n/// `underflow_modulus` flag:\n/// * `underflow_modulus = 0` => `add = 0`\n/// * `underflow_modulus = 1` => `add = MOD`\n///\n/// If `lhs`, `rhs` and `MOD` are valid `BigNum` limbs and the witness for\n/// `(bf, cf, underflow_modulus)` is the honest one produced by `__sub_with_flags`,\n/// these constraints enforce:\n/// - a valid limb-wise borrow chain for `lhs - rhs`, and\n/// - a valid limb-wise addition chain for either `lhs - rhs` or\n/// `lhs - rhs + MOD`, with no underflow in any limb.\n///\n/// Under these assumptions the constrained result equals:\n///\n/// result = lhs - rhs (mod MOD)\n///\n/// in the intended arithmetic.\n///\n/// ## Limitations / extra satisfying witnesses\n///\n/// The constraint system itself does **not** uniquely determine the carry/borrow\n/// flags nor the `underflow_modulus` bit:\n///\n/// - For each limb `i`, `bf[i]` and `cf[i]` only appear in the combination\n/// `bf[i] * 2^{120} - cf[i] * 2^{120}`. This means that both\n///\n/// (bf[i], cf[i]) = (0, 0) and (bf[i], cf[i]) = (1, 1)\n///\n/// give the same contribution to the equation. As a result, there are multiple\n/// valid flag assignments for the *same* `lhs`, `rhs`, `add` and `result`.\n///\n/// - More importantly, when `lhs < rhs`, the true field result is\n///\n/// lhs - rhs + MOD,\n///\n/// and as long as\n///\n/// lhs - rhs + MOD < 2^{MOD_BITS},\n///\n/// a malicious prover can:\n/// * set `underflow_modulus` inconsistently with the true underflow, and\n/// * adjust the `(bf, cf)` flags accordingly,\n///\n/// such that all equations above still hold and all `result` limbs remain\n/// within range. In other words, the circuit can be satisfied by a witness\n/// that does **not** correspond to the unique intended subtraction modulo\n/// `MOD` for some inputs with `lhs < rhs`.\n///\n/// Consequently, this function is only *conditionally* sound: we rely on the\n/// out-of-circuit implementation of `__sub_with_flags` to provide the honest\n/// `(borrow_flags, carry_flags, underflow_modulus)` witness. Under that\n/// assumption, the constrained `result` matches `lhs - rhs (mod MOD)`.\n///\n/// ## Completeness\n///\n/// For inputs in the range `0 <= lhs, rhs < MOD` and honest flags from\n/// `__sub_with_flags`, the constraints are complete: every valid `BigNum`\n/// difference `lhs - rhs (mod MOD)` admits a satisfying assignment.\n///\n/// Inputs with `lhs` or `rhs` in `[MOD, 2^{MOD_BITS})` are still representable\n/// as limb arrays and may admit satisfying witnesses, but then the operation\n/// no longer corresponds to a unique, well-defined subtraction in the field\n/// `Z / MOD Z`. Such uses are outside the intended semantics of this function.\npub(crate) fn sub(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n if std::runtime::is_unconstrained() {\n // Safety: no need to constrain in unconstrained runtime\n unsafe {\n __sub(params.modulus, lhs, rhs)\n }\n } else {\n // Safety: we constrain carry, borrow, underflow and result immediately\n let (result, carry_flags, borrow_flags, underflow_modulus): ([u128; N], [bool; N - 1], [bool; N - 1], bool) =\n unsafe { __sub_with_flags(params.modulus, lhs, rhs) };\n validate_in_range::(result);\n\n let mut addend: [u128; N] = if underflow_modulus {\n params.modulus\n } else {\n [0; N]\n };\n\n let result_limb: Field = (lhs[0] as Field) - (rhs[0] as Field) - (result[0] as Field)\n + (addend[0] as Field)\n + (borrow_flags[0] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[0] as Field) * (TWO_POW_120 as Field);\n assert(result_limb == 0);\n\n for i in 1..N - 1 {\n let result_limb: Field = (lhs[i] as Field) - (rhs[i] as Field) - (result[i] as Field)\n + (addend[i] as Field)\n + (borrow_flags[i] as Field) * (TWO_POW_120 as Field)\n - (carry_flags[i] as Field) * (TWO_POW_120 as Field)\n - (borrow_flags[i - 1] as Field)\n + (carry_flags[i - 1] as Field);\n assert(result_limb == 0);\n }\n let result_limb: Field = (lhs[N - 1] as Field)\n - (rhs[N - 1] as Field)\n - (result[N - 1] as Field)\n + (addend[N - 1] as Field)\n - (borrow_flags[N - 2] as Field)\n + (carry_flags[N - 2] as Field);\n assert(result_limb == 0);\n result\n }\n}\n\n/// Compute the `BigNum` multiplication\n///\n/// Computes `result = lhs * rhs (mod MOD)` by:\n/// 1. Computing `result` out of circuit via `__mul`.\n/// 2. Constraining the quadratic relation `lhs * rhs - result = 0` with\n/// `evaluate_quadratic_expression`.\n///\n/// ## Soundness\n/// Soundness reduces to `evaluate_quadratic_expression` for the relation\n/// `lhs * rhs - result = 0`\n///\n/// ## Note\n/// When possible, prefer expressing your computation directly as a quadratic\n/// relation and calling `evaluate_quadratic_expression` instead of using `mul`\npub(crate) fn mul(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n // Safety: we constrain the multiplication result immediately after\n let result: [u128; N] = unsafe { __mul::(params, lhs, rhs) };\n if !std::runtime::is_unconstrained() {\n // lhs * rhs - result = 0\n evaluate_quadratic_expression(\n params,\n [[lhs]],\n [[false]],\n [[rhs]],\n [[false]],\n [result],\n [true],\n );\n }\n result\n}\n\n/// Compute the `BigNum` squaring\n///\n/// Computes `result = val * val (mod MOD)` by:\n/// 1. Computing `result` out of circuit via `__sqr`.\n/// 2. Constraining the quadratic relation `val * val - result = 0` with\n/// `evaluate_quadratic_expression`.\n///\n/// ## Soundness\n/// Soundness reduces to `evaluate_quadratic_expression` for the relation\n/// `val * val - result = 0`\n///\n/// ## Note\n/// When possible, prefer expressing your computation directly as a quadratic\n/// relation and calling `evaluate_quadratic_expression` instead of using `sqr`\npub(crate) fn sqr(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n // Safety: we constrain the multiplication result immediately after\n let result: [u128; N] = unsafe { __sqr::<_, MOD_BITS>(params, val) };\n if !std::runtime::is_unconstrained() {\n // val * val - result = 0\n evaluate_quadratic_expression(\n params,\n [[val]],\n [[false]],\n [[val]],\n [[false]],\n [result],\n [true],\n );\n }\n result\n}\n\n/// Compute the `BigNum` division\n///\n/// Computes `result = lhs * rhs^{-1} (mod MOD)` by:\n/// 1. Computing `result` out of circuit via `__div`.\n/// 2. Constraining the quadratic relation `result * rhs - lhs = 0` with\n/// `evaluate_quadratic_expression`.\n/// 3. Enforcing `rhs != 0 (mod MOD)`.\n///\n/// ## Soundness\n/// Soundness reduces to `evaluate_quadratic_expression` for the relation\n/// `result * rhs - lhs = 0`, together with the non-zero check on `rhs` and the\n/// assumption that `MOD` has multiplicative inverses for all non-zero elements\n/// (`params.has_multiplicative_inverse = true`).\n///\n/// ## Note\n/// - This is **expensive** in witness time due to modular inversion.\n/// - When possible, prefer expressing your computation directly as a quadratic\n/// relation and calling `evaluate_quadratic_expression` instead of using `div`.\n/// - In the unconstrained runtime, the behavior of `__div` on zero divisors is\n/// not constrained by this function.\npub(crate) fn div(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n assert(\n params.has_multiplicative_inverse,\n \"BigNum has no multiplicative inverse. Use udiv for unsigned integer division\",\n );\n // Safety: We constrain the result of division immediately after\n let result: [u128; N] = unsafe { __div::<_, MOD_BITS>(params, lhs, rhs) };\n if !std::runtime::is_unconstrained() {\n // result * rhs - lhs = 0\n evaluate_quadratic_expression(\n params,\n [[result]],\n [[false]],\n [[rhs]],\n [[false]],\n [lhs],\n [true],\n );\n assert_is_not_zero(params, rhs);\n }\n result\n}\n\n/// Compute the `BigNum` integer division with remainder\n///\n/// Computes `quotient = floor(numerator / divisor)` and\n/// `remainder = numerator % divisor` by:\n/// 1. Computing `(quotient, remainder)` out of circuit via `__udiv_mod`.\n/// 2. Constraining the quadratic relation\n/// quotient * divisor + remainder - numerator = 0\n/// with `validate_udiv_mod_expression`.\n/// 3. Enforcing `remainder < divisor`.\n///\n/// ## Soundness\n/// Soundness reduces to `validate_udiv_mod_expression` for the relation\n/// quotient * divisor + remainder - numerator = 0,\n/// together with `remainder < divisor` check enforced via `validate_gt`.\n///\n/// Under these checks, any satisfying assignment corresponds to a valid\n/// integer division `numerator = quotient * divisor + remainder` with\n/// `0 <= remainder < divisor`\n///\n/// ## Note\n/// Enforcing `divisor != 0` is not necessary. `remainder < divisor`\n/// Already enforces this.\npub(crate) fn udiv_mod(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> ([u128; N], [u128; N]) {\n // Safety: We constrain the result of __udiv_mod immediately after\n let (quotient, remainder): ([u128; N], [u128; N]) = unsafe { __udiv_mod(numerator, divisor) };\n if !std::runtime::is_unconstrained() {\n // quotient * divisor + remainder - numerator = 0\n validate_udiv_mod_expression::(numerator, divisor, quotient, remainder);\n // remainder < divisor\n validate_gt::(divisor, remainder);\n }\n (quotient, remainder)\n}\n\n/// Compute the `BigNum` integer division\n///\n/// Returns `floor(numerator / divisor)`.\n/// All constraints and soundness details are handled inside `udiv_mod`.\npub(crate) fn udiv(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> [u128; N] {\n udiv_mod::(numerator, divisor).0\n}\n\n/// Compute the `BigNum` remainder\n///\n/// Returns `numerator % divisor`.\n/// All constraints and soundness details are handled inside `udiv_mod`.\npub(crate) fn umod(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> [u128; N] {\n udiv_mod::(numerator, divisor).1\n}","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/constrained_ops.nr"},"121":{"source":"use crate::utils::split_bits;\n\nuse crate::constants::{TWO_POW_120, TWO_POW_126, TWO_POW_246};\n\nuse crate::fns::constrained_ops::{validate_in_range, validate_quotient_in_range};\nuse crate::fns::unconstrained_helpers::__barrett_reduction;\nuse crate::fns::unconstrained_ops::__is_zero;\n\nuse crate::params::BigNumParams;\n\n// ------------------------------ UNCONSTRAINED EXPRESSIONS ------------------------------\n\n/// Compute the result of a linear combination of (possibly negative) `BigNum` values (unconstrained)\n///\n/// ## Note\n/// 1. `modulus2` is structured such that all limbs will be greater than `0`, even when subtracting.\n/// To do this, when computing `p - x`, we ensure that each limb in `p` is greater than each limb in `x`.\n/// We know that, for a valid bignum element, the limbs in `x` will be < 2^{120}\n/// Therefore each of the limbs in `p` (except the most significant) will borrow 2^{120} from the more significant limb.\n/// Finally, to ensure we do not underflow in the most significant limb, we use `2p` instead of `p`\n///\n/// 2. Returns the `Field` values that are not normalized to be 120-bit\nunconstrained fn __add_linear_expression(\n params: BigNumParams,\n vals: [[u128; N]; M],\n flags: [bool; M],\n) -> ([Field; N]) {\n let mut sum: [Field; N] = [0; N];\n let modulus2: [u128; N] = params.double_modulus;\n for i in 0..M {\n if (flags[i]) {\n for j in 0..N {\n sum[j] = sum[j] + (modulus2[j] as Field) - (vals[i][j] as Field);\n }\n } else {\n for j in 0..N {\n sum[j] = sum[j] + (vals[i][j] as Field);\n }\n }\n }\n sum\n}\n\n/// Compute the limb products of a quadratic expression (unconstrained)\n///\n/// See `__compute_quadratic_expression_with_borrow_flags` for full description\n///\n/// ## Note\n/// Returns the `Field` values that are not normalized to be 120-bit\nunconstrained fn __compute_quadratic_expression_product(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> [Field; 2 * N] {\n let mut lhs: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n let mut rhs: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n\n for i in 0..NUM_PRODUCTS {\n lhs[i] = __add_linear_expression(params, lhs_terms[i], lhs_flags[i]);\n rhs[i] = __add_linear_expression(params, rhs_terms[i], rhs_flags[i]);\n }\n let add: [Field; N] = __add_linear_expression(params, linear_terms, linear_flags);\n\n let mut mulout: [Field; 2 * N] = [0; 2 * N];\n for i in 0..N {\n for j in 0..N {\n for k in 0..NUM_PRODUCTS {\n mulout[i + j] += lhs[k][i] * rhs[k][j];\n }\n }\n mulout[i] += add[i];\n }\n mulout\n}\n\n/// Compute the borrow flags for a limb-wise subtraction `lhs - rhs` (unconstrained).\n///\n/// This helper operates on `N`-limb values where each limb is interpreted as a\n/// 120-bit chunk (base `B = 2^{120}`), but where intermediate limbs may exceed\n/// `2^{120}` due to sums of products.\n///\n/// Conceptually, we want to model the integer subtraction\n///\n/// lhs - rhs\n///\n/// as a base-`B` subtraction with borrows, without allowing any intermediate\n/// values to go negative in the circuit field. We achieve this by:\n///\n/// 1. Working with widened 246-bit ranges per limb.\n/// 2. Encoding a borrow from limb `i+1` into limb `i` by:\n/// - adding `2^{246}` into limb `i`,\n/// - subtracting `2^{126}` (= 2^{246 - 120}) from limb `i+1` after\n/// scaling by `2^{-120}`.\n///\n/// The returned `borrow_flags[i]` indicate whether the canonical integer\n/// subtraction would borrow from limb `i+1` into limb `i`. These flags are\n/// later re-applied in-circuit via `apply_borrow_flags`, and the resulting\n/// limbs are checked by `validate_expression_is_zero`.\nunconstrained fn __compute_borrow_flags(\n mut lhs_limbs: [Field; N],\n rhs_limbs: [Field; N],\n) -> [bool; N - 1] {\n // compute borrow flags from mulout_p and mulout_n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n let borrow_shift: Field = TWO_POW_246; // 2^{246}\n let borrow_carry: Field = TWO_POW_126; // 2^{126} = 2^{246 - 120}\n let downshift_120: Field = 1 / (TWO_POW_120 as Field);\n\n // determine whether we need to borrow from more significant limbs.\n // initial limb is \"simple\" comparison operation\n borrow_flags[0] = lhs_limbs[0].lt(rhs_limbs[0]);\n\n // we have N - 1 borrow flags. The number of limbs is N\n // and there is nothing to borrow against for the final limb.\n let mut hi_bits: Field =\n (lhs_limbs[0] - rhs_limbs[0] + ((borrow_flags[0] as Field) * borrow_shift)) * downshift_120;\n\n for i in 1..(N - 1) {\n // compute the contribution from limb `i-1` that gets added into limb `i`, and add into limb `i`\n lhs_limbs[i] += hi_bits;\n\n let subtrahend: Field = rhs_limbs[i] + (borrow_flags[i - 1] as Field) * borrow_carry;\n\n // determine whether negative limb values are greater than positive limb values\n borrow_flags[i] = lhs_limbs[i].lt(subtrahend);\n let minuend: Field = lhs_limbs[i] + (borrow_flags[i] as Field) * borrow_shift;\n\n hi_bits = (minuend - subtrahend) * downshift_120;\n }\n borrow_flags\n}\n\n/// Given a degree-2 `BigNum` expression that is equal to `0 mod MOD`, compute\n/// the quotient and the borrow flags (unconstrained).\n///\n/// The expression has the form:\n///\n/// sum_{k=0}^{NUM_PRODUCTS-1} (L_k * R_k) + sum_{i=0}^{ADD_N-1} A_i = quotient * MOD\n///\n/// where each `L_k`, `R_k`, `A_i` is an `N`-limb `BigNum` assembled from the\n/// `(terms, flags)` arrays.\n///\n/// This helper:\n/// 1. Evaluates the quadratic expression into `mulout_p` as a `2N`-limb\n/// non-normalized value.\n/// 2. Normalizes `mulout_p` into 120-bit limbs and applies Barrett\n/// reduction to obtain `(quotient, remainder)`.\n/// 3. Asserts that the integer remainder is zero (debugging aid; range\n/// checks enforce this later).\n/// 4. Reconstructs `mulout_n = quotient * MOD`.\n/// 5. Computes `borrow_flags` for the limb-wise subtraction\n/// `mulout_p - mulout_n`,\n/// using the 2^{246}/2^{126} encoding described in\n/// `evaluate_quadratic_expression`.\n///\n/// The returned `quotient` and `borrow_flags` are later constrained\n/// in-circuit by `compute_quadratic_expression_with_modulus` and\n/// `evaluate_quadratic_expression`.\nunconstrained fn __compute_quadratic_expression_with_borrow_flags(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> ([u128; N], [bool; 2 * N - 2]) {\n let mulout_p: [Field; 2 * N] = __compute_quadratic_expression_product(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n\n // `__normalize_limbs` will validate that we do not overflow 2N, normally we should not overflow 2N-1\n let mut relation_result: [u128; 2 * N] = split_bits::__normalize_limbs(mulout_p);\n let (quotient, remainder): ([u128; N], [u128; N]) =\n __barrett_reduction(relation_result, params.redc_param, MOD_BITS, params.modulus);\n\n // This is verified later by the range checks but left for debugging purposes\n assert(__is_zero(remainder));\n\n // We do not normalize `mulout_n` so we won't fill the `2 * N - 1`\n let mut mulout_n: [Field; 2 * N] = [0; 2 * N];\n for i in 0..N {\n for j in 0..N {\n mulout_n[i + j] += (quotient[i] as Field) * (params.modulus[j] as Field);\n }\n }\n\n let borrow_flags: [bool; 2 * N - 1] = __compute_borrow_flags(mulout_p, mulout_n);\n\n // We have to copy it because we know that borrow_flags[2 * N - 1] is always 0\n // But we also have to provide 2 * N limbs to `__barrett_reduction`.\n // And keep `__compute_borrow_flags` generic enough\n let mut borrow_flags_real: [bool; 2 * N - 2] = [false; 2 * N - 2];\n for i in 0..2 * N - 2 {\n borrow_flags_real[i] = borrow_flags[i];\n }\n\n (quotient, borrow_flags_real)\n}\n\n/// Computes the quotient/remainder of a quadratic expression (unconstrained)\n///\n/// See `__compute_quadratic_expression_with_borrow_flags` for full description\npub(crate) unconstrained fn __compute_quadratic_expression(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> ([u128; N], [u128; N]) {\n let mulout: [Field; 2 * N] = __compute_quadratic_expression_product(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n // __normalize_limbs will validate that we do not overflow 2N, normally we should not overflow 2N-1\n let mut relation_result: [u128; 2 * N] = split_bits::__normalize_limbs(mulout);\n\n let (quotient, remainder): ([u128; N], [u128; N]) =\n __barrett_reduction(relation_result, params.redc_param, MOD_BITS, params.modulus);\n\n (quotient, remainder)\n}\n\n// ------------------------------ CONSTRAINED EXPRESSIONS ------------------------------\n\n/// Constrained version of `__add_linear_expression`\n///\n/// Computes all the linear parts of an expression in-circuit\n///\n/// ## Note\n/// 1. Negative terms are implemented by adding `double_modulus`\n/// `double_modulus` is chosen so that all limbs except the top one\n/// are > 2^{120}, which prevents underflows in intermediate computations.\n///\n/// 2. For the most significant limb we slightly reduce the padding (to keep the\n/// overall value equal to `2 * MOD`), so in principle there is a narrow edge\n/// case where that limb could underflow if enough negative contributions are\n/// accumulated and the top limb of `MOD` is very small. In practice, the\n/// global `BigNum` range and operand-count assumptions in\n/// `evaluate_quadratic_expression` rule out such patterns.\nfn compute_linear_expressions(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> ([[Field; N]; NUM_PRODUCTS], [[Field; N]; NUM_PRODUCTS], [Field; N]) {\n // lhs linear terms\n let mut lhs_linear: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n // rhs linear terms\n let mut rhs_linear: [[Field; N]; NUM_PRODUCTS] = [[0; N]; NUM_PRODUCTS];\n // linear terms\n let mut lin_expr: [Field; N] = [0; N];\n\n for k in 0..NUM_PRODUCTS {\n for i in 0..N {\n for j in 0..LHS_N {\n // Note: if lhs_flags[k][j] - `is_negative` is not known at comptime this is very expensive\n if (lhs_flags[k][j]) {\n lhs_linear[k][i] -= lhs_terms[k][j][i] as Field;\n lhs_linear[k][i] += params.double_modulus[i] as Field;\n } else {\n lhs_linear[k][i] += lhs_terms[k][j][i] as Field;\n }\n }\n for j in 0..RHS_N {\n // Note: if rhs_flags[k][j] - `is_negative` is not known at comptime this is very expensive\n if (rhs_flags[k][j]) {\n rhs_linear[k][i] -= rhs_terms[k][j][i] as Field;\n rhs_linear[k][i] += params.double_modulus[i] as Field;\n } else {\n rhs_linear[k][i] += rhs_terms[k][j][i] as Field;\n }\n }\n }\n }\n\n for i in 0..N {\n for j in 0..ADD_N {\n // Note: if linear_flags[j] - `is_negative` is not known at comptime this is very expensive\n if (linear_flags[j]) {\n lin_expr[i] -= linear_terms[j][i] as Field;\n lin_expr[i] += params.double_modulus[i] as Field;\n } else {\n lin_expr[i] += linear_terms[j][i] as Field;\n }\n }\n }\n\n (lhs_linear, rhs_linear, lin_expr)\n}\n\n/// Constrained version of `__compute_quadratic_expression_product`\n///\n/// Computes the following expression in-circuit:\n/// \\sum (L_i * R_i) + \\sum (A_i) - QUOTIENT * MOD\n///\n/// Because of the subtraction of `QUOTIENT * MODULUS`, the resulting limbs may\n/// underflow and represent *negative* values. To account for this, we allow the\n/// prover to choose a sequence of borrow flags and interpret the limbs with\n/// additional terms:\n///\n/// - for each limb `i` we may add `2^{246}` (via a flag at position `i`);\n/// - for each limb `i` we may subtract `2^{126 = 246 - 120}` (via the flag\n/// at position `i - 1`).\n///\n/// This corresponds to borrowing `2^{126}` from limb `i + 1` and adding\n/// `2^{246}` into limb `i`. After this adjustment, an honest prover can ensure\n/// that every limb lies in `[0, 2^{246})` and that the adjusted limbs encode\n/// the correct integer value.\n///\n/// Additionally, we constrain the quotient limbs via `validate_quotient_in_range`:\n/// - limbs `0..N-2` of `quotient` are < 2^{120};\n/// - the top limb is < 2^{TOP_LIMB_BITS + 6}.\n/// Which validates `quotient < 2^{MOD_BITS + 6}`\n///\n/// ## TODO\n/// Apply static or runtime checks in this method to validate that the effective\n/// `twiddle_factor` does not exceed 6 under the chosen parameters.\nfn compute_quadratic_expression_with_modulus(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) -> [Field; 2 * N - 1] {\n // Safety: use an unconstrained function to compute the value of the quotient and borrow_flags out-of-circuit\n let (quotient, borrow_flags): ([u128; N], [bool; 2 * N - 2]) = unsafe {\n __compute_quadratic_expression_with_borrow_flags::(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n )\n };\n\n // Constrain the `quotient < 2^{MOD_BITS + 6}`\n // By constraining limbs(0..N-2) to be < 2^120 and the the top limb < 2^{TOP_LIMB_BITS + 6}\n validate_quotient_in_range::(quotient);\n\n // Compute the linear sums that represent L_i, R_i, A\n let (lhs_linear, rhs_linear, lin_expr): ([[Field; N]; NUM_PRODUCTS], [[Field; N]; NUM_PRODUCTS], [Field; N]) = compute_linear_expressions::(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n\n // We want to evaluate that L * R + A - Quotient * MOD = 0, evaluated over the integers\n // For this we need to be able to borrow values from more-significant limbs into less-significant limbs,\n // so that we can ensure that no limbs will underflow\n let mut expression_limbs: [Field; 2 * N - 1] = [0; 2 * N - 1];\n\n // Compute the product t0 * t1 + t4 - Quotient * MOD\n // TODO: this is super nasty as it requires a multiplication\n for i in 0..N {\n for j in 0..N {\n for k in 0..NUM_PRODUCTS {\n if k == 0 {\n let new_term: Field = lhs_linear[k][i] * rhs_linear[k][j]\n - (quotient[i] as Field) * (params.modulus[j] as Field);\n // width-4 optimization\n std::as_witness(new_term);\n expression_limbs[i + j] += new_term;\n } else {\n expression_limbs[i + j] += lhs_linear[k][i] * rhs_linear[k][j];\n }\n }\n // This is the fallback for pure linear expression\n if (NUM_PRODUCTS == 0) {\n expression_limbs[i + j] -= (quotient[i] as Field) * (params.modulus[j] as Field);\n }\n }\n expression_limbs[i] += lin_expr[i];\n }\n\n apply_borrow_flags(expression_limbs, borrow_flags)\n}\n\n/// Apply a precomputed borrow chain to a limb array.\n///\n/// Given:\n///\n/// - `expression_limbs`: an `N`-limb array of `Field` values representing a\n/// (possibly non-normalized) degree-2-style expression, and\n/// - `borrow_flags[i]` indicating that we \"borrow\" from limb `i+1` into limb `i`,\n///\n/// this function applies the same 2^{246}/2^{126} encoding used in\n/// `__compute_borrow_flags` to produce an adjusted limb array\n///\n/// This matches the behavior of `__compute_borrow_flags`, which conceptually:\n///\n/// 1. Adds `2^{246}` into a limb when a borrow is taken at that limb;\n/// 2. After scaling by `2^{-120}`, contributes `2^{126}` into the next limb.\n///\n/// The resulting `expression_limbs` can then be passed to\n/// `validate_expression_is_zero`, which:\n///\n/// - right-shifts by 120 bits per limb,\n/// - enforces a 126-bit bound,\n/// - and propagates carries forward, finally checking that the most\n/// significant limb is zero.\n///\n/// ## Assumptions\n///\n/// - `borrow_flags` was computed consistently with the original construction\n/// of `expression_limbs` (e.g. via `__compute_borrow_flags` on the\n/// corresponding unconstrained expression).\n/// - The caller has ensured that each adjusted limb remains < 2^{246} for\n/// honest witnesses (e.g. via `NUM_PRODUCTS < 64`).\n///\n/// ## Note\n///\n/// This function does not itself enforce any bit-size bounds; it only applies\n/// the borrow encoding. The actual range checks happen later in\n/// `validate_expression_is_zero`.\n///\n/// ## TODO\n/// define trade-offs regarding the value of borrow_shift\n/// (the larger the value, the greater the range check that is required on product_limbs)\n/// (126-bit range check is a sweet spot for the barretenberg backend as it decomposes into 9 14-bit range checks)\n/// (the barretenberg backend can evaluate these in 5.25 gates. 127 bits costs 6.5 gates)\nfn apply_borrow_flags(\n mut expression_limbs: [Field; N],\n borrow_flags: [bool; N - 1],\n) -> [Field; N] {\n let borrow_shift: Field = TWO_POW_246; // 2^{246}\n let borrow_carry: Field = TWO_POW_126; // 2^{246 - 120} = 2^{126}\n\n // Get the product_limbs into the form where each entry is a 246-bit value\n expression_limbs[0] += (borrow_flags[0] as Field) * borrow_shift;\n for i in 1..(N - 1) {\n expression_limbs[i] += (borrow_flags[i] as Field) * borrow_shift\n - (borrow_flags[i - 1] as Field) * borrow_carry;\n }\n expression_limbs[N - 1] -= (borrow_flags[N - 2] as Field) * borrow_carry;\n expression_limbs\n}\n\n/// Validate that `limbs` represent the integer value `0`\n///\n/// ## Assumptions\n/// - `limbs` is an array of `Field` values that was derived arithmetically as\n/// a degree-2 expression\n/// - each limb satisfies `limbs[i] < 2^{246}`, as ensured by\n/// `compute_quadratic_expression_with_modulus` under its parameter bounds.\n///\n/// ## Details\n/// Each element `i` in `limbs` overlaps in bit-range with element `i+1`, EXCEPT for the low 120 bits\n/// i.e. we need to do the following for each limb `i`:\n/// 1. validate the limb's low-120 bits equals zero\n/// 2. compute the limb \"carry\" by right-shifting by 2^{120}\n/// 3. propagate the \"carry\" into limb `i+1`\n/// We can efficiently do all of the above by multiplying the limb by 2^{-120} and constraining the result to be <2^{126}\n///\n/// If the low 120 bits are nonzero, there is no value in `[0, 2^{126})` that\n/// could have produced this limb after multiplying by `2^{120}`. Since\n/// multiplication by `2^{120}` is a bijection on the Field, any limb with\n/// non-zero low 120 bits must map outside the `[0, 2^{126})` range after\n/// scaling by `2^{-120}`.\n///\n/// The most significant limb has no limb to \"carry\" values into - the entire limb must equal zero\n///\n/// ## Note\n/// The constant 126 is not arbitrary. We use 120-bit limbs and allow up to 64\n/// products per limb, which contributes at most `log2(64) = 6` bits of headroom.\n/// After scaling by `2^{-120}`, honest witnesses fit in 126 bits. We could in\n/// principle go higher (up to roughly `CircuitModulusBits - 121`), but 126 is\n/// the minimal bound consistent with `NUM_PRODUCTS < 64` and is significantly\n/// cheaper than larger bounds for the barretenberg backend.\nfn validate_expression_is_zero(mut limbs: [Field; N]) {\n let hi_shift: Field = TWO_POW_120 as Field;\n let hi_downshift: Field = 1 / hi_shift;\n for i in 0..N - 1 {\n limbs[i] *= hi_downshift;\n std::as_witness(limbs[i]);\n limbs[i].assert_max_bit_size::<126>(); // N.B. is this sufficient? going beyond 126 costs us 1 gate per limb\n limbs[i + 1] += limbs[i];\n }\n assert(limbs[N - 1] == 0);\n}\n\n/// Constrain a degree-2 `BigNum` expression to be equal to 0 (mod `MOD`)\n///\n//\n/// This method is intended for relations where the remainder term of the\n/// degree-2 expression is exactly zero as an integer relation. In other words,\n/// we use it only when we expect:\n///\n/// \\sum (L_i * R_i) + \\sum (A_i) - QUOTIENT * MOD = 0\n///\n/// as integers, not just modulo the circuit field or `BigNum` field.\n///\n/// ## Details\n///\n/// The constrained expression, viewed over the integers, is:\n///\n/// \\sum_{i=0}^{NUM_PRODUCTS-1} (L_i * R_i)\n/// + \\sum_{i=0}^{ADD_N-1} (A_i)\n/// - QUOTIENT * MOD\n/// = 0\n///\n/// Each `L_i`, `R_i`, `A_i` is an `N`-limb `BigNum` assembled from the\n/// `(terms, flags)` arrays. For example, for `i = 0`:\n///\n/// L_0 = \\sum_{j=0}^{LHS_N-1} lhs[0][j] as a `BigNum`\n/// R_0 = \\sum_{j=0}^{RHS_N-1} rhs[0][j] as a `BigNum`\n///\n/// The intent is to capture a generic degree-2 expression within Noir's\n/// limitations (no efficient dynamically sized vectors).\n///\n/// The expensive parts of this algorithm are:\n/// 1. evaluating the limb products required to compute the `L_i * R_i` values;\n/// 2. applying range constraints to validate that the result encodes 0.\n///\n/// ## Note\n/// When the expression is evaluated over `N`-limb `BigNum` values, the product\n/// has up to `2N - 1` significant limbs. Each limb is a sum of at most\n/// `NUM_PRODUCTS` products of `linear` 120-bit limbs and `quadratic` 240-bit-ish limbs\n///\n/// Note that:\n/// * limb-wise multiplication is not uniform across indices. For example:\n///\n/// [x0, x1, x2] * [y0, y1, y2] =\n/// [\n/// x0*y0, // 1 term\n/// x0*y1 + x1*y0, // 2 terms\n/// x0*y2 + x1*y1 + x2*y0, // 3 terms\n/// x1*y2 + x2*y1, // 2 terms\n/// x2*y2 // 1 term\n/// ]\n/// The number of partial products per limb grows linearly from 1 to N,\n/// then decreases linearly back to 1.\n///\n/// * we also allow linear combinations inside the products, which further increases the bound\n/// on a `quadratic` limb\n///\n/// * finally, when `is_negative` flag is set, we effectively add 2 * MOD to each limb, where\n/// 2 * MOD limbs are structured in such a way that they all are > 2**120\n///\n/// We allow `NUM_PRODUCTS < 64` completeness-wise, but it certainly can overflow the 2^{240 + `twiddle_factor=6`} bound\n/// in edge cases. See completeness section for an example.\n///\n/// ## Assumptions\n///\n/// Each `BigNum` value used in this gadget is already range constrained:\n/// - limbs `0..N-2` satisfy `limb_i < 2^{120}`\n/// - limb `N-1` satisfies `limb_{N-1} < 2^{TOP_LIMB_BITS}`\n///\n/// ## Completeness\n/// If an honest prover supplies inputs that satisfy the assumptions above,\n/// it can always find a `quotient` and `borrow_flags` such that the integer\n/// relation holds and all constraints are satisfied.\n///\n/// The only possibility to break completeness is by providing too many inputs, for example:\n///\n/// (a0 + a1 + a2) * (b0 + b1 + b2) + ... (60 times), with each a_i having its limbs at maximum value of 2^{120} - 1\n/// The middle limb will contain a value that will definitely overflow the 2^{246} bound.\n///\n/// ## Soundness\n/// This function is conditionally sound: it enforces that the degree-2 relation\n/// holds modulo `MOD`, but it does not, by itself, enforce that any particular\n/// term (for example a result `z`) is a *canonical* representative in\n/// `[0, MOD)`.\n///\n/// In other words, if the surrounding relation is invariant under adding a\n/// multiple of `MOD` to one of its terms, then a dishonest prover can exploit\n/// this. For example, consider a multiplication relation:\n///\n/// x * y - z = 0 (mod MOD)\n///\n/// Internally we encode this as:\n///\n/// x * y + 2 * MOD - z - quotient * MOD = 0\n///\n/// which is equivalent to:\n///\n/// x * y - z = (quotient - 2) * MOD\n///\n/// Suppose the honest witness uses some `z` satisfying\n/// `0 <= z < MOD` and some `quotient`. If the `BigNum` encoding allows\n/// `z' = z + MOD` (i.e. `z' < 2^{MOD_BITS}` still holds), then a dishonest\n/// prover can instead provide:\n///\n/// z' = z + MOD\n/// quotient' = quotient - 1\n///\n/// and still satisfy:\n///\n/// x * y + 2 * MOD - z' - quotient' * MOD = 0\n///\n/// even though `z'` is no longer the canonical representative of `x * y mod MOD`.\n///\n/// The same consideration applies to almost every constrained `BigNum` relation:\n/// whenever a value participates *only* through a modular equality, and no\n/// separate range constraint is imposed on that value, the prover is free to\n/// shift it by an extra `MOD` as long as the resulting limb\n/// encoding still satisfies its bit-bounds. This is inherent in working with\n/// modular constraints; the responsibility for enforcing canonical\n/// representatives lies with the caller when it is required.\n///\n/// This is the same \"extra modulus\" phenomenon as in the `add`/`sub` functions:\n/// the constraints are sound for modular arithmetic, but any caller that\n/// requires canonical outputs in `[0, MOD)` must additionally enforce a\n/// range check (for example via `validate_in_field`) on the relevant terms.\npub(crate) fn evaluate_quadratic_expression(\n params: BigNumParams,\n lhs_terms: [[[u128; N]; LHS_N]; NUM_PRODUCTS],\n lhs_flags: [[bool; LHS_N]; NUM_PRODUCTS],\n rhs_terms: [[[u128; N]; RHS_N]; NUM_PRODUCTS],\n rhs_flags: [[bool; RHS_N]; NUM_PRODUCTS],\n linear_terms: [[u128; N]; ADD_N],\n linear_flags: [bool; ADD_N],\n) {\n assert(NUM_PRODUCTS < 64, f\"evaluate_quadratic_expression overflow in operands count\");\n // NUM_PRODUCTS < 64 is a light bound that tries to ensure each limb sum < 2^{246} so that the 126-bit bound is valid.\n\n lhs_terms.for_each(|lhs_limbs: [[u128; N]; LHS_N]| {\n lhs_limbs.for_each(|term: [u128; N]| validate_in_range::(term))\n });\n rhs_terms.for_each(|rhs_limbs: [[u128; N]; RHS_N]| {\n rhs_limbs.for_each(|term: [u128; N]| validate_in_range::(term))\n });\n linear_terms.for_each(|term: [u128; N]| validate_in_range::(term));\n\n let expression_limbs: [Field; 2 * N - 1] = compute_quadratic_expression_with_modulus::(\n params,\n lhs_terms,\n lhs_flags,\n rhs_terms,\n rhs_flags,\n linear_terms,\n linear_flags,\n );\n validate_expression_is_zero(expression_limbs);\n}\n\n// ------------------------------ UDIV MOD EXPRESSION ------------------------------\n\n/// Given a `udiv_mod` `BigNum` expression that is equal to `0` over integers, compute the borrow flags (unconstrained)\n///\n/// Mirror function of `__compute_quadratic_expression_with_borrow_flags` optimized to compute borrow flags of an expression:\n/// divisor * quotient + remainder - numerator = 0\n/// see `__compute_quadratic_expression_with_borrow_flags` for details\n///\n/// The main differences from it are:\n/// 1. `product_limbs` stores only the least-significant `N` limbs of\n/// `quotient * divisor + remainder`. This is sufficient to compute the\n/// borrow flags for the first `N` limbs of\n/// quotient * divisor + remainder - numerator.\n///\n/// For an honest `udiv_mod` relation we also have\n/// quotient * divisor <= numerator < B^N,\n/// so the true product fits into `N` limbs as an integer.\n/// 2. Instead of subtracting `quotient * MOD` we subtract `numerator`. This is due to the fact that\n/// we no longer work over `MOD`, and we can't really do subtractions as we did previously: `double_modulus - x`\n///\n/// ## Note\n/// We leave the borrow values at 2^{246}, even though we should never reach this bound with just 3 terms\n/// The cases where it can happen are: N >= 64 (middle limb will have 64 additions). And it is a pure completeness issue\n/// But the rest of the library will probably not work with that massive number anyway\nunconstrained fn __compute_udiv_mod_expression_with_borrow_flags(\n numerator: [u128; N],\n divisor: [u128; N],\n quotient: [u128; N],\n remainder: [u128; N],\n) -> [bool; N - 1] {\n let mut product_limbs: [Field; N] = [0; N];\n let mut numerator_field: [Field; N] = [0; N];\n for i in 0..N {\n for j in 0..N - i {\n product_limbs[i + j] += (quotient[i] as Field) * (divisor[j] as Field);\n }\n product_limbs[i] += (remainder[i] as Field);\n\n numerator_field[i] = numerator[i] as Field;\n }\n\n __compute_borrow_flags(product_limbs, numerator_field)\n}\n\n/// Constrained version of `__compute_udiv_mod_expression_with_borrow_flags`\n///\n/// Computes the following expression in-circuit:\n/// quotient * divisor + remainder - numerator = 0\n///\n/// Mirror function of `compute_quadratic_expression_with_modulus`. See it for details.\n///\n/// ## Soundness note\n/// We compute the full convolution `quotient * divisor` into `2N - 1` limbs\n/// and then constrain all limbs with index `i >= N` to be zero. For `i >= N`\n/// the value `expression_limbs_full[i]` is a sum of products\n/// sum_{j+k=i} quotient[j] * divisor[k]\n/// with no contribution from `numerator` or `remainder`.\n///\n/// Every limb of `quotient` and `divisor` is range-constrained to be a 120-bit\n/// integer, so each product term is < 2^{240} and each coefficient of the\n/// convolution is strictly smaller than the field modulus. In this regime,\n/// the constraint `expression_limbs_full[i] == 0` in `Field` coincides with\n/// the same equality over the integers.\n///\n/// Vanishing of all high limbs `i >= N` is therefore an integer statement that\n/// the product has degree < N, i.e.\n/// quotient * divisor < 2^{120 * N},\n/// so `quotient * divisor` fits into `N` 120-bit limbs and does not overflow.\nfn compute_udiv_mod_expression(\n numerator: [u128; N],\n divisor: [u128; N],\n quotient: [u128; N],\n remainder: [u128; N],\n) -> [Field; N] {\n // Safety: use an unconstrained function to compute the value of the quotient and borrow_flags out-of-circuit\n let borrow_flags: [bool; N - 1] = unsafe {\n __compute_udiv_mod_expression_with_borrow_flags::(\n numerator,\n divisor,\n quotient,\n remainder,\n )\n };\n\n let mut expression_limbs_full: [Field; 2 * N - 1] = [0; 2 * N - 1];\n for i in 0..N {\n for j in 0..N {\n expression_limbs_full[i + j] += (quotient[i] as Field) * (divisor[j] as Field);\n }\n expression_limbs_full[i] += (remainder[i] as Field) - (numerator[i] as Field);\n }\n\n let mut expression_limbs: [Field; N] = [0; N];\n for i in 0..N {\n expression_limbs[i] = expression_limbs_full[i];\n }\n for i in N..2 * N - 1 {\n assert(expression_limbs_full[i] == 0);\n }\n\n apply_borrow_flags(expression_limbs, borrow_flags)\n}\n\n/// Constrain a `udiv_mod` `BigNum` expression to be equal to 0\n///\n/// Mirror function of `evaluate_quadratic_expression`\n///\n/// ## Details\n///\n/// The constrained expression, viewed over the integers, is:\n///\n/// quotient * divisor + remainder - numerator = 0\n///\n/// ## Completeness\n/// If an honest prover supplies valid `BigNum` inputs that satisfy the equation,\n/// it can always find `borrow_flags` such that the integer\n/// relation holds and all constraints are satisfied.\n///\n/// The only possibility to break completeness is by providing a `BigNum` with `N >= 64`\n/// See `__compute_udiv_mod_expression_with_borrow_flags` for details\n///\n/// ## Soundness\n/// This function is conditionally sound: it enforces that the degree-2 relation\n/// holds over the integers, but it does not, by itself, enforce that\n/// this relation is unique for given `numerator` and `divisor`\n///\n/// For example, if the true relation is\n/// quotient * divisor + remainder - numerator = 0\n///\n/// then we can set quotient' = quotient - 1, remainder' = remainder + divisor\npub(crate) fn validate_udiv_mod_expression(\n numerator: [u128; N],\n divisor: [u128; N],\n quotient: [u128; N],\n remainder: [u128; N],\n) {\n validate_in_range::(numerator);\n validate_in_range::(divisor);\n validate_in_range::(quotient);\n validate_in_range::(remainder);\n\n let expression_limbs: [Field; N] =\n compute_udiv_mod_expression::(numerator, divisor, quotient, remainder);\n validate_expression_is_zero(expression_limbs);\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/expressions.nr"},"124":{"source":"// This file contains the unconstrained helpers that are mostly used by unconstrained ops\n\nuse crate::constants::TWO_POW_120;\n\nuse crate::fns::unconstrained_ops::{__add, __eq, __gte, __mul, __neg, __pow, __sqr};\n\nuse crate::utils::msb::get_msb;\nuse crate::utils::split_bits::{__normalize_limbs, __split_120_bits};\n\nuse crate::params::BigNumParams;\n\n// ------------------------------ DERIVATION HELPER FUNCTIONS ------------------------------\n\n/// Construct a `1` BigNum value (unconstrained)\npub(crate) unconstrained fn __one() -> [u128; N] {\n let mut limbs: [u128; N] = [0; N];\n limbs[0] = 1;\n limbs\n}\n\n/// Construct a BigNum value from Field (unconstrained)\n///\n/// Split the native `Field` value into `N` 120-bit limbs\npub(crate) unconstrained fn __from_field(val: Field) -> [u128; N] {\n let mut x: Field = val;\n let mut result: [u128; N] = [0; N];\n\n if (N == 1) {\n let (first_limb, _): (u128, Field) = __split_120_bits(x);\n result[0] = first_limb;\n }\n\n if (N == 2) {\n let (first_limb, x): (u128, Field) = __split_120_bits(x);\n let (second_limb, _): (u128, Field) = __split_120_bits(x);\n result[0] = first_limb;\n result[1] = second_limb;\n }\n\n if (N > 2) {\n let (first_limb, x): (u128, Field) = __split_120_bits(x);\n let (second_limb, x): (u128, Field) = __split_120_bits(x);\n let (third_limb, _): (u128, Field) = __split_120_bits(x);\n result[0] = first_limb;\n result[1] = second_limb;\n result[2] = third_limb;\n }\n result\n}\n\n// ------------------------------ ARITHMETIC WITH FLAGS HELPER FUNCTIONS ------------------------------\n// These are the functions that compute modular operations results as well as borrow and carry flags for constraints\n\n/// Compute the `MOD - val` and the corresponding borrow flags (unconstrained)\n///\n/// Negate the value and compute the flags indicating whether we need\n/// to borrow a `bit` from the upper limb when subtracting the value from modulus\n///\n/// ## Note\n/// The `borrow_in` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __neg_with_flags(\n modulus: [u128; N],\n val: [u128; N],\n) -> ([u128; N], [bool; N - 1]) {\n let mut result: [u128; N] = [0; N];\n let mut borrow_in: u128 = 0;\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n for i in 0..N {\n let sub_term: u128 = val[i] + borrow_in;\n borrow_in = (sub_term > modulus[i]) as u128;\n result[i] = borrow_in * TWO_POW_120 + modulus[i] - sub_term;\n if (i < N - 1) {\n borrow_flags[i] = (borrow_in != 0);\n }\n }\n (result, borrow_flags)\n}\n\n/// Compute modular addition and the corresponding borrow and carry flags (unconstrained)\n///\n/// Given `x, y, MOD` compute x + y or x + y - MOD in case it overflows\n/// Additionally compute all the carries from addition (x + y)\n/// and borrows from subtraction (- MOD)\n///\n/// ## Note\n/// The `borrow` must be equal to `carry` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __add_with_flags(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> ([u128; N], [bool; N - 1], [bool; N - 1], bool) {\n let mask: u128 = TWO_POW_120 - 1;\n\n let add_res: [u128; N] = __helper_add(lhs, rhs);\n let overflow: bool = __gte(add_res, modulus);\n\n let mut subtrahend: [u128; N] = if overflow { modulus } else { [0; N] };\n let mut result: [u128; N] = [0; N];\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n let mut carry_flags: [bool; N - 1] = [false; N - 1];\n\n let mut carry: u128 = 0;\n let mut borrow: u128 = 0;\n for i in 0..N {\n let mut add_term: u128 = lhs[i] + rhs[i] + carry;\n carry = add_term >> 120;\n add_term &= mask;\n\n let sub_term: u128 = subtrahend[i] + borrow;\n borrow = (sub_term > add_term) as u128;\n\n result[i] = borrow * TWO_POW_120 + add_term - sub_term;\n\n // Only set `borrow` and `carry` if they differ\n // And if it's not the last limb\n if (carry != borrow) & (i < N - 1) {\n carry_flags[i] = carry != 0;\n borrow_flags[i] = borrow != 0;\n }\n }\n (result, carry_flags, borrow_flags, overflow)\n}\n\n/// Compute modular subtraction and the corresponding borrow and carry flags (unconstrained)\n///\n/// Given `x, y, MOD` compute x - y or x - y + MOD in case it overflows\n/// Additionally compute all the carries from addition (x + MOD)\n/// and borrows from subtraction (- y)\n///\n/// ## Note\n/// The `borrow` must be equal to `carry` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __sub_with_flags(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> ([u128; N], [bool; N - 1], [bool; N - 1], bool) {\n let mask: u128 = TWO_POW_120 - 1;\n\n let underflow: bool = !__gte(lhs, rhs);\n\n let addend: [u128; N] = if underflow { modulus } else { [0; N] };\n let mut result: [u128; N] = [0; N];\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n let mut carry_flags: [bool; N - 1] = [false; N - 1];\n\n let mut carry: u128 = 0;\n let mut borrow: u128 = 0;\n for i in 0..N {\n let mut add_term: u128 = lhs[i] + addend[i] + carry;\n carry = add_term >> 120;\n add_term &= mask;\n\n let sub_term: u128 = rhs[i] + borrow;\n borrow = (sub_term > add_term) as u128;\n\n result[i] = borrow * TWO_POW_120 + add_term - sub_term;\n\n // Only set `borrow` and `carry` if they differ\n // And if it's not the last limb\n if (carry != borrow) & (i < N - 1) {\n carry_flags[i] = carry != 0;\n borrow_flags[i] = borrow != 0;\n }\n }\n (result, carry_flags, borrow_flags, underflow)\n}\n\n/// Validate that lhs - rhs does not underflow (unconstrained)\n///\n/// Same as `__validate_gte_with_flags`, but we don't compute the\n/// result of a subtraction\npub(crate) unconstrained fn __validate_in_field_compute_borrow_flags(\n params: BigNumParams,\n val: [u128; N],\n) -> [bool; N - 1] {\n let modulus: [u128; N] = params.modulus;\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n borrow_flags[0] = modulus[0] < val[0];\n for i in 1..N - 1 {\n borrow_flags[i] = modulus[i] < val[i] + (borrow_flags[i - 1] as u128);\n }\n borrow_flags\n}\n\n/// Validate that lhs - rhs does not underflow (unconstrained)\n///\n/// Compute underflow flag (lhs < rhs)\n/// then perform subtraction with borrow flags\n///\n/// ## Note\n/// The `borrow` must be equal to 0 at the end of the loop.\n/// And it can't be nonzero, since we swap the terms at the beginning\npub(crate) unconstrained fn __validate_gte_with_flags(\n lhs: [u128; N],\n rhs: [u128; N],\n) -> (bool, [u128; N], [bool; N - 1]) {\n let mut a: [u128; N] = lhs;\n let mut b: [u128; N] = rhs;\n\n let underflow: bool = !__gte(lhs, rhs);\n // swap a and b if there's an underflow\n let (a, b): ([u128; N], [u128; N]) = if underflow { (b, a) } else { (a, b) };\n\n let mut result: [u128; N] = [0; N];\n\n let mut borrow_flags: [bool; N - 1] = [false; N - 1];\n\n let mut borrow: u128 = 0;\n for i in 0..N {\n let mut add_term: u128 = a[i];\n\n let sub_term: u128 = b[i] + borrow;\n borrow = (sub_term > add_term) as u128;\n\n result[i] = borrow * TWO_POW_120 + add_term - sub_term;\n\n if (i < N - 1) {\n borrow_flags[i] = borrow != 0;\n }\n }\n (underflow, result, borrow_flags)\n}\n\n// ------------------------------ BARRETT REDUCTION ------------------------------\n\n/// `BARRETT_REDUCTION_OVERFLOW_BITS` defines how large an input to barrett reduction can be\n///\n/// maximum value = modulus^2 << BARRETT_REDUCTION_OVERFLOW_BITS\n/// see __barrett_reduction for more details\ncomptime global BARRETT_REDUCTION_OVERFLOW_BITS: u32 = 4;\n\n/// Optimized modular multiplication (unconstrained)\n///\n/// The trick is to approximate 1/p with m/2**r, because division by 2**r is much cheaper\n/// In our case m = redc_param = floor(2^{MOD_BITS * 2 + BARRET_REDUCTION_OVERFLOW_BITS} / p)\n/// r = MOD_BITS * 2 + BARRET_REDUCTION_OVERFLOW_BITS\n///\n/// When we apply the barrett reduction, the maximum value of the output will be <= p * (1 + x/2^{2k})\n/// where p = modulus,\n/// x = reduction input\n///\n/// If x > p * p, we need k to be larger than modulus_bits()\n/// We hardcode k = 4, which means that the maximum value of x is approx. 16 * p * p\n/// This should be larger than most values put into `evaluate_quadratic_expression`\n///\n/// ## TODO\n/// Detect cases where x might be too large at comptime\n///\n/// ## Note\n/// very niche edge case error that we need to be aware of:\n/// N must be large enough to cover the modulus *plus* BARRETT_REDUCTION_OVERFLOW_BITS\n/// i.e. a 359-bit prime needs (I think) 4 limbs to represent or we may overflow\n/// when calling __barrett_reduction\n///\n/// ## Note on final reduction\n///\n/// Assumptions:\n/// - k = ceil(log2 p), so p <= 2^k\n/// - s = 4, m = redc_param = floor(2^{2*k + s}/p)\n/// - x < 16 * p^2 (x < 2^{2 * k + s})\n///\n/// Let m' = 2^{2*k + s} / p, and write m = m' - \\epsilon, \\epsilon \\in [0, 1)\n//\n/// quo = floor(x * m / 2^{2 * k + s}) = floor(x * m' / 2^{2 * k + s} - x * \\epsilon / 2^{2 * k + s}) =\n/// floor(x / p - x * \\epsilon / 2^{2 * k + s})\n///\n/// Bounds:\n/// quo <= floor(x / p)\n///\n/// floor(a - b) >= floor(a) - ceil(b) (known identity) =>\n/// quo >= floor(x / p) - ceil(x * \\epsilon / 2^{2 * k + s})\n/// >= floor(x / p) - ceil(x / 2^{2 * k + s}) (epsilon < 1)\n///\n/// x / 2^{2 * k + s} < C * p^2 / 2^{2 * k + s} <= C * 2^{2 * k} / 2^{2 * k + s} = C / 2^s\n///\n/// When the assumption holds (C = 16), ceil(x / 2^{2 * k + s}) = 1, for x > 0\n/// Therefore quo = {floor(x/p), floor(x/p) - 1}\n///\n/// In first case: rem = x - quo * p = x - floor(x/p) * p < p\n/// In second case: rem = x - (floor(x/p) - 1) * p = (x - floor(x/p) * p) + p -> need 1 subtraction\n///\n/// ### Note\n/// We allow 64 products to be summed inside the `evaluate_quadratic_expression`\n/// In that case x / 2^{2 * k + s} < 64 / 2^4 = 4 => hence we need to subtract modulus at most 4 times\n/// We can leave it 2 for now as it is unlikely to reach beyond 32 * p^2\n///\n/// In the worst case though, we will have the input > 64 * p^2\n/// (for example (a1 + b1) * (c1 + d1) + ... 64 times)\n/// This is highly unlikely though.\n///\n/// ### TODO:\n/// Possibly change the `BARRETT_REDUCTION_OVERFLOW_BITS` to 6, so that we need only 1 reduction here\n/// However we will have to recompute all the fields `redc_param`s and fix paramgen\npub(crate) unconstrained fn __barrett_reduction(\n x: [u128; 2 * N],\n redc_param: [u128; N],\n k: u32,\n modulus: [u128; N],\n) -> ([u128; N], [u128; N]) {\n // TODO: switch to __helper_mul, once the compiler is smart enough to handle this\n let mut mulout_field: [Field; 3 * N] = [0; 3 * N];\n for i in 0..(2 * N) {\n for j in 0..N {\n mulout_field[i + j] += (x[i] as Field) * (redc_param[j] as Field);\n }\n }\n let mulout: [u128; 3 * N] = __normalize_limbs(mulout_field);\n\n let quotient: [u128; 3 * N] = __shr(mulout, (k + k + BARRETT_REDUCTION_OVERFLOW_BITS));\n\n // Remove a bunch of zeros from the end\n let mut smaller_quotient: [u128; N] = [0; N];\n for i in 0..N {\n smaller_quotient[i] = quotient[i] as u128;\n }\n\n // long_quotient_mul_modulus can never exceed input value `x` so can fit into size-2 array\n let long_quotient_mul_modulus: [u128; 2 * N] = __helper_mul(smaller_quotient, modulus);\n let long_remainder: [u128; 2 * N] = __helper_sub(x, long_quotient_mul_modulus);\n\n // Remove a bunch of zeros from the end\n let mut remainder: [u128; N] = [0; N];\n for i in 0..N {\n remainder[i] = long_remainder[i];\n }\n\n for _ in 0..2 {\n if (__gte(remainder, modulus)) {\n remainder = __helper_sub(remainder, modulus);\n smaller_quotient = __increment(smaller_quotient);\n }\n }\n\n (smaller_quotient, remainder)\n}\n\n// ------------------------------ ARITHMETIC HELPER FUNCTIONS ------------------------------\n// These are the functions that operate on limbs as if they were just big integers\n\n/// Adds `1` to the BigNum value without modular reduction (unconstrained)\n///\n/// ## Note\n/// The `carry` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __increment(val: [u128; N]) -> [u128; N] {\n let mask: u128 = TWO_POW_120 - 1;\n\n let mut result: [u128; N] = [0; N];\n let mut carry: u128 = 1;\n for i in 0..N {\n let add_term: u128 = val[i] + carry;\n carry = add_term >> 120;\n result[i] = add_term & mask;\n }\n result\n}\n\n/// Adds two `BigNum` values without modular reduction (unconstrained).\n///\n/// ## Note\n/// The `carry` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __helper_add(lhs: [u128; N], rhs: [u128; N]) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let mut carry: u128 = 0;\n let mask: u128 = TWO_POW_120 - 1;\n\n for i in 0..N {\n let add_term: u128 = lhs[i] + rhs[i] + carry;\n carry = add_term >> 120;\n result[i] = add_term & mask;\n }\n result\n}\n\n/// Subtracts two `BigNum` values without modular reduction (unconstrained).\n///\n/// ## Note\n/// The `borrow` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __helper_sub(lhs: [u128; N], rhs: [u128; N]) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let mut borrow: u128 = 0;\n for i in 0..N {\n let subtrahend: u128 = rhs[i] + borrow;\n borrow = (subtrahend > lhs[i]) as u128;\n result[i] = (borrow << 120) + lhs[i] - subtrahend;\n }\n result\n}\n\n/// Multiplies two `BigNum` values without modular reduction (unconstrained).\n///\n/// Computes the full schoolbook product of two N-limb little-endian arrays\n///\n/// ## Note\n/// The mathematical product fits in `2 * N - 1` limbs, but we keep `2 * N`\n/// limbs intentionally as the extra high limb safely absorbs a possible single limb overflow\n/// for moduli close to `120 * N` bits.\npub(crate) unconstrained fn __helper_mul(\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; 2 * N] {\n let mut result: [Field; 2 * N] = [0; 2 * N];\n for i in 0..N {\n for j in 0..N {\n result[i + j] += (lhs[i] as Field) * (rhs[j] as Field);\n }\n }\n __normalize_limbs(result)\n}\n\n// ------------------------------ LOGIC HELPER FUNCTIONS ------------------------------\n// These are the functions that operate on limbs as if they were just big integers\n\n/// Left-shifts a `BigNum` value by `shift` bits (unconstrained).\n///\n/// Performs a bitwise left shift across limbs.\n///\n/// ## Note\n/// The most significant limb is truncated to 120 bits after the shift.\n///\n/// No bounds check is performed on `num_shifted_limbs`.\n/// However, we use it only in `__udiv_mod`, where it is not possible to reach\n/// `num_shifted_limbs` > `N`\npub(crate) unconstrained fn __shl(input: [u128; N], shift: u32) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let num_shifted_limbs: u32 = shift / 120;\n let limb_shift: u128 = (shift % 120) as u128;\n let remainder_shift: u128 = 120 - limb_shift;\n\n let mask: u128 = TWO_POW_120 - 1;\n let mut remainder: u128 = input[0] >> remainder_shift;\n\n result[num_shifted_limbs] = (input[0] << limb_shift) & mask;\n\n for i in 1..(N - num_shifted_limbs) {\n let value: u128 = input[i];\n let upshift: u128 = ((value << limb_shift) | remainder) & mask;\n result[i + num_shifted_limbs] = upshift;\n remainder = value >> remainder_shift;\n }\n result\n}\n\n/// Right-shifts a `BigNum` value by `shift` bits (unconstrained).\n///\n/// Performs a bitwise right shift across limbs.\n///\n/// # Note\n/// No bounds check is performed on `num_shifted_limbs`.\n/// However, we use it only in `__tonelli_shanks_sqrt`, where it is not possible to reach\n/// `num_shifted_limbs` > `N`\npub(crate) unconstrained fn __shr(input: [u128; N], shift: u32) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n\n let num_shifted_limbs: u32 = shift / 120;\n let limb_shift: u128 = (shift % 120) as u128;\n\n let remainder_shift: u128 = 120 - limb_shift;\n let low_mask: u128 = (1 as u128 << limb_shift) - 1;\n\n result[0] = input[num_shifted_limbs] >> limb_shift;\n for i in 1..(N - num_shifted_limbs) {\n let value: u128 = input[i + num_shifted_limbs];\n\n let carry: u128 = (value & low_mask) << remainder_shift;\n result[i - 1] |= carry;\n\n result[i] = value >> limb_shift;\n }\n result\n}\n\n/// Right-shifts a `BigNum` value by `1` bit (unconstrained)\n///\n/// # Note\n/// All the operations on limbs are executed in place\n/// to save opcodes\npub(crate) unconstrained fn __shr1(mut input: [u128; N]) -> [u128; N] {\n let value: u128 = input[N - 1];\n let mut remainder: u128 = (value & 1) << 119;\n input[N - 1] >>= 1;\n\n for i in 1..N {\n let value: u128 = input[N - 1 - i];\n input[N - 1 - i] = (value >> 1) | remainder;\n remainder = (value & 1) << 119;\n }\n input\n}\n\n/// Returns the index of the most significant set bit in a `BigNum` value (unconstrained).\npub(crate) unconstrained fn __get_msb(val: [u128; N]) -> u32 {\n let mut count: u32 = 0;\n for i in 0..N {\n let idx: u32 = N - 1 - i;\n let v: u128 = val[idx];\n if (v > 0) {\n count = 120 * idx + get_msb(v);\n break;\n }\n }\n count\n}\n\n/// Returns `true` if the bit at position `bit` is set in the `BigNum` (unconstrained).\n///\n/// ## Note\n/// No bounds check is performed on `bit`\npub(crate) fn __get_bit(input: [u128; N], bit: u32) -> bool {\n let segment_index: u32 = bit / 120;\n let uint_index: u128 = (bit % 120) as u128;\n\n let limb: u128 = input[segment_index];\n let value: u128 = (limb >> uint_index) & 1;\n value == 1\n}\n\n// ------------------------------ SQRT HELPER FUNCTIONS ------------------------------\n// These are the functions that are used during taking a square root\n\n/// Compute the maximal power of 2 that divides the group order (unconstrained)\n///\n/// Find the maximum value s such that `MOD = 2^s * q + 1`, where `q` is odd\n/// This is needed for our Tonelli-Shanks sqrt algorithm\npub(crate) unconstrained fn __primitive_root_log_size(\n params: BigNumParams,\n) -> u32 {\n let mut target: [u128; N] = __helper_sub(params.modulus, __one());\n let mut result: u32 = 0;\n while !__get_bit(target, result) {\n result += 1;\n }\n result\n}\n\n/// Find a quadratic non-residue `g` where `g` is the smallest such value (unconstrained)\n/// i.e. smallest `g` such that `g^{(p - 1)/2} = -1 (mod MOD)`\n/// or smallest `g`, such that `x^2 - g = 0 (mod MOD)` has no solutions\n///\n/// ## Note\n/// WARNING If the field is not prime, this function will enter an infinite loop!\npub(crate) unconstrained fn __quadratic_non_residue(\n params: BigNumParams,\n) -> [u128; N] {\n let one: [u128; N] = __one();\n let neg_one: [u128; N] = __neg(params.modulus, one);\n\n let p_minus_one_over_two: [u128; N] = __shr1(__helper_sub(params.modulus, __one()));\n\n // We start with 2\n let mut target: [u128; N] = __increment(one);\n let mut expd: [u128; N] = __pow(params, target, p_minus_one_over_two);\n while !__eq(expd, neg_one) {\n target = __increment(target);\n expd = __pow(params, target, p_minus_one_over_two);\n }\n target\n}\n\n/// Compute the smallest `i`, such that `t^{2^i} = 1, t^{2^{i-1}} = -1 (mod MOD)` (unconstrained)\n///\n/// ## Note\n/// Multiplicative order of t must divide 2^v2(MOD-1), otherwise you'll end up in an infinite loop!\npub(crate) unconstrained fn __tonelli_shanks_sqrt_find_i(\n params: BigNumParams,\n t: [u128; N],\n) -> u32 {\n let one: [u128; N] = __one();\n let mut c: [u128; N] = t;\n\n let mut i: u32 = 0;\n // Compute t^{2^k} until it hits 1 for the first time\n while !__eq(c, one) {\n c = __sqr::(params, c);\n i += 1;\n }\n i\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/unconstrained_helpers.nr"},"125":{"source":"// This file contains the unconstrained operations that are used directly by BigNum class\n\nuse crate::fns::constrained_ops::derive_from_seed;\n\nuse crate::fns::unconstrained_helpers::{\n __barrett_reduction, __get_bit, __get_msb, __helper_add, __helper_mul, __helper_sub,\n __increment, __one, __primitive_root_log_size, __quadratic_non_residue, __shl, __shr, __shr1,\n __tonelli_shanks_sqrt_find_i,\n};\n\nuse crate::constants::TWO_POW_120;\n\nuse crate::params::BigNumParams;\n\n// ------------------------------ DERIVATION FUNCTIONS ------------------------------\n\n/// Deterministically derives a `BigNum` from a seed value (unconstrained)\n///\n/// Takes a seed byte array and generates a `BigNum` in the range [0, modulus-1].\n///\n/// See more information in `constrained_ops.nr`: `derive_from_seed`\npub(crate) unconstrained fn __derive_from_seed(\n params: BigNumParams,\n seed: [u8; SeedBytes],\n) -> [u128; N] {\n derive_from_seed::(params, seed)\n}\n\n// ------------------------------ COMPARISON FUNCTIONS ------------------------------\n\n/// Compare two limb arrays for equality (unconstrained)\npub(crate) unconstrained fn __eq(lhs: [u128; N], rhs: [u128; N]) -> bool {\n lhs == rhs\n}\n\n/// Compare a limb array to a zero array (unconstrained)\npub(crate) unconstrained fn __is_zero(limbs: [u128; N]) -> bool {\n limbs == [0; N]\n}\n\n/// Compare two little-endian limb arrays for `lhs >= rhs` over integers (unconstrained)\n///\n/// Starts from the most significant limb (`N - 1`) and returns true\n/// if `lhs` is greater or equal to `rhs`\npub(crate) unconstrained fn __gte(lhs: [u128; N], rhs: [u128; N]) -> bool {\n let mut result: bool = true;\n for i in 0..N {\n let idx: u32 = N - 1 - i;\n if (lhs[idx] != rhs[idx]) {\n result = lhs[idx] > rhs[idx];\n break;\n }\n }\n result\n}\n\n// ------------------------------ ARITHMETIC FUNCTIONS ------------------------------\n\n/// Negates a `BigNum` value, returning `m - x` (unconstrained)\n///\n/// ## Note\n/// The input is assumed to be less than modulus\npub(crate) unconstrained fn __neg(modulus: [u128; N], limbs: [u128; N]) -> [u128; N] {\n __helper_sub(modulus, limbs)\n}\n\n/// Adds two `BigNum` values with modular reduction (unconstrained)\n///\n/// Sums the limbs one by one, keeping the carry.\n/// In case the result overflows the modulus, the modulus is subtracted once\n///\n/// ## Note\n/// The `carry` must be `0` at the end of the loop.\n/// No explicit assertion is made, as this condition is validated during evaluation.\npub(crate) unconstrained fn __add(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n let mut result: [u128; N] = [0; N];\n let mut carry: u128 = 0;\n let mask: u128 = TWO_POW_120 - 1;\n\n for i in 0..N {\n let add_term: u128 = (lhs[i] + rhs[i] + carry);\n carry = add_term >> 120;\n result[i] = add_term & mask;\n }\n\n // check if the result is greater than the modulus\n if __gte(result, modulus) {\n __helper_sub(result, modulus)\n } else {\n result\n }\n}\n\n/// Subtracts two `BigNum` values with modular reduction (unconstrained).\n///\n/// Computes `x + (m - y)` (mod m)\npub(crate) unconstrained fn __sub(\n modulus: [u128; N],\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n __add(modulus, lhs, __neg(modulus, rhs))\n}\n\n/// Multiply `x` and `y` and reduce via Barrett, returning (Q, R) (unconstrained).\n///\n/// For `BigNum` values `x` and `y` compute (`Q`, `R`) such that:\n/// x * y = R + Q * m, 0 <= R < m\n/// See `__barrett_reduction` for details.\npub(crate) unconstrained fn __mul_with_quotient(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> ([u128; N], [u128; N]) {\n let to_reduce: [u128; N * 2] = __helper_mul(lhs, rhs);\n let (q, r): ([u128; N], [u128; N]) =\n __barrett_reduction(to_reduce, params.redc_param, MOD_BITS, params.modulus);\n (q, r)\n}\n\n/// Multiplies two `BigNum` values with modular reduction (unconstrained).\npub(crate) unconstrained fn __mul(\n params: BigNumParams,\n lhs: [u128; N],\n rhs: [u128; N],\n) -> [u128; N] {\n __mul_with_quotient::(params, lhs, rhs).1\n}\n\n/// Squares a `BigNum` value with modular reduction (unconstrained).\npub(crate) unconstrained fn __sqr(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n __mul_with_quotient::(params, val, val).1\n}\n\n/// Modular exponentiation via square-and-multiply. LSB-first (unconstrained).\n///\n/// Computes `x^e mod m`\n///\n/// ## Note\n/// For the loop, we are using `MOD_BITS` instead of `__get_msb`\n/// because it is much much cheaper\npub(crate) unconstrained fn __pow(\n params: BigNumParams,\n val: [u128; N],\n exponent: [u128; N],\n) -> [u128; N] {\n let mut accumulator: [u128; N] = __one();\n let mut x: [u128; N] = val;\n let num_bits: u32 = MOD_BITS + 1;\n\n for i in 0..num_bits {\n if __get_bit(exponent, i) {\n accumulator = __mul::(params, accumulator, x);\n }\n x = __sqr::(params, x);\n }\n accumulator\n}\n\n/// Given a `BigNum` value `x` compute x^{-1} (mod m) (unconstrained)\n///\n/// x^{p-1} = 1 (mod p) (Fermat's little theorem)\n/// x^{p-2} = x^{-1} (mod p)\n///\n/// ## Note\n/// The input value must be nonzero and modulus has to be prime\n/// No explicit assertion is made, as this condition is validated during evaluation\npub(crate) unconstrained fn __invmod(\n params: BigNumParams,\n val: [u128; N],\n) -> [u128; N] {\n let one: [u128; N] = __one();\n let exp: [u128; N] = __helper_sub(params.modulus, __helper_add(one, one));\n __pow::(params, val, exp)\n}\n\n/// Divides two `BigNum` values with modular reduction (unconstrained).\n///\n/// Computes `x * y^{-1}` (mod m)\n///\n/// ## Note\n/// The divisor must be nonzero\n/// No explicit assertion is made, as this condition is validated during evaluation\npub(crate) unconstrained fn __div(\n params: BigNumParams,\n numerator: [u128; N],\n divisor: [u128; N],\n) -> [u128; N] {\n let inv_divisor: [u128; N] = __invmod::(params, divisor);\n __mul::(params, numerator, inv_divisor)\n}\n\n/// Given the `BigNum` inputs `x, y`, compute integer division x / y (unconstrained)\n///\n/// This function implements binary long division and outputs (`quotient`, `remainder`) such that:\n/// 1. floor(numerator / divisor) = quotient\n/// 2. numerator % divisor = remainder\n/// 3. divisor * quotient + remainder = numerator\n///\n/// ## Note\n/// The divisor must be nonzero\n/// No explicit assertion is made, as this condition is validated during evaluation\npub(crate) unconstrained fn __udiv_mod(\n numerator: [u128; N],\n divisor: [u128; N],\n) -> ([u128; N], [u128; N]) {\n let mut quotient: [u128; N] = [0; N];\n let mut remainder: [u128; N] = numerator;\n let b: [u128; N] = divisor;\n\n let numerator_msb: u32 = __get_msb(numerator);\n let divisor_msb: u32 = __get_msb(divisor);\n if divisor_msb > numerator_msb {\n ([0; N], numerator)\n } else {\n let mut bit_difference: u32 = __get_msb(remainder) - __get_msb(divisor);\n let mut divisor: [u128; N] = __shl(divisor, bit_difference);\n let mut accumulator: [u128; N] = __shl(__one(), bit_difference);\n\n // The same as divisor > remainder\n if (__gte(divisor, __increment(remainder))) {\n divisor = __shr1(divisor);\n accumulator = __shr1(accumulator);\n }\n\n for _ in 0..(N * 120) {\n if (__gte(remainder, b) == false) {\n break;\n }\n // we've shunted 'divisor' up to have the same bit length as our remainder.\n // If remainder >= divisor, then a is at least '1 << bit_difference' multiples of b\n if (__gte(remainder, divisor)) {\n remainder = __helper_sub(remainder, divisor);\n // we can use OR here instead of +, as\n // accumulator is always a nice power of two\n quotient = __helper_add(quotient, accumulator);\n }\n divisor = __shr1(divisor);\n accumulator = __shr1(accumulator);\n }\n\n (quotient, remainder)\n }\n}\n\n/// Batch modular inversion of `BigNum` values in an array (unconstrained)\n///\n/// Given values v[0..M), returns inv[0...M) with inv[i] = v[i]^{-1} (mod m)\n///\n/// We use the Montgomery trick:\n/// First we compute the partial products:\n/// T0 = 1\n/// T1 = v1,\n/// T2 = v1 * v2,\n/// ...\n/// T_{m - 1} = T_{m - 2} * v_{m - 1} = v1 * ... * v_{m - 1}\n///\n/// P = T_{m-1} * v_m = v1 * v2 * ... * v_m\n///\n/// Then we calculate a single inverse P^-1 = v1^-1 * v2^-1 * ... * v_m^-1\n/// Finally we compute\n/// v_m^-1 = (P^-1 * T_{m-1})\n/// v_{m - 1}^-1 = (P^-1 * v_m * T_{m - 2})\n/// ....\n/// v_2^-1 = (P^-1 * v_m * ... * v_3 * T_1)\n/// v_1^-1 = (P^-1 * v_m * ... * v_2 * T_0)\n///\n/// ## Note\n/// Zero elements are allowed and are left unchanged in the resulting array\n///\n/// This interacts poorly with `neg(zero)`:\n/// Calling `neg` on `zero` yields `modulus` rather than `0`.\n/// A value in this form will **not** satisfy\n/// the `__is_zero` check and will lead to incorrect results.\n///\n/// This edge case should be rare, but it's worth keeping in mind when\n/// composing operations or debugging unexpected behavior\npub(crate) unconstrained fn batch_invert(\n params: BigNumParams,\n vals: [[u128; N]; M],\n) -> [[u128; N]; M] {\n let mut accumulator: [u128; N] = __one();\n let mut temporaries: [[u128; N]; M] = [[0; N]; M];\n\n for i in 0..M {\n temporaries[i] = accumulator;\n if (!__is_zero(vals[i])) {\n accumulator = __mul::(params, accumulator, vals[i]);\n }\n }\n\n let mut result: [[u128; N]; M] = [[0; N]; M];\n accumulator = __invmod::(params, accumulator);\n for i in 0..M {\n let idx: u32 = M - 1 - i;\n if (!__is_zero(vals[idx])) {\n let T0: [u128; N] = __mul::(params, accumulator, temporaries[idx]);\n accumulator = __mul::(params, accumulator, vals[idx]);\n result[idx] = T0;\n }\n }\n result\n}\n\n/// Batch modular inversion of `BigNum` values in a slice (unconstrained)\n///\n/// See `batch_invert` for details\npub(crate) unconstrained fn batch_invert_slice(\n params: BigNumParams,\n vals: [[u128; N]],\n) -> [[u128; N]] {\n let mut accumulator: [u128; N] = __one();\n let mut temporaries: [[u128; N]] = &[];\n\n let M: u32 = vals.len();\n\n for i in 0..M {\n temporaries = temporaries.push_back(accumulator);\n if (!__is_zero(vals[i])) {\n accumulator = __mul::(params, accumulator, vals[i]);\n }\n }\n\n let mut result: [[u128; N]] = [];\n accumulator = __invmod::(params, accumulator);\n for i in 0..M {\n let idx: u32 = M - 1 - i;\n if (!__is_zero(vals[idx])) {\n let T0: [u128; N] = __mul::(params, accumulator, temporaries[idx]);\n accumulator = __mul::(params, accumulator, vals[idx]);\n result = result.push_front(T0);\n } else {\n result = result.push_front([0; N]);\n }\n }\n\n result\n}\n\n/// Compute a modular square root in a prime field (unconstrained)\npub(crate) unconstrained fn __sqrt(\n params: BigNumParams,\n input: [u128; N],\n) -> std::option::Option<[u128; N]> {\n assert(\n params.has_multiplicative_inverse,\n \"BigNum::__sqrt: Must be a field to take square roots\",\n );\n\n if (__is_zero(input)) {\n Option::some(input)\n } else if (params.modulus[0] % 4 == 3) {\n __easy_sqrt(params, input)\n } else {\n __tonelli_shanks_sqrt(params, input)\n }\n}\n\n/// Compute a modular square root using the Tonelli-Shanks algorithm (unconstrained)\n///\n/// Solves `x^2 = a (mod MOD)` for odd prime MOD\n///\n/// ## Algorithm\n///\n/// Here p = MOD\n///\n/// Tonelli-Shanks setup\n///\n/// Write `p - 1 = 2^s * Q`, `Q` - odd\n/// Define:\n/// `R = a^{(Q+1)/2}`\n/// `t = a^Q`\n///\n/// so that `R^2 = a^{Q + 1} = a * a^Q = a * t`\n/// If t = 1, we are done\n///\n/// By Euler's criterion, `a` is a quadratic reside iff `a^{(p - 1)/2} = 1`\n/// Since `t = a^Q` and `(p - 1) / 2 = Q * 2^{s-1}` we have:\n/// `t^{2^{s-1}} = a^{Q * 2^{s-1}} = a^{(p-1)/2} = 1`, assuming `a` is a q.r.\n///\n/// To proceed with computing our square root, we want to transfer `t` into a smaller subgroup,\n/// specifically, the `2^(s-2)`'th roots of unity or lower.\n///\n/// We do this by finding some value `b`, such that\n/// `(t * b^2)^{2^{s-2}} = 1` and `R' = R * b`\n/// Finding such a `b` is trivial, because from Euler's criterion, we know that,\n/// for any quadratic non-residue `z`, `z^{(p - 1) / 2} = -1`\n/// i.e. `z^{Q * 2^{s-1}} = -1`\n/// => `z^Q` is a `2^{s-1}`'th root of `-1`\n/// => `z^{2 * Q}` is a `2^{s-2}`'th root of `-1`\n///\n/// Since `t^{2^{s-1}} = 1`, we know that for some `i`, `i <= s - 2: t^{2^{i-1}} = -1`\n/// => `t * z^{2 * Q}` is a `2^{s - 2}`'th root of unity.\n/// We can iteratively transform `t` into ever smaller subgroups, until `t = 1`.\n/// At each iteration, we need to find a new value for `b`, which we can obtain\n/// by repeatedly squaring `z^Q`\n///\n/// ## Note\n/// Only use for prime fields! Function may infinite loop if used for non-prime fields\n///\n/// The input is assumed to be a nonzero value\npub(crate) unconstrained fn __tonelli_shanks_sqrt(\n params: BigNumParams,\n input: [u128; N],\n) -> std::option::Option<[u128; N]> {\n let mut result: Option<[u128; N]> = Option::none();\n\n let one: [u128; N] = __one();\n let s: u32 = __primitive_root_log_size::(params); // p - 1 = 2^s * Q, where Q is odd\n let Q: [u128; N] = __shr(__helper_sub(params.modulus, one), s);\n let Q_minus_one_over_two: [u128; N] = __shr1(__helper_sub(Q, one)); // (Q - 1) / 2\n\n let z: [u128; N] = __quadratic_non_residue::(params);\n\n // Initialize:\n // b = a^{(Q - 1)/2}\n // R = a * b = a^{(Q + 1) / 2} => R^2 = a * a^Q\n // t = R * b = a^Q\n let mut b: [u128; N] = __pow::<_, MOD_BITS>(params, input, Q_minus_one_over_two);\n let mut r: [u128; N] = __mul::<_, MOD_BITS>(params, input, b);\n let mut t: [u128; N] = __mul::<_, MOD_BITS>(params, r, b);\n\n let mut check: [u128; N] = t;\n // Assure t^{2^{s - 1}} = a^{(p -1)/2} = 1, otherwise we have met a non-residue\n for _ in 0..s - 1 {\n check = __sqr::(params, check);\n }\n if (__eq(check, one)) {\n let mut m: u32 = s;\n let mut c: [u128; N] = __pow::(params, z, Q); // z^Q - proper 2^{M}'th root of unity\n\n // Tonelli-Shanks main loop\n\n // At the beginning of each iteration we have:\n // M - current exponent such that t lies in the subgroup of order 2^m\n // t - element, whose order divides 2^m\n // c - the proper 2^M'th root of unity\n // R - accumulator with R^2 = a * t\n\n // If t == 1, we are done and R is a square root\n //\n // Otherwise\n // 1. We compute 1 <= i < M, such that t^{2^i} = 1, t^{2^{i - 1}} = -1\n // 2. Set b = c^{2^{M - i - 1}}, so it becomes a proper 2^(i+1)'th root of unity\n // Then b^2 has order 2^i which matches the order of t\n //\n // 3. Update the state values:\n // R <- R * b\n // t <- t * b^2\n // c <- b^2 = c^{2^{M - i}}\n // M <- i\n // reduces the order of t from 2^i to at most 2^{i - 1} and preserves R^2 = a * t\n //\n // The loop runs at most s times because M strictly decreases\n for _ in 0..s {\n if (__eq(t, one)) {\n result = Option::some(r);\n break;\n }\n let i: u32 = __tonelli_shanks_sqrt_find_i::(params, t);\n let mut j: u32 = m - i - 1;\n b = c;\n for _ in 0..j {\n b = __sqr(params, b);\n }\n\n let b2: [u128; N] = __sqr::(params, b);\n c = b2;\n t = __mul::(params, t, b2);\n r = __mul::(params, r, b);\n m = i;\n }\n }\n result\n}\n\n/// Compute a modular square root for MOD = 3 (mod 4) (unconstrained)\n///\n/// In case MOD = 3 (mod 4), the square root can be computed using the formula:\n/// `R = a^{(MOD + 1) / 4} (mod MOD)`\n///\n/// Then R^2 = a^{(MOD + 1)/ 4 * 2} = a^{(MOD + 1) / 2} = a^{(MOD - 1) / 2 + 1} = a\n///\n/// ## Note\n/// The input is assumed to be a nonzero value\n///\n/// This is much cheaper than `__tonelli_shanks_sqrt`\npub(crate) unconstrained fn __easy_sqrt(\n params: BigNumParams,\n input: [u128; N],\n) -> std::option::Option<[u128; N]> {\n let mut result: Option<[u128; N]> = Option::none();\n\n let one: [u128; N] = __one();\n let p_minus_one_over_two: [u128; N] = __shr1(__helper_sub(params.modulus, one));\n let mut check: [u128; N] = __pow(params, input, p_minus_one_over_two);\n if (__eq(check, one)) {\n // a = (MOD - 1) / 2\n // b = (a + 1) / 2 = ((MOD - 1) / 2 + 1) / 2 = (MOD + 1) / 4\n let p_plus_one_over_four: [u128; N] = __shr1(__increment(p_minus_one_over_two));\n result = Option::some(__pow(params, input, p_plus_one_over_four));\n }\n result\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/fns/unconstrained_ops.nr"},"134":{"source":"use std::ops::WrappingMul;\n\nglobal MUL_DE_BRUIJN_BIT: [u32; 128] = [\n 1, 14, 2, 15, 26, 20, 3, 16, 68, 80, 27, 21, 56, 50, 4, 17, 65, 96, 69, 81, 105, 99, 28, 22, 86,\n 90, 57, 51, 72, 42, 5, 126, 18, 66, 48, 94, 97, 84, 70, 124, 82, 122, 106, 100, 114, 108, 29,\n 23, 77, 102, 87, 91, 119, 116, 58, 52, 61, 110, 73, 37, 43, 31, 6, 127, 13, 25, 19, 67, 79, 55,\n 49, 64, 95, 104, 98, 85, 89, 71, 41, 125, 47, 93, 83, 123, 121, 113, 107, 76, 101, 118, 115, 60,\n 109, 36, 30, 12, 24, 78, 54, 63, 103, 88, 40, 46, 92, 120, 112, 75, 117, 59, 35, 11, 53, 62, 39,\n 45, 111, 74, 34, 10, 38, 44, 33, 9, 32, 8, 7, 128,\n];\n\n/// Get the most significant bit position of a `val` (unconstrained)\n///\n/// Bit hack that uses De Bruijn sequence to calculate msb position in log(N)\n/// See [IntegerLog2DeBruijn](https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn)\npub(crate) unconstrained fn get_msb(x: u128) -> u32 {\n let result: u32 = if x == 0 {\n 0\n } else {\n let mut v: u128 = x;\n v |= v >> 1;\n v |= v >> 2;\n v |= v >> 4;\n v |= v >> 8;\n v |= v >> 16;\n v |= v >> 32;\n v |= v >> 64;\n let index: u128 = (v.wrapping_mul(0x1FC10C2FBCF471B913B14CD2595D6D5)) >> 121;\n MUL_DE_BRUIJN_BIT[index as u32]\n };\n result\n}\n\nmod tests {\n use crate::constants::{TWO_POW_120, TWO_POW_60};\n use crate::fns::unconstrained_helpers::__get_msb;\n use super::get_msb as get_msb128;\n use std::ops::WrappingMul;\n\n fn assert_msb_equal(x: u64) {\n // Safety: test code\n let msb64 = unsafe { get_msb64(x) };\n // Safety: test code\n let msb128 = unsafe { get_msb128(x as u128) };\n assert_eq(msb64, msb128);\n }\n\n #[test]\n /// Check that the msb functions are equivalent with de bruijn sequence for 64 bits and 128 bits\n fn test_get_msb() {\n // Test case 1: MSB at position 7\n let x: u64 = 0x80; // binary: 10000000\n assert_msb_equal(x);\n\n // Test case 2: MSB at position 0\n let x: u64 = 0x1; // binary: 00000001\n assert_msb_equal(x);\n\n // Test case 3: MSB at position 63\n let x: u64 = 0x8000000000000000; // binary: 1000...0000 (63 zeros)\n assert_msb_equal(x);\n\n // Test case 4: Zero input\n let x: u64 = 0x0;\n assert_msb_equal(x);\n\n // Test case 5: All bits set\n let x: u64 = 0xFFFFFFFFFFFFFFFF;\n assert_msb_equal(x);\n }\n\n /// Multiple entires in the `MUL_DE_BRUIJN_BIT` list do not map to a valid output of `v * 0x6c04f118e9966f6b`.\n /// This is a dummy value to fill the gaps in the map.\n global n1: u32 = 0xffffffff;\n\n global MUL_DE_BRUIJN_BIT_64: [u32; 128] = [\n 0, // change to 1 if you want bitSize(0) = 1\n 48, n1, n1, 31, n1, 15, 51, n1, 63, 5, n1, n1, n1, 19, n1, 23, 28, n1, n1, n1, 40, 36, 46,\n n1, 13, n1, n1, n1, 34, n1, 58, n1, 60, 2, 43, 55, n1, n1, n1, 50, 62, 4, n1, 18, 27, n1,\n 39, 45, n1, n1, 33, 57, n1, 1, 54, n1, 49, n1, 17, n1, n1, 32, n1, 53, n1, 16, n1, n1, 52,\n n1, n1, n1, 64, 6, 7, 8, n1, 9, n1, n1, n1, 20, 10, n1, n1, 24, n1, 29, n1, n1, 21, n1, 11,\n n1, n1, 41, n1, 25, 37, n1, 47, n1, 30, 14, n1, n1, n1, n1, 22, n1, n1, 35, 12, n1, n1, n1,\n 59, 42, n1, n1, 61, 3, 26, 38, 44, n1, 56,\n ];\n\n pub(crate) unconstrained fn get_msb64(x: u64) -> u32 {\n let mut v: u64 = x;\n v |= v >> 1;\n v |= v >> 2;\n v |= v >> 4;\n v |= v >> 8;\n v |= v >> 16;\n v |= v >> 32;\n let index: u64 = (v.wrapping_mul(0x6c04f118e9966f6b)) >> 57;\n (index as Field).assert_max_bit_size::<32>();\n MUL_DE_BRUIJN_BIT_64[index as u32]\n }\n\n unconstrained fn __get_msb64(val: [u128; N]) -> u32 {\n let mut count: u32 = 0;\n for i in 0..N {\n let v: u128 = val[((N) - 1 - i)];\n let v_low: u64 = v as u64 % TWO_POW_60 as u64;\n let v_high: u64 = ((v - v_low as u128) / TWO_POW_60) as u64;\n if (v_high > 0) {\n count = 60 * ((2 * N) - 1 - (i * 2)) + get_msb64(v_high);\n break;\n }\n if (v_low > 0) {\n count = 60 * ((2 * N) - 1 - (i * 2 + 1)) + get_msb64(v_low);\n break;\n }\n }\n count\n }\n\n #[test]\n // Check that the msb functions are equivalent with De Bruijn sequence for 64 bits and 128 bits\n unconstrained fn test_get_msb_equivalence() {\n // Test single limb (64-bit number)\n let x: Field = 0x8000000000000000;\n let arr: [u128; 4] = [0, 0, x as u128, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test multiple limbs (120-bit number)\n let x: Field = 0x800000000000000000000000000000; // 120 bits number, 2^119\n let arr: [u128; 4] = [0, 0, x as u128, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test zero\n let arr: [u128; 4] = [0, 0, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test all bits set (120 bits)\n let x: Field = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // 120 bits, 2^120 - 1\n let arr: [u128; 4] = [0, x as u128, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n\n // Test systematic bit positions\n for i in 0..120 {\n let x: u128 = 1;\n let shifted: u128 = x << i;\n let arr: [u128; 4] = [0, shifted, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n }\n\n // Test random-like patterns (multiple bits set)\n let patterns: [Field; 7] = [\n 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, // alternating bits\n 0x555555555555555555555555555555, // alternating bits (opposite)\n 0x1234567890ABCDEF1234567890ABCD, // some pattern\n 0xFEDCBA0987654321FEDCBA09876543, // some pattern\n 0x800000000000000000000000000001, // highest and lowest bits\n 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE, // all bits except lowest\n 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFF, // all bits except highest\n ];\n for i in 0..patterns.len() {\n let arr: [u128; 4] = [0, patterns[i] as u128, 0, 0];\n let msb1: u32 = __get_msb64(arr);\n let msb2: u32 = __get_msb(arr);\n assert_eq(msb1, msb2);\n }\n\n // Test with MSB in different array positions (120 bits)\n let x: Field = 0x800000000000000000000000000000; // 120 bits\n let arr1: [u128; 4] = [x as u128, 0, 0, 0];\n let arr2: [u128; 4] = [0, x as u128, 0, 0];\n let arr3: [u128; 4] = [0, 0, x as u128, 0];\n let arr4: [u128; 4] = [0, 0, 0, x as u128];\n let msb1_1: u32 = __get_msb64(arr1);\n let msb2_1: u32 = __get_msb(arr1);\n assert_eq(msb1_1, msb2_1);\n\n let msb1_2: u32 = __get_msb64(arr2);\n let msb2_2: u32 = __get_msb(arr2);\n assert_eq(msb1_2, msb2_2);\n\n let msb1_3: u32 = __get_msb64(arr3);\n let msb2_3: u32 = __get_msb(arr3);\n assert_eq(msb1_3, msb2_3);\n\n let msb1_4: u32 = __get_msb64(arr4);\n let msb2_4: u32 = __get_msb(arr4);\n assert_eq(msb1_4, msb2_4);\n }\n\n #[test]\n unconstrained fn fuzz_get_msb(seed: [u128; 5]) {\n let mut seed_copy: [u128; 5] = seed;\n for i in 0..5 {\n seed_copy[i] = seed_copy[i] & (TWO_POW_120 - 1);\n }\n let msb1: u32 = __get_msb64(seed_copy);\n let msb2: u32 = __get_msb(seed_copy);\n assert_eq(msb1, msb2);\n }\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/utils/msb.nr"},"135":{"source":"use crate::constants::TWO_POW_120;\n\n/// Split the Field value into two 120-bit limbs (unconstrained)\n///\n/// Here we're taking advantage of truncating 120 bit limbs from the input field\n/// and then subtracting them from the input such that the field division is equivalent\n/// to integer division.\n///\n/// We return the lower 120-bit limb as a `u128` value,\n/// and the upper limbs as a `Field`, to avoid unnecessary conversions\n/// and potential overflows\npub(crate) unconstrained fn __split_120_bits(mut x: Field) -> (u128, Field) {\n let low: u128 = (x as u128) % TWO_POW_120;\n let high: Field = ((x - low as Field) / TWO_POW_120 as Field);\n (low, high)\n}\n\n/// Normalize an array of Field values into 120-bit limbs (unconstrained)\n///\n/// Each Field element is split into two parts modulo 2^{120}\n/// The overflow from the lower limbs is carried into the higher limbs\npub(crate) unconstrained fn __normalize_limbs(input: [Field; N]) -> [u128; N] {\n let mut normalized: [u128; N] = [0; N];\n let mut next: Field = input[0];\n for i in 0..(N - 1) {\n let (lo, hi): (u128, Field) = __split_120_bits(next);\n normalized[i] = lo;\n next = input[i + 1] + hi;\n }\n let (lo, hi): (u128, Field) = __split_120_bits(next);\n normalized[N - 1] = lo;\n\n // non-zero final carry <=> normalized value overflows the array length\n assert(hi == 0);\n\n normalized\n}\n","path":"/home/ace/nargo/github.com/gnosisguild/noir-bignum/v0.0.3/src/utils/split_bits.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.vk b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_bn.vk deleted file mode 100644 index 08f48fd083b6b6c83bcd5e870c96cd4108f5f0a0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajg`9Bkk1Hf@(wlTvn=iD}$^DDXUA=f;v9EEb#_f>Oct{lsgBUg^Ob0df`p_(CGucOJ|i2hl930gAWUJwBsWd?#%x;+4n=|cg73_FC$e)LNKY- zIclkU^04u(MReaE^0__c!zEq z;<`NlirX%`$mx_LEl$xem92*3R}ygCDN?%~^Sx3eEUr4ud(xSuajSJE+tM2iR+p^P zHq*nW+kO>N6>!E%eYsC5%outCjt@$H{2$Jrr0goKd}r5P za>vbvk-CrPD!mP8@H>Rx!e0F0W=R9_N$|i)&4TI*|EQnKMqScqvj-HrIz@4n<2pOY8E1F)JM0#pHnM1fU=0zy( z_%qMyxZWQx?+BR=?Il@r!~nf*&8}!Ns7pMpqrWQrc)Zw@*Z-7XUcHL^6Txd4J!V2Al*=;v4!!`K@gbfaSTLmu69!42Y3A`+F|$K0(dhza^ZX< zxk|O~ zCqvH%(i|T)QI3tbM`SoLL!OXRwE7})MHgzTJ;C^Ha7~l_=qeo=nxTwu8&Vp+X zjELa1`&C#Z)5EP4)X<|kglT?JL~wB^Y?06EL8N+86e^7)q#H=nlM*Z9YJnL(kQj-X z1=AI>8JRSBW_Fkrk2^a;xc!McdhJz5`me!Y+qM^h#T~lG!8l@GsYy8@#AE(kG zoXDH`|MJTi!r}yBJ1aJNF(ai0zR11ytmB!vXuog&)`jFXHR*B?iMs9wAfzPJZ)Dd6 zC0p$Ji;lDsPz+LVmHpz4ZY=8Jh0bUpO+v6nv&vIEXwNalDdd&1=AJHoPAF!=eOtgy zDFWOi%Sml+d5S?551PpVyN-~^R)#vg*&X6~gR8<|vZ{)kb}kA8aK54xP-kczbq1WQ zKxG*Jj!+Pq4beI7A@x98E-@N9zFa4pUR8@}SOA8^kBiHVR-pj!Jta4a>G7klig7=Fa>FH*)N- z4utF?!G%ovG|&iSAjr+4gqxEs8HnpjTVwSr_#{|az6s0H85uBwM##N~kTe4BUKED= z=I4_%3NYX7-Hn7(W`}Iq!gXE$?N9&W>`Leqw|QC3CNsO^=CJVz*iKIv>f8greeX>K pUqbSRf$YAgnR`8jQ>|%vi+7ROaIe@*Qp1JEo_`4XI5_!f(Lb|$Eq(w1 diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json deleted file mode 100644 index 0726b9a65b..0000000000 --- a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.json +++ /dev/null @@ -1 +0,0 @@ -{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"1413289141083555426","abi":{"parameters":[{"name":"decryption_shares","type":{"kind":"array","length":3,"type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]}}},"visibility":"public"},{"name":"party_ids","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"public"},{"name":"message","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]},"visibility":"public"},{"name":"u_global","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"crt_quotients","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":80,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":null,"error_types":{"991688543994151927":{"error_kind":"string","string":"Division verification failed: result * rhs ≠ lhs (mod m)"},"6347439466827421235":{"error_kind":"string","string":"CRT reconstruction verification failed"},"15764276373176857197":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"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","debug_symbols":"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","file_map":{"50":{"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::{MAX_MSG_NON_ZERO_COEFFS, T};\nuse lib::configs::default::threshold::{\n DECRYPTED_SHARES_AGGREGATION_BIT_NOISE, DECRYPTED_SHARES_AGGREGATION_CONFIGS, L,\n};\nuse lib::core::threshold::decrypted_shares_aggregation::DecryptedSharesAggregationModular;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n decryption_shares: pub [[Polynomial; L]; T + 1],\n party_ids: pub [Field; T + 1],\n message: pub Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n) {\n let decrypted_shares_aggregation: DecryptedSharesAggregationModular = DecryptedSharesAggregationModular::new(\n DECRYPTED_SHARES_AGGREGATION_CONFIGS,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n );\n\n decrypted_shares_aggregation.execute();\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/decrypted_shares_aggregation_mod/src/main.nr"},"67":{"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::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\nuse dep::bignum::BigNum;\nuse dep::bignum::bignum::to_field;\nuse dep::bignum::SecureThreshold8192;\n\n/// Cryptographic parameters for decryption share aggregation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Plaintext modulus (typically denoted as `t`)\n pub plaintext_modulus: Field,\n /// Precomputed value: `-Q^(-1) mod t` where Q is the product of all CRT moduli\n pub q_inverse_mod_t: Field,\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], plaintext_modulus: Field, q_inverse_mod_t: Field) -> Self {\n Configs { qis, plaintext_modulus, q_inverse_mod_t }\n }\n}\n\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using BigNum\n/// for large Q values.\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationBigNum {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using modular arithmetic\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationModular {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n\nimpl DecryptedSharesAggregationBigNum {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationBigNum {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Verifies decoding using BigNum for large Q values\n fn verify_decoding(self) {\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1 as Field;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_bn = SecureThreshold8192::from(q_modulus);\n\n let q_half_bn = q_bn.udiv(SecureThreshold8192::from(2));\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let u_bn = SecureThreshold8192::from(self.u_global.coefficients[coeff_idx]);\n let t_bn = SecureThreshold8192::from(self.configs.plaintext_modulus);\n let u_bn_mod_q = u_bn.umod(q_bn);\n let t_bn_mod_q = t_bn.umod(q_bn);\n let t_times_u_bn_q = (t_bn_mod_q * u_bn_mod_q).umod(q_bn);\n\n let m = ModU128::new(self.configs.plaintext_modulus);\n\n // Check if centering is needed\n let needs_centering = t_times_u_bn_q > q_half_bn;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_bn - t_times_u_bn_q;\n let centered_positive_mod_t = centered_positive.umod(t_bn);\n let centered_field = to_field(centered_positive_mod_t);\n m.mul_mod(self.configs.q_inverse_mod_t, centered_field)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_bn_t = t_times_u_bn_q.umod(t_bn);\n let t_times_u_field = to_field(t_times_u_bn_t);\n let product = m.mul_mod(self.configs.q_inverse_mod_t, t_times_u_field);\n if product == 0 {\n 0\n } else {\n self.configs.plaintext_modulus - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\nimpl DecryptedSharesAggregationModular {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationModular {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Alternative verification function using efficient modular arithmetic without BigNum.\n ///\n /// Uses `ModU128` for decoding verification instead of BigNum. More efficient when\n /// Q (the product of all CRT moduli) fits within u128 (e.g., 72 bits for insecure parameter sets).\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Alternative decoding verification using the formula:\n /// message = -Q^{-1} * (t * u_global)_Q mod t\n fn verify_decoding(self) {\n let t: Field = self.configs.plaintext_modulus;\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_half = q_modulus as u128 / 2;\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let q_mod = ModU128::new(q_modulus);\n let t_mod = ModU128::new(t);\n\n // Compute (t * u_global) mod Q using modular arithmetic functions\n let t_times_u_mod_q = q_mod.mul_mod(t, self.u_global.coefficients[coeff_idx]);\n let needs_centering = (t_times_u_mod_q as u128) > q_half;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_modulus - t_times_u_mod_q;\n let centered_positive_mod_t = t_mod.reduce_mod(centered_positive);\n\n t_mod.mul_mod(self.configs.q_inverse_mod_t, centered_positive_mod_t)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_mod_t = t_mod.reduce_mod(t_times_u_mod_q);\n let product = t_mod.mul_mod(self.configs.q_inverse_mod_t, t_times_u_mod_t);\n if product == 0 {\n 0\n } else {\n t - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\n/// Computes all Lagrange coefficients using optimized modular arithmetic\npub fn compute_all_lagrange_coeffs(\n qis: [Field; L],\n party_ids: [Field; T + 1],\n) -> [[Field; T + 1]; L] {\n let mut lagrange_coeffs = [[0 as Field; T + 1]; L];\n\n // Step 1: Cache |x_i - x_j| factors for all party pairs\n let mut diffs = [[0 as Field; T + 1]; T + 1];\n for i in 0..(T + 1) {\n for j in (i + 1)..(T + 1) {\n let diff = party_ids[j] - party_ids[i];\n diffs[i][j] = diff;\n diffs[j][i] = diff;\n }\n }\n\n // Step 2: Determine signs (same for all parties within a basis)\n let numerator_sign_negative = (T % 2) == 1;\n\n // Step 3: For each CRT basis, compute Lagrange coefficients\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n\n // Compute product of all party IDs: PRODUCT(j=0..T) x_j mod q_l\n let mut product_x = 1 as Field;\n for j in 0..(T + 1) {\n product_x = m.mul_mod(product_x, party_ids[j]);\n }\n\n // For each party i, compute L_i(0) mod q_l\n for party_idx in 0..(T + 1) {\n // Numerator (absolute value): PRODUCT(j!=party_idx) x_j\n let numerator_abs = m.div_mod(product_x, party_ids[party_idx]);\n\n // Denominator (absolute value): PRODUCT(j!=party_idx) |x_party_idx - x_j|\n let mut denominator_abs = 1 as Field;\n for j in 0..(T + 1) {\n if j != party_idx {\n denominator_abs = m.mul_mod(denominator_abs, diffs[party_idx][j]);\n }\n }\n\n // Determine denominator sign\n let num_greater = T - party_idx;\n let denom_sign_negative = (num_greater % 2) == 1;\n\n // Compute unsigned result: |numerator| / |denominator| mod q_l\n let result_abs = m.div_mod(numerator_abs, denominator_abs);\n\n // Apply combined sign\n let should_negate = numerator_sign_negative != denom_sign_negative;\n let result = if should_negate {\n m.reduce_mod(q_l - result_abs)\n } else {\n result_abs\n };\n\n lagrange_coeffs[basis_idx][party_idx] = result;\n }\n }\n\n lagrange_coeffs\n}\n\n/// Computes u^{(l)} for each CRT basis via Lagrange interpolation\npub fn compute_crt_components(\n qis: [Field; L],\n decryption_shares: [[Polynomial; L]; T + 1],\n lagrange_coeffs: [[Field; T + 1]; L],\n) -> [Polynomial; L] {\n let mut u_crts: [Polynomial; L] =\n [Polynomial::new([0; MAX_MSG_NON_ZERO_COEFFS]); L];\n\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n let mut u_coeffs = [0 as Field; MAX_MSG_NON_ZERO_COEFFS];\n\n // For each coefficient position\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n let mut u_coeff = 0 as Field;\n\n // Sum all contributions: u = SUM(i=0..T) [d_i * L_i(0)] mod q_l\n for party_idx in 0..(T + 1) {\n let d_coeff = decryption_shares[party_idx][basis_idx].coefficients[coeff_idx];\n let l_i_0 = lagrange_coeffs[basis_idx][party_idx];\n\n let term = m.mul_mod(d_coeff, l_i_0);\n u_coeff = m.reduce_mod(u_coeff + term);\n }\n\n u_coeffs[coeff_idx] = u_coeff;\n }\n\n u_crts[basis_idx] = Polynomial::new(u_coeffs);\n }\n\n u_crts\n}\n\n/// Verifies CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global for all bases l\npub fn verify_crt_reconstruction(\n qis: [Field; L],\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n u_crts: [Polynomial; L],\n) {\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n\n // Compute r^{(l)} * q_l\n let r_times_q = crt_quotients[basis_idx].mul_scalar(q_l);\n\n // Compute u^{(l)} + r^{(l)} * q_l\n let reconstructed = u_crts[basis_idx].add(r_times_q);\n\n // Verify: u^{(l)} + r^{(l)} * q_l = u_global\n // Must hold for every coefficient\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n assert(\n reconstructed.coefficients[coeff_idx] == u_global.coefficients[coeff_idx],\n \"CRT reconstruction verification failed\",\n );\n }\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/decrypted_shares_aggregation.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.vk b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation_mod.vk deleted file mode 100644 index b3b83d01c2855ffba802a461022eb61b41a1156f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajgcRw2l1HkdbOr$|Xa%Sz7Q1c-+(WpZewTTk5j#9CXS}{r~O5#w_6fLFrL}FIm zoh>MdqE+LH=Zsoy#i5US-a+s8@An1#0DvC``=J7OY<}zjpyajQxPx}qxQE0t*;XqS zztu3ek2G7Q+1p@eU(Op}0`Lu;?T5<<;sy^E1j+-pIrWiYiS@dW`)15QlL!1CqgZPv25UxLp*`uEB z_V)VC|2R(ZfEk{AvAUilkDc`+{Iat>b@axzRA1d&t=rs_tPUwx2x(24>tE(o)i9CC zw_7i0aYFjWYZU6^rTf<4MVWF4k5vqmb8u(MCPH==yqf;lHtOk!dhoWxw3Y2MY*(zR zytl3Z%+ee}S~RH&7$fcezEh!CnYJNo(3iy(?UTX^8WQQJfRBQaJ3 z@2)6yiI|L->erBMxafut6c_eyaPBfH3oP7WSb@)PcIiUZI zf=k$Li24S>{Frj@HnI5&KN0`ojjx&=1L4L&p5upAbxs#!HoVF;ze){9UIP~$ZQh|{ zN+V$X?L?{WY1==ZsfND7r8iu62y(W0<&j_KgW6ZFgk)&T^;VP^4%zQ@f@fw8WG1pT zwPY5?F74P;Wa#FMQZm&Nk}-rbjM8?t@EK=Ek~93mPx#RBDIkC&68qN z(CRdMranzipu7~c2iXb1O*IX7YQ%Z3JE5Ajn~>&>Nr9orur2+@wDzkQxt?7JXV21H zySjYR+0WLNhrO+BkY^p>R=jNvqYB?yxtXqzT|ASc#_LMU?nq3VgN8sYLsx(}!+Hl@ zY=MJXMFH}kE{RK|sK**-i|->Z)4!Z9pBLn*$|V5BPxe3dl^H3##ytG$s$en0ZlXkg z&X9?4Nh>#G@yK2_&YHLE_+=W}439Qv-s$v76Z={B~p6EAL;7 zCJi)zWN-hqPu2#a2eVhR1ZoZZnN*1kPnI?@OHEmL`r;z3(ez4OJJq z=^?IsW#7LWR+*msK^Vp#v|QCoD?ViI-2$H0)^bpo91FE8@q{FgHHZGhlgkQOJ+J?& zUiEr2Cva8c6q`IGZn17#WWvjzRy?juMs zT6X3(ZR2?VcP~Yy-aJtZ2Y%9MNE5I1Ifa%Ls^w+y!xlZ>=>vFN=u=Xef67r@(f3#Y z6E(H~A!2UFs^V9lgC`8n)}&mQ_n%V&c*HiP!8N9HG@4M?cL_cqe-DGw@ve*c+?0Pc z1Pv8E5RXy?Ai6m&_=L5|-O434*;_%Q%_Jz@hk(+%Dv}Gmj7pb&6#r8xq{Y184;cyt zj8a7BWrCJe*iATLh{J%`V49A9ekt8<|AXS++ogiZ*>(!nqn|e90Z-=&C*m-2QIc?v zG}A|ZnLv|8gwik1rk?|0Oe-r0nq{;`2l(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_E_SM_BIT_SECRET,\n SHARE_COMPUTATION_E_SM_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SmudgingNoiseShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n e_sm_secret: [Polynomial; L_THRESHOLD],\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let share_computation_e_sm: SmudgingNoiseShareComputation = SmudgingNoiseShareComputation::new(\n SHARE_COMPUTATION_E_SM_CONFIGS,\n expected_secret_commitment,\n e_sm_secret,\n y,\n PARITY_MATRIX,\n );\n\n share_computation_e_sm.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/e_sm_share_computation/src/main.nr"},"63":{"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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/share_computation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/e_sm_share_computation.vk b/crates/zk-prover/tests/fixtures/e_sm_share_computation.vk deleted file mode 100644 index 70efd9e0c24c6f638143cf1acbdbb43c2487db6c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajg`6CmI1Ay^4Uvsl}?t9LSx$nG;FlX7D_C)mHY0Jv zZk>ZH=ML!eGKUs( zMeoed6V!5AbSJau+Y3&EO~KId2~{r#HrAwr7t4&+li+60;O&MVuBx74cLC5K-dZ20 zBgQR;_t)-`ZQeKmF$w(*!`JZ+>a^qXI%knBOu%#Xd*QpeTE`G&`j@x!Zj);1Rh+s7 zLTS||9&td-VIL^0+yFOmbf?=n+1Se7?->M1ODkcat*@w{q_p&9?Ki8k;$>tNa)vptv(Y%%?bh_pa0I?bq!jes&jVdsuS?3U z7evG^%HQ?vvhaRQqykT;#`@`k^K&jqesV(n7CDSIr=rnPcW|IT5Uv^$*ps!+LCIGk zUio296XV*GE@U0mbVwdPdBds*xi3>&D6D4XQg8yjv)%&xzAYtuo1NjV?(JoEC7WAo zUshc3I-eo)lC!=rOd2j{lbsW8Rnu!Q{#BPk#kzQ~)|jYNQ-?9a&nh5AuZPWZZCA{f zl_RdMe);Fnj_hQN)+BpofZo7<#3jJ!R!kb|iMcz%QhX7oBUTUkix&( zcz}1Irg}lfl*e-L>nKi*I*}|%!m%pIllZ3mUO)t6@I%8P`g#3z@m()jZvzpwdhJ_8da|rr}z2WcMjfTdwHkhz{jfdn^WUPxlnv#MxJ5<>xd0^ zp!`c2(wIhG)6dDY%_uM2KR8Le*HMn%jNT~a>}7{RQKC9tGLr{iQP@R3<}uv_)*&PO z+2Kn2-7!>r1tCTECt^^%s`79?g1a2ChqcdbLs*>WC9!)H%#3=XBZ3}u%&X(^s&LoDzcV+ppCYbu3N z%F9tB9h`J+Li!;3E>Gml)ZW>MLeJ;&Dy5$^uD|8$*&bD`PD^`U;+b1q^qMuCx~8aC zBB!wonCNIm@MqAw(Qf$2@w9f4H$bI_Itm?L7 zqwK3Cv?i+wQohp@a!QJ_ ziYOT{JQ;?uJ(J}|+3A<ccpc&q9oRG8P zHPAvutzTKhI`CSh&Ij|<20u^@u|yjP11n5tD=WEMFT~hcIA~2pEpx5SHKrU(K`=hS zz2C!?0pPYNmuu0h>l+2X#b+Sp5wEt^G`?dy;9s zPb!PaM=<1O^_vU=~8K)_Td#NeXl4|`Hj8@&5tX&Js;434UFIl6cuoKE)g#oTYE$j_uail+q zRH#)1{o?3hCX)4G%pMSFVNha>!_dE%0M#Vq`!P}V-xJiXMob{lfvJuDbkTnSI}9`0 diff --git a/crates/zk-prover/tests/fixtures/pk.json b/crates/zk-prover/tests/fixtures/pk.json deleted file mode 100644 index ebc943b3f3..0000000000 --- a/crates/zk-prover/tests/fixtures/pk.json +++ /dev/null @@ -1 +0,0 @@ -{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"4119404624100087182","abi":{"parameters":[{"name":"pk0is","type":{"kind":"array","length":1,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk1is","type":{"kind":"array","length":1,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"field"},"visibility":"public"},"error_types":{}},"bytecode":"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","debug_symbols":"pdjRattIFIfxd/F1Lub8z2hG01dZluKmbjEYJ7jJwlL67mvX5ztOFiTSpDdK4upDkc5PM+Tn5uvuy/P3z/vjt4cfm09//dx8Oe0Ph/33z4eH++3T/uF4/unPX3cbvv38dNrtzj/avPj8fNbj9rQ7Pm0+HZ8Ph7vNP9vD8+//9ONxe/x9fNqezp+Wu83u+PV8PAe/7Q+7y1e/7m5nl+VTa5/j5DrPefr0+nxbPn+UGuePNuX5Ta/O1/L5bVQuoJdyu4JeXxV8pdCtR6H1aSwV6nLBy8Q1eHnxW/Tp7YXqWehjqdCWC9P5XxSmaS7vKTTLQpO/q1BKFsw+WlBdKqzMQy+qOQ+zLT1Nsw8PhOnDE7GeeNNIWP3wTKwm3jYU64k3TcWbE+8cizlfEza1xWc6VsbCL59ex8J7WUqorF5FyeEci3dTa8Npl6G5XoVNt6s4j/pbE9M8GndzvHhl/j+x8s4cVrkXw0ZdTKw801qbsXLUcbsKG39wL1o+EZX+nnvxKiG963aOeruddfkq1ubCZDmdvvi60Mp09ub8Ir1NtnQVXj78UN0+/lDXfpHZuZ197tOrq/j7/N32fn96tQnalHPw/JKy60HXg18P9XqYrod2PfTrYb4eRpxOJjoWIYuSRcqiZRGzqFnkLHqKnriu6Cl6ip6ip+gpeoqeoufR8+g5v2j0PHoePY+eR8+j59Gr0avRq9Gr3Lno1ejV6NXo1ejV6E3Rm6I3RW+K3sSjiN4UvSl6U/Sm6LXotei16LXoteg1nm30WvRa9Fr0evR69Hr0evR69Hr0OsMSvR69Hr05enP05ujN0ZujN0dvjt7M9EVvjt6I3ojeiN6I3ojeiN6I3ojeYJxznhnowkQXRrow04WhLkx1YawLc10Y7EL5RoVyYkktySW9JJgUk2QwY6AxpULKuDHgGHIMOoYdA4+hx+Bj+DFP4JQhZBgyEBmKDEaGIwOSIcmgZDXfHZTRZHAyPBmgDFEGKcOUgcpQZVO+ligDy5Bl0DJsGbgMXQYvw5cBzFq+8ShjzEBmKDOYGc4MaIY0g5phzXq+TCnDzfBmgDPEGeQMcwY6Q53BzuZ8T1NGnkHPsGfgM/QZ/Ax/BkBDoI1cAnINYBHAoDAoDAqDwqAwKAwKg8KgLJcXyhgUBoVBYVAYFAaFQeW6lQvXbeWinGtXLl65euXyletXLmAYFAaFQXkuipQxKAwKg8KgMCgMCoPCoDComustZQwKg8KgMCgMCoPCoDAoDGrKpZwyBoVBYVAYFAaFQWFQGBQG1XKXQBmDwqAwKAwKg8KgMCgMCoPquQGhjEFhUBgUBoVBYVAYFAaFQc25t6GMQWFQGBQGhUFhUBgUBoVBjdw25b6JjRMGHYOOQcegY9Ax6Bh0DDoG3XJLRhmDjkHHoGPQMegYdAw6Bh2DrtztUcagY9Ax6Bh0DDoGPXeRuY3MfeRtI0k5t5K5l8zNZO4mczuJQcegXwy6Ll/o8sWvy17/tN9+Oezib5bfno/3L/6E+fTvI5/wR87H08P97uvzaXfZ6f/+7Lz3/w8=","file_map":{"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{L, N};\nuse lib::configs::default::dkg::PK_BIT_PK;\nuse lib::core::dkg::pk::Pk;\nuse lib::math::polynomial::Polynomial;\n\nfn main(pk0is: [Polynomial; L], pk1is: [Polynomial; L]) -> pub Field {\n let pk: Pk = Pk::new(pk0is, pk1is);\n pk.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/pk/src/main.nr"},"62":{"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::commitments::compute_dkg_pk_commitment;\nuse crate::math::polynomial::Polynomial;\n\n/// Correct DKG Public Key Circuit (Circuit 0).\npub struct Pk {\n /// Correct DKG public key components\n /// pk0[i] is the first component for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component for modulus i\n pk1: [Polynomial; L],\n}\n\nimpl Pk {\n pub fn new(pk0: [Polynomial; L], pk1: [Polynomial; L]) -> Self {\n Pk { pk0, pk1 }\n }\n\n /// Main verification function\n /// Returns commitment to correct DKG public key\n pub fn execute(self) -> Field {\n compute_dkg_pk_commitment::(self.pk0, self.pk1)\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/pk.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/pk.vk b/crates/zk-prover/tests/fixtures/pk.vk deleted file mode 100644 index 913fa7712f317c097f59822c203fa3657cdeb197..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajg`9Bkk1HkcZ&YAJB&COh4j(w3z!)5_;Zn(u^?@# z#0&1PHt3!Gbuai!)(L?|6ooE33U?C+MVq9HYR_(*7!1{aBHRe)N3FwM%2%SgNA+4g zM}qTNpghG|(A0ZM9N><&?fGh>x+=o^?CYyuN{0F2$Vw-1oCvrS)TU3cE>^Nuerigu z>N7X7#fHt)elEgZ1;ol&;$Rm?B2p>4l;@=dm~j>`t~yj2!UO;s!m#wM7(~B-Ooo`# z0e;E*Tihl@S1CF!F(ZLuwKIWG4TK4W6z*1BK+a=)mgvC9F9V@wbucc5(YlNCepdwe z#vCm+4dcbTFIeabKY7(f%d^$eO;KK=1rbrz)M$$Uz98HS^-R&AmP}*&Qg0n- z%Y;Y0k1QB0^lhMP`XV+XhXwq73^F&ZkK|N#?>l?W3Zg=yUSHX{-Z_dJg4_)+I1n_| zeZxn|W5?BDN{zg~bY3O|KwVB+9LYx6rVdSvcfXLP!2w+EAB2I|&%)}Eu5A2ze#Kx0 z26l_qYXRiokT5RkJHUy#FlXM{IsSX`gqZ}MQ4Ughd1zyu`WBw9m0N#HsR2Q-T>nGC|RjL{Vdcj*k+I@>_!}0R9WIS8hUZYA@=c5&_hRN&>LbKMR zkm!Tnj`9*aymEBAPNn+2y4kqtSN;a5kO#HuMuDwc8)WB znQ+4nQM!3X&lHz!&)K#u21%aU^I{I>T^phUjVQrNdZNcR>-LBoH{+qfNPSepv9Glh zNaLkj(0x%V>BCR~B)cdKrU$-9kX_a5K8bk8nPrKnVV6D>s@kM>(kiAC1yp2n$XjNH zf&yu$sxQ+=CTlgdX8Ko0@xhTUJuwV8)aro%-H+MlL%bI#F1KpRP?+R0v_9n626HA< zcg4M}TaQNq!#nf#)-L(6zkh?q94(4JXJMK(p zAK?Y~?jK*1PtBi2oj%nC4o{11V%b%R9?K%a+FpC(OXpi6`vEt_KDOv>LJXy$Xo=*2 zF|Rh`241A=hT(iKx#dt|hp53NREYvwz)HA&6b2PMBL8a9C>M34Cbt}%-}B0v!Rbl5 z*5>!yP1+*`-Y;lh&lc(Rfd;A~m1&eW>D1WJDr?ILlaD@}n za7KdVs}d@Jl`n{19h4Ox$&Xa^EQ*rdV&bdnXL0Usi>S1$w~n^>j&_qOte6L=dPlaj z145FFmrTIHU60DEY`!~fTlP1Yya;yekDHD^O~^Ja$s z2bBNk`j1V6K(sDb0co$P3Ac=WC;@tZdzTTZwKi4x#M_)%e;C>$?l-Mmb7|AjryosU z929{}J$K@x$CF3GpVSR@_&nk&EqmPiEEicbKaCcc8$g>qDEK=j>iZ$Jnh8Hx*oaO{ zn5-AQOV8r2t$H0gR4zDX@x)%WKisoq?)IPDFHl2`E|0g(lM2dqZ&g1_x4#1xNfd1T zmFYVnO#U3nz=tyX`RcxaN=JVVcad7jgy#+Ql zy8!k%>&-N`5w9UkV4*d}ywQ?{@KW0zuU!cxK}+&X7A&1*{6|#~ihcaK+Wx^m@?!{j zdAZsY^>qgiBeAsEAv-{fzU$Ba^b-du2FZc0G1&i~l(u2#NaAX#C%udu6BG052vxMa nkCig4cwytbkZA1Ho&FH?kAJQA{V4?!iyAUpNaAs!*f;+RLVY [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::H;\nuse lib::configs::default::threshold::{L, N, PK_AGGREGATION_BIT_PK, PK_AGGREGATION_CONFIGS};\nuse lib::core::threshold::pk_aggregation::PkAggregation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_threshold_pk_commitments: pub [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n) -> pub Field {\n let pk_aggregation: PkAggregation = PkAggregation::new(\n PK_AGGREGATION_CONFIGS,\n expected_threshold_pk_commitments,\n pk0,\n pk1,\n pk0_agg,\n pk1_agg,\n );\n\n pk_aggregation.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/pk_aggregation/src/main.nr"},"69":{"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::commitments::compute_pk_aggregation_commitment;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold public key aggregation circuit.\npub struct Configs {\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Public Key Aggregation (Circuit 5).\n///\n/// Verifies that for each CRT basis l and each coefficient i:\n/// - pk0_agg[l][i] = sum_h(pk0[h][l][i]) mod q_l\n/// - pk1_agg[l][i] = sum_h(pk1[h][l][i]) mod q_l\npub struct PkAggregation {\n /// Circuit parameters including CRT moduli\n configs: Configs,\n\n /// Expected commitments to threshold public key (from C1)\n /// We need one commitment from each honest party (H).\n /// (public witness)\n expected_threshold_pk_commitments: [Field; H],\n\n /// Individual public keys from H honest parties\n /// pk0[party_idx][basis_idx] - first component of public key for each party and CRT basis\n /// (committed witnesses)\n pk0: [[Polynomial; L]; H],\n /// pk1[party_idx][basis_idx] - second component of public key for each party and CRT basis\n /// (committed witnesses)\n pk1: [[Polynomial; L]; H],\n\n /// Claimed aggregated public key\n /// pk0_agg[basis_idx] - first component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk0_agg: [Polynomial; L],\n /// pk1_agg[basis_idx] - second component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk1_agg: [Polynomial; L],\n}\n\nimpl PkAggregation {\n pub fn new(\n configs: Configs,\n expected_threshold_pk_commitments: [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n ) -> Self {\n PkAggregation { configs, expected_threshold_pk_commitments, pk0, pk1, pk0_agg, pk1_agg }\n }\n\n /// Verifies that pk hashes to each expected_threshold_pk_commitment\n fn verify_pk_commitments(self) {\n for i in 0..H {\n assert(\n compute_pk_aggregation_commitment::(self.pk0[i], self.pk1[i])\n == self.expected_threshold_pk_commitments[i],\n \"PK commitment mismatch\",\n );\n }\n }\n\n fn verify_pk_for_basis(\n self,\n pk: [[Polynomial; L]; H],\n pk_agg: [Polynomial; L],\n basis_idx: u32,\n ) {\n let q_l = self.configs.qis[basis_idx];\n let mod_q_l = ModU128::new(q_l);\n\n for coeff_idx in 0..N {\n // Sum pk coefficients from all honest parties\n let mut sum_pk: Field = 0;\n for party_idx in 0..H {\n sum_pk = sum_pk + pk[party_idx][basis_idx].coefficients[coeff_idx];\n }\n\n // Reduce mod q_l\n let sum_pk_reduced = mod_q_l.reduce_mod(sum_pk);\n\n // Verify equality\n assert(\n sum_pk_reduced == pk_agg[basis_idx].coefficients[coeff_idx],\n \"pk aggregation mismatch\",\n );\n }\n }\n\n /// Main verification function\n /// Returns commitment to aggregated threshold public key\n pub fn execute(self) -> Field {\n // 0. Verify pk commitments\n self.verify_pk_commitments();\n\n // 1. Verify pk0 & pk1 aggregations for each CRT basis\n for basis_idx in 0..L {\n self.verify_pk_for_basis(self.pk0, self.pk0_agg, basis_idx);\n self.verify_pk_for_basis(self.pk1, self.pk1_agg, basis_idx);\n }\n\n // 2. Commit to aggregated threshold public key\n compute_pk_aggregation_commitment::(self.pk0_agg, self.pk1_agg)\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/pk_aggregation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/pk_aggregation.vk b/crates/zk-prover/tests/fixtures/pk_aggregation.vk deleted file mode 100644 index 58a10c89eef0602904ff50a5ced0d1cbabd1509e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajg`6Cky1HkdkH72<>jA8Eke#XKcw^xP`*-#`z!z1L_>qWV**c=b#dJxH#dy3?E zo=9PfFlIu?HDu1{{SThLzkdFJF97hb3H_@A03yF|Amqv-LbGo&{HJlh|I`&XoPjm? z_$W_txw(gRPx!DM$){FjlU=jOo4EF1U1dDv@wqX~hjCWij~q~btm#6(5v{IN ziFEBaNEukKy6pH_>N8(G8aN;AeRAEGeEDe{X^-;AsB!{hmq}Z&Y}k*Jc#SEx->cmy z)bnn-qw!49NA8uY-`saDiTC~i>{UKZrP|Ig4@<5u^y(6RPoS{URel450@6{j#q*{J zPwn5^1A=ph%+>UnxN*bYzl|KU}0YQT3f5QBUDvtz04uhxe^96 zte}{QN_$>PW~m5udNTTDIX9zOnAw8}4VENwmMWH8v2w=oG7L&(w7j%1g z1bu*LtDSk;bc&$YmDU=wED8`_0?@5+pZNR@*3|@rNMiJE21Xk-0o_eix3zD<$L@?A z>ncpI`;9kwZ|D0<ASl=19Whn$-+6~0?p44!WkPbmd{sm|Z#Q8O zYkg$7VN1d*=m$$9S2NCn7{hR-yF*OxMDA(`r<(V;H|riQV*9Nq)=r{xKh?Y|q33y6 z8qocyr;RQz8Ppr;O1qH4*E_dCid1cdd(F1^TZ`R^#U_$^GRfu#f!TqRDcOsWM_Ux1 zFK{wKqVxHS53(+yUR&t}$aps~xj(vE+gfIcg9gFE`kVXfv_E&R8vW(Q|0R8g*P3+G->B=#}uS?dqysNc--kIckhEos_jn{u{=r zA3A|b@{EX`5fymAK{=AY5{m{A7HX!0-EmkI-<{)!qt$0WURJEV$yX+vVQ-`x7?pU` zQG_<{#&hn`YumaFZePgXZ1{N5WDc+jtM>K_Hxo#3DOyxC;Yiq_2kh7T&VYlzmb73# z9?HcA4}Wz@kvt}+y4B>%kkMUXmdY? zU!_hji$LuLC$S4WgRg{7FF%=?a?Z$>=>fv2OgRs_{Asj^dW(p>0>zg{ioGV88tQbP zUdFwCKJC6G71aTIy|>tPn5)OLoka`bDKna?r~r3eh;aZpyW0vnX1dyIj5ry7YJ37r zNU$ORN~Sv9j9mJ#RXk70$H}NP8{Ua`_fgfg1KufWM})Mk7$t!7$+)aYjVX zhd@IbR1W`ayap)PZfeS__TFHrh5HuCHVSA%RY>oa=F72;Xm+z)pq<}&zmbcvaEQqH zQ+Oe3aGC?nWh4w{w1t~DTTMXSmA5IiD?v$oCHW={D`&Xxm?Bhmh&xZ)_ukLK@Z0(M zdD;c4Yj$pEk(Aj{TR=F<AE<)?L47xX7~-vgxjw+JjTu5w9T nwq1_L7gN>uU+gl5et_pp@?>D#%PIRxQHyq [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str {}\n}\n\nimpl From> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n","path":"std/array/mod.nr"},"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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, PK_GENERATION_BIT_E_SM, PK_GENERATION_BIT_EEK, PK_GENERATION_BIT_PK, PK_GENERATION_BIT_R1,\n PK_GENERATION_BIT_R2, PK_GENERATION_BIT_SK, PK_GENERATION_CONFIGS,\n};\nuse lib::core::threshold::pk_generation::PkGeneration;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n a: pub [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n) -> pub (Field, Field, Field) {\n let pk_generation: PkGeneration = PkGeneration::new(\n PK_GENERATION_CONFIGS,\n a,\n eek,\n sk,\n e_sm,\n r1is,\n r2is,\n pk0is,\n pk1is,\n );\n pk_generation.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/pk_generation/src/main.nr"},"70":{"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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_threshold_pk_challenge, compute_threshold_pk_commitment,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for threshold public key generation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bound for error polynomial (eek) coefficients\n pub eek_bound: Field,\n /// Bound for secret key polynomial (sk) coefficients\n pub sk_bound: Field,\n /// Bound for smudging noise polynomial (e_sm) coefficients\n pub e_sm_bound: Field,\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(\n qis: [Field; L],\n eek_bound: Field,\n sk_bound: Field,\n e_sm_bound: Field,\n r1_bounds: [Field; L],\n r2_bounds: [Field; L],\n ) -> Self {\n Configs { qis, eek_bound, sk_bound, e_sm_bound, r1_bounds, r2_bounds }\n }\n}\n\n/// Correct Threshold Public Key Generation Circuit (Circuit 1).\n///\n/// Verifies:\n/// 1. Range checks on all secret witnesses (secret key, error, smudging noise, quotients)\n/// 2. Correct public key generation: pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n/// and pk1_i = a_i\n///\n/// Outputs:\n/// - commit(threshold_sk)\n/// - commit(threshold_pk)\n/// - commit(e_sm)\npub struct PkGeneration {\n /// Cryptographic parameters including bounds, moduli, and constants.\n configs: Configs,\n\n /// Common Reference String polynomials (public witnesses)\n /// One polynomial per modulus i\n a: [Polynomial; L],\n\n /// Error polynomial (secret witness)\n /// Small coefficients sampled from error distribution\n eek: Polynomial,\n\n /// Secret key polynomial (secret witness)\n /// Small coefficients sampled from CBD (Centered Binomial Distribution)\n sk: Polynomial,\n\n /// Smudging noise polynomial (secret witness)\n /// Used for threshold decryption security\n e_sm: [Polynomial; L],\n\n /// Quotients from polynomial operations (secret witnesses)\n /// r1[i] are quotients from modulus switching for modulus i (can be negative, degree 2*N-1)\n r1: [Polynomial<2 * N - 1>; L],\n /// r2[i] are quotients from cyclotomic reduction for modulus i (typically positive, degree N-1)\n r2: [Polynomial; L],\n\n /// Threshold public key components (committed witnesses)\n /// pk0[i] is the first component of the public key for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component of the public key for modulus i (should equal a[i])\n pk1: [Polynomial; L],\n}\n\nimpl PkGeneration {\n pub fn new(\n configs: Configs,\n a: [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n ) -> Self {\n PkGeneration { configs, a, eek, sk, e_sm, r1, r2, pk0, pk1 }\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation\n fn payload(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let mut inputs = Vec::new();\n\n // Flatten CRS polynomials a (L polynomials of degree N)\n inputs = flatten::<_, _, BIT_PK>(inputs, self.a);\n\n // Flatten error polynomial eek (1 polynomial of degree N)\n inputs = flatten::<_, _, BIT_EEK>(inputs, [self.eek]);\n\n // Use commitments instead of full polynomials\n inputs.push(sk_commitment);\n inputs.push(pk_commitment);\n inputs.push(e_sm_commitment);\n\n // Flatten quotient polynomials (L polynomials each)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n inputs\n }\n\n /// Main execution function\n /// Returns (commit(threshold_sk), commit(threshold_pk), commit(e_sm))\n pub fn execute(self) -> (Field, Field, Field) {\n // Step 1: Perform range checks on all secret witness values\n self.perform_range_checks();\n\n // Step 2: Compute commitments\n let sk_commitment = compute_share_computation_sk_commitment::(self.sk);\n let e_sm_commitment =\n compute_share_computation_e_sm_commitment::(self.e_sm);\n let pk_commitment = compute_threshold_pk_commitment::(self.pk0, self.pk1);\n\n // Step 3: Generate Fiat-Shamir challenges using commitments\n let gammas = self.generate_challenge(sk_commitment, pk_commitment, e_sm_commitment);\n\n // Step 4: Verify public key equations for each modulus\n for i in 0..L {\n let gamma = gammas.get(i);\n self.verify_public_key_for_modulus(i, gamma);\n }\n\n // Step 5: Return all commitments\n (sk_commitment, pk_commitment, e_sm_commitment)\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let inputs = self.payload(sk_commitment, pk_commitment, e_sm_commitment);\n\n compute_threshold_pk_challenge::(inputs)\n }\n\n /// Performs range checks on all secret witness values\n fn perform_range_checks(self) {\n // Check that error polynomial has small coefficients\n self.eek.range_check_2bounds::(self.configs.eek_bound, self.configs.eek_bound);\n\n // Check that secret key polynomial has small coefficients\n self.sk.range_check_2bounds::(self.configs.sk_bound, self.configs.sk_bound);\n\n // Check quotient terms are within expected bounds (per modulus)\n for i in 0..L {\n self.e_sm[i].range_check_2bounds::(\n self.configs.e_sm_bound,\n self.configs.e_sm_bound,\n );\n\n self.r1[i].range_check_2bounds::(\n self.configs.r1_bounds[i],\n self.configs.r1_bounds[i],\n );\n\n self.r2[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n }\n }\n\n /// Verifies the threshold public key generation equations for a specific CRT basis\n fn verify_public_key_for_modulus(self, i: u32, gamma: Field) {\n // Evaluate all polynomials at the random challenge point gamma\n let a_at_gamma = self.a.map(|a_poly| a_poly.eval(gamma));\n\n let eek_at_gamma = self.eek.eval(gamma);\n let sk_at_gamma = self.sk.eval(gamma);\n\n let r1_at_gamma = self.r1.map(|r1_poly| r1_poly.eval(gamma));\n let r2_at_gamma = self.r2.map(|r2_poly| r2_poly.eval(gamma));\n\n let pk0_at_gamma = self.pk0.map(|pk0_poly| pk0_poly.eval(gamma));\n let pk1_at_gamma = self.pk1.map(|pk1_poly| pk1_poly.eval(gamma));\n\n // Evaluate the cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n let expected_pk0 = -a_at_gamma[i] * sk_at_gamma\n + eek_at_gamma\n + r2_at_gamma[i] * cyclo_at_gamma\n + r1_at_gamma[i] * self.configs.qis[i];\n\n assert(pk0_at_gamma[i] == expected_pk0, \"Public key equation 1 failed\");\n\n // Equation 2: pk1_i = a_i\n assert(pk1_at_gamma[i] == a_at_gamma[i], \"Public key equation 2 failed\");\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/pk_generation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/pk_generation.vk b/crates/zk-prover/tests/fixtures/pk_generation.vk deleted file mode 100644 index e38d16b2d449b8408bf985bcdd2c8b451dd28204..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajg`9Bkm1IO{r$FVhH*bpE0Xw#gvWXaWLj;#4O=c-7bCFkffa_0!2PmW;-iE=de z5#?BpBEu(g%<;)JOo~EM`0V@r3;Mi&dp(|iz#9Pg>7YMVfS}aR9RL)7m|wTH9q?y? zTk9l5U%gbxd-Ii3+*{>y7Q|m=h4>#kHU~Nroa(E$9Fn=yXff$99?7GS9OJ)JUUy44 zQZ=-}&ni3~8v&DwL?U|`={9DZiLnGZjRI4DS>Jg` z8RD_R0kJZG>s_k2jlwXXK`-ClfRryKb*vnw0V~vWLDI29sx26xpmYELsDL?=Sdcn0 z>?g&HR-Cnv@TzW93&2Ge;#VVE548Ohmchn8u6?@r{w}MB%g+I8jk}F{Ljk*#QXgldG#1uWCUqqFC0S~FWh_eQ- z4oi5=4@|m`zztNaiINFG$C}BMRM$*&*qdx_FnTvJ=G@_zcTWQS)O(1y0K|l%Td;HC zU;0hjO|@-uRu`yp7fj?MqH~|s&PbO{U4EOcO@ry}sP?=rUayh4?AdZj{x^{r$8GQzPQ^hZn0zZ!|HXMWE?B zBMqd+E6`*%RFajyAaPDlOl0^<=cw%luszHfgsg1fgsCRCq6y& zHF8MT`iDrfbG+fA=l0{8IrpAv30mxu9dDeB-B|N^MI<#<&3C^W|571$$`Wt67vc@7j^z5V5YRR-j``MC_o!Q(Q{K=`N@!X_@eEsZ|2y?XU(e?F;K{!x~-}9fX$zBjSL<{9HYum~C}_B1t!4!8BO? z@UmG8&|lae`~LWvTc+fQ~GX*uIG*`Ckljjv~E*E+V=%#j-pm4s*pv4$@(m~ zi(T9SGM0F?J^W^WUoAH`rMO}nN9|*d{i0WOrYl~?Krw4BBy!d_G|s_|4cadz&Zg1E zW1s`=!dv%q;PzT|VY57H)>}UKIk;2Bisg+oqZM4(ACfsCNE=NOFr%0BqdIeMiJR{# zdst1$=IFKgy<_{Z9u}A=(5w9c=Yu6P)R=7w@#W}V49ow%>CW|?B8Lwjf^fJJIN_HyeO*QHJ?Uw zj*#;o2r|KpE||ZSd+s#u$3co=`u76I7z-W5KsFXWt{5q|iTPDtB?>K_eZrm*#){gop zYfp2HuRF)S)YiUO%X|IpcY6YvZH(k`duixn{@iG`s|vEt$UBC74W)lkJV{Iu6(gS+CX)rJF;07_ zkdp&OscPMe1I-~upW==~YSt1b$1QoOX4X!fa(ZrwZP(vku zIVq=TY^Hl0&}asx=J(|9av-$X)D)sMcy_4)iwU+Q-a3ASgB+4O;qzb+*=s=*k==Y@LnaNz-g=0M*dpzy9ezTtGR+TnS;^ClKbUSXN0`$wVlcH(h(N ufVt1toLT;`3qHOXhZ#ZEZ}~-{yCEAZlb?%MuF7iYF^mRz%|Xm}D*pqvAu{j) diff --git a/crates/zk-prover/tests/fixtures/share_decryption.json b/crates/zk-prover/tests/fixtures/share_decryption.json deleted file mode 100644 index cf6809aa8c..0000000000 --- a/crates/zk-prover/tests/fixtures/share_decryption.json +++ /dev/null @@ -1 +0,0 @@ -{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"5855950985937366278","abi":{"parameters":[{"name":"expected_sk_commitment","type":{"kind":"field"},"visibility":"public"},{"name":"expected_e_sm_commitment","type":{"kind":"field"},"visibility":"public"},{"name":"ct0","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"public"},{"name":"ct1","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"public"},{"name":"sk","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"e_sm","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"r1","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"r2","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"d","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":null,"error_types":{"790736725912586495":{"error_kind":"string","string":"Decryption share computation failed"},"7023503018538476324":{"error_kind":"string","string":"S commitment mismatch"},"12469291177396340830":{"error_kind":"string","string":"call to assert_max_bit_size"},"13823868475309396004":{"error_kind":"string","string":"E commitment mismatch"}}},"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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, THRESHOLD_SHARE_DECRYPTION_BIT_CT, THRESHOLD_SHARE_DECRYPTION_BIT_D,\n THRESHOLD_SHARE_DECRYPTION_BIT_E_SM, THRESHOLD_SHARE_DECRYPTION_BIT_R1,\n THRESHOLD_SHARE_DECRYPTION_BIT_R2, THRESHOLD_SHARE_DECRYPTION_BIT_SK,\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n};\nuse lib::core::threshold::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_sk_commitment: pub Field,\n expected_e_sm_commitment: pub Field,\n ct0: pub [Polynomial; L],\n ct1: pub [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<(2 * N) - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n) {\n let share_decryption: ShareDecryption = ShareDecryption::new(\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n );\n share_decryption.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/share_decryption/src/main.nr"},"71":{"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::commitments::{\n compute_aggregated_shares_commitment, compute_threshold_share_decryption_challenge,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold decryption share circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], r1_bounds: [Field; L], r2_bounds: [Field; L]) -> Self {\n Configs { qis, r1_bounds, r2_bounds }\n }\n}\n\n/// Threshold Share Decryption (Circuit 6).\n///\n/// Verifies:\n/// 1. Commitment to sk matches expected (from DKG decryption circuit)\n/// 2. Commitment to e_sm matches expected (from DKG decryption circuit)\n/// 3. Correct computation: d_i = c_0i + c_1i * s_i + e_i + r_2i * (X^N + 1) + r_1i * q_i\npub struct ShareDecryption {\n /// Circuit parameters including bounds and cryptographic constants\n configs: Configs,\n\n /// Expected commitment to aggregated sk shares (from DKG decryption circuit)\n /// (public witness)\n expected_sk_commitment: Field,\n\n /// Expected commitment to aggregated e_sm shares (from DKG decryption circuit)\n /// (public witness)\n expected_e_sm_commitment: Field,\n\n /// Ciphertext components (public witnesses)\n /// ct0 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct0: [Polynomial; L],\n /// ct1 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct1: [Polynomial; L],\n\n /// Aggregated sum of sk shares (secret witness)\n sk: [Polynomial; L],\n\n /// Aggregated sum of e_sm shares (secret witness, direct input)\n /// e_sm[basis] - sum of e_sm shares for each CRT basis (degree N-1 with N coefficients)\n e_sm: [Polynomial; L],\n\n /// Quotient polynomials for lifting to Z (secret witnesses)\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n\n /// Party's computed decryption share\n /// (public witnesses)\n d: [Polynomial; L],\n}\n\nimpl ShareDecryption {\n pub fn new(\n configs: Configs,\n expected_sk_commitment: Field,\n expected_e_sm_commitment: Field,\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n ) -> Self {\n ShareDecryption {\n configs,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n }\n }\n\n /// Verifies that aggregated secret shares hash to expected_sk_commitment\n fn verify_agg_sk_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.sk)\n == self.expected_sk_commitment,\n \"S commitment mismatch\",\n );\n }\n\n /// Verifies that aggregated noise shares hash to expected_e_sm_commitment\n fn verify_agg_e_sm_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.e_sm)\n == self.expected_e_sm_commitment,\n \"E commitment mismatch\",\n );\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation.\n ///\n /// This function serializes all polynomial coefficients (both public inputs and\n /// secret witnesses) into a 1D array in a deterministic order. The flattened data\n /// is used to generate the Fiat-Shamir challenge via the SAFE sponge API.\n ///\n /// The order of serialization is:\n /// 1. Commitment to aggregated secret shares `sk` (expected_sk_commitment)\n /// 2. Commitment to aggregated noise shares `e_sm` (expected_e_sm_commitment)\n /// 3. Ciphertext components `c_0` for each CRT basis (serialized coefficients)\n /// 4. Ciphertext components `c_1` for each CRT basis (serialized coefficients)\n /// 5. Quotient polynomials `r_1` for each CRT basis (serialized coefficients)\n /// 6. Quotient polynomials `r_2` for each CRT basis (serialized coefficients)\n /// 7. Decryption shares `d` for each CRT basis (serialized coefficients)\n ///\n /// Note: Aggregated secret shares `sk` and noise shares `e_sm` are represented by their\n /// commitments rather than serialized coefficients. This saves constraints while\n /// still binding them to the transcript.\n ///\n /// # Returns\n /// A vector containing commitments and polynomial coefficients in flattened form,\n /// ready for hashing to generate the Fiat-Shamir challenge.\n fn payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n // Use commitments instead of full polynomials (saves constraints)\n inputs.push(self.expected_sk_commitment);\n inputs.push(self.expected_e_sm_commitment);\n\n // Flatten ciphertext components (public inputs)\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1);\n\n // Flatten quotient polynomials (secret witnesses)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n // Flatten decryption shares (public outputs)\n inputs = flatten::<_, _, BIT_D>(inputs, self.d);\n\n inputs\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify sk commitment matches expected\n self.verify_agg_sk_commitment();\n\n // Step 2: Verify e_sm commitment matches expected\n self.verify_agg_e_sm_commitment();\n\n // Step 3: Perform range checks on quotient polynomials\n // Note: sk and e_sm range checks are handled by commitment verification\n // (the DKG decryption circuit already performed range checks on these values)\n self.check_range_bounds();\n\n // Step 4: Generate Fiat-Shamir challenge from the transcript\n let gamma = self.generate_challenge();\n\n // Step 5: Verify decryption share computation for each CRT basis\n for i in 0..L {\n self.verify_decryption_share_computation(i, gamma);\n }\n }\n\n /// Performs range checks on quotient polynomial witnesses.\n ///\n /// This function constrains quotient polynomials to be within their expected bounds\n /// as specified in the `configs`. This is critical for security because it prevents\n /// attacks where malicious provers provide out-of-range values that could break the\n /// security properties of the Threshold scheme.\n ///\n /// Note: Range checks on `sk` and `e_sm` are NOT performed here because:\n /// - Their commitments are verified against expected values from the DKG circuit\n /// - The DKG decryption circuit already performed range checks on these values\n /// - Commitment binding ensures the values match what was previously verified\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any quotient coefficient is\n /// outside its expected bounds.\n fn check_range_bounds(self) {\n // Check quotient polynomials are within bounds\n for basis_idx in 0..L {\n // r_1 quotients can be negative (modulus quotients)\n self.r1[basis_idx].range_check_2bounds::(\n self.configs.r1_bounds[basis_idx],\n self.configs.r1_bounds[basis_idx],\n );\n // r_2 quotients (cyclotomic quotients)\n self.r2[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge value using the SAFE cryptographic sponge.\n ///\n /// This function implements the Fiat-Shamir transform for the decryption share circuit:\n /// 1. Flattens all witness data (commitments for sk/e_sm, ciphertexts c_0/c_1, quotients r_1/r_2, decryption shares d) into a single array\n /// 2. Absorbs the flattened data into the SAFE sponge\n /// 3. Squeezes a single challenge value\n ///\n /// The challenge is used to evaluate polynomials for the Schwartz-Zippel lemma,\n /// which allows verification of polynomial equations by checking them at a random\n /// point rather than checking all coefficients.\n ///\n /// # Returns\n /// A single challenge value `gamma` used as the evaluation point for verifying\n /// the decryption share computation formula for all CRT bases.\n fn generate_challenge(self) -> Field {\n let inputs = self.payload();\n\n compute_threshold_share_decryption_challenge::(inputs)\n }\n\n /// Verifies the lifted decryption share computation formula for a specific CRT basis using the Schwartz-Zippel lemma.\n ///\n /// This function verifies that the decryption share for basis `i` satisfies:\n /// `d_i(gamma) = c_0i(gamma) + c_1i(gamma) * s_i(gamma) + e_i(gamma) + r_2i(gamma) * cyclo(gamma) + r_1i(gamma) * q_i`\n ///\n /// Where:\n /// - `c_0i`, `c_1i` are ciphertext components for basis i\n /// - `s_i` is the aggregated secret key shares for basis i\n /// - `e_i` is the aggregated noise shares for basis i\n /// - `r_1i`, `r_2i` are quotient witnesses for basis i\n /// - `cyclo(gamma) = gamma^N + 1` is the cyclotomic polynomial evaluated at gamma\n /// - `q_i` is the CRT modulus for basis i\n ///\n /// The Schwartz-Zippel lemma ensures that if this equation holds at a random point\n /// `gamma`, then the polynomials are identical with high probability.\n ///\n /// # Arguments\n /// * `basis_idx` - The index of the CRT basis to verify (0 <= basis_idx < L)\n /// * `gamma` - The Fiat-Shamir challenge value used as the evaluation point\n ///\n /// # Panics\n /// The circuit will fail if the decryption share computation formula doesn't hold for the specified basis.\n fn verify_decryption_share_computation(self, basis_idx: u32, gamma: Field) {\n // Evaluate ciphertext components at gamma\n let c_0_at_gamma = self.ct0[basis_idx].eval(gamma);\n let c_1_at_gamma = self.ct1[basis_idx].eval(gamma);\n\n // Evaluate aggregated sums at gamma\n let sk_at_gamma = self.sk[basis_idx].eval(gamma);\n let e_sm_at_gamma = self.e_sm[basis_idx].eval(gamma);\n\n // Evaluate quotient polynomials at gamma\n let r_1_at_gamma = self.r1[basis_idx].eval(gamma);\n let r_2_at_gamma = self.r2[basis_idx].eval(gamma);\n\n // Evaluate cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // Compute expected decryption share using the lifted formula:\n // d_i = c_0i + c_1i * sk_i + e_sm_i + r_2i * (X^N + 1) + r_1i * q_i\n let expected_decryption_share = c_0_at_gamma\n + c_1_at_gamma * sk_at_gamma\n + e_sm_at_gamma\n + r_2_at_gamma * cyclo_at_gamma\n + r_1_at_gamma * self.configs.qis[basis_idx];\n\n // Evaluate the party's claimed decryption share at gamma\n let computed_decryption_share = self.d[basis_idx].eval(gamma);\n\n // Enforce equality: computed decryption share must match expected value\n assert(\n computed_decryption_share == expected_decryption_share,\n \"Decryption share computation failed\",\n );\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/share_decryption.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/share_decryption.vk b/crates/zk-prover/tests/fixtures/share_decryption.vk deleted file mode 100644 index e1ea1bfab34d1f30acc3b615f8a8adfa10ab19a4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajg`6Ckw0KoAL(`@Ee*u=)N8euYp`Jt0cjBZh@^Nbk+n`tq zHPN2-j*FzMosDHl_Uji*?~$bV%FPm5x2*iO zXfh*m8J1Z0cIJ*W9eUTc^_o+Sft*6{rk=O)BeDrnL{F{g#nrE4iMPSnZpAE~1#0d; zg<2AM%#&7UBYRX;(#t$!0~rPtxdP!CI*?J*2CHy zWM#M`Z!VRlox9T|dL-+)y{D)4*i?G36v1SKur*~krq@m!BVmPJcP?ogl(#ROV+XDo zrHAt^a@*j4#WOF2oAZF9S&m{UF}NayRoC5>PxMVYHh9P^V4dG67$_@X!@8%&qsb+8 zy(-kOpD@5sA3T`H2Qnf#{S!gmsdo=KzDQ{*b@vY5ju`oHI_+Gq?jE8E6JG3v3zoW3 z{;-sZ$)QY#!;F%s2SxUl#eHR2*^;x5c9)|R#fKAE+o0$Ht5B;%ZA*(MoKsj|CI23+(L>P>|FAsjW*_w9N z_x2SM*Is?`7^|2Z=n<^bJIC4(kdrJjbZ%rfMV^NvsBen+I*2eQzO+t<4n8rbN|o~$ z4^3#zEh2?(SRLN5ndP07fDU%XZVcGw{PL5Aptd_cD0~InQg_bcWgAcnJ9s@QpSRk> zg{OXfKkQSALJ?O%@2j`L@*|NsLIFJFpx~Ok%5dV3zI|iC@v>YHjRSh(!CUC;v))b) zGFLtb)2Piew2*FX8M5!dA+ehCtZ~yI>iZYCCo=z*O~Y?eKAl3%Qumy%bv8L?XgmOYPT)1qfkPNe z+rO;m1upHIf5o?2HlN+YA>cjk)v502Y`E6oKp;0+HDDH%8ePEJCi*EC=04|*-}^qf z-`$j4D=Mh_JZv$m;QMh}o5&X)j-zz$S{oGLV zWK9IR8cShTF9!T+@o_F5ro_^FN#Zp0KS5FV#p7X{_*ZtMi`xg)~F72rW|PeGNX7T0;X1)&6?3#Os|F zu2$!tCJNDYk)Ywjdm7)y)td|{w6#kW%p}BN?6Z3-I~PAKEXRqqvyVqpKNdr`eYKhN z`y&$Ti1<&s_kB2fAdZQS1x=))}0Ilm3^`y-;HZBVG(0AqW>{HiuU zWG%#`i|Ad!xXmW{;L63}k_WEY$@*v=;${2^q<>QI8J?@^xCI3mmtr70%4^-Jn8EZ%IXVZ-3A)M_Yr*;WC~_n{hP{XG zucaUjTVaN>jrX7d?kfqIgge{9?VUSOzjp4q=e)ox&8p0F@l2TBb_?Pn1gF5-5@3J*Gxx@3Xl00cB zQ`_i!ceBe~HkfaG`@ASf%m#$>RjyJcSMj9}B_)u?Um_epP;-4&!&D=+{1Rx^UkS#y zDHJFR5N;ZC@CyF=Zar^iG}9faK-Tw*K>I3cn(@ZM&MQX1(;uA6fYul!y+veYaVbhE z#Ycf>WJasZd7w630yKg;CLx1jwZW8H`j&C#5zz{1+`G0Q33&D)c@U>75hyB%B3w%M zi~{OU3rh#QcwY|Wry3bSl?E<;rGPOR)_9=Rm`p;m1T578M|L&)JbmIfu$pFLYKKeB z5&WD?`^aIyc}Wm5TaPs%n~w;i<-d=RzC3uszm$z&X_p-f%)KOdJe2*iNN(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{\n L, N, SHARE_ENCRYPTION_BIT_CT, SHARE_ENCRYPTION_BIT_E0, SHARE_ENCRYPTION_BIT_E1,\n SHARE_ENCRYPTION_BIT_MSG, SHARE_ENCRYPTION_BIT_P1, SHARE_ENCRYPTION_BIT_P2,\n SHARE_ENCRYPTION_BIT_PK, SHARE_ENCRYPTION_BIT_R1, SHARE_ENCRYPTION_BIT_R2,\n SHARE_ENCRYPTION_BIT_U, SHARE_ENCRYPTION_CONFIGS,\n};\nuse lib::core::dkg::share_encryption::ShareEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_pk_commitment: pub Field,\n expected_message_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: pub [Polynomial; L],\n ct1is: pub [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n) {\n let share_encryption: ShareEncryption = ShareEncryption::new(\n SHARE_ENCRYPTION_CONFIGS,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n share_encryption.execute();\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/share_encryption/src/main.nr"},"65":{"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::commitments::compute_dkg_pk_commitment;\nuse crate::math::commitments::{\n compute_share_encryption_challenge, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for DKG share encryption circuit.\npub struct Configs {\n /// Plaintext modulus t\n pub t: Field,\n /// Q mod t (for scaling message)\n pub q_mod_t: Field,\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Bound for message polynomial (m)\n pub msg_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n t: Field,\n q_mod_t: Field,\n qis: [Field; L],\n k0is: [Field; L],\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n msg_bound: Field,\n ) -> Self {\n Configs {\n t,\n q_mod_t,\n qis,\n k0is,\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n msg_bound,\n }\n }\n}\n\n/// DKG Share Encryption Circuit (Circuit 3).\n///\n/// Verifies:\n/// 1. Public key commitment matches expected (from Circuit 0)\n/// 2. Message commitment matches expected (from SK shares circuit)\n/// 3. Correct DKG share encryption: ct0[l] = pk0[l] * u + e0[l] + k1 * k0[l] + r1[l] * q[l] + r2[l] * (X^N + 1)\n/// and ct1[l] = pk1[l] * u + e1 + p2[l] * (X^N + 1) + p1[l] * q[l]\npub struct ShareEncryption {\n /// Circuit parameters\n configs: Configs,\n /// Expected commitment to public key (from Circuit 0)\n /// (public witness)\n expected_pk_commitment: Field,\n /// Expected commitment to message (from SK shares verification circuit)\n /// (public witness)\n expected_message_commitment: Field,\n /// Public key component 0 for each CRT basis (committed witnesses)\n pk0is: [Polynomial; L],\n /// Public key component 1 for each CRT basis (committed witnesses)\n pk1is: [Polynomial; L],\n /// Ciphertext component 0 for each CRT basis (public witnesses)\n ct0is: [Polynomial; L],\n /// Ciphertext component 1 for each CRT basis (public witnesses)\n ct1is: [Polynomial; L],\n /// Random ternary polynomial u (secret witness)\n u: Polynomial,\n /// Error polynomial e0 (secret witness)\n e0: Polynomial,\n /// Per-basis error polynomials e0[l] (secret witnesses)\n e0is: [Polynomial; L],\n /// CRT quotients for e0 (secret witnesses)\n e0_quotients: [Polynomial; L],\n /// Error polynomial e1 (secret witness)\n e1: Polynomial,\n /// Raw message polynomial (secret witness)\n message: Polynomial,\n /// Modulus switching quotient polynomials r1 (secret witnesses, degree 2N-1)\n r1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials r2 (secret witnesses, degree N-1)\n r2is: [Polynomial; L],\n /// Modulus switching quotient polynomials p1 (secret witnesses, degree 2N-1)\n p1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials p2 (secret witnesses, degree N-1)\n p2is: [Polynomial; L],\n}\n\nimpl ShareEncryption {\n pub fn new(\n configs: Configs,\n expected_pk_commitment: Field,\n expected_message_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> Self {\n ShareEncryption {\n configs,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Verifies that the public key hashes to the expected commitment\n fn verify_pk_commitment(self) {\n assert(\n compute_dkg_pk_commitment::(self.pk0is, self.pk1is)\n == self.expected_pk_commitment,\n \"Public key commitment mismatch\",\n );\n }\n\n /// Verifies that the message polynomial hashes to the expected commitment\n fn verify_message_commitment(self) {\n assert(\n compute_share_encryption_commitment_from_message::(self.message)\n == self.expected_message_commitment,\n \"Message commitment mismatch\",\n );\n }\n\n /// Computes the scaled message k1 from the raw message in centered form\n /// k1[i] = (q_mod_t * message[i]) mod t, centered to [-t/2, t/2)\n fn compute_scaled_message(self) -> Polynomial {\n let t = self.configs.t;\n let t_mod = ModU128::new(t);\n let q_mod_t: Field = self.configs.q_mod_t;\n let mut k1_coeffs: [Field; N] = [0; N];\n\n // Integer division for t_half\n let t_half: u128 = (t as u128) / 2;\n\n for i in 0..N {\n let msg_i: Field = self.message.coefficients[i];\n let q_times_m_mod_t = t_mod.mul_mod(q_mod_t, msg_i);\n\n // Check if centering is needed (value > t/2 means negative in centered form)\n let needs_centering = (q_times_m_mod_t as u128) > t_half;\n\n k1_coeffs[i] = if needs_centering {\n // Value is in (t/2, t), negative in centered form\n // Represent as P - magnitude (i.e., 0 - magnitude in Field)\n let magnitude = t - q_times_m_mod_t;\n 0 - magnitude\n } else {\n // Value is in [0, t/2], stays positive\n q_times_m_mod_t\n };\n }\n\n Polynomial { coefficients: k1_coeffs }\n }\n\n /// Flattens all polynomial coefficients into a single array for Fiat-Shamir challenge generation\n fn payload(self, k1: Polynomial) -> Vec {\n let mut inputs = Vec::new();\n\n // Use pk commitment instead of full pk polynomials\n inputs.push(self.expected_pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n\n // Use message commitment instead of full message\n inputs.push(self.expected_message_commitment);\n\n // Include computed k1 in payload\n for i in 0..N {\n inputs.push(k1.coefficients[i]);\n }\n\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Performs coefficient-wise CRT consistency check for the e0 error polynomial\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n for j in 0..N {\n assert(\n self.e0.coefficients[j]\n == self.e0is[i].coefficients[j]\n + self.e0_quotients[i].coefficients[j] * self.configs.qis[i],\n );\n }\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify public key commitment matches expected\n self.verify_pk_commitment();\n\n // Step 2: Verify message commitment matches expected\n self.verify_message_commitment();\n\n // Step 3: Perform range checks\n self.check_range_bounds();\n\n // Step 4: Check CRT consistency for e0\n self.check_e0_crt_consistency();\n\n // Step 5: Compute scaled message k1 from message\n let k1 = self.compute_scaled_message();\n\n // Step 6: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge(k1);\n\n // Step 7: Verify encryption constraints\n self.verify_evaluations(gammas, k1)\n }\n\n /// Performs range checks on all secret witness polynomial coefficients\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::(self.configs.e0_bound, self.configs.e0_bound);\n self.e1.range_check_2bounds::(self.configs.e1_bound, self.configs.e1_bound);\n\n // Message should be in [0, t)\n self.message.range_check_standard::(self.configs.msg_bound);\n\n for i in 0..L {\n self.pk0is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n\n self.r1is[i].range_check_2bounds::(\n self.configs.r1_up_bounds[i],\n self.configs.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n\n self.p1is[i].range_check_2bounds::(\n self.configs.p1_bounds[i],\n self.configs.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n self.configs.p2_bounds[i],\n self.configs.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(self, k1: Polynomial) -> Vec {\n let inputs = self.payload(k1);\n\n compute_share_encryption_challenge::(inputs)\n }\n\n /// Verifies DKG encryption constraints using Fiat-Shamir challenges and the Schwartz-Zippel lemma\n fn verify_evaluations(self, gammas: Vec, k1: Polynomial) {\n let gamma = gammas.get(0);\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n // Verify ct0 equation: ct0[i] = pk0[i]*u + e0[i] + k1*k0[i] + r1[i]*q[i] + r2[i]*cyclo\n let mut ct0_rhs = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n ct0_rhs += k1_at_gamma * self.configs.k0is[i];\n ct0_rhs += r1i_at_gamma * self.configs.qis[i];\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n let ct0_lhs = self.ct0is[i].eval(gamma);\n\n // Verify ct1 equation: ct1[i] = pk1[i]*u + e1 + p2[i]*cyclo + p1[i]*q[i]\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n let mut ct1_rhs = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n ct1_rhs += p2is_at_gamma * cyclo_at_gamma;\n ct1_rhs += p1is_at_gamma * self.configs.qis[i];\n let ct1_lhs = self.ct1is[i].eval(gamma);\n\n // Accumulate weighted sums for batch verification\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n assert(sum.0 == sum.1);\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/share_encryption.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/share_encryption.vk b/crates/zk-prover/tests/fixtures/share_encryption.vk deleted file mode 100644 index 929d89b0c4f50c04eac7662bab4ff8b7e7ba6f16..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajg=OY^k1IO{imL`ITvqy|ZG-{mj2%2bvm`7CAsoJ%xc3XR0>`^hQadw`nitQ*$ zOSQsdj~I;^GsxSgs z_JJ;qi(_q9BG|`f0=)EiESgMthfB{Ch+mC5T^!{Q51?$B`Y(;;ja1vr93D|eQN7d^ zw#T1VtNUnzWJ_j4`-Hm##q6o>qmW5T@|07hg3&qia6C;RVqN@Ic;nr;Z>vJr<6U== z$QaXK9iuP!q$Bjfw7+qpS95m8UCm#nRpX4&L9^DiUId4GK1s5=P<82SF@FuWr_O#H zSexdXW%p|OeL>P{h2sMf18ZR+AoCi&>5RVWCOxwJ_e0#nSt;ujk$j00V$eacSDZaa zv5BJPlC;v@?1ReI>wlM}p6zXD-qo(ETYw14vGG?ywzEL30vd3S#f$q!P-Gybth~;k zM3tf-2fVRyXbTs{yIwhSmoc@#=%aWo4cu$;pSD0qa#$Lq_6_g!OlzX1EcuN#WQK&unCWPt*yXcgU0YL|<}BnQ z|9?q3PSr5SpJj|4@IcVh*YAn&?j!`-dZPxej6PWd8g;2eokThjZvaVzG{qQpQ6@RKn}z4?@66XI+1 zwdMN}p6Vzo6(gTu<$K(fbVX*?5p+9vslwA)`*c&O;ek*8|4*3}Pt_E~gVMu?S$3R; zCc*NHs3GRUSH;Rkm{22e6zyveK+@*DN)hZpQhT58UiK-S)o4mlFJCHn{i=GqQ~;$z zBJpX{sVv@R^w6&Q2rkNHK})o<2BUfE3VilJY~*B{ygR?O&pJy4t=KAq$@Y!iJEDN*WHMAFQlo}HTAQXyF> zUNuo}|0PKKV2mL7ee~>eVo~Cku=q^xZIBzuv*EH5cr?8ia7cQnSYi=}X6&<)IJLYvy{_fG)KNKBskT805tq@0R>IuTcN86z zW)H;dLEZWu05s?8C)NC$b2!Vpc-$rL4!o`$PFa95yv1ncVE9Z~MoF?Avvk2uqA)sz zR1BK#Gwa$87^E;_A&j4)x#XrOPFt}1->Th4Bf-nv?|(o*9@v%ys~4v z&S-%L4?+~*Xs7Y;%q4dp1CYHNZ%9KnJ@kmjFyS(5@4WA56!e_wZ~k>vBy-9)@JO)Q zKdgYQFl?aTHx*cX4$q^N00~6V_v8VLmubDm(4!WK_dbEwFBrzyEqfbF;10$Z6d4sQ zS70o&X#3%!vTU!0*p^VFj!Ka$`_HBjZp-i$e;H<`yd2c=O^gf3-PuBJo9}3?#c(sd zR3U<&L;{ro@INMP??kMP?3XM}6x^0qq3L_XIk}@WZ$MKaGN?Goyzrm$FTFI(=#wIo z`B4Z}QUc$S(nK9z;F84~;kU8sE@}BqW(SK1)=oa}qhvFA+|b^J9H3$*lOCog8z>HQ zh{fbNCjj*q;0pdVW3@n`RxI|C>agxw6Q4`Ic_h$mQYo!d7LsEUM!R+6u;oV$| z>(*g8MX-;VZ|ArSc`z^#vnAA+h98GJA=wkujeumxvw~|(yq%Qi|CHf~0lp{do_^m8 zL){7ro~V;iTb8#BMN=7cb3mw`{lE3;U!3EL@JP++ek~ajPzUP&f{2KmJF6A>Xtt5k r2uqjIqPi$91)Y59{0)LEVYeMug=#osP0p1Us_(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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_SK_BIT_SECRET,\n SHARE_COMPUTATION_SK_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SecretKeyShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let sk_share_computation: SecretKeyShareComputation = SecretKeyShareComputation::new(\n SHARE_COMPUTATION_SK_CONFIGS,\n expected_secret_commitment,\n sk_secret,\n y,\n PARITY_MATRIX,\n );\n\n sk_share_computation.execute()\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/dkg/sk_share_computation/src/main.nr"},"63":{"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::commitments::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/dkg/share_computation.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"77":{"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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\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 assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\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 * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/U128.nr"},"79":{"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/// 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_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/sk_share_computation.vk b/crates/zk-prover/tests/fixtures/sk_share_computation.vk deleted file mode 100644 index 56f249009a6465135172f73f87432d86ef724d1b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajgXCoU30D$2HMG`ww93{kFp{K5mB6eb=_AFZEtZKCc(N>6}_Glr?H zS4YsCz4xpYd%L6I{=xPA`uuRdVVle5@gF-D`n`58C8j=c ztCh!%-Wl>QpWk-rKO<_RCk3#OSa|@nopb-f1VwawEo5!OEZJI)op!Q)7CEaVRngMd z!`zp$gA;Ot?9Ci{;T;J~%ZPEUmc)Jm?!UO&qCoDd*Rvr_?WOG85LBBXJeSqw@)sF* zr~V2*f3J^0gHm_z3PdR4R!s#7@L5|kfP}9s_~YI?6Q|>b;==SAHop_Z@9#8pF#{L+ z3qB;jljNb`6_WUkE<%&N`^w-5u-cxF1M zje2IC3Thdof*-cLy~l^N6M8jD9#ekOlBu9qvI(wTd!Ho!1kmXA)R)0fg;SvwavYil zt0geMr$N#EaXMiWlw=p9^}$d{)`q5d>?Ot&Z>nb;RF`wa3)^9eYC&k3&AZm1L3xZ| zj29WVt3v}3QVC2O`854$J#ow-o@_zS`A_>EK}PcaKkyP&R=ANkhUUyOEBcg z!4XzOl+vu7IcT)Xo3H*l0JgIpeR}T1&cHaFM(q&^eqATWZcu-R6w`?gaxnfuiVho5 z_O-AWn_b>^-uE(aF>@R-OR*)Zna>cI`c29a+c!Nu=?M5T5iCodL7Q?Jm<^dz*Q#!M z7c;Z1U$7<_nrgINPC$Z1TL?QV)M&6|nw3ZMK^B??BN1P)G5k-%4%jj?{9BGlOD27sf_$J|U>sVtQefgN8{grL}6o{o2 zQD#*;ULJW8V$Kx}PLX39nxvCGnIhb*UThhHrIf z{M^^$ukZhcnsG#dU0(Q;#9A= z+Ao@n22P$(hP4;6Lh}HxP@#gO!yk6y!iK*AC>%mgU%!6f6DVh&>H6lvrZ(Yi7nbs= zV(_8$g`P94u@xvry>FANBwbHQ4o&RA1&ZL>XBKI{rViZho6ZVJA;4>rDN<9O(Xdq3 zC-iTG9ebr3&8ZUeQE1Wpx<>y-o6FbpNnz;FE!AzYsc$r-s@bN^HJdy*bxqr z2f#iL+PH@;c5miQ50G7?m8htDL{~56tH%8Cypqa9@l3o(7KEak+#->k4N{g-c@e`s zEjLhM!UwTv6>5vp@JP)1h}oW!Sz%^zMLx$!8+2|g!2yLMDP5u0rGmtuj!`<9w_|{) zNf;uqr0+dYum+8WsQmrQ;zw?eEc0+6W>7A%L5ersG?eOOJUhv{_xE~+g%K_^{S|aJ zrEQEums1A{o}+~rQce0{u8La&rAzmp^X8NF=S*xRynE$gGIZ{j8r}gHIU#q+QQq5Pd;?Zq}FV9s$F&r3JbxpP>vLP`>yn6?l-%zE1 k#A&}8JU92RV?d=&ndQez(SajcP^^`1C38V6951J diff --git a/crates/zk-prover/tests/fixtures/user_data_encryption.json b/crates/zk-prover/tests/fixtures/user_data_encryption.json deleted file mode 100644 index f036e61b8c..0000000000 --- a/crates/zk-prover/tests/fixtures/user_data_encryption.json +++ /dev/null @@ -1 +0,0 @@ -{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"9408608105749895694","abi":{"parameters":[{"name":"pk_commitment","type":{"kind":"field"},"visibility":"public"},{"name":"pk0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"ct0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"ct1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"u","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e0","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e1","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"e0_quotients","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"k1","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"r1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"r2is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"p1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"p2is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":null,"error_types":{"12469291177396340830":{"error_kind":"string","string":"call to assert_max_bit_size"}}},"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, 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: [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 // 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(f\"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(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 #[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: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\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: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\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(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\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 _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; 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(bits: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\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: [u1; 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: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\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: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\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: [u1; 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: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\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: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 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 bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"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;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(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(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(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(\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 // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(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(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(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 let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(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(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\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(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(_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 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;\n\nimpl BuildHasher for BuildHasherDefault\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 Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(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(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(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(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(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(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(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(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(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(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(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(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 Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(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 Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(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 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(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\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 is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"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_E1,\n USER_DATA_ENCRYPTION_BIT_K, USER_DATA_ENCRYPTION_BIT_P1, USER_DATA_ENCRYPTION_BIT_P2,\n USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_R1, USER_DATA_ENCRYPTION_BIT_R2,\n USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_CONFIGS,\n};\nuse lib::core::threshold::user_data_encryption::UserDataEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n pk_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e1: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n k1: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n) {\n let user_data_encryption: UserDataEncryption = UserDataEncryption::new(\n USER_DATA_ENCRYPTION_CONFIGS,\n pk_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n k1,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n let is_user_data_encryption_valid = user_data_encryption.execute();\n assert(is_user_data_encryption_valid);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/bin/threshold/user_data_encryption/src/main.nr"},"72":{"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::commitments::compute_user_data_encryption_challenge_commitment;\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Greco circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Lower bound for k1 polynomial (scaled message)\n pub k1_low_bound: Field,\n /// Upper bound for k1 polynomial (scaled message)\n pub k1_up_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n qis: [Field; L],\n k0is: [Field; L],\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n k1_low_bound: Field,\n k1_up_bound: Field,\n ) -> Self {\n Configs {\n qis,\n k0is,\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n k1_low_bound,\n k1_up_bound,\n }\n }\n}\n\n/// Correct User Data Encryption Circuit under Threshold public key\n///\n/// Verifies:\n/// 1. Range checks on all polynomial coefficients\n/// 2. Correct encryption: ct0i = pk0i * u + e0 + k1 * k0i + r1i * qi + r2i * cyclo\n/// and ct1i = pk1i * u + e1 + p1i * qi + p2i * cyclo\n///\n/// DISCLAIMER: Ported from Halo2 circuit by Greco paper authors @ PSE.\n/// Halo2 implementation: https://github.com/privacy-scaling-explorations/greco\npub struct UserDataEncryption {\n configs: Configs,\n pk_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n k1: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n}\n\nimpl UserDataEncryption {\n pub fn new(\n configs: Configs,\n pk_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n k1: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> UserDataEncryption {\n UserDataEncryption {\n configs,\n pk_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n k1,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Flattens all polynomials coefficients into a single array for challenge generation.\n ///\n /// This function serializes all polynomial coefficients into a 1D array to enable\n /// the generation of random challenge values using the Fiat-Shamir transform.\n /// The coefficients are arranged in a specific order to ensure deterministic\n /// challenge generation.\n ///\n /// # Returns\n /// An array containing all polynomials coefficients in flattened form\n fn gammas_payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n inputs.push(self.pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n // Flatten common polynomials (used across all CRT bases)\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n inputs = flatten::<_, _, BIT_K>(inputs, [self.k1]);\n\n // Flatten randomness polynomials for each CRT basis\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Performs coefficient-wise CRT consistency check for e0 polynomial.\n ///\n /// Verifies that for each CRT basis i and each coefficient j:\n /// e0.coefficients[j] = e0is[i].coefficients[j] + e0_quotients[i].coefficients[j] * qi\n ///\n /// This ensures that e0 == e0is[i] (mod qi) for all coefficients, which is\n /// much more secure than checking equality at a single evaluation point.\n ///\n /// # Security\n /// Coefficient-wise checking prevents attacks where a malicious prover could\n /// construct different polynomials that happen to evaluate to the same value\n /// at a single challenge point.\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n // Check each coefficient satisfies the CRT relationship\n for j in 0..N {\n // Verify: e0_coeff = e0i_coeff + quotient_coeff * qi\n assert(\n self.e0.coefficients[j]\n == self.e0is[i].coefficients[j]\n + self.e0_quotients[i].coefficients[j] * self.configs.qis[i],\n );\n }\n }\n }\n\n /// Verifies the correct encryption constraints for the Greco circuit.\n ///\n /// This function implements the core zero-knowledge proof by checking:\n /// 1. Binary constraint on k1 polynomial\n /// 2. Range constraints on all polynomials coefficients\n /// 3. CRT consistency for e0 polynomial\n /// 4. Correct encryption equations\n ///\n /// The proof uses the Schwartz-Zippel lemma: if polynomial equations hold\n /// when evaluated at random points, then the polynomials are identical with\n /// high probability.\n ///\n /// # Encryption Equations\n /// For each CRT basis i:\n /// * ct0i(gamma) = pk0i(gamma) * u(gamma) + e0(gamma) + k1(gamma) * k0i + r1i(gamma) * qi + r2i(gamma) * cyclo\n /// * ct1i(gamma) = pk1i(gamma) * u(gamma) + e1(gamma) + p1i(gamma) * qi + p2i(gamma) * cyclo\n ///\n /// Where:\n /// * cyclo(gamma) = gamma^N + 1 (cyclotomic polynomial)\n /// * qi, k0i are constants from the cryptographic parameters\n /// * r1i, r2i, p1i, p2i are randomness polynomials for each i-th CRT basis.\n ///\n /// # Returns\n /// True if the encryption constraints are satisfied, false otherwise.\n pub fn execute(self) -> bool {\n // Step 1: Perform range checks on all polynomial coefficients\n self.check_range_bounds();\n\n // Step 2: Check CRT consistency for e0 polynomial\n self.check_e0_crt_consistency();\n\n // Step 3: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge();\n\n // Step 4: Verify encryption constraints using challenges\n self.verify_evaluations(gammas)\n }\n\n /// Performs range checks on all polynomial coefficients.\n ///\n /// Checks that all polynomial coefficients are within their expected bounds\n /// as specified in the `configs`. This prevents attacks where coefficients\n /// are outside the valid range, which could break the security properties\n /// of the encryption scheme.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// its expected bounds. The bounds are defined per polynomial type in the `configs`.\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::(self.configs.e0_bound, self.configs.e0_bound);\n self.e1.range_check_2bounds::(self.configs.e1_bound, self.configs.e1_bound);\n self.k1.range_check_2bounds::(self.configs.k1_up_bound, self.configs.k1_low_bound);\n\n for i in 0..L {\n self.pk0is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n\n self.r1is[i].range_check_2bounds::(\n self.configs.r1_up_bounds[i],\n self.configs.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n\n self.p1is[i].range_check_2bounds::(\n self.configs.p1_bounds[i],\n self.configs.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n self.configs.p2_bounds[i],\n self.configs.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge.\n ///\n /// This function implements the Fiat-Shamir transform for the Greco circuit:\n /// 1. First, it computes and verifies the public key commitment by absorbing\n /// all public key polynomials and squeezing a single commitment value.\n /// 2. Then, it generates challenge values by absorbing all witness values\n /// (ciphertexts, errors, randomness) and squeezing 2L challenge values.\n ///\n /// The sponge absorbs all witness values and squeezes out deterministic random\n /// field elements that will be used to evaluate polynomials for the Schwartz-Zippel lemma.\n ///\n /// # Returns\n /// Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}] where:\n /// - gamma_0 is used as the primary evaluation point\n /// - gamma_1, ..., gamma_{L-1} are used for linear combination of ct0 constraints\n /// - gamma_L, ..., gamma_{2L-1} are used for linear combination of ct1 constraints\n fn generate_challenge(self) -> Vec {\n compute_user_data_encryption_challenge_commitment::(\n self.pk0is,\n self.pk1is,\n self.gammas_payload(),\n self.pk_commitment,\n )\n }\n\n /// Verifies encryption constraints using Fiat-Shamir challenges.\n ///\n /// For each CRT basis i, this function verifies that the encryption equations hold\n /// when evaluated at the challenge points. It uses the Schwartz-Zippel lemma:\n /// if polynomial equations hold when evaluated at random points, then the polynomials\n /// are identical with high probability.\n ///\n /// The verification combines all CRT bases using a linear combination with the\n /// challenge values to reduce the number of constraints while maintaining security.\n ///\n /// # Arguments\n /// * `gammas` - Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}]\n /// generated by `generate_challenge()`\n ///\n /// # Returns\n /// `true` if all encryption constraints are satisfied, `false` otherwise.\n fn verify_evaluations(self, gammas: Vec) -> bool {\n let gamma = gammas.get(0);\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = self.k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n let pk0_u = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n let mut ct0_rhs = pk0_u + (k1_at_gamma * self.configs.k0is[i]);\n ct0_rhs += r1i_at_gamma * self.configs.qis[i];\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n let ct0_lhs = self.ct0is[i].eval(gamma);\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n let pk1_u = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n let mut ct1_rhs = pk1_u + p2is_at_gamma * cyclo_at_gamma;\n ct1_rhs += p1is_at_gamma * self.configs.qis[i];\n let ct1_lhs = self.ct1is[i].eval(gamma);\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n sum.0 == sum.1\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/core/threshold/user_data_encryption.nr"},"74":{"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};\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 - \"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/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/commitments.nr"},"75":{"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() -> (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 assert(group >= 1);\n (nibble_bits, group)\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::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` 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(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(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.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\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::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\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 = Vec::new();\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.push(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.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\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 mut inputs = Vec::new();\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.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(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 mut inputs = Vec::new();\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.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(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 mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(0) != 0);\n assert(digests2.get(0) == digests1.get(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.get(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.get(i) == packed2.get(i));\n }\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/helpers.nr"},"80":{"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 {\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 Polynomial {\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 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::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` 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(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::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\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::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` 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(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::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\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::()`)\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(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\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#[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_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\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\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"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 {\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 SafeSponge {\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 {\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: Vec) {\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.get(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) -> Vec {\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 = Vec::new();\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.push(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, STATE_SIZE)\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(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 Vec.\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 = Vec::from_slice(&[1, 2, 3]);\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.get(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.get(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 = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\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.get(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.get(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 = Vec::from_slice([10, 20, 30]);\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.get(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.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != output2.get(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 = Vec::from_slice([1, 2, 3]);\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.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(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(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(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":"/home/ace/main/gnosis/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/crates/zk-prover/tests/fixtures/user_data_encryption.vk b/crates/zk-prover/tests/fixtures/user_data_encryption.vk deleted file mode 100644 index 0934ae5fb94ed2f384f22af5d21f52aafb4d5fd0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1888 zcmajgcRw2l1Hf?!E|F0|gcJ>81~F=nh>B6GMvc}un#~?Xvj*D}Tpj^vpu7jqQ3EHqm#oP1 z^TYYmLI?^H(?PG$so*bmV8CWnk`gVNEc=^jCxofTKJc+L%2}5kdO1q5p%cb`1|<7j z@Jl~MY$v=2o2(OSzXhF`PD2QTM>%1j8n{xGY@eInSeAotKzGEDB$iBXFsvL#W*-n% z<2W&4-}t{FbrjNt5G7~wRwFyX5Q9^$CfO1l0PK$2jhmJU6`SqcW322lb4O1kZhjPu zNe;-z-=@k-mRh%5^KkpZ3_nL&s{>=h^oh)9O5+j7Lnn)}9JYMKYw&jI;UOBCL5C4F z`ayZQyOGtTVk3{O4sD+RxYJpKZMIPc(T3GNjG!*?1#r8}@&nv1$kmwJyFYK{Ge>A7 zp?fWTrhroi1z2H#*}iFnDQH$Mx4F+m`B;=m z&#WflgA-5#)C(v}pJ|nAWfqP0YpVLAGuB-Z~k5=Qa_bIeoRY`Rk`^lBOna@rUsLj1$@|iUe zZ_Zn;)@B(LD>iZ=YtLLUFrMc=jWdexcxE?FPoHYO;~{tGO9*hQ2zaZ@z`1P}c~D4Q zZ-vQHw%!})`swtyl`7|?31(=+=h+N#HVMw z5IIj3J+2wGnGAfygPJtJ4GhanmLq~73fcNQnTr@osV}lmD#O3HY7Htdpt3I+O>e9fmJ$|XDjNI`tDslpVdq4E+#fQszk;7Gj>JXPl_e*Ys*v{z}^4eXBaA3b@tlB&D-aHl>N2-3^ z;kLT#MStbmrJYf9A(PyHA0^QnHt`@DPxFQaJ806x8F#v|@#bR%rG_i1-5OuI(2p{) zFb$1DFiB_)A-(lx=8#=_F~(xI==I#gQLt3*%C;59u&3tb4b6UFcBB-_=2`mZFHk^|;FaWJud) z_3f)4EH>)&E-pUYZs4v7Z4=`yJ9uLdV+2>y|yBMZC+vB5yFhHGV5yYjtB|G-lipI)eILP33qPxb)1(7Z#-1)$9Bu66(f? z#=%LfbE>oiw^8{kMIPU^{1o9O2&AX;lx{o|l-Rzi9F{0IK^FaO2t)rPg*J*NG8udz z-#_2IQJubI9U7xG)ROa^@j0B97NT(sC)v1K@3I%xnIurK!q*cO^gxjyOP) z<+y}fryV?_*2X^nxipn~M@q3?-!I{=FHVER{}g@=mmroEDUuDXGfL|b&&%V(Nh_r! zftO^bYR#@dt@{M~BwUjb>x4R+9RXUeGO3}rT(Lyfq23a0S z0R2T_Y-r^~6+obgNQ5el=&Zd4du3bw3b34(rL|$;8RnFFSJH>Y3%`+_Olwm+N=AXu zhxGmh9;2TOgdi)85jX11CWY@R>`gu22&2LoxyCDIj^h6B<%FdNz&UFEA)NdOpWNIW zwLILWjjIvr>3>J9xFU3K|KMMMA2<*#=uuugD}eL*9@vfbEQPo5r3l Option<( let sd: e3_fhe_params::PresetSearchDefaults = BfvPreset::InsecureThreshold512.search_defaults().unwrap(); - setup_circuit_fixtures(&backend, &["dkg", "share_encryption"], "share_encryption").await; + setup_compiled_circuit(&backend, "dkg", "share_encryption").await; let sample = ShareEncryptionCircuitData::generate_sample( preset, @@ -96,7 +97,7 @@ async fn setup_share_encryption_sk_test() -> Option<( let sd: e3_fhe_params::PresetSearchDefaults = BfvPreset::InsecureThreshold512.search_defaults().unwrap(); - setup_circuit_fixtures(&backend, &["dkg", "share_encryption"], "share_encryption").await; + setup_compiled_circuit(&backend, "dkg", "share_encryption").await; let sample = ShareEncryptionCircuitData::generate_sample( preset, @@ -133,12 +134,7 @@ async fn setup_share_computation_sk_test() -> Option<( let bb = find_bb().await?; let (backend, temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures( - &backend, - &["dkg", "sk_share_computation"], - "sk_share_computation", - ) - .await; + setup_compiled_circuit(&backend, "dkg", "sk_share_computation").await; let sample = ShareComputationCircuitData::generate_sample(preset, committee, DkgInputType::SecretKey) @@ -170,12 +166,7 @@ async fn setup_share_computation_e_sm_test() -> Option<( let bb = find_bb().await?; let (backend, temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures( - &backend, - &["dkg", "e_sm_share_computation"], - "e_sm_share_computation", - ) - .await; + setup_compiled_circuit(&backend, "dkg", "e_sm_share_computation").await; let sample = ShareComputationCircuitData::generate_sample( preset, @@ -210,7 +201,7 @@ async fn setup_pk_generation_test() -> Option<( let bb = find_bb().await?; let (backend, temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures(&backend, &["threshold", "pk_generation"], "pk_generation").await; + setup_compiled_circuit(&backend, "threshold", "pk_generation").await; let sample = PkGenerationCircuitData::generate_sample(preset, committee).ok()?; let prover = ZkProver::new(&backend); @@ -240,12 +231,7 @@ async fn setup_share_decryption_test() -> Option<( let bb = find_bb().await?; let (backend, temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures( - &backend, - &["threshold", "share_decryption"], - "share_decryption", - ) - .await; + setup_compiled_circuit(&backend, "threshold", "share_decryption").await; let sample = ThresholdShareDecryptionCircuitData::generate_sample(preset, committee).ok()?; let prover = ZkProver::new(&backend); @@ -275,7 +261,7 @@ async fn setup_pk_aggregation_test() -> Option<( let bb = find_bb().await?; let (backend, temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures(&backend, &["threshold", "pk_aggregation"], "pk_aggregation").await; + setup_compiled_circuit(&backend, "threshold", "pk_aggregation").await; let sample = PkAggregationCircuitData::generate_sample(preset, committee).ok()?; let prover = ZkProver::new(&backend); @@ -305,12 +291,7 @@ async fn setup_decrypted_shares_aggregation_test() -> Option<( let bb = find_bb().await?; let (backend, temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures( - &backend, - &["threshold", "decrypted_shares_aggregation_bn"], - "decrypted_shares_aggregation_bn", - ) - .await; + setup_compiled_circuit(&backend, "threshold", "decrypted_shares_aggregation_bn").await; let sample = DecryptedSharesAggregationCircuitData::generate_sample(preset, committee).ok()?; let prover = ZkProver::new(&backend); @@ -339,7 +320,7 @@ async fn setup_pk_test() -> Option<( let bb = find_bb().await?; let (backend, temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures(&backend, &["dkg", "pk"], "pk").await; + setup_compiled_circuit(&backend, "dkg", "pk").await; let sample = PkCircuitData::generate_sample(preset).ok()?; let prover = ZkProver::new(&backend); diff --git a/crates/zk-prover/tests/onchain_verification_tests.rs b/crates/zk-prover/tests/onchain_verification_tests.rs index 76b128a8ee..503d924bf9 100644 --- a/crates/zk-prover/tests/onchain_verification_tests.rs +++ b/crates/zk-prover/tests/onchain_verification_tests.rs @@ -17,7 +17,7 @@ use alloy::{ rpc::types::TransactionRequest, sol, }; -use common::{find_anvil, find_bb, setup_circuit_fixtures, setup_test_prover}; +use common::{find_anvil, find_bb, setup_compiled_circuit, setup_test_prover}; use e3_fhe_params::BfvPreset; use e3_zk_helpers::circuits::dkg::pk::circuit::{PkCircuit, PkCircuitData}; use e3_zk_prover::{Provable, ZkProver}; @@ -71,7 +71,7 @@ async fn test_pk_bfv_onchain_verification() { let preset = BfvPreset::InsecureThreshold512; let (backend, _temp) = setup_test_prover(&bb).await; - setup_circuit_fixtures(&backend, &["dkg", "pk"], "pk").await; + setup_compiled_circuit(&backend, "dkg", "pk").await; let sample = match PkCircuitData::generate_sample(preset) { Ok(s) => s, diff --git a/crates/zk-prover/tests/witness_tests.rs b/crates/zk-prover/tests/witness_tests.rs index 471dd929dd..472c39624d 100644 --- a/crates/zk-prover/tests/witness_tests.rs +++ b/crates/zk-prover/tests/witness_tests.rs @@ -34,15 +34,3 @@ fn test_witness_generation_wrong_sum_fails() { assert!(result.is_err()); } - -#[test] -fn test_compiled_circuit_from_fixture() { - let fixtures = fixtures_dir(); - let circuit = CompiledCircuit::from_file(&fixtures.join("pk.json")).unwrap(); - - assert!( - !circuit.abi.parameters.is_empty(), - "PkBfv circuit should have parameters" - ); - assert!(circuit.abi.parameters.len() > 0); -} diff --git a/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol b/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol index 8cfc0cb37a..5b7da618f6 100644 --- a/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol +++ b/packages/enclave-contracts/contracts/verifier/DkgPkVerifier.sol @@ -7,122 +7,238 @@ uint256 constant LOG_N = 13; uint256 constant NUMBER_OF_PUBLIC_INPUTS = 17; uint256 constant VK_HASH = 0x170affbea8713b79ad326398ea7b49424c51fa4dca10a65185ad33dbce4d6001; library HonkVerificationKey { - function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) { + function loadVerificationKey() + internal + pure + returns (Honk.VerificationKey memory) + { Honk.VerificationKey memory vk = Honk.VerificationKey({ circuitSize: uint256(8192), logCircuitSize: uint256(13), publicInputsSize: uint256(17), - ql: Honk.G1Point({ - x: uint256(0x22a702d6d3957500783049fee5af2a27155cfdf1b6c2958942f5cde4bc63d163), - y: uint256(0x003567b43861479b2347249040b9a4c4423f494e6dd8a7de9a4e3900741c4551) + ql: Honk.G1Point({ + x: uint256( + 0x22a702d6d3957500783049fee5af2a27155cfdf1b6c2958942f5cde4bc63d163 + ), + y: uint256( + 0x003567b43861479b2347249040b9a4c4423f494e6dd8a7de9a4e3900741c4551 + ) }), - qr: Honk.G1Point({ - x: uint256(0x1333cd6f8595ef95ab9d9744d1d00175a56c1b0bc60000ac6d4eb9ec7315c70a), - y: uint256(0x1c891650f45fe25cf375ea0b322372757b89799546eed2152766130e6b99efa0) + qr: Honk.G1Point({ + x: uint256( + 0x1333cd6f8595ef95ab9d9744d1d00175a56c1b0bc60000ac6d4eb9ec7315c70a + ), + y: uint256( + 0x1c891650f45fe25cf375ea0b322372757b89799546eed2152766130e6b99efa0 + ) }), - qo: Honk.G1Point({ - x: uint256(0x251fdc445de2b90170e8c86c41a81303bb3de75352f2bd6f095bdab77486445a), - y: uint256(0x06f20c995414f9b6bdb794492d328124e2b7676329a5a1724365076751ad2a8a) + qo: Honk.G1Point({ + x: uint256( + 0x251fdc445de2b90170e8c86c41a81303bb3de75352f2bd6f095bdab77486445a + ), + y: uint256( + 0x06f20c995414f9b6bdb794492d328124e2b7676329a5a1724365076751ad2a8a + ) }), - q4: Honk.G1Point({ - x: uint256(0x12600bb185b845c63e4b9d5c310db2d257aa5d1d09090ef3c8bdd7334e8991d0), - y: uint256(0x017ccf0bdad7381ff8a3bef25259d90c296b71c037ee58bcce51cb0b7a6e97f4) + q4: Honk.G1Point({ + x: uint256( + 0x12600bb185b845c63e4b9d5c310db2d257aa5d1d09090ef3c8bdd7334e8991d0 + ), + y: uint256( + 0x017ccf0bdad7381ff8a3bef25259d90c296b71c037ee58bcce51cb0b7a6e97f4 + ) }), - qm: Honk.G1Point({ - x: uint256(0x1a5c96bf5dac44c45e28380daccedfec1d9a8919999a0d748a8686f7f42cba76), - y: uint256(0x28c5876a4c88720ff49870cbc3b7f41c26a131f4d57ce95cbc6127859c08931f) + qm: Honk.G1Point({ + x: uint256( + 0x1a5c96bf5dac44c45e28380daccedfec1d9a8919999a0d748a8686f7f42cba76 + ), + y: uint256( + 0x28c5876a4c88720ff49870cbc3b7f41c26a131f4d57ce95cbc6127859c08931f + ) }), - qc: Honk.G1Point({ - x: uint256(0x2c740230a118ad04f1482eeef2e75a14aed0f961b763120de34d0fbe63ca12b0), - y: uint256(0x1b9aa7fd5bf93acbaadd615b6e0829e714539fe471bece34b359cd6a96d00294) + qc: Honk.G1Point({ + x: uint256( + 0x2c740230a118ad04f1482eeef2e75a14aed0f961b763120de34d0fbe63ca12b0 + ), + y: uint256( + 0x1b9aa7fd5bf93acbaadd615b6e0829e714539fe471bece34b359cd6a96d00294 + ) }), - qLookup: Honk.G1Point({ - x: uint256(0x0c4032c3079594eb75a8449d3d5ce8bc3661650d53f9b24d923d8f404cb0bbc9), - y: uint256(0x1084d709650356d40f0158fd6da81f54eb5fe796a0ca89441369b7c24301f851) + qLookup: Honk.G1Point({ + x: uint256( + 0x0c4032c3079594eb75a8449d3d5ce8bc3661650d53f9b24d923d8f404cb0bbc9 + ), + y: uint256( + 0x1084d709650356d40f0158fd6da81f54eb5fe796a0ca89441369b7c24301f851 + ) }), - qArith: Honk.G1Point({ - x: uint256(0x1f13031b7801d2da6d5206a7da087d7661d87905cef81f24e3cbe9e7a1c51488), - y: uint256(0x2d93aa6923ac15844842bd024199117f43ca14c883f37570030fdf385356a18a) + qArith: Honk.G1Point({ + x: uint256( + 0x1f13031b7801d2da6d5206a7da087d7661d87905cef81f24e3cbe9e7a1c51488 + ), + y: uint256( + 0x2d93aa6923ac15844842bd024199117f43ca14c883f37570030fdf385356a18a + ) }), - qDeltaRange: Honk.G1Point({ - x: uint256(0x300557c1eda8ed63912d72e051bb3431bd54f7395755b820a59ff85295eb36d9), - y: uint256(0x227e5f5f62555201e96e188514b5387fb7e026a4af0ac209ec6730c4e0e6cc76) + qDeltaRange: Honk.G1Point({ + x: uint256( + 0x300557c1eda8ed63912d72e051bb3431bd54f7395755b820a59ff85295eb36d9 + ), + y: uint256( + 0x227e5f5f62555201e96e188514b5387fb7e026a4af0ac209ec6730c4e0e6cc76 + ) }), - qElliptic: Honk.G1Point({ - x: uint256(0x20a7925feb244b2ba41d31db4651a6c6c6be672ed0e7711f2ef4c2b89f9c4a5f), - y: uint256(0x2472b531a32a7d7f80ec3c3375977ba4968f326786473e34d1fd73e6236cf661) + qElliptic: Honk.G1Point({ + x: uint256( + 0x20a7925feb244b2ba41d31db4651a6c6c6be672ed0e7711f2ef4c2b89f9c4a5f + ), + y: uint256( + 0x2472b531a32a7d7f80ec3c3375977ba4968f326786473e34d1fd73e6236cf661 + ) }), - qMemory: Honk.G1Point({ - x: uint256(0x02095e5acd019e4edaf8d736615b4a159deafdb98a171db591ed499b0219fb4b), - y: uint256(0x0644f4dc54ac72663d956a233412f748e74b1591553ecbca703829acf75e471a) + qMemory: Honk.G1Point({ + x: uint256( + 0x02095e5acd019e4edaf8d736615b4a159deafdb98a171db591ed499b0219fb4b + ), + y: uint256( + 0x0644f4dc54ac72663d956a233412f748e74b1591553ecbca703829acf75e471a + ) }), - qNnf: Honk.G1Point({ - x: uint256(0x022bae55678012a184d4cb970b8f9a6d1334097d611de534bef96fc9f8d9d011), - y: uint256(0x284ee2d499274885bcb7a0d77b0a261d9192ec413b0c0a86fb27ae88cdd5a72c) + qNnf: Honk.G1Point({ + x: uint256( + 0x022bae55678012a184d4cb970b8f9a6d1334097d611de534bef96fc9f8d9d011 + ), + y: uint256( + 0x284ee2d499274885bcb7a0d77b0a261d9192ec413b0c0a86fb27ae88cdd5a72c + ) }), - qPoseidon2External: Honk.G1Point({ - x: uint256(0x2dd8c7e5ce5f6a7053c173bb140d46830ab962c6c45d637d66171ee540bb21d5), - y: uint256(0x033b47f5f8496af8d227ef175c47b3f7cd666ebc94f0e63562ebfcf30d73f6e2) + qPoseidon2External: Honk.G1Point({ + x: uint256( + 0x2dd8c7e5ce5f6a7053c173bb140d46830ab962c6c45d637d66171ee540bb21d5 + ), + y: uint256( + 0x033b47f5f8496af8d227ef175c47b3f7cd666ebc94f0e63562ebfcf30d73f6e2 + ) }), - qPoseidon2Internal: Honk.G1Point({ - x: uint256(0x2940b2ab034af88869e264e12ee268b16c221b5f2cdd96748cce870c1a7bb24a), - y: uint256(0x04cfb9bfe08adf0e6f25c2cc9e83448d8f23d9fb3a0efba8d41768520d62d0e8) + qPoseidon2Internal: Honk.G1Point({ + x: uint256( + 0x2940b2ab034af88869e264e12ee268b16c221b5f2cdd96748cce870c1a7bb24a + ), + y: uint256( + 0x04cfb9bfe08adf0e6f25c2cc9e83448d8f23d9fb3a0efba8d41768520d62d0e8 + ) }), - s1: Honk.G1Point({ - x: uint256(0x1b300dbb752984d39a06a3278fc9048a525d0fdf14ef98f17ffb42a971fb9032), - y: uint256(0x01ccd716ea4eeba47b57e3110f305af0d1e2feec11f2656816dbb234ea0b3b1b) + s1: Honk.G1Point({ + x: uint256( + 0x1b300dbb752984d39a06a3278fc9048a525d0fdf14ef98f17ffb42a971fb9032 + ), + y: uint256( + 0x01ccd716ea4eeba47b57e3110f305af0d1e2feec11f2656816dbb234ea0b3b1b + ) }), - s2: Honk.G1Point({ - x: uint256(0x0d2e187f65cf5ab43eac061f54e93bdcc292b2f518ee632b030ea3290143139c), - y: uint256(0x03ff9967978b924f43af1e71f6281ee36a96c1b647bbf8c17e3cb4626068b78b) + s2: Honk.G1Point({ + x: uint256( + 0x0d2e187f65cf5ab43eac061f54e93bdcc292b2f518ee632b030ea3290143139c + ), + y: uint256( + 0x03ff9967978b924f43af1e71f6281ee36a96c1b647bbf8c17e3cb4626068b78b + ) }), - s3: Honk.G1Point({ - x: uint256(0x2106e82e5e59b21be7c8ac07ede04efc6445f01e31b5ce7894444cb081df43d1), - y: uint256(0x0571641ab150cfa4371421f984cc897945b69ca100d0960c2ee5ca1d17cd9670) + s3: Honk.G1Point({ + x: uint256( + 0x2106e82e5e59b21be7c8ac07ede04efc6445f01e31b5ce7894444cb081df43d1 + ), + y: uint256( + 0x0571641ab150cfa4371421f984cc897945b69ca100d0960c2ee5ca1d17cd9670 + ) }), - s4: Honk.G1Point({ - x: uint256(0x27599a711decc65fa4aad9515655e029868cc54d495fb8b53fa44e165702a5ee), - y: uint256(0x1d9db80b8419761979511454f69fa448fc50d15062e434c6994c4ccc4912f672) + s4: Honk.G1Point({ + x: uint256( + 0x27599a711decc65fa4aad9515655e029868cc54d495fb8b53fa44e165702a5ee + ), + y: uint256( + 0x1d9db80b8419761979511454f69fa448fc50d15062e434c6994c4ccc4912f672 + ) }), - t1: Honk.G1Point({ - x: uint256(0x099e3bd5a0a00ab7fe18040105b9b395b5d8b7b4a63b05df652b0d10ef146d26), - y: uint256(0x0015b8d2515d76e2ccec99dcd194592129af3a637f5a622a32440f860d1e2a7f) + t1: Honk.G1Point({ + x: uint256( + 0x099e3bd5a0a00ab7fe18040105b9b395b5d8b7b4a63b05df652b0d10ef146d26 + ), + y: uint256( + 0x0015b8d2515d76e2ccec99dcd194592129af3a637f5a622a32440f860d1e2a7f + ) }), - t2: Honk.G1Point({ - x: uint256(0x1b917517920bad3d8bc01c9595092a222b888108dc25d1aa450e0b4bc212c37e), - y: uint256(0x305e8992b148eedb22e6e992077a84482141c7ebe42000a1d58ccb74381f6d19) + t2: Honk.G1Point({ + x: uint256( + 0x1b917517920bad3d8bc01c9595092a222b888108dc25d1aa450e0b4bc212c37e + ), + y: uint256( + 0x305e8992b148eedb22e6e992077a84482141c7ebe42000a1d58ccb74381f6d19 + ) }), - t3: Honk.G1Point({ - x: uint256(0x13567e3b915c81013ada15236ba5cfa60111b440400b2bca37e2b1085e924a77), - y: uint256(0x0148d22589b91f0d8f4674af5744dedafd63caea904b434e748f9713de8cc3d7) + t3: Honk.G1Point({ + x: uint256( + 0x13567e3b915c81013ada15236ba5cfa60111b440400b2bca37e2b1085e924a77 + ), + y: uint256( + 0x0148d22589b91f0d8f4674af5744dedafd63caea904b434e748f9713de8cc3d7 + ) }), - t4: Honk.G1Point({ - x: uint256(0x043d063b130adfb37342af45d0155a28edd1a7e46c840d9c943fdf45521c64ce), - y: uint256(0x261522c4089330646aff96736194949330952ae74c573d1686d9cb4a00733854) + t4: Honk.G1Point({ + x: uint256( + 0x043d063b130adfb37342af45d0155a28edd1a7e46c840d9c943fdf45521c64ce + ), + y: uint256( + 0x261522c4089330646aff96736194949330952ae74c573d1686d9cb4a00733854 + ) }), - id1: Honk.G1Point({ - x: uint256(0x1fa05f284bf1410f37f0d556ccfeb052395ec8625620cf724d146a3b15496d4d), - y: uint256(0x0c8fc17b9b81b4f93a7b9bdd1cc5f01a30ef6e808409c456f6d6d13fe7d2eb17) + id1: Honk.G1Point({ + x: uint256( + 0x1fa05f284bf1410f37f0d556ccfeb052395ec8625620cf724d146a3b15496d4d + ), + y: uint256( + 0x0c8fc17b9b81b4f93a7b9bdd1cc5f01a30ef6e808409c456f6d6d13fe7d2eb17 + ) }), - id2: Honk.G1Point({ - x: uint256(0x05798d2cd96b3294d8cc2f0120fa58ffea3a662e32039784f0b0b051e34e8718), - y: uint256(0x02d377efbb702de6d6a38e5c42c6aaf56cc11762d724a635ea4d5dc72eb9e0ca) + id2: Honk.G1Point({ + x: uint256( + 0x05798d2cd96b3294d8cc2f0120fa58ffea3a662e32039784f0b0b051e34e8718 + ), + y: uint256( + 0x02d377efbb702de6d6a38e5c42c6aaf56cc11762d724a635ea4d5dc72eb9e0ca + ) }), - id3: Honk.G1Point({ - x: uint256(0x110bd6ab5007b97692cd6e8ea8cab85d8b039d9e8dc2a9931fa6dcd72e0adac8), - y: uint256(0x2e418397e17371fcf5a1a5c614f4dfe9727b79d5aa127ab98c04a7a4c06ccb9f) + id3: Honk.G1Point({ + x: uint256( + 0x110bd6ab5007b97692cd6e8ea8cab85d8b039d9e8dc2a9931fa6dcd72e0adac8 + ), + y: uint256( + 0x2e418397e17371fcf5a1a5c614f4dfe9727b79d5aa127ab98c04a7a4c06ccb9f + ) }), - id4: Honk.G1Point({ - x: uint256(0x0ccf438e4b27c76e599cda77ba04ad29cbaf538ded427e979eef69a5a9884b78), - y: uint256(0x09117b0cb34fc65ed20f92de70c6f8e073c755fb4acf2d74f402c6a97ee3d01a) + id4: Honk.G1Point({ + x: uint256( + 0x0ccf438e4b27c76e599cda77ba04ad29cbaf538ded427e979eef69a5a9884b78 + ), + y: uint256( + 0x09117b0cb34fc65ed20f92de70c6f8e073c755fb4acf2d74f402c6a97ee3d01a + ) }), - lagrangeFirst: Honk.G1Point({ - x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001), - y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002) + lagrangeFirst: Honk.G1Point({ + x: uint256( + 0x0000000000000000000000000000000000000000000000000000000000000001 + ), + y: uint256( + 0x0000000000000000000000000000000000000000000000000000000000000002 + ) }), - lagrangeLast: Honk.G1Point({ - x: uint256(0x22671e023cbbeb82d51b48eb911951a7a1f9c2bb913f3f42a56f272e205d4624), - y: uint256(0x139bdfe9fe99633e5abe888702fa64a75c80d62184d0a16bd999840553954bb1) + lagrangeLast: Honk.G1Point({ + x: uint256( + 0x22671e023cbbeb82d51b48eb911951a7a1f9c2bb913f3f42a56f272e205d4624 + ), + y: uint256( + 0x139bdfe9fe99633e5abe888702fa64a75c80d62184d0a16bd999840553954bb1 + ) }) }); return vk; @@ -132,24 +248,31 @@ library HonkVerificationKey { pragma solidity ^0.8.27; interface IVerifier { - function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external returns (bool); + function verify( + bytes calldata _proof, + bytes32[] calldata _publicInputs + ) external returns (bool); } type Fr is uint256; -using {add as +} for Fr global; -using {sub as -} for Fr global; -using {mul as *} for Fr global; +using { add as + } for Fr global; +using { sub as - } for Fr global; +using { mul as * } for Fr global; -using {exp as ^} for Fr global; -using {notEqual as !=} for Fr global; -using {equal as ==} for Fr global; +using { exp as ^ } for Fr global; +using { notEqual as != } for Fr global; +using { equal as == } for Fr global; uint256 constant SUBGROUP_SIZE = 256; uint256 constant MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617; // Prime field order uint256 constant P = MODULUS; -Fr constant SUBGROUP_GENERATOR = Fr.wrap(0x07b0c561a6148404f086204a9f36ffb0617942546750f230c893619174a57a76); -Fr constant SUBGROUP_GENERATOR_INVERSE = Fr.wrap(0x204bd3277422fad364751ad938e2b5e6a54cf8c68712848a692c553d0329f5d6); +Fr constant SUBGROUP_GENERATOR = Fr.wrap( + 0x07b0c561a6148404f086204a9f36ffb0617942546750f230c893619174a57a76 +); +Fr constant SUBGROUP_GENERATOR_INVERSE = Fr.wrap( + 0x204bd3277422fad364751ad938e2b5e6a54cf8c68712848a692c553d0329f5d6 +); Fr constant MINUS_ONE = Fr.wrap(MODULUS - 1); Fr constant ONE = Fr.wrap(1); Fr constant ZERO = Fr.wrap(0); @@ -185,7 +308,7 @@ library FrLib { mstore(add(free, 0x20), 0x20) mstore(add(free, 0x40), 0x20) mstore(add(free, 0x60), v) - mstore(add(free, 0x80), sub(MODULUS, 2)) + mstore(add(free, 0x80), sub(MODULUS, 2)) mstore(add(free, 0xa0), MODULUS) let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) if iszero(success) { @@ -209,7 +332,7 @@ library FrLib { mstore(add(free, 0x20), 0x20) mstore(add(free, 0x40), 0x20) mstore(add(free, 0x60), b) - mstore(add(free, 0x80), v) + mstore(add(free, 0x80), v) mstore(add(free, 0xa0), MODULUS) let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) if iszero(success) { @@ -488,26 +611,63 @@ library ZKTranscriptLib { uint256 logN ) external pure returns (ZKTranscript memory t) { Fr previousChallenge; - (t.relationParameters, previousChallenge) = - generateRelationParametersChallenges(proof, publicInputs, vkHash, publicInputsSize, previousChallenge); + ( + t.relationParameters, + previousChallenge + ) = generateRelationParametersChallenges( + proof, + publicInputs, + vkHash, + publicInputsSize, + previousChallenge + ); - (t.alphas, previousChallenge) = generateAlphaChallenges(previousChallenge, proof); + (t.alphas, previousChallenge) = generateAlphaChallenges( + previousChallenge, + proof + ); - (t.gateChallenges, previousChallenge) = generateGateChallenges(previousChallenge, logN); - (t.libraChallenge, previousChallenge) = generateLibraChallenge(previousChallenge, proof); - (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges(proof, previousChallenge, logN); + (t.gateChallenges, previousChallenge) = generateGateChallenges( + previousChallenge, + logN + ); + (t.libraChallenge, previousChallenge) = generateLibraChallenge( + previousChallenge, + proof + ); + (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges( + proof, + previousChallenge, + logN + ); - (t.rho, previousChallenge) = generateRhoChallenge(proof, previousChallenge); + (t.rho, previousChallenge) = generateRhoChallenge( + proof, + previousChallenge + ); - (t.geminiR, previousChallenge) = generateGeminiRChallenge(proof, previousChallenge, logN); + (t.geminiR, previousChallenge) = generateGeminiRChallenge( + proof, + previousChallenge, + logN + ); - (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge(proof, previousChallenge, logN); + (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge( + proof, + previousChallenge, + logN + ); - (t.shplonkZ, previousChallenge) = generateShplonkZChallenge(proof, previousChallenge); + (t.shplonkZ, previousChallenge) = generateShplonkZChallenge( + proof, + previousChallenge + ); return t; } - function splitChallenge(Fr challenge) internal pure returns (Fr first, Fr second) { + function splitChallenge( + Fr challenge + ) internal pure returns (Fr first, Fr second) { uint256 challengeU256 = uint256(Fr.unwrap(challenge)); uint256 lo = challengeU256 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; uint256 hi = challengeU256 >> 128; @@ -521,11 +681,23 @@ library ZKTranscriptLib { uint256 vkHash, uint256 publicInputsSize, Fr previousChallenge - ) internal pure returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) { - (rp.eta, rp.etaTwo, rp.etaThree, previousChallenge) = - generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); + ) + internal + pure + returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) + { + ( + rp.eta, + rp.etaTwo, + rp.etaThree, + previousChallenge + ) = generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); - (rp.beta, rp.gamma, nextPreviousChallenge) = generateBetaAndGammaChallenges(previousChallenge, proof); + ( + rp.beta, + rp.gamma, + nextPreviousChallenge + ) = generateBetaAndGammaChallenges(previousChallenge, proof); } function generateEtaChallenge( @@ -533,7 +705,11 @@ library ZKTranscriptLib { bytes32[] calldata publicInputs, uint256 vkHash, uint256 publicInputsSize - ) internal pure returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) { + ) + internal + pure + returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) + { bytes32[] memory round0 = new bytes32[](1 + publicInputsSize + 6); round0[0] = bytes32(vkHash); @@ -541,7 +717,8 @@ library ZKTranscriptLib { round0[1 + i] = bytes32(publicInputs[i]); } for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib.toBytes32(proof.pairingPointObject[i]); + round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib + .toBytes32(proof.pairingPointObject[i]); } // Create the first challenge @@ -553,18 +730,21 @@ library ZKTranscriptLib { round0[1 + publicInputsSize + 4] = bytes32(proof.w3.x); round0[1 + publicInputsSize + 5] = bytes32(proof.w3.y); - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round0))); + previousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(round0)) + ); (eta, etaTwo) = splitChallenge(previousChallenge); - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); + previousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(Fr.unwrap(previousChallenge))) + ); - (etaThree,) = splitChallenge(previousChallenge); + (etaThree, ) = splitChallenge(previousChallenge); } - function generateBetaAndGammaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) - { + function generateBetaAndGammaChallenges( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) { bytes32[7] memory round1; round1[0] = FrLib.toBytes32(previousChallenge); round1[1] = bytes32(proof.lookupReadCounts.x); @@ -574,12 +754,17 @@ library ZKTranscriptLib { round1[5] = bytes32(proof.w4.x); round1[6] = bytes32(proof.w4.y); - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round1))); + nextPreviousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(round1)) + ); (beta, gamma) = splitChallenge(nextPreviousChallenge); } // Alpha challenges non-linearise the gate contributions - function generateAlphaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) + function generateAlphaChallenges( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr[NUMBER_OF_ALPHAS] memory alphas, Fr nextPreviousChallenge) @@ -592,9 +777,11 @@ library ZKTranscriptLib { alpha0[3] = proof.zPerm.x; alpha0[4] = proof.zPerm.y; - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(alpha0))); + nextPreviousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(alpha0)) + ); Fr alpha; - (alpha,) = splitChallenge(nextPreviousChallenge); + (alpha, ) = splitChallenge(nextPreviousChallenge); // Compute powers of alpha for batching subrelations alphas[0] = alpha; @@ -603,38 +790,54 @@ library ZKTranscriptLib { } } - function generateGateChallenges(Fr previousChallenge, uint256 logN) + function generateGateChallenges( + Fr previousChallenge, + uint256 logN + ) internal pure - returns (Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, Fr nextPreviousChallenge) + returns ( + Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, + Fr nextPreviousChallenge + ) { - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); - (gateChallenges[0],) = splitChallenge(previousChallenge); + previousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(Fr.unwrap(previousChallenge))) + ); + (gateChallenges[0], ) = splitChallenge(previousChallenge); for (uint256 i = 1; i < logN; i++) { gateChallenges[i] = gateChallenges[i - 1] * gateChallenges[i - 1]; } nextPreviousChallenge = previousChallenge; } - function generateLibraChallenge(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr libraChallenge, Fr nextPreviousChallenge) - { + function generateLibraChallenge( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr libraChallenge, Fr nextPreviousChallenge) { // 2 comm, 1 sum, 1 challenge uint256[4] memory challengeData; challengeData[0] = Fr.unwrap(previousChallenge); challengeData[1] = proof.libraCommitments[0].x; challengeData[2] = proof.libraCommitments[0].y; challengeData[3] = Fr.unwrap(proof.libraSum); - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(challengeData))); - (libraChallenge,) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(challengeData)) + ); + (libraChallenge, ) = splitChallenge(nextPreviousChallenge); } - function generateSumcheckChallenges(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) + function generateSumcheckChallenges( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure - returns (Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, Fr nextPreviousChallenge) + returns ( + Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, + Fr nextPreviousChallenge + ) { for (uint256 i = 0; i < logN; i++) { Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH + 1] memory univariateChal; @@ -643,24 +846,27 @@ library ZKTranscriptLib { for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { univariateChal[j + 1] = proof.sumcheckUnivariates[i][j]; } - prevChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(univariateChal))); + prevChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(univariateChal)) + ); - (sumcheckChallenges[i],) = splitChallenge(prevChallenge); + (sumcheckChallenges[i], ) = splitChallenge(prevChallenge); } nextPreviousChallenge = prevChallenge; } // We add Libra claimed eval + 3 comm + 1 more eval - function generateRhoChallenge(Honk.ZKProof memory proof, Fr prevChallenge) - internal - pure - returns (Fr rho, Fr nextPreviousChallenge) - { + function generateRhoChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge + ) internal pure returns (Fr rho, Fr nextPreviousChallenge) { uint256[NUMBER_OF_ENTITIES + 9] memory rhoChallengeElements; rhoChallengeElements[0] = Fr.unwrap(prevChallenge); uint256 i; for (i = 1; i <= NUMBER_OF_ENTITIES; i++) { - rhoChallengeElements[i] = Fr.unwrap(proof.sumcheckEvaluations[i - 1]); + rhoChallengeElements[i] = Fr.unwrap( + proof.sumcheckEvaluations[i - 1] + ); } rhoChallengeElements[i] = Fr.unwrap(proof.libraEvaluation); @@ -677,15 +883,17 @@ library ZKTranscriptLib { i += 2; rhoChallengeElements[i] = Fr.unwrap(proof.geminiMaskingEval); - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(rhoChallengeElements))); - (rho,) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(rhoChallengeElements)) + ); + (rho, ) = splitChallenge(nextPreviousChallenge); } - function generateGeminiRChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr geminiR, Fr nextPreviousChallenge) - { + function generateGeminiRChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr geminiR, Fr nextPreviousChallenge) { uint256[] memory gR = new uint256[]((logN - 1) * 2 + 1); gR[0] = Fr.unwrap(prevChallenge); @@ -694,54 +902,70 @@ library ZKTranscriptLib { gR[2 + i * 2] = proof.geminiFoldComms[i].y; } - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(gR))); + nextPreviousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(gR)) + ); - (geminiR,) = splitChallenge(nextPreviousChallenge); + (geminiR, ) = splitChallenge(nextPreviousChallenge); } - function generateShplonkNuChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr shplonkNu, Fr nextPreviousChallenge) - { - uint256[] memory shplonkNuChallengeElements = new uint256[](logN + 1 + 4); + function generateShplonkNuChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr shplonkNu, Fr nextPreviousChallenge) { + uint256[] memory shplonkNuChallengeElements = new uint256[]( + logN + 1 + 4 + ); shplonkNuChallengeElements[0] = Fr.unwrap(prevChallenge); for (uint256 i = 1; i <= logN; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap(proof.geminiAEvaluations[i - 1]); + shplonkNuChallengeElements[i] = Fr.unwrap( + proof.geminiAEvaluations[i - 1] + ); } uint256 libraIdx = 0; for (uint256 i = logN + 1; i <= logN + 4; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap(proof.libraPolyEvals[libraIdx]); + shplonkNuChallengeElements[i] = Fr.unwrap( + proof.libraPolyEvals[libraIdx] + ); libraIdx++; } - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkNuChallengeElements))); - (shplonkNu,) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(shplonkNuChallengeElements)) + ); + (shplonkNu, ) = splitChallenge(nextPreviousChallenge); } - function generateShplonkZChallenge(Honk.ZKProof memory proof, Fr prevChallenge) - internal - pure - returns (Fr shplonkZ, Fr nextPreviousChallenge) - { + function generateShplonkZChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge + ) internal pure returns (Fr shplonkZ, Fr nextPreviousChallenge) { uint256[3] memory shplonkZChallengeElements; shplonkZChallengeElements[0] = Fr.unwrap(prevChallenge); shplonkZChallengeElements[1] = proof.shplonkQ.x; shplonkZChallengeElements[2] = proof.shplonkQ.y; - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkZChallengeElements))); - (shplonkZ,) = splitChallenge(nextPreviousChallenge); + nextPreviousChallenge = FrLib.fromBytes32( + keccak256(abi.encodePacked(shplonkZChallengeElements)) + ); + (shplonkZ, ) = splitChallenge(nextPreviousChallenge); } - function loadProof(bytes calldata proof, uint256 logN) internal pure returns (Honk.ZKProof memory p) { + function loadProof( + bytes calldata proof, + uint256 logN + ) internal pure returns (Honk.ZKProof memory p) { uint256 boundary = 0x0; // Pairing point object for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - p.pairingPointObject[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + p.pairingPointObject[i] = bytesToFr( + proof[boundary:boundary + FIELD_ELEMENT_SIZE] + ); boundary += FIELD_ELEMENT_SIZE; } // Commitments @@ -753,17 +977,25 @@ library ZKTranscriptLib { boundary += GROUP_ELEMENT_SIZE; // Lookup / Permutation Helper Commitments - p.lookupReadCounts = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.lookupReadCounts = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; - p.lookupReadTags = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.lookupReadTags = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; p.w4 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.lookupInverses = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.lookupInverses = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; p.zPerm = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[0] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.libraCommitments[0] = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; p.libraSum = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); @@ -771,52 +1003,76 @@ library ZKTranscriptLib { // Sumcheck univariates for (uint256 i = 0; i < logN; i++) { for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { - p.sumcheckUnivariates[i][j] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + p.sumcheckUnivariates[i][j] = bytesToFr( + proof[boundary:boundary + FIELD_ELEMENT_SIZE] + ); boundary += FIELD_ELEMENT_SIZE; } } // Sumcheck evaluations for (uint256 i = 0; i < NUMBER_OF_ENTITIES; i++) { - p.sumcheckEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + p.sumcheckEvaluations[i] = bytesToFr( + proof[boundary:boundary + FIELD_ELEMENT_SIZE] + ); boundary += FIELD_ELEMENT_SIZE; } - p.libraEvaluation = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + p.libraEvaluation = bytesToFr( + proof[boundary:boundary + FIELD_ELEMENT_SIZE] + ); boundary += FIELD_ELEMENT_SIZE; - p.libraCommitments[1] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.libraCommitments[1] = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[2] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.libraCommitments[2] = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingPoly = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.geminiMaskingPoly = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingEval = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + p.geminiMaskingEval = bytesToFr( + proof[boundary:boundary + FIELD_ELEMENT_SIZE] + ); boundary += FIELD_ELEMENT_SIZE; // Gemini // Read gemini fold univariates for (uint256 i = 0; i < logN - 1; i++) { - p.geminiFoldComms[i] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.geminiFoldComms[i] = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; } // Read gemini a evaluations for (uint256 i = 0; i < logN; i++) { - p.geminiAEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + p.geminiAEvaluations[i] = bytesToFr( + proof[boundary:boundary + FIELD_ELEMENT_SIZE] + ); boundary += FIELD_ELEMENT_SIZE; } for (uint256 i = 0; i < 4; i++) { - p.libraPolyEvals[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + p.libraPolyEvals[i] = bytesToFr( + proof[boundary:boundary + FIELD_ELEMENT_SIZE] + ); boundary += FIELD_ELEMENT_SIZE; } // Shplonk - p.shplonkQ = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.shplonkQ = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); boundary += GROUP_ELEMENT_SIZE; // KZG - p.kzgQuotient = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + p.kzgQuotient = bytesToG1Point( + proof[boundary:boundary + GROUP_ELEMENT_SIZE] + ); } } @@ -834,15 +1090,54 @@ library RelationsLib { Fr[NUMBER_OF_SUBRELATIONS] memory evaluations; // Accumulate all relations in Ultra Honk - each with varying number of subrelations - accumulateArithmeticRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePermutationRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateLogDerivativeLookupRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateDeltaRangeRelation(purportedEvaluations, evaluations, powPartialEval); - accumulateEllipticRelation(purportedEvaluations, evaluations, powPartialEval); - accumulateMemoryRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateNnfRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePoseidonExternalRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePoseidonInternalRelation(purportedEvaluations, evaluations, powPartialEval); + accumulateArithmeticRelation( + purportedEvaluations, + evaluations, + powPartialEval + ); + accumulatePermutationRelation( + purportedEvaluations, + rp, + evaluations, + powPartialEval + ); + accumulateLogDerivativeLookupRelation( + purportedEvaluations, + rp, + evaluations, + powPartialEval + ); + accumulateDeltaRangeRelation( + purportedEvaluations, + evaluations, + powPartialEval + ); + accumulateEllipticRelation( + purportedEvaluations, + evaluations, + powPartialEval + ); + accumulateMemoryRelation( + purportedEvaluations, + rp, + evaluations, + powPartialEval + ); + accumulateNnfRelation( + purportedEvaluations, + evaluations, + powPartialEval + ); + accumulatePoseidonExternalRelation( + purportedEvaluations, + evaluations, + powPartialEval + ); + accumulatePoseidonInternalRelation( + purportedEvaluations, + evaluations, + powPartialEval + ); // batch the subrelations with the alpha challenges to obtain the full honk relation accumulator = scaleAndBatchSubrelations(evaluations, alphas); @@ -853,11 +1148,15 @@ library RelationsLib { * the relation checking code being cluttered with uint256 type casting, which is often a different colour in code * editors, and thus is noisy. */ - function wire(Fr[NUMBER_OF_ENTITIES] memory p, WIRE _wire) internal pure returns (Fr) { + function wire( + Fr[NUMBER_OF_ENTITIES] memory p, + WIRE _wire + ) internal pure returns (Fr) { return p[uint256(_wire)]; } - uint256 internal constant NEG_HALF_MODULO_P = 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; + uint256 internal constant NEG_HALF_MODULO_P = + 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; /** * Ultra Arithmetic Relation * @@ -873,9 +1172,16 @@ library RelationsLib { { Fr neg_half = Fr.wrap(NEG_HALF_MODULO_P); - Fr accum = (q_arith - Fr.wrap(3)) * (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * neg_half; - accum = accum + (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) - + (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + wire(p, WIRE.Q_C); + Fr accum = (q_arith - Fr.wrap(3)) * + (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * + neg_half; + accum = + accum + + (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) + + (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + + (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + + wire(p, WIRE.Q_C); accum = accum + (q_arith - ONE) * wire(p, WIRE.W_4_SHIFT); accum = accum * q_arith; accum = accum * domainSep; @@ -884,7 +1190,10 @@ library RelationsLib { // Relation 1 { - Fr accum = wire(p, WIRE.W_L) + wire(p, WIRE.W_4) - wire(p, WIRE.W_L_SHIFT) + wire(p, WIRE.Q_M); + Fr accum = wire(p, WIRE.W_L) + + wire(p, WIRE.W_4) - + wire(p, WIRE.W_L_SHIFT) + + wire(p, WIRE.Q_M); accum = accum * (q_arith - Fr.wrap(2)); accum = accum * (q_arith - ONE); accum = accum * q_arith; @@ -903,38 +1212,67 @@ library RelationsLib { Fr grand_product_denominator; { - Fr num = wire(p, WIRE.W_L) + wire(p, WIRE.ID_1) * rp.beta + rp.gamma; - num = num * (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); - num = num * (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); - num = num * (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); + Fr num = wire(p, WIRE.W_L) + + wire(p, WIRE.ID_1) * + rp.beta + + rp.gamma; + num = + num * + (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); + num = + num * + (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); + num = + num * + (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); grand_product_numerator = num; } { - Fr den = wire(p, WIRE.W_L) + wire(p, WIRE.SIGMA_1) * rp.beta + rp.gamma; - den = den * (wire(p, WIRE.W_R) + wire(p, WIRE.SIGMA_2) * rp.beta + rp.gamma); - den = den * (wire(p, WIRE.W_O) + wire(p, WIRE.SIGMA_3) * rp.beta + rp.gamma); - den = den * (wire(p, WIRE.W_4) + wire(p, WIRE.SIGMA_4) * rp.beta + rp.gamma); + Fr den = wire(p, WIRE.W_L) + + wire(p, WIRE.SIGMA_1) * + rp.beta + + rp.gamma; + den = + den * + (wire(p, WIRE.W_R) + + wire(p, WIRE.SIGMA_2) * + rp.beta + + rp.gamma); + den = + den * + (wire(p, WIRE.W_O) + + wire(p, WIRE.SIGMA_3) * + rp.beta + + rp.gamma); + den = + den * + (wire(p, WIRE.W_4) + + wire(p, WIRE.SIGMA_4) * + rp.beta + + rp.gamma); grand_product_denominator = den; } // Contribution 2 { - Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * grand_product_numerator; - - acc = acc - - ( - (wire(p, WIRE.Z_PERM_SHIFT) + (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) - * grand_product_denominator - ); + Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * + grand_product_numerator; + + acc = + acc - + ((wire(p, WIRE.Z_PERM_SHIFT) + + (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) * + grand_product_denominator); acc = acc * domainSep; evals[2] = acc; } // Contribution 3 { - Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; + Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * + wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; evals[3] = acc; } } @@ -950,32 +1288,52 @@ library RelationsLib { // Calculate the write term (the table accumulation) { - write_term = wire(p, WIRE.TABLE_1) + rp.gamma + (wire(p, WIRE.TABLE_2) * rp.eta) - + (wire(p, WIRE.TABLE_3) * rp.etaTwo) + (wire(p, WIRE.TABLE_4) * rp.etaThree); + write_term = + wire(p, WIRE.TABLE_1) + + rp.gamma + + (wire(p, WIRE.TABLE_2) * rp.eta) + + (wire(p, WIRE.TABLE_3) * rp.etaTwo) + + (wire(p, WIRE.TABLE_4) * rp.etaThree); } // Calculate the write term { - Fr derived_entry_1 = wire(p, WIRE.W_L) + rp.gamma + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); - Fr derived_entry_2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_M) * wire(p, WIRE.W_R_SHIFT); - Fr derived_entry_3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_C) * wire(p, WIRE.W_O_SHIFT); - - read_term = derived_entry_1 + (derived_entry_2 * rp.eta) + (derived_entry_3 * rp.etaTwo) - + (wire(p, WIRE.Q_O) * rp.etaThree); + Fr derived_entry_1 = wire(p, WIRE.W_L) + + rp.gamma + + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); + Fr derived_entry_2 = wire(p, WIRE.W_R) + + wire(p, WIRE.Q_M) * + wire(p, WIRE.W_R_SHIFT); + Fr derived_entry_3 = wire(p, WIRE.W_O) + + wire(p, WIRE.Q_C) * + wire(p, WIRE.W_O_SHIFT); + + read_term = + derived_entry_1 + + (derived_entry_2 * rp.eta) + + (derived_entry_3 * rp.etaTwo) + + (wire(p, WIRE.Q_O) * rp.etaThree); } Fr read_inverse = wire(p, WIRE.LOOKUP_INVERSES) * write_term; Fr write_inverse = wire(p, WIRE.LOOKUP_INVERSES) * read_term; - Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + wire(p, WIRE.Q_LOOKUP) - - (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); + Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + + wire(p, WIRE.Q_LOOKUP) - + (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); // Inverse calculated correctly relation - Fr accumulatorNone = read_term * write_term * wire(p, WIRE.LOOKUP_INVERSES) - inverse_exists_xor; + Fr accumulatorNone = read_term * + write_term * + wire(p, WIRE.LOOKUP_INVERSES) - + inverse_exists_xor; accumulatorNone = accumulatorNone * domainSep; // Inverse - Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * read_inverse - wire(p, WIRE.LOOKUP_READ_COUNTS) * write_inverse; + Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * + read_inverse - + wire(p, WIRE.LOOKUP_READ_COUNTS) * + write_inverse; Fr read_tag = wire(p, WIRE.LOOKUP_READ_TAGS); @@ -1089,7 +1447,11 @@ library RelationsLib { x_add_identity = x_add_identity * x_diff * x_diff; x_add_identity = x_add_identity - y2_sqr - y1_sqr + y1y2 + y1y2; - evals[11] = x_add_identity * partialEval * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); + evals[11] = + x_add_identity * + partialEval * + wire(p, WIRE.Q_ELLIPTIC) * + (ONE - q_is_double); } // Contribution 11 point addition, x-coordinate check @@ -1097,8 +1459,15 @@ library RelationsLib { { Fr y1_plus_y3 = ep.y_1 + ep.y_3; Fr y_diff = ep.y_2 * q_sign - ep.y_1; - Fr y_add_identity = y1_plus_y3 * x_diff + (ep.x_3 - ep.x_1) * y_diff; - evals[12] = y_add_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); + Fr y_add_identity = y1_plus_y3 * + x_diff + + (ep.x_3 - ep.x_1) * + y_diff; + evals[12] = + y_add_identity * + domainSep * + wire(p, WIRE.Q_ELLIPTIC) * + (ONE - q_is_double); } // Contribution 10 point doubling, x-coordinate check @@ -1111,9 +1480,15 @@ library RelationsLib { Fr x1_pow_4_mul_9 = x_pow_4 * Fr.wrap(9); // NOTE: pushed into memory (stack >:'( ) - ep.x_double_identity = (ep.x_3 + ep.x_1 + ep.x_1) * y1_sqr_mul_4 - x1_pow_4_mul_9; - - Fr acc = ep.x_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; + ep.x_double_identity = + (ep.x_3 + ep.x_1 + ep.x_1) * + y1_sqr_mul_4 - + x1_pow_4_mul_9; + + Fr acc = ep.x_double_identity * + domainSep * + wire(p, WIRE.Q_ELLIPTIC) * + q_is_double; evals[11] = evals[11] + acc; } @@ -1121,8 +1496,16 @@ library RelationsLib { // (y1 + y1) (2y1) - (3 * x1 * x1)(x1 - x3) = 0 { Fr x1_sqr_mul_3 = (ep.x_1 + ep.x_1 + ep.x_1) * ep.x_1; - Fr y_double_identity = x1_sqr_mul_3 * (ep.x_1 - ep.x_3) - (ep.y_1 + ep.y_1) * (ep.y_1 + ep.y_3); - evals[12] = evals[12] + y_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; + Fr y_double_identity = x1_sqr_mul_3 * + (ep.x_1 - ep.x_3) - + (ep.y_1 + ep.y_1) * + (ep.y_1 + ep.y_3); + evals[12] = + evals[12] + + y_double_identity * + domainSep * + wire(p, WIRE.Q_ELLIPTIC) * + q_is_double; } } @@ -1196,8 +1579,12 @@ library RelationsLib { * For ROM gates, qc = 0 */ ap.memory_record_check = wire(p, WIRE.W_O) * rp.etaThree; - ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_R) * rp.etaTwo); - ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_L) * rp.eta); + ap.memory_record_check = + ap.memory_record_check + + (wire(p, WIRE.W_R) * rp.etaTwo); + ap.memory_record_check = + ap.memory_record_check + + (wire(p, WIRE.W_L) * rp.eta); ap.memory_record_check = ap.memory_record_check + wire(p, WIRE.Q_C); ap.partial_record_check = ap.memory_record_check; // used in RAM consistency check; deg 1 or 4 ap.memory_record_check = ap.memory_record_check - wire(p, WIRE.W_4); @@ -1221,16 +1608,26 @@ library RelationsLib { ap.index_delta = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_L); ap.record_delta = wire(p, WIRE.W_4_SHIFT) - wire(p, WIRE.W_4); - ap.index_is_monotonically_increasing = ap.index_delta * (ap.index_delta - Fr.wrap(1)); // deg 2 + ap.index_is_monotonically_increasing = + ap.index_delta * + (ap.index_delta - Fr.wrap(1)); // deg 2 - ap.adjacent_values_match_if_adjacent_indices_match = (ap.index_delta * MINUS_ONE + ONE) * ap.record_delta; // deg 2 + ap.adjacent_values_match_if_adjacent_indices_match = + (ap.index_delta * MINUS_ONE + ONE) * + ap.record_delta; // deg 2 - evals[14] = ap.adjacent_values_match_if_adjacent_indices_match * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) - * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - evals[15] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) - * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + evals[14] = + ap.adjacent_values_match_if_adjacent_indices_match * + (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + evals[15] = + ap.index_is_monotonically_increasing * + (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - ap.ROM_consistency_check_identity = ap.memory_record_check * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 + ap.ROM_consistency_check_identity = + ap.memory_record_check * + (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 /** * Contributions 15,16,17 @@ -1257,13 +1654,22 @@ library RelationsLib { // reverse order we could re-use `ap.partial_record_check` 1 - ((w3' * eta + w2') * eta + w1') * eta // deg 1 or 4 ap.next_gate_access_type = wire(p, WIRE.W_O_SHIFT) * rp.etaThree; - ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); - ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_L_SHIFT) * rp.eta); - ap.next_gate_access_type = wire(p, WIRE.W_4_SHIFT) - ap.next_gate_access_type; + ap.next_gate_access_type = + ap.next_gate_access_type + + (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); + ap.next_gate_access_type = + ap.next_gate_access_type + + (wire(p, WIRE.W_L_SHIFT) * rp.eta); + ap.next_gate_access_type = + wire(p, WIRE.W_4_SHIFT) - + ap.next_gate_access_type; Fr value_delta = wire(p, WIRE.W_O_SHIFT) - wire(p, WIRE.W_O); - ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = - (ap.index_delta * MINUS_ONE + ONE) * value_delta * (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 + ap + .adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = + (ap.index_delta * MINUS_ONE + ONE) * + value_delta * + (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the // next gate would make the identity fail). We need to validate that its 'access type' bool is correct. Can't @@ -1271,15 +1677,28 @@ library RelationsLib { // type is correct, to cover this edge case // deg 2 or 4 ap.next_gate_access_type_is_boolean = - ap.next_gate_access_type * ap.next_gate_access_type - ap.next_gate_access_type; + ap.next_gate_access_type * + ap.next_gate_access_type - + ap.next_gate_access_type; // Putting it all together... - evals[16] = ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation - * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 - evals[17] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 - evals[18] = ap.next_gate_access_type_is_boolean * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 - - ap.RAM_consistency_check_identity = ap.access_check * (wire(p, WIRE.Q_O)); // deg 3 or 9 + evals[16] = + ap + .adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation * + (wire(p, WIRE.Q_O)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 + evals[17] = + ap.index_is_monotonically_increasing * + (wire(p, WIRE.Q_O)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 + evals[18] = + ap.next_gate_access_type_is_boolean * + (wire(p, WIRE.Q_O)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 + + ap.RAM_consistency_check_identity = + ap.access_check * + (wire(p, WIRE.Q_O)); // deg 3 or 9 /** * RAM Timestamp Consistency Check @@ -1293,7 +1712,10 @@ library RelationsLib { * Else timestamp_check = 0 */ ap.timestamp_delta = wire(p, WIRE.W_R_SHIFT) - wire(p, WIRE.W_R); - ap.RAM_timestamp_check_identity = (ap.index_delta * MINUS_ONE + ONE) * ap.timestamp_delta - wire(p, WIRE.W_O); // deg 3 + ap.RAM_timestamp_check_identity = + (ap.index_delta * MINUS_ONE + ONE) * + ap.timestamp_delta - + wire(p, WIRE.W_O); // deg 3 /** * Complete Contribution 12 @@ -1302,12 +1724,21 @@ library RelationsLib { */ ap.memory_identity = ap.ROM_consistency_check_identity; // deg 3 or 6 ap.memory_identity = - ap.memory_identity + ap.RAM_timestamp_check_identity * (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 - ap.memory_identity = ap.memory_identity + ap.memory_record_check * (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 - ap.memory_identity = ap.memory_identity + ap.RAM_consistency_check_identity; // deg 3 or 9 + ap.memory_identity + + ap.RAM_timestamp_check_identity * + (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 + ap.memory_identity = + ap.memory_identity + + ap.memory_record_check * + (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 + ap.memory_identity = + ap.memory_identity + + ap.RAM_consistency_check_identity; // deg 3 or 9 // (deg 3 or 9) + (deg 4) + (deg 3) - ap.memory_identity = ap.memory_identity * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 + ap.memory_identity = + ap.memory_identity * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 evals[13] = ap.memory_identity; } @@ -1346,28 +1777,56 @@ library RelationsLib { * * */ - ap.limb_subproduct = wire(p, WIRE.W_L) * wire(p, WIRE.W_R_SHIFT) + wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R); - ap.non_native_field_gate_2 = - (wire(p, WIRE.W_L) * wire(p, WIRE.W_4) + wire(p, WIRE.W_R) * wire(p, WIRE.W_O) - wire(p, WIRE.W_O_SHIFT)); + ap.limb_subproduct = + wire(p, WIRE.W_L) * + wire(p, WIRE.W_R_SHIFT) + + wire(p, WIRE.W_L_SHIFT) * + wire(p, WIRE.W_R); + ap.non_native_field_gate_2 = (wire(p, WIRE.W_L) * + wire(p, WIRE.W_4) + + wire(p, WIRE.W_R) * + wire(p, WIRE.W_O) - + wire(p, WIRE.W_O_SHIFT)); ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * LIMB_SIZE; - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 - wire(p, WIRE.W_4_SHIFT); - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 + ap.limb_subproduct; - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * wire(p, WIRE.Q_4); + ap.non_native_field_gate_2 = + ap.non_native_field_gate_2 - + wire(p, WIRE.W_4_SHIFT); + ap.non_native_field_gate_2 = + ap.non_native_field_gate_2 + + ap.limb_subproduct; + ap.non_native_field_gate_2 = + ap.non_native_field_gate_2 * + wire(p, WIRE.Q_4); ap.limb_subproduct = ap.limb_subproduct * LIMB_SIZE; - ap.limb_subproduct = ap.limb_subproduct + (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); + ap.limb_subproduct = + ap.limb_subproduct + + (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); ap.non_native_field_gate_1 = ap.limb_subproduct; - ap.non_native_field_gate_1 = ap.non_native_field_gate_1 - (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); - ap.non_native_field_gate_1 = ap.non_native_field_gate_1 * wire(p, WIRE.Q_O); + ap.non_native_field_gate_1 = + ap.non_native_field_gate_1 - + (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); + ap.non_native_field_gate_1 = + ap.non_native_field_gate_1 * + wire(p, WIRE.Q_O); ap.non_native_field_gate_3 = ap.limb_subproduct; - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 + wire(p, WIRE.W_4); - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 - (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 * wire(p, WIRE.Q_M); - - Fr non_native_field_identity = - ap.non_native_field_gate_1 + ap.non_native_field_gate_2 + ap.non_native_field_gate_3; - non_native_field_identity = non_native_field_identity * wire(p, WIRE.Q_R); + ap.non_native_field_gate_3 = + ap.non_native_field_gate_3 + + wire(p, WIRE.W_4); + ap.non_native_field_gate_3 = + ap.non_native_field_gate_3 - + (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); + ap.non_native_field_gate_3 = + ap.non_native_field_gate_3 * + wire(p, WIRE.Q_M); + + Fr non_native_field_identity = ap.non_native_field_gate_1 + + ap.non_native_field_gate_2 + + ap.non_native_field_gate_3; + non_native_field_identity = + non_native_field_identity * + wire(p, WIRE.Q_R); // ((((w2' * 2^14 + w1') * 2^14 + w3) * 2^14 + w2) * 2^14 + w1 - w4) * qm // deg 2 @@ -1395,8 +1854,11 @@ library RelationsLib { ap.limb_accumulator_2 = ap.limb_accumulator_2 - wire(p, WIRE.W_4_SHIFT); ap.limb_accumulator_2 = ap.limb_accumulator_2 * wire(p, WIRE.Q_M); - Fr limb_accumulator_identity = ap.limb_accumulator_1 + ap.limb_accumulator_2; - limb_accumulator_identity = limb_accumulator_identity * wire(p, WIRE.Q_O); // deg 3 + Fr limb_accumulator_identity = ap.limb_accumulator_1 + + ap.limb_accumulator_2; + limb_accumulator_identity = + limb_accumulator_identity * + wire(p, WIRE.Q_O); // deg 3 ap.nnf_identity = non_native_field_identity + limb_accumulator_identity; ap.nnf_identity = ap.nnf_identity * (wire(p, WIRE.Q_NNF) * domainSep); @@ -1456,13 +1918,25 @@ library RelationsLib { ep.v3 = ep.t2 + ep.v4; // u_1 + 3u_2 + 5u_3 + 7u_4 ep.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_EXTERNAL) * domainSep; - evals[20] = evals[20] + ep.q_pos_by_scaling * (ep.v1 - wire(p, WIRE.W_L_SHIFT)); + evals[20] = + evals[20] + + ep.q_pos_by_scaling * + (ep.v1 - wire(p, WIRE.W_L_SHIFT)); - evals[21] = evals[21] + ep.q_pos_by_scaling * (ep.v2 - wire(p, WIRE.W_R_SHIFT)); + evals[21] = + evals[21] + + ep.q_pos_by_scaling * + (ep.v2 - wire(p, WIRE.W_R_SHIFT)); - evals[22] = evals[22] + ep.q_pos_by_scaling * (ep.v3 - wire(p, WIRE.W_O_SHIFT)); + evals[22] = + evals[22] + + ep.q_pos_by_scaling * + (ep.v3 - wire(p, WIRE.W_O_SHIFT)); - evals[23] = evals[23] + ep.q_pos_by_scaling * (ep.v4 - wire(p, WIRE.W_4_SHIFT)); + evals[23] = + evals[23] + + ep.q_pos_by_scaling * + (ep.v4 - wire(p, WIRE.W_4_SHIFT)); } struct PoseidonInternalParams { @@ -1487,10 +1961,18 @@ library RelationsLib { PoseidonInternalParams memory ip; Fr[4] memory INTERNAL_MATRIX_DIAGONAL = [ - FrLib.from(0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7), - FrLib.from(0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b), - FrLib.from(0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15), - FrLib.from(0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b) + FrLib.from( + 0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7 + ), + FrLib.from( + 0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b + ), + FrLib.from( + 0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15 + ), + FrLib.from( + 0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b + ) ]; // add round constants @@ -1508,16 +1990,28 @@ library RelationsLib { ip.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_INTERNAL) * domainSep; ip.v1 = ip.u1 * INTERNAL_MATRIX_DIAGONAL[0] + ip.u_sum; - evals[24] = evals[24] + ip.q_pos_by_scaling * (ip.v1 - wire(p, WIRE.W_L_SHIFT)); + evals[24] = + evals[24] + + ip.q_pos_by_scaling * + (ip.v1 - wire(p, WIRE.W_L_SHIFT)); ip.v2 = ip.u2 * INTERNAL_MATRIX_DIAGONAL[1] + ip.u_sum; - evals[25] = evals[25] + ip.q_pos_by_scaling * (ip.v2 - wire(p, WIRE.W_R_SHIFT)); + evals[25] = + evals[25] + + ip.q_pos_by_scaling * + (ip.v2 - wire(p, WIRE.W_R_SHIFT)); ip.v3 = ip.u3 * INTERNAL_MATRIX_DIAGONAL[2] + ip.u_sum; - evals[26] = evals[26] + ip.q_pos_by_scaling * (ip.v3 - wire(p, WIRE.W_O_SHIFT)); + evals[26] = + evals[26] + + ip.q_pos_by_scaling * + (ip.v3 - wire(p, WIRE.W_O_SHIFT)); ip.v4 = ip.u4 * INTERNAL_MATRIX_DIAGONAL[3] + ip.u_sum; - evals[27] = evals[27] + ip.q_pos_by_scaling * (ip.v4 - wire(p, WIRE.W_4_SHIFT)); + evals[27] = + evals[27] + + ip.q_pos_by_scaling * + (ip.v4 - wire(p, WIRE.W_4_SHIFT)); } function scaleAndBatchSubrelations( @@ -1527,7 +2021,10 @@ library RelationsLib { accumulator = evaluations[0]; for (uint256 i = 1; i < NUMBER_OF_SUBRELATIONS; ++i) { - accumulator = accumulator + evaluations[i] * subrelationChallenges[i - 1]; + accumulator = + accumulator + + evaluations[i] * + subrelationChallenges[i - 1]; } } } @@ -1563,7 +2060,10 @@ library CommitmentSchemeLib { Fr[] foldPosEvaluations; } - function computeSquares(Fr r, uint256 logN) internal pure returns (Fr[] memory) { + function computeSquares( + Fr r, + uint256 logN + ) internal pure returns (Fr[] memory) { Fr[] memory squares = new Fr[](logN); squares[0] = r; for (uint256 i = 1; i < logN; ++i) { @@ -1585,12 +2085,15 @@ library CommitmentSchemeLib { Fr challengePower = geminiEvalChallengePowers[i - 1]; Fr u = sumcheckUChallenges[i - 1]; - Fr batchedEvalRoundAcc = ( - (challengePower * batchedEvalAccumulator * Fr.wrap(2)) - - geminiEvaluations[i - 1] * (challengePower * (ONE - u) - u) - ); + Fr batchedEvalRoundAcc = ((challengePower * + batchedEvalAccumulator * + Fr.wrap(2)) - + geminiEvaluations[i - 1] * + (challengePower * (ONE - u) - u)); // Divide by the denominator - batchedEvalRoundAcc = batchedEvalRoundAcc * (challengePower * (ONE - u) + u).invert(); + batchedEvalRoundAcc = + batchedEvalRoundAcc * + (challengePower * (ONE - u) + u).invert(); batchedEvalAccumulator = batchedEvalRoundAcc; foldPosEvaluations[i - 1] = batchedEvalRoundAcc; @@ -1621,14 +2124,18 @@ function bytesToFr(bytes calldata proofSection) pure returns (Fr scalar) { } // EC Point utilities -function bytesToG1Point(bytes calldata proofSection) pure returns (Honk.G1Point memory point) { +function bytesToG1Point( + bytes calldata proofSection +) pure returns (Honk.G1Point memory point) { point = Honk.G1Point({ x: uint256(bytes32(proofSection[0x00:0x20])) % Q, y: uint256(bytes32(proofSection[0x20:0x40])) % Q }); } -function negateInplace(Honk.G1Point memory point) pure returns (Honk.G1Point memory) { +function negateInplace( + Honk.G1Point memory point +) pure returns (Honk.G1Point memory) { point.y = (Q - point.y) % Q; return point; } @@ -1645,10 +2152,9 @@ function negateInplace(Honk.G1Point memory point) pure returns (Honk.G1Point mem * @return lhs * @return rhs */ -function convertPairingPointsToG1(Fr[PAIRING_POINTS_SIZE] memory pairingPoints) - pure - returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) -{ +function convertPairingPointsToG1( + Fr[PAIRING_POINTS_SIZE] memory pairingPoints +) pure returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) { uint256 lhsX = Fr.unwrap(pairingPoints[0]); lhsX |= Fr.unwrap(pairingPoints[1]) << 68; lhsX |= Fr.unwrap(pairingPoints[2]) << 136; @@ -1692,7 +2198,10 @@ function generateRecursionSeparator( // hash the accum X // hash the accum Y - (Honk.G1Point memory proofLhs, Honk.G1Point memory proofRhs) = convertPairingPointsToG1(proofPairingPoints); + ( + Honk.G1Point memory proofLhs, + Honk.G1Point memory proofRhs + ) = convertPairingPointsToG1(proofPairingPoints); uint256[8] memory recursionSeparatorElements; @@ -1708,7 +2217,9 @@ function generateRecursionSeparator( recursionSeparatorElements[6] = accRhs.x; recursionSeparatorElements[7] = accRhs.y; - recursionSeparator = FrLib.fromBytes32(keccak256(abi.encodePacked(recursionSeparatorElements))); + recursionSeparator = FrLib.fromBytes32( + keccak256(abi.encodePacked(recursionSeparatorElements)) + ); } /** @@ -1720,10 +2231,11 @@ function generateRecursionSeparator( * @param recursionSeperator The separator to use for the multiplication. * @return `(recursionSeperator * basePoint) + other`. */ -function mulWithSeperator(Honk.G1Point memory basePoint, Honk.G1Point memory other, Fr recursionSeperator) - view - returns (Honk.G1Point memory) -{ +function mulWithSeperator( + Honk.G1Point memory basePoint, + Honk.G1Point memory other, + Fr recursionSeperator +) view returns (Honk.G1Point memory) { Honk.G1Point memory result; result = ecMul(recursionSeperator, basePoint); @@ -1740,7 +2252,10 @@ function mulWithSeperator(Honk.G1Point memory basePoint, Honk.G1Point memory oth * @param point The point to multiply. * @return result The result of the multiplication. */ -function ecMul(Fr value, Honk.G1Point memory point) view returns (Honk.G1Point memory) { +function ecMul( + Fr value, + Honk.G1Point memory point +) view returns (Honk.G1Point memory) { Honk.G1Point memory result; assembly { @@ -1786,7 +2301,10 @@ function ecMul(Fr value, Honk.G1Point memory point) view returns (Honk.G1Point m * @param rhs The right hand side of the addition. * @return result The result of the addition. */ -function ecAdd(Honk.G1Point memory lhs, Honk.G1Point memory rhs) view returns (Honk.G1Point memory) { +function ecAdd( + Honk.G1Point memory lhs, + Honk.G1Point memory rhs +) view returns (Honk.G1Point memory) { Honk.G1Point memory result; assembly { @@ -1810,7 +2328,9 @@ function ecAdd(Honk.G1Point memory lhs, Honk.G1Point memory rhs) view returns (H // Call the ecAdd precompile, it takes in the following // [lhs.x, lhs.y, rhs.x, rhs.y], and returns their addition back into the free memory location. let success := staticcall(gas(), 0x06, free, 0x80, free, 0x40) - if iszero(success) { revert(0, 0) } + if iszero(success) { + revert(0, 0) + } // Copy the result of the addition back into the result memory location. // Memory layout: @@ -1839,22 +2359,41 @@ function validateOnCurve(Honk.G1Point memory point) pure { require(success, "point is not on the curve"); } -function pairing(Honk.G1Point memory rhs, Honk.G1Point memory lhs) view returns (bool decodedResult) { +function pairing( + Honk.G1Point memory rhs, + Honk.G1Point memory lhs +) view returns (bool decodedResult) { bytes memory input = abi.encodePacked( rhs.x, rhs.y, // Fixed G2 point - uint256(0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2), - uint256(0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed), - uint256(0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b), - uint256(0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa), + uint256( + 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2 + ), + uint256( + 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed + ), + uint256( + 0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b + ), + uint256( + 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa + ), lhs.x, lhs.y, // G2 point from VK - uint256(0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1), - uint256(0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0), - uint256(0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4), - uint256(0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55) + uint256( + 0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1 + ), + uint256( + 0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0 + ), + uint256( + 0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4 + ), + uint256( + 0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55 + ) ); (bool success, bytes memory result) = address(0x08).staticcall(input); @@ -1863,9 +2402,6 @@ function pairing(Honk.G1Point memory rhs, Honk.G1Point memory lhs) view returns // Field arithmetic libraries - prevent littering the code with modmul / addmul - - - abstract contract BaseZKHonkVerifier is IVerifier { using FrLib for Fr; @@ -1874,7 +2410,12 @@ abstract contract BaseZKHonkVerifier is IVerifier { uint256 immutable $VK_HASH; uint256 immutable $NUM_PUBLIC_INPUTS; - constructor(uint256 _N, uint256 _logN, uint256 _vkHash, uint256 _numPublicInputs) { + constructor( + uint256 _N, + uint256 _logN, + uint256 _vkHash, + uint256 _numPublicInputs + ) { $N = _N; $LOG_N = _logN; $VK_HASH = _vkHash; @@ -1883,7 +2424,11 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Errors error ProofLengthWrong(); - error ProofLengthWrongWithLogN(uint256 logN, uint256 actualLength, uint256 expectedLength); + error ProofLengthWrongWithLogN( + uint256 logN, + uint256 actualLength, + uint256 expectedLength + ); error PublicInputsLengthWrong(); error SumcheckFailed(); error ShpleminiFailed(); @@ -1903,7 +2448,10 @@ abstract contract BaseZKHonkVerifier is IVerifier { proofLength += NUM_ELEMENTS_COMM * 4; // Libra concat, grand sum, quotient comms + Gemini masking // Sumcheck - proofLength += logN * ZK_BATCHED_RELATION_PARTIAL_LENGTH * NUM_ELEMENTS_FR; // sumcheck univariates + proofLength += + logN * + ZK_BATCHED_RELATION_PARTIAL_LENGTH * + NUM_ELEMENTS_FR; // sumcheck univariates proofLength += NUMBER_OF_ENTITIES * NUM_ELEMENTS_FR; // sumcheck evaluations // Libra and Gemini @@ -1923,20 +2471,26 @@ abstract contract BaseZKHonkVerifier is IVerifier { uint256 constant SHIFTED_COMMITMENTS_START = 30; - function loadVerificationKey() internal pure virtual returns (Honk.VerificationKey memory); + function loadVerificationKey() + internal + pure + virtual + returns (Honk.VerificationKey memory); - function verify(bytes calldata proof, bytes32[] calldata publicInputs) - public - view - override - returns (bool verified) - { + function verify( + bytes calldata proof, + bytes32[] calldata publicInputs + ) public view override returns (bool verified) { // Calculate expected proof size based on $LOG_N uint256 expectedProofSize = calculateProofSize($LOG_N); // Check the received proof is the expected size where each field element is 32 bytes if (proof.length != expectedProofSize * 32) { - revert ProofLengthWrongWithLogN($LOG_N, proof.length, expectedProofSize * 32); + revert ProofLengthWrongWithLogN( + $LOG_N, + proof.length, + expectedProofSize * 32 + ); } Honk.VerificationKey memory vk = loadVerificationKey(); @@ -1947,15 +2501,20 @@ abstract contract BaseZKHonkVerifier is IVerifier { } // Generate the fiat shamir challenges for the whole protocol - ZKTranscript memory t = - ZKTranscriptLib.generateTranscript(p, publicInputs, $VK_HASH, $NUM_PUBLIC_INPUTS, $LOG_N); + ZKTranscript memory t = ZKTranscriptLib.generateTranscript( + p, + publicInputs, + $VK_HASH, + $NUM_PUBLIC_INPUTS, + $LOG_N + ); // Derive public input delta t.relationParameters.publicInputsDelta = computePublicInputDelta( publicInputs, p.pairingPointObject, t.relationParameters.beta, - t.relationParameters.gamma, /*pubInputsOffset=*/ + t.relationParameters.gamma /*pubInputsOffset=*/, 1 ); @@ -1979,11 +2538,16 @@ abstract contract BaseZKHonkVerifier is IVerifier { Fr numerator = Fr.wrap(1); Fr denominator = Fr.wrap(1); - Fr numeratorAcc = gamma + (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); + Fr numeratorAcc = gamma + + (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); Fr denominatorAcc = gamma - (beta * FrLib.from(offset + 1)); { - for (uint256 i = 0; i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; i++) { + for ( + uint256 i = 0; + i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; + i++ + ) { Fr pubInput = FrLib.fromBytes32(publicInputs[i]); numerator = numerator * (numeratorAcc + pubInput); @@ -2008,27 +2572,40 @@ abstract contract BaseZKHonkVerifier is IVerifier { publicInputDelta = FrLib.div(numerator, denominator); } - function verifySumcheck(Honk.ZKProof memory proof, ZKTranscript memory tp) internal view returns (bool verified) { + function verifySumcheck( + Honk.ZKProof memory proof, + ZKTranscript memory tp + ) internal view returns (bool verified) { Fr roundTargetSum = tp.libraChallenge * proof.libraSum; // default 0 Fr powPartialEvaluation = Fr.wrap(1); // We perform sumcheck reductions over log n rounds ( the multivariate degree ) for (uint256 round; round < $LOG_N; ++round) { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariate = proof.sumcheckUnivariates[round]; + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] + memory roundUnivariate = proof.sumcheckUnivariates[round]; Fr totalSum = roundUnivariate[0] + roundUnivariate[1]; if (totalSum != roundTargetSum) revert SumcheckFailed(); Fr roundChallenge = tp.sumCheckUChallenges[round]; // Update the round target for the next rounf - roundTargetSum = computeNextTargetSum(roundUnivariate, roundChallenge); + roundTargetSum = computeNextTargetSum( + roundUnivariate, + roundChallenge + ); powPartialEvaluation = - powPartialEvaluation * (Fr.wrap(1) + roundChallenge * (tp.gateChallenges[round] - Fr.wrap(1))); + powPartialEvaluation * + (Fr.wrap(1) + + roundChallenge * + (tp.gateChallenges[round] - Fr.wrap(1))); } // Last round Fr grandHonkRelationSum = RelationsLib.accumulateRelationEvaluations( - proof.sumcheckEvaluations, tp.relationParameters, tp.alphas, powPartialEvaluation + proof.sumcheckEvaluations, + tp.relationParameters, + tp.alphas, + powPartialEvaluation ); Fr evaluation = Fr.wrap(1); @@ -2037,27 +2614,48 @@ abstract contract BaseZKHonkVerifier is IVerifier { } grandHonkRelationSum = - grandHonkRelationSum * (Fr.wrap(1) - evaluation) + proof.libraEvaluation * tp.libraChallenge; + grandHonkRelationSum * + (Fr.wrap(1) - evaluation) + + proof.libraEvaluation * + tp.libraChallenge; verified = (grandHonkRelationSum == roundTargetSum); } // Return the new target sum for the next sumcheck round - function computeNextTargetSum(Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, Fr roundChallenge) - internal - view - returns (Fr targetSum) - { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), - Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000000240), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), - Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80) - ]; + function computeNextTargetSum( + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, + Fr roundChallenge + ) internal view returns (Fr targetSum) { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] + memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ + Fr.wrap( + 0x0000000000000000000000000000000000000000000000000000000000009d80 + ), + Fr.wrap( + 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51 + ), + Fr.wrap( + 0x00000000000000000000000000000000000000000000000000000000000005a0 + ), + Fr.wrap( + 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31 + ), + Fr.wrap( + 0x0000000000000000000000000000000000000000000000000000000000000240 + ), + Fr.wrap( + 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31 + ), + Fr.wrap( + 0x00000000000000000000000000000000000000000000000000000000000005a0 + ), + Fr.wrap( + 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51 + ), + Fr.wrap( + 0x0000000000000000000000000000000000000000000000000000000000009d80 + ) + ]; // To compute the next target sum, we evaluate the given univariate at a point u (challenge). @@ -2070,11 +2668,17 @@ abstract contract BaseZKHonkVerifier is IVerifier { Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory denominatorInverses; for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - denominatorInverses[i] = FrLib.invert(BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * (roundChallenge - Fr.wrap(i))); + denominatorInverses[i] = FrLib.invert( + BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * + (roundChallenge - Fr.wrap(i)) + ); } for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - targetSum = targetSum + roundUnivariates[i] * denominatorInverses[i]; + targetSum = + targetSum + + roundUnivariates[i] * + denominatorInverses[i]; } // Scale the sum by the value of B(x) @@ -2090,56 +2694,67 @@ abstract contract BaseZKHonkVerifier is IVerifier { Honk.G1Point P_1; } - function verifyShplemini(Honk.ZKProof memory proof, Honk.VerificationKey memory vk, ZKTranscript memory tp) - internal - view - returns (bool verified) - { + function verifyShplemini( + Honk.ZKProof memory proof, + Honk.VerificationKey memory vk, + ZKTranscript memory tp + ) internal view returns (bool verified) { CommitmentSchemeLib.ShpleminiIntermediates memory mem; // stack // - Compute vector (r, r², ... , r²⁽ⁿ⁻¹⁾), where n = log_circuit_size - Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib.computeSquares(tp.geminiR, $LOG_N); + Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib + .computeSquares(tp.geminiR, $LOG_N); // Arrays hold values that will be linearly combined for the gemini and shplonk batch openings - Fr[] memory scalars = new Fr[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); - Honk.G1Point[] memory commitments = new Honk.G1Point[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); + Fr[] memory scalars = new Fr[]( + NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3 + ); + Honk.G1Point[] memory commitments = new Honk.G1Point[]( + NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3 + ); - mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[0]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[0]).invert(); + mem.posInvertedDenominator = (tp.shplonkZ - + powers_of_evaluation_challenge[0]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + + powers_of_evaluation_challenge[0]).invert(); - mem.unshiftedScalar = mem.posInvertedDenominator + (tp.shplonkNu * mem.negInvertedDenominator); + mem.unshiftedScalar = + mem.posInvertedDenominator + + (tp.shplonkNu * mem.negInvertedDenominator); mem.shiftedScalar = - tp.geminiR.invert() * (mem.posInvertedDenominator - (tp.shplonkNu * mem.negInvertedDenominator)); + tp.geminiR.invert() * + (mem.posInvertedDenominator - + (tp.shplonkNu * mem.negInvertedDenominator)); scalars[0] = Fr.wrap(1); commitments[0] = proof.shplonkQ; /* Batch multivariate opening claims, shifted and unshifted - * The vector of scalars is populated as follows: - * \f[ - * \left( - * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) - * \right) - * \f] - * - * The following vector is concatenated to the vector of commitments: - * \f[ - * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} - * \f] - * - * Simultaneously, the evaluation of the multilinear polynomial - * \f[ - * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} - * \f] - * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. - * - * This approach minimizes the number of iterations over the commitments to multilinear polynomials - * and eliminates the need to store the powers of \f$ \rho \f$. - */ + * The vector of scalars is populated as follows: + * \f[ + * \left( + * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) + * \right) + * \f] + * + * The following vector is concatenated to the vector of commitments: + * \f[ + * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} + * \f] + * + * Simultaneously, the evaluation of the multilinear polynomial + * \f[ + * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} + * \f] + * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. + * + * This approach minimizes the number of iterations over the commitments to multilinear polynomials + * and eliminates the need to store the powers of \f$ \rho \f$. + */ mem.batchedEvaluation = proof.geminiMaskingEval; mem.batchingChallenge = tp.rho; mem.unshiftedScalarNeg = mem.unshiftedScalar.neg(); @@ -2148,7 +2763,9 @@ abstract contract BaseZKHonkVerifier is IVerifier { scalars[1] = mem.unshiftedScalarNeg; for (uint256 i = 0; i < NUMBER_UNSHIFTED; ++i) { scalars[i + 2] = mem.unshiftedScalarNeg * mem.batchingChallenge; - mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[i] * mem.batchingChallenge); + mem.batchedEvaluation = + mem.batchedEvaluation + + (proof.sumcheckEvaluations[i] * mem.batchingChallenge); mem.batchingChallenge = mem.batchingChallenge * tp.rho; } // g commitments are accumulated at r @@ -2161,9 +2778,13 @@ abstract contract BaseZKHonkVerifier is IVerifier { uint256 scalarOff = i + SHIFTED_COMMITMENTS_START; uint256 evaluationOff = i + NUMBER_UNSHIFTED; - scalars[scalarOff] = scalars[scalarOff] + (mem.shiftedScalarNeg * mem.batchingChallenge); + scalars[scalarOff] = + scalars[scalarOff] + + (mem.shiftedScalarNeg * mem.batchingChallenge); mem.batchedEvaluation = - mem.batchedEvaluation + (proof.sumcheckEvaluations[evaluationOff] * mem.batchingChallenge); + mem.batchedEvaluation + + (proof.sumcheckEvaluations[evaluationOff] * + mem.batchingChallenge); mem.batchingChallenge = mem.batchingChallenge * tp.rho; } @@ -2216,15 +2837,15 @@ abstract contract BaseZKHonkVerifier is IVerifier { * \f[ * \left( \text{com}(A_1), \text{com}(A_2), \ldots, \text{com}(A_{n-1}) \right) * \f] - * to the 'commitments' vector. - * - * 2. Computes the scalars: - * \f[ - * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} - * \f] - * and places them into the 'scalars' vector. - * - * 3. Accumulates the summands of the constant term: + * to the 'commitments' vector. + * + * 2. Computes the scalars: + * \f[ + * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} + * \f] + * and places them into the 'scalars' vector. + * + * 3. Accumulates the summands of the constant term: * \f[ * \sum_{i=2}^{n-1} \frac{\nu^{i} \cdot A_i(-r^{2^i})}{z + r^{2^i}} * \f] @@ -2233,17 +2854,23 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Add contributions from A₀(r) and A₀(-r) to constant_term_accumulator: // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., $LOG_N - 1 - Fr[] memory foldPosEvaluations = CommitmentSchemeLib.computeFoldPosEvaluations( - tp.sumCheckUChallenges, - mem.batchedEvaluation, - proof.geminiAEvaluations, - powers_of_evaluation_challenge, - $LOG_N - ); + Fr[] memory foldPosEvaluations = CommitmentSchemeLib + .computeFoldPosEvaluations( + tp.sumCheckUChallenges, + mem.batchedEvaluation, + proof.geminiAEvaluations, + powers_of_evaluation_challenge, + $LOG_N + ); - mem.constantTermAccumulator = foldPosEvaluations[0] * mem.posInvertedDenominator; mem.constantTermAccumulator = - mem.constantTermAccumulator + (proof.geminiAEvaluations[0] * tp.shplonkNu * mem.negInvertedDenominator); + foldPosEvaluations[0] * + mem.posInvertedDenominator; + mem.constantTermAccumulator = + mem.constantTermAccumulator + + (proof.geminiAEvaluations[0] * + tp.shplonkNu * + mem.negInvertedDenominator); mem.batchingChallenge = tp.shplonkNu.sqr(); uint256 boundary = NUMBER_UNSHIFTED + 2; @@ -2255,22 +2882,40 @@ abstract contract BaseZKHonkVerifier is IVerifier { if (!dummy_round) { // Update inverted denominators - mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[i + 1]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[i + 1]).invert(); + mem.posInvertedDenominator = (tp.shplonkZ - + powers_of_evaluation_challenge[i + 1]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + + powers_of_evaluation_challenge[i + 1]).invert(); // Compute the scalar multipliers for Aₗ(± r^{2ˡ}) and [Aₗ] - mem.scalingFactorPos = mem.batchingChallenge * mem.posInvertedDenominator; - mem.scalingFactorNeg = mem.batchingChallenge * tp.shplonkNu * mem.negInvertedDenominator; - scalars[boundary + i] = mem.scalingFactorNeg.neg() + mem.scalingFactorPos.neg(); + mem.scalingFactorPos = + mem.batchingChallenge * + mem.posInvertedDenominator; + mem.scalingFactorNeg = + mem.batchingChallenge * + tp.shplonkNu * + mem.negInvertedDenominator; + scalars[boundary + i] = + mem.scalingFactorNeg.neg() + + mem.scalingFactorPos.neg(); // Accumulate the const term contribution given by // v^{2l} * Aₗ(r^{2ˡ}) /(z-r^{2^l}) + v^{2l+1} * Aₗ(-r^{2ˡ}) /(z+ r^{2^l}) - Fr accumContribution = mem.scalingFactorNeg * proof.geminiAEvaluations[i + 1]; - accumContribution = accumContribution + mem.scalingFactorPos * foldPosEvaluations[i + 1]; - mem.constantTermAccumulator = mem.constantTermAccumulator + accumContribution; + Fr accumContribution = mem.scalingFactorNeg * + proof.geminiAEvaluations[i + 1]; + accumContribution = + accumContribution + + mem.scalingFactorPos * + foldPosEvaluations[i + 1]; + mem.constantTermAccumulator = + mem.constantTermAccumulator + + accumContribution; } // Update the running power of v - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; + mem.batchingChallenge = + mem.batchingChallenge * + tp.shplonkNu * + tp.shplonkNu; commitments[boundary + i] = proof.geminiFoldComms[i]; } @@ -2279,16 +2924,24 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Finalize the batch opening claim mem.denominators[0] = Fr.wrap(1).div(tp.shplonkZ - tp.geminiR); - mem.denominators[1] = Fr.wrap(1).div(tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR); + mem.denominators[1] = Fr.wrap(1).div( + tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR + ); mem.denominators[2] = mem.denominators[0]; mem.denominators[3] = mem.denominators[0]; - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; + mem.batchingChallenge = + mem.batchingChallenge * + tp.shplonkNu * + tp.shplonkNu; for (uint256 i = 0; i < LIBRA_EVALUATIONS; i++) { Fr scalingFactor = mem.denominators[i] * mem.batchingChallenge; mem.batchingScalars[i] = scalingFactor.neg(); mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu; - mem.constantTermAccumulator = mem.constantTermAccumulator + scalingFactor * proof.libraPolyEvals[i]; + mem.constantTermAccumulator = + mem.constantTermAccumulator + + scalingFactor * + proof.libraPolyEvals[i]; } scalars[boundary] = mem.batchingScalars[0]; scalars[boundary + 1] = mem.batchingScalars[1] + mem.batchingScalars[2]; @@ -2298,10 +2951,17 @@ abstract contract BaseZKHonkVerifier is IVerifier { commitments[boundary++] = proof.libraCommitments[i]; } - commitments[boundary] = Honk.G1Point({x: 1, y: 2}); + commitments[boundary] = Honk.G1Point({ x: 1, y: 2 }); scalars[boundary++] = mem.constantTermAccumulator; - if (!checkEvalsConsistency(proof.libraPolyEvals, tp.geminiR, tp.sumCheckUChallenges, proof.libraEvaluation)) { + if ( + !checkEvalsConsistency( + proof.libraPolyEvals, + tp.geminiR, + tp.sumCheckUChallenges, + proof.libraEvaluation + ) + ) { revert ConsistencyCheckFailed(); } @@ -2315,9 +2975,15 @@ abstract contract BaseZKHonkVerifier is IVerifier { pair.P_1 = negateInplace(quotient_commitment); // Aggregate pairing points - Fr recursionSeparator = generateRecursionSeparator(proof.pairingPointObject, pair.P_0, pair.P_1); - (Honk.G1Point memory P_0_other, Honk.G1Point memory P_1_other) = - convertPairingPointsToG1(proof.pairingPointObject); + Fr recursionSeparator = generateRecursionSeparator( + proof.pairingPointObject, + pair.P_0, + pair.P_1 + ); + ( + Honk.G1Point memory P_0_other, + Honk.G1Point memory P_1_other + ) = convertPairingPointsToG1(proof.pairingPointObject); // Validate the points from the proof are on the curve validateOnCurve(P_0_other); @@ -2357,8 +3023,14 @@ abstract contract BaseZKHonkVerifier is IVerifier { for (uint256 round = 0; round < $LOG_N; round++) { uint256 currIdx = 1 + LIBRA_UNIVARIATES_LENGTH * round; mem.challengePolyLagrange[currIdx] = one; - for (uint256 idx = currIdx + 1; idx < currIdx + LIBRA_UNIVARIATES_LENGTH; idx++) { - mem.challengePolyLagrange[idx] = mem.challengePolyLagrange[idx - 1] * uChallenges[round]; + for ( + uint256 idx = currIdx + 1; + idx < currIdx + LIBRA_UNIVARIATES_LENGTH; + idx++ + ) { + mem.challengePolyLagrange[idx] = + mem.challengePolyLagrange[idx - 1] * + uChallenges[round]; } } @@ -2367,7 +3039,10 @@ abstract contract BaseZKHonkVerifier is IVerifier { for (uint256 idx = 0; idx < SUBGROUP_SIZE; idx++) { mem.denominators[idx] = mem.rootPower * geminiR - one; mem.denominators[idx] = mem.denominators[idx].invert(); - mem.challengePolyEval = mem.challengePolyEval + mem.challengePolyLagrange[idx] * mem.denominators[idx]; + mem.challengePolyEval = + mem.challengePolyEval + + mem.challengePolyLagrange[idx] * + mem.denominators[idx]; mem.rootPower = mem.rootPower * SUBGROUP_GENERATOR_INVERSE; } @@ -2378,20 +3053,28 @@ abstract contract BaseZKHonkVerifier is IVerifier { mem.diff = mem.lagrangeFirst * libraPolyEvals[2]; - mem.diff = mem.diff - + (geminiR - SUBGROUP_GENERATOR_INVERSE) - * (libraPolyEvals[1] - libraPolyEvals[2] - libraPolyEvals[0] * mem.challengePolyEval); - mem.diff = mem.diff + mem.lagrangeLast * (libraPolyEvals[2] - libraEval) - vanishingPolyEval * libraPolyEvals[3]; + mem.diff = + mem.diff + + (geminiR - SUBGROUP_GENERATOR_INVERSE) * + (libraPolyEvals[1] - + libraPolyEvals[2] - + libraPolyEvals[0] * + mem.challengePolyEval); + mem.diff = + mem.diff + + mem.lagrangeLast * + (libraPolyEvals[2] - libraEval) - + vanishingPolyEval * + libraPolyEvals[3]; check = mem.diff == Fr.wrap(0); } // This implementation is the same as above with different constants - function batchMul(Honk.G1Point[] memory base, Fr[] memory scalars) - internal - view - returns (Honk.G1Point memory result) - { + function batchMul( + Honk.G1Point[] memory base, + Fr[] memory scalars + ) internal view returns (Honk.G1Point memory result) { uint256 limit = NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3; // Validate all points are on the curve @@ -2404,7 +3087,9 @@ abstract contract BaseZKHonkVerifier is IVerifier { let free := mload(0x40) let count := 0x01 - for {} lt(count, add(limit, 1)) { count := add(count, 1) } { + for {} lt(count, add(limit, 1)) { + count := add(count, 1) + } { // Get loop offsets let base_base := add(base, mul(count, 0x20)) let scalar_base := add(scalars, mul(count, 0x20)) @@ -2414,9 +3099,22 @@ abstract contract BaseZKHonkVerifier is IVerifier { // Add scalar mstore(add(free, 0x80), mload(scalar_base)) - success := and(success, staticcall(gas(), 7, add(free, 0x40), 0x60, add(free, 0x40), 0x40)) + success := and( + success, + staticcall( + gas(), + 7, + add(free, 0x40), + 0x60, + add(free, 0x40), + 0x40 + ) + ) // accumulator = accumulator + accumulator_2 - success := and(success, staticcall(gas(), 6, free, 0x80, free, 0x40)) + success := and( + success, + staticcall(gas(), 6, free, 0x80, free, 0x40) + ) } // Return the result @@ -2428,8 +3126,15 @@ abstract contract BaseZKHonkVerifier is IVerifier { } } -contract DkgPkVerifier is BaseZKHonkVerifier(N, LOG_N, VK_HASH, NUMBER_OF_PUBLIC_INPUTS) { - function loadVerificationKey() internal pure override returns (Honk.VerificationKey memory) { - return HonkVerificationKey.loadVerificationKey(); +contract DkgPkVerifier is + BaseZKHonkVerifier(N, LOG_N, VK_HASH, NUMBER_OF_PUBLIC_INPUTS) +{ + function loadVerificationKey() + internal + pure + override + returns (Honk.VerificationKey memory) + { + return HonkVerificationKey.loadVerificationKey(); } } diff --git a/scripts/build-circuits.ts b/scripts/build-circuits.ts index d81f825957..53f65d76a5 100644 --- a/scripts/build-circuits.ts +++ b/scripts/build-circuits.ts @@ -81,8 +81,11 @@ class NoirCircuitBuilder { return result } - if (this.options.clean && existsSync(this.options.outputDir!)) { - rmSync(this.options.outputDir!, { recursive: true }) + if (this.options.clean) { + if (existsSync(this.options.outputDir!)) { + rmSync(this.options.outputDir!, { recursive: true }) + } + this.cleanTargetDirs(circuits) } mkdirSync(this.options.outputDir!, { recursive: true }) @@ -120,6 +123,33 @@ class NoirCircuitBuilder { } } + private cleanTargetDirs(circuits: CircuitInfo[]): void { + const cleaned = new Set() + for (const circuit of circuits) { + // Clean group-level target (e.g. circuits/bin/dkg/target) + const groupTarget = join(this.circuitsDir, circuit.group, 'target') + if (!cleaned.has(groupTarget) && existsSync(groupTarget)) { + rmSync(groupTarget, { recursive: true }) + cleaned.add(groupTarget) + } + // Clean circuit-level target (e.g. circuits/bin/dkg/pk/target) + const circuitTarget = join(circuit.path, 'target') + if (!cleaned.has(circuitTarget) && existsSync(circuitTarget)) { + rmSync(circuitTarget, { recursive: true }) + cleaned.add(circuitTarget) + } + } + // Clean root-level target (circuits/bin/target) + const rootTarget = join(this.circuitsDir, 'target') + if (existsSync(rootTarget)) { + rmSync(rootTarget, { recursive: true }) + cleaned.add(rootTarget) + } + if (cleaned.size > 0) { + console.log(` 🧹 Cleaned ${cleaned.size} stale target dir(s)`) + } + } + private discoverCircuits(): CircuitInfo[] { const circuits: CircuitInfo[] = [] if (!existsSync(this.circuitsDir)) return circuits diff --git a/scripts/generate-verifiers.ts b/scripts/generate-verifiers.ts index a9ac95e07f..3b4588578a 100644 --- a/scripts/generate-verifiers.ts +++ b/scripts/generate-verifiers.ts @@ -97,6 +97,9 @@ class VerifierGenerator { return } + // Clean stale nargo build caches to prevent using outdated artifacts + this.cleanTargetDirs(circuits) + // Prepare output directory if (this.options.clean && existsSync(this.verifierDir)) { rmSync(this.verifierDir, { recursive: true }) @@ -305,6 +308,34 @@ class VerifierGenerator { return `${pascal(group)}${pascal(name)}Verifier` } + /** + * Remove all nargo target directories to prevent stale cached artifacts + * from being picked up instead of freshly compiled ones. + */ + private cleanTargetDirs(circuits: CircuitInfo[]): void { + const cleaned = new Set() + for (const circuit of circuits) { + const groupTarget = join(this.circuitsDir, circuit.group, 'target') + if (!cleaned.has(groupTarget) && existsSync(groupTarget)) { + rmSync(groupTarget, { recursive: true }) + cleaned.add(groupTarget) + } + const circuitTarget = join(circuit.path, 'target') + if (!cleaned.has(circuitTarget) && existsSync(circuitTarget)) { + rmSync(circuitTarget, { recursive: true }) + cleaned.add(circuitTarget) + } + } + const rootTarget = join(this.circuitsDir, 'target') + if (existsSync(rootTarget)) { + rmSync(rootTarget, { recursive: true }) + cleaned.add(rootTarget) + } + if (cleaned.size > 0) { + console.log(` 🧹 Cleaned ${cleaned.size} stale target dir(s)`) + } + } + private checkTool(cmd: string, name: string): void { try { execSync(cmd, { stdio: ['pipe', 'pipe', 'pipe'] }) From 0f270d1f8964e3c221102694ff72168976d38622 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Tue, 17 Feb 2026 23:25:26 +0500 Subject: [PATCH 13/32] fix: add bb to CI --- .github/workflows/ci.yml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 571a05fc30..bbbe268d1a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,6 +22,7 @@ env: NODE_VERSION: 22 RUST_TOOLCHAIN: 1.86.0 NOIR_TOOLCHAIN: v1.0.0-beta.15 + BB_VERSION: 3.0.0-nightly.20251104 HARDHAT_VAR_MNEMONIC: 'test test test test test test test test test test test junk' HARDHAT_VAR_INFURA_API_KEY: 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz' PRIVATE_KEY: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80' @@ -575,6 +576,15 @@ jobs: with: toolchain: ${{ env.NOIR_TOOLCHAIN }} + - name: Install Barretenberg (bb) + run: | + curl -fsSL "https://github.com/AztecProtocol/aztec-packages/releases/download/v${{ env.BB_VERSION }}/barretenberg-amd64-linux.tar.gz" -o bb.tar.gz + mkdir -p bb_extract && tar -xzf bb.tar.gz -C bb_extract + BB_BIN=$(find bb_extract -name bb -type f | head -n 1) + sudo mv "$BB_BIN" /usr/local/bin/bb + chmod +x /usr/local/bin/bb + bb --version + - name: Check formatting run: ./scripts/lint-circuits.sh From 26af8e9c95deca5abd6d42bf89d948e65cd5c2ae Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Tue, 17 Feb 2026 23:49:21 +0500 Subject: [PATCH 14/32] fix: add bb to CI --- .github/workflows/ci.yml | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index bbbe268d1a..80e291da88 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -631,10 +631,14 @@ jobs: with: toolchain: ${{ env.RUST_TOOLCHAIN }} - - name: Install Nargo - uses: noir-lang/noirup@v0.1.4 - with: - toolchain: ${{ env.NOIR_TOOLCHAIN }} + - name: Install Barretenberg (bb) + run: | + curl -fsSL "https://github.com/AztecProtocol/aztec-packages/releases/download/v${{ env.BB_VERSION }}/barretenberg-amd64-linux.tar.gz" -o bb.tar.gz + mkdir -p bb_extract && tar -xzf bb.tar.gz -C bb_extract + BB_BIN=$(find bb_extract -name bb -type f | head -n 1) + sudo mv "$BB_BIN" /usr/local/bin/bb + chmod +x /usr/local/bin/bb + bb --version - name: Download compiled circuit artifacts uses: actions/download-artifact@v4 From 63d5248e0b86df078066050d51890e0edea491a6 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Wed, 18 Feb 2026 10:03:15 +0500 Subject: [PATCH 15/32] fix: use ZkProver for onchain test --- .../tests/onchain_verification_tests.rs | 55 ++----------------- 1 file changed, 6 insertions(+), 49 deletions(-) diff --git a/crates/zk-prover/tests/onchain_verification_tests.rs b/crates/zk-prover/tests/onchain_verification_tests.rs index 503d924bf9..a50225a34c 100644 --- a/crates/zk-prover/tests/onchain_verification_tests.rs +++ b/crates/zk-prover/tests/onchain_verification_tests.rs @@ -22,7 +22,6 @@ use e3_fhe_params::BfvPreset; use e3_zk_helpers::circuits::dkg::pk::circuit::{PkCircuit, PkCircuitData}; use e3_zk_prover::{Provable, ZkProver}; use std::path::PathBuf; -use tokio::{fs, process::Command}; sol! { #[sol(rpc)] @@ -100,53 +99,10 @@ async fn test_pk_bfv_onchain_verification() { "local proof verification failed: {local_ok:?}" ); - // Re-prove with `--oracle_hash keccak` for on-chain verification. - // The default ultra_honk proof uses Poseidon2 (for recursive verification in Noir), - // but the Solidity verifier expects a keccak-based Fiat-Shamir transcript. - // We reuse the witness file already written by prove() above. - - let circuit_dir = backend.circuits_dir.join("dkg").join("pk"); - let circuit_path = circuit_dir.join("pk.json"); - let vk_path = circuit_dir.join("pk.vk"); - let job_dir = backend.work_dir.join(e3_id); - let witness_path = job_dir.join("witness.gz"); - let onchain_out = job_dir.join("onchain_out"); - fs::create_dir_all(&onchain_out).await.unwrap(); - - let keccak_output = Command::new(&backend.bb_binary) - .args([ - "prove", - "--scheme", - "ultra_honk", - "--oracle_hash", - "keccak", - "-b", - &circuit_path.to_string_lossy(), - "-w", - &witness_path.to_string_lossy(), - "-k", - &vk_path.to_string_lossy(), - "-o", - &onchain_out.to_string_lossy(), - ]) - .output() - .await - .expect("failed to run bb prove with keccak oracle hash"); - - assert!( - keccak_output.status.success(), - "bb prove --oracle_hash keccak failed:\nstderr: {}\nstdout: {}", - String::from_utf8_lossy(&keccak_output.stderr), - String::from_utf8_lossy(&keccak_output.stdout), - ); - - let onchain_proof_data = fs::read(onchain_out.join("proof")).await.unwrap(); - let onchain_public_signals = fs::read(onchain_out.join("public_inputs")).await.unwrap(); - println!( - "keccak proof: {} bytes, public_inputs: {} bytes", - onchain_proof_data.len(), - onchain_public_signals.len() + "proof: {} bytes, public_inputs: {} bytes", + proof.data.len(), + proof.public_signals.len() ); // Deploy verifier contract to Anvil @@ -212,11 +168,12 @@ async fn test_pk_bfv_onchain_verification() { // Verify proof on-chain - let proof_bytes = Bytes::from(onchain_proof_data); + let proof_bytes = Bytes::copy_from_slice(&proof.data); // pk_bfv has 17 public inputs, 16 are pairing points baked into the proof, // so only 1 (the pk commitment) gets passed as publicInputs to the contract. - let public_inputs: Vec> = onchain_public_signals + let public_inputs: Vec> = proof + .public_signals .chunks(32) .map(|chunk| { let mut buf = [0u8; 32]; From 41ff9499de6d77ea25a9f9a4cce6867910beee76 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Thu, 19 Feb 2026 23:12:38 +0500 Subject: [PATCH 16/32] fix: resolve conflicts --- crates/keyshare/src/threshold_keyshare.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/crates/keyshare/src/threshold_keyshare.rs b/crates/keyshare/src/threshold_keyshare.rs index 02338ab92c..cc7ac634c8 100644 --- a/crates/keyshare/src/threshold_keyshare.rs +++ b/crates/keyshare/src/threshold_keyshare.rs @@ -9,13 +9,13 @@ use anyhow::{anyhow, bail, Context, Result}; use e3_crypto::{Cipher, SensitiveBytes}; use e3_data::Persistable; use e3_events::{ - prelude::*, trap, BusHandle, CiphernodeSelected, CiphertextOutputPublished, ComputeRequest, - ComputeResponse, ComputeResponseKind, CorrelationId, DecryptionshareCreated, Die, - E3RequestComplete, E3id, EType, EnclaveEvent, EnclaveEventData, EncryptionKey, - EncryptionKeyCollectionFailed, EncryptionKeyCreated, EncryptionKeyPending, EventContext, - KeyshareCreated, PartyId, PkGenerationProofRequest, PkGenerationProofSigned, Sequenced, - SignedProofPayload, ThresholdShare, ThresholdShareCollectionFailed, ThresholdShareCreated, - ThresholdSharePending, TypedEvent, + prelude::*, trap, BusHandle, CiphernodeSelected, CiphertextOutputPublished, + CommitteeMemberExpelled, ComputeRequest, ComputeResponse, ComputeResponseKind, CorrelationId, + DecryptionshareCreated, Die, E3RequestComplete, E3id, EType, EnclaveEvent, EnclaveEventData, + EncryptionKey, EncryptionKeyCollectionFailed, EncryptionKeyCreated, EncryptionKeyPending, + EventContext, KeyshareCreated, PartyId, PkGenerationProofRequest, PkGenerationProofSigned, + Sequenced, SignedProofPayload, ThresholdShare, ThresholdShareCollectionFailed, + ThresholdShareCreated, ThresholdSharePending, TypedEvent, }; use e3_fhe::create_crp; use e3_fhe_params::{BfvParamSet, BfvPreset}; From 9714ad3fbf6c155266492903d98c3b436c01764c Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Fri, 20 Feb 2026 17:03:27 +0500 Subject: [PATCH 17/32] fix: slashing verifier mismatch --- .github/workflows/ci.yml | 1 - .../events/src/enclave_event/signed_proof.rs | 84 +- .../tests/slashing_integration_tests.rs | 981 ++++++++++++++++++ .../IBondingRegistry.json | 2 +- .../ICiphernodeRegistry.json | 2 +- .../interfaces/IEnclave.sol/IEnclave.json | 2 +- .../ISlashingManager.json | 22 +- .../EnclaveTicketToken.json | 2 +- .../DkgPkVerifier.sol/DkgPkVerifier.json | 8 +- .../DkgPkVerifier.sol/ZKTranscriptLib.json | 2 +- .../contracts/E3RefundManager.sol | 21 +- .../enclave-contracts/contracts/Enclave.sol | 23 +- .../contracts/interfaces/IE3RefundManager.sol | 6 +- .../contracts/interfaces/ISlashingManager.sol | 26 +- .../contracts/slashing/SlashingManager.sol | 118 ++- .../contracts/test/MockCiphernodeRegistry.sol | 21 +- .../test/Slashing/SlashingManager.spec.ts | 335 +++++- 17 files changed, 1555 insertions(+), 101 deletions(-) create mode 100644 crates/zk-prover/tests/slashing_integration_tests.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index be925ddf37..9e25418ea2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,7 +23,6 @@ env: RUST_TOOLCHAIN: 1.86.0 NOIR_TOOLCHAIN: v1.0.0-beta.15 BB_VERSION: 3.0.0-nightly.20251104 - BB_VERSION: 3.0.0-nightly.20251104 HARDHAT_VAR_MNEMONIC: 'test test test test test test test test test test test junk' HARDHAT_VAR_INFURA_API_KEY: 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz' PRIVATE_KEY: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80' diff --git a/crates/events/src/enclave_event/signed_proof.rs b/crates/events/src/enclave_event/signed_proof.rs index 4834144cb7..e26a4ba005 100644 --- a/crates/events/src/enclave_event/signed_proof.rs +++ b/crates/events/src/enclave_event/signed_proof.rs @@ -13,7 +13,7 @@ use crate::{CircuitName, E3id, Proof}; use actix::Message; -use alloy::primitives::{keccak256, Address, Bytes, Signature, U256}; +use alloy::primitives::{keccak256, Address, FixedBytes, Signature, U256}; use alloy::signers::{local::PrivateKeySigner, SignerSync}; use alloy::sol_types::SolValue; use anyhow::{anyhow, Result}; @@ -104,11 +104,36 @@ pub struct ProofPayload { } impl ProofPayload { + /// The typehash that domain-separates the signed message. + /// + /// Must match `PROOF_PAYLOAD_TYPEHASH` in `SlashingManager.sol`: + /// `keccak256("ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)")` + pub fn typehash() -> [u8; 32] { + keccak256( + "ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)", + ) + .into() + } + /// Compute the keccak256 digest of the canonical encoding. /// - /// Uses standard ABI encoding (`abi.encode`) which includes offsets and - /// lengths for dynamic types, avoiding collision between the two - /// variable-length `Bytes` fields (`proof` and `publicSignals`). + /// Uses structured hashing with a typehash prefix for domain separation, + /// and keccak256-hashes the dynamic fields (`zkProof`, `publicSignals`) + /// for gas efficiency on the Solidity verification side. + /// + /// The encoding is: + /// ```text + /// keccak256(abi.encode( + /// PROOF_PAYLOAD_TYPEHASH, // bytes32 + /// chainId, // uint256 + /// e3Id, // uint256 + /// proofType, // uint256 + /// keccak256(zkProof), // bytes32 + /// keccak256(publicSignals) // bytes32 + /// )) + /// ``` + /// + /// This matches the reconstruction in `SlashingManager.proposeSlash()`. pub fn digest(&self) -> Result<[u8; 32]> { let e3_id_u256: U256 = self .e3_id @@ -116,13 +141,17 @@ impl ProofPayload { .try_into() .map_err(|_| anyhow!("E3id cannot be converted to U256"))?; - // keccak256(abi.encode(chainId, e3Id, proofType, proof, publicSignals)) + let typehash = Self::typehash(); + + // keccak256(abi.encode(typehash, chainId, e3Id, proofType, keccak256(proof), keccak256(publicSignals))) + // All fields are bytes32/uint256 → pure static ABI encoding (6 × 32 = 192 bytes) let encoded = ( + typehash, U256::from(self.e3_id.chain_id()), e3_id_u256, U256::from(self.proof_type as u8), - Bytes::copy_from_slice(&self.proof.data), - Bytes::copy_from_slice(&self.proof.public_signals), + keccak256(&*self.proof.data), + keccak256(&*self.proof.public_signals), ) .abi_encode(); @@ -206,6 +235,47 @@ impl Display for SignedProofFailed { } } +/// Encode a [`SignedProofFailed`] event into the ABI-encoded evidence bytes +/// expected by `SlashingManager.proposeSlash()`. +/// +/// Returns: `abi.encode(bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier)` +/// +/// The `verifier` is the current on-chain verifier contract address for this +/// proof type's slash policy. The `FaultSubmitter` actor must look this up +/// before calling this function. +pub fn encode_fault_evidence(failed: &SignedProofFailed, verifier: Address) -> Vec { + use alloy::primitives::Bytes; + + let proof = &failed.signed_payload.payload.proof; + + // Convert raw public_signals bytes → Vec> (one per 32-byte field) + let public_inputs: Vec> = proof + .public_signals + .chunks(32) + .map(|chunk| { + let mut buf = [0u8; 32]; + buf[..chunk.len()].copy_from_slice(chunk); + FixedBytes::from(buf) + }) + .collect(); + + // Must match the decode in SlashingManager.proposeSlash(): + // (bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) + // + // IMPORTANT: Use abi_encode_params() (not abi_encode()) because abi_encode() + // wraps dynamic tuples in an outer offset word, but Solidity's abi.decode() + // expects flat parameter encoding — the same as abi.encode(a, b, c, ...). + ( + Bytes::copy_from_slice(&proof.data), + public_inputs, + Bytes::copy_from_slice(&failed.signed_payload.signature), + U256::from(failed.e3_id.chain_id()), + U256::from(failed.signed_payload.payload.proof_type as u8), + verifier, + ) + .abi_encode_params() +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/zk-prover/tests/slashing_integration_tests.rs b/crates/zk-prover/tests/slashing_integration_tests.rs new file mode 100644 index 0000000000..9ba8871bb4 --- /dev/null +++ b/crates/zk-prover/tests/slashing_integration_tests.rs @@ -0,0 +1,981 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! Slashing integration tests: complete flow from proof generation → +//! operator signing → evidence encoding → on-chain SlashingManager verification. +//! +//! ## What these tests prove +//! +//! 1. **Signing format alignment**: Rust `ProofPayload.digest()` produces the +//! exact structured hash that `SlashingManager.proposeSlash()` reconstructs. +//! 2. **Evidence encoding**: `encode_fault_evidence()` output is correctly +//! decoded by the Solidity `abi.decode` in `proposeSlash()`. +//! 3. **ECDSA recovery**: Signatures created with alloy's `sign_message_sync` +//! are correctly recovered on-chain via `ECDSA.recover(toEthSignedMessageHash(...))`. +//! 4. **Complete slashing flow**: Valid proofs revert with `ProofIsValid()`, +//! wrong signers revert with `SignerIsNotOperator()`, and invalid proofs +//! result in successful slash execution. +//! +//! ## Prerequisites +//! +//! On-chain tests require: +//! - `anvil` on PATH (from Foundry) +//! - Compiled Hardhat artifacts: `cd packages/enclave-contracts && npx hardhat compile` +//! +//! Run with: `cargo test -p e3-zk-prover --test slashing_integration_tests` + +mod common; + +use alloy::{ + network::TransactionBuilder, + primitives::{keccak256, Address, Bytes, FixedBytes, U256}, + providers::{Provider, ProviderBuilder}, + rpc::types::TransactionRequest, + signers::local::PrivateKeySigner, + sol, + sol_types::SolValue, +}; +use common::find_anvil; +use e3_events::{ + encode_fault_evidence, CircuitName, E3id, Proof, ProofPayload, ProofType, SignedProofFailed, + SignedProofPayload, +}; +use e3_utils::utility_types::ArcBytes; +use std::path::PathBuf; + +// ── Contract ABI definitions (bytecodes loaded from Hardhat artifacts at runtime) ── + +sol! { + #[sol(rpc)] + contract SlashingManager { + struct SlashPolicy { + uint256 ticketPenalty; + uint256 licensePenalty; + bool requiresProof; + address proofVerifier; + bool banNode; + uint256 appealWindow; + bool enabled; + bool affectsCommittee; + uint8 failureReason; + } + + function proposeSlash(uint256 e3Id, address operator, bytes32 reason, bytes calldata proof) external returns (uint256 proposalId); + function setSlashPolicy(bytes32 reason, SlashPolicy calldata policy) external; + function totalProposals() external view returns (uint256); + function isBanned(address node) external view returns (bool); + + error ProofIsValid(); + error SignerIsNotOperator(); + error OperatorNotInCommittee(); + error VerifierMismatch(); + } + + #[sol(rpc)] + contract MockCircuitVerifier { + function setReturnValue(bool _returnValue) external; + } + + #[sol(rpc)] + contract MockCiphernodeRegistry { + function setCommitteeNodes(uint256 e3Id, address[] calldata nodes) external; + } +} + +// ── Helpers ── + +/// No-op contract deployment bytecode. +/// +/// Deploys a contract whose runtime is a single STOP opcode. +/// All calls to this contract succeed with empty return data, making it +/// suitable as a mock for any interface that only has void-returning functions +/// (e.g., IBondingRegistry.slashTicketBalance, IEnclave.onE3Failed). +const NOOP_DEPLOY_BYTECODE: &[u8] = &[ + 0x60, 0x01, // PUSH1 0x01 (runtime size) + 0x60, 0x0c, // PUSH1 0x0c (offset of runtime in init code) + 0x60, 0x00, // PUSH1 0x00 (memory destination) + 0x39, // CODECOPY + 0x60, 0x01, // PUSH1 0x01 (return size) + 0x60, 0x00, // PUSH1 0x00 (return offset) + 0xf3, // RETURN + 0x00, // -- runtime: STOP -- +]; + +fn contracts_artifacts_dir() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../packages/enclave-contracts/artifacts/contracts") +} + +fn read_artifact_bytecode(subpath: &str) -> Option> { + let path = contracts_artifacts_dir().join(subpath); + let json_str = std::fs::read_to_string(&path).ok()?; + let json: serde_json::Value = serde_json::from_str(&json_str).ok()?; + let hex_str = json["bytecode"].as_str()?; + let clean = hex_str.strip_prefix("0x").unwrap_or(hex_str); + hex::decode(clean).ok() +} + +/// Load all three contract bytecodes, returning None if any are missing. +fn load_slashing_artifacts() -> Option<(Vec, Vec, Vec)> { + let sm = read_artifact_bytecode("slashing/SlashingManager.sol/SlashingManager.json")?; + let mv = read_artifact_bytecode("test/MockSlashingVerifier.sol/MockCircuitVerifier.json")?; + let mr = read_artifact_bytecode("test/MockCiphernodeRegistry.sol/MockCiphernodeRegistry.json")?; + Some((sm, mv, mr)) +} + +/// Deploy a contract on the connected provider. +/// `creation_bytecode` is the compiled init code; `constructor_args` is appended (ABI-encoded). +async fn deploy_contract( + provider: &impl Provider, + creation_bytecode: &[u8], + constructor_args: &[u8], +) -> Address { + let mut deploy_data = creation_bytecode.to_vec(); + deploy_data.extend_from_slice(constructor_args); + let tx = TransactionRequest::default().with_deploy_code(Bytes::from(deploy_data)); + let receipt = provider + .send_transaction(tx) + .await + .expect("failed to send deploy tx") + .get_receipt() + .await + .expect("failed to get deploy receipt"); + receipt + .contract_address + .expect("deploy receipt missing contract address") +} + +/// Create a test ProofPayload with the given parameters. +fn test_proof_payload(e3_id: u64, chain_id: u64) -> ProofPayload { + ProofPayload { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + proof_type: ProofType::T0PkBfv, + proof: Proof::new( + CircuitName::PkBfv, + ArcBytes::from_bytes(&[0xde, 0xad, 0xbe, 0xef]), + // One 32-byte public input (padded zero) + ArcBytes::from_bytes(&[0u8; 32]), + ), + } +} + +// ════════════════════════════════════════════════════════════════════════════ +// Pure Rust tests — no Anvil or artifacts required +// ════════════════════════════════════════════════════════════════════════════ + +/// Verifies the typehash constant matches the keccak256 of the type string. +#[test] +fn test_proof_payload_typehash() { + let expected: [u8; 32] = keccak256( + "ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)", + ) + .into(); + assert_eq!( + ProofPayload::typehash(), + expected, + "typehash should match keccak256 of the type string" + ); +} + +/// Verifies that digest() uses the structured typehash format with hashed dynamic fields. +#[test] +fn test_proof_payload_digest_matches_manual_computation() { + let payload = test_proof_payload(1, 42); + let digest = payload.digest().expect("digest should succeed"); + + // Manually compute expected digest + let typehash = keccak256( + "ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)", + ); + let expected_encoded = ( + typehash, + U256::from(42u64), // chainId + U256::from(1u64), // e3Id + U256::from(0u8), // proofType (T0PkBfv = 0) + keccak256(&[0xde, 0xad, 0xbe, 0xef]), // keccak256(zkProof) + keccak256(&[0u8; 32]), // keccak256(publicSignals) + ) + .abi_encode(); + let expected_digest: [u8; 32] = keccak256(&expected_encoded).into(); + + assert_eq!( + digest, expected_digest, + "digest should match manual computation" + ); +} + +/// Verifies sign → recover roundtrip with the structured digest format. +#[test] +fn test_signing_roundtrip_with_structured_digest() { + let signer: PrivateKeySigner = + "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + .parse() + .unwrap(); + + let payload = test_proof_payload(42, 31337); + let signed = SignedProofPayload::sign(payload, &signer).expect("signing should succeed"); + let recovered = signed.recover_address().expect("recovery should succeed"); + + assert_eq!( + recovered, + signer.address(), + "recovered address should match signer" + ); +} + +/// Verifies that different payloads produce different digests (no collisions). +#[test] +fn test_different_payloads_different_digests() { + let p1 = test_proof_payload(1, 42); + let p2 = test_proof_payload(2, 42); // different e3Id + let mut p3 = test_proof_payload(1, 42); + p3.proof_type = ProofType::T1PkGeneration; // different proofType + + let d1 = p1.digest().unwrap(); + let d2 = p2.digest().unwrap(); + let d3 = p3.digest().unwrap(); + + assert_ne!(d1, d2, "different e3Ids should produce different digests"); + assert_ne!( + d1, d3, + "different proofTypes should produce different digests" + ); +} + +/// Verifies that encode_fault_evidence() produces correctly structured ABI encoding. +#[test] +fn test_encode_fault_evidence_structure() { + let signer: PrivateKeySigner = + "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + .parse() + .unwrap(); + let verifier_addr: Address = "0x1234567890abcdef1234567890abcdef12345678" + .parse() + .unwrap(); + + let payload = test_proof_payload(42, 31337); + let signed = SignedProofPayload::sign(payload, &signer).expect("signing should succeed"); + + let failed = SignedProofFailed { + e3_id: E3id::new("42", 31337), + faulting_node: signer.address(), + proof_type: ProofType::T0PkBfv, + signed_payload: signed.clone(), + }; + + let evidence = encode_fault_evidence(&failed, verifier_addr); + + // Decode and verify structure: (bytes, bytes32[], bytes, uint256, uint256, address) + type EvidenceTuple = (Bytes, Vec>, Bytes, U256, U256, Address); + let decoded = EvidenceTuple::abi_decode_params(&evidence).expect("evidence should ABI-decode"); + + let (zk_proof, public_inputs, sig, chain_id, proof_type, verifier) = decoded; + + assert_eq!(&zk_proof[..], &[0xde, 0xad, 0xbe, 0xef], "zkProof mismatch"); + assert_eq!(public_inputs.len(), 1, "should have 1 public input"); + assert_eq!( + public_inputs[0], + FixedBytes::from([0u8; 32]), + "public input value mismatch" + ); + assert_eq!(&sig[..], &signed.signature[..], "signature bytes mismatch"); + assert_eq!(chain_id, U256::from(31337u64), "chainId mismatch"); + assert_eq!(proof_type, U256::from(0u8), "proofType mismatch"); + assert_eq!(verifier, verifier_addr, "verifier address mismatch"); +} + +/// Verifies that the digest format matches what Solidity would compute. +/// +/// This is the critical cross-language test: if this passes, then: +/// `keccak256(abi.encode(PROOF_PAYLOAD_TYPEHASH, chainId, e3Id, proofType, keccak256(zkProof), keccak256(abi.encodePacked(publicInputs))))` +/// in Solidity produces the same bytes32 as `ProofPayload::digest()` in Rust. +#[test] +fn test_digest_matches_solidity_encoding() { + let payload = test_proof_payload(42, 31337); + let digest = payload.digest().expect("digest should succeed"); + + // Simulate what Solidity does step by step: + // + // bytes32 messageHash = keccak256(abi.encode( + // PROOF_PAYLOAD_TYPEHASH, // bytes32 + // chainId, // uint256 + // e3Id, // uint256 + // proofType, // uint256 + // keccak256(zkProof), // bytes32 + // keccak256(abi.encodePacked(publicInputs)) // bytes32 + // )); + // + // For publicInputs = [bytes32(0)]: + // abi.encodePacked(publicInputs) = 0x0000...0000 (32 bytes) + // which is the same as the raw publicSignals bytes + + let typehash = keccak256( + "ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)", + ); + + // abi.encode of all-static types: each word is 32 bytes, no offsets + let mut solidity_encoded = Vec::with_capacity(192); + solidity_encoded.extend_from_slice(typehash.as_ref()); // bytes32 + solidity_encoded.extend_from_slice(&U256::from(31337u64).to_be_bytes::<32>()); // uint256 chainId + solidity_encoded.extend_from_slice(&U256::from(42u64).to_be_bytes::<32>()); // uint256 e3Id + solidity_encoded.extend_from_slice(&U256::from(0u8).to_be_bytes::<32>()); // uint256 proofType + solidity_encoded.extend_from_slice(keccak256(&[0xde, 0xad, 0xbe, 0xef]).as_ref()); // keccak256(zkProof) + + // For publicInputs = [bytes32(0)]: + // Solidity: keccak256(abi.encodePacked(publicInputs)) = keccak256(bytes32(0)) + // Rust: keccak256(public_signals) = keccak256([0u8; 32]) + // These must be the same! + let sol_public_inputs_hash = keccak256(&[0u8; 32]); + solidity_encoded.extend_from_slice(sol_public_inputs_hash.as_ref()); // keccak256(publicSignals) + + let solidity_digest: [u8; 32] = keccak256(&solidity_encoded).into(); + + assert_eq!( + digest, solidity_digest, + "Rust digest must exactly match Solidity messageHash reconstruction" + ); +} + +// ════════════════════════════════════════════════════════════════════════════ +// On-chain integration tests — require Anvil + compiled Hardhat artifacts +// ════════════════════════════════════════════════════════════════════════════ + +/// **Complete flow**: operator signs proof → evidence encoded → SlashingManager +/// reconstructs digest, recovers signer, verifies committee membership, and +/// checks ZK proof validity. +/// +/// With MockCircuitVerifier returning TRUE (proof is valid), the contract +/// reverts with `ProofIsValid()`. This proves the full Rust→Solidity signing +/// pipeline works correctly. +#[tokio::test] +async fn test_onchain_valid_proof_reverts_proof_is_valid() { + if !find_anvil().await { + println!("skipping: anvil not found on PATH"); + return; + } + + let (sm_bytecode, mv_bytecode, mr_bytecode) = match load_slashing_artifacts() { + Some(artifacts) => artifacts, + None => { + println!( + "skipping: contract artifacts not found \ + (run `npx hardhat compile` in packages/enclave-contracts)" + ); + return; + } + }; + + let provider = ProviderBuilder::new().connect_anvil_with_wallet(); + let chain_id = provider.get_chain_id().await.unwrap(); + let accounts = provider.get_accounts().await.unwrap(); + let admin = accounts[0]; + + // Operator uses a separate key (not an Anvil pre-funded account) + let operator_signer = PrivateKeySigner::random(); + let operator_addr = operator_signer.address(); + + // Deploy infrastructure contracts + let noop_addr = deploy_contract(&provider, NOOP_DEPLOY_BYTECODE, &[]).await; + let mock_verifier_addr = deploy_contract(&provider, &mv_bytecode, &[]).await; + let mock_registry_addr = deploy_contract(&provider, &mr_bytecode, &[]).await; + + // Deploy SlashingManager(admin, bondingRegistry, ciphernodeRegistry, enclave) + let sm_args = (admin, noop_addr, mock_registry_addr, noop_addr).abi_encode(); + let sm_addr = deploy_contract(&provider, &sm_bytecode, &sm_args).await; + + println!("deployed: SlashingManager={sm_addr}, MockVerifier={mock_verifier_addr}, MockRegistry={mock_registry_addr}"); + println!("operator: {operator_addr} (chain_id: {chain_id})"); + + // Bind contract instances + let slashing_mgr = SlashingManager::new(sm_addr, &provider); + let mock_verifier = MockCircuitVerifier::new(mock_verifier_addr, &provider); + let mock_registry = MockCiphernodeRegistry::new(mock_registry_addr, &provider); + + // ── Setup: slash policy + committee ── + + let reason: FixedBytes<32> = keccak256("E3_BAD_DKG_PROOF"); + let e3_id: u64 = 42; + + slashing_mgr + .setSlashPolicy( + reason, + SlashingManager::SlashPolicy { + ticketPenalty: U256::from(50_000_000u64), + licensePenalty: U256::from(100_000_000_000_000_000_000u128), + requiresProof: true, + proofVerifier: mock_verifier_addr, + banNode: false, + appealWindow: U256::ZERO, + enabled: true, + affectsCommittee: false, + failureReason: 0u8, + }, + ) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + mock_registry + .setCommitteeNodes(U256::from(e3_id), vec![operator_addr]) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + // MockCircuitVerifier returns TRUE → proof is valid → no fault + mock_verifier + .setReturnValue(true) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + // ── Operator signs proof (Rust-side) ── + + let payload = ProofPayload { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + proof_type: ProofType::T0PkBfv, + proof: Proof::new( + CircuitName::PkBfv, + ArcBytes::from_bytes(&[0xde, 0xad, 0xbe, 0xef]), + ArcBytes::from_bytes(&[0u8; 32]), + ), + }; + + let signed = + SignedProofPayload::sign(payload, &operator_signer).expect("signing should succeed"); + + // ── FaultSubmitter encodes evidence (Rust-side) ── + + let failed = SignedProofFailed { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + faulting_node: operator_addr, + proof_type: ProofType::T0PkBfv, + signed_payload: signed, + }; + + let evidence = encode_fault_evidence(&failed, mock_verifier_addr); + + // ── Submit to SlashingManager (on-chain) ── + + let result = slashing_mgr + .proposeSlash( + U256::from(e3_id), + operator_addr, + reason, + Bytes::from(evidence), + ) + .call() + .await; + + // Should revert with ProofIsValid — the proof is valid, so there's no fault + assert!( + result.is_err(), + "should revert because the proof is valid (no fault to slash)" + ); + + let err_string = format!("{:?}", result.unwrap_err()); + assert!( + err_string.contains("ProofIsValid") || err_string.contains("0x5b718c5b"), + "expected ProofIsValid revert, got: {err_string}" + ); + + println!("PASS: valid proof correctly reverts with ProofIsValid — Rust→Solidity signing alignment verified"); +} + +/// Tests that a wrong signer (attacker) cannot slash an arbitrary operator. +/// +/// The attacker signs the proof with their own key but submits it as evidence +/// against a different operator. The contract should reject because the +/// recovered signer doesn't match the target operator. +#[tokio::test] +async fn test_onchain_wrong_signer_reverts_signer_is_not_operator() { + if !find_anvil().await { + println!("skipping: anvil not found on PATH"); + return; + } + + let (sm_bytecode, mv_bytecode, mr_bytecode) = match load_slashing_artifacts() { + Some(artifacts) => artifacts, + None => { + println!("skipping: contract artifacts not found"); + return; + } + }; + + let provider = ProviderBuilder::new().connect_anvil_with_wallet(); + let chain_id = provider.get_chain_id().await.unwrap(); + let accounts = provider.get_accounts().await.unwrap(); + let admin = accounts[0]; + + let attacker_signer = PrivateKeySigner::random(); + let victim_addr: Address = "0x1111111111111111111111111111111111111111" + .parse() + .unwrap(); + + let noop_addr = deploy_contract(&provider, NOOP_DEPLOY_BYTECODE, &[]).await; + let mock_verifier_addr = deploy_contract(&provider, &mv_bytecode, &[]).await; + let mock_registry_addr = deploy_contract(&provider, &mr_bytecode, &[]).await; + + let sm_args = (admin, noop_addr, mock_registry_addr, noop_addr).abi_encode(); + let sm_addr = deploy_contract(&provider, &sm_bytecode, &sm_args).await; + + let slashing_mgr = SlashingManager::new(sm_addr, &provider); + let mock_registry = MockCiphernodeRegistry::new(mock_registry_addr, &provider); + + let reason: FixedBytes<32> = keccak256("E3_BAD_DKG_PROOF"); + let e3_id: u64 = 42; + + slashing_mgr + .setSlashPolicy( + reason, + SlashingManager::SlashPolicy { + ticketPenalty: U256::from(50_000_000u64), + licensePenalty: U256::from(100_000_000_000_000_000_000u128), + requiresProof: true, + proofVerifier: mock_verifier_addr, + banNode: false, + appealWindow: U256::ZERO, + enabled: true, + affectsCommittee: false, + failureReason: 0u8, + }, + ) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + // Add VICTIM to committee (not the attacker) + mock_registry + .setCommitteeNodes(U256::from(e3_id), vec![victim_addr]) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + // Attacker signs the proof with their own key + let payload = ProofPayload { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + proof_type: ProofType::T0PkBfv, + proof: Proof::new( + CircuitName::PkBfv, + ArcBytes::from_bytes(&[0xde, 0xad]), + ArcBytes::from_bytes(&[0u8; 32]), + ), + }; + let signed = + SignedProofPayload::sign(payload, &attacker_signer).expect("signing should succeed"); + + let failed = SignedProofFailed { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + faulting_node: attacker_signer.address(), + proof_type: ProofType::T0PkBfv, + signed_payload: signed, + }; + + let evidence = encode_fault_evidence(&failed, mock_verifier_addr); + + // Submit evidence targeting the VICTIM, but signed by the ATTACKER + let result = slashing_mgr + .proposeSlash( + U256::from(e3_id), + victim_addr, // <-- target is victim, not the actual signer + reason, + Bytes::from(evidence), + ) + .call() + .await; + + assert!(result.is_err(), "should revert because signer != operator"); + + let err_string = format!("{:?}", result.unwrap_err()); + assert!( + err_string.contains("SignerIsNotOperator") || err_string.contains("0xcd659038"), + "expected SignerIsNotOperator revert, got: {err_string}" + ); + + println!("PASS: wrong signer correctly reverts — V-001 protection verified"); +} + +/// Tests that operators not in the committee cannot be slashed. +#[tokio::test] +async fn test_onchain_non_committee_member_reverts() { + if !find_anvil().await { + println!("skipping: anvil not found on PATH"); + return; + } + + let (sm_bytecode, mv_bytecode, mr_bytecode) = match load_slashing_artifacts() { + Some(artifacts) => artifacts, + None => { + println!("skipping: contract artifacts not found"); + return; + } + }; + + let provider = ProviderBuilder::new().connect_anvil_with_wallet(); + let chain_id = provider.get_chain_id().await.unwrap(); + let accounts = provider.get_accounts().await.unwrap(); + let admin = accounts[0]; + + let operator_signer = PrivateKeySigner::random(); + let operator_addr = operator_signer.address(); + + let noop_addr = deploy_contract(&provider, NOOP_DEPLOY_BYTECODE, &[]).await; + let mock_verifier_addr = deploy_contract(&provider, &mv_bytecode, &[]).await; + let mock_registry_addr = deploy_contract(&provider, &mr_bytecode, &[]).await; + + let sm_args = (admin, noop_addr, mock_registry_addr, noop_addr).abi_encode(); + let sm_addr = deploy_contract(&provider, &sm_bytecode, &sm_args).await; + + let slashing_mgr = SlashingManager::new(sm_addr, &provider); + + let reason: FixedBytes<32> = keccak256("E3_BAD_DKG_PROOF"); + let e3_id: u64 = 42; + + slashing_mgr + .setSlashPolicy( + reason, + SlashingManager::SlashPolicy { + ticketPenalty: U256::from(50_000_000u64), + licensePenalty: U256::from(100_000_000_000_000_000_000u128), + requiresProof: true, + proofVerifier: mock_verifier_addr, + banNode: false, + appealWindow: U256::ZERO, + enabled: true, + affectsCommittee: false, + failureReason: 0u8, + }, + ) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + // NOTE: We do NOT add the operator to the committee + + // Operator signs a proof + let payload = ProofPayload { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + proof_type: ProofType::T0PkBfv, + proof: Proof::new( + CircuitName::PkBfv, + ArcBytes::from_bytes(&[0xab, 0xcd]), + ArcBytes::from_bytes(&[0u8; 32]), + ), + }; + let signed = + SignedProofPayload::sign(payload, &operator_signer).expect("signing should succeed"); + + let failed = SignedProofFailed { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + faulting_node: operator_addr, + proof_type: ProofType::T0PkBfv, + signed_payload: signed, + }; + + let evidence = encode_fault_evidence(&failed, mock_verifier_addr); + + let result = slashing_mgr + .proposeSlash( + U256::from(e3_id), + operator_addr, + reason, + Bytes::from(evidence), + ) + .call() + .await; + + assert!( + result.is_err(), + "should revert because operator is not in committee" + ); + + let err_string = format!("{:?}", result.unwrap_err()); + assert!( + err_string.contains("OperatorNotInCommittee") || err_string.contains("0x7353fac5"), + "expected OperatorNotInCommittee revert, got: {err_string}" + ); + + println!("PASS: non-committee member correctly reverts — committee check verified"); +} + +/// Tests the complete slash execution flow: invalid proof → fault confirmed → slash executed. +/// +/// Uses a NOOP contract as BondingRegistry so that `slashTicketBalance` and +/// `slashLicenseBond` calls succeed silently, allowing the full flow to complete. +#[tokio::test] +async fn test_onchain_invalid_proof_executes_slash() { + if !find_anvil().await { + println!("skipping: anvil not found on PATH"); + return; + } + + let (sm_bytecode, mv_bytecode, mr_bytecode) = match load_slashing_artifacts() { + Some(artifacts) => artifacts, + None => { + println!("skipping: contract artifacts not found"); + return; + } + }; + + let provider = ProviderBuilder::new().connect_anvil_with_wallet(); + let chain_id = provider.get_chain_id().await.unwrap(); + let accounts = provider.get_accounts().await.unwrap(); + let admin = accounts[0]; + + let operator_signer = PrivateKeySigner::random(); + let operator_addr = operator_signer.address(); + + let noop_addr = deploy_contract(&provider, NOOP_DEPLOY_BYTECODE, &[]).await; + let mock_verifier_addr = deploy_contract(&provider, &mv_bytecode, &[]).await; + let mock_registry_addr = deploy_contract(&provider, &mr_bytecode, &[]).await; + + // Use noop as both bondingRegistry and enclave + let sm_args = (admin, noop_addr, mock_registry_addr, noop_addr).abi_encode(); + let sm_addr = deploy_contract(&provider, &sm_bytecode, &sm_args).await; + + let slashing_mgr = SlashingManager::new(sm_addr, &provider); + let mock_verifier = MockCircuitVerifier::new(mock_verifier_addr, &provider); + let mock_registry = MockCiphernodeRegistry::new(mock_registry_addr, &provider); + + let reason: FixedBytes<32> = keccak256("E3_BAD_DKG_PROOF"); + let e3_id: u64 = 42; + + slashing_mgr + .setSlashPolicy( + reason, + SlashingManager::SlashPolicy { + ticketPenalty: U256::from(50_000_000u64), + licensePenalty: U256::from(100_000_000_000_000_000_000u128), + requiresProof: true, + proofVerifier: mock_verifier_addr, + banNode: false, + appealWindow: U256::ZERO, + enabled: true, + affectsCommittee: false, + failureReason: 0u8, + }, + ) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + mock_registry + .setCommitteeNodes(U256::from(e3_id), vec![operator_addr]) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + // MockCircuitVerifier returns FALSE → proof is invalid → fault confirmed + mock_verifier + .setReturnValue(false) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + // Operator signs a (bad) proof + let payload = ProofPayload { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + proof_type: ProofType::T0PkBfv, + proof: Proof::new( + CircuitName::PkBfv, + ArcBytes::from_bytes(&[0xba, 0xd0, 0xba, 0xd0]), + ArcBytes::from_bytes(&[0u8; 32]), + ), + }; + let signed = + SignedProofPayload::sign(payload, &operator_signer).expect("signing should succeed"); + + let failed = SignedProofFailed { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + faulting_node: operator_addr, + proof_type: ProofType::T0PkBfv, + signed_payload: signed, + }; + + let evidence = encode_fault_evidence(&failed, mock_verifier_addr); + + // Verify proposal count before + let proposals_before = slashing_mgr + .totalProposals() + .call() + .await + .expect("totalProposals call failed"); + assert_eq!( + proposals_before, + U256::ZERO, + "should have 0 proposals before" + ); + + // Submit slash — should succeed (invalid proof = fault confirmed) + let receipt = slashing_mgr + .proposeSlash( + U256::from(e3_id), + operator_addr, + reason, + Bytes::from(evidence), + ) + .send() + .await + .expect("proposeSlash tx should not fail to send") + .get_receipt() + .await + .expect("proposeSlash receipt should be obtainable"); + + assert!( + receipt.status(), + "proposeSlash transaction should succeed (invalid proof = fault confirmed, slash executed)" + ); + + // Verify proposal was created and executed + let proposals_after = slashing_mgr + .totalProposals() + .call() + .await + .expect("totalProposals call failed"); + assert_eq!( + proposals_after, + U256::from(1u64), + "should have 1 proposal after slash" + ); + + println!("PASS: invalid proof correctly triggers slash execution — full flow verified"); +} + +/// Tests that verifier mismatch is detected (verifier-upgrade protection). +/// +/// If the evidence references an old verifier address but the policy has been +/// updated to a new verifier, proposeSlash should revert with VerifierMismatch. +#[tokio::test] +async fn test_onchain_verifier_mismatch_reverts() { + if !find_anvil().await { + println!("skipping: anvil not found on PATH"); + return; + } + + let (sm_bytecode, mv_bytecode, mr_bytecode) = match load_slashing_artifacts() { + Some(artifacts) => artifacts, + None => { + println!("skipping: contract artifacts not found"); + return; + } + }; + + let provider = ProviderBuilder::new().connect_anvil_with_wallet(); + let chain_id = provider.get_chain_id().await.unwrap(); + let accounts = provider.get_accounts().await.unwrap(); + let admin = accounts[0]; + + let operator_signer = PrivateKeySigner::random(); + let operator_addr = operator_signer.address(); + + let noop_addr = deploy_contract(&provider, NOOP_DEPLOY_BYTECODE, &[]).await; + let mock_verifier_addr = deploy_contract(&provider, &mv_bytecode, &[]).await; + let mock_registry_addr = deploy_contract(&provider, &mr_bytecode, &[]).await; + + let sm_args = (admin, noop_addr, mock_registry_addr, noop_addr).abi_encode(); + let sm_addr = deploy_contract(&provider, &sm_bytecode, &sm_args).await; + + let slashing_mgr = SlashingManager::new(sm_addr, &provider); + + let reason: FixedBytes<32> = keccak256("E3_BAD_DKG_PROOF"); + let e3_id: u64 = 42; + + slashing_mgr + .setSlashPolicy( + reason, + SlashingManager::SlashPolicy { + ticketPenalty: U256::from(50_000_000u64), + licensePenalty: U256::from(100_000_000_000_000_000_000u128), + requiresProof: true, + proofVerifier: mock_verifier_addr, + banNode: false, + appealWindow: U256::ZERO, + enabled: true, + affectsCommittee: false, + failureReason: 0u8, + }, + ) + .send() + .await + .unwrap() + .get_receipt() + .await + .unwrap(); + + let payload = ProofPayload { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + proof_type: ProofType::T0PkBfv, + proof: Proof::new( + CircuitName::PkBfv, + ArcBytes::from_bytes(&[0xab]), + ArcBytes::from_bytes(&[0u8; 32]), + ), + }; + let signed = + SignedProofPayload::sign(payload, &operator_signer).expect("signing should succeed"); + + let failed = SignedProofFailed { + e3_id: E3id::new(&e3_id.to_string(), chain_id), + faulting_node: operator_addr, + proof_type: ProofType::T0PkBfv, + signed_payload: signed, + }; + + // Encode evidence pointing to a DIFFERENT verifier (simulating stale evidence) + let stale_verifier: Address = "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef" + .parse() + .unwrap(); + let evidence = encode_fault_evidence(&failed, stale_verifier); + + let result = slashing_mgr + .proposeSlash( + U256::from(e3_id), + operator_addr, + reason, + Bytes::from(evidence), + ) + .call() + .await; + + assert!( + result.is_err(), + "should revert because verifier in evidence doesn't match policy" + ); + + let err_string = format!("{:?}", result.unwrap_err()); + assert!( + err_string.contains("VerifierMismatch") || err_string.contains("0x1c485278"), + "expected VerifierMismatch revert, got: {err_string}" + ); + + println!("PASS: verifier mismatch correctly reverts — verifier-upgrade protection verified"); +} diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json index a9daa05c33..4b4862b5bd 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json @@ -890,5 +890,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IBondingRegistry.sol", - "buildInfoId": "solc-0_8_28-e60a5d7c133605edcf61acdd5ba43ab44ee0928e" + "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json index 58f727060a..b085714590 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json @@ -767,5 +767,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ICiphernodeRegistry.sol", - "buildInfoId": "solc-0_8_28-e60a5d7c133605edcf61acdd5ba43ab44ee0928e" + "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json index 28c6fdb611..f0f17e304c 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json @@ -1202,5 +1202,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IEnclave.sol", - "buildInfoId": "solc-0_8_28-e60a5d7c133605edcf61acdd5ba43ab44ee0928e" + "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json index b319c58b6d..aae08da573 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json @@ -63,11 +63,26 @@ "name": "InvalidProposal", "type": "error" }, + { + "inputs": [], + "name": "OperatorNotInCommittee", + "type": "error" + }, + { + "inputs": [], + "name": "ProofIsValid", + "type": "error" + }, { "inputs": [], "name": "ProofRequired", "type": "error" }, + { + "inputs": [], + "name": "SignerIsNotOperator", + "type": "error" + }, { "inputs": [], "name": "SlashReasonDisabled", @@ -83,6 +98,11 @@ "name": "Unauthorized", "type": "error" }, + { + "inputs": [], + "name": "VerifierMismatch", + "type": "error" + }, { "inputs": [], "name": "VerifierNotSet", @@ -820,5 +840,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ISlashingManager.sol", - "buildInfoId": "solc-0_8_28-0871e0e155b06f51b6fb81507908de5a4ecc60f9" + "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json index 54cd4e3cb9..7ccba112b9 100644 --- a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json +++ b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json @@ -1210,5 +1210,5 @@ ] }, "inputSourceName": "project/contracts/token/EnclaveTicketToken.sol", - "buildInfoId": "solc-0_8_28-15112a5a277d7846347c8e3a91ba0ec7bb3521bd" + "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json index 96ca48277a..5eee2539ed 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json @@ -102,7 +102,7 @@ } }, "immutableReferences": { - "33263": [ + "33527": [ { "length": 32, "start": 91 @@ -164,13 +164,13 @@ "start": 11964 } ], - "33265": [ + "33529": [ { "length": 32, "start": 398 } ], - "33267": [ + "33531": [ { "length": 32, "start": 432 @@ -182,5 +182,5 @@ ] }, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" + "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json index 06119e9770..53b441c1c3 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json @@ -396,5 +396,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-ae0b6c33e5fca23f9554b44e15b97ffa4e4f6aed" + "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" } \ No newline at end of file diff --git a/packages/enclave-contracts/contracts/E3RefundManager.sol b/packages/enclave-contracts/contracts/E3RefundManager.sol index 5e9001b403..e1803e9ccd 100644 --- a/packages/enclave-contracts/contracts/E3RefundManager.sol +++ b/packages/enclave-contracts/contracts/E3RefundManager.sol @@ -103,10 +103,12 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { function calculateRefund( uint256 e3Id, uint256 originalPayment, - address[] calldata honestNodes + address[] calldata honestNodes, + IERC20 paymentToken ) external onlyEnclave { require(!_distributions[e3Id].calculated, "Already calculated"); require(originalPayment > 0, "No payment"); + require(address(paymentToken) != address(0), "Invalid fee token"); // Calculate work value based on stage IEnclave.E3Stage failedAt = _getFailedAtStage(e3Id); @@ -121,14 +123,15 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { honestNodeAmount - requesterAmount; - // Store distribution + // Store distribution with the actual token used for this E3 _distributions[e3Id] = RefundDistribution({ requesterAmount: requesterAmount, honestNodeAmount: honestNodeAmount, protocolAmount: protocolAmount, totalSlashed: 0, honestNodeCount: honestNodes.length, - calculated: true + calculated: true, + feeToken: paymentToken }); // Store honest nodes @@ -138,7 +141,7 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { // Transfer protocol fee to treasury immediately if (protocolAmount > 0) { - feeToken.safeTransfer(treasury, protocolAmount); + paymentToken.safeTransfer(treasury, protocolAmount); } emit RefundDistributionCalculated( @@ -239,7 +242,8 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { _claimed[e3Id][msg.sender] = true; - feeToken.safeTransfer(msg.sender, amount); + // Use the per-E3 fee token (not the global one, which may have been rotated) + dist.feeToken.safeTransfer(msg.sender, amount); emit RefundClaimed(e3Id, msg.sender, amount, "REQUESTER"); } @@ -266,15 +270,16 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { _claimed[e3Id][msg.sender] = true; - // Distribute reward through bonding registry - feeToken.approve(address(bondingRegistry), amount); + // Use the per-E3 fee token and distribute through bonding registry + IERC20 token = dist.feeToken; + token.approve(address(bondingRegistry), amount); address[] memory nodeArray = new address[](1); nodeArray[0] = msg.sender; uint256[] memory amountArray = new uint256[](1); amountArray[0] = amount; - bondingRegistry.distributeRewards(feeToken, nodeArray, amountArray); + bondingRegistry.distributeRewards(token, nodeArray, amountArray); emit RefundClaimed(e3Id, msg.sender, amount, "HONEST_NODE"); } diff --git a/packages/enclave-contracts/contracts/Enclave.sol b/packages/enclave-contracts/contracts/Enclave.sol index 4567276a6e..27d130b87f 100644 --- a/packages/enclave-contracts/contracts/Enclave.sol +++ b/packages/enclave-contracts/contracts/Enclave.sol @@ -472,25 +472,33 @@ contract Enclave is IEnclave, OwnableUpgradeable { /// @notice Distributes rewards to active committee members after successful E3 completion. /// @dev Uses active committee nodes (excluding expelled members). /// Divides the E3 payment equally among active members and transfers via bonding registry. + /// If no active members remain (e.g., all expelled), refunds the requester to prevent fund lockup. /// @param e3Id The ID of the E3 for which to distribute rewards. function _distributeRewards(uint256 e3Id) internal { address[] memory activeNodes = ciphernodeRegistry .getActiveCommitteeNodes(e3Id); uint256 activeLength = activeNodes.length; - if (activeLength == 0) return; + uint256 totalAmount = e3Payments[e3Id]; + e3Payments[e3Id] = 0; + if (totalAmount == 0) return; + + if (activeLength == 0) { + address requester = _e3Requesters[e3Id]; + if (requester != address(0)) { + feeToken.safeTransfer(requester, totalAmount); + } + return; + } uint256[] memory amounts = new uint256[](activeLength); // Distribute equally among active (non-expelled) committee members - uint256 amount = e3Payments[e3Id] / activeLength; + uint256 amount = totalAmount / activeLength; for (uint256 i = 0; i < activeLength; i++) { amounts[i] = amount; } - uint256 totalAmount = e3Payments[e3Id]; - e3Payments[e3Id] = 0; - feeToken.approve(address(bondingRegistry), totalAmount); bondingRegistry.distributeRewards(feeToken, activeNodes, amounts); @@ -662,7 +670,8 @@ contract Enclave is IEnclave, OwnableUpgradeable { } /// @notice Process a failed E3 and calculate refunds - /// @dev Can be called by anyone once E3 is in failed state + /// @dev Can be called by anyone once E3 is in failed state. + /// Passes the current feeToken so the refund manager stores the correct token per-E3. /// @param e3Id The ID of the failed E3 function processE3Failure(uint256 e3Id) external { E3Stage stage = _e3Stages[e3Id]; @@ -675,7 +684,7 @@ contract Enclave is IEnclave, OwnableUpgradeable { address[] memory honestNodes = _getHonestNodes(e3Id); feeToken.safeTransfer(address(e3RefundManager), payment); - e3RefundManager.calculateRefund(e3Id, payment, honestNodes); + e3RefundManager.calculateRefund(e3Id, payment, honestNodes, feeToken); emit E3FailureProcessed(e3Id, payment, honestNodes.length); } diff --git a/packages/enclave-contracts/contracts/interfaces/IE3RefundManager.sol b/packages/enclave-contracts/contracts/interfaces/IE3RefundManager.sol index aa2062cb47..44a079494b 100644 --- a/packages/enclave-contracts/contracts/interfaces/IE3RefundManager.sol +++ b/packages/enclave-contracts/contracts/interfaces/IE3RefundManager.sol @@ -5,6 +5,7 @@ // or FITNESS FOR A PARTICULAR PURPOSE. pragma solidity >=0.8.27; import { IEnclave } from "./IEnclave.sol"; +import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /** * @title IE3RefundManager @@ -32,6 +33,7 @@ interface IE3RefundManager { uint256 totalSlashed; // Slashed funds added uint256 honestNodeCount; // Number of honest nodes bool calculated; // Whether distribution is calculated + IERC20 feeToken; // The fee token used for this E3's payment (stored per-E3 to survive token rotations) } //////////////////////////////////////////////////////////// // // @@ -86,10 +88,12 @@ interface IE3RefundManager { /// @param e3Id The failed E3 ID /// @param originalPayment The original payment amount /// @param honestNodes Array of honest node addresses + /// @param paymentToken The fee token that was used for this E3's payment function calculateRefund( uint256 e3Id, uint256 originalPayment, - address[] calldata honestNodes + address[] calldata honestNodes, + IERC20 paymentToken ) external; /// @notice Requester claims their refund diff --git a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol index 2ba0978ab1..6646b743af 100644 --- a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol +++ b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol @@ -102,6 +102,18 @@ interface ISlashingManager { /// @notice Thrown when provided proof fails verification error InvalidProof(); + /// @notice The ZK proof verified successfully — the operator's submission was valid, not a fault + error ProofIsValid(); + + /// @notice Thrown when the recovered signer does not match the operator being slashed + error SignerIsNotOperator(); + + /// @notice Thrown when the operator is not a member of the committee for this E3 + error OperatorNotInCommittee(); + + /// @notice Thrown when the verifier address in signed evidence doesn't match the policy's current verifier + error VerifierMismatch(); + /// @notice Thrown when attempting to execute a slash whose appeal was upheld error AppealUpheld(); @@ -328,12 +340,20 @@ interface ISlashingManager { /** * @notice Creates a new slash proposal with cryptographic proof (Lane A - permissionless) - * @dev Anyone can call this for proof-based slashes. Proof is verified on-chain. - * For proof-based policies (appealWindow=0), slash is executed atomically. + * @dev Anyone can call this for proof-based slashes. Requires the operator's ECDSA signature + * over the proof payload to prevent arbitrary slashing. + * Evidence format: abi.encode(bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) + * The operator must have signed: keccak256(abi.encode(PROOF_PAYLOAD_TYPEHASH, chainId, e3Id, + * proofType, keccak256(zkProof), keccak256(abi.encodePacked(publicInputs)))) + * Verifications performed: + * 1. Verifier address in evidence matches the policy's current proofVerifier + * 2. Signature recovery confirms the operator authored the bad proof + * 3. Committee membership check confirms the operator was in the E3's committee + * 4. ZK proof re-verification confirms the proof is indeed invalid (fault) * @param e3Id ID of the E3 computation this slash relates to * @param operator Address of the ciphernode operator to slash (must be non-zero) * @param reason Hash of the slash reason (must have an enabled proof-required policy) - * @param proof Proof data to be verified by the policy's proof verifier contract + * @param proof Evidence data: abi.encode(zkProof, publicInputs, signature, chainId, proofType, verifier) * @return proposalId Sequential ID of the created proposal */ function proposeSlash( diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index 051cfab593..13e590e141 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -9,6 +9,10 @@ pragma solidity >=0.8.27; import { AccessControl } from "@openzeppelin/contracts/access/AccessControl.sol"; +import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; +import { + MessageHashUtils +} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol"; import { ISlashingManager } from "../interfaces/ISlashingManager.sol"; import { IBondingRegistry } from "../interfaces/IBondingRegistry.sol"; import { ICiphernodeRegistry } from "../interfaces/ICiphernodeRegistry.sol"; @@ -63,11 +67,16 @@ contract SlashingManager is ISlashingManager, AccessControl { mapping(bytes32 evidenceKey => bool consumed) public evidenceConsumed; // ====================== - // Errors (contract-level) + // Constants // ====================== - /// @notice The ZK proof verified successfully — the operator's submission was valid, not a fault - error ProofIsValid(); + /// @notice EIP-712 style typehash for the operator's signed proof payload. + /// @dev Must match `ProofPayload::typehash()` in `crates/events/src/enclave_event/signed_proof.rs`. + /// Prevents cross-chain, cross-E3, and cross-proof-type replay of signed proofs. + bytes32 public constant PROOF_PAYLOAD_TYPEHASH = + keccak256( + "ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)" + ); // ====================== // Modifiers @@ -211,7 +220,14 @@ contract SlashingManager is ISlashingManager, AccessControl { /// @inheritdoc ISlashingManager /// @dev Lane A: Permissionless proof-based slash. Anyone can call. - /// Atomically proposes, verifies proof, and executes slash. + /// Atomically proposes, verifies operator signature + ZK proof, and executes slash. + /// Evidence format: abi.encode(bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) + /// The operator must have signed: keccak256(abi.encode(PROOF_PAYLOAD_TYPEHASH, chainId, e3Id, proofType, keccak256(zkProof), keccak256(abi.encodePacked(publicInputs)))) + /// This prevents: + /// - Arbitrary proof submission (attacker can't forge operator's signature) + /// - Cross-E3 replay (e3Id is in the signed message) + /// - Cross-chain replay (chainId is in the signed message) + /// - Verifier-upgrade attacks (verifier in evidence must match policy's current verifier) function proposeSlash( uint256 e3Id, address operator, @@ -232,26 +248,8 @@ contract SlashingManager is ISlashingManager, AccessControl { require(!evidenceConsumed[evidenceKey], DuplicateEvidence()); evidenceConsumed[evidenceKey] = true; - // Decode proof: caller encodes (bytes zkProof, bytes32[] publicInputs) - (bytes memory zkProof, bytes32[] memory publicInputs) = abi.decode( - proof, - (bytes, bytes32[]) - ); - - // Verify against circuit verifier via staticcall - // INVERTED logic: proof must FAIL to confirm fault - // (the operator submitted a bad proof — re-verification fails) - (bool callSuccess, bytes memory returnData) = policy - .proofVerifier - .staticcall( - abi.encodeCall(ICircuitVerifier.verify, (zkProof, publicInputs)) - ); - - if (callSuccess) { - bool proofValid = abi.decode(returnData, (bool)); - if (proofValid) revert ProofIsValid(); - } - // If staticcall reverted or returned false → proof is invalid → fault confirmed + // Verify evidence: signature, committee membership, and ZK proof + _verifyProofEvidence(proof, e3Id, operator, policy.proofVerifier); // Create proposal proposalId = totalProposals; @@ -357,6 +355,78 @@ contract SlashingManager is ISlashingManager, AccessControl { // Internal Execution // ====================== + /// @dev Verifies the operator is/was a committee member for the given E3. + function _verifyCommitteeMembership( + uint256 e3Id, + address operator + ) internal view { + address[] memory committeeNodes = ciphernodeRegistry.getCommitteeNodes( + e3Id + ); + bool isMember = false; + for (uint256 i = 0; i < committeeNodes.length; i++) { + if (committeeNodes[i] == operator) { + isMember = true; + break; + } + } + require(isMember, OperatorNotInCommittee()); + } + + /// @dev Decodes evidence, verifies operator signature, committee membership, + /// and that the ZK proof is invalid (fault confirmed). + /// Evidence format: abi.encode(bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) + function _verifyProofEvidence( + bytes calldata proof, + uint256 e3Id, + address operator, + address policyVerifier + ) internal view { + ( + bytes memory zkProof, + bytes32[] memory publicInputs, + bytes memory signature, + uint256 chainId, + uint256 proofType, + address signedVerifier + ) = abi.decode( + proof, + (bytes, bytes32[], bytes, uint256, uint256, address) + ); + + // 1. Verify verifier in evidence matches policy's current verifier. + require(signedVerifier == policyVerifier, VerifierMismatch()); + + // 2. Verify the operator signed this exact proof payload. + bytes32 messageHash = keccak256( + abi.encode( + PROOF_PAYLOAD_TYPEHASH, + chainId, + e3Id, + proofType, + keccak256(zkProof), + keccak256(abi.encodePacked(publicInputs)) + ) + ); + bytes32 ethSignedHash = MessageHashUtils.toEthSignedMessageHash( + messageHash + ); + address recoveredSigner = ECDSA.recover(ethSignedHash, signature); + require(recoveredSigner == operator, SignerIsNotOperator()); + + // 3. Verify committee membership. + _verifyCommitteeMembership(e3Id, operator); + + // 4. Re-verify the ZK proof on-chain (INVERTED: must FAIL to confirm fault). + (bool callSuccess, bytes memory returnData) = policyVerifier.staticcall( + abi.encodeCall(ICircuitVerifier.verify, (zkProof, publicInputs)) + ); + if (callSuccess) { + bool proofValid = abi.decode(returnData, (bool)); + if (proofValid) revert ProofIsValid(); + } + } + /** * @notice Internal function that executes a slash and handles committee expulsion * @param proposalId ID of the proposal to execute diff --git a/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol b/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol index 2a307d9b08..09c23abb86 100644 --- a/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol +++ b/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol @@ -10,6 +10,20 @@ import { IEnclave } from "../interfaces/IEnclave.sol"; import { IBondingRegistry } from "../interfaces/IBondingRegistry.sol"; contract MockCiphernodeRegistry is ICiphernodeRegistry { + /// @notice Configurable committee members per E3 for testing + mapping(uint256 => address[]) private _committeeNodes; + + /// @notice Set committee members for an E3 (test helper) + function setCommitteeNodes( + uint256 e3Id, + address[] calldata nodes + ) external { + delete _committeeNodes[e3Id]; + for (uint256 i = 0; i < nodes.length; i++) { + _committeeNodes[e3Id].push(nodes[i]); + } + } + function requestCommittee( uint256, uint256, @@ -52,10 +66,9 @@ contract MockCiphernodeRegistry is ICiphernodeRegistry { ) external pure {} // solhint-disable-line no-empty-blocks function getCommitteeNodes( - uint256 - ) external pure returns (address[] memory) { - address[] memory nodes = new address[](0); - return nodes; + uint256 e3Id + ) external view returns (address[] memory) { + return _committeeNodes[e3Id]; } function root() external pure returns (uint256) { diff --git a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts index 16ce2efb63..5d47eda3ba 100644 --- a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts +++ b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts @@ -9,6 +9,7 @@ import { network } from "hardhat"; import BondingRegistryModule from "../../ignition/modules/bondingRegistry"; import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken"; import EnclaveTokenModule from "../../ignition/modules/enclaveToken"; +import MockCiphernodeRegistryModule from "../../ignition/modules/mockCiphernodeRegistry"; import MockCircuitVerifierModule from "../../ignition/modules/mockSlashingVerifier"; import MockStableTokenModule from "../../ignition/modules/mockStableToken"; import SlashingManagerModule from "../../ignition/modules/slashingManager"; @@ -16,12 +17,14 @@ import { BondingRegistry__factory as BondingRegistryFactory, EnclaveTicketToken__factory as EnclaveTicketTokenFactory, EnclaveToken__factory as EnclaveTokenFactory, + MockCiphernodeRegistry__factory as MockCiphernodeRegistryFactory, MockCircuitVerifier__factory as MockCircuitVerifierFactory, MockUSDC__factory as MockUSDCFactory, SlashingManager__factory as SlashingManagerFactory, } from "../../types"; +import type { MockCircuitVerifier } from "../../types"; +import type { MockCiphernodeRegistry } from "../../types"; import type { SlashingManager } from "../../types/contracts/slashing/SlashingManager"; -import type { MockCircuitVerifier } from "../../types/contracts/test/MockSlashingVerifier"; const { ethers, networkHelpers, ignition } = await network.connect(); const { loadFixture, time } = networkHelpers; @@ -44,15 +47,66 @@ describe("SlashingManager", function () { const abiCoder = ethers.AbiCoder.defaultAbiCoder(); + // Must match the PROOF_PAYLOAD_TYPEHASH in SlashingManager.sol + const PROOF_PAYLOAD_TYPEHASH = ethers.keccak256( + ethers.toUtf8Bytes( + "ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)", + ), + ); + + /** + * Helper to create a signed proof evidence bundle. + * The operator signs the proof payload (matching Rust ProofPayload.digest()), + * then the evidence is encoded in the format expected by proposeSlash(). + * Returns abi.encode(zkProof, publicInputs, signature, chainId, proofType, verifier) + */ + async function signAndEncodeProof( + signer: any, + e3Id: number, + reason: string, + verifierAddress: string, + zkProof: string = "0x1234", + publicInputs: string[] = [ethers.ZeroHash], + chainId: number = 31337, // Hardhat default chain ID + proofType: number = 0, // T0PkBfv + ): Promise { + // Operator signs: keccak256(abi.encode(PROOF_PAYLOAD_TYPEHASH, chainId, e3Id, proofType, keccak256(zkProof), keccak256(publicSignals))) + const messageHash = ethers.keccak256( + abiCoder.encode( + ["bytes32", "uint256", "uint256", "uint256", "bytes32", "bytes32"], + [ + PROOF_PAYLOAD_TYPEHASH, + chainId, + e3Id, + proofType, + ethers.keccak256(zkProof), + ethers.keccak256( + ethers.solidityPacked(["bytes32[]"], [publicInputs]), + ), + ], + ), + ); + const signature = await signer.signMessage(ethers.getBytes(messageHash)); + // Evidence format: abi.encode(zkProof, publicInputs, signature, chainId, proofType, verifier) + return abiCoder.encode( + ["bytes", "bytes32[]", "bytes", "uint256", "uint256", "address"], + [zkProof, publicInputs, signature, chainId, proofType, verifierAddress], + ); + } + /** - * Helper to encode proof data as (bytes zkProof, bytes32[] publicInputs) - * for the circuit verifier inverted-logic path. + * Legacy helper for tests that check early failures (before abi.decode). + * This encodes a minimal 6-tuple with dummy values for basic validation tests. */ - function encodeProof( + function encodeDummyProof( zkProof: string = "0x1234", publicInputs: string[] = [ethers.ZeroHash], + verifierAddress: string = ethers.ZeroAddress, ): string { - return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); + return abiCoder.encode( + ["bytes", "bytes32[]", "bytes", "uint256", "uint256", "address"], + [zkProof, publicInputs, "0x00", 31337, 0, verifierAddress], + ); } async function setupPolicies( @@ -139,6 +193,13 @@ describe("SlashingManager", function () { MockCircuitVerifierModule, ); + const mockCiphernodeRegistryContract = await ignition.deploy( + MockCiphernodeRegistryModule, + ); + + const mockCiphernodeRegistryAddress = + await mockCiphernodeRegistryContract.mockCiphernodeRegistry.getAddress(); + const slashingManagerContract = await ignition.deploy( SlashingManagerModule, { @@ -146,7 +207,7 @@ describe("SlashingManager", function () { SlashingManager: { admin: ownerAddress, bondingRegistry: ownerAddress, - ciphernodeRegistry: addressOne, + ciphernodeRegistry: mockCiphernodeRegistryAddress, enclave: addressOne, }, }, @@ -189,6 +250,10 @@ describe("SlashingManager", function () { await mockVerifierContract.mockCircuitVerifier.getAddress(), owner, ); + const mockCiphernodeRegistry = MockCiphernodeRegistryFactory.connect( + mockCiphernodeRegistryAddress, + owner, + ); const slashingManager = SlashingManagerFactory.connect( await slashingManagerContract.slashingManager.getAddress(), owner, @@ -229,6 +294,7 @@ describe("SlashingManager", function () { ticketToken, usdcToken, mockVerifier, + mockCiphernodeRegistry, }; } @@ -512,16 +578,23 @@ describe("SlashingManager", function () { }); describe("proposeSlash() — Lane A (proof-based, permissionless)", function () { - it("should propose and auto-execute slash with proof", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); + it("should propose and auto-execute slash with signed proof from operator", async function () { + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); // MockCircuitVerifier default returnValue=false → proof invalid → fault confirmed + const verifierAddress = await mockVerifier.getAddress(); const proofPolicy = { ticketPenalty: ethers.parseUnits("50", 6), licensePenalty: ethers.parseEther("100"), requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), + proofVerifier: verifierAddress, banNode: false, appealWindow: 0, enabled: true, @@ -530,10 +603,19 @@ describe("SlashingManager", function () { }; await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); - const proof = encodeProof(); + // Set up committee membership for operator const e3Id = 0; + await mockCiphernodeRegistry.setCommitteeNodes(e3Id, [operatorAddress]); - // Anyone can call proposeSlash (permissionless for Lane A) + // Operator signs the bad proof + const proof = await signAndEncodeProof( + operator, + e3Id, + REASON_MISBEHAVIOR, + verifierAddress, + ); + + // Anyone can submit the signed evidence (permissionless for Lane A) await expect( slashingManager .connect(proposer) @@ -550,14 +632,21 @@ describe("SlashingManager", function () { }); it("should revert if circuit verifier says proof is valid (no fault)", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); + const verifierAddress = await mockVerifier.getAddress(); const proofPolicy = { ticketPenalty: ethers.parseUnits("50", 6), licensePenalty: ethers.parseEther("100"), requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), + proofVerifier: verifierAddress, banNode: false, appealWindow: 0, enabled: true, @@ -569,7 +658,14 @@ describe("SlashingManager", function () { // Set mock verifier to return true → proof is valid → NOT a fault await mockVerifier.setReturnValue(true); - const proof = encodeProof(); + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); + + const proof = await signAndEncodeProof( + operator, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + ); await expect( slashingManager .connect(proposer) @@ -577,13 +673,95 @@ describe("SlashingManager", function () { ).to.be.revertedWithCustomError(slashingManager, "ProofIsValid"); }); + it("should revert if signer is not the operator (V-001 fix)", async function () { + const { + slashingManager, + proposer, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); + + const verifierAddress = await mockVerifier.getAddress(); + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: verifierAddress, + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); + + // Proposer signs the proof (NOT the operator) — should be rejected + const proof = await signAndEncodeProof( + proposer, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + ); + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError(slashingManager, "SignerIsNotOperator"); + }); + + it("should revert if operator is not in committee (V-001 fix)", async function () { + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); + + const verifierAddress = await mockVerifier.getAddress(); + const proofPolicy = { + ticketPenalty: ethers.parseUnits("50", 6), + licensePenalty: ethers.parseEther("100"), + requiresProof: true, + proofVerifier: verifierAddress, + banNode: false, + appealWindow: 0, + enabled: true, + affectsCommittee: false, + failureReason: 0, + }; + await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + + // Do NOT add operator to committee — empty committee for this E3 + + const proof = await signAndEncodeProof( + operator, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + ); + await expect( + slashingManager + .connect(proposer) + .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof), + ).to.be.revertedWithCustomError( + slashingManager, + "OperatorNotInCommittee", + ); + }); + it("should revert if operator is zero address", async function () { const { slashingManager, proposer, mockVerifier } = await loadFixture(setup); await setupPolicies(slashingManager, mockVerifier); - const proof = encodeProof(); + // Any non-empty proof triggers ZeroAddress check before decode + const proof = encodeDummyProof(); await expect( slashingManager @@ -596,7 +774,7 @@ describe("SlashingManager", function () { const { slashingManager, proposer, operatorAddress } = await loadFixture(setup); - const proof = encodeProof(); + const proof = encodeDummyProof(); await expect( slashingManager @@ -630,14 +808,21 @@ describe("SlashingManager", function () { }); it("should reject duplicate evidence", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); + const verifierAddress = await mockVerifier.getAddress(); const proofPolicy = { ticketPenalty: ethers.parseUnits("50", 6), licensePenalty: ethers.parseEther("100"), requiresProof: true, - proofVerifier: await mockVerifier.getAddress(), + proofVerifier: verifierAddress, banNode: false, appealWindow: 0, enabled: true, @@ -645,8 +830,14 @@ describe("SlashingManager", function () { failureReason: 0, }; await slashingManager.setSlashPolicy(REASON_MISBEHAVIOR, proofPolicy); + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); - const proof = encodeProof(); + const proof = await signAndEncodeProof( + operator, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + ); await slashingManager .connect(proposer) .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); @@ -660,21 +851,43 @@ describe("SlashingManager", function () { }); it("should increment totalProposals", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); await setupPolicies(slashingManager, mockVerifier); + const verifierAddress = await mockVerifier.getAddress(); + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); + await mockCiphernodeRegistry.setCommitteeNodes(1, [operatorAddress]); + expect(await slashingManager.totalProposals()).to.equal(0); - const proof1 = encodeProof("0x1111"); + const proof1 = await signAndEncodeProof( + operator, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + "0x1111", + ); await slashingManager .connect(proposer) .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof1); expect(await slashingManager.totalProposals()).to.equal(1); - const proof2 = encodeProof("0x2222"); + const proof2 = await signAndEncodeProof( + operator, + 1, + REASON_MISBEHAVIOR, + verifierAddress, + "0x2222", + ); await slashingManager .connect(proposer) .proposeSlash(1, operatorAddress, REASON_MISBEHAVIOR, proof2); @@ -683,14 +896,29 @@ describe("SlashingManager", function () { }); it("should ban node when policy requires it", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); await setupPolicies(slashingManager, mockVerifier); + const verifierAddress = await mockVerifier.getAddress(); + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); + expect(await slashingManager.isBanned(operatorAddress)).to.be.false; - const proof = encodeProof("0x3333"); + const proof = await signAndEncodeProof( + operator, + 0, + REASON_DOUBLE_SIGN, + verifierAddress, + "0x3333", + ); await slashingManager .connect(proposer) .proposeSlash(0, operatorAddress, REASON_DOUBLE_SIGN, proof); @@ -803,13 +1031,26 @@ describe("SlashingManager", function () { }); it("should revert if proof-based slash tries to executeSlash separately", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); await setupPolicies(slashingManager, mockVerifier); + const verifierAddress = await mockVerifier.getAddress(); + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); // Proof-based slash auto-executes in proposeSlash - const proof = encodeProof(); + const proof = await signAndEncodeProof( + operator, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + ); await slashingManager .connect(proposer) .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); @@ -969,12 +1210,20 @@ describe("SlashingManager", function () { operator, operatorAddress, mockVerifier, + mockCiphernodeRegistry, } = await loadFixture(setup); await setupPolicies(slashingManager, mockVerifier); + const verifierAddress = await mockVerifier.getAddress(); + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); // Proof-based slash auto-executes with proofVerified=true - const proof = encodeProof(); + const proof = await signAndEncodeProof( + operator, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + ); await slashingManager .connect(proposer) .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); @@ -1246,12 +1495,26 @@ describe("SlashingManager", function () { }); it("should return correct slash proposal", async function () { - const { slashingManager, proposer, operatorAddress, mockVerifier } = - await loadFixture(setup); + const { + slashingManager, + proposer, + operator, + operatorAddress, + mockVerifier, + mockCiphernodeRegistry, + } = await loadFixture(setup); await setupPolicies(slashingManager, mockVerifier); + const verifierAddress = await mockVerifier.getAddress(); + await mockCiphernodeRegistry.setCommitteeNodes(0, [operatorAddress]); - const proof = encodeProof("0x4444"); + const proof = await signAndEncodeProof( + operator, + 0, + REASON_MISBEHAVIOR, + verifierAddress, + "0x4444", + ); await slashingManager .connect(proposer) .proposeSlash(0, operatorAddress, REASON_MISBEHAVIOR, proof); From dc9b42f61e58470a81c70abf3a8906ca895de099 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Fri, 20 Feb 2026 18:18:52 +0500 Subject: [PATCH 18/32] fix: slashing encode fault & e3 tokens --- crates/evm/src/slashing_manager_sol_writer.rs | 25 ++++------ .../zk-helpers/src/ciphernodes_committee.rs | 22 ++++----- .../IBondingRegistry.json | 15 +++++- .../ICiphernodeRegistry.json | 2 +- .../interfaces/IEnclave.sol/IEnclave.json | 2 +- .../ISlashingManager.json | 7 ++- .../EnclaveTicketToken.json | 2 +- .../DkgPkVerifier.sol/DkgPkVerifier.json | 8 +-- .../DkgPkVerifier.sol/ZKTranscriptLib.json | 2 +- .../contracts/E3RefundManager.sol | 20 ++++---- .../enclave-contracts/contracts/Enclave.sol | 49 ++++++++++++++++--- .../contracts/interfaces/IBondingRegistry.sol | 7 +++ .../contracts/interfaces/ISlashingManager.sol | 3 ++ .../contracts/registry/BondingRegistry.sol | 25 +++++++--- .../contracts/slashing/SlashingManager.sol | 19 ++++--- 15 files changed, 136 insertions(+), 72 deletions(-) diff --git a/crates/evm/src/slashing_manager_sol_writer.rs b/crates/evm/src/slashing_manager_sol_writer.rs index dc992afe8b..229f09fa0f 100644 --- a/crates/evm/src/slashing_manager_sol_writer.rs +++ b/crates/evm/src/slashing_manager_sol_writer.rs @@ -16,7 +16,6 @@ use alloy::{ providers::{Provider, WalletProvider}, rpc::types::TransactionReceipt, sol, - sol_types::SolValue, }; use anyhow::Result; use e3_events::prelude::*; @@ -25,7 +24,7 @@ use e3_events::EnclaveEvent; use e3_events::EnclaveEventData; use e3_events::EventType; use e3_events::Shutdown; -use e3_events::{EType, SignedProofFailed}; +use e3_events::{encode_fault_evidence, EType, SignedProofFailed}; use e3_utils::NotifySync; use tracing::info; @@ -138,20 +137,15 @@ async fn submit_slash_proposal( let operator = data.faulting_node; let reason = keccak256(data.proof_type.slash_reason().as_bytes()); - // Encode as (bytes zkProof, bytes32[] publicInputs) - let zk_proof = Bytes::copy_from_slice(&data.signed_payload.payload.proof.data); - let public_inputs_bytes = &data.signed_payload.payload.proof.public_signals; - - // Each 32-byte chunk of public_signals becomes one bytes32 element - let mut public_inputs: Vec<[u8; 32]> = Vec::new(); - for chunk in public_inputs_bytes.chunks(32) { - let mut padded = [0u8; 32]; - let start = 32 - chunk.len(); - padded[start..].copy_from_slice(chunk); - public_inputs.push(padded); - } + // Look up the verifier address from the on-chain slash policy. + // This is required to encode the full 6-tuple evidence that the contract expects: + // (bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) + let contract = ISlashingManager::new(contract_address, provider.provider()); + let policy = contract.getSlashPolicy(reason.into()).call().await?; + let verifier = policy.proofVerifier; - let proof_data = (zk_proof, public_inputs).abi_encode(); + // Use the canonical encoder from signed_proof.rs (H-02/C-02 fix) + let proof_data = encode_fault_evidence(&data, verifier); let from_address = provider.provider().default_signer_address(); let current_nonce = provider @@ -160,7 +154,6 @@ async fn submit_slash_proposal( .pending() .await?; - // DuplicateEvidence() = keccak256("DuplicateEvidence()")[:4] – retry if not yet on-chain send_tx_with_retry("proposeSlash", &[], || { info!( "proposeSlash() e3_id={:?} operator={:?} reason={:?}", diff --git a/crates/zk-helpers/src/ciphernodes_committee.rs b/crates/zk-helpers/src/ciphernodes_committee.rs index da5a706e55..f1a912296a 100644 --- a/crates/zk-helpers/src/ciphernodes_committee.rs +++ b/crates/zk-helpers/src/ciphernodes_committee.rs @@ -38,18 +38,16 @@ impl CiphernodesCommitteeSize { h: 5, threshold: 2, }, - _ => unreachable!(), + CiphernodesCommitteeSize::Medium => CiphernodesCommittee { + n: 10, + h: 8, + threshold: 4, + }, + CiphernodesCommitteeSize::Large => CiphernodesCommittee { + n: 20, + h: 15, + threshold: 7, + }, } - // @todo add the other committee sizes - // CiphernodesCommitteeSize::Medium => CiphernodesCommittee { - // n: 5, - // h: 5, - // threshold: 2, - // }, - // CiphernodesCommitteeSize::Large => CiphernodesCommittee { - // n: 5, - // h: 5, - // threshold: 2, - // }, } } diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json index 4b4862b5bd..b412e533af 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json @@ -611,6 +611,19 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "address", + "name": "distributor", + "type": "address" + } + ], + "name": "revokeRewardDistributor", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -890,5 +903,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IBondingRegistry.sol", - "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" + "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json index b085714590..e750d08ef2 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json @@ -767,5 +767,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ICiphernodeRegistry.sol", - "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" + "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json index f0f17e304c..1f89db3b7c 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json @@ -1202,5 +1202,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IEnclave.sol", - "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" + "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json index aae08da573..eee9e7f5a5 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json @@ -98,6 +98,11 @@ "name": "Unauthorized", "type": "error" }, + { + "inputs": [], + "name": "VerifierCallFailed", + "type": "error" + }, { "inputs": [], "name": "VerifierMismatch", @@ -840,5 +845,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ISlashingManager.sol", - "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" + "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json index 7ccba112b9..caa6d9312a 100644 --- a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json +++ b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json @@ -1210,5 +1210,5 @@ ] }, "inputSourceName": "project/contracts/token/EnclaveTicketToken.sol", - "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" + "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json index 5eee2539ed..18e639df1b 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json @@ -102,7 +102,7 @@ } }, "immutableReferences": { - "33527": [ + "33611": [ { "length": 32, "start": 91 @@ -164,13 +164,13 @@ "start": 11964 } ], - "33529": [ + "33613": [ { "length": 32, "start": 398 } ], - "33531": [ + "33615": [ { "length": 32, "start": 432 @@ -182,5 +182,5 @@ ] }, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" + "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json index 53b441c1c3..9fd248d1e5 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json @@ -396,5 +396,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-55834258511e6e9e42821e54c3876bcc8ee4f5f3" + "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" } \ No newline at end of file diff --git a/packages/enclave-contracts/contracts/E3RefundManager.sol b/packages/enclave-contracts/contracts/E3RefundManager.sol index e1803e9ccd..5806976909 100644 --- a/packages/enclave-contracts/contracts/E3RefundManager.sol +++ b/packages/enclave-contracts/contracts/E3RefundManager.sol @@ -42,6 +42,8 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { mapping(uint256 e3Id => RefundDistribution) internal _distributions; /// @notice Tracks claims per E3 per address mapping(uint256 e3Id => mapping(address => bool)) internal _claimed; + /// @notice Tracks number of claims made per E3 (for routeSlashedFunds guard) + mapping(uint256 e3Id => uint256) internal _claimCount; /// @notice Maps E3 ID to honest node addresses mapping(uint256 e3Id => address[]) internal _honestNodes; //////////////////////////////////////////////////////////// @@ -241,6 +243,7 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { if (amount == 0) revert NoRefundAvailable(e3Id); _claimed[e3Id][msg.sender] = true; + _claimCount[e3Id]++; // Use the per-E3 fee token (not the global one, which may have been rotated) dist.feeToken.safeTransfer(msg.sender, amount); @@ -269,17 +272,13 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { require(amount > 0, NoRefundAvailable(e3Id)); _claimed[e3Id][msg.sender] = true; + _claimCount[e3Id]++; - // Use the per-E3 fee token and distribute through bonding registry + // Transfer directly to the honest node. Using distributeRewards would require + // this contract to be an authorized distributor in BondingRegistry, and the node + // must be registered. Direct transfer is simpler and more reliable for refunds. IERC20 token = dist.feeToken; - token.approve(address(bondingRegistry), amount); - - address[] memory nodeArray = new address[](1); - nodeArray[0] = msg.sender; - uint256[] memory amountArray = new uint256[](1); - amountArray[0] = amount; - - bondingRegistry.distributeRewards(token, nodeArray, amountArray); + token.safeTransfer(msg.sender, amount); emit RefundClaimed(e3Id, msg.sender, amount, "HONEST_NODE"); } @@ -291,9 +290,10 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { ) external onlyEnclave { RefundDistribution storage dist = _distributions[e3Id]; require(dist.calculated, "Not calculated"); + require(_claimCount[e3Id] == 0, "Claims already started"); + require(amount > 0, "Zero amount"); // Add slashed funds to distribution - // Note: slashing should be finalized before claims are made. // 50% to requester, 50% to honest nodes for non-participation uint256 toRequester = amount / 2; uint256 toHonestNodes = amount - toRequester; diff --git a/packages/enclave-contracts/contracts/Enclave.sol b/packages/enclave-contracts/contracts/Enclave.sol index 27d130b87f..65243cf2b1 100644 --- a/packages/enclave-contracts/contracts/Enclave.sol +++ b/packages/enclave-contracts/contracts/Enclave.sol @@ -94,6 +94,10 @@ contract Enclave is IEnclave, OwnableUpgradeable { /// @notice Maps E3 ID to requester address mapping(uint256 e3Id => address) internal _e3Requesters; + /// @notice Maps E3 ID to the fee token used at request time + /// @dev Stored per-E3 to survive global feeToken rotations (H-01 fix) + mapping(uint256 e3Id => IERC20) internal _e3FeeTokens; + /// @notice Global timeout configuration E3TimeoutConfig internal _timeoutConfig; @@ -351,6 +355,9 @@ contract Enclave is IEnclave, OwnableUpgradeable { feeToken.safeTransferFrom(msg.sender, address(this), e3Fee); + // Store the fee token used for this E3 (survives global token rotations) + _e3FeeTokens[e3Id] = feeToken; + require( ciphernodeRegistry.requestCommittee( e3Id, @@ -381,6 +388,13 @@ contract Enclave is IEnclave, OwnableUpgradeable { ) external returns (bool success) { E3 memory e3 = getE3(e3Id); + // C-01 fix: Verify E3 is in KeyPublished stage before accepting ciphertext + E3Stage current = _e3Stages[e3Id]; + require( + current == E3Stage.KeyPublished, + InvalidStage(e3Id, E3Stage.KeyPublished, current) + ); + E3Deadlines memory deadlines = _e3Deadlines[e3Id]; // You cannot post outputs after the compute deadline @@ -473,6 +487,7 @@ contract Enclave is IEnclave, OwnableUpgradeable { /// @dev Uses active committee nodes (excluding expelled members). /// Divides the E3 payment equally among active members and transfers via bonding registry. /// If no active members remain (e.g., all expelled), refunds the requester to prevent fund lockup. + /// Any division dust is sent to the last member rather than being lost. /// @param e3Id The ID of the E3 for which to distribute rewards. function _distributeRewards(uint256 e3Id) internal { address[] memory activeNodes = ciphernodeRegistry @@ -483,10 +498,13 @@ contract Enclave is IEnclave, OwnableUpgradeable { e3Payments[e3Id] = 0; if (totalAmount == 0) return; + // Use the per-E3 fee token (not the global one, which may have been rotated) + IERC20 paymentToken = _e3FeeTokens[e3Id]; + if (activeLength == 0) { address requester = _e3Requesters[e3Id]; if (requester != address(0)) { - feeToken.safeTransfer(requester, totalAmount); + paymentToken.safeTransfer(requester, totalAmount); } return; } @@ -495,16 +513,23 @@ contract Enclave is IEnclave, OwnableUpgradeable { // Distribute equally among active (non-expelled) committee members uint256 amount = totalAmount / activeLength; + uint256 distributed = 0; for (uint256 i = 0; i < activeLength; i++) { amounts[i] = amount; + distributed += amount; + } + // Give any division dust to the last member (C-03 fix) + uint256 dust = totalAmount - distributed; + if (dust > 0) { + amounts[activeLength - 1] += dust; } - feeToken.approve(address(bondingRegistry), totalAmount); + paymentToken.approve(address(bondingRegistry), totalAmount); - bondingRegistry.distributeRewards(feeToken, activeNodes, amounts); + bondingRegistry.distributeRewards(paymentToken, activeNodes, amounts); - // Dust goes to treasury (implicit via remaining approval) - feeToken.approve(address(bondingRegistry), 0); + // Reset approval + paymentToken.approve(address(bondingRegistry), 0); emit RewardsDistributed(e3Id, activeNodes, amounts); } @@ -671,7 +696,7 @@ contract Enclave is IEnclave, OwnableUpgradeable { /// @notice Process a failed E3 and calculate refunds /// @dev Can be called by anyone once E3 is in failed state. - /// Passes the current feeToken so the refund manager stores the correct token per-E3. + /// Uses the per-E3 feeToken stored at request time (survives global token rotation). /// @param e3Id The ID of the failed E3 function processE3Failure(uint256 e3Id) external { E3Stage stage = _e3Stages[e3Id]; @@ -683,8 +708,16 @@ contract Enclave is IEnclave, OwnableUpgradeable { address[] memory honestNodes = _getHonestNodes(e3Id); - feeToken.safeTransfer(address(e3RefundManager), payment); - e3RefundManager.calculateRefund(e3Id, payment, honestNodes, feeToken); + // Use the per-E3 fee token (H-01 fix: survives global feeToken rotation) + IERC20 paymentToken = _e3FeeTokens[e3Id]; + + paymentToken.safeTransfer(address(e3RefundManager), payment); + e3RefundManager.calculateRefund( + e3Id, + payment, + honestNodes, + paymentToken + ); emit E3FailureProcessed(e3Id, payment, honestNodes.length); } diff --git a/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol b/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol index a343b2f747..10dec6c2cb 100644 --- a/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol +++ b/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol @@ -439,6 +439,13 @@ interface IBondingRegistry { */ function setRewardDistributor(address newRewardDistributor) external; + /** + * @notice Revoke reward distributor authorization + * @param distributor Address to revoke + * @dev Only callable by contract owner + */ + function revokeRewardDistributor(address distributor) external; + /** * @notice Withdraw slashed funds to treasury * @param ticketAmount Amount of slashed ticket balance to withdraw diff --git a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol index 6646b743af..6566356c14 100644 --- a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol +++ b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol @@ -114,6 +114,9 @@ interface ISlashingManager { /// @notice Thrown when the verifier address in signed evidence doesn't match the policy's current verifier error VerifierMismatch(); + /// @notice Thrown when the verifier staticcall fails (e.g., contract doesn't exist, reverts, or runs out of gas) + error VerifierCallFailed(); + /// @notice Thrown when attempting to execute a slash whose appeal was upheld error AppealUpheld(); diff --git a/packages/enclave-contracts/contracts/registry/BondingRegistry.sol b/packages/enclave-contracts/contracts/registry/BondingRegistry.sol index 41006ce38b..fdd151f7e8 100644 --- a/packages/enclave-contracts/contracts/registry/BondingRegistry.sol +++ b/packages/enclave-contracts/contracts/registry/BondingRegistry.sol @@ -62,8 +62,10 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { /// @notice Address authorized to perform slashing operations address public slashingManager; - /// @notice Address authorized to distribute rewards to operators - address public rewardDistributor; + /// @notice Addresses authorized to distribute rewards to operators + /// @dev Multiple contracts (Enclave, E3RefundManager) need to distribute rewards. + /// Each authorized distributor must approve this contract for the reward token. + mapping(address => bool) public authorizedDistributors; /// @notice Treasury address that receives slashed funds address public slashedFundsTreasury; @@ -574,14 +576,14 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { address[] calldata recipients, uint256[] calldata amounts ) external { - require(msg.sender == rewardDistributor, OnlyRewardDistributor()); + require(authorizedDistributors[msg.sender], OnlyRewardDistributor()); require(recipients.length == amounts.length, ArrayLengthMismatch()); uint256 len = recipients.length; for (uint256 i = 0; i < len; i++) { if (amounts[i] > 0 && operators[recipients[i]].registered) { rewardToken.safeTransferFrom( - rewardDistributor, + msg.sender, recipients[i], amounts[i] ); @@ -679,13 +681,20 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { slashingManager = newSlashingManager; } - /// @notice Sets the reward distributor address - /// @dev Only callable by owner - /// @param newRewardDistributor Address of the reward distributor + /// @notice Authorizes an address to distribute rewards + /// @dev Only callable by owner. Supports multiple authorized distributors (Enclave + E3RefundManager) + /// @param newRewardDistributor Address to authorize as reward distributor function setRewardDistributor( address newRewardDistributor ) public onlyOwner { - rewardDistributor = newRewardDistributor; + authorizedDistributors[newRewardDistributor] = true; + } + + /// @notice Revokes reward distributor authorization + /// @dev Only callable by owner + /// @param distributor Address to revoke + function revokeRewardDistributor(address distributor) public onlyOwner { + authorizedDistributors[distributor] = false; } /// @inheritdoc IBondingRegistry diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index 13e590e141..e08ba012e3 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -64,6 +64,8 @@ contract SlashingManager is ISlashingManager, AccessControl { mapping(address node => bool banned) public banned; /// @notice Evidence replay protection: tracks consumed evidence keys + /// @dev Key is keccak256(abi.encode(e3Id, operator, keccak256(proof))) — reason-independent + /// to prevent the same proof/evidence from being used to slash under multiple reasons. mapping(bytes32 evidenceKey => bool consumed) public evidenceConsumed; // ====================== @@ -241,9 +243,9 @@ contract SlashingManager is ISlashingManager, AccessControl { require(policy.requiresProof, InvalidPolicy()); require(proof.length != 0, ProofRequired()); - // Evidence replay protection + // Evidence replay protection — reason-independent to prevent cross-reason replay (M-05) bytes32 evidenceKey = keccak256( - abi.encode(e3Id, operator, reason, keccak256(proof)) + abi.encode(e3Id, operator, keccak256(proof)) ); require(!evidenceConsumed[evidenceKey], DuplicateEvidence()); evidenceConsumed[evidenceKey] = true; @@ -295,9 +297,9 @@ contract SlashingManager is ISlashingManager, AccessControl { require(policy.enabled, SlashReasonDisabled()); require(!policy.requiresProof, InvalidPolicy()); - // Evidence replay protection + // Evidence replay protection — reason-independent to prevent cross-reason replay (M-05) bytes32 evidenceKey = keccak256( - abi.encode(e3Id, operator, reason, keccak256(evidence)) + abi.encode(e3Id, operator, keccak256(evidence)) ); require(!evidenceConsumed[evidenceKey], DuplicateEvidence()); evidenceConsumed[evidenceKey] = true; @@ -418,13 +420,14 @@ contract SlashingManager is ISlashingManager, AccessControl { _verifyCommitteeMembership(e3Id, operator); // 4. Re-verify the ZK proof on-chain (INVERTED: must FAIL to confirm fault). + // The staticcall MUST succeed — if the verifier reverts or doesn't exist, + // we cannot determine fault and must not slash (M-04 fix). (bool callSuccess, bytes memory returnData) = policyVerifier.staticcall( abi.encodeCall(ICircuitVerifier.verify, (zkProof, publicInputs)) ); - if (callSuccess) { - bool proofValid = abi.decode(returnData, (bool)); - if (proofValid) revert ProofIsValid(); - } + require(callSuccess, VerifierCallFailed()); + bool proofValid = abi.decode(returnData, (bool)); + if (proofValid) revert ProofIsValid(); } /** From ee556ac434d56ca48e8623da91088120349ed95a Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Fri, 20 Feb 2026 22:16:24 +0500 Subject: [PATCH 19/32] fix: linting errors --- crates/evm/src/enclave_sol_writer.rs | 11 ++++- crates/evm/src/slashing_manager_sol_writer.rs | 1 - examples/CRISP/client/src/App.tsx | 1 + .../client/src/components/Cards/Card.tsx | 25 ++++------ .../client/src/components/Cards/PollCard.tsx | 10 ++-- .../client/src/components/CircularTiles.tsx | 18 ++++--- .../CRISP/client/src/components/NavMenu.tsx | 25 +++++----- .../NotificationAlert.context.tsx | 1 + .../voteManagement/VoteManagement.context.tsx | 1 + .../DailyPoll/components/ConfirmVote.tsx | 1 + .../src/pages/PollResult/PollResult.tsx | 2 + .../IBondingRegistry.json | 2 +- .../ICiphernodeRegistry.json | 2 +- .../interfaces/IEnclave.sol/IEnclave.json | 41 +++++++++++++++- .../ISlashingManager.json | 2 +- .../EnclaveTicketToken.json | 47 ++++++++++++------- .../DkgPkVerifier.sol/DkgPkVerifier.json | 8 ++-- .../DkgPkVerifier.sol/ZKTranscriptLib.json | 2 +- .../contracts/E3RefundManager.sol | 25 ++++++++-- .../enclave-contracts/contracts/Enclave.sol | 43 +++++++++++------ .../contracts/interfaces/IEnclave.sol | 13 +++++ .../contracts/interfaces/ISlashingManager.sol | 4 +- .../contracts/registry/BondingRegistry.sol | 32 +++++++++---- .../registry/CiphernodeRegistryOwnable.sol | 20 +++++++- .../contracts/slashing/SlashingManager.sol | 38 ++++++++++++--- .../contracts/test/MockCiphernodeRegistry.sol | 2 +- .../contracts/token/EnclaveTicketToken.sol | 15 ++++++ .../contracts/token/EnclaveToken.sol | 3 +- .../ignition/modules/slashingManager.ts | 2 - .../test/Slashing/SlashingManager.spec.ts | 2 - .../client/src/context/WizardContext.tsx | 4 ++ .../src/pages/steps/RequestComputation.tsx | 2 +- 32 files changed, 293 insertions(+), 112 deletions(-) diff --git a/crates/evm/src/enclave_sol_writer.rs b/crates/evm/src/enclave_sol_writer.rs index a95416dce0..21a5fd8a42 100644 --- a/crates/evm/src/enclave_sol_writer.rs +++ b/crates/evm/src/enclave_sol_writer.rs @@ -26,7 +26,7 @@ use e3_events::{run_once, EnclaveEvent}; use e3_events::{E3id, EType, PlaintextAggregated}; use e3_utils::NotifySync; use e3_utils::MAILBOX_LIMIT; -use tracing::info; +use tracing::{info, warn}; sol!( #[sol(rpc)] @@ -114,6 +114,15 @@ impl Handler 1 { + warn!( + "E3 {} has {} decrypted outputs but only the first is published on-chain. \ + Multi-output support is not yet implemented.", + e3_id, + decrypted_output.len() + ); + } let result = publish_plaintext_output( provider, contract_address, diff --git a/crates/evm/src/slashing_manager_sol_writer.rs b/crates/evm/src/slashing_manager_sol_writer.rs index 229f09fa0f..446f24041c 100644 --- a/crates/evm/src/slashing_manager_sol_writer.rs +++ b/crates/evm/src/slashing_manager_sol_writer.rs @@ -144,7 +144,6 @@ async fn submit_slash_proposal( let policy = contract.getSlashPolicy(reason.into()).call().await?; let verifier = policy.proofVerifier; - // Use the canonical encoder from signed_proof.rs (H-02/C-02 fix) let proof_data = encode_fault_evidence(&data, verifier); let from_address = provider.provider().default_signer_address(); diff --git a/examples/CRISP/client/src/App.tsx b/examples/CRISP/client/src/App.tsx index 335d3794d3..ad087a4442 100644 --- a/examples/CRISP/client/src/App.tsx +++ b/examples/CRISP/client/src/App.tsx @@ -45,6 +45,7 @@ const App: React.FC = () => { }) } })() + // eslint-disable-next-line react-hooks/exhaustive-deps }, []) return ( diff --git a/examples/CRISP/client/src/components/Cards/Card.tsx b/examples/CRISP/client/src/components/Cards/Card.tsx index f55705491f..e5ded8c8fb 100644 --- a/examples/CRISP/client/src/components/Cards/Card.tsx +++ b/examples/CRISP/client/src/components/Cards/Card.tsx @@ -4,7 +4,7 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -import React, { useEffect, useState } from 'react' +import React, { useMemo, useState } from 'react' interface CardProps { children: React.ReactNode @@ -17,22 +17,17 @@ interface CardProps { const Card: React.FC = ({ children, isActive, isDetails, checked, onChecked }) => { const [isClicked, setIsClicked] = useState(checked ?? false) - useEffect(() => { - setIsClicked(checked ?? false) - }, [checked]) + const derivedIsClicked = useMemo(() => { + if (isActive) return false + return checked ?? isClicked + }, [isActive, checked, isClicked]) const handleClick = () => { if (isDetails) return - if (onChecked) onChecked(!isClicked) - setIsClicked(!isClicked) + if (onChecked) onChecked(!derivedIsClicked) + setIsClicked(!derivedIsClicked) } - useEffect(() => { - if (isActive) { - setIsClicked(false) - } - }, [isActive]) - return (

= ({ children, isActive, isDetails, checked, onC ${!isDetails && 'shadow-md'} transform border-2 transition-all duration-300 ease-in-out - ${isClicked ? 'scale-105 border-lime-400' : ''} - ${isClicked ? 'border-lime-400' : 'border-slate-600/20'} - ${isClicked ? 'bg-white' : 'bg-slate-100'} + ${derivedIsClicked ? 'scale-105 border-lime-400' : ''} + ${derivedIsClicked ? 'border-lime-400' : 'border-slate-600/20'} + ${derivedIsClicked ? 'bg-white' : 'bg-slate-100'} ${!isDetails && 'hover:border-lime-300 hover:bg-white hover:shadow-lg'} flex w-full items-center justify-center `} diff --git a/examples/CRISP/client/src/components/Cards/PollCard.tsx b/examples/CRISP/client/src/components/Cards/PollCard.tsx index 25713063e0..235ebc0951 100644 --- a/examples/CRISP/client/src/components/Cards/PollCard.tsx +++ b/examples/CRISP/client/src/components/Cards/PollCard.tsx @@ -4,9 +4,9 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -import React, { useEffect, useState } from 'react' +import React, { useEffect, useMemo, useState } from 'react' import { useNavigate } from 'react-router-dom' -import { PollOption, PollResult } from '@/model/poll.model' +import { PollResult } from '@/model/poll.model' import VotesBadge from '@/components/VotesBadge' import PollCardResult from '@/components/Cards/PollCardResult' import { formatDate, markWinner } from '@/utils/methods' @@ -15,7 +15,6 @@ import { usePublicClient } from 'wagmi' const PollCard: React.FC = ({ roundId, options, totalVotes, date, endTime }) => { const navigate = useNavigate() - const [results, setResults] = useState(options) const [isActive, setIsActive] = useState(true) const { roundState, setPollResult, currentRoundId } = useVoteManagementContext() const client = usePublicClient() @@ -40,10 +39,7 @@ const PollCard: React.FC = ({ roundId, options, totalVotes, date, en return () => clearInterval(interval) }, [endTime, client, isActive]) - useEffect(() => { - const newPollOptions = markWinner(options) - setResults(newPollOptions) - }, [options]) + const results = useMemo(() => markWinner(options), [options]) const handleNavigation = () => { if (isActive && isCurrentRound) { diff --git a/examples/CRISP/client/src/components/CircularTiles.tsx b/examples/CRISP/client/src/components/CircularTiles.tsx index 8ccf12c0a3..00c73d5f69 100644 --- a/examples/CRISP/client/src/components/CircularTiles.tsx +++ b/examples/CRISP/client/src/components/CircularTiles.tsx @@ -4,17 +4,23 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -import { memo } from 'react' +import { memo, useEffect, useState } from 'react' import CircularTile from './CircularTile' +const generateRotations = (count: number) => [...Array(count)].map(() => [0, 90, 180, 270][Math.floor(Math.random() * 4)]) + const CircularTiles = ({ count = 1, className }: { count?: number; className?: string }) => { + const [rotations, setRotations] = useState(() => generateRotations(count)) + + useEffect(() => { + setRotations(generateRotations(count)) + }, [count]) + return ( <> - {[...Array(count)].map((_i, index) => { - const rand_index = Math.floor(Math.random() * 4) - const rotation = [0, 90, 180, 270][rand_index] - return - })} + {rotations.map((rotation, index) => ( + + ))} ) } diff --git a/examples/CRISP/client/src/components/NavMenu.tsx b/examples/CRISP/client/src/components/NavMenu.tsx index 59034ebeb2..1f28b6062f 100644 --- a/examples/CRISP/client/src/components/NavMenu.tsx +++ b/examples/CRISP/client/src/components/NavMenu.tsx @@ -35,16 +35,19 @@ const NavMenu: React.FC = () => { const [isOpen, setIsOpen] = useState(false) const buttonRef = useRef(null) - const handleClickOutside = (event: MouseEvent) => { - if ( - isOpen && - menuRef.current && - !menuRef.current.contains(event.target as Node) && - !buttonRef.current?.contains(event.target as Node) - ) { - setIsOpen(false) - } - } + const handleClickOutside = React.useCallback( + (event: MouseEvent) => { + if ( + isOpen && + menuRef.current && + !menuRef.current.contains(event.target as Node) && + !buttonRef.current?.contains(event.target as Node) + ) { + setIsOpen(false) + } + }, + [isOpen], + ) const toggleMenu = (event: React.MouseEvent) => { event.stopPropagation() @@ -59,7 +62,7 @@ const NavMenu: React.FC = () => { return () => { document.removeEventListener('mousedown', handleClickOutside) } - }, [isOpen]) + }, [isOpen, handleClickOutside]) const handleNavigation = (path: string) => { navigate(path) diff --git a/examples/CRISP/client/src/context/NotificationAlert/NotificationAlert.context.tsx b/examples/CRISP/client/src/context/NotificationAlert/NotificationAlert.context.tsx index 34397220c3..159a390791 100644 --- a/examples/CRISP/client/src/context/NotificationAlert/NotificationAlert.context.tsx +++ b/examples/CRISP/client/src/context/NotificationAlert/NotificationAlert.context.tsx @@ -85,4 +85,5 @@ const NotificationAlertProvider = ({ children }: NotificationAlertProviderProps) ) } +// eslint-disable-next-line react-refresh/only-export-components export { useNotificationAlertContext, NotificationAlertProvider } diff --git a/examples/CRISP/client/src/context/voteManagement/VoteManagement.context.tsx b/examples/CRISP/client/src/context/voteManagement/VoteManagement.context.tsx index 1299e8d105..ede1bea4ef 100644 --- a/examples/CRISP/client/src/context/voteManagement/VoteManagement.context.tsx +++ b/examples/CRISP/client/src/context/voteManagement/VoteManagement.context.tsx @@ -239,4 +239,5 @@ const VoteManagementProvider = ({ children }: VoteManagementProviderProps) => { ) } +// eslint-disable-next-line react-refresh/only-export-components export { useVoteManagementContext, VoteManagementProvider } diff --git a/examples/CRISP/client/src/pages/DailyPoll/components/ConfirmVote.tsx b/examples/CRISP/client/src/pages/DailyPoll/components/ConfirmVote.tsx index 0393c73b38..a17d3200f5 100644 --- a/examples/CRISP/client/src/pages/DailyPoll/components/ConfirmVote.tsx +++ b/examples/CRISP/client/src/pages/DailyPoll/components/ConfirmVote.tsx @@ -15,6 +15,7 @@ const ConfirmVote: React.FC<{ confirmationUrl: string }> = ({ confirmationUrl }) return () => { setTxUrl(undefined) } + // eslint-disable-next-line react-hooks/exhaustive-deps }, []) return ( diff --git a/examples/CRISP/client/src/pages/PollResult/PollResult.tsx b/examples/CRISP/client/src/pages/PollResult/PollResult.tsx index 50107fa8cd..4c5db262f8 100644 --- a/examples/CRISP/client/src/pages/PollResult/PollResult.tsx +++ b/examples/CRISP/client/src/pages/PollResult/PollResult.tsx @@ -45,12 +45,14 @@ const PollResult: React.FC = () => { setLoading(false) } } + // eslint-disable-next-line react-hooks/exhaustive-deps }, [pastPolls, roundId, roundState, activeTotalCount]) useEffect(() => { if (pollResult && loading) { setLoading(false) } + // eslint-disable-next-line react-hooks/exhaustive-deps }, [pollResult]) return ( diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json index b412e533af..641d507cc5 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json @@ -903,5 +903,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IBondingRegistry.sol", - "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" + "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json index e750d08ef2..3643b967e5 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json @@ -767,5 +767,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ICiphernodeRegistry.sol", - "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" + "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json index 1f89db3b7c..a379281110 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json @@ -163,6 +163,19 @@ "name": "E3ProgramEnabled", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes[]", + "name": "e3ProgramParams", + "type": "bytes[]" + } + ], + "name": "E3ProgramsParamsRemoved", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -420,6 +433,19 @@ "name": "RewardsDistributed", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "slashingManager", + "type": "address" + } + ], + "name": "SlashingManagerSet", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -954,6 +980,19 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "bytes[]", + "name": "_e3ProgramsParams", + "type": "bytes[]" + } + ], + "name": "removeE3ProgramsParams", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -1202,5 +1241,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IEnclave.sol", - "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" + "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json index eee9e7f5a5..d84e4f5b18 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json @@ -845,5 +845,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ISlashingManager.sol", - "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" + "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json index caa6d9312a..17d318e4f7 100644 --- a/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json +++ b/packages/enclave-contracts/artifacts/contracts/token/EnclaveTicketToken.sol/EnclaveTicketToken.json @@ -508,12 +508,12 @@ "inputs": [ { "internalType": "address", - "name": "spender", + "name": "", "type": "address" }, { "internalType": "uint256", - "name": "value", + "name": "", "type": "uint256" } ], @@ -525,7 +525,7 @@ "type": "bool" } ], - "stateMutability": "nonpayable", + "stateMutability": "pure", "type": "function" }, { @@ -919,6 +919,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "payableBalance", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -1143,72 +1156,72 @@ "type": "function" } ], - "bytecode": "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", - "deployedBytecode": "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", + "bytecode": "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", + "deployedBytecode": "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", "linkReferences": {}, "deployedLinkReferences": {}, "immutableReferences": { "3415": [ { "length": 32, - "start": 1988 + "start": 2115 }, { "length": 32, - "start": 2985 + "start": 3117 }, { "length": 32, - "start": 3290 + "start": 3422 }, { "length": 32, - "start": 3463 + "start": 3595 } ], "6684": [ { "length": 32, - "start": 3694 + "start": 3826 } ], "6686": [ { "length": 32, - "start": 3652 + "start": 3784 } ], "6688": [ { "length": 32, - "start": 3610 + "start": 3742 } ], "6690": [ { "length": 32, - "start": 3775 + "start": 3907 } ], "6692": [ { "length": 32, - "start": 3815 + "start": 3947 } ], "6695": [ { "length": 32, - "start": 4463 + "start": 4602 } ], "6698": [ { "length": 32, - "start": 4508 + "start": 4647 } ] }, "inputSourceName": "project/contracts/token/EnclaveTicketToken.sol", - "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" + "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json index 18e639df1b..49bba848aa 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/DkgPkVerifier.json @@ -102,7 +102,7 @@ } }, "immutableReferences": { - "33611": [ + "33764": [ { "length": 32, "start": 91 @@ -164,13 +164,13 @@ "start": 11964 } ], - "33613": [ + "33766": [ { "length": 32, "start": 398 } ], - "33615": [ + "33768": [ { "length": 32, "start": 432 @@ -182,5 +182,5 @@ ] }, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" + "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json index 9fd248d1e5..77f4e0d705 100644 --- a/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json +++ b/packages/enclave-contracts/artifacts/contracts/verifier/DkgPkVerifier.sol/ZKTranscriptLib.json @@ -396,5 +396,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/verifier/DkgPkVerifier.sol", - "buildInfoId": "solc-0_8_28-92d3f46ab335995fa05f4ef570c190692cc126a0" + "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" } \ No newline at end of file diff --git a/packages/enclave-contracts/contracts/E3RefundManager.sol b/packages/enclave-contracts/contracts/E3RefundManager.sol index 5806976909..05f4c8225b 100644 --- a/packages/enclave-contracts/contracts/E3RefundManager.sol +++ b/packages/enclave-contracts/contracts/E3RefundManager.sol @@ -39,13 +39,19 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { /// @notice Work value allocation configuration WorkValueAllocation internal _workAllocation; /// @notice Maps E3 ID to refund distribution - mapping(uint256 e3Id => RefundDistribution) internal _distributions; + mapping(uint256 e3Id => RefundDistribution distribution) + internal _distributions; /// @notice Tracks claims per E3 per address - mapping(uint256 e3Id => mapping(address => bool)) internal _claimed; + mapping(uint256 e3Id => mapping(address claimer => bool hasClaimed)) + internal _claimed; /// @notice Tracks number of claims made per E3 (for routeSlashedFunds guard) - mapping(uint256 e3Id => uint256) internal _claimCount; + mapping(uint256 e3Id => uint256 count) internal _claimCount; + /// @notice Tracks number of honest node claims made per E3 (for dust fix) + mapping(uint256 e3Id => uint256 count) internal _honestNodeClaimCount; + /// @notice Tracks total amount paid to honest nodes per E3 (for dust fix) + mapping(uint256 e3Id => uint256 amount) internal _totalHonestNodePaid; /// @notice Maps E3 ID to honest node addresses - mapping(uint256 e3Id => address[]) internal _honestNodes; + mapping(uint256 e3Id => address[] nodes) internal _honestNodes; //////////////////////////////////////////////////////////// // // // Modifiers // @@ -268,7 +274,16 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { require(isHonest, NotHonestNode(e3Id, msg.sender)); require(dist.honestNodeCount > 0, NoRefundAvailable(e3Id)); - amount = dist.honestNodeAmount / dist.honestNodeCount; + uint256 perNodeAmount = dist.honestNodeAmount / dist.honestNodeCount; + + _honestNodeClaimCount[e3Id]++; + if (_honestNodeClaimCount[e3Id] == dist.honestNodeCount) { + // Last claimer gets whatever remains (includes dust) + amount = dist.honestNodeAmount - _totalHonestNodePaid[e3Id]; + } else { + amount = perNodeAmount; + } + _totalHonestNodePaid[e3Id] += amount; require(amount > 0, NoRefundAvailable(e3Id)); _claimed[e3Id][msg.sender] = true; diff --git a/packages/enclave-contracts/contracts/Enclave.sol b/packages/enclave-contracts/contracts/Enclave.sol index 65243cf2b1..56ae005de7 100644 --- a/packages/enclave-contracts/contracts/Enclave.sol +++ b/packages/enclave-contracts/contracts/Enclave.sol @@ -24,6 +24,7 @@ import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; * @notice Main contract for managing Encrypted Execution Environments (E3) * @dev Coordinates E3 lifecycle including request, activation, input publishing, and output verification */ +// solhint-disable-next-line max-states-count contract Enclave is IEnclave, OwnableUpgradeable { using SafeERC20 for IERC20; @@ -83,20 +84,19 @@ contract Enclave is IEnclave, OwnableUpgradeable { mapping(uint256 e3Id => uint256 e3Payment) public e3Payments; /// @notice Maps E3 ID to its current stage - mapping(uint256 e3Id => E3Stage) internal _e3Stages; + mapping(uint256 e3Id => E3Stage stage) internal _e3Stages; /// @notice Maps E3 ID to its deadlines - mapping(uint256 e3Id => E3Deadlines) internal _e3Deadlines; + mapping(uint256 e3Id => E3Deadlines deadlines) internal _e3Deadlines; /// @notice Maps E3 ID to failure reason (if failed) - mapping(uint256 e3Id => FailureReason) internal _e3FailureReasons; + mapping(uint256 e3Id => FailureReason reason) internal _e3FailureReasons; /// @notice Maps E3 ID to requester address - mapping(uint256 e3Id => address) internal _e3Requesters; + mapping(uint256 e3Id => address requester) internal _e3Requesters; /// @notice Maps E3 ID to the fee token used at request time - /// @dev Stored per-E3 to survive global feeToken rotations (H-01 fix) - mapping(uint256 e3Id => IERC20) internal _e3FeeTokens; + mapping(uint256 e3Id => IERC20 token) internal _e3FeeTokens; /// @notice Global timeout configuration E3TimeoutConfig internal _timeoutConfig; @@ -220,7 +220,7 @@ contract Enclave is IEnclave, OwnableUpgradeable { require( msg.sender == address(ciphernodeRegistry) || msg.sender == address(slashingManager), - "Only CiphernodeRegistry or SlashingManager" + "Only Registry or SlashingMgr" ); _; } @@ -388,7 +388,6 @@ contract Enclave is IEnclave, OwnableUpgradeable { ) external returns (bool success) { E3 memory e3 = getE3(e3Id); - // C-01 fix: Verify E3 is in KeyPublished stage before accepting ciphertext E3Stage current = _e3Stages[e3Id]; require( current == E3Stage.KeyPublished, @@ -518,18 +517,16 @@ contract Enclave is IEnclave, OwnableUpgradeable { amounts[i] = amount; distributed += amount; } - // Give any division dust to the last member (C-03 fix) uint256 dust = totalAmount - distributed; if (dust > 0) { amounts[activeLength - 1] += dust; } - paymentToken.approve(address(bondingRegistry), totalAmount); + paymentToken.forceApprove(address(bondingRegistry), totalAmount); bondingRegistry.distributeRewards(paymentToken, activeNodes, amounts); - // Reset approval - paymentToken.approve(address(bondingRegistry), 0); + paymentToken.forceApprove(address(bondingRegistry), 0); emit RewardsDistributed(e3Id, activeNodes, amounts); } @@ -669,6 +666,21 @@ contract Enclave is IEnclave, OwnableUpgradeable { emit AllowedE3ProgramsParamsSet(_e3ProgramsParams); } + /// @notice Removes previously allowed E3 program parameter sets + /// @param _e3ProgramsParams Array of ABI encoded parameter sets to remove + function removeE3ProgramsParams( + bytes[] memory _e3ProgramsParams + ) public onlyOwner { + uint256 length = _e3ProgramsParams.length; + for (uint256 i; i < length; ) { + delete e3ProgramsParams[_e3ProgramsParams[i]]; + unchecked { + ++i; + } + } + emit E3ProgramsParamsRemoved(_e3ProgramsParams); + } + /// @notice Sets the E3 Refund Manager contract address /// @param _e3RefundManager The new E3 Refund Manager contract address function setE3RefundManager( @@ -692,6 +704,7 @@ contract Enclave is IEnclave, OwnableUpgradeable { "Invalid SlashingManager address" ); slashingManager = _slashingManager; + emit SlashingManagerSet(address(_slashingManager)); } /// @notice Process a failed E3 and calculate refunds @@ -708,7 +721,6 @@ contract Enclave is IEnclave, OwnableUpgradeable { address[] memory honestNodes = _getHonestNodes(e3Id); - // Use the per-E3 fee token (H-01 fix: survives global feeToken rotation) IERC20 paymentToken = _e3FeeTokens[e3Id]; paymentToken.safeTransfer(address(e3RefundManager), payment); @@ -771,7 +783,10 @@ contract Enclave is IEnclave, OwnableUpgradeable { uint256 e3Id, uint8 reason ) external onlyCiphernodeRegistryOrSlashingManager { - require(reason > 0 && reason <= 12, "Invalid failure reason"); + require( + reason > 0 && reason <= uint8(FailureReason.VerificationFailed), + "Invalid failure reason" + ); // Mark E3 as failed with the given reason _markE3FailedWithReason(e3Id, FailureReason(reason)); } diff --git a/packages/enclave-contracts/contracts/interfaces/IEnclave.sol b/packages/enclave-contracts/contracts/interfaces/IEnclave.sol index 67a0a81382..2bcf537536 100644 --- a/packages/enclave-contracts/contracts/interfaces/IEnclave.sol +++ b/packages/enclave-contracts/contracts/interfaces/IEnclave.sol @@ -153,10 +153,18 @@ interface IEnclave { /// @param e3ProgramParams Array of encoded encryption scheme parameters (e.g, for BFV) event AllowedE3ProgramsParamsSet(bytes[] e3ProgramParams); + /// @notice Emitted when E3 program parameter sets are removed. + /// @param e3ProgramParams Array of removed encryption scheme parameters. + event E3ProgramsParamsRemoved(bytes[] e3ProgramParams); + /// @notice Emitted when E3RefundManager contract is set. /// @param e3RefundManager The address of the E3RefundManager contract. event E3RefundManagerSet(address indexed e3RefundManager); + /// @notice Emitted when the SlashingManager contract is set. + /// @param slashingManager The address of the SlashingManager contract. + event SlashingManagerSet(address indexed slashingManager); + /// @notice Emitted when a failed E3 is processed for refunds. /// @param e3Id The ID of the failed E3. /// @param paymentAmount The original payment amount being refunded. @@ -307,6 +315,11 @@ interface IEnclave { /// @param _e3ProgramsParams Array of ABI encoded parameter sets to allow. function setE3ProgramsParams(bytes[] memory _e3ProgramsParams) external; + /// @notice Removes previously allowed E3 program parameter sets. + /// @dev This function revokes specific parameter sets that should no longer be allowed. + /// @param _e3ProgramsParams Array of ABI encoded parameter sets to remove. + function removeE3ProgramsParams(bytes[] memory _e3ProgramsParams) external; + //////////////////////////////////////////////////////////// // // // Get Functions // diff --git a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol index 6566356c14..dbbe28f036 100644 --- a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol +++ b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol @@ -345,7 +345,9 @@ interface ISlashingManager { * @notice Creates a new slash proposal with cryptographic proof (Lane A - permissionless) * @dev Anyone can call this for proof-based slashes. Requires the operator's ECDSA signature * over the proof payload to prevent arbitrary slashing. - * Evidence format: abi.encode(bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) + * Evidence format: + * abi.encode(bytes zkProof, bytes32[] publicInputs, + * bytes signature, uint256 chainId, uint256 proofType, address verifier) * The operator must have signed: keccak256(abi.encode(PROOF_PAYLOAD_TYPEHASH, chainId, e3Id, * proofType, keccak256(zkProof), keccak256(abi.encodePacked(publicInputs)))) * Verifications performed: diff --git a/packages/enclave-contracts/contracts/registry/BondingRegistry.sol b/packages/enclave-contracts/contracts/registry/BondingRegistry.sol index fdd151f7e8..7da4ada99c 100644 --- a/packages/enclave-contracts/contracts/registry/BondingRegistry.sol +++ b/packages/enclave-contracts/contracts/registry/BondingRegistry.sol @@ -9,6 +9,9 @@ pragma solidity >=0.8.27; import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; +import { + ReentrancyGuardUpgradeable +} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol"; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import { SafeERC20 @@ -26,7 +29,12 @@ import { EnclaveTicketToken } from "../token/EnclaveTicketToken.sol"; * @notice Implementation of the bonding registry managing operator ticket balances and license bonds * @dev Handles deposits, withdrawals, slashing, exits, and integrates with registry and slashing manager */ -contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { +// solhint-disable-next-line max-states-count +contract BondingRegistry is + IBondingRegistry, + OwnableUpgradeable, + ReentrancyGuardUpgradeable +{ using SafeERC20 for IERC20; using ExitQueueLib for ExitQueueLib.ExitQueueState; @@ -65,7 +73,8 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { /// @notice Addresses authorized to distribute rewards to operators /// @dev Multiple contracts (Enclave, E3RefundManager) need to distribute rewards. /// Each authorized distributor must approve this contract for the reward token. - mapping(address => bool) public authorizedDistributors; + mapping(address distributor => bool authorized) + public authorizedDistributors; /// @notice Treasury address that receives slashed funds address public slashedFundsTreasury; @@ -175,6 +184,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { uint64 _exitDelay ) public initializer { __Ownable_init(msg.sender); + __ReentrancyGuard_init(); setTicketToken(_ticketToken); setLicenseToken(_licenseToken); setRegistry(_registry); @@ -306,7 +316,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { /// @inheritdoc IBondingRegistry function deregisterOperator( uint256[] calldata siblingNodes - ) external noExitInProgress(msg.sender) { + ) external noExitInProgress(msg.sender) nonReentrant { Operator storage op = operators[msg.sender]; require(op.registered, NotRegistered()); @@ -354,7 +364,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { /// @inheritdoc IBondingRegistry function addTicketBalance( uint256 amount - ) external noExitInProgress(msg.sender) { + ) external noExitInProgress(msg.sender) nonReentrant { require(amount != 0, ZeroAmount()); require(operators[msg.sender].registered, NotRegistered()); @@ -373,7 +383,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { /// @inheritdoc IBondingRegistry function removeTicketBalance( uint256 amount - ) external noExitInProgress(msg.sender) { + ) external noExitInProgress(msg.sender) nonReentrant { require(amount != 0, ZeroAmount()); require(operators[msg.sender].registered, NotRegistered()); require( @@ -395,7 +405,9 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { } /// @inheritdoc IBondingRegistry - function bondLicense(uint256 amount) external noExitInProgress(msg.sender) { + function bondLicense( + uint256 amount + ) external noExitInProgress(msg.sender) nonReentrant { require(amount != 0, ZeroAmount()); uint256 balanceBefore = licenseToken.balanceOf(address(this)); @@ -418,7 +430,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { /// @inheritdoc IBondingRegistry function unbondLicense( uint256 amount - ) external noExitInProgress(msg.sender) { + ) external noExitInProgress(msg.sender) nonReentrant { require(amount != 0, ZeroAmount()); require( operators[msg.sender].licenseBond >= amount, @@ -446,7 +458,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { function claimExits( uint256 maxTicketAmount, uint256 maxLicenseAmount - ) external { + ) external nonReentrant { (uint256 ticketClaim, uint256 licenseClaim) = _exits.claimAssets( msg.sender, maxTicketAmount, @@ -575,7 +587,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { IERC20 rewardToken, address[] calldata recipients, uint256[] calldata amounts - ) external { + ) external nonReentrant { require(authorizedDistributors[msg.sender], OnlyRewardDistributor()); require(recipients.length == amounts.length, ArrayLengthMismatch()); @@ -701,7 +713,7 @@ contract BondingRegistry is IBondingRegistry, OwnableUpgradeable { function withdrawSlashedFunds( uint256 ticketAmount, uint256 licenseAmount - ) public onlyOwner { + ) public onlyOwner nonReentrant { require(ticketAmount <= slashedTicketBalance, InsufficientBalance()); require(licenseAmount <= slashedLicenseBond, InsufficientBalance()); diff --git a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol index c48ccf187f..51ee0fc3ae 100644 --- a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol +++ b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol @@ -226,6 +226,11 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { //////////////////////////////////////////////////////////// /// @inheritdoc ICiphernodeRegistry + /// @dev Uses numActiveOperators() which checks registered + minimum bond + minimum tickets. + /// Between request time and ticket submission, operators may become inactive by losing + /// bond or tickets. The check at request time may be stale by the time submitTicket + /// is called. This is appropriately conservative — it prevents requesting committees + /// when not enough operators are active even at request time. function requestCommittee( uint256 e3Id, uint256 seed, @@ -279,6 +284,10 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { // TODO: Currently we trust the owner to publish the correct committee. // TODO: Need a Proof that the public key is generated from the committee + // SECURITY: Without DKG correctness proofs, a malicious owner could publish a key they + // control, enabling decryption of all E3 results. This is a centralization assumption + // accepted for the current phase. DKG proof verification must be added before + // decentralizing the owner role. c.publicKey = publicKeyHash; publicKeyHashes[e3Id] = publicKeyHash; // Progress E3 to KeyPublished stage @@ -634,7 +643,10 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { } /// @notice Validates that a node is eligible to submit a ticket - /// @dev Uses snapshot of ticket balance at E3 request block for deterministic validation + /// @dev Uses snapshot of ticket balance at (requestBlock - 1) for deterministic validation. + /// The -1 offset prevents same-block manipulation attacks where an operator could deposit + /// tickets and submit in the same transaction. Deposits in the request block itself are + /// excluded. This is conservative but not fully settled — see TODO below. /// @param node Address of the ciphernode /// @param ticketNumber The ticket number being submitted /// @param e3Id ID of the E3 computation @@ -667,7 +679,11 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { } /// @notice Inserts a node into the top-N list - Smallest scores - /// @dev If the node is not in the top-N, it is added to the top-N. + /// @dev O(N) linear scan per insertion to find the worst score. For a committee of size N + /// with S total submissions, total gas is O(N * S). With N=20 and S=1000, this is ~20K + /// iterations at ~200 gas each (≈ 4M gas total), which is acceptable for current + /// parameters. Will not scale to N > ~50 without switching to a heap or sorted + /// data structure. /// @param c Committee storage reference /// @param node Address of the node /// @param score Score of the node diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index e08ba012e3..0e8aa59dde 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -223,13 +223,24 @@ contract SlashingManager is ISlashingManager, AccessControl { /// @inheritdoc ISlashingManager /// @dev Lane A: Permissionless proof-based slash. Anyone can call. /// Atomically proposes, verifies operator signature + ZK proof, and executes slash. - /// Evidence format: abi.encode(bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) - /// The operator must have signed: keccak256(abi.encode(PROOF_PAYLOAD_TYPEHASH, chainId, e3Id, proofType, keccak256(zkProof), keccak256(abi.encodePacked(publicInputs)))) + /// Evidence format: + /// `abi.encode(bytes zkProof, bytes32[] publicInputs, + /// bytes signature, + /// uint256 chainId, + /// uint256 proofType, + /// address verifier)` + /// The operator must have signed: + /// `keccak256(abi.encode(PROOF_PAYLOAD_TYPEHASH, + /// chainId, + /// e3Id, + /// proofType, + /// keccak256(zkProof), + /// keccak256(abi.encodePacked(publicInputs))))` /// This prevents: /// - Arbitrary proof submission (attacker can't forge operator's signature) - /// - Cross-E3 replay (e3Id is in the signed message) - /// - Cross-chain replay (chainId is in the signed message) - /// - Verifier-upgrade attacks (verifier in evidence must match policy's current verifier) + /// - Cross-E3 replay (e3Id is in the signed message)` + /// - Cross-chain replay (chainId is in the signed message)` + /// - Verifier-upgrade attacks (verifier in evidence must match policy's current verifier)` function proposeSlash( uint256 e3Id, address operator, @@ -377,7 +388,12 @@ contract SlashingManager is ISlashingManager, AccessControl { /// @dev Decodes evidence, verifies operator signature, committee membership, /// and that the ZK proof is invalid (fault confirmed). - /// Evidence format: abi.encode(bytes zkProof, bytes32[] publicInputs, bytes signature, uint256 chainId, uint256 proofType, address verifier) + /// Evidence format: + /// `abi.encode(bytes zkProof, bytes32[] publicInputs, + /// bytes signature, + /// uint256 chainId, + /// uint256 proofType, + /// address verifier)` function _verifyProofEvidence( bytes calldata proof, uint256 e3Id, @@ -432,6 +448,12 @@ contract SlashingManager is ISlashingManager, AccessControl { /** * @notice Internal function that executes a slash and handles committee expulsion + * @dev For Lane B (delayed execution), the operator may have deregistered during the appeal + * window. BondingRegistry.slashTicketBalance and slashLicenseBond use Math.min(requested, + * available), so zero-balance operators receive a zero slash gracefully. The exit queue's + * slashPendingAssets(includeLockedAssets=true) covers operators mid-exit. If the operator + * has already claimed their exit, funds are gone and the slash amount becomes 0. This is + * an accepted tradeoff for the appeal window design. * @param proposalId ID of the proposal to execute * @param policy The slash policy for this proposal */ @@ -493,6 +515,10 @@ contract SlashingManager is ISlashingManager, AccessControl { // ====================== /// @inheritdoc ISlashingManager + /// @dev Only the accused operator can file an appeal. No delegate, multi-sig, or representative + /// patterns exist. If the operator has lost access to their key or been banned, they cannot + /// appeal. Consider adding an appealDelegate mapping for production to allow a designated + /// representative to appeal on behalf of the operator. function fileAppeal(uint256 proposalId, string calldata evidence) external { require(proposalId < totalProposals, InvalidProposal()); SlashProposal storage p = _proposals[proposalId]; diff --git a/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol b/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol index 09c23abb86..a16cdc38cf 100644 --- a/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol +++ b/packages/enclave-contracts/contracts/test/MockCiphernodeRegistry.sol @@ -11,7 +11,7 @@ import { IBondingRegistry } from "../interfaces/IBondingRegistry.sol"; contract MockCiphernodeRegistry is ICiphernodeRegistry { /// @notice Configurable committee members per E3 for testing - mapping(uint256 => address[]) private _committeeNodes; + mapping(uint256 e3Id => address[] nodes) private _committeeNodes; /// @notice Set committee members for an E3 (test helper) function setCommitteeNodes( diff --git a/packages/enclave-contracts/contracts/token/EnclaveTicketToken.sol b/packages/enclave-contracts/contracts/token/EnclaveTicketToken.sol index 9d932d6a66..b7be111ef8 100644 --- a/packages/enclave-contracts/contracts/token/EnclaveTicketToken.sol +++ b/packages/enclave-contracts/contracts/token/EnclaveTicketToken.sol @@ -57,6 +57,10 @@ contract EnclaveTicketToken is /// @dev Only this contract can call restricted functions like depositFor, withdrawTo, burnTickets, and payout address public registry; + /// @notice Tracks slashed funds available for payout (L-12 defense-in-depth) + /// @dev Incremented by burnTickets, decremented by payout. Prevents payout exceeding slashed amount. + uint256 public payableBalance; + /// @notice Restricts function access to only the registry contract /// @dev Reverts with NotRegistry if caller is not the registry address modifier onlyRegistry() { @@ -101,6 +105,7 @@ contract EnclaveTicketToken is * @dev Only callable by the registry contract. Transfers underlying tokens from the registry to * this contract and mints an equivalent amount of ticket tokens. Automatically delegates * voting power to the operator on their first deposit to enable voting power tracking. + * Combined with delegate() reverting DelegationLocked(), operators permanently self-delegate. * @param operator Address to receive the minted ticket tokens * @param amount Number of underlying tokens to deposit and ticket tokens to mint * @return success True if the deposit and minting succeeded @@ -172,6 +177,7 @@ contract EnclaveTicketToken is address operator, uint256 amount ) external onlyRegistry { + payableBalance += amount; _burn(operator, amount); } @@ -182,9 +188,18 @@ contract EnclaveTicketToken is * @param amount Amount of ticket tokens to payout. */ function payout(address to, uint256 amount) external onlyRegistry { + require(amount <= payableBalance, "Exceeds payable balance"); + payableBalance -= amount; SafeERC20.safeTransfer(IERC20(address(underlying())), to, amount); } + /** + * @dev Override approve to revert — ticket tokens are non-transferable. + */ + function approve(address, uint256) public pure override returns (bool) { + revert TransferNotAllowed(); + } + /** * @dev Override ERC20Votes update hook to prevent transfers between users. */ diff --git a/packages/enclave-contracts/contracts/token/EnclaveToken.sol b/packages/enclave-contracts/contracts/token/EnclaveToken.sol index f1e5534008..0443d2d218 100644 --- a/packages/enclave-contracts/contracts/token/EnclaveToken.sol +++ b/packages/enclave-contracts/contracts/token/EnclaveToken.sol @@ -60,7 +60,6 @@ contract EnclaveToken is bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); /// @notice Tracks the cumulative amount of tokens minted since deployment - /// @dev Incremented with each mint operation to enforce MAX_SUPPLY cap uint256 public totalMinted; /// @notice Mapping of addresses permitted to transfer tokens when restrictions are active @@ -158,6 +157,7 @@ contract EnclaveToken is for (uint256 i = 0; i < len; i++) { address recipient = recipients[i]; uint256 amount = amounts[i]; + if (recipient == address(0)) revert ZeroAddress(); if (amount == 0) revert ZeroAmount(); if (amount > MAX_SUPPLY - minted) revert ExceedsTotalSupply(); @@ -222,6 +222,7 @@ contract EnclaveToken is * @dev Overrides ERC20 and ERC20Votes to add transfer restriction logic. Reverts if transfers * are restricted and neither sender nor receiver is whitelisted. Minting (from == 0) and * burning (to == 0) are always allowed regardless of restrictions. + * * @param from Address sending tokens (zero address for minting) * @param to Address receiving tokens (zero address for burning) * @param value Amount of tokens being transferred diff --git a/packages/enclave-contracts/ignition/modules/slashingManager.ts b/packages/enclave-contracts/ignition/modules/slashingManager.ts index 2a4c8abbbf..e44ad80287 100644 --- a/packages/enclave-contracts/ignition/modules/slashingManager.ts +++ b/packages/enclave-contracts/ignition/modules/slashingManager.ts @@ -3,8 +3,6 @@ // This file is provided WITHOUT ANY WARRANTY; // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. - -/* eslint-disable @typescript-eslint/no-explicit-any */ import { buildModule } from "@nomicfoundation/hardhat-ignition/modules"; export default buildModule("SlashingManager", (m) => { diff --git a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts index 5d47eda3ba..f96574724a 100644 --- a/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts +++ b/packages/enclave-contracts/test/Slashing/SlashingManager.spec.ts @@ -23,7 +23,6 @@ import { SlashingManager__factory as SlashingManagerFactory, } from "../../types"; import type { MockCircuitVerifier } from "../../types"; -import type { MockCiphernodeRegistry } from "../../types"; import type { SlashingManager } from "../../types/contracts/slashing/SlashingManager"; const { ethers, networkHelpers, ignition } = await network.connect(); @@ -719,7 +718,6 @@ describe("SlashingManager", function () { operator, operatorAddress, mockVerifier, - mockCiphernodeRegistry, } = await loadFixture(setup); const verifierAddress = await mockVerifier.getAddress(); diff --git a/templates/default/client/src/context/WizardContext.tsx b/templates/default/client/src/context/WizardContext.tsx index 2a239998ec..32c6fbbd21 100644 --- a/templates/default/client/src/context/WizardContext.tsx +++ b/templates/default/client/src/context/WizardContext.tsx @@ -13,6 +13,7 @@ import { getEnclaveSDKConfig } from '@/utils/sdk-config' // TYPES & ENUMS // ============================================================================ +// eslint-disable-next-line react-refresh/only-export-components export enum WizardStep { CONNECT_WALLET = 1, REQUEST_COMPUTATION = 2, @@ -61,6 +62,7 @@ interface WizardContextType { const WizardContext = createContext(undefined) +// eslint-disable-next-line react-refresh/only-export-components export const useWizard = () => { const context = useContext(WizardContext) if (!context) { @@ -104,6 +106,7 @@ export const WizardProvider: React.FC = ({ children }) => { }) // Auto-advance steps based on state. + /* eslint-disable react-hooks/set-state-in-effect */ useEffect(() => { if (!isConnected) { setCurrentStep(WizardStep.CONNECT_WALLET) @@ -111,6 +114,7 @@ export const WizardProvider: React.FC = ({ children }) => { setCurrentStep(WizardStep.REQUEST_COMPUTATION) } }, [isConnected, sdk.isInitialized, currentStep]) + /* eslint-enable react-hooks/set-state-in-effect */ const handleReset = useCallback(() => { setCurrentStep(WizardStep.CONNECT_WALLET) diff --git a/templates/default/client/src/pages/steps/RequestComputation.tsx b/templates/default/client/src/pages/steps/RequestComputation.tsx index 2b06cbc524..efbb0015a2 100644 --- a/templates/default/client/src/pages/steps/RequestComputation.tsx +++ b/templates/default/client/src/pages/steps/RequestComputation.tsx @@ -75,7 +75,7 @@ const RequestComputation: React.FC = () => { off(EnclaveEventType.E3_REQUESTED, handleE3Requested) off(RegistryEventType.COMMITTEE_PUBLISHED, handleCommitteePublished) } - }, [isInitialized, onEnclaveEvent, off, EnclaveEventType, RegistryEventType]) + }, [isInitialized, onEnclaveEvent, off, EnclaveEventType, RegistryEventType, setE3State]) // Auto-advance to next step when committee publishes useEffect(() => { From 97eb21e2ab739ce3e37d7ec2d41935a9c640dc03 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Fri, 20 Feb 2026 22:37:36 +0500 Subject: [PATCH 20/32] chore: update contract addresses --- examples/CRISP/enclave.config.yaml | 13 +- .../packages/crisp-contracts/deploy/deploy.ts | 1 + .../crisp-contracts/deployed_contracts.json | 150 ++++++++++++++++++ .../ISlashingManager.json | 2 +- .../enclave-contracts/deployed_contracts.json | 136 ++++++++++++++++ .../scripts/deployEnclave.ts | 2 + packages/enclave-contracts/scripts/utils.ts | 1 + templates/default/enclave.config.yaml | 4 +- 8 files changed, 301 insertions(+), 8 deletions(-) diff --git a/examples/CRISP/enclave.config.yaml b/examples/CRISP/enclave.config.yaml index 976928cd43..71e18d12b6 100644 --- a/examples/CRISP/enclave.config.yaml +++ b/examples/CRISP/enclave.config.yaml @@ -3,20 +3,23 @@ chains: rpc_url: ws://localhost:8545 contracts: e3_program: - address: '0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB' + address: '0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8' deploy_block: 37 enclave: address: '0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0' - deploy_block: 15 + deploy_block: 13 ciphernode_registry: address: '0x610178dA211FEF7D417bC0e6FeD39F05609AD788' - deploy_block: 13 + deploy_block: 11 bonding_registry: address: '0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6' - deploy_block: 10 + deploy_block: 8 fee_token: address: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0' - deploy_block: 5 + deploy_block: 4 + slashing_manager: + address: '0x0165878A594ca255338adfa4d48449f69242Eb8F' + deploy_block: 8 program: dev: true nodes: diff --git a/examples/CRISP/packages/crisp-contracts/deploy/deploy.ts b/examples/CRISP/packages/crisp-contracts/deploy/deploy.ts index 90f7a359fd..5582d17bb0 100644 --- a/examples/CRISP/packages/crisp-contracts/deploy/deploy.ts +++ b/examples/CRISP/packages/crisp-contracts/deploy/deploy.ts @@ -16,6 +16,7 @@ const contractMapping: Record = { Enclave: 'enclave', CiphernodeRegistryOwnable: 'ciphernode_registry', BondingRegistry: 'bonding_registry', + SlashingManager: 'slashing_manager', MockUSDC: 'fee_token', } diff --git a/examples/CRISP/packages/crisp-contracts/deployed_contracts.json b/examples/CRISP/packages/crisp-contracts/deployed_contracts.json index 43557cade4..98a62ff20d 100644 --- a/examples/CRISP/packages/crisp-contracts/deployed_contracts.json +++ b/examples/CRISP/packages/crisp-contracts/deployed_contracts.json @@ -154,5 +154,155 @@ "address": "0x6d97bDf6741905F63bd99e0EB920FFe5e5498544", "blockNumber": 10285602 } + }, + "localhost": { + "PoseidonT3": { + "blockNumber": 3, + "address": "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93" + }, + "MockUSDC": { + "constructorArgs": { + "initialSupply": "1000000" + }, + "blockNumber": 4, + "address": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0" + }, + "EnclaveToken": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + }, + "blockNumber": 5, + "address": "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9" + }, + "EnclaveTicketToken": { + "constructorArgs": { + "baseToken": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0", + "registry": "0x0000000000000000000000000000000000000001", + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + }, + "blockNumber": 7, + "address": "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707" + }, + "SlashingManager": { + "constructorArgs": { + "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "bondingRegistry": "0x0000000000000000000000000000000000000001", + "ciphernodeRegistry": "0x0000000000000000000000000000000000000001", + "enclave": "0x0000000000000000000000000000000000000001" + }, + "blockNumber": 8, + "address": "0x0165878A594ca255338adfa4d48449f69242Eb8F" + }, + "BondingRegistry": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "ticketToken": "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707", + "licenseToken": "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9", + "registry": "0x0000000000000000000000000000000000000001", + "slashedFundsTreasury": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "ticketPrice": "10000000", + "licenseRequiredBond": "100000000000000000000", + "minTicketBalance": "1", + "exitDelay": "604800" + }, + "proxyRecords": { + "initData": "0x7333fa82000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660000000000000000000000005fc8d32690cc91d4c39d9d3abcbd16989f875707000000000000000000000000cf7ed3acca5a467e9e704c703e8d87f634fb0fc90000000000000000000000000000000000000000000000000000000000000001000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb9226600000000000000000000000000000000000000000000000000000000009896800000000000000000000000000000000000000000000000056bc75e2d6310000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000093a80", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6", + "proxyAdminAddress": "0x94099942864EA81cCF197E9D71ac53310b1468D8", + "implementationAddress": "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853" + }, + "blockNumber": 8, + "address": "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6" + }, + "CiphernodeRegistryOwnable": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "enclaveAddress": "0x0000000000000000000000000000000000000001", + "submissionWindow": "10" + }, + "proxyRecords": { + "initData": "0x1794bb3c000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000a", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0x610178dA211FEF7D417bC0e6FeD39F05609AD788", + "proxyAdminAddress": "0x6F1216D1BFe15c98520CA1434FC1d9D57AC95321", + "implementationAddress": "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318" + }, + "blockNumber": 11, + "address": "0x610178dA211FEF7D417bC0e6FeD39F05609AD788" + }, + "Enclave": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "registry": "0x610178dA211FEF7D417bC0e6FeD39F05609AD788", + "bondingRegistry": "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6", + "e3RefundManager": "0x0000000000000000000000000000000000000001", + "feeToken": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0", + "maxDuration": "2592000", + "timeoutConfig": "{\"committeeFormationWindow\":3600,\"dkgWindow\":7200,\"computeWindow\":86400,\"decryptionWindow\":3600,\"gracePeriod\":600}", + "params": [ + "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000ffffee0010000000000000000000000000000000000000000000000000000000ffffc400100000000000000000000000000000000000000000000000000000000000000013300000000000000000000000000000000000000000000000000000000000000" + ] + }, + "proxyRecords": { + "initData": "0x69c5b347000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000610178da211fef7d417bc0e6fed39f05609ad7880000000000000000000000002279b7a0a67db372996a5fab50d91eaa73d2ebe600000000000000000000000000000000000000000000000000000000000000010000000000000000000000009fe46736679d2d9a65f0992f2272de9f3c7fa6e00000000000000000000000000000000000000000000000000000000000278d000000000000000000000000000000000000000000000000000000000000001c2000000000000000000000000000000000000000000000000000000000000151800000000000000000000000000000000000000000000000000000000000000e1000000000000000000000000000000000000000000000000000000000000002580000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000ffffee0010000000000000000000000000000000000000000000000000000000ffffc400100000000000000000000000000000000000000000000000000000000000000013300000000000000000000000000000000000000000000000000000000000000", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0", + "proxyAdminAddress": "0x1F708C24a0D3A740cD47cC0444E9480899f3dA7D", + "implementationAddress": "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e" + }, + "blockNumber": 13, + "address": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0" + }, + "E3RefundManager": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "enclave": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0", + "treasury": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + }, + "proxyRecords": { + "initData": "0xc0c53b8b000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000a51c1fc2f0d1a1b8494ed1fe312d7c3a78ed91c0000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0x9A676e781A523b5d0C0e43731313A708CB607508", + "proxyAdminAddress": "0x8e80FFe6Dc044F4A766Afd6e5a8732Fe0977A493", + "implementationAddress": "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82" + }, + "blockNumber": 15, + "address": "0x9A676e781A523b5d0C0e43731313A708CB607508" + }, + "MockComputeProvider": { + "blockNumber": 29, + "address": "0x09635F643e140090A9A8Dcd712eD6285858ceBef" + }, + "MockDecryptionVerifier": { + "blockNumber": 30, + "address": "0xc5a5C42992dECbae36851359345FE25997F5C42d" + }, + "MockE3Program": { + "blockNumber": 31, + "address": "0x67d269191c92Caf3cD7723F116c85e6E9bf55933" + }, + "MockRISC0Verifier": { + "address": "0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB", + "blockNumber": 34 + }, + "HonkVerifier": { + "address": "0xa82fF9aFd8f496c3d6ac40E2a0F282E47488CFc9", + "blockNumber": 36 + }, + "CRISPProgram": { + "address": "0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8", + "blockNumber": 37, + "constructorArgs": { + "enclave": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0", + "verifierAddress": "0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB", + "honkVerifierAddress": "0xa82fF9aFd8f496c3d6ac40E2a0F282E47488CFc9", + "imageId": "0x23734b77b0f76e85623a88d7a82f24c34c94834f2501964ea123b7a2027013a2" + } + }, + "MockVotingToken": { + "address": "0xf5059a5D33d5853360D16C683c16e67980206f36", + "blockNumber": 39 + } } } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json index d84e4f5b18..cac6ebdc68 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json @@ -845,5 +845,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ISlashingManager.sol", - "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" + "buildInfoId": "solc-0_8_28-b3b58155055b32b4d831cf2920825ceb07ed106a" } \ No newline at end of file diff --git a/packages/enclave-contracts/deployed_contracts.json b/packages/enclave-contracts/deployed_contracts.json index 703194cdfb..2e5973e418 100644 --- a/packages/enclave-contracts/deployed_contracts.json +++ b/packages/enclave-contracts/deployed_contracts.json @@ -132,5 +132,141 @@ "blockNumber": 10279540, "address": "0xB886C067e9C1D2B31461F4DFd29f557B5714297d" } + }, + "localhost": { + "PoseidonT3": { + "blockNumber": 3, + "address": "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93" + }, + "MockUSDC": { + "constructorArgs": { + "initialSupply": "1000000" + }, + "blockNumber": 4, + "address": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0" + }, + "EnclaveToken": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + }, + "blockNumber": 5, + "address": "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9" + }, + "EnclaveTicketToken": { + "constructorArgs": { + "baseToken": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0", + "registry": "0x0000000000000000000000000000000000000001", + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + }, + "blockNumber": 7, + "address": "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707" + }, + "SlashingManager": { + "constructorArgs": { + "admin": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "bondingRegistry": "0x0000000000000000000000000000000000000001", + "ciphernodeRegistry": "0x0000000000000000000000000000000000000001", + "enclave": "0x0000000000000000000000000000000000000001" + }, + "blockNumber": 8, + "address": "0x0165878A594ca255338adfa4d48449f69242Eb8F" + }, + "BondingRegistry": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "ticketToken": "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707", + "licenseToken": "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9", + "registry": "0x0000000000000000000000000000000000000001", + "slashedFundsTreasury": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "ticketPrice": "10000000", + "licenseRequiredBond": "100000000000000000000", + "minTicketBalance": "1", + "exitDelay": "604800" + }, + "proxyRecords": { + "initData": "0x7333fa82000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660000000000000000000000005fc8d32690cc91d4c39d9d3abcbd16989f875707000000000000000000000000cf7ed3acca5a467e9e704c703e8d87f634fb0fc90000000000000000000000000000000000000000000000000000000000000001000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb9226600000000000000000000000000000000000000000000000000000000009896800000000000000000000000000000000000000000000000056bc75e2d6310000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000093a80", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6", + "proxyAdminAddress": "0x94099942864EA81cCF197E9D71ac53310b1468D8", + "implementationAddress": "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853" + }, + "blockNumber": 8, + "address": "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6" + }, + "CiphernodeRegistryOwnable": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "enclaveAddress": "0x0000000000000000000000000000000000000001", + "submissionWindow": "10" + }, + "proxyRecords": { + "initData": "0x1794bb3c000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000a", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0x610178dA211FEF7D417bC0e6FeD39F05609AD788", + "proxyAdminAddress": "0x6F1216D1BFe15c98520CA1434FC1d9D57AC95321", + "implementationAddress": "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318" + }, + "blockNumber": 11, + "address": "0x610178dA211FEF7D417bC0e6FeD39F05609AD788" + }, + "Enclave": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "registry": "0x610178dA211FEF7D417bC0e6FeD39F05609AD788", + "bondingRegistry": "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6", + "e3RefundManager": "0x0000000000000000000000000000000000000001", + "feeToken": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0", + "maxDuration": "2592000", + "timeoutConfig": "{\"committeeFormationWindow\":3600,\"dkgWindow\":7200,\"computeWindow\":86400,\"decryptionWindow\":3600,\"gracePeriod\":600}", + "params": [ + "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000ffffee0010000000000000000000000000000000000000000000000000000000ffffc400100000000000000000000000000000000000000000000000000000000000000013300000000000000000000000000000000000000000000000000000000000000" + ] + }, + "proxyRecords": { + "initData": "0x69c5b347000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000610178da211fef7d417bc0e6fed39f05609ad7880000000000000000000000002279b7a0a67db372996a5fab50d91eaa73d2ebe600000000000000000000000000000000000000000000000000000000000000010000000000000000000000009fe46736679d2d9a65f0992f2272de9f3c7fa6e00000000000000000000000000000000000000000000000000000000000278d000000000000000000000000000000000000000000000000000000000000001c2000000000000000000000000000000000000000000000000000000000000151800000000000000000000000000000000000000000000000000000000000000e1000000000000000000000000000000000000000000000000000000000000002580000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000ffffee0010000000000000000000000000000000000000000000000000000000ffffc400100000000000000000000000000000000000000000000000000000000000000013300000000000000000000000000000000000000000000000000000000000000", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0", + "proxyAdminAddress": "0x1F708C24a0D3A740cD47cC0444E9480899f3dA7D", + "implementationAddress": "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e" + }, + "blockNumber": 13, + "address": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0" + }, + "E3RefundManager": { + "constructorArgs": { + "owner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "enclave": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0", + "treasury": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + }, + "proxyRecords": { + "initData": "0xc0c53b8b000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266000000000000000000000000a51c1fc2f0d1a1b8494ed1fe312d7c3a78ed91c0000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "initialOwner": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + "proxyAddress": "0x9A676e781A523b5d0C0e43731313A708CB607508", + "proxyAdminAddress": "0x8e80FFe6Dc044F4A766Afd6e5a8732Fe0977A493", + "implementationAddress": "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82" + }, + "blockNumber": 15, + "address": "0x9A676e781A523b5d0C0e43731313A708CB607508" + }, + "MockComputeProvider": { + "blockNumber": 29, + "address": "0x09635F643e140090A9A8Dcd712eD6285858ceBef" + }, + "MockDecryptionVerifier": { + "blockNumber": 30, + "address": "0xc5a5C42992dECbae36851359345FE25997F5C42d" + }, + "MockE3Program": { + "blockNumber": 31, + "address": "0x67d269191c92Caf3cD7723F116c85e6E9bf55933" + }, + "ZKTranscriptLib": { + "blockNumber": 34, + "address": "0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB" + }, + "DkgPkVerifier": { + "blockNumber": 35, + "address": "0x9E545E3C0baAB3E08CdfD552C960A1050f373042" + } } } \ No newline at end of file diff --git a/packages/enclave-contracts/scripts/deployEnclave.ts b/packages/enclave-contracts/scripts/deployEnclave.ts index 00013dbdc3..d43b0522a9 100644 --- a/packages/enclave-contracts/scripts/deployEnclave.ts +++ b/packages/enclave-contracts/scripts/deployEnclave.ts @@ -102,6 +102,8 @@ export const deployEnclave = async (withMocks?: boolean) => { const { slashingManager } = await deployAndSaveSlashingManager({ admin: ownerAddress, bondingRegistry: addressOne, + ciphernodeRegistry: addressOne, + enclave: addressOne, hre, }); const slashingManagerAddress = await slashingManager.getAddress(); diff --git a/packages/enclave-contracts/scripts/utils.ts b/packages/enclave-contracts/scripts/utils.ts index a86684fe5d..53ca1ab1d4 100644 --- a/packages/enclave-contracts/scripts/utils.ts +++ b/packages/enclave-contracts/scripts/utils.ts @@ -39,6 +39,7 @@ export interface EnclaveConfig { enclave?: { address: string; deploy_block: number }; ciphernode_registry?: { address: string; deploy_block: number }; bonding_registry?: { address: string; deploy_block: number }; + slashing_manager?: { address: string; deploy_block: number }; fee_token?: { address: string; deploy_block: number }; }; }>; diff --git a/templates/default/enclave.config.yaml b/templates/default/enclave.config.yaml index 1ab0ad3071..c6fc5d7ec4 100644 --- a/templates/default/enclave.config.yaml +++ b/templates/default/enclave.config.yaml @@ -15,8 +15,8 @@ chains: address: "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6" deploy_block: 1 # Set to actual deploy block slashing_manager: - address: "0x0000000000000000000000000000000000000000" - deploy_block: 1 # Set to actual deploy block + address: '0x0165878A594ca255338adfa4d48449f69242Eb8F' + deploy_block: 8 fee_token: address: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0" deploy_block: 1 # Set to actual deploy block From abf791c25b6a4eba09df04a3b6c8274c4c7795e3 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 21 Feb 2026 00:41:45 +0500 Subject: [PATCH 21/32] fix: slashing manager tests --- .../IBondingRegistry.json | 2 +- .../ICiphernodeRegistry.json | 2 +- .../interfaces/IEnclave.sol/IEnclave.json | 17 +- .../ISlashingManager.json | 2 +- .../enclave-contracts/contracts/Enclave.sol | 1 - .../contracts/interfaces/IEnclave.sol | 1 - .../registry/CiphernodeRegistryOwnable.sol | 2 +- .../ignition/modules/enclave.ts | 1 - .../scripts/deployAndSave/enclave.ts | 1 - .../scripts/deployEnclave.ts | 1 - .../test/E3Lifecycle/E3Integration.spec.ts | 1 - .../enclave-contracts/test/Enclave.spec.ts | 5 +- .../CiphernodeRegistryOwnable.spec.ts | 1 - .../test/Slashing/CommitteeExpulsion.spec.ts | 211 +++++++----------- 14 files changed, 87 insertions(+), 161 deletions(-) diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json index 641d507cc5..b87aa0ec93 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IBondingRegistry.sol/IBondingRegistry.json @@ -903,5 +903,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IBondingRegistry.sol", - "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" + "buildInfoId": "solc-0_8_28-2d0c0fb6cf254d92756645139041fc1083954efa" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json index 3643b967e5..28e91369d8 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ICiphernodeRegistry.sol/ICiphernodeRegistry.json @@ -767,5 +767,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ICiphernodeRegistry.sol", - "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" + "buildInfoId": "solc-0_8_28-2d0c0fb6cf254d92756645139041fc1083954efa" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json index a379281110..2bfe082fbd 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/IEnclave.sol/IEnclave.json @@ -465,11 +465,6 @@ "internalType": "uint256", "name": "decryptionWindow", "type": "uint256" - }, - { - "internalType": "uint256", - "name": "gracePeriod", - "type": "uint256" } ], "indexed": false, @@ -839,11 +834,6 @@ "internalType": "uint256", "name": "decryptionWindow", "type": "uint256" - }, - { - "internalType": "uint256", - "name": "gracePeriod", - "type": "uint256" } ], "internalType": "struct IEnclave.E3TimeoutConfig", @@ -1217,11 +1207,6 @@ "internalType": "uint256", "name": "decryptionWindow", "type": "uint256" - }, - { - "internalType": "uint256", - "name": "gracePeriod", - "type": "uint256" } ], "internalType": "struct IEnclave.E3TimeoutConfig", @@ -1241,5 +1226,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/IEnclave.sol", - "buildInfoId": "solc-0_8_28-2c25095d1e3a91525c0c4b9447ccae8788bab93f" + "buildInfoId": "solc-0_8_28-2d0c0fb6cf254d92756645139041fc1083954efa" } \ No newline at end of file diff --git a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json index cac6ebdc68..6ba870c913 100644 --- a/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json +++ b/packages/enclave-contracts/artifacts/contracts/interfaces/ISlashingManager.sol/ISlashingManager.json @@ -845,5 +845,5 @@ "deployedLinkReferences": {}, "immutableReferences": {}, "inputSourceName": "project/contracts/interfaces/ISlashingManager.sol", - "buildInfoId": "solc-0_8_28-b3b58155055b32b4d831cf2920825ceb07ed106a" + "buildInfoId": "solc-0_8_28-2d0c0fb6cf254d92756645139041fc1083954efa" } \ No newline at end of file diff --git a/packages/enclave-contracts/contracts/Enclave.sol b/packages/enclave-contracts/contracts/Enclave.sol index 56ae005de7..d5e8abbbd6 100644 --- a/packages/enclave-contracts/contracts/Enclave.sol +++ b/packages/enclave-contracts/contracts/Enclave.sol @@ -945,7 +945,6 @@ contract Enclave is IEnclave, OwnableUpgradeable { require(config.dkgWindow > 0, "Invalid DKG window"); require(config.computeWindow > 0, "Invalid compute window"); require(config.decryptionWindow > 0, "Invalid decryption window"); - require(config.gracePeriod > 0, "Invalid grace period"); _timeoutConfig = config; diff --git a/packages/enclave-contracts/contracts/interfaces/IEnclave.sol b/packages/enclave-contracts/contracts/interfaces/IEnclave.sol index 2bcf537536..f96d76a2a0 100644 --- a/packages/enclave-contracts/contracts/interfaces/IEnclave.sol +++ b/packages/enclave-contracts/contracts/interfaces/IEnclave.sol @@ -59,7 +59,6 @@ interface IEnclave { uint256 dkgWindow; uint256 computeWindow; uint256 decryptionWindow; - uint256 gracePeriod; } /// @notice Deadlines for each E3 diff --git a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol index 51ee0fc3ae..bf574d0ec6 100644 --- a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol +++ b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol @@ -376,7 +376,7 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { require(c.initialized, CommitteeNotRequested()); require(!c.finalized, CommitteeAlreadyFinalized()); require( - block.timestamp >= c.committeeDeadline, + block.timestamp > c.committeeDeadline, SubmissionWindowNotClosed() ); c.finalized = true; diff --git a/packages/enclave-contracts/ignition/modules/enclave.ts b/packages/enclave-contracts/ignition/modules/enclave.ts index 9f216e7544..e6990e143f 100644 --- a/packages/enclave-contracts/ignition/modules/enclave.ts +++ b/packages/enclave-contracts/ignition/modules/enclave.ts @@ -18,7 +18,6 @@ export default buildModule("Enclave", (m) => { dkgWindow: 7200, computeWindow: 86400, decryptionWindow: 3600, - gracePeriod: 600, }); const enclaveImpl = m.contract("Enclave", []); diff --git a/packages/enclave-contracts/scripts/deployAndSave/enclave.ts b/packages/enclave-contracts/scripts/deployAndSave/enclave.ts index ff60f4217c..b8aa4f0dfd 100644 --- a/packages/enclave-contracts/scripts/deployAndSave/enclave.ts +++ b/packages/enclave-contracts/scripts/deployAndSave/enclave.ts @@ -21,7 +21,6 @@ export interface E3TimeoutConfig { dkgWindow: number; computeWindow: number; decryptionWindow: number; - gracePeriod: number; } /** diff --git a/packages/enclave-contracts/scripts/deployEnclave.ts b/packages/enclave-contracts/scripts/deployEnclave.ts index d43b0522a9..8da5a2668d 100644 --- a/packages/enclave-contracts/scripts/deployEnclave.ts +++ b/packages/enclave-contracts/scripts/deployEnclave.ts @@ -26,7 +26,6 @@ const DEFAULT_TIMEOUT_CONFIG = { dkgWindow: 7200, computeWindow: 86400, decryptionWindow: 3600, - gracePeriod: 600, }; /** diff --git a/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts b/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts index 8c55add5c3..e42635d1cb 100644 --- a/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts +++ b/packages/enclave-contracts/test/E3Lifecycle/E3Integration.spec.ts @@ -56,7 +56,6 @@ describe("E3 Integration - Refund/Timeout Mechanism", function () { dkgWindow: ONE_DAY, computeWindow: THREE_DAYS, decryptionWindow: ONE_DAY, - gracePeriod: ONE_HOUR, }; const abiCoder = ethers.AbiCoder.defaultAbiCoder(); diff --git a/packages/enclave-contracts/test/Enclave.spec.ts b/packages/enclave-contracts/test/Enclave.spec.ts index 2534b89074..43446b05ec 100644 --- a/packages/enclave-contracts/test/Enclave.spec.ts +++ b/packages/enclave-contracts/test/Enclave.spec.ts @@ -43,7 +43,6 @@ describe("Enclave", function () { dkgWindow: 3600, // 1 hour computeWindow: 3600, // 1 hour decryptionWindow: 3600, // 1 hour - gracePeriod: 300, // 5 minutes }; const inputWindowDuration = 300; @@ -935,9 +934,9 @@ describe("Enclave", function () { await expect(enclave.publishCiphertextOutput(e3Id, data, proof)) .to.be.revertedWithCustomError( enclave, - "CiphertextOutputAlreadyPublished", + "InvalidStage", ) - .withArgs(e3Id); + .withArgs(e3Id, 3, 4); }); it("reverts if committee duties are over", async function () { const { diff --git a/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts b/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts index dacd5637f4..570395f84f 100644 --- a/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts +++ b/packages/enclave-contracts/test/Registry/CiphernodeRegistryOwnable.spec.ts @@ -177,7 +177,6 @@ describe("CiphernodeRegistryOwnable", function () { dkgWindow: 3600, computeWindow: 3600, decryptionWindow: 3600, - gracePeriod: 300, }, }, }, diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts index 88e71b16fc..229ca57e4a 100644 --- a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -77,14 +77,49 @@ describe("Committee Expulsion & Fault Tolerance", function () { dkgWindow: ONE_DAY, computeWindow: THREE_DAYS, decryptionWindow: ONE_DAY, - gracePeriod: ONE_HOUR, }; - function encodeProof( + // Must match the PROOF_PAYLOAD_TYPEHASH in SlashingManager.sol + const PROOF_PAYLOAD_TYPEHASH = ethers.keccak256( + ethers.toUtf8Bytes( + "ProofPayload(uint256 chainId,uint256 e3Id,uint256 proofType,bytes zkProof,bytes publicSignals)", + ), + ); + + /** + * Helper to create a signed proof evidence bundle. + * The operator signs the proof payload (matching SlashingManager._verifyProofEvidence), + * then the evidence is encoded in the 6-field format expected by proposeSlash(). + */ + async function signAndEncodeProof( + signer: Signer, + e3Id: number, + verifierAddress: string, zkProof: string = "0x1234", publicInputs: string[] = [ethers.ZeroHash], - ): string { - return abiCoder.encode(["bytes", "bytes32[]"], [zkProof, publicInputs]); + chainId: number = 31337, + proofType: number = 0, + ): Promise { + const messageHash = ethers.keccak256( + abiCoder.encode( + ["bytes32", "uint256", "uint256", "uint256", "bytes32", "bytes32"], + [ + PROOF_PAYLOAD_TYPEHASH, + chainId, + e3Id, + proofType, + ethers.keccak256(zkProof), + ethers.keccak256( + ethers.solidityPacked(["bytes32[]"], [publicInputs]), + ), + ], + ), + ); + const signature = await signer.signMessage(ethers.getBytes(messageHash)); + return abiCoder.encode( + ["bytes", "bytes32[]", "bytes", "uint256", "uint256", "address"], + [zkProof, publicInputs, signature, chainId, proofType, verifierAddress], + ); } const setup = async () => { @@ -335,6 +370,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { } await time.increase(SORTITION_SUBMISSION_WINDOW + 1); await registry.finalizeCommittee(e3Id); + + // Publish the committee key so getCommitteeNodes works + const nodes = await Promise.all(operators.map((op) => op.getAddress())); + const publicKey = ethers.toUtf8Bytes("fake-public-key"); + const publicKeyHash = ethers.keccak256(publicKey); + await registry.publishCommittee(e3Id, nodes, publicKey, publicKeyHash); } // Set up committee-affecting slash policy @@ -394,6 +435,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { const { registry, slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -422,7 +464,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { // Submit slash proposal — MockCircuitVerifier returns false by default // so fault is confirmed and slash is auto-executed - const proof = encodeProof(); + const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); const tx = await slashingManager.proposeSlash( 0, op1Address, @@ -448,7 +490,9 @@ describe("Committee Expulsion & Fault Tolerance", function () { it("should keep E3 alive when active members >= threshold", async function () { const { enclave, + registry, slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -469,7 +513,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Slash one member — 3 active → 2 active, threshold is 2, still viable - const proof = encodeProof(); + const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -481,12 +525,18 @@ describe("Committee Expulsion & Fault Tolerance", function () { // or whatever stage it was at, not Failed const stage = await enclave.getE3Stage(0); expect(stage).to.not.equal(6); // 6 = E3Stage.Failed + + // Active committee still has enough members + expect(await registry.getActiveCommitteeCount(0)).to.equal(2); + const threshold = await registry.getCommitteeThreshold(0); + expect(threshold[0]).to.equal(2); // M=2 }); it("should fail E3 when active members drop below threshold", async function () { const { enclave, slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -507,7 +557,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Slash first member — 3 → 2 active, still >= 2 - const proof1 = encodeProof("0x1111"); + const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0x1111"); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -519,7 +569,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(stage).to.not.equal(6); // Not failed yet // Slash second member — 2 → 1 active, below threshold M=2 - const proof2 = encodeProof("0x2222"); + const proof2 = await signAndEncodeProof(operator2, 0, await mockVerifier.getAddress(), "0x2222"); const tx = await slashingManager.proposeSlash( 0, await operator2.getAddress(), @@ -543,6 +593,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { const { registry, slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -563,7 +614,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Slash operator1 once - const proof1 = encodeProof("0xaaaa"); + const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0xaaaa"); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -573,7 +624,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(await registry.getActiveCommitteeCount(0)).to.equal(2); // Slash operator1 again with different proof (different evidence key) - const proof2 = encodeProof("0xbbbb"); + const proof2 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0xbbbb"); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -589,6 +640,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { const { registry, slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -614,7 +666,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(nodesBefore).to.include(await operator1.getAddress()); // Expel operator1 - const proof = encodeProof(); + const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -632,54 +684,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { }); describe("E3 continues above threshold", function () { - it("should allow the E3 lifecycle to progress despite expelled member", async function () { - const { - enclave, - registry, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); // M=2, N=3 - await finalizeCommitteeWithOperators(0, [ - operator1, - operator2, - operator3, - ]); - - // Expel one member - const proof = encodeProof(); - await slashingManager.proposeSlash( - 0, - await operator3.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // E3 should still be alive (not failed) - const stage = await enclave.getE3Stage(0); - expect(stage).to.not.equal(6); // Not E3Stage.Failed - - // Active committee still has enough members - expect(await registry.getActiveCommitteeCount(0)).to.equal(2); - const threshold = await registry.getCommitteeThreshold(0); - expect(threshold[0]).to.equal(2); // M=2 - }); - it("should allow multiple expulsions while staying above threshold", async function () { const { enclave, registry, slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -705,7 +715,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(await registry.getActiveCommitteeCount(0)).to.equal(4); // Expel 2 out of 4 — still have 2 >= M=2 - const proof1 = encodeProof("0x1111"); + const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0x1111"); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -714,7 +724,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { ); expect(await registry.getActiveCommitteeCount(0)).to.equal(3); - const proof2 = encodeProof("0x2222"); + const proof2 = await signAndEncodeProof(operator2, 0, await mockVerifier.getAddress(), "0x2222"); await slashingManager.proposeSlash( 0, await operator2.getAddress(), @@ -733,7 +743,9 @@ describe("Committee Expulsion & Fault Tolerance", function () { it("should fail E3 exactly at the threshold breach", async function () { const { enclave, + registry, slashingManager, + mockVerifier, operator1, operator2, setupOperator, @@ -748,7 +760,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { await finalizeCommitteeWithOperators(0, [operator1, operator2]); // Expel one member: 2 → 1 < M=2 → E3 fails immediately - const proof = encodeProof(); + const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); const tx = await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -758,6 +770,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { await expect(tx).to.emit(enclave, "E3Failed"); + // Should emit CommitteeViabilityUpdated(viable=false) + await expect(tx) + .to.emit(registry, "CommitteeViabilityUpdated") + .withArgs(0, 1, 2, false); + const stage = await enclave.getE3Stage(0); expect(stage).to.equal(6); // Failed }); @@ -766,6 +783,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { const { enclave, slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -786,7 +804,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Expel operator1 — still viable (2 >= 2) - const proof1 = encodeProof("0x1111"); + const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0x1111"); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -795,7 +813,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { ); // Expel operator2 — now below threshold (1 < 2), E3 fails - const proof2 = encodeProof("0x2222"); + const proof2 = await signAndEncodeProof(operator2, 0, await mockVerifier.getAddress(), "0x2222"); await slashingManager.proposeSlash( 0, await operator2.getAddress(), @@ -809,7 +827,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { // Try to expel operator3 — E3 already failed so onE3Failed should revert // but expelCommitteeMember itself should still work (idempotent-ish) - const proof3 = encodeProof("0x3333"); + const proof3 = await signAndEncodeProof(operator3, 0, await mockVerifier.getAddress(), "0x3333"); // This should revert because the E3 is already in Failed state // and onE3Failed will revert with E3AlreadyFailed @@ -824,80 +842,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { }); }); - describe("viability events", function () { - it("should emit CommitteeViabilityUpdated(viable=true) when still above threshold", async function () { - const { - registry, - slashingManager, - operator1, - operator2, - operator3, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - await setupOperator(operator3); - - await makeRequest([2, 3]); - await finalizeCommitteeWithOperators(0, [ - operator1, - operator2, - operator3, - ]); - - const proof = encodeProof(); - const tx = await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // 3 → 2 active, M=2 → viable - await expect(tx) - .to.emit(registry, "CommitteeViabilityUpdated") - .withArgs(0, 2, 2, true); - }); - - it("should emit CommitteeViabilityUpdated(viable=false) when below threshold", async function () { - const { - registry, - slashingManager, - operator1, - operator2, - setupOperator, - makeRequest, - finalizeCommitteeWithOperators, - } = await loadFixture(setup); - - await setupOperator(operator1); - await setupOperator(operator2); - - await makeRequest([2, 2]); - await finalizeCommitteeWithOperators(0, [operator1, operator2]); - - const proof = encodeProof(); - const tx = await slashingManager.proposeSlash( - 0, - await operator1.getAddress(), - REASON_BAD_DKG, - proof, - ); - - // 2 → 1 active, M=2 → not viable - await expect(tx) - .to.emit(registry, "CommitteeViabilityUpdated") - .withArgs(0, 1, 2, false); - }); - }); - describe("slash execution events", function () { it("should emit SlashExecuted on proof-based committee slash", async function () { const { slashingManager, + mockVerifier, operator1, operator2, operator3, @@ -917,7 +866,7 @@ describe("Committee Expulsion & Fault Tolerance", function () { operator3, ]); - const proof = encodeProof(); + const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); const op1Addr = await operator1.getAddress(); const tx = await slashingManager.proposeSlash( 0, From a99d180564a514a62f9f8bc9d7e3204f4add105e Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 21 Feb 2026 00:42:05 +0500 Subject: [PATCH 22/32] chore: lint --- .../enclave-contracts/test/Enclave.spec.ts | 5 +- .../test/Slashing/CommitteeExpulsion.spec.ts | 93 ++++++++++++++++--- 2 files changed, 80 insertions(+), 18 deletions(-) diff --git a/packages/enclave-contracts/test/Enclave.spec.ts b/packages/enclave-contracts/test/Enclave.spec.ts index 43446b05ec..54969c83e6 100644 --- a/packages/enclave-contracts/test/Enclave.spec.ts +++ b/packages/enclave-contracts/test/Enclave.spec.ts @@ -932,10 +932,7 @@ describe("Enclave", function () { await enclave.publishCiphertextOutput(e3Id, data, proof); await expect(enclave.publishCiphertextOutput(e3Id, data, proof)) - .to.be.revertedWithCustomError( - enclave, - "InvalidStage", - ) + .to.be.revertedWithCustomError(enclave, "InvalidStage") .withArgs(e3Id, 3, 4); }); it("reverts if committee duties are over", async function () { diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts index 229ca57e4a..d11a71fb1e 100644 --- a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -464,7 +464,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { // Submit slash proposal — MockCircuitVerifier returns false by default // so fault is confirmed and slash is auto-executed - const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); + const proof = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + ); const tx = await slashingManager.proposeSlash( 0, op1Address, @@ -513,7 +517,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Slash one member — 3 active → 2 active, threshold is 2, still viable - const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); + const proof = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + ); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -557,7 +565,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Slash first member — 3 → 2 active, still >= 2 - const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0x1111"); + const proof1 = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + "0x1111", + ); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -569,7 +582,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(stage).to.not.equal(6); // Not failed yet // Slash second member — 2 → 1 active, below threshold M=2 - const proof2 = await signAndEncodeProof(operator2, 0, await mockVerifier.getAddress(), "0x2222"); + const proof2 = await signAndEncodeProof( + operator2, + 0, + await mockVerifier.getAddress(), + "0x2222", + ); const tx = await slashingManager.proposeSlash( 0, await operator2.getAddress(), @@ -614,7 +632,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Slash operator1 once - const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0xaaaa"); + const proof1 = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + "0xaaaa", + ); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -624,7 +647,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(await registry.getActiveCommitteeCount(0)).to.equal(2); // Slash operator1 again with different proof (different evidence key) - const proof2 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0xbbbb"); + const proof2 = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + "0xbbbb", + ); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -666,7 +694,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(nodesBefore).to.include(await operator1.getAddress()); // Expel operator1 - const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); + const proof = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + ); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -715,7 +747,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { expect(await registry.getActiveCommitteeCount(0)).to.equal(4); // Expel 2 out of 4 — still have 2 >= M=2 - const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0x1111"); + const proof1 = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + "0x1111", + ); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -724,7 +761,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { ); expect(await registry.getActiveCommitteeCount(0)).to.equal(3); - const proof2 = await signAndEncodeProof(operator2, 0, await mockVerifier.getAddress(), "0x2222"); + const proof2 = await signAndEncodeProof( + operator2, + 0, + await mockVerifier.getAddress(), + "0x2222", + ); await slashingManager.proposeSlash( 0, await operator2.getAddress(), @@ -760,7 +802,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { await finalizeCommitteeWithOperators(0, [operator1, operator2]); // Expel one member: 2 → 1 < M=2 → E3 fails immediately - const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); + const proof = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + ); const tx = await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -804,7 +850,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { ]); // Expel operator1 — still viable (2 >= 2) - const proof1 = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress(), "0x1111"); + const proof1 = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + "0x1111", + ); await slashingManager.proposeSlash( 0, await operator1.getAddress(), @@ -813,7 +864,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { ); // Expel operator2 — now below threshold (1 < 2), E3 fails - const proof2 = await signAndEncodeProof(operator2, 0, await mockVerifier.getAddress(), "0x2222"); + const proof2 = await signAndEncodeProof( + operator2, + 0, + await mockVerifier.getAddress(), + "0x2222", + ); await slashingManager.proposeSlash( 0, await operator2.getAddress(), @@ -827,7 +883,12 @@ describe("Committee Expulsion & Fault Tolerance", function () { // Try to expel operator3 — E3 already failed so onE3Failed should revert // but expelCommitteeMember itself should still work (idempotent-ish) - const proof3 = await signAndEncodeProof(operator3, 0, await mockVerifier.getAddress(), "0x3333"); + const proof3 = await signAndEncodeProof( + operator3, + 0, + await mockVerifier.getAddress(), + "0x3333", + ); // This should revert because the E3 is already in Failed state // and onE3Failed will revert with E3AlreadyFailed @@ -866,7 +927,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { operator3, ]); - const proof = await signAndEncodeProof(operator1, 0, await mockVerifier.getAddress()); + const proof = await signAndEncodeProof( + operator1, + 0, + await mockVerifier.getAddress(), + ); const op1Addr = await operator1.getAddress(); const tx = await slashingManager.proposeSlash( 0, From 25dedaef12c728da2244f40935453c5563f57023 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 21 Feb 2026 01:15:44 +0500 Subject: [PATCH 23/32] fix: remove registered check from distribute reward --- .../enclave-contracts/contracts/interfaces/IBondingRegistry.sol | 2 +- .../enclave-contracts/contracts/registry/BondingRegistry.sol | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol b/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol index 10dec6c2cb..d910cdb5ff 100644 --- a/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol +++ b/packages/enclave-contracts/contracts/interfaces/IBondingRegistry.sol @@ -350,7 +350,7 @@ interface IBondingRegistry { * @param rewardToken Reward token contract * @param operators Addresses of the operators to distribute rewards to * @param amounts Amounts of rewards to distribute to each operator - * @dev Only callable by contract owner + * @dev Only callable by authorized distributors. */ function distributeRewards( IERC20 rewardToken, diff --git a/packages/enclave-contracts/contracts/registry/BondingRegistry.sol b/packages/enclave-contracts/contracts/registry/BondingRegistry.sol index 7da4ada99c..53eff07658 100644 --- a/packages/enclave-contracts/contracts/registry/BondingRegistry.sol +++ b/packages/enclave-contracts/contracts/registry/BondingRegistry.sol @@ -593,7 +593,7 @@ contract BondingRegistry is uint256 len = recipients.length; for (uint256 i = 0; i < len; i++) { - if (amounts[i] > 0 && operators[recipients[i]].registered) { + if (amounts[i] > 0) { rewardToken.safeTransferFrom( msg.sender, recipients[i], From 9c0357bf9d833020d1731886027ba16c1a0d5ca9 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 21 Feb 2026 21:58:04 +0500 Subject: [PATCH 24/32] chore: update env --- examples/CRISP/server/.env.example | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/CRISP/server/.env.example b/examples/CRISP/server/.env.example index 0d81df449f..58d0f1c6e4 100644 --- a/examples/CRISP/server/.env.example +++ b/examples/CRISP/server/.env.example @@ -15,7 +15,7 @@ CRON_API_KEY=1234567890 # Based on Default Hardhat Deployments (Only for testing) ENCLAVE_ADDRESS="0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0" CIPHERNODE_REGISTRY_ADDRESS="0x610178dA211FEF7D417bC0e6FeD39F05609AD788" -E3_PROGRAM_ADDRESS="0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB" # CRISPProgram Contract Address +E3_PROGRAM_ADDRESS="0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8" # CRISPProgram Contract Address FEE_TOKEN_ADDRESS="0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0" # E3 Config From 4933869296de43e882bb4a13450599e529451939 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sat, 21 Feb 2026 21:59:26 +0500 Subject: [PATCH 25/32] chore: update config --- templates/default/enclave.config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/templates/default/enclave.config.yaml b/templates/default/enclave.config.yaml index c6fc5d7ec4..16d03bf0f6 100644 --- a/templates/default/enclave.config.yaml +++ b/templates/default/enclave.config.yaml @@ -3,7 +3,7 @@ chains: rpc_url: "ws://localhost:8545" contracts: e3_program: - address: "0xc3e53F4d16Ae77Db1c982e75a937B9f60FE63690" + address: "0xa82fF9aFd8f496c3d6ac40E2a0F282E47488CFc9" deploy_block: 1 # Set to actual deploy block enclave: address: "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0" From a62e20f1131b326156e0584604ee2b8470491ef9 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 22 Feb 2026 02:31:05 +0500 Subject: [PATCH 26/32] fix: resolve conflicts --- crates/aggregator/src/publickey_aggregator.rs | 10 ++- .../src/ciphernode_builder.rs | 13 +++- .../src/enclave_event/slash_executed.rs | 6 +- crates/events/src/ordered_set.rs | 4 ++ crates/evm/src/slashing_manager_sol_reader.rs | 6 +- crates/keyshare/src/threshold_keyshare.rs | 72 ++++++++++++++----- .../contracts/E3RefundManager.sol | 13 ++++ .../contracts/interfaces/ISlashingManager.sol | 9 +++ .../registry/CiphernodeRegistryOwnable.sol | 1 + .../contracts/slashing/SlashingManager.sol | 40 ++++++----- .../test/Slashing/CommitteeExpulsion.spec.ts | 1 - 11 files changed, 131 insertions(+), 44 deletions(-) diff --git a/crates/aggregator/src/publickey_aggregator.rs b/crates/aggregator/src/publickey_aggregator.rs index e61e3b557e..38001fb087 100644 --- a/crates/aggregator/src/publickey_aggregator.rs +++ b/crates/aggregator/src/publickey_aggregator.rs @@ -154,6 +154,14 @@ impl PublicKeyAggregator { return Ok(state); }; + // Remove the expelled node from the nodes set so it won't appear in + // PublicKeyAggregated.nodes (forwarded on-chain for reward distribution). + // Note: the corresponding keyshare cannot be removed because the + // keyshares OrderedSet is keyed by raw bytes with no node mapping. + // This is acceptable because BFV public key aggregation is additive + // and works correctly with any superset of valid keys. + nodes.remove(&node.to_string()); + if *threshold_n > 0 { *threshold_n -= 1; info!( @@ -192,7 +200,7 @@ impl Handler for PublicKeyAggregator { } EnclaveEventData::E3RequestComplete(_) => self.notify_sync(ctx, Die), EnclaveEventData::CommitteeMemberExpelled(data) => { - let node_addr = format!("{:?}", data.node); + let node_addr = data.node.to_string(); info!( "PublicKeyAggregator: committee member expelled: {} for e3_id={}", node_addr, data.e3_id diff --git a/crates/ciphernode-builder/src/ciphernode_builder.rs b/crates/ciphernode-builder/src/ciphernode_builder.rs index 1872324f70..d1a0e67a15 100644 --- a/crates/ciphernode-builder/src/ciphernode_builder.rs +++ b/crates/ciphernode-builder/src/ciphernode_builder.rs @@ -690,13 +690,20 @@ async fn setup_evm_system( // Writer: submit proposeSlash transactions match provider_cache.ensure_write_provider(&chain).await { Ok(write_provider) => { - SlashingManagerSolWriter::attach( + match SlashingManagerSolWriter::attach( &bus, write_provider.clone(), contract_addr, ) - .await?; - info!("SlashingManagerSolWriter attached for fault submission"); + .await + { + Ok(_) => { + info!("SlashingManagerSolWriter attached for fault submission"); + } + Err(e) => { + error!("Failed to attach SlashingManagerSolWriter, skipping: {}", e) + } + } } Err(e) => error!( "Failed to create write provider for SlashingManager, skipping: {}", diff --git a/crates/events/src/enclave_event/slash_executed.rs b/crates/events/src/enclave_event/slash_executed.rs index d75f2ed338..08ba4ebc69 100644 --- a/crates/events/src/enclave_event/slash_executed.rs +++ b/crates/events/src/enclave_event/slash_executed.rs @@ -20,15 +20,15 @@ pub struct SlashExecuted { /// The E3 computation this slash relates to. pub e3_id: E3id, /// On-chain proposal ID. - pub proposal_id: u64, + pub proposal_id: u128, /// Address of the slashed operator. pub operator: Address, /// Hash of the slash reason. pub reason: [u8; 32], /// Amount of ticket collateral slashed. - pub ticket_amount: u64, + pub ticket_amount: u128, /// Amount of license bond slashed. - pub license_amount: u64, + pub license_amount: u128, } impl Display for SlashExecuted { diff --git a/crates/events/src/ordered_set.rs b/crates/events/src/ordered_set.rs index 13f08295aa..5c5fd0b18d 100644 --- a/crates/events/src/ordered_set.rs +++ b/crates/events/src/ordered_set.rs @@ -33,6 +33,10 @@ impl OrderedSet { self.0.is_empty() } + pub fn remove(&mut self, value: &T) -> bool { + self.0.remove(value) + } + pub fn iter(&self) -> impl Iterator { self.0.iter() } diff --git a/crates/evm/src/slashing_manager_sol_reader.rs b/crates/evm/src/slashing_manager_sol_reader.rs index 8aad006bcd..cb341c95c8 100644 --- a/crates/evm/src/slashing_manager_sol_reader.rs +++ b/crates/evm/src/slashing_manager_sol_reader.rs @@ -28,11 +28,11 @@ pub fn extractor(data: &LogData, topic: Option<&B256>, chain_id: u64) -> Option< ); Some(EnclaveEventData::from(e3_events::SlashExecuted { e3_id: E3id::new(event.e3Id.to_string(), chain_id), - proposal_id: event.proposalId.to(), + proposal_id: event.proposalId.to::(), operator: event.operator, reason: event.reason.into(), - ticket_amount: event.ticketAmount.to(), - license_amount: event.licenseAmount.to(), + ticket_amount: event.ticketAmount.to::(), + license_amount: event.licenseAmount.to::(), })) } _topic => { diff --git a/crates/keyshare/src/threshold_keyshare.rs b/crates/keyshare/src/threshold_keyshare.rs index c9a576237a..46eedf5ccc 100644 --- a/crates/keyshare/src/threshold_keyshare.rs +++ b/crates/keyshare/src/threshold_keyshare.rs @@ -49,6 +49,17 @@ use crate::encryption_key_collector::{ }; use crate::threshold_share_collector::{ExpelPartyFromShareCollection, ThresholdShareCollector}; +/// Tracks committee membership state, buffering expulsion events that arrive +/// before the committee list is known. +enum CommitteeState { + /// Committee not yet finalized; buffer any expulsion events for replay. + Pending { + buffered_expulsions: Vec<(CommitteeMemberExpelled, EventContext)>, + }, + /// Committee finalized — members list is available. + Finalized { members: Vec }, +} + #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] #[rtype(result = "()")] pub struct GenPkShareAndSkSss(CiphernodeSelected); @@ -323,7 +334,7 @@ pub struct ThresholdKeyshare { encryption_key_collector: Option>, state: Persistable, share_enc_preset: BfvPreset, - committee: Option>, + committee: CommitteeState, } impl ThresholdKeyshare { @@ -335,7 +346,9 @@ impl ThresholdKeyshare { encryption_key_collector: None, state: params.state, share_enc_preset: params.share_enc_preset, - committee: None, + committee: CommitteeState::Pending { + buffered_expulsions: Vec::new(), + }, } } } @@ -393,27 +406,34 @@ impl ThresholdKeyshare { data: CommitteeMemberExpelled, ec: EventContext, ) { - let node_addr = format!("{:?}", data.node); + // Use Display formatting (to_string) for consistent matching with + // committee list populated via Address::to_string() in ciphernode_registry_sol.rs + let node_addr = data.node.to_string(); info!( "CommitteeMemberExpelled received: node={} for e3_id={}, active_count_after={}", node_addr, data.e3_id, data.active_count_after ); - let party_id = match &self.committee { - Some(committee) => { - let node_lower = node_addr.to_lowercase(); - committee - .iter() - .position(|addr| addr.to_lowercase() == node_lower) - .map(|idx| idx as u64) - } - None => { - error!( - "Cannot resolve expelled node {} to party_id: committee list not available", + let members = match &mut self.committee { + CommitteeState::Pending { + buffered_expulsions, + } => { + warn!( + "Buffering CommitteeMemberExpelled for node {} until CommitteeFinalized arrives", node_addr ); - None + buffered_expulsions.push((data, ec)); + return; } + CommitteeState::Finalized { members } => members, + }; + + let party_id = { + let node_lower = node_addr.to_lowercase(); + members + .iter() + .position(|addr| addr.to_lowercase() == node_lower) + .map(|idx| idx as u64) }; let Some(party_id) = party_id else { @@ -1141,7 +1161,27 @@ impl Handler for ThresholdKeyshare { data.committee.len(), data.e3_id ); - self.committee = Some(data.committee); + // Take any buffered expulsions before transitioning state + let pending = match std::mem::replace( + &mut self.committee, + CommitteeState::Finalized { + members: data.committee, + }, + ) { + CommitteeState::Pending { + buffered_expulsions, + } => buffered_expulsions, + CommitteeState::Finalized { .. } => Vec::new(), + }; + + // Replay any buffered expulsion events that arrived before the committee was known + for (expulsion_data, expulsion_ec) in pending { + info!( + "Replaying buffered CommitteeMemberExpelled for node={:?} e3_id={}", + expulsion_data.node, expulsion_data.e3_id + ); + self.handle_committee_member_expelled(expulsion_data, expulsion_ec); + } } EnclaveEventData::CommitteeMemberExpelled(data) => { self.handle_committee_member_expelled(data, ec); diff --git a/packages/enclave-contracts/contracts/E3RefundManager.sol b/packages/enclave-contracts/contracts/E3RefundManager.sol index 05f4c8225b..e3ed6a7e1a 100644 --- a/packages/enclave-contracts/contracts/E3RefundManager.sol +++ b/packages/enclave-contracts/contracts/E3RefundManager.sol @@ -240,6 +240,12 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { RefundDistribution storage dist = _distributions[e3Id]; if (!dist.calculated) revert RefundNotCalculated(e3Id); + // Guard against pre-upgrade records where feeToken was not yet stored + require( + address(dist.feeToken) != address(0), + "feeToken not initialized" + ); + address requester = enclave.getRequester(e3Id); if (msg.sender != requester) revert NotRequester(e3Id, msg.sender); @@ -263,6 +269,13 @@ contract E3RefundManager is IE3RefundManager, OwnableUpgradeable { ) external returns (uint256 amount) { RefundDistribution storage dist = _distributions[e3Id]; require(dist.calculated, RefundNotCalculated(e3Id)); + + // Guard against pre-upgrade records where feeToken was not yet stored + require( + address(dist.feeToken) != address(0), + "feeToken not initialized" + ); + require(!_claimed[e3Id][msg.sender], AlreadyClaimed(e3Id, msg.sender)); // Check if caller is honest node diff --git a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol index dbbe28f036..9cf3c4089d 100644 --- a/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol +++ b/packages/enclave-contracts/contracts/interfaces/ISlashingManager.sol @@ -78,6 +78,12 @@ interface ISlashingManager { address proposer; bytes32 proofHash; bool proofVerified; + /// @dev Snapshotted from SlashPolicy at proposal time to prevent execution drift + bool banNode; + /// @dev Snapshotted from SlashPolicy at proposal time to prevent execution drift + bool affectsCommittee; + /// @dev Snapshotted from SlashPolicy at proposal time to prevent execution drift + uint8 failureReason; } // ====================== @@ -153,6 +159,9 @@ interface ISlashingManager { /// @notice Thrown when the same evidence bundle has already been used in a proposal error DuplicateEvidence(); + /// @notice Thrown when the chainId in the signed proof payload does not match the current chain + error ChainIdMismatch(); + // ====================== // Events // ====================== diff --git a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol index bf574d0ec6..fc20835afd 100644 --- a/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol +++ b/packages/enclave-contracts/contracts/registry/CiphernodeRegistryOwnable.sol @@ -555,6 +555,7 @@ contract CiphernodeRegistryOwnable is ICiphernodeRegistry, OwnableUpgradeable { returns (uint256 activeCount, uint32 thresholdM) { Committee storage c = committees[e3Id]; + require(c.finalized, CommitteeNotFinalized()); thresholdM = c.threshold[0]; // Idempotent: if already expelled, return current state diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index 0e8aa59dde..dc79d90542 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -279,6 +279,10 @@ contract SlashingManager is ISlashingManager, AccessControl { p.proposer = msg.sender; p.proofHash = keccak256(proof); p.proofVerified = true; + // Snapshot behavioral flags from policy at proposal time + p.banNode = policy.banNode; + p.affectsCommittee = policy.affectsCommittee; + p.failureReason = policy.failureReason; emit SlashProposed( proposalId, @@ -291,7 +295,7 @@ contract SlashingManager is ISlashingManager, AccessControl { msg.sender ); - _executeSlash(proposalId, policy); + _executeSlash(proposalId); } /// @inheritdoc ISlashingManager @@ -329,6 +333,11 @@ contract SlashingManager is ISlashingManager, AccessControl { p.executableAt = executableAt; p.proposer = msg.sender; p.proofHash = keccak256(evidence); + // Snapshot behavioral flags from policy at proposal time + // to prevent execution drift if policy is modified during appeal window + p.banNode = policy.banNode; + p.affectsCommittee = policy.affectsCommittee; + p.failureReason = policy.failureReason; emit SlashProposed( proposalId, @@ -349,10 +358,8 @@ contract SlashingManager is ISlashingManager, AccessControl { SlashProposal storage p = _proposals[proposalId]; require(!p.executed, AlreadyExecuted()); - SlashPolicy memory policy = slashPolicies[p.reason]; - - // Proof-based slashes are already executed atomically in proposeSlash - require(!policy.requiresProof, InvalidPolicy()); + // Use snapshotted requiresProof state: proof-based slashes are already executed atomically in proposeSlash + require(!p.proofVerified, InvalidPolicy()); // Evidence mode: check appeal window require(block.timestamp >= p.executableAt, AppealWindowActive()); @@ -361,7 +368,7 @@ contract SlashingManager is ISlashingManager, AccessControl { require(!p.appealUpheld, AppealUpheld()); } - _executeSlash(proposalId, policy); + _executeSlash(proposalId); } // ====================== @@ -415,6 +422,9 @@ contract SlashingManager is ISlashingManager, AccessControl { // 1. Verify verifier in evidence matches policy's current verifier. require(signedVerifier == policyVerifier, VerifierMismatch()); + // 1b. Verify chainId matches current chain to prevent cross-chain replay. + require(chainId == block.chainid, ChainIdMismatch()); + // 2. Verify the operator signed this exact proof payload. bytes32 messageHash = keccak256( abi.encode( @@ -455,12 +465,8 @@ contract SlashingManager is ISlashingManager, AccessControl { * has already claimed their exit, funds are gone and the slash amount becomes 0. This is * an accepted tradeoff for the appeal window design. * @param proposalId ID of the proposal to execute - * @param policy The slash policy for this proposal */ - function _executeSlash( - uint256 proposalId, - SlashPolicy memory policy - ) internal { + function _executeSlash(uint256 proposalId) internal { SlashProposal storage p = _proposals[proposalId]; p.executed = true; @@ -481,21 +487,21 @@ contract SlashingManager is ISlashingManager, AccessControl { ); } - // Ban node if policy requires it - if (policy.banNode) { + // Ban node if snapshotted policy requires it + if (p.banNode) { banned[p.operator] = true; emit NodeBanUpdated(p.operator, true, p.reason, address(this)); } - // Committee expulsion for E3-scoped slashes + // Committee expulsion for E3-scoped slashes (uses snapshotted behavioral flags) // expelCommitteeMember returns (activeCount, thresholdM) — one call instead of three - if (policy.affectsCommittee) { + if (p.affectsCommittee) { (uint256 activeCount, uint32 thresholdM) = ciphernodeRegistry .expelCommitteeMember(p.e3Id, p.operator, p.reason); // If active count drops below M, fail the E3 - if (activeCount < thresholdM && policy.failureReason > 0) { - enclave.onE3Failed(p.e3Id, policy.failureReason); + if (activeCount < thresholdM && p.failureReason > 0) { + enclave.onE3Failed(p.e3Id, p.failureReason); } } diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts index d11a71fb1e..64a010900c 100644 --- a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -73,7 +73,6 @@ describe("Committee Expulsion & Fault Tolerance", function () { "0x2c2a814a0495f913a3a312fc4771e37552bc14f8a2d4075a08122d356f0849c6"; const defaultTimeoutConfig = { - committeeFormationWindow: ONE_DAY, dkgWindow: ONE_DAY, computeWindow: THREE_DAYS, decryptionWindow: ONE_DAY, From 81bd5931ea73c5b3a17cbcdf58b7b240c74e71f5 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 22 Feb 2026 11:27:49 +0500 Subject: [PATCH 27/32] fix: review comments --- crates/aggregator/src/publickey_aggregator.rs | 39 ++++++++++++------- .../contracts/slashing/SlashingManager.sol | 2 +- .../test/Slashing/CommitteeExpulsion.spec.ts | 14 ++++--- 3 files changed, 36 insertions(+), 19 deletions(-) diff --git a/crates/aggregator/src/publickey_aggregator.rs b/crates/aggregator/src/publickey_aggregator.rs index 38001fb087..f811142d21 100644 --- a/crates/aggregator/src/publickey_aggregator.rs +++ b/crates/aggregator/src/publickey_aggregator.rs @@ -201,26 +201,39 @@ impl Handler for PublicKeyAggregator { EnclaveEventData::E3RequestComplete(_) => self.notify_sync(ctx, Die), EnclaveEventData::CommitteeMemberExpelled(data) => { let node_addr = data.node.to_string(); + + if data.e3_id != self.e3_id { + error!("Wrong e3_id sent to PublicKeyAggregator for expulsion. This should not happen."); + return; + } + info!( "PublicKeyAggregator: committee member expelled: {} for e3_id={}", node_addr, data.e3_id ); trap(EType::PublickeyAggregation, &self.bus.with_ec(&ec), || { + let was_collecting = matches!( + self.state.get(), + Some(PublicKeyAggregatorState::Collecting { .. }) + ); + self.handle_member_expelled(&node_addr, &ec)?; - if let Some(PublicKeyAggregatorState::Computing { keyshares, .. }) = - &self.state.get() - { - self.notify_sync( - ctx, - TypedEvent::new( - ComputeAggregate { - keyshares: keyshares.clone(), - e3_id: data.e3_id, - }, - ec.clone(), - ), - ); + if was_collecting { + if let Some(PublicKeyAggregatorState::Computing { keyshares, .. }) = + &self.state.get() + { + self.notify_sync( + ctx, + TypedEvent::new( + ComputeAggregate { + keyshares: keyshares.clone(), + e3_id: data.e3_id, + }, + ec.clone(), + ), + ); + } } Ok(()) }); diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index dc79d90542..ad284c5db5 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -501,7 +501,7 @@ contract SlashingManager is ISlashingManager, AccessControl { // If active count drops below M, fail the E3 if (activeCount < thresholdM && p.failureReason > 0) { - enclave.onE3Failed(p.e3Id, p.failureReason); + try enclave.onE3Failed(p.e3Id, p.failureReason) {} catch {} } } diff --git a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts index 64a010900c..ba1918e6fd 100644 --- a/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts +++ b/packages/enclave-contracts/test/Slashing/CommitteeExpulsion.spec.ts @@ -880,8 +880,8 @@ describe("Committee Expulsion & Fault Tolerance", function () { const stage = await enclave.getE3Stage(0); expect(stage).to.equal(6); - // Try to expel operator3 — E3 already failed so onE3Failed should revert - // but expelCommitteeMember itself should still work (idempotent-ish) + // Try to expel operator3 — E3 already failed, but onE3Failed is wrapped + // in try-catch so financial penalties are still applied const proof3 = await signAndEncodeProof( operator3, 0, @@ -889,8 +889,8 @@ describe("Committee Expulsion & Fault Tolerance", function () { "0x3333", ); - // This should revert because the E3 is already in Failed state - // and onE3Failed will revert with E3AlreadyFailed + // The third slash should succeed — penalties are applied even though E3 is already Failed. + // The onE3Failed call silently fails (try-catch) since E3 is already in Failed state. await expect( slashingManager.proposeSlash( 0, @@ -898,7 +898,11 @@ describe("Committee Expulsion & Fault Tolerance", function () { REASON_BAD_DKG, proof3, ), - ).to.be.revertedWithCustomError(enclave, "E3AlreadyFailed"); + ).to.emit(slashingManager, "SlashExecuted"); + + // E3 stage should still be Failed + const stageAfter = await enclave.getE3Stage(0); + expect(stageAfter).to.equal(6); }); }); From 0cab318ade733cbbe79277af759881285ea20e86 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 22 Feb 2026 12:45:05 +0500 Subject: [PATCH 28/32] fix: remove committee from threshold keyshare --- .../src/keyshare_created_filter_buffer.rs | 5 ++ crates/aggregator/src/publickey_aggregator.rs | 5 ++ crates/events/src/committee.rs | 66 ++++++++++++++ .../src/enclave_event/slash_executed.rs | 8 +- crates/events/src/lib.rs | 2 + crates/evm/src/ciphernode_registry_sol.rs | 1 + crates/keyshare/src/threshold_keyshare.rs | 87 ++----------------- crates/sortition/src/repo.rs | 6 +- crates/sortition/src/sortition.rs | 86 +++++++++++++++--- 9 files changed, 167 insertions(+), 99 deletions(-) create mode 100644 crates/events/src/committee.rs diff --git a/crates/aggregator/src/keyshare_created_filter_buffer.rs b/crates/aggregator/src/keyshare_created_filter_buffer.rs index fdcf272f51..e193461e4b 100644 --- a/crates/aggregator/src/keyshare_created_filter_buffer.rs +++ b/crates/aggregator/src/keyshare_created_filter_buffer.rs @@ -71,6 +71,11 @@ impl Handler for KeyshareCreatedFilterBuffer { self.process_buffered_events(); } EnclaveEventData::CommitteeMemberExpelled(data) => { + // Only process raw events from chain (party_id not yet resolved). + if data.party_id.is_some() { + return; + } + // Remove expelled node so we don't forward late KeyshareCreated events from them if let Some(ref mut committee) = self.committee { let node_addr = format!("{:?}", data.node); diff --git a/crates/aggregator/src/publickey_aggregator.rs b/crates/aggregator/src/publickey_aggregator.rs index f811142d21..d8cf851573 100644 --- a/crates/aggregator/src/publickey_aggregator.rs +++ b/crates/aggregator/src/publickey_aggregator.rs @@ -200,6 +200,11 @@ impl Handler for PublicKeyAggregator { } EnclaveEventData::E3RequestComplete(_) => self.notify_sync(ctx, Die), EnclaveEventData::CommitteeMemberExpelled(data) => { + // Only process raw events from chain (party_id not yet resolved). + if data.party_id.is_some() { + return; + } + let node_addr = data.node.to_string(); if data.e3_id != self.e3_id { diff --git a/crates/events/src/committee.rs b/crates/events/src/committee.rs new file mode 100644 index 0000000000..1ac2ea6cff --- /dev/null +++ b/crates/events/src/committee.rs @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; + +/// Ordered list of committee members where index == party_id. +/// +/// Provides O(1) address→party_id lookups via an internal index. +/// The index is skipped during serialization and rebuilt lazily on first lookup +/// after deserialization. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct Committee { + /// Ordered member list — index == party_id. + members: Vec, + /// Lowercased-address → party_id for O(1) lookup. + #[serde(skip)] + index: HashMap, +} + +impl Committee { + pub fn new(members: Vec) -> Self { + let index = members + .iter() + .enumerate() + .map(|(i, addr)| (addr.to_lowercase(), i as u64)) + .collect(); + Self { members, index } + } + + /// Resolve an address to its party_id (position in the committee list). + pub fn party_id_for(&self, addr: &str) -> Option { + // Rebuild index lazily after deserialization (serde skip) + if self.index.is_empty() && !self.members.is_empty() { + // Fallback linear scan when index hasn't been rebuilt + let lower = addr.to_lowercase(); + return self + .members + .iter() + .position(|a| a.to_lowercase() == lower) + .map(|i| i as u64); + } + self.index.get(&addr.to_lowercase()).copied() + } + + /// Check if an address is a committee member. + pub fn contains(&self, addr: &str) -> bool { + self.party_id_for(addr).is_some() + } + + /// The ordered member list (index == party_id). + pub fn members(&self) -> &[String] { + &self.members + } + + pub fn len(&self) -> usize { + self.members.len() + } + + pub fn is_empty(&self) -> bool { + self.members.is_empty() + } +} diff --git a/crates/events/src/enclave_event/slash_executed.rs b/crates/events/src/enclave_event/slash_executed.rs index 08ba4ebc69..824ae2b6a8 100644 --- a/crates/events/src/enclave_event/slash_executed.rs +++ b/crates/events/src/enclave_event/slash_executed.rs @@ -57,14 +57,18 @@ pub struct CommitteeMemberExpelled { pub reason: [u8; 32], /// Number of active committee members remaining after expulsion. pub active_count_after: u64, + /// Party ID (position in the committee list) of the expelled member. + /// `None` when read from chain (not yet resolved); `Some(id)` after + /// enrichment by the Sortition actor. + pub party_id: Option, } impl Display for CommitteeMemberExpelled { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!( f, - "CommitteeMemberExpelled {{ e3_id: {}, node: {}, active_count_after: {} }}", - self.e3_id, self.node, self.active_count_after + "CommitteeMemberExpelled {{ e3_id: {}, node: {}, active_count_after: {}, party_id: {:?} }}", + self.e3_id, self.node, self.active_count_after, self.party_id ) } } diff --git a/crates/events/src/lib.rs b/crates/events/src/lib.rs index 2d0e7b9050..bd0fe091dc 100644 --- a/crates/events/src/lib.rs +++ b/crates/events/src/lib.rs @@ -5,6 +5,7 @@ // or FITNESS FOR A PARTICULAR PURPOSE. mod bus_handle; +mod committee; mod correlation_id; mod data_events; mod e3id; @@ -29,6 +30,7 @@ mod sync; mod traits; pub use bus_handle::*; +pub use committee::*; pub use correlation_id::*; pub use data_events::*; pub use e3id::*; diff --git a/crates/evm/src/ciphernode_registry_sol.rs b/crates/evm/src/ciphernode_registry_sol.rs index 13591a492d..6a1cfe3369 100644 --- a/crates/evm/src/ciphernode_registry_sol.rs +++ b/crates/evm/src/ciphernode_registry_sol.rs @@ -169,6 +169,7 @@ impl From for e3_events::CommitteeMemberExpe node: value.0.node, reason: value.0.reason.into(), active_count_after: value.0.activeCountAfter.to(), + party_id: None, } } } diff --git a/crates/keyshare/src/threshold_keyshare.rs b/crates/keyshare/src/threshold_keyshare.rs index 46eedf5ccc..f27780c111 100644 --- a/crates/keyshare/src/threshold_keyshare.rs +++ b/crates/keyshare/src/threshold_keyshare.rs @@ -49,17 +49,6 @@ use crate::encryption_key_collector::{ }; use crate::threshold_share_collector::{ExpelPartyFromShareCollection, ThresholdShareCollector}; -/// Tracks committee membership state, buffering expulsion events that arrive -/// before the committee list is known. -enum CommitteeState { - /// Committee not yet finalized; buffer any expulsion events for replay. - Pending { - buffered_expulsions: Vec<(CommitteeMemberExpelled, EventContext)>, - }, - /// Committee finalized — members list is available. - Finalized { members: Vec }, -} - #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] #[rtype(result = "()")] pub struct GenPkShareAndSkSss(CiphernodeSelected); @@ -334,7 +323,6 @@ pub struct ThresholdKeyshare { encryption_key_collector: Option>, state: Persistable, share_enc_preset: BfvPreset, - committee: CommitteeState, } impl ThresholdKeyshare { @@ -346,9 +334,6 @@ impl ThresholdKeyshare { encryption_key_collector: None, state: params.state, share_enc_preset: params.share_enc_preset, - committee: CommitteeState::Pending { - buffered_expulsions: Vec::new(), - }, } } } @@ -406,47 +391,17 @@ impl ThresholdKeyshare { data: CommitteeMemberExpelled, ec: EventContext, ) { - // Use Display formatting (to_string) for consistent matching with - // committee list populated via Address::to_string() in ciphernode_registry_sol.rs - let node_addr = data.node.to_string(); - info!( - "CommitteeMemberExpelled received: node={} for e3_id={}, active_count_after={}", - node_addr, data.e3_id, data.active_count_after - ); - - let members = match &mut self.committee { - CommitteeState::Pending { - buffered_expulsions, - } => { - warn!( - "Buffering CommitteeMemberExpelled for node {} until CommitteeFinalized arrives", - node_addr - ); - buffered_expulsions.push((data, ec)); - return; - } - CommitteeState::Finalized { members } => members, - }; - - let party_id = { - let node_lower = node_addr.to_lowercase(); - members - .iter() - .position(|addr| addr.to_lowercase() == node_lower) - .map(|idx| idx as u64) - }; - - let Some(party_id) = party_id else { - error!( - "Expelled node {} not found in committee list, cannot remove from collectors", - node_addr - ); + // Only process enriched events (party_id resolved by Sortition). + // Raw events from chain (party_id = None) are ignored here; + // Sortition will re-publish them with party_id set. + let Some(party_id) = data.party_id else { return; }; + let node_addr = data.node.to_string(); info!( - "Resolved expelled node {} to party_id={}, forwarding to collectors", - node_addr, party_id + "CommitteeMemberExpelled received (enriched): node={}, party_id={}, e3_id={}, active_count_after={}", + node_addr, party_id, data.e3_id, data.active_count_after ); if let Some(ref collector) = self.encryption_key_collector { @@ -1155,34 +1110,6 @@ impl Handler for ThresholdKeyshare { EnclaveEventData::ComputeResponse(data) => { self.notify_sync(ctx, TypedEvent::new(data, ec)) } - EnclaveEventData::CommitteeFinalized(data) => { - info!( - "ThresholdKeyshare received CommitteeFinalized with {} committee members for e3_id={}", - data.committee.len(), - data.e3_id - ); - // Take any buffered expulsions before transitioning state - let pending = match std::mem::replace( - &mut self.committee, - CommitteeState::Finalized { - members: data.committee, - }, - ) { - CommitteeState::Pending { - buffered_expulsions, - } => buffered_expulsions, - CommitteeState::Finalized { .. } => Vec::new(), - }; - - // Replay any buffered expulsion events that arrived before the committee was known - for (expulsion_data, expulsion_ec) in pending { - info!( - "Replaying buffered CommitteeMemberExpelled for node={:?} e3_id={}", - expulsion_data.node, expulsion_data.e3_id - ); - self.handle_committee_member_expelled(expulsion_data, expulsion_ec); - } - } EnclaveEventData::CommitteeMemberExpelled(data) => { self.handle_committee_member_expelled(data, ec); } diff --git a/crates/sortition/src/repo.rs b/crates/sortition/src/repo.rs index ffa3b84cc9..0b25aad99b 100644 --- a/crates/sortition/src/repo.rs +++ b/crates/sortition/src/repo.rs @@ -7,7 +7,7 @@ use crate::backends::SortitionBackend; use crate::sortition::NodeStateStore; use e3_data::{Repositories, Repository}; -use e3_events::{E3id, StoreKeys}; +use e3_events::{Committee, E3id, StoreKeys}; use e3_request::E3Meta; use std::collections::HashMap; @@ -42,11 +42,11 @@ impl NodeStateRepositoryFactory for Repositories { } pub trait FinalizedCommitteesRepositoryFactory { - fn finalized_committees(&self) -> Repository>>; + fn finalized_committees(&self) -> Repository>; } impl FinalizedCommitteesRepositoryFactory for Repositories { - fn finalized_committees(&self) -> Repository>> { + fn finalized_committees(&self) -> Repository> { Repository::new(self.store.scope(StoreKeys::finalized_committees())) } } diff --git a/crates/sortition/src/sortition.rs b/crates/sortition/src/sortition.rs index a690a7f08c..541166a1f4 100644 --- a/crates/sortition/src/sortition.rs +++ b/crates/sortition/src/sortition.rs @@ -12,10 +12,11 @@ use alloy::primitives::U256; use anyhow::{anyhow, Result}; use e3_data::{AutoPersist, Persistable, Repository}; use e3_events::{ - prelude::*, trap, CiphernodeAdded, CiphernodeRemoved, CommitteeFinalized, CommitteePublished, - ConfigurationUpdated, E3Failed, E3Requested, E3Stage, E3StageChanged, EType, EnclaveEvent, - EventContext, EventType, OperatorActivationChanged, PlaintextOutputPublished, Seed, Sequenced, - TicketBalanceUpdated, TypedEvent, + prelude::*, trap, CiphernodeAdded, CiphernodeRemoved, Committee, CommitteeFinalized, + CommitteeMemberExpelled, CommitteePublished, ConfigurationUpdated, E3Failed, E3Requested, + E3Stage, E3StageChanged, EType, EnclaveEvent, EventContext, EventType, + OperatorActivationChanged, PlaintextOutputPublished, Seed, Sequenced, TicketBalanceUpdated, + TypedEvent, }; use e3_events::{BusHandle, E3id, EnclaveEventData}; use e3_utils::{NotifySync, MAILBOX_LIMIT}; @@ -212,7 +213,7 @@ pub struct Sortition { /// Event bus for error reporting and enclave event subscription. bus: BusHandle, /// Persistent map of finalized committees per E3 - finalized_committees: Persistable>>, + finalized_committees: Persistable>, /// Address for the CiphernodeSelector ciphernode_selector: Addr, /// Address for the current node @@ -229,7 +230,7 @@ pub struct SortitionParams { /// Node state store per chain pub node_state: Persistable>, /// Persistent map of finalized committees per E3 - pub finalized_committees: Persistable>>, + pub finalized_committees: Persistable>, /// Address for the CiphernodeSelector pub ciphernode_selector: Addr, /// Address for the current node @@ -253,7 +254,7 @@ impl Sortition { bus: &BusHandle, backends_store: Repository>, node_state_store: Repository>, - committees_store: Repository>>, + committees_store: Repository>, default_backend: SortitionBackend, ciphernode_selector: Addr, address: &str, @@ -289,6 +290,7 @@ impl Sortition { EventType::CommitteePublished, EventType::PlaintextOutputPublished, EventType::CommitteeFinalized, + EventType::CommitteeMemberExpelled, EventType::E3Failed, EventType::E3StageChanged, ], @@ -331,23 +333,21 @@ impl Sortition { }) } - fn get_committe(&self, e3_id: &E3id) -> Vec { + fn get_committee(&self, e3_id: &E3id) -> Option { self.finalized_committees .get() .and_then(|committees| committees.get(e3_id).cloned()) - .unwrap_or_else(|| Vec::new()) } fn committee_contains(&mut self, e3_id: E3id, node: String) -> bool { - let committee = self.get_committe(&e3_id); - - if committee.len() == 0 { + let Some(committee) = self.get_committee(&e3_id) else { // Non blocking error self.bus.err( EType::Sortition, anyhow!("No finalized committee found for E3 {}", e3_id), ); - } + return false; + }; committee.contains(&node) } @@ -438,6 +438,9 @@ impl Handler for Sortition { EnclaveEventData::CommitteeFinalized(data) => { self.notify_sync(ctx, TypedEvent::new(data, ec)) } + EnclaveEventData::CommitteeMemberExpelled(data) => { + self.notify_sync(ctx, TypedEvent::new(data, ec)) + } _ => (), } } @@ -784,9 +787,64 @@ impl Handler> for Sortition { ); self.finalized_committees.try_mutate(&ec, |mut committees| { - committees.insert(msg.e3_id.clone(), msg.committee.clone()); + committees.insert(msg.e3_id.clone(), Committee::new(msg.committee.clone())); Ok(committees) }) }) } } + +impl Handler> for Sortition { + type Result = (); + + fn handle( + &mut self, + msg: TypedEvent, + _ctx: &mut Self::Context, + ) -> Self::Result { + let (data, ec) = msg.into_components(); + + // Only process raw events from chain (party_id not yet resolved). + // Events we re-publish with party_id set will also arrive here; ignore them. + if data.party_id.is_some() { + return; + } + + trap(EType::Sortition, &self.bus.with_ec(&ec), || { + let node_addr = data.node.to_string(); + + let Some(committee) = self.get_committee(&data.e3_id) else { + warn!( + "CommitteeMemberExpelled for node {} but no finalized committee found for e3_id={}. \ + The committee should always be finalized before expulsions.", + node_addr, data.e3_id + ); + return Ok(()); + }; + + let Some(party_id) = committee.party_id_for(&node_addr) else { + warn!( + "Expelled node {} not found in committee for e3_id={}", + node_addr, data.e3_id + ); + return Ok(()); + }; + + info!( + "Sortition: resolved expelled node {} to party_id={} for e3_id={}, re-publishing enriched event", + node_addr, party_id, data.e3_id + ); + + // Re-publish the event with party_id set to downstream actors + self.bus.publish( + CommitteeMemberExpelled { + party_id: Some(party_id), + ..data + }, + ec, + )?; + + Ok(()) + }) + } +} From 5be3ce8ecf917e8de7580df6fba7920f5f438bb1 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 22 Feb 2026 14:13:33 +0500 Subject: [PATCH 29/32] fix: stop actors with E3 Completed --- crates/aggregator/src/committee_finalizer.rs | 50 +++++++++++++++++-- .../src/keyshare_created_filter_buffer.rs | 9 +++- crates/keyshare/src/threshold_keyshare.rs | 23 --------- crates/request/src/router.rs | 15 ++++++ crates/sortition/src/sortition.rs | 10 ++++ 5 files changed, 80 insertions(+), 27 deletions(-) diff --git a/crates/aggregator/src/committee_finalizer.rs b/crates/aggregator/src/committee_finalizer.rs index a4618f16ee..dcfe621f44 100644 --- a/crates/aggregator/src/committee_finalizer.rs +++ b/crates/aggregator/src/committee_finalizer.rs @@ -6,8 +6,8 @@ use actix::prelude::*; use e3_events::{ - prelude::*, trap, BusHandle, CommitteeFinalizeRequested, CommitteeRequested, EType, - EnclaveEvent, EnclaveEventData, EventType, Shutdown, TypedEvent, + prelude::*, trap, BusHandle, CommitteeFinalizeRequested, CommitteeRequested, E3Failed, E3Stage, + E3StageChanged, EType, EnclaveEvent, EnclaveEventData, EventType, Shutdown, TypedEvent, }; use e3_utils::{NotifySync, MAILBOX_LIMIT}; use std::collections::HashMap; @@ -33,7 +33,12 @@ impl CommitteeFinalizer { let addr = CommitteeFinalizer::new(bus).start(); bus.subscribe_all( - &[EventType::CommitteeRequested, EventType::Shutdown], + &[ + EventType::CommitteeRequested, + EventType::Shutdown, + EventType::E3Failed, + EventType::E3StageChanged, + ], addr.clone().recipient(), ); @@ -57,6 +62,10 @@ impl Handler for CommitteeFinalizer { self.notify_sync(ctx, TypedEvent::new(data, ec)) } EnclaveEventData::Shutdown(data) => self.notify_sync(ctx, data), + EnclaveEventData::E3Failed(data) => self.notify_sync(ctx, TypedEvent::new(data, ec)), + EnclaveEventData::E3StageChanged(data) => { + self.notify_sync(ctx, TypedEvent::new(data, ec)) + } _ => (), } } @@ -166,3 +175,38 @@ impl Handler for CommitteeFinalizer { ctx.stop(); } } + +impl Handler> for CommitteeFinalizer { + type Result = (); + fn handle(&mut self, msg: TypedEvent, ctx: &mut Self::Context) -> Self::Result { + let e3_id_str = msg.e3_id.to_string(); + if let Some(handle) = self.pending_committees.remove(&e3_id_str) { + info!( + e3_id = %msg.e3_id, + reason = ?msg.reason, + "E3 failed — cancelling pending committee finalization timer" + ); + ctx.cancel_future(handle); + } + } +} + +impl Handler> for CommitteeFinalizer { + type Result = (); + fn handle(&mut self, msg: TypedEvent, ctx: &mut Self::Context) -> Self::Result { + match &msg.new_stage { + E3Stage::Complete | E3Stage::Failed => { + let e3_id_str = msg.e3_id.to_string(); + if let Some(handle) = self.pending_committees.remove(&e3_id_str) { + info!( + e3_id = %msg.e3_id, + stage = ?msg.new_stage, + "E3 reached terminal stage — cancelling pending committee finalization timer" + ); + ctx.cancel_future(handle); + } + } + _ => {} + } + } +} diff --git a/crates/aggregator/src/keyshare_created_filter_buffer.rs b/crates/aggregator/src/keyshare_created_filter_buffer.rs index e193461e4b..2426218a9a 100644 --- a/crates/aggregator/src/keyshare_created_filter_buffer.rs +++ b/crates/aggregator/src/keyshare_created_filter_buffer.rs @@ -6,7 +6,7 @@ use actix::prelude::*; -use e3_events::{prelude::*, EnclaveEvent, EnclaveEventData}; +use e3_events::{prelude::*, Die, EnclaveEvent, EnclaveEventData}; use e3_utils::MAILBOX_LIMIT; use std::collections::HashSet; use tracing::info; @@ -94,3 +94,10 @@ impl Handler for KeyshareCreatedFilterBuffer { } } } + +impl Handler for KeyshareCreatedFilterBuffer { + type Result = (); + fn handle(&mut self, _: Die, ctx: &mut Self::Context) -> Self::Result { + ctx.stop(); + } +} diff --git a/crates/keyshare/src/threshold_keyshare.rs b/crates/keyshare/src/threshold_keyshare.rs index f27780c111..f4097f75ab 100644 --- a/crates/keyshare/src/threshold_keyshare.rs +++ b/crates/keyshare/src/threshold_keyshare.rs @@ -1084,29 +1084,6 @@ impl Handler for ThresholdKeyshare { let _ = self.handle_pk_generation_proof_signed(TypedEvent::new(data, ec)); } EnclaveEventData::E3RequestComplete(data) => self.notify_sync(ctx, data), - EnclaveEventData::E3Failed(data) => { - warn!( - "E3 failed: {:?}. Shutting down ThresholdKeyshare for e3_id={}", - data.reason, data.e3_id - ); - self.notify_sync(ctx, E3RequestComplete { e3_id: data.e3_id }); - } - EnclaveEventData::E3StageChanged(data) => { - use e3_events::E3Stage; - match &data.new_stage { - E3Stage::Complete | E3Stage::Failed => { - info!("E3 reached terminal stage {:?}. Shutting down ThresholdKeyshare for e3_id={}", data.new_stage, data.e3_id); - self.notify_sync(ctx, E3RequestComplete { e3_id: data.e3_id }); - } - _ => { - trace!( - "E3 stage changed to {:?} for e3_id={}", - data.new_stage, - data.e3_id - ); - } - } - } EnclaveEventData::ComputeResponse(data) => { self.notify_sync(ctx, TypedEvent::new(data, ec)) } diff --git a/crates/request/src/router.rs b/crates/request/src/router.rs index d7a0a52b7e..c1051099c1 100644 --- a/crates/request/src/router.rs +++ b/crates/request/src/router.rs @@ -23,6 +23,7 @@ use e3_events::prelude::*; use e3_events::trap; use e3_events::BusHandle; use e3_events::E3RequestComplete; +use e3_events::E3Stage; use e3_events::EType; use e3_events::EnclaveEventData; use e3_events::EventType; @@ -201,6 +202,20 @@ impl Handler for E3Router { // Send to bus so all other actors can react to a request being complete. self.bus.publish(event, ctx)?; } + EnclaveEventData::E3Failed(_) => { + let event = E3RequestComplete { + e3_id: e3_id.clone(), + }; + self.bus.publish(event, ctx)?; + } + EnclaveEventData::E3StageChanged(ref data) + if matches!(data.new_stage, E3Stage::Complete | E3Stage::Failed) => + { + let event = E3RequestComplete { + e3_id: e3_id.clone(), + }; + self.bus.publish(event, ctx)?; + } EnclaveEventData::E3RequestComplete(_) => { // Note this will be sent above to the children who can kill themselves based on // the event diff --git a/crates/sortition/src/sortition.rs b/crates/sortition/src/sortition.rs index 541166a1f4..ae070dcaba 100644 --- a/crates/sortition/src/sortition.rs +++ b/crates/sortition/src/sortition.rs @@ -358,6 +358,12 @@ impl Sortition { reason: &str, ec: EventContext, ) -> Result<()> { + self.finalized_committees + .try_mutate(&ec, |mut committees| { + committees.remove(e3_id); + Ok(committees) + })?; + self.node_state.try_mutate(&ec, |mut state_map| { let chain_id = e3_id.chain_id(); let e3_id_str = format!("{}:{}", chain_id, e3_id.e3_id()); @@ -441,6 +447,10 @@ impl Handler for Sortition { EnclaveEventData::CommitteeMemberExpelled(data) => { self.notify_sync(ctx, TypedEvent::new(data, ec)) } + EnclaveEventData::E3Failed(data) => self.notify_sync(ctx, TypedEvent::new(data, ec)), + EnclaveEventData::E3StageChanged(data) => { + self.notify_sync(ctx, TypedEvent::new(data, ec)) + } _ => (), } } From c90ebeb33ea8d9b9d21d80a84d49c79e63da8deb Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 22 Feb 2026 14:18:56 +0500 Subject: [PATCH 30/32] fix: update cargo toml --- Cargo.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index 3d071b5094..95088c2a01 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3409,7 +3409,7 @@ dependencies = [ [[package]] name = "e3-hamt" -version = "0.1.14" +version = "0.1.15" dependencies = [ "anyhow", "bincode 1.3.3", From 1afecc06f919a276090ae8259efe0a04af23b21d Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 22 Feb 2026 14:36:44 +0500 Subject: [PATCH 31/32] fix: review comments --- .../src/keyshare_created_filter_buffer.rs | 2 +- crates/events/src/committee.rs | 40 +++++++++++++------ crates/keyshare/src/threshold_keyshare.rs | 9 +---- crates/request/src/router.rs | 6 --- crates/sortition/src/sortition.rs | 6 --- 5 files changed, 30 insertions(+), 33 deletions(-) diff --git a/crates/aggregator/src/keyshare_created_filter_buffer.rs b/crates/aggregator/src/keyshare_created_filter_buffer.rs index 2426218a9a..8171f1599c 100644 --- a/crates/aggregator/src/keyshare_created_filter_buffer.rs +++ b/crates/aggregator/src/keyshare_created_filter_buffer.rs @@ -78,7 +78,7 @@ impl Handler for KeyshareCreatedFilterBuffer { // Remove expelled node so we don't forward late KeyshareCreated events from them if let Some(ref mut committee) = self.committee { - let node_addr = format!("{:?}", data.node); + let node_addr = data.node.to_string(); info!( "KeyshareCreatedFilterBuffer: removing expelled node {} from committee filter (e3_id={})", node_addr, data.e3_id diff --git a/crates/events/src/committee.rs b/crates/events/src/committee.rs index 1ac2ea6cff..b55a2a04e9 100644 --- a/crates/events/src/committee.rs +++ b/crates/events/src/committee.rs @@ -10,9 +10,11 @@ use std::collections::HashMap; /// Ordered list of committee members where index == party_id. /// /// Provides O(1) address→party_id lookups via an internal index. -/// The index is skipped during serialization and rebuilt lazily on first lookup -/// after deserialization. -#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +/// The index is eagerly rebuilt when the struct is deserialized. +/// +/// `PartialEq` compares only the `members` vec (the canonical data); +/// the `index` is a derived cache. +#[derive(Clone, Debug, Serialize)] pub struct Committee { /// Ordered member list — index == party_id. members: Vec, @@ -21,6 +23,28 @@ pub struct Committee { index: HashMap, } +impl PartialEq for Committee { + fn eq(&self, other: &Self) -> bool { + self.members == other.members + } +} + +impl Eq for Committee {} + +impl<'de> Deserialize<'de> for Committee { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + #[derive(Deserialize)] + struct Inner { + members: Vec, + } + let inner = Inner::deserialize(deserializer)?; + Ok(Committee::new(inner.members)) + } +} + impl Committee { pub fn new(members: Vec) -> Self { let index = members @@ -33,16 +57,6 @@ impl Committee { /// Resolve an address to its party_id (position in the committee list). pub fn party_id_for(&self, addr: &str) -> Option { - // Rebuild index lazily after deserialization (serde skip) - if self.index.is_empty() && !self.members.is_empty() { - // Fallback linear scan when index hasn't been rebuilt - let lower = addr.to_lowercase(); - return self - .members - .iter() - .position(|a| a.to_lowercase() == lower) - .map(|i| i as u64); - } self.index.get(&addr.to_lowercase()).copied() } diff --git a/crates/keyshare/src/threshold_keyshare.rs b/crates/keyshare/src/threshold_keyshare.rs index f4097f75ab..b27ba8f8c1 100644 --- a/crates/keyshare/src/threshold_keyshare.rs +++ b/crates/keyshare/src/threshold_keyshare.rs @@ -35,13 +35,8 @@ use e3_utils::{NotifySync, MAILBOX_LIMIT}; use e3_zk_helpers::CiphernodesCommitteeSize; use fhe::bfv::{PublicKey, SecretKey}; use fhe_traits::{DeserializeParametrized, Serialize}; -use rand::{rngs::OsRng, SeedableRng}; -use rand_chacha::ChaCha20Rng; -use std::{ - collections::HashMap, - mem, - sync::{Arc, Mutex}, -}; +use rand::rngs::OsRng; +use std::{collections::HashMap, mem, sync::Arc}; use tracing::{error, info, trace, warn}; use crate::encryption_key_collector::{ diff --git a/crates/request/src/router.rs b/crates/request/src/router.rs index c1051099c1..93fea43614 100644 --- a/crates/request/src/router.rs +++ b/crates/request/src/router.rs @@ -202,12 +202,6 @@ impl Handler for E3Router { // Send to bus so all other actors can react to a request being complete. self.bus.publish(event, ctx)?; } - EnclaveEventData::E3Failed(_) => { - let event = E3RequestComplete { - e3_id: e3_id.clone(), - }; - self.bus.publish(event, ctx)?; - } EnclaveEventData::E3StageChanged(ref data) if matches!(data.new_stage, E3Stage::Complete | E3Stage::Failed) => { diff --git a/crates/sortition/src/sortition.rs b/crates/sortition/src/sortition.rs index ae070dcaba..ee6e37ba09 100644 --- a/crates/sortition/src/sortition.rs +++ b/crates/sortition/src/sortition.rs @@ -358,12 +358,6 @@ impl Sortition { reason: &str, ec: EventContext, ) -> Result<()> { - self.finalized_committees - .try_mutate(&ec, |mut committees| { - committees.remove(e3_id); - Ok(committees) - })?; - self.node_state.try_mutate(&ec, |mut state_map| { let chain_id = e3_id.chain_id(); let e3_id_str = format!("{}:{}", chain_id, e3_id.e3_id()); From 47e7fc75bfa43145a60251a70289b31a19fde021 Mon Sep 17 00:00:00 2001 From: Hamza Khalid Date: Sun, 22 Feb 2026 14:56:39 +0500 Subject: [PATCH 32/32] fix: review comments --- .../enclave-contracts/contracts/slashing/SlashingManager.sol | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol index ad284c5db5..7cbfd2c680 100644 --- a/packages/enclave-contracts/contracts/slashing/SlashingManager.sol +++ b/packages/enclave-contracts/contracts/slashing/SlashingManager.sol @@ -452,6 +452,7 @@ contract SlashingManager is ISlashingManager, AccessControl { abi.encodeCall(ICircuitVerifier.verify, (zkProof, publicInputs)) ); require(callSuccess, VerifierCallFailed()); + require(returnData.length >= 32, VerifierCallFailed()); bool proofValid = abi.decode(returnData, (bool)); if (proofValid) revert ProofIsValid(); }