From cc2c84f040da1a63372b608adf783f6fe924e0f0 Mon Sep 17 00:00:00 2001 From: Paul Miller Date: Sat, 31 Dec 2022 06:49:09 +0000 Subject: [PATCH] Improve field tests --- test/basic.test.js | 246 +++++++++++++++++++ test/bls12-381.test.js | 520 ----------------------------------------- 2 files changed, 246 insertions(+), 520 deletions(-) diff --git a/test/basic.test.js b/test/basic.test.js index a6a5961..c653fb1 100644 --- a/test/basic.test.js +++ b/test/basic.test.js @@ -15,7 +15,252 @@ import { starkCurve } from '../lib/esm/stark.js'; import { pallas, vesta } from '../lib/esm/pasta.js'; import { bn254 } from '../lib/esm/bn.js'; import { jubjub } from '../lib/esm/jubjub.js'; +import { bls12_381 } from '../lib/esm/bls12-381.js'; +// Fields tests +const FIELDS = { + secp192r1: { Fp: [secp192r1.CURVE.Fp] }, + secp224r1: { Fp: [secp224r1.CURVE.Fp] }, + secp256r1: { Fp: [secp256r1.CURVE.Fp] }, + secp521r1: { Fp: [secp521r1.CURVE.Fp] }, + secp256k1: { Fp: [secp256k1.CURVE.Fp] }, + stark: { Fp: [starkCurve.CURVE.Fp] }, + jubjub: { Fp: [jubjub.CURVE.Fp] }, + ed25519: { Fp: [ed25519.CURVE.Fp] }, + ed448: { Fp: [ed448.CURVE.Fp] }, + bn254: { Fp: [bn254.CURVE.Fp] }, + pallas: { Fp: [pallas.CURVE.Fp] }, + vesta: { Fp: [vesta.CURVE.Fp] }, + bls12: { + Fp: [bls12_381.CURVE.Fp], + Fp2: [ + bls12_381.CURVE.Fp2, + fc.array(fc.bigInt(1n, bls12_381.CURVE.Fp.ORDER - 1n), { + minLength: 2, + maxLength: 2, + }), + (Fp2, num) => Fp2.fromBigTuple([num[0], num[1]]), + ], + // Fp6: [bls12_381.CURVE.Fp6], + Fp12: [ + bls12_381.CURVE.Fp12, + fc.array(fc.bigInt(1n, bls12_381.CURVE.Fp.ORDER - 1n), { + minLength: 12, + maxLength: 12, + }), + (Fp12, num) => Fp12.fromBigTwelve(num), + ], + }, +}; + +for (const c in FIELDS) { + const curve = FIELDS[c]; + for (const f in curve) { + const Fp = curve[f][0]; + const name = `${c}/${f}:`; + const FC_BIGINT = curve[f][1] ? curve[f][1] : fc.bigInt(1n, Fp.ORDER - 1n); + + const create = curve[f][2] ? curve[f][2].bind(null, Fp) : (num) => Fp.create(num); + should(`${name} equality`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + const b = create(num); + deepStrictEqual(Fp.equals(a, b), true); + deepStrictEqual(Fp.equals(b, a), true); + }) + ); + }); + should(`${name} non-equality`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { + const a = create(num1); + const b = create(num2); + deepStrictEqual(Fp.equals(a, b), num1 === num2); + deepStrictEqual(Fp.equals(b, a), num1 === num2); + }) + ); + }); + should(`${name} add/subtract/commutativity`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { + const a = create(num1); + const b = create(num2); + deepStrictEqual(Fp.add(a, b), Fp.add(b, a)); + }) + ); + }); + should(`${name} add/subtract/associativity`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { + const a = create(num1); + const b = create(num2); + const c = create(num3); + deepStrictEqual(Fp.add(a, Fp.add(b, c)), Fp.add(Fp.add(a, b), c)); + }) + ); + }); + should(`${name} add/subtract/x+0=x`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + deepStrictEqual(Fp.add(a, Fp.ZERO), a); + }) + ); + }); + should(`${name} add/subtract/x-0=x`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + deepStrictEqual(Fp.sub(a, Fp.ZERO), a); + deepStrictEqual(Fp.sub(a, a), Fp.ZERO); + }) + ); + }); + should(`${name} add/subtract/negate equality`, () => { + fc.assert( + fc.property(FC_BIGINT, (num1) => { + const a = create(num1); + const b = create(num1); + deepStrictEqual(Fp.sub(Fp.ZERO, a), Fp.negate(a)); + deepStrictEqual(Fp.sub(a, b), Fp.add(a, Fp.negate(b))); + deepStrictEqual(Fp.sub(a, b), Fp.add(a, Fp.mul(b, Fp.create(-1n)))); + }) + ); + }); + should(`${name} add/subtract/negate`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + deepStrictEqual(Fp.negate(a), Fp.sub(Fp.ZERO, a)); + deepStrictEqual(Fp.negate(a), Fp.mul(a, Fp.create(-1n))); + }) + ); + }); + + should(`${name} multiply/commutativity`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { + const a = create(num1); + const b = create(num2); + deepStrictEqual(Fp.mul(a, b), Fp.mul(b, a)); + }) + ); + }); + should(`${name} multiply/associativity`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { + const a = create(num1); + const b = create(num2); + const c = create(num3); + deepStrictEqual(Fp.mul(a, Fp.mul(b, c)), Fp.mul(Fp.mul(a, b), c)); + }) + ); + }); + should(`${name} multiply/distributivity`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { + const a = create(num1); + const b = create(num2); + const c = create(num3); + deepStrictEqual(Fp.mul(a, Fp.add(b, c)), Fp.add(Fp.mul(b, a), Fp.mul(c, a))); + }) + ); + }); + should(`${name} multiply/add equality`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + deepStrictEqual(Fp.mul(a, 0n), Fp.ZERO); + deepStrictEqual(Fp.mul(a, Fp.ZERO), Fp.ZERO); + deepStrictEqual(Fp.mul(a, 1n), a); + deepStrictEqual(Fp.mul(a, Fp.ONE), a); + deepStrictEqual(Fp.mul(a, 2n), Fp.add(a, a)); + deepStrictEqual(Fp.mul(a, 3n), Fp.add(Fp.add(a, a), a)); + deepStrictEqual(Fp.mul(a, 4n), Fp.add(Fp.add(Fp.add(a, a), a), a)); + }) + ); + }); + should(`${name} multiply/square equality`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + deepStrictEqual(Fp.square(a), Fp.mul(a, a)); + }) + ); + }); + should(`${name} multiply/pow equality`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + deepStrictEqual(Fp.pow(a, 0n), Fp.ONE); + deepStrictEqual(Fp.pow(a, 1n), a); + deepStrictEqual(Fp.pow(a, 2n), Fp.mul(a, a)); + deepStrictEqual(Fp.pow(a, 3n), Fp.mul(Fp.mul(a, a), a)); + }) + ); + }); + const isSquare = mod.FpIsSquare(Fp); + should(`${name} multiply/sqrt`, () => { + if (Fp === bls12_381.CURVE.Fp12) return; // Not implemented + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + let root; + try { + root = Fp.sqrt(a); + } catch (e) { + deepStrictEqual(isSquare(a), false); + return; + } + deepStrictEqual(isSquare(a), true); + deepStrictEqual(Fp.equals(Fp.square(root), a), true, 'sqrt(a)^2 == a'); + deepStrictEqual(Fp.equals(Fp.square(Fp.negate(root)), a), true, '(-sqrt(a))^2 == a'); + }) + ); + }); + + should(`${name} div/division by one equality`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + if (Fp.equals(a, Fp.ZERO)) return; // No division by zero + deepStrictEqual(Fp.div(a, Fp.ONE), a); + deepStrictEqual(Fp.div(a, a), Fp.ONE); + }) + ); + }); + should(`${name} zero division equality`, () => { + fc.assert( + fc.property(FC_BIGINT, (num) => { + const a = create(num); + deepStrictEqual(Fp.div(Fp.ZERO, a), Fp.ZERO); + }) + ); + }); + should(`${name} div/division distributivity`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { + const a = create(num1); + const b = create(num2); + const c = create(num3); + deepStrictEqual(Fp.div(Fp.add(a, b), c), Fp.add(Fp.div(a, c), Fp.div(b, c))); + }) + ); + }); + should(`${name} div/division and multiplication equality`, () => { + fc.assert( + fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { + const a = create(num1); + const b = create(num2); + deepStrictEqual(Fp.div(a, b), Fp.mul(a, Fp.invert(b))); + }) + ); + }); + } +} + +// Group tests // prettier-ignore const CURVES = { secp192r1, secp224r1, secp256r1, secp384r1, secp521r1, @@ -29,6 +274,7 @@ const CURVES = { }; const NUM_RUNS = 5; + const getXY = (p) => ({ x: p.x, y: p.y }); function equal(a, b, comment) { diff --git a/test/bls12-381.test.js b/test/bls12-381.test.js index 884df4a..e599b13 100644 --- a/test/bls12-381.test.js +++ b/test/bls12-381.test.js @@ -41,145 +41,7 @@ const getPubKey = (priv) => bls.getPublicKey(priv); { const Fp = bls.Fp; const FC_BIGINT = fc.bigInt(1n, Fp.ORDER - 1n); - should('bls12-381/Fp/equality', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - const b = Fp.create(num); - deepStrictEqual(Fp.equals(a, b), true); - deepStrictEqual(Fp.equals(b, a), true); - }) - ); - }); - should('bls12-381/Fp/non-equality', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - deepStrictEqual(Fp.equals(a, b), num1 === num2); - deepStrictEqual(Fp.equals(b, a), num1 === num2); - }) - ); - }); - should('bls12-381/Fp/add/subtract/commutativity', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - deepStrictEqual(Fp.add(a, b), Fp.add(b, a)); - }) - ); - }); - should('bls12-381/Fp/add/subtract/associativity', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - const c = Fp.create(num3); - deepStrictEqual(Fp.add(a, Fp.add(b, c)), Fp.add(Fp.add(a, b), c)); - }) - ); - }); - should('bls12-381/Fp/add/subtract/x+0=x', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.add(a, Fp.ZERO), a); - }) - ); - }); - should('bls12-381/Fp/add/subtract/x-0=x', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.sub(a, Fp.ZERO), a); - deepStrictEqual(Fp.sub(a, a), Fp.ZERO); - }) - ); - }); - should('bls12-381/Fp/add/subtract/negate equality', () => { - fc.assert( - fc.property(FC_BIGINT, (num1) => { - const a = Fp.create(num1); - const b = Fp.create(num1); - deepStrictEqual(Fp.sub(Fp.ZERO, a), Fp.negate(a)); - deepStrictEqual(Fp.sub(a, b), Fp.add(a, Fp.negate(b))); - deepStrictEqual(Fp.sub(a, b), Fp.add(a, Fp.mul(b, Fp.create(-1n)))); - }) - ); - }); - should('bls12-381/Fp/add/subtract/negate', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.negate(a), Fp.sub(Fp.ZERO, a)); - deepStrictEqual(Fp.negate(a), Fp.mul(a, Fp.create(-1n))); - }) - ); - }); - should('bls12-381/Fp/multiply/commutativity', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - deepStrictEqual(Fp.mul(a, b), Fp.mul(b, a)); - }) - ); - }); - should('bls12-381/Fp/multiply/associativity', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - const c = Fp.create(num3); - deepStrictEqual(Fp.mul(a, Fp.mul(b, c)), Fp.mul(Fp.mul(a, b), c)); - }) - ); - }); - should('bls12-381/Fp/multiply/distributivity', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - const c = Fp.create(num3); - deepStrictEqual(Fp.mul(a, Fp.add(b, c)), Fp.add(Fp.mul(b, a), Fp.mul(c, a))); - }) - ); - }); - should('bls12-381/Fp/multiply/add equality', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.mul(a, Fp.create(0n)), Fp.ZERO); - deepStrictEqual(Fp.mul(a, Fp.ZERO), Fp.ZERO); - deepStrictEqual(Fp.mul(a, Fp.create(1n)), a); - deepStrictEqual(Fp.mul(a, Fp.ONE), a); - deepStrictEqual(Fp.mul(a, Fp.create(2n)), Fp.add(a, a)); - deepStrictEqual(Fp.mul(a, Fp.create(3n)), Fp.add(Fp.add(a, a), a)); - deepStrictEqual(Fp.mul(a, Fp.create(4n)), Fp.add(Fp.add(Fp.add(a, a), a), a)); - }) - ); - }); - should('bls12-381/Fp/multiply/square equality', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.square(a), Fp.mul(a, a)); - }) - ); - }); - should('bls12-381/Fp/multiply/pow equality', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.pow(a, 0n), Fp.ONE); - deepStrictEqual(Fp.pow(a, 1n), a); - deepStrictEqual(Fp.pow(a, 2n), Fp.mul(a, a)); - deepStrictEqual(Fp.pow(a, 3n), Fp.mul(Fp.mul(a, a), a)); - }) - ); - }); should('bls12-381/Fp/multiply/sqrt', () => { let sqr1 = Fp.sqrt(Fp.create(300855555557n)); deepStrictEqual( @@ -188,43 +50,6 @@ const getPubKey = (priv) => bls.getPublicKey(priv); ); throws(() => Fp.sqrt(Fp.create(72057594037927816n))); }); - - should('bls12-381/Fp/div/division by one equality', () => { - fc.assert( - fc.property(fc.bigInt(1n, Fp.ORDER - 1n), (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.div(a, Fp.ONE), a); - deepStrictEqual(Fp.div(a, a), Fp.ONE); - }) - ); - }); - should('bls12-381/Fp/div/division by zero equality', () => { - fc.assert( - fc.property(FC_BIGINT, (num) => { - const a = Fp.create(num); - deepStrictEqual(Fp.div(Fp.ZERO, a), Fp.ZERO); - }) - ); - }); - should('bls12-381/Fp/div/division distributivity', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, FC_BIGINT, (num1, num2, num3) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - const c = Fp.create(num3); - deepStrictEqual(Fp.div(Fp.add(a, b), c), Fp.add(Fp.div(a, c), Fp.div(b, c))); - }) - ); - }); - should('bls12-381/Fp/div/division and multiplication equality', () => { - fc.assert( - fc.property(FC_BIGINT, FC_BIGINT, (num1, num2) => { - const a = Fp.create(num1); - const b = Fp.create(num2); - deepStrictEqual(Fp.div(a, b), Fp.mul(a, Fp.invert(b))); - }) - ); - }); } // Fp2 @@ -234,16 +59,6 @@ const getPubKey = (priv) => bls.getPublicKey(priv); const FC_BIGINT = fc.bigInt(1n, Fp.ORDER - 1n); const FC_BIGINT_2 = fc.array(FC_BIGINT, { minLength: 2, maxLength: 2 }); - should('bls12-381 Fp2/equality', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - const b = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.equals(a, b), true); - deepStrictEqual(Fp2.equals(b, a), true); - }) - ); - }); should('bls12-381 Fp2/non-equality', () => { fc.assert( fc.property(FC_BIGINT_2, FC_BIGINT_2, (num1, num2) => { @@ -254,136 +69,7 @@ const getPubKey = (priv) => bls.getPublicKey(priv); }) ); }); - should('bls12-381 Fp2/add/subtract/commutativity', () => { - fc.assert( - fc.property(FC_BIGINT_2, FC_BIGINT_2, (num1, num2) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num2[0], num2[1]]); - deepStrictEqual(Fp2.add(a, b), Fp2.add(b, a)); - }) - ); - }); - should('bls12-381 Fp2/add/subtract/associativity', () => { - fc.assert( - fc.property(FC_BIGINT_2, FC_BIGINT_2, FC_BIGINT_2, (num1, num2, num3) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num2[0], num2[1]]); - const c = Fp2.fromBigTuple([num3[0], num3[1]]); - deepStrictEqual(Fp2.add(a, Fp2.add(b, c)), Fp2.add(Fp2.add(a, b), c)); - }) - ); - }); - should('bls12-381 Fp2/add/subtract/x+0=x', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.add(a, Fp2.ZERO), a); - }) - ); - }); - should('bls12-381 Fp2/add/subtract/x-0=x', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.sub(a, Fp2.ZERO), a); - deepStrictEqual(Fp2.sub(a, a), Fp2.ZERO); - }) - ); - }); - should('bls12-381 Fp2/add/subtract/negate equality', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num1) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num1[0], num1[1]]); - deepStrictEqual(Fp2.sub(Fp2.ZERO, a), Fp2.negate(a)); - deepStrictEqual(Fp2.sub(a, b), Fp2.add(a, Fp2.negate(b))); - deepStrictEqual(Fp2.sub(a, b), Fp2.add(a, Fp2.mul(b, -1n))); - }) - ); - }); - should('bls12-381 Fp2/add/subtract/negate', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.negate(a), Fp2.sub(Fp2.ZERO, a)); - deepStrictEqual(Fp2.negate(a), Fp2.mul(a, -1n)); - }) - ); - }); - should('bls12-381 Fp2/multiply/commutativity', () => { - fc.assert( - fc.property(FC_BIGINT_2, FC_BIGINT_2, (num1, num2) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num2[0], num2[1]]); - deepStrictEqual(Fp2.mul(a, b), Fp2.mul(b, a)); - }) - ); - }); - should('bls12-381 Fp2/multiply/associativity', () => { - fc.assert( - fc.property(FC_BIGINT_2, FC_BIGINT_2, FC_BIGINT_2, (num1, num2, num3) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num2[0], num2[1]]); - const c = Fp2.fromBigTuple([num3[0], num3[1]]); - deepStrictEqual(Fp2.mul(a, Fp2.mul(b, c)), Fp2.mul(Fp2.mul(a, b), c)); - }) - ); - }); - should('bls12-381 Fp2/multiply/distributivity', () => { - fc.assert( - fc.property(FC_BIGINT_2, FC_BIGINT_2, FC_BIGINT_2, (num1, num2, num3) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num2[0], num2[1]]); - const c = Fp2.fromBigTuple([num3[0], num3[1]]); - deepStrictEqual(Fp2.mul(a, Fp2.add(b, c)), Fp2.add(Fp2.mul(b, a), Fp2.mul(c, a))); - }) - ); - }); - should('bls12-381 Fp2/multiply/add equality', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.mul(a, 0n), Fp2.ZERO); - deepStrictEqual(Fp2.mul(a, Fp2.ZERO), Fp2.ZERO); - deepStrictEqual(Fp2.mul(a, 1n), a); - deepStrictEqual(Fp2.mul(a, Fp2.ONE), a); - deepStrictEqual(Fp2.mul(a, 2n), Fp2.add(a, a)); - deepStrictEqual(Fp2.mul(a, 3n), Fp2.add(Fp2.add(a, a), a)); - deepStrictEqual(Fp2.mul(a, 4n), Fp2.add(Fp2.add(Fp2.add(a, a), a), a)); - }) - ); - }); - should('bls12-381 Fp2/multiply/square equality', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.square(a), Fp2.mul(a, a)); - }) - ); - }); - should('bls12-381 Fp2/multiply/pow equality', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.pow(a, 0n), Fp2.ONE); - deepStrictEqual(Fp2.pow(a, 1n), a); - deepStrictEqual(Fp2.pow(a, 2n), Fp2.mul(a, a)); - deepStrictEqual(Fp2.pow(a, 3n), Fp2.mul(Fp2.mul(a, a), a)); - }) - ); - }); - - should('bls12-381 Fp2/div/distributivity', () => { - fc.assert( - fc.property(FC_BIGINT_2, FC_BIGINT_2, FC_BIGINT_2, (num1, num2, num3) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num2[0], num2[1]]); - const c = Fp2.fromBigTuple([num3[0], num3[1]]); - deepStrictEqual(Fp2.div(Fp2.add(a, b), c), Fp2.add(Fp2.div(a, c), Fp2.div(b, c))); - }) - ); - }); should('bls12-381 Fp2/div/x/1=x', () => { fc.assert( fc.property(FC_BIGINT_2, (num) => { @@ -394,23 +80,6 @@ const getPubKey = (priv) => bls.getPublicKey(priv); }) ); }); - should('bls12-381 Fp2/div/ x/0=0', () => { - fc.assert( - fc.property(FC_BIGINT_2, (num) => { - const a = Fp2.fromBigTuple([num[0], num[1]]); - deepStrictEqual(Fp2.div(Fp2.ZERO, a), Fp2.ZERO); - }) - ); - }); - should('bls12-381 Fp2/div/ multiply equality', () => { - fc.assert( - fc.property(FC_BIGINT_2, FC_BIGINT_2, (num1, num2) => { - const a = Fp2.fromBigTuple([num1[0], num1[1]]); - const b = Fp2.fromBigTuple([num2[0], num2[1]]); - deepStrictEqual(Fp2.div(a, b), Fp2.mul(a, Fp2.invert(b))); - }) - ); - }); should('bls12-381 Fp2/frobenius', () => { // expect(Fp2.FROBENIUS_COEFFICIENTS[0].equals(Fp.ONE)).toBe(true); @@ -472,195 +141,6 @@ const getPubKey = (priv) => bls.getPublicKey(priv); }); } -// Fp12 -{ - const Fp = bls.Fp; - const Fp12 = bls.Fp12; - const FC_BIGINT = fc.bigInt(1n, Fp.ORDER - 1n); - const FC_BIGINT_12 = fc.array(FC_BIGINT, { - minLength: 12, - maxLength: 12, - }); - - should('bls12-381 Fp12/equality', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - const b = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.equals(a, b), true); - deepStrictEqual(Fp12.equals(b, a), true); - }) - ); - }); - should('bls12-381 Fp12/non-equality', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, (num1, num2) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - deepStrictEqual(Fp12.equals(a, b), num1[0] === num2[0] && num1[1] === num2[1]); - deepStrictEqual(Fp12.equals(b, a), num1[0] === num2[0] && num1[1] === num2[1]); - }) - ); - }); - should('bls12-381 Fp12/add/subtract/commutativuty', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, (num1, num2) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - deepStrictEqual(Fp12.add(a, b), Fp12.add(b, a)); - }) - ); - }); - should('bls12-381 Fp12/add/subtract/associativity', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, FC_BIGINT_12, (num1, num2, num3) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - const c = Fp12.fromBigTwelve(num3); - deepStrictEqual(Fp12.add(a, Fp12.add(b, c)), Fp12.add(Fp12.add(a, b), c)); - }) - ); - }); - should('bls12-381 Fp12/add/subtract/x+0=x', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.add(a, Fp12.ZERO), a); - }) - ); - }); - should('bls12-381 Fp12/add/subtract/x-0=x', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.sub(a, Fp12.ZERO), a); - deepStrictEqual(Fp12.sub(a, a), Fp12.ZERO); - }) - ); - }); - should('bls12-381 Fp12/add/subtract/negate equality', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num1) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num1); - deepStrictEqual(Fp12.sub(Fp12.ZERO, a), Fp12.negate(a)); - deepStrictEqual(Fp12.sub(a, b), Fp12.add(a, Fp12.negate(b))); - deepStrictEqual(Fp12.sub(a, b), Fp12.add(a, Fp12.mul(b, -1n))); - }) - ); - }); - should('bls12-381 Fp12/add/subtract/negate', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.negate(a), Fp12.sub(Fp12.ZERO, a)); - deepStrictEqual(Fp12.negate(a), Fp12.mul(a, -1n)); - }) - ); - }); - - should('bls12-381 Fp12/multiply/commutativity', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, (num1, num2) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - deepStrictEqual(Fp12.mul(a, b), Fp12.mul(b, a)); - }) - ); - }); - should('bls12-381 Fp12/multiply/associativity', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, FC_BIGINT_12, (num1, num2, num3) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - const c = Fp12.fromBigTwelve(num3); - deepStrictEqual(Fp12.mul(a, Fp12.mul(b, c)), Fp12.mul(Fp12.mul(a, b), c)); - }) - ); - }); - should('bls12-381 Fp12/multiply/distributivity', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, FC_BIGINT_12, (num1, num2, num3) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - const c = Fp12.fromBigTwelve(num3); - deepStrictEqual(Fp12.mul(a, Fp12.add(b, c)), Fp12.add(Fp12.mul(b, a), Fp12.mul(c, a))); - }) - ); - }); - should('bls12-381 Fp12/multiply/add equality', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.mul(a, 0n), Fp12.ZERO); - deepStrictEqual(Fp12.mul(a, Fp12.ZERO), Fp12.ZERO); - deepStrictEqual(Fp12.mul(a, 1n), a); - deepStrictEqual(Fp12.mul(a, Fp12.ONE), a); - deepStrictEqual(Fp12.mul(a, 2n), Fp12.add(a, a)); - deepStrictEqual(Fp12.mul(a, 3n), Fp12.add(Fp12.add(a, a), a)); - deepStrictEqual(Fp12.mul(a, 4n), Fp12.add(Fp12.add(Fp12.add(a, a), a), a)); - }) - ); - }); - should('bls12-381 Fp12/multiply/square equality', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.square(a), Fp12.mul(a, a)); - }) - ); - }); - should('bls12-381 Fp12/multiply/pow equality', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.pow(a, 0n), Fp12.ONE); - deepStrictEqual(Fp12.pow(a, 1n), a); - deepStrictEqual(Fp12.pow(a, 2n), Fp12.mul(a, a)); - deepStrictEqual(Fp12.pow(a, 3n), Fp12.mul(Fp12.mul(a, a), a)); - }) - ); - }); - - should('bls12-381 Fp12/div/x/1=x', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.div(a, 1n), a); - deepStrictEqual(Fp12.div(a, Fp12.ONE), a); - deepStrictEqual(Fp12.div(a, a), Fp12.ONE); - }) - ); - }); - should('bls12-381 Fp12/div/x/0=0', () => { - fc.assert( - fc.property(FC_BIGINT_12, (num) => { - const a = Fp12.fromBigTwelve(num); - deepStrictEqual(Fp12.div(Fp12.ZERO, a), Fp12.ZERO); - }) - ); - }); - should('bls12-381 Fp12/div/distributivity', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, FC_BIGINT_12, (num1, num2, num3) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - const c = Fp12.fromBigTwelve(num3); - deepStrictEqual(Fp12.div(Fp12.add(a, b), c), Fp12.add(Fp12.div(a, c), Fp12.div(b, c))); - }) - ); - }); - should('bls12-381 Fp12/div/multiply equality', () => { - fc.assert( - fc.property(FC_BIGINT_12, FC_BIGINT_12, (num1, num2) => { - const a = Fp12.fromBigTwelve(num1); - const b = Fp12.fromBigTwelve(num2); - deepStrictEqual(Fp12.div(a, b), Fp12.mul(a, Fp12.invert(b))); - }) - ); - }); -} - // Point { const Fp = bls.Fp;