From fc53098332e1843759114ad7c05118e8fee141ed Mon Sep 17 00:00:00 2001 From: Tom French <15848336+TomAFrench@users.noreply.github.com> Date: Thu, 3 Oct 2024 14:06:13 +0100 Subject: [PATCH] fix: bump minimum noir version to 0.35.0 and address privacy warnings (#24) * feat: address privacy warnings * chore: bump msnv to 0.35.0 --- .github/workflows/test.yml | 4 +- Nargo.toml | 2 +- src/bignum_test.nr | 9 +++- src/fields/U1024.nr | 2 +- src/fields/U2048.nr | 2 +- src/fields/U256.nr | 2 +- src/fields/U384.nr | 2 +- src/fields/U4096.nr | 2 +- src/fields/U512.nr | 2 +- src/fields/U768.nr | 2 +- src/fields/U8192.nr | 2 +- src/fields/bls12_377Fq.nr | 2 +- src/fields/bls12_377Fr.nr | 2 +- src/fields/bls12_381Fq.nr | 2 +- src/fields/bls12_381Fr.nr | 2 +- src/fields/bn254Fq.nr | 2 +- src/fields/ed25519Fq.nr | 2 +- src/fields/ed25519Fr.nr | 2 +- src/fields/mnt4_753Fq.nr | 4 +- src/fields/mnt4_753Fr.nr | 4 +- src/fields/mnt6_753Fq.nr | 4 +- src/fields/mnt6_753Fr.nr | 4 +- src/fields/mod.nr | 74 +++++++++++++++------------------ src/fields/pallasFq.nr | 2 +- src/fields/pallasFr.nr | 2 +- src/fields/secp256k1Fq.nr | 2 +- src/fields/secp256k1Fr.nr | 2 +- src/fields/secp256r1Fq.nr | 2 +- src/fields/secp256r1Fr.nr | 2 +- src/fields/secp384r1Fq.nr | 2 +- src/fields/secp384r1Fr.nr | 2 +- src/fields/vestaFq.nr | 2 +- src/fields/vestaFr.nr | 2 +- src/lib.nr | 8 ++-- src/runtime_bignum.nr | 55 ++++++++++++++++-------- src/runtime_bignum_test.nr | 49 ++++++++++++---------- src/utils/mod.nr | 8 ++-- src/utils/u60_representation.nr | 2 +- 38 files changed, 153 insertions(+), 124 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d8ab990..9012213 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -16,7 +16,7 @@ jobs: strategy: fail-fast: false matrix: - toolchain: [nightly, 0.34.0] + toolchain: [nightly, 0.35.0] steps: - name: Checkout sources uses: actions/checkout@v4 @@ -38,7 +38,7 @@ jobs: - name: Install Nargo uses: noir-lang/noirup@v0.1.3 with: - toolchain: 0.34.0 + toolchain: 0.35.0 - name: Run formatter run: nargo fmt --check diff --git a/Nargo.toml b/Nargo.toml index 848d8a1..4eb9369 100644 --- a/Nargo.toml +++ b/Nargo.toml @@ -2,6 +2,6 @@ name = "bignum" type = "lib" authors = [""] -compiler_version = ">=0.34.0" +compiler_version = ">=0.35.0" [dependencies] diff --git a/src/bignum_test.nr b/src/bignum_test.nr index e8207df..c74875b 100644 --- a/src/bignum_test.nr +++ b/src/bignum_test.nr @@ -10,6 +10,13 @@ use crate::runtime_bignum::BigNumInstance; use crate::BigNumTrait; struct Test2048Params{} + +// See https://github.com/noir-lang/noir/issues/6172 +#[test] +fn silence_warning() { + let _ = Test2048Params {}; +} + impl RuntimeBigNumParamsTrait<18> for Test2048Params { fn modulus_bits() -> u32 { 2048 @@ -85,7 +92,6 @@ impl BigNumParamsTrait<18> for Test2048Params { } type Fq = BigNum<3, BNParams>; -type Fqq = BigNum<18, Test2048Params>; fn test_eq(_: BigNum, __: [Field; N]) where BigNum: BigNumTrait { let a = BigNum::__derive_from_seed([1, 2, 3, 4]); @@ -635,3 +641,4 @@ fn test_expressions() { let wx_constrained = w * x; assert(wx_constrained.limbs == wx.limbs); } + diff --git a/src/fields/U1024.nr b/src/fields/U1024.nr index 44a2e43..a024bbb 100644 --- a/src/fields/U1024.nr +++ b/src/fields/U1024.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct U1024Params {} +pub struct U1024Params {} impl RuntimeBigNumParamsTrait<9> for U1024Params { fn modulus_bits() -> u32 { 1025 diff --git a/src/fields/U2048.nr b/src/fields/U2048.nr index 5637f23..3394e44 100644 --- a/src/fields/U2048.nr +++ b/src/fields/U2048.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct U2048Params {} +pub struct U2048Params {} impl RuntimeBigNumParamsTrait<18> for U2048Params { fn modulus_bits() -> u32 { 2049 diff --git a/src/fields/U256.nr b/src/fields/U256.nr index 03d359d..258ef2e 100644 --- a/src/fields/U256.nr +++ b/src/fields/U256.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct U256Params {} +pub struct U256Params {} impl RuntimeBigNumParamsTrait<3> for U256Params { fn modulus_bits() -> u32 { 257 diff --git a/src/fields/U384.nr b/src/fields/U384.nr index 47af961..b827d68 100644 --- a/src/fields/U384.nr +++ b/src/fields/U384.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct U384_Params {} +pub struct U384_Params {} impl RuntimeBigNumParamsTrait<4> for U384_Params { fn modulus_bits() -> u32 { 385 diff --git a/src/fields/U4096.nr b/src/fields/U4096.nr index f260007..806e2a5 100644 --- a/src/fields/U4096.nr +++ b/src/fields/U4096.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct U4096Params {} +pub struct U4096Params {} impl RuntimeBigNumParamsTrait<35> for U4096Params { fn modulus_bits() -> u32 { 4097 diff --git a/src/fields/U512.nr b/src/fields/U512.nr index 1bd901d..b49c20b 100644 --- a/src/fields/U512.nr +++ b/src/fields/U512.nr @@ -6,7 +6,7 @@ use crate::utils::u60_representation::U60Repr; // a / b = c // b * c + (rem < modulus) = a -struct U512Params {} +pub struct U512Params {} impl RuntimeBigNumParamsTrait<5> for U512Params { fn modulus_bits() -> u32 { 513 diff --git a/src/fields/U768.nr b/src/fields/U768.nr index 06abaf2..b5a41ec 100644 --- a/src/fields/U768.nr +++ b/src/fields/U768.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct U768Params {} +pub struct U768Params {} impl RuntimeBigNumParamsTrait<13> for U768Params { fn modulus_bits() -> u32 { 1537 diff --git a/src/fields/U8192.nr b/src/fields/U8192.nr index 503ae3a..089e16b 100644 --- a/src/fields/U8192.nr +++ b/src/fields/U8192.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct U8192Params {} +pub struct U8192Params {} impl RuntimeBigNumParamsTrait<69> for U8192Params { fn modulus_bits() -> u32 { 8193 diff --git a/src/fields/bls12_377Fq.nr b/src/fields/bls12_377Fq.nr index bcd7504..7c13ca1 100644 --- a/src/fields/bls12_377Fq.nr +++ b/src/fields/bls12_377Fq.nr @@ -21,7 +21,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct BLS12_377_Fq_Params {} +pub struct BLS12_377_Fq_Params {} impl RuntimeBigNumParamsTrait<4> for BLS12_377_Fq_Params { fn modulus_bits() -> u32 { 377 diff --git a/src/fields/bls12_377Fr.nr b/src/fields/bls12_377Fr.nr index 6ac4f40..c44c18c 100644 --- a/src/fields/bls12_377Fr.nr +++ b/src/fields/bls12_377Fr.nr @@ -21,7 +21,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct BLS12_377_Fr_Params {} +pub struct BLS12_377_Fr_Params {} impl RuntimeBigNumParamsTrait<3> for BLS12_377_Fr_Params { fn modulus_bits() -> u32 { 253 diff --git a/src/fields/bls12_381Fq.nr b/src/fields/bls12_381Fq.nr index f602c3a..f788c44 100644 --- a/src/fields/bls12_381Fq.nr +++ b/src/fields/bls12_381Fq.nr @@ -19,7 +19,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct BLS12_381_Fq_Params {} +pub struct BLS12_381_Fq_Params {} impl RuntimeBigNumParamsTrait<4> for BLS12_381_Fq_Params { fn modulus_bits() -> u32 { 381 diff --git a/src/fields/bls12_381Fr.nr b/src/fields/bls12_381Fr.nr index 5474e50..89b4a1d 100644 --- a/src/fields/bls12_381Fr.nr +++ b/src/fields/bls12_381Fr.nr @@ -19,7 +19,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct BLS12_381_Fr_Params {} +pub struct BLS12_381_Fr_Params {} impl RuntimeBigNumParamsTrait<3> for BLS12_381_Fr_Params { fn modulus_bits() -> u32 { 255 diff --git a/src/fields/bn254Fq.nr b/src/fields/bn254Fq.nr index 32dc391..0d40eba 100644 --- a/src/fields/bn254Fq.nr +++ b/src/fields/bn254Fq.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct BNParams {} +pub struct BNParams {} impl RuntimeBigNumParamsTrait<3> for BNParams { fn modulus_bits() -> u32 { 254 diff --git a/src/fields/ed25519Fq.nr b/src/fields/ed25519Fq.nr index 9242a12..cf7cb66 100644 --- a/src/fields/ed25519Fq.nr +++ b/src/fields/ed25519Fq.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::BigNumParamsTrait as BigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct ED25519_Fq_Params {} +pub struct ED25519_Fq_Params {} impl RuntimeBigNumParamsTrait<3> for ED25519_Fq_Params { fn modulus_bits() -> u32 { 255 diff --git a/src/fields/ed25519Fr.nr b/src/fields/ed25519Fr.nr index 8d6a686..2673458 100644 --- a/src/fields/ed25519Fr.nr +++ b/src/fields/ed25519Fr.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct ED25519_Fr_Params {} +pub struct ED25519_Fr_Params {} impl RuntimeBigNumParamsTrait<3> for ED25519_Fr_Params { fn modulus_bits() -> u32 { 253 diff --git a/src/fields/mnt4_753Fq.nr b/src/fields/mnt4_753Fq.nr index ad8bad9..d2b4df2 100644 --- a/src/fields/mnt4_753Fq.nr +++ b/src/fields/mnt4_753Fq.nr @@ -17,14 +17,14 @@ //! * G2 curve equation: y^2 = x^3 + Ax + B, where //! * A = Fq2 = (a * NON_RESIDUE, 0) //! * B = Fq2(0, b * NON_RESIDUE) -//! * NON_RESIDUE = 13 is the quadratic non-residue used to construct the +//! * NON_RESIDUE = 13 is the quadratic non-residue used to conpub struct the //! extension field Fq2 use crate::BigNumParamsTrait; use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct MNT4_753_Fq_Params {} +pub struct MNT4_753_Fq_Params {} impl RuntimeBigNumParamsTrait<7> for MNT4_753_Fq_Params { fn modulus_bits() -> u32 { 753 diff --git a/src/fields/mnt4_753Fr.nr b/src/fields/mnt4_753Fr.nr index 145c0a7..4142fe8 100644 --- a/src/fields/mnt4_753Fr.nr +++ b/src/fields/mnt4_753Fr.nr @@ -17,14 +17,14 @@ //! * G2 curve equation: y^2 = x^3 + Ax + B, where //! * A = Fq2 = (a * NON_RESIDUE, 0) //! * B = Fq2(0, b * NON_RESIDUE) -//! * NON_RESIDUE = 13 is the quadratic non-residue used to construct the +//! * NON_RESIDUE = 13 is the quadratic non-residue used to conpub struct the //! extension field Fq2 use crate::BigNumParamsTrait; use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct MNT4_753_Fr_Params {} +pub struct MNT4_753_Fr_Params {} impl RuntimeBigNumParamsTrait<7> for MNT4_753_Fr_Params { fn modulus_bits() -> u32 { 753 diff --git a/src/fields/mnt6_753Fq.nr b/src/fields/mnt6_753Fq.nr index 9c88054..c581c56 100644 --- a/src/fields/mnt6_753Fq.nr +++ b/src/fields/mnt6_753Fq.nr @@ -17,14 +17,14 @@ //! * G2 curve equation: y^2 = x^3 + Ax + B, where //! * A = Fq3(0, 0, a) //! * B = Fq3(b * NON_RESIDUE, 0, 0) -//! * NON_RESIDUE = 11 is the cubic non-residue used to construct the +//! * NON_RESIDUE = 11 is the cubic non-residue used to conpub struct the //! extension field Fq3 use crate::BigNumParamsTrait; use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct MNT6_753_Fq_Params {} +pub struct MNT6_753_Fq_Params {} impl RuntimeBigNumParamsTrait<7> for MNT6_753_Fq_Params { fn modulus_bits() -> u32 { 753 diff --git a/src/fields/mnt6_753Fr.nr b/src/fields/mnt6_753Fr.nr index 438055b..cb83e36 100644 --- a/src/fields/mnt6_753Fr.nr +++ b/src/fields/mnt6_753Fr.nr @@ -17,14 +17,14 @@ //! * G2 curve equation: y^2 = x^3 + Ax + B, where //! * A = Fq3(0, 0, a) //! * B = Fq3(b * NON_RESIDUE, 0, 0) -//! * NON_RESIDUE = 11 is the cubic non-residue used to construct the +//! * NON_RESIDUE = 11 is the cubic non-residue used to conpub struct the //! extension field Fq3 use crate::BigNumParamsTrait; use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct MNT6_753_Fr_Params {} +pub struct MNT6_753_Fr_Params {} impl RuntimeBigNumParamsTrait<7> for MNT6_753_Fr_Params { fn modulus_bits() -> u32 { 753 diff --git a/src/fields/mod.nr b/src/fields/mod.nr index d24f3c3..db44ec3 100644 --- a/src/fields/mod.nr +++ b/src/fields/mod.nr @@ -1,37 +1,35 @@ -mod bn254Fq; -mod bls12_377Fq; -mod bls12_377Fr; -mod bls12_381Fr; -mod bls12_381Fq; -mod ed25519Fq; -mod ed25519Fr; -mod mnt4_753Fq; -mod mnt4_753Fr; -mod mnt6_753Fq; -mod mnt6_753Fr; -mod pallasFq; -mod pallasFr; -mod secp256k1Fq; -mod secp256k1Fr; -mod secp256r1Fq; -mod secp256r1Fr; -mod secp384r1Fq; -mod secp384r1Fr; -mod vestaFq; -mod vestaFr; -mod U256; -mod U384; -mod U512; -mod U768; -mod U1024; -mod U2048; -mod U4096; -mod U8192; +pub mod bn254Fq; +pub mod bls12_377Fq; +pub mod bls12_377Fr; +pub mod bls12_381Fr; +pub mod bls12_381Fq; +pub mod ed25519Fq; +pub mod ed25519Fr; +pub mod mnt4_753Fq; +pub mod mnt4_753Fr; +pub mod mnt6_753Fq; +pub mod mnt6_753Fr; +pub mod pallasFq; +pub mod pallasFr; +pub mod secp256k1Fq; +pub mod secp256k1Fr; +pub mod secp256r1Fq; +pub mod secp256r1Fr; +pub mod secp384r1Fq; +pub mod secp384r1Fr; +pub mod vestaFq; +pub mod vestaFr; +pub mod U256; +pub mod U384; +pub mod U512; +pub mod U768; +pub mod U1024; +pub mod U2048; +pub mod U4096; +pub mod U8192; -use crate::BigNum; pub use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; -use crate::fields::bn254Fq::BNParams; /** * @brief Parameter definitions for generic fields of varying bit lengths @@ -39,37 +37,33 @@ use crate::fields::bn254Fq::BNParams; * modulus is a witness value and cannot be predefined * e.g. 2048-bit RSA) **/ -struct Params512 {} +pub struct Params512 {} impl RuntimeBigNumParamsTrait<5> for Params512 { fn modulus_bits() -> u32 { 512 } } -struct Params768 {} +pub struct Params768 {} impl RuntimeBigNumParamsTrait<7> for Params768 { fn modulus_bits() -> u32 { 768 } } -struct Params1024 {} +pub struct Params1024 {} impl RuntimeBigNumParamsTrait<9> for Params1024 { fn modulus_bits() -> u32 { 1024 } } -struct Params2048 {} +pub struct Params2048 {} impl RuntimeBigNumParamsTrait<18> for Params2048 { fn modulus_bits() -> u32 { 2048 } } -struct Params4096 {} +pub struct Params4096 {} impl RuntimeBigNumParamsTrait<35> for Params4096 { fn modulus_bits() -> u32 { 4096 } } - -// example typedef when using a defined bignum instance -type Fq = BigNum<3, BNParams>; - diff --git a/src/fields/pallasFq.nr b/src/fields/pallasFq.nr index fec36d2..af65272 100644 --- a/src/fields/pallasFq.nr +++ b/src/fields/pallasFq.nr @@ -18,7 +18,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Pallas_Fq_Params {} +pub struct Pallas_Fq_Params {} impl RuntimeBigNumParamsTrait<3> for Pallas_Fq_Params { fn modulus_bits() -> u32 { 255 diff --git a/src/fields/pallasFr.nr b/src/fields/pallasFr.nr index e055ed9..e3960d9 100644 --- a/src/fields/pallasFr.nr +++ b/src/fields/pallasFr.nr @@ -18,7 +18,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Pallas_Fr_Params {} +pub struct Pallas_Fr_Params {} impl RuntimeBigNumParamsTrait<3> for Pallas_Fr_Params { fn modulus_bits() -> u32 { 255 diff --git a/src/fields/secp256k1Fq.nr b/src/fields/secp256k1Fq.nr index aa9789f..1f3741e 100644 --- a/src/fields/secp256k1Fq.nr +++ b/src/fields/secp256k1Fq.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Secp256k1_Fq_Params {} +pub struct Secp256k1_Fq_Params {} impl RuntimeBigNumParamsTrait<3> for Secp256k1_Fq_Params { fn modulus_bits() -> u32 { 256 diff --git a/src/fields/secp256k1Fr.nr b/src/fields/secp256k1Fr.nr index 0241570..6d604ea 100644 --- a/src/fields/secp256k1Fr.nr +++ b/src/fields/secp256k1Fr.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Secp256k1_Fr_Params {} +pub struct Secp256k1_Fr_Params {} impl RuntimeBigNumParamsTrait<3> for Secp256k1_Fr_Params { fn modulus_bits() -> u32 { 256 diff --git a/src/fields/secp256r1Fq.nr b/src/fields/secp256r1Fq.nr index 9603a0b..2023f04 100644 --- a/src/fields/secp256r1Fq.nr +++ b/src/fields/secp256r1Fq.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Secp256r1_Fq_Params {} +pub struct Secp256r1_Fq_Params {} impl RuntimeBigNumParamsTrait<3> for Secp256r1_Fq_Params { fn modulus_bits() -> u32 { 256 diff --git a/src/fields/secp256r1Fr.nr b/src/fields/secp256r1Fr.nr index 0fefbd7..e028721 100644 --- a/src/fields/secp256r1Fr.nr +++ b/src/fields/secp256r1Fr.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Secp256r1_Fr_Params {} +pub struct Secp256r1_Fr_Params {} impl RuntimeBigNumParamsTrait<3> for Secp256r1_Fr_Params { fn modulus_bits() -> u32 { 256 diff --git a/src/fields/secp384r1Fq.nr b/src/fields/secp384r1Fq.nr index 7c8a9b9..ccb39ef 100644 --- a/src/fields/secp384r1Fq.nr +++ b/src/fields/secp384r1Fq.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Secp384r1_Fq_Params {} +pub struct Secp384r1_Fq_Params {} impl RuntimeBigNumParamsTrait<4> for Secp384r1_Fq_Params { fn modulus_bits() -> u32 { 384 diff --git a/src/fields/secp384r1Fr.nr b/src/fields/secp384r1Fr.nr index 16ed6c2..6ed9764 100644 --- a/src/fields/secp384r1Fr.nr +++ b/src/fields/secp384r1Fr.nr @@ -3,7 +3,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Secp384r1_Fr_Params {} +pub struct Secp384r1_Fr_Params {} impl RuntimeBigNumParamsTrait<4> for Secp384r1_Fr_Params { fn modulus_bits() -> u32 { 384 diff --git a/src/fields/vestaFq.nr b/src/fields/vestaFq.nr index 4e2e7b6..fbbefe9 100644 --- a/src/fields/vestaFq.nr +++ b/src/fields/vestaFq.nr @@ -19,7 +19,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Vesta_Fq_Params {} +pub struct Vesta_Fq_Params {} impl RuntimeBigNumParamsTrait<3> for Vesta_Fq_Params { fn modulus_bits() -> u32 { 255 diff --git a/src/fields/vestaFr.nr b/src/fields/vestaFr.nr index 17b6e25..d5ef72b 100644 --- a/src/fields/vestaFr.nr +++ b/src/fields/vestaFr.nr @@ -19,7 +19,7 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; use crate::utils::u60_representation::U60Repr; -struct Vesta_Fr_Params {} +pub struct Vesta_Fr_Params {} impl RuntimeBigNumParamsTrait<3> for Vesta_Fr_Params { fn modulus_bits() -> u32 { 255 diff --git a/src/lib.nr b/src/lib.nr index 315a43b..de450e4 100644 --- a/src/lib.nr +++ b/src/lib.nr @@ -1,7 +1,7 @@ -mod utils; +pub(crate) mod utils; mod bignum_test; -mod fields; -mod runtime_bignum; +pub mod fields; +pub(crate) mod runtime_bignum; mod runtime_bignum_test; pub use crate::utils::u60_representation::U60Repr; @@ -10,7 +10,7 @@ pub use crate::runtime_bignum::BigNumInstanceTrait as RuntimeBigNumInstanceTrait pub use crate::runtime_bignum::BigNumParamsTrait as RuntimeBigNumParamsTrait; pub use crate::runtime_bignum::BigNumTrait as RuntimeBigNumTrait; -struct BigNum { +pub struct BigNum { limbs: [Field; N] } diff --git a/src/runtime_bignum.nr b/src/runtime_bignum.nr index ed05b68..cd7e45e 100644 --- a/src/runtime_bignum.nr +++ b/src/runtime_bignum.nr @@ -1,4 +1,3 @@ -use dep::std; use crate::utils::u60_representation::U60Repr; use crate::utils::split_bits; use crate::BigNum; @@ -7,7 +6,7 @@ use crate::BigNum; * e.g. RSA where the modulus is a witness value as it changes for every RSA signature * tee `lib.nr` for a trait definition where the modulus is known at compile time **/ -trait BigNumTrait { +pub trait BigNumTrait { fn new() -> Self; fn one() -> Self; fn from(limbs: [Field]) -> Self; @@ -28,7 +27,7 @@ trait BigNumTrait { * BigNumInstance wraps the modulus parameter (as well as a Barret reduction parameter), * which is required for the majority of BigNum operations **/ -trait BigNumInstanceTrait where BN: BigNumTrait { +pub trait BigNumInstanceTrait where BN: BigNumTrait { fn modulus(self) -> BN; fn __derive_from_seed(self, seed: [u8; SeedBytes]) -> BN; fn eq(self, lhs: BN, rhs: BN) -> bool; @@ -79,7 +78,7 @@ trait BigNumInstanceTrait where BN: BigNumTrait { * @brief BigNumParamsTrait defines a "field" with which to parametrise BigNum. * @description The "field" does not need to be prime, any value *should* work (TODO: test!) **/ -trait BigNumParamsTrait { +pub trait BigNumParamsTrait { /** * @brief modulus_bits = log2(modulus) rounded up **/ @@ -88,7 +87,7 @@ trait BigNumParamsTrait { fn has_multiplicative_inverse() -> bool { true } } -struct BigNumInstance { +pub struct BigNumInstance { /** * @brief modulus: all BigNum operations are evaluated modulo this value @@ -894,7 +893,11 @@ impl BigNumInstance where Params: BigNumParamsTra flags } - unconstrained fn __pow_impl(self, val: BigNum, exponent: BigNum) -> BigNum { + unconstrained fn __pow_impl( + self, + val: BigNum, + exponent: BigNum + ) -> BigNum { let x: U60Repr = U60Repr::from(exponent.limbs); let num_bits = Params::modulus_bits() + 1; @@ -934,12 +937,20 @@ impl BigNumInstance where Params: BigNumParamsTra (quotient, remainder) } - unconstrained fn __mul_impl(self, lhs: BigNum, rhs: BigNum) -> BigNum { + unconstrained fn __mul_impl( + self, + lhs: BigNum, + rhs: BigNum + ) -> BigNum { let (_, b) = self.__mul_with_quotient(lhs, rhs); b } - unconstrained fn __add_impl(self, lhs: BigNum, rhs: BigNum) -> BigNum { + unconstrained fn __add_impl( + self, + lhs: BigNum, + rhs: BigNum + ) -> BigNum { let x_u60 : U60Repr = U60Repr::from(lhs.limbs); let y_u60 : U60Repr = U60Repr::from(rhs.limbs); @@ -1111,7 +1122,10 @@ impl BigNumInstance where Params: BigNumParamsTra (result, carry_flags, borrow_flags, underflow) } - unconstrained fn __neg_with_flags(self, val: BigNum) -> (BigNum, [bool; N]) { + unconstrained fn __neg_with_flags( + self, + val: BigNum + ) -> (BigNum, [bool; N]) { let f: [Field; N] = val.limbs; let x_u60 : U60Repr = U60Repr::from(f); let mut result_u60 : U60Repr = U60Repr { limbs: [0; 2 * N] }; @@ -1137,7 +1151,11 @@ impl BigNumInstance where Params: BigNumParamsTra * @brief given inputs `x, y` compute 2p + x - y (unconstrained) * @description see `__neg` for why we use 2p instead of p **/ - unconstrained fn __sub_impl(self, lhs: BigNum, rhs: BigNum) -> BigNum { + unconstrained fn __sub_impl( + self, + lhs: BigNum, + rhs: BigNum + ) -> BigNum { self.__add(lhs, self.__neg(rhs)) } @@ -1149,7 +1167,10 @@ impl BigNumInstance where Params: BigNumParamsTra self.__pow(val, result) } - unconstrained fn batch_invert_impl(self, x: [BigNum; M]) -> [BigNum; M] { + unconstrained fn batch_invert_impl( + self, + x: [BigNum; M] + ) -> [BigNum; M] { // TODO: ugly! Will fail if input slice is empty let mut accumulator: BigNum = BigNum::one(); let mut result: [BigNum; M] = [BigNum::new(); M]; @@ -1202,7 +1223,11 @@ impl BigNumInstance where Params: BigNumParamsTra result } - unconstrained fn __div_impl(self, numerator: BigNum, divisor: BigNum) -> BigNum { + unconstrained fn __div_impl( + self, + numerator: BigNum, + divisor: BigNum + ) -> BigNum { let t0 = self.__invmod(divisor); self.__mul(numerator, t0) } @@ -1215,11 +1240,7 @@ impl BigNumInstance where Params: BigNumParamsTra // We know that, for a valid bignum element, the limbs in `x` will be <2^{120} // Therefore each of the limbs in `p` (except the most significant) will borrow 2^{120} from the more significant limb. // Finally, to ensure we do not underflow in the most significant limb, we use `2p` instead of `p` - unconstrained fn __add_linear_expression( - self, - x: [BigNum; M], - flags: [bool; M] - ) -> ([Field; N]) { + unconstrained fn __add_linear_expression(self, x: [BigNum; M], flags: [bool; M]) -> ([Field; N]) { // TODO, validate we do not overflow N2 when multiplying and N when adding let mut sum: [Field; N] = [0; N]; // TODO: ugly! Will fail if input array is empty diff --git a/src/runtime_bignum_test.nr b/src/runtime_bignum_test.nr index 210464c..d60eacb 100644 --- a/src/runtime_bignum_test.nr +++ b/src/runtime_bignum_test.nr @@ -3,8 +3,15 @@ use crate::runtime_bignum::BigNumInstance; use crate::runtime_bignum::BigNumParamsTrait; use crate::utils::u60_representation::U60Repr; use crate::fields::bn254Fq::BNParams as BNParams; -use crate::fields::bn254Fq::BN254INSTANCE; + struct Test2048Params {} + +// See https://github.com/noir-lang/noir/issues/6172 +#[test] +fn silence_warning() { + let _ = Test2048Params {}; +} + impl BigNumParamsTrait<18> for Test2048Params { fn modulus_bits() -> u32 { 2048 @@ -56,9 +63,9 @@ fn get_2048_BN_instance() -> BigNumInstance<18, Test2048Params> { } type Fq = BigNum<3, BNParams>; -type FqInstance = BigNumInstance<3, BNParams>; -type Fqq = BigNum<18, Test2048Params>; -type FqqInstance = BigNumInstance<18, Test2048Params>; +// type FqInstance = BigNumInstance<3, BNParams>; +// type Fqq = BigNum<18, Test2048Params>; +// type FqqInstance = BigNumInstance<18, Test2048Params>; fn test_eq(BNInstance: BigNumInstance) where Params: BigNumParamsTrait { let a: BigNum = BNInstance.__derive_from_seed([1, 2, 3, 4]); @@ -187,12 +194,12 @@ fn assert_is_not_equal_overloaded_fail(bn: BigNumInstance = U60Repr::from(instance.modulus().limbs); @@ -278,55 +285,55 @@ fn test_add_modulus_overflow() { #[test] fn test_mul_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); test_mul(instance); } #[test] fn test_add_BN2() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); test_add(instance); } #[test] fn test_div_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); test_div(instance); } #[test] fn test_invmod_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); test_invmod(instance); } #[test] fn test_assert_is_not_equal_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); assert_is_not_equal(instance); } #[test(should_fail_with = "asssert_is_not_equal fail")] fn test_assert_is_not_equal_fail_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); assert_is_not_equal_fail(instance); } #[test(should_fail_with = "asssert_is_not_equal fail")] fn test_assert_is_not_equal_overloaded_lhs_fail_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); assert_is_not_equal_overloaded_lhs_fail(instance); } #[test(should_fail_with = "asssert_is_not_equal fail")] fn test_assert_is_not_equal_overloaded_rhs_fail_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); assert_is_not_equal_overloaded_rhs_fail(instance); } #[test(should_fail_with = "asssert_is_not_equal fail")] fn test_assert_is_not_equal_overloaded_fail_BN() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); assert_is_not_equal_overloaded_fail(instance); } @@ -468,7 +475,7 @@ fn test_2048_bit_quadratic_expression() { #[test] fn test_expressions() { - let instance = BN254INSTANCE; + let instance = BNParams::get_instance(); let x: [Field; 6] = [ 0x000000000000000000000000000000000083684820ff40795b8d9f1be2220cba, 0x0000000000000000000000000000000000d4924fbdc522b07b6cd0ef5508fd66, 0x0000000000000000000000000000000000d48f6c43c5930f3d70d6db09a48f4a, 0x0000000000000000000000000000000000e7f72b2c0756704bea85be38352b34, 0x00000000000000000000000000000000000000000000000000000000b05d5ac5, 0 diff --git a/src/utils/mod.nr b/src/utils/mod.nr index b670a2d..ca761e4 100644 --- a/src/utils/mod.nr +++ b/src/utils/mod.nr @@ -1,4 +1,4 @@ -mod u60_representation; -mod split_bits; -mod u60_representation_test; -mod msb; +pub(crate) mod u60_representation; +pub(crate) mod split_bits; +pub(crate) mod u60_representation_test; +pub(crate) mod msb; diff --git a/src/utils/u60_representation.nr b/src/utils/u60_representation.nr index f9c1472..21d3b89 100644 --- a/src/utils/u60_representation.nr +++ b/src/utils/u60_representation.nr @@ -8,7 +8,7 @@ use crate::utils::msb::get_msb64; * It is helpful to use u60 types when evaluating addition operations that can overflow the field modulus, * as well as when performing bit shifts. */ -struct U60Repr { +pub struct U60Repr { limbs: [u64; N * NumSegments] }