From e5612f57055c2ce87b04ded8da99e32295dea3e6 Mon Sep 17 00:00:00 2001 From: Mamy Ratsimbazafy Date: Thu, 16 Feb 2023 12:45:05 +0100 Subject: [PATCH] Multi-Scalar-Multiplication / Linear combination (#220) * unoptimized msm * MSM: reorder loops * add a signed windowed recoding technique * improve wNAF table access * use batchAffine * revamp EC tests * MSM signed digit support * refactor MSM: recode signed ahead of time * missing test vector * refactor allocs and Alloca sideeffect * add an endomorphism threshold * Add Jacobian extended coordinates * refactor recodings, prepare for parallelizable on-the-fly signed recoding * recoding changes, introduce proper NAF for pairings * more pairings refactoring, introduce miller accumulator for EVM * some optim to the addchain miller loop * start optimizing multi-pairing * finish multi-miller loop refactoring * minor tuning * MSM: signed encoding suitable for parallelism (no precompute) * cleanup signed window encoding * add prefetching * add metering * properly init result to infinity * comment on prefetching * introduce vartime inversion for batch additions * fix JacExt infinity conversion * add batchAffine for MSM, though slower than JacExtended at the moment * add a batch affine scheduler for MSM * Add Multi-Scalar-Multiplication endomorphism acceleration * some tuning * signed integer fixes + 32-bit + tuning * Some more tuning * common msm bench + don't use affine for c < 9 * nit --- benchmarks/bench_ec_g1.nim | 34 +- benchmarks/bench_ec_g1_batch.nim | 35 +- benchmarks/bench_ec_g1_msm_bls12_381.nim | 60 + benchmarks/bench_ec_g1_msm_bn254_snarks.nim | 59 + benchmarks/bench_ec_g1_scalar_mul.nim | 81 ++ benchmarks/bench_ec_g2.nim | 32 +- benchmarks/bench_ec_g2_scalar_mul.nim | 80 ++ benchmarks/bench_elliptic_template.nim | 165 ++- benchmarks/bench_fields_template.nim | 7 + benchmarks/bench_fp.nim | 1 + benchmarks/bench_fp12.nim | 1 + benchmarks/bench_fp2.nim | 1 + benchmarks/bench_fp4.nim | 1 + benchmarks/bench_fp6.nim | 1 + benchmarks/bench_pairing_template.nim | 4 +- benchmarks/bench_summary_template.nim | 4 +- constantine.nimble | 106 +- constantine/ethereum_evm_precompiles.nim | 36 +- constantine/math/arithmetic/bigints.nim | 333 +++++- constantine/math/arithmetic/finite_fields.nim | 35 +- constantine/math/arithmetic/limbs_exgcd.nim | 240 +++- .../math/arithmetic/limbs_unsaturated.nim | 2 +- .../math/config/curves_declaration.nim | 11 +- .../math/constants/bls12_377_pairings.nim | 8 +- .../math/constants/bls12_377_subgroups.nim | 47 +- .../math/constants/bls12_381_pairings.nim | 8 +- .../math/constants/bls12_381_subgroups.nim | 18 +- .../math/constants/bn254_nogami_pairings.nim | 15 +- .../math/constants/bn254_snarks_pairings.nim | 3 +- .../math/constants/bw6_761_pairings.nim | 3 +- .../math/constants/pallas_subgroups.nim | 4 +- .../math/constants/secp256k1_subgroups.nim | 37 + .../math/constants/vesta_subgroups.nim | 4 +- .../math/constants/zoo_endomorphisms.nim | 7 + constantine/math/constants/zoo_subgroups.nim | 6 +- .../math/elliptic/ec_endomorphism_accel.nim | 4 +- .../math/elliptic/ec_multi_scalar_mul.nim | 411 +++++++ .../ec_multi_scalar_mul_scheduler.nim | 611 ++++++++++ constantine/math/elliptic/ec_scalar_mul.nim | 1 + .../math/elliptic/ec_scalar_mul_vartime.nim | 128 +++ .../ec_shortweierstrass_batch_ops.nim | 154 ++- ...ec_shortweierstrass_batch_ops_parallel.nim | 16 +- .../elliptic/ec_shortweierstrass_jacobian.nim | 61 +- .../ec_shortweierstrass_jacobian_extended.nim | 371 ++++++ .../ec_shortweierstrass_projective.nim | 57 +- constantine/math/extension_fields/towers.nim | 110 +- constantine/math/io/io_ec.nim | 5 +- .../math/pairings/cyclotomic_subgroups.nim | 2 +- constantine/math/pairings/miller_loops.nim | 355 +++--- constantine/math/pairings/pairings_bls12.nim | 33 +- constantine/math/pairings/pairings_bn.nim | 51 +- .../math/pairings/pairings_bw6_761.nim | 25 +- .../math/pairings/pairings_generic.nim | 6 +- constantine/platforms/abstractions.nim | 179 ++- constantine/platforms/allocs.nim | 25 +- constantine/platforms/bithacks.nim | 10 +- constantine/platforms/codecs.nim | 2 +- .../compilers/compiler_optim_hints.nim | 151 +++ .../platforms/constant_time/ct_routines.nim | 33 +- constantine/platforms/primitives.nim | 31 +- constantine/platforms/signed_secret_words.nim | 195 ---- constantine/signatures/bls_signatures.nim | 38 +- helpers/prng_unsafe.nim | 13 +- metering/m_msm.nim | 44 + metering/m_pairings.nim | 21 +- metering/reports.nim | 14 +- metering/tracer.nim | 22 +- sage/derive_pairing.sage | 7 +- sage/testgen_scalar_mul.sage | 25 +- .../math/support/ec_reference_scalar_mult.nim | 71 -- tests/math/t_bigints.nim | 67 +- tests/math/t_bigints_multimod.nim | 2 +- tests/math/t_ec_frobenius.nim | 10 +- tests/math/t_ec_sage_bls12_377.nim | 33 +- tests/math/t_ec_sage_bls12_381.nim | 33 +- tests/math/t_ec_sage_bn254_nogami.nim | 33 +- tests/math/t_ec_sage_bn254_snarks.nim | 33 +- tests/math/t_ec_sage_bw6_761_g1.nim | 33 +- tests/math/t_ec_sage_bw6_761_g2.nim | 33 +- tests/math/t_ec_sage_pallas.nim | 17 +- tests/math/t_ec_sage_template.nim | 118 +- tests/math/t_ec_sage_vesta.nim | 17 +- tests/math/t_ec_shortw_jac_g1_msm.nim | 29 + tests/math/t_ec_shortw_jac_g1_mul_sanity.nim | 4 +- ....nim => t_ec_shortw_jac_g1_sum_reduce.nim} | 0 .../math/t_ec_shortw_jacext_g1_add_double.nim | 53 + .../math/t_ec_shortw_jacext_g1_mixed_add.nim | 54 + .../math/t_ec_shortw_jacext_g1_sum_reduce.nim | 29 + tests/math/t_ec_shortw_prj_g1_msm.nim | 29 + tests/math/t_ec_shortw_prj_g1_mul_sanity.nim | 4 +- ....nim => t_ec_shortw_prj_g1_sum_reduce.nim} | 0 tests/math/t_ec_template.nim | 230 ++-- .../math/t_finite_fields_double_precision.nim | 6 +- tests/math/t_finite_fields_mulsquare.nim | 12 +- tests/math/t_finite_fields_powinv.nim | 43 +- tests/math/t_finite_fields_sqrt.nim | 8 +- tests/math/t_fp12_exponentiation.nim | 2 +- tests/math/t_fp2_sqrt.nim | 6 +- tests/math/t_fp_cubic_root.nim | 2 +- tests/math/t_fp_tower_frobenius_template.nim | 2 +- tests/math/t_fp_tower_template.nim | 2 +- tests/math/t_fr.nim | 4 +- tests/math/t_io_bigints.nim | 4 +- tests/math/t_io_fields.nim | 2 +- tests/math/t_io_unsaturated.nim | 2 +- .../t_pairing_bls12_377_line_functions.nim | 2 +- tests/math/t_pairing_bls12_377_multi.nim | 62 + .../t_pairing_bls12_381_line_functions.nim | 2 +- tests/math/t_pairing_cyclotomic_subgroup.nim | 2 +- tests/math/t_pairing_template.nim | 4 +- tests/math/t_primitives.nim | 2 +- .../tv_BLS12_377_scalar_mul_G1_128bit.json | 532 +++++++++ ...=> tv_BLS12_377_scalar_mul_G1_253bit.json} | 40 + .../tv_BLS12_377_scalar_mul_G1_32bit.json | 532 +++++++++ .../tv_BLS12_377_scalar_mul_G1_64bit.json | 532 +++++++++ .../tv_BLS12_377_scalar_mul_G2_128bit.json | 1020 +++++++++++++++++ ...=> tv_BLS12_377_scalar_mul_G2_253bit.json} | 40 + .../tv_BLS12_377_scalar_mul_G2_32bit.json | 1020 +++++++++++++++++ .../tv_BLS12_377_scalar_mul_G2_64bit.json | 1020 +++++++++++++++++ .../tv_BLS12_381_scalar_mul_G1_128bit.json | 532 +++++++++ ...=> tv_BLS12_381_scalar_mul_G1_255bit.json} | 40 + .../tv_BLS12_381_scalar_mul_G1_32bit.json | 532 +++++++++ .../tv_BLS12_381_scalar_mul_G1_64bit.json | 532 +++++++++ .../tv_BLS12_381_scalar_mul_G2_128bit.json | 1020 +++++++++++++++++ ...=> tv_BLS12_381_scalar_mul_G2_255bit.json} | 40 + .../tv_BLS12_381_scalar_mul_G2_32bit.json | 1020 +++++++++++++++++ .../tv_BLS12_381_scalar_mul_G2_64bit.json | 1020 +++++++++++++++++ ...tv_BN254_Nogami_scalar_mul_G1_254bit.json} | 40 + ...tv_BN254_Nogami_scalar_mul_G2_254bit.json} | 40 + .../tv_BN254_Snarks_scalar_mul_G1_128bit.json | 532 +++++++++ ...tv_BN254_Snarks_scalar_mul_G1_254bit.json} | 40 + .../tv_BN254_Snarks_scalar_mul_G1_32bit.json | 532 +++++++++ .../tv_BN254_Snarks_scalar_mul_G1_64bit.json | 532 +++++++++ .../tv_BN254_Snarks_scalar_mul_G2_128bit.json | 1020 +++++++++++++++++ ...tv_BN254_Snarks_scalar_mul_G2_254bit.json} | 40 + .../tv_BN254_Snarks_scalar_mul_G2_32bit.json | 1020 +++++++++++++++++ .../tv_BN254_Snarks_scalar_mul_G2_64bit.json | 1020 +++++++++++++++++ ...n => tv_BW6_761_scalar_mul_G1_377bit.json} | 40 + ...n => tv_BW6_761_scalar_mul_G2_377bit.json} | 40 + ...on => tv_Pallas_scalar_mul_G1_255bit.json} | 40 + ...son => tv_Vesta_scalar_mul_G1_255bit.json} | 40 + tests/parallel/t_ec_template_parallel.nim | 10 +- tests/t_hash_to_curve.nim | 4 +- 143 files changed, 18968 insertions(+), 1295 deletions(-) create mode 100644 benchmarks/bench_ec_g1_msm_bls12_381.nim create mode 100644 benchmarks/bench_ec_g1_msm_bn254_snarks.nim create mode 100644 benchmarks/bench_ec_g1_scalar_mul.nim create mode 100644 benchmarks/bench_ec_g2_scalar_mul.nim create mode 100644 constantine/math/constants/secp256k1_subgroups.nim create mode 100644 constantine/math/elliptic/ec_multi_scalar_mul.nim create mode 100644 constantine/math/elliptic/ec_multi_scalar_mul_scheduler.nim create mode 100644 constantine/math/elliptic/ec_scalar_mul_vartime.nim create mode 100644 constantine/math/elliptic/ec_shortweierstrass_jacobian_extended.nim create mode 100644 constantine/platforms/compilers/compiler_optim_hints.nim delete mode 100644 constantine/platforms/signed_secret_words.nim create mode 100644 metering/m_msm.nim delete mode 100644 tests/math/support/ec_reference_scalar_mult.nim create mode 100644 tests/math/t_ec_shortw_jac_g1_msm.nim rename tests/math/{t_ec_shortw_jac_g1_batch_add.nim => t_ec_shortw_jac_g1_sum_reduce.nim} (100%) create mode 100644 tests/math/t_ec_shortw_jacext_g1_add_double.nim create mode 100644 tests/math/t_ec_shortw_jacext_g1_mixed_add.nim create mode 100644 tests/math/t_ec_shortw_jacext_g1_sum_reduce.nim create mode 100644 tests/math/t_ec_shortw_prj_g1_msm.nim rename tests/math/{t_ec_shortw_prj_g1_batch_add.nim => t_ec_shortw_prj_g1_sum_reduce.nim} (100%) create mode 100644 tests/math/t_pairing_bls12_377_multi.nim create mode 100644 tests/math/vectors/tv_BLS12_377_scalar_mul_G1_128bit.json rename tests/math/vectors/{tv_BLS12_377_scalar_mul_G1.json => tv_BLS12_377_scalar_mul_G1_253bit.json} (96%) create mode 100644 tests/math/vectors/tv_BLS12_377_scalar_mul_G1_32bit.json create mode 100644 tests/math/vectors/tv_BLS12_377_scalar_mul_G1_64bit.json create mode 100644 tests/math/vectors/tv_BLS12_377_scalar_mul_G2_128bit.json rename tests/math/vectors/{tv_BLS12_377_scalar_mul_G2.json => tv_BLS12_377_scalar_mul_G2_253bit.json} (97%) create mode 100644 tests/math/vectors/tv_BLS12_377_scalar_mul_G2_32bit.json create mode 100644 tests/math/vectors/tv_BLS12_377_scalar_mul_G2_64bit.json create mode 100644 tests/math/vectors/tv_BLS12_381_scalar_mul_G1_128bit.json rename tests/math/vectors/{tv_BLS12_381_scalar_mul_G1.json => tv_BLS12_381_scalar_mul_G1_255bit.json} (96%) create mode 100644 tests/math/vectors/tv_BLS12_381_scalar_mul_G1_32bit.json create mode 100644 tests/math/vectors/tv_BLS12_381_scalar_mul_G1_64bit.json create mode 100644 tests/math/vectors/tv_BLS12_381_scalar_mul_G2_128bit.json rename tests/math/vectors/{tv_BLS12_381_scalar_mul_G2.json => tv_BLS12_381_scalar_mul_G2_255bit.json} (97%) create mode 100644 tests/math/vectors/tv_BLS12_381_scalar_mul_G2_32bit.json create mode 100644 tests/math/vectors/tv_BLS12_381_scalar_mul_G2_64bit.json rename tests/math/vectors/{tv_BN254_Nogami_scalar_mul_G1.json => tv_BN254_Nogami_scalar_mul_G1_254bit.json} (95%) rename tests/math/vectors/{tv_BN254_Nogami_scalar_mul_G2.json => tv_BN254_Nogami_scalar_mul_G2_254bit.json} (97%) create mode 100644 tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_128bit.json rename tests/math/vectors/{tv_BN254_Snarks_scalar_mul_G1.json => tv_BN254_Snarks_scalar_mul_G1_254bit.json} (95%) create mode 100644 tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_32bit.json create mode 100644 tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_64bit.json create mode 100644 tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_128bit.json rename tests/math/vectors/{tv_BN254_Snarks_scalar_mul_G2.json => tv_BN254_Snarks_scalar_mul_G2_254bit.json} (97%) create mode 100644 tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_32bit.json create mode 100644 tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_64bit.json rename tests/math/vectors/{tv_BW6_761_scalar_mul_G1.json => tv_BW6_761_scalar_mul_G1_377bit.json} (97%) rename tests/math/vectors/{tv_BW6_761_scalar_mul_G2.json => tv_BW6_761_scalar_mul_G2_377bit.json} (97%) rename tests/math/vectors/{tv_Pallas_scalar_mul_G1.json => tv_Pallas_scalar_mul_G1_255bit.json} (95%) rename tests/math/vectors/{tv_Vesta_scalar_mul_G1.json => tv_Vesta_scalar_mul_G1_255bit.json} (95%) diff --git a/benchmarks/bench_ec_g1.nim b/benchmarks/bench_ec_g1.nim index 38e8825..d6cd924 100644 --- a/benchmarks/bench_ec_g1.nim +++ b/benchmarks/bench_ec_g1.nim @@ -12,7 +12,8 @@ import ../constantine/math/arithmetic, ../constantine/math/elliptic/[ ec_shortweierstrass_projective, - ec_shortweierstrass_jacobian], + ec_shortweierstrass_jacobian, + ec_shortweierstrass_jacobian_extended], # Helpers ./bench_elliptic_template @@ -46,33 +47,32 @@ proc main() = const curve = AvailableCurves[i] addBench(ECP_ShortW_Prj[Fp[curve], G1], Iters) addBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) + addBench(ECP_ShortW_JacExt[Fp[curve], G1], Iters) mixedAddBench(ECP_ShortW_Prj[Fp[curve], G1], Iters) mixedAddBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) + mixedAddBench(ECP_ShortW_JacExt[Fp[curve], G1], Iters) doublingBench(ECP_ShortW_Prj[Fp[curve], G1], Iters) doublingBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) + doublingBench(ECP_ShortW_JacExt[Fp[curve], G1], Iters) separator() affFromProjBench(ECP_ShortW_Prj[Fp[curve], G1], MulIters) affFromJacBench(ECP_ShortW_Jac[Fp[curve], G1], MulIters) separator() - scalarMulUnsafeDoubleAddBench(ECP_ShortW_Prj[Fp[curve], G1], MulIters) - scalarMulUnsafeDoubleAddBench(ECP_ShortW_Jac[Fp[curve], G1], MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromProjBatchBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, useBatching = false, batchIters) separator() - scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Prj[Fp[curve], G1], MulIters) - scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Jac[Fp[curve], G1], MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromProjBatchBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, useBatching = true, batchIters) separator() - scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], window = 2, MulIters) - scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], window = 3, MulIters) - scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], window = 4, MulIters) - scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], window = 5, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], window = 2, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], window = 3, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], window = 4, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], window = 5, MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromJacBatchBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, useBatching = false, batchIters) separator() - scalarMulEndo(ECP_ShortW_Prj[Fp[curve], G1], MulIters) - scalarMulEndoWindow(ECP_ShortW_Prj[Fp[curve], G1], MulIters) - scalarMulEndo(ECP_ShortW_Jac[Fp[curve], G1], MulIters) - scalarMulEndoWindow(ECP_ShortW_Jac[Fp[curve], G1], MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromJacBatchBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, useBatching = true, batchIters) separator() separator() diff --git a/benchmarks/bench_ec_g1_batch.nim b/benchmarks/bench_ec_g1_batch.nim index 4995c9f..ebf2d76 100644 --- a/benchmarks/bench_ec_g1_batch.nim +++ b/benchmarks/bench_ec_g1_batch.nim @@ -14,6 +14,7 @@ import ec_shortweierstrass_affine, ec_shortweierstrass_projective, ec_shortweierstrass_jacobian, + ec_shortweierstrass_jacobian_extended, ec_shortweierstrass_batch_ops_parallel], ../constantine/platforms/threadpool/threadpool, # Helpers @@ -38,7 +39,7 @@ proc multiAddParallelBench*(EC: typedesc, numPoints: int, iters: int) = var tp = Threadpool.new() bench("EC parallel batch add (" & align($tp.numThreads, 2) & " threads) " & $EC.G & " (" & $numPoints & " points)", EC, iters): - tp.sum_batch_vartime_parallel(r, points) + tp.sum_reduce_vartime_parallel(r, points) tp.shutdown() @@ -57,41 +58,55 @@ const AvailableCurves = [ BLS12_381, ] +# const testNumPoints = [10, 100, 1000, 10000, 100000] +const testNumPoints = [4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 65536, 131072] + proc main() = separator() staticFor i, 0, AvailableCurves.len: const curve = AvailableCurves[i] addBench(ECP_ShortW_Prj[Fp[curve], G1], Iters) - addBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) - mixedAddBench(ECP_ShortW_Prj[Fp[curve], G1], Iters) - mixedAddBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) doublingBench(ECP_ShortW_Prj[Fp[curve], G1], Iters) + mixedAddBench(ECP_ShortW_Prj[Fp[curve], G1], Iters) + addBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) doublingBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) + mixedAddBench(ECP_ShortW_Jac[Fp[curve], G1], Iters) + addBench(ECP_ShortW_JacExt[Fp[curve], G1], Iters) + doublingBench(ECP_ShortW_JacExt[Fp[curve], G1], Iters) + mixedAddBench(ECP_ShortW_JacExt[Fp[curve], G1], Iters) separator() - for numPoints in [10, 100, 1000, 10000, 100000, 1000000]: + for numPoints in testNumPoints: let batchIters = max(1, Iters div numPoints) multiAddBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, useBatching = false, batchIters) separator() - for numPoints in [10, 100, 1000, 10000, 100000, 1000000]: + for numPoints in testNumPoints: let batchIters = max(1, Iters div numPoints) multiAddBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, useBatching = true, batchIters) separator() - for numPoints in [10, 100, 1000, 10000, 100000, 1000000]: + for numPoints in testNumPoints: let batchIters = max(1, Iters div numPoints) multiAddParallelBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, batchIters) separator() - for numPoints in [10, 100, 1000, 10000, 100000, 1000000]: + for numPoints in testNumPoints: let batchIters = max(1, Iters div numPoints) multiAddBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, useBatching = false, batchIters) separator() - for numPoints in [10, 100, 1000, 10000, 100000, 1000000]: + for numPoints in testNumPoints: let batchIters = max(1, Iters div numPoints) multiAddBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, useBatching = true, batchIters) separator() - for numPoints in [10, 100, 1000, 10000, 100000, 1000000]: + for numPoints in testNumPoints: let batchIters = max(1, Iters div numPoints) multiAddParallelBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, batchIters) separator() + for numPoints in testNumPoints: + let batchIters = max(1, Iters div numPoints) + multiAddBench(ECP_ShortW_JacExt[Fp[curve], G1], numPoints, useBatching = false, batchIters) + separator() + for numPoints in testNumPoints: + let batchIters = max(1, Iters div numPoints) + multiAddBench(ECP_ShortW_JacExt[Fp[curve], G1], numPoints, useBatching = true, batchIters) + separator() separator() main() diff --git a/benchmarks/bench_ec_g1_msm_bls12_381.nim b/benchmarks/bench_ec_g1_msm_bls12_381.nim new file mode 100644 index 0000000..5e75db5 --- /dev/null +++ b/benchmarks/bench_ec_g1_msm_bls12_381.nim @@ -0,0 +1,60 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../constantine/math/config/curves, + ../constantine/math/arithmetic, + ../constantine/math/elliptic/[ + ec_shortweierstrass_affine, + ec_shortweierstrass_projective, + ec_shortweierstrass_jacobian, + ec_scalar_mul, + ec_multi_scalar_mul], + ../constantine/math/constants/zoo_subgroups, + # Helpers + ../helpers/prng_unsafe, + ./bench_elliptic_template, + ./bench_blueprint + +# ############################################################ +# +# Benchmark of the G1 group of +# Short Weierstrass elliptic curves +# in (homogeneous) projective coordinates +# +# ############################################################ + + +const Iters = 10_000 +const AvailableCurves = [ + BLS12_381, +] + +# const testNumPoints = [10, 100, 1000, 10000, 100000] +const testNumPoints = [8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, + 16384, 32768, 65536, 131072, 262144] + +proc main() = + separator() + staticFor i, 0, AvailableCurves.len: + const curve = AvailableCurves[i] + separator() + # for numPoints in testNumPoints: + # let batchIters = max(1, Iters div numPoints) + # msmBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, batchIters) + # separator() + # separator() + for numPoints in testNumPoints: + let batchIters = max(1, Iters div numPoints) + msmBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, batchIters) + separator() + separator() + +main() +notes() diff --git a/benchmarks/bench_ec_g1_msm_bn254_snarks.nim b/benchmarks/bench_ec_g1_msm_bn254_snarks.nim new file mode 100644 index 0000000..365088f --- /dev/null +++ b/benchmarks/bench_ec_g1_msm_bn254_snarks.nim @@ -0,0 +1,59 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../constantine/math/config/curves, + ../constantine/math/arithmetic, + ../constantine/math/elliptic/[ + ec_shortweierstrass_affine, + ec_shortweierstrass_projective, + ec_shortweierstrass_jacobian, + ec_scalar_mul, + ec_multi_scalar_mul], + ../constantine/math/constants/zoo_subgroups, + # Helpers + ../helpers/prng_unsafe, + ./bench_elliptic_template, + ./bench_blueprint + +# ############################################################ +# +# Benchmark of the G1 group of +# Short Weierstrass elliptic curves +# in (homogeneous) projective coordinates +# +# ############################################################ + + +const Iters = 10_000 +const AvailableCurves = [ + BN254_Snarks, +] + +const testNumPoints = [10, 100, 1000, 10000, 100000] +# const testNumPoints = [64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072] + +proc main() = + separator() + staticFor i, 0, AvailableCurves.len: + const curve = AvailableCurves[i] + separator() + # for numPoints in testNumPoints: + # let batchIters = max(1, Iters div numPoints) + # msmBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, batchIters) + # separator() + # separator() + for numPoints in testNumPoints: + let batchIters = max(1, Iters div numPoints) + msmBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, batchIters) + separator() + separator() + +main() +notes() diff --git a/benchmarks/bench_ec_g1_scalar_mul.nim b/benchmarks/bench_ec_g1_scalar_mul.nim new file mode 100644 index 0000000..ec94103 --- /dev/null +++ b/benchmarks/bench_ec_g1_scalar_mul.nim @@ -0,0 +1,81 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../constantine/math/config/curves, + ../constantine/math/arithmetic, + ../constantine/math/elliptic/[ + ec_shortweierstrass_projective, + ec_shortweierstrass_jacobian], + # Helpers + ./bench_elliptic_template + +# ############################################################ +# +# Benchmark of the G1 group of +# Short Weierstrass elliptic curves +# in (homogeneous) projective coordinates +# +# ############################################################ + + +const Iters = 10_000 +const MulIters = 100 +const AvailableCurves = [ + # P224, + BN254_Nogami, + BN254_Snarks, + # Edwards25519, + # P256, + # Secp256k1, + Pallas, + Vesta, + BLS12_377, + BLS12_381, +] + +proc main() = + separator() + staticFor i, 0, AvailableCurves.len: + const curve = AvailableCurves[i] + const bits = 64 # curve.getCurveOrderBitwidth() + scalarMulUnsafeDoubleAddBench(ECP_ShortW_Prj[Fp[curve], G1], bits, MulIters) + scalarMulUnsafeDoubleAddBench(ECP_ShortW_Jac[Fp[curve], G1], bits, MulIters) + separator() + scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Prj[Fp[curve], G1], bits, MulIters) + scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Jac[Fp[curve], G1], bits, MulIters) + separator() + scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 2, MulIters) + scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 3, MulIters) + scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 4, MulIters) + scalarMulGenericBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 5, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 2, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 3, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 4, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 5, MulIters) + separator() + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 2, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 3, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 4, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp[curve], G1], bits, window = 5, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 2, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 3, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 4, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp[curve], G1], bits, window = 5, MulIters) + separator() + when bits >= 196: # All endomorphisms constants are below this threshold + scalarMulEndo( ECP_ShortW_Prj[Fp[curve], G1], bits, MulIters) + scalarMulEndoWindow(ECP_ShortW_Prj[Fp[curve], G1], bits, MulIters) + scalarMulEndo( ECP_ShortW_Jac[Fp[curve], G1], bits, MulIters) + scalarMulEndoWindow(ECP_ShortW_Jac[Fp[curve], G1], bits, MulIters) + separator() + separator() + +main() +notes() diff --git a/benchmarks/bench_ec_g2.nim b/benchmarks/bench_ec_g2.nim index dab49ec..debc060 100644 --- a/benchmarks/bench_ec_g2.nim +++ b/benchmarks/bench_ec_g2.nim @@ -13,7 +13,8 @@ import ../constantine/math/extension_fields, ../constantine/math/elliptic/[ ec_shortweierstrass_projective, - ec_shortweierstrass_jacobian], + ec_shortweierstrass_jacobian, + ec_shortweierstrass_jacobian_extended], # Helpers ./bench_elliptic_template, # Standard library @@ -47,31 +48,32 @@ proc main() = const curve = AvailableCurves[i] addBench(ECP_ShortW_Prj[Fp2[curve], G2], Iters) addBench(ECP_ShortW_Jac[Fp2[curve], G2], Iters) + addBench(ECP_ShortW_JacExt[Fp2[curve], G2], Iters) mixedAddBench(ECP_ShortW_Prj[Fp2[curve], G2], Iters) mixedAddBench(ECP_ShortW_Jac[Fp2[curve], G2], Iters) + mixedAddBench(ECP_ShortW_JacExt[Fp2[curve], G2], Iters) doublingBench(ECP_ShortW_Prj[Fp2[curve], G2], Iters) doublingBench(ECP_ShortW_Jac[Fp2[curve], G2], Iters) + doublingBench(ECP_ShortW_JacExt[Fp2[curve], G2], Iters) separator() affFromProjBench(ECP_ShortW_Prj[Fp2[curve], G2], MulIters) affFromJacBench(ECP_ShortW_Jac[Fp2[curve], G2], MulIters) separator() - scalarMulUnsafeDoubleAddBench(ECP_ShortW_Prj[Fp2[curve], G2], MulIters) - scalarMulUnsafeDoubleAddBench(ECP_ShortW_Jac[Fp2[curve], G2], MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromProjBatchBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, useBatching = false, batchIters) separator() - scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Prj[Fp2[curve], G2], MulIters) - scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Jac[Fp2[curve], G2], MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromProjBatchBench(ECP_ShortW_Prj[Fp[curve], G1], numPoints, useBatching = true, batchIters) separator() - scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], window = 2, MulIters) - scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], window = 3, MulIters) - scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], window = 4, MulIters) - scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], window = 5, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], window = 2, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], window = 3, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], window = 4, MulIters) - scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], window = 5, MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromJacBatchBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, useBatching = false, batchIters) separator() - scalarMulEndo(ECP_ShortW_Prj[Fp2[curve], G2], MulIters) - scalarMulEndo(ECP_ShortW_Jac[Fp2[curve], G2], MulIters) + for numPoints in [10, 100, 1000, 10000]: + let batchIters = max(1, Iters div numPoints) + affFromJacBatchBench(ECP_ShortW_Jac[Fp[curve], G1], numPoints, useBatching = true, batchIters) separator() separator() diff --git a/benchmarks/bench_ec_g2_scalar_mul.nim b/benchmarks/bench_ec_g2_scalar_mul.nim new file mode 100644 index 0000000..8b46ae2 --- /dev/null +++ b/benchmarks/bench_ec_g2_scalar_mul.nim @@ -0,0 +1,80 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../constantine/math/config/curves, + ../constantine/math/arithmetic, + ../constantine/math/extension_fields, + ../constantine/math/elliptic/[ + ec_shortweierstrass_projective, + ec_shortweierstrass_jacobian], + # Helpers + ./bench_elliptic_template, + # Standard library + std/strutils + +# ############################################################ +# +# Benchmark of the G1 group of +# Short Weierstrass elliptic curves +# in (homogeneous) projective coordinates +# +# ############################################################ + + +const Iters = 10_000 +const MulIters = 500 +const AvailableCurves = [ + # P224, + BN254_Nogami, + BN254_Snarks, + # Edwards25519, + # P256, + # Secp256k1, + BLS12_377, + BLS12_381, +] + +proc main() = + separator() + staticFor i, 0, AvailableCurves.len: + const curve = AvailableCurves[i] + const bits = 64 # curve.getCurveOrderBitwidth() + scalarMulUnsafeDoubleAddBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, MulIters) + scalarMulUnsafeDoubleAddBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, MulIters) + separator() + scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, MulIters) + scalarMulUnsafeMinHammingWeightRecodingBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, MulIters) + separator() + scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 2, MulIters) + scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 3, MulIters) + scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 4, MulIters) + scalarMulGenericBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 5, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 2, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 3, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 4, MulIters) + scalarMulGenericBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 5, MulIters) + separator() + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 2, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 3, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 4, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Prj[Fp2[curve], G2], bits, window = 5, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 2, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 3, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 4, MulIters) + scalarMulUnsafeWNAFBench(ECP_ShortW_Jac[Fp2[curve], G2], bits, window = 5, MulIters) + separator() + when bits >= 196: # All endomorphisms constants are below this threshold + scalarMulEndo(ECP_ShortW_Prj[Fp2[curve], G2], bits, MulIters) + scalarMulEndo(ECP_ShortW_Jac[Fp2[curve], G2], bits, MulIters) + separator() + separator() + +main() +notes() diff --git a/benchmarks/bench_elliptic_template.nim b/benchmarks/bench_elliptic_template.nim index 5051065..cb4b00a 100644 --- a/benchmarks/bench_elliptic_template.nim +++ b/benchmarks/bench_elliptic_template.nim @@ -22,19 +22,21 @@ import ec_shortweierstrass_affine, ec_shortweierstrass_projective, ec_shortweierstrass_jacobian, + ec_shortweierstrass_jacobian_extended, ec_shortweierstrass_batch_ops, ec_scalar_mul, ec_endomorphism_accel], + ../constantine/math/constants/zoo_subgroups, # Helpers ../helpers/prng_unsafe, ./platforms, ./bench_blueprint, # Reference unsafe scalar multiplication - ../tests/math/support/ec_reference_scalar_mult + ../constantine/math/elliptic/ec_scalar_mul_vartime export notes export abstractions # generic sandwich on SecretBool and SecretBool in Jacobian sum -proc separator*() = separator(177) +proc separator*() = separator(206) macro fixEllipticDisplay(EC: typedesc): untyped = # At compile-time, enums are integers and their display is buggy @@ -50,20 +52,30 @@ proc report(op, elliptic: string, start, stop: MonoTime, startClk, stopClk: int6 let ns = inNanoseconds((stop-start) div iters) let throughput = 1e9 / float64(ns) when SupportsGetTicks: - echo &"{op:<60} {elliptic:<40} {throughput:>15.3f} ops/s {ns:>9} ns/op {(stopClk - startClk) div iters:>9} CPU cycles (approx)" + echo &"{op:<80} {elliptic:<40} {throughput:>15.3f} ops/s {ns:>12} ns/op {(stopClk - startClk) div iters:>12} CPU cycles (approx)" else: - echo &"{op:<60} {elliptic:<40} {throughput:>15.3f} ops/s {ns:>9} ns/op" + echo &"{op:<80} {elliptic:<40} {throughput:>15.3f} ops/s {ns:>12} ns/op" template bench*(op: string, EC: typedesc, iters: int, body: untyped): untyped = measure(iters, startTime, stopTime, startClk, stopClk, body) report(op, fixEllipticDisplay(EC), startTime, stopTime, startClk, stopClk, iters) +func `+=`[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_JacExt[F, G]) {.inline.}= + P.sum_vartime(P, Q) +func `+=`[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_Aff[F, G]) {.inline.}= + P.madd_vartime(P, Q) + proc addBench*(EC: typedesc, iters: int) = var r {.noInit.}: EC let P = rng.random_unsafe(EC) let Q = rng.random_unsafe(EC) - bench("EC Add " & $EC.G, EC, iters): - r.sum(P, Q) + + when EC is ECP_ShortW_JacExt: + bench("EC Add vartime " & $EC.G, EC, iters): + r.sum_vartime(P, Q) + else: + bench("EC Add " & $EC.G, EC, iters): + r.sum(P, Q) proc mixedAddBench*(EC: typedesc, iters: int) = var r {.noInit.}: EC @@ -71,8 +83,13 @@ proc mixedAddBench*(EC: typedesc, iters: int) = let Q = rng.random_unsafe(EC) var Qaff: ECP_ShortW_Aff[EC.F, EC.G] Qaff.affine(Q) - bench("EC Mixed Addition " & $EC.G, EC, iters): - r.madd(P, Qaff) + + when EC is ECP_ShortW_JacExt: + bench("EC Mixed Addition vartime " & $EC.G, EC, iters): + r.madd_vartime(P, Qaff) + else: + bench("EC Mixed Addition " & $EC.G, EC, iters): + r.madd(P, Qaff) proc doublingBench*(EC: typedesc, iters: int) = var r {.noInit.}: EC @@ -92,11 +109,40 @@ proc affFromJacBench*(EC: typedesc, iters: int) = bench("EC Jacobian to Affine " & $EC.G, EC, iters): r.affine(P) -proc scalarMulGenericBench*(EC: typedesc, window: static int, iters: int) = - const bits = EC.F.C.getCurveOrderBitwidth() +proc affFromProjBatchBench*(EC: typedesc, numPoints: int, useBatching: bool, iters: int) = + var r = newSeq[affine(EC)](numPoints) + var points = newSeq[EC](numPoints) + for i in 0 ..< numPoints: + points[i] = rng.random_unsafe(EC) + + if useBatching: + bench("EC Projective to Affine - batched " & $EC.G & " (" & $numPoints & " points)", EC, iters): + r.asUnchecked().batchAffine(points.asUnchecked(), numPoints) + else: + bench("EC Projective to Affine - unbatched " & $EC.G & " (" & $numPoints & " points)", EC, iters): + for i in 0 ..< numPoints: + r[i].affine(points[i]) + +proc affFromJacBatchBench*(EC: typedesc, numPoints: int, useBatching: bool, iters: int) = + var r = newSeq[affine(EC)](numPoints) + var points = newSeq[EC](numPoints) + + for i in 0 ..< numPoints: + points[i] = rng.random_unsafe(EC) + + if useBatching: + bench("EC Jacobian to Affine - batched " & $EC.G & " (" & $numPoints & " points)", EC, iters): + r.asUnchecked().batchAffine(points.asUnchecked(), numPoints) + else: + bench("EC Jacobian to Affine - unbatched " & $EC.G & " (" & $numPoints & " points)", EC, iters): + for i in 0 ..< numPoints: + r[i].affine(points[i]) + +proc scalarMulGenericBench*(EC: typedesc, bits, window: static int, iters: int) = var r {.noInit.}: EC - let P = rng.random_unsafe(EC) # TODO: clear cofactor + var P = rng.random_unsafe(EC) + P.clearCofactor() let exponent = rng.random_unsafe(BigInt[bits]) @@ -104,11 +150,10 @@ proc scalarMulGenericBench*(EC: typedesc, window: static int, iters: int) = r = P r.scalarMulGeneric(exponent, window) -proc scalarMulEndo*(EC: typedesc, iters: int) = - const bits = EC.F.C.getCurveOrderBitwidth() - +proc scalarMulEndo*(EC: typedesc, bits: static int, iters: int) = var r {.noInit.}: EC - let P = rng.random_unsafe(EC) # TODO: clear cofactor + var P = rng.random_unsafe(EC) + P.clearCofactor() let exponent = rng.random_unsafe(BigInt[bits]) @@ -116,11 +161,10 @@ proc scalarMulEndo*(EC: typedesc, iters: int) = r = P r.scalarMulEndo(exponent) -proc scalarMulEndoWindow*(EC: typedesc, iters: int) = - const bits = EC.F.C.getCurveOrderBitwidth() - +proc scalarMulEndoWindow*(EC: typedesc, bits: static int, iters: int) = var r {.noInit.}: EC - let P = rng.random_unsafe(EC) # TODO: clear cofactor + var P = rng.random_unsafe(EC) + P.clearCofactor() let exponent = rng.random_unsafe(BigInt[bits]) @@ -131,29 +175,38 @@ proc scalarMulEndoWindow*(EC: typedesc, iters: int) = else: {.error: "Not implemented".} -proc scalarMulUnsafeDoubleAddBench*(EC: typedesc, iters: int) = - const bits = EC.F.C.getCurveOrderBitwidth() - +proc scalarMulUnsafeDoubleAddBench*(EC: typedesc, bits: static int, iters: int) = var r {.noInit.}: EC - let P = rng.random_unsafe(EC) # TODO: clear cofactor + var P = rng.random_unsafe(EC) + P.clearCofactor() let exponent = rng.random_unsafe(BigInt[bits]) bench("EC ScalarMul " & $bits & "-bit " & $EC.G & " (unsafe reference DoubleAdd)", EC, iters): r = P - r.unsafe_ECmul_double_add(exponent) - -proc scalarMulUnsafeMinHammingWeightRecodingBench*(EC: typedesc, iters: int) = - const bits = EC.F.C.getCurveOrderBitwidth() + r.scalarMul_doubleAdd_vartime(exponent) +proc scalarMulUnsafeMinHammingWeightRecodingBench*(EC: typedesc, bits: static int, iters: int) = var r {.noInit.}: EC - var P = rng.random_unsafe(EC) # TODO: clear cofactor + var P = rng.random_unsafe(EC) + P.clearCofactor() let exponent = rng.random_unsafe(BigInt[bits]) bench("EC ScalarMul " & $bits & "-bit " & $EC.G & " (unsafe min Hamming Weight recoding)", EC, iters): r = P - r.unsafe_ECmul_minHammingWeight(exponent) + r.scalarMul_minHammingWeight_vartime(exponent) + +proc scalarMulUnsafeWNAFBench*(EC: typedesc, bits, window: static int, iters: int) = + var r {.noInit.}: EC + var P = rng.random_unsafe(EC) + P.clearCofactor() + + let exponent = rng.random_unsafe(BigInt[bits]) + + bench("EC ScalarMul " & $bits & "-bit " & $EC.G & " (unsafe wNAF-" & $window & ")", EC, iters): + r = P + r.scalarMul_minHammingWeight_windowed_vartime(exponent, window) proc multiAddBench*(EC: typedesc, numPoints: int, useBatching: bool, iters: int) = var points = newSeq[ECP_ShortW_Aff[EC.F, EC.G]](numPoints) @@ -165,9 +218,61 @@ proc multiAddBench*(EC: typedesc, numPoints: int, useBatching: bool, iters: int) if useBatching: bench("EC Multi Add batched " & $EC.G & " (" & $numPoints & " points)", EC, iters): - r.sum_batch_vartime(points) + r.sum_reduce_vartime(points) else: bench("EC Multi Mixed-Add unbatched " & $EC.G & " (" & $numPoints & " points)", EC, iters): r.setInf() for i in 0 ..< numPoints: r += points[i] + + +proc msmBench*(EC: typedesc, numPoints: int, iters: int) = + const bits = EC.F.C.getCurveOrderBitwidth() + var points = newSeq[ECP_ShortW_Aff[EC.F, EC.G]](numPoints) + var scalars = newSeq[BigInt[bits]](numPoints) + + for i in 0 ..< numPoints: + var tmp = rng.random_unsafe(EC) + tmp.clearCofactor() + points[i].affine(tmp) + scalars[i] = rng.random_unsafe(BigInt[bits]) + + var r{.noInit.}: EC + var startNaive, stopNaive, startMSMbaseline, stopMSMbaseline, startMSMopt, stopMSMopt: MonoTime + + if numPoints <= 100000: + bench("EC scalar muls " & align($numPoints, 7) & " (scalars " & $bits & "-bit, points) pairs ", EC, iters): + startNaive = getMonotime() + var tmp: EC + r.setInf() + for i in 0 ..< points.len: + tmp.fromAffine(points[i]) + tmp.scalarMul(scalars[i]) + r += tmp + stopNaive = getMonotime() + + block: + bench("EC multi-scalar-mul baseline " & align($numPoints, 7) & " (scalars " & $bits & "-bit, points) pairs ", EC, iters): + startMSMbaseline = getMonotime() + r.multiScalarMul_reference_vartime(scalars, points) + stopMSMbaseline = getMonotime() + + block: + bench("EC multi-scalar-mul optimized " & align($numPoints, 7) & " (scalars " & $bits & "-bit, points) pairs ", EC, iters): + startMSMopt = getMonotime() + r.multiScalarMul_vartime(scalars, points) + stopMSMopt = getMonotime() + + let perfNaive = inNanoseconds((stopNaive-startNaive) div iters) + let perfMSMbaseline = inNanoseconds((stopMSMbaseline-startMSMbaseline) div iters) + let perfMSMopt = inNanoseconds((stopMSMopt-startMSMopt) div iters) + + if numPoints <= 100000: + let speedupBaseline = float(perfNaive) / float(perfMSMbaseline) + echo &"Speedup ratio baseline over naive linear combination: {speedupBaseline:>6.3f}x" + + let speedupOpt = float(perfNaive) / float(perfMSMopt) + echo &"Speedup ratio optimized over naive linear combination: {speedupOpt:>6.3f}x" + + let speedupOptBaseline = float(perfMSMbaseline) / float(perfMSMopt) + echo &"Speedup ratio optimized over baseline linear combination: {speedupOptBaseline:>6.3f}x" diff --git a/benchmarks/bench_fields_template.nim b/benchmarks/bench_fields_template.nim index 0d99dc5..930d871 100644 --- a/benchmarks/bench_fields_template.nim +++ b/benchmarks/bench_fields_template.nim @@ -160,6 +160,13 @@ proc invBench*(T: typedesc, iters: int) = bench("Inversion (constant-time)", T, iters): r.inv(x) +proc invVartimeBench*(T: typedesc, iters: int) = + var r: T + let x = rng.random_unsafe(T) + preventOptimAway(r) + bench("Inversion (variable-time)", T, iters): + r.inv_vartime(x) + proc isSquareBench*(T: typedesc, iters: int) = let x = rng.random_unsafe(T) bench("isSquare (constant-time)", T, iters): diff --git a/benchmarks/bench_fp.nim b/benchmarks/bench_fp.nim index 5e668b0..230d61c 100644 --- a/benchmarks/bench_fp.nim +++ b/benchmarks/bench_fp.nim @@ -61,6 +61,7 @@ proc main() = toFieldBench(Fp[curve], Iters) smallSeparator() invBench(Fp[curve], ExponentIters) + invVartimeBench(Fp[curve], ExponentIters) isSquareBench(Fp[curve], ExponentIters) sqrtBench(Fp[curve], ExponentIters) sqrtRatioBench(Fp[curve], ExponentIters) diff --git a/benchmarks/bench_fp12.nim b/benchmarks/bench_fp12.nim index 991d83b..344262c 100644 --- a/benchmarks/bench_fp12.nim +++ b/benchmarks/bench_fp12.nim @@ -40,6 +40,7 @@ proc main() = mulBench(Fp12[curve], Iters) sqrBench(Fp12[curve], Iters) invBench(Fp12[curve], InvIters) + invVartimeBench(Fp12[curve], InvIters) separator() main() diff --git a/benchmarks/bench_fp2.nim b/benchmarks/bench_fp2.nim index 3eae545..b3b8396 100644 --- a/benchmarks/bench_fp2.nim +++ b/benchmarks/bench_fp2.nim @@ -48,6 +48,7 @@ proc main() = rdc2xBench(Fp2[curve], Iters) smallSeparator() invBench(Fp2[curve], InvIters) + invVartimeBench(Fp2[curve], InvIters) isSquareBench(Fp2[curve], InvIters) sqrtBench(Fp2[curve], InvIters) separator() diff --git a/benchmarks/bench_fp4.nim b/benchmarks/bench_fp4.nim index 6eba487..c2f7ac8 100644 --- a/benchmarks/bench_fp4.nim +++ b/benchmarks/bench_fp4.nim @@ -48,6 +48,7 @@ proc main() = rdc2xBench(Fp4[curve], Iters) smallSeparator() invBench(Fp4[curve], InvIters) + invVartimeBench(Fp4[curve], InvIters) separator() main() diff --git a/benchmarks/bench_fp6.nim b/benchmarks/bench_fp6.nim index ab80391..8827179 100644 --- a/benchmarks/bench_fp6.nim +++ b/benchmarks/bench_fp6.nim @@ -46,6 +46,7 @@ proc main() = rdc2xBench(Fp6[curve], Iters) smallSeparator() invBench(Fp6[curve], InvIters) + invVartimeBench(Fp6[curve], InvIters) separator() main() diff --git a/benchmarks/bench_pairing_template.nim b/benchmarks/bench_pairing_template.nim index 9519790..2ebd19a 100644 --- a/benchmarks/bench_pairing_template.nim +++ b/benchmarks/bench_pairing_template.nim @@ -184,7 +184,7 @@ proc millerLoopBLS12Bench*(C: static Curve, iters: int) = var f: Fp12[C] bench("Miller Loop BLS12", C, iters): - f.millerLoopGenericBLS12(P, Q) + f.millerLoopGenericBLS12(Q, P) proc millerLoopBNBench*(C: static Curve, iters: int) = let @@ -193,7 +193,7 @@ proc millerLoopBNBench*(C: static Curve, iters: int) = var f: Fp12[C] bench("Miller Loop BN", C, iters): - f.millerLoopGenericBN(P, Q) + f.millerLoopGenericBN(Q, P) proc finalExpEasyBench*(C: static Curve, iters: int) = var r = rng.random_unsafe(Fp12[C]) diff --git a/benchmarks/bench_summary_template.nim b/benchmarks/bench_summary_template.nim index b9c81ff..8a43895 100644 --- a/benchmarks/bench_summary_template.nim +++ b/benchmarks/bench_summary_template.nim @@ -172,7 +172,7 @@ proc millerLoopBLS12Bench*(C: static Curve, iters: int) = var f: Fp12[C] bench("Miller Loop BLS12", C, iters): - f.millerLoopGenericBLS12(P, Q) + f.millerLoopGenericBLS12(Q, P) proc millerLoopBNBench*(C: static Curve, iters: int) = let @@ -181,7 +181,7 @@ proc millerLoopBNBench*(C: static Curve, iters: int) = var f: Fp12[C] bench("Miller Loop BN", C, iters): - f.millerLoopGenericBN(P, Q) + f.millerLoopGenericBN(Q, P) proc finalExpBLS12Bench*(C: static Curve, iters: int) = var r = rng.random_unsafe(Fp12[C]) diff --git a/constantine.nimble b/constantine.nimble index 65d5d5c..1c6449d 100644 --- a/constantine.nimble +++ b/constantine.nimble @@ -99,15 +99,18 @@ const testDesc: seq[tuple[path: string, useGMP: bool]] = @[ # ("tests/math/t_ec_shortw_prj_g1_add_double.nim", false), # ("tests/math/t_ec_shortw_prj_g1_mul_sanity.nim", false), # ("tests/math/t_ec_shortw_prj_g1_mul_distri.nim", false), - # ("tests/math/t_ec_shortw_prj_g1_mul_vs_ref.nim", false), + ("tests/math/t_ec_shortw_prj_g1_mul_vs_ref.nim", false), # ("tests/math/t_ec_shortw_prj_g1_mixed_add.nim", false), # ("tests/math/t_ec_shortw_jac_g1_add_double.nim", false), # ("tests/math/t_ec_shortw_jac_g1_mul_sanity.nim", false), # ("tests/math/t_ec_shortw_jac_g1_mul_distri.nim", false), - # ("tests/math/t_ec_shortw_jac_g1_mul_vs_ref.nim", false), + ("tests/math/t_ec_shortw_jac_g1_mul_vs_ref.nim", false), # ("tests/math/t_ec_shortw_jac_g1_mixed_add.nim", false), + ("tests/math/t_ec_shortw_jacext_g1_add_double.nim", false), + ("tests/math/t_ec_shortw_jacext_g1_mixed_add.nim", false), + # ("tests/math/t_ec_twedwards_prj_add_double", false), # ("tests/math/t_ec_twedwards_prj_mul_sanity", false), # ("tests/math/t_ec_twedwards_prj_mul_distri", false), @@ -118,49 +121,49 @@ const testDesc: seq[tuple[path: string, useGMP: bool]] = @[ # ("tests/math/t_ec_shortw_prj_g2_add_double_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_sanity_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_distri_bn254_snarks.nim", false), - # ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bn254_snarks.nim", false), + ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mixed_add_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_prj_g2_add_double_bls12_381.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_sanity_bls12_381.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_distri_bls12_381.nim", false), - # ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bls12_381.nim", false), + ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bls12_381.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mixed_add_bls12_381.nim", false), # ("tests/math/t_ec_shortw_prj_g2_add_double_bls12_377.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_sanity_bls12_377.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_distri_bls12_377.nim", false), - # ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bls12_377.nim", false), + ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bls12_377.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mixed_add_bls12_377.nim", false), # ("tests/math/t_ec_shortw_prj_g2_add_double_bw6_761.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_sanity_bw6_761.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mul_distri_bw6_761.nim", false), - # ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bw6_761.nim", false), + ("tests/math/t_ec_shortw_prj_g2_mul_vs_ref_bw6_761.nim", false), # ("tests/math/t_ec_shortw_prj_g2_mixed_add_bw6_761.nim", false), # ("tests/math/t_ec_shortw_jac_g2_add_double_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_sanity_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_distri_bn254_snarks.nim", false), - # ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bn254_snarks.nim", false), + ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mixed_add_bn254_snarks.nim", false), # ("tests/math/t_ec_shortw_jac_g2_add_double_bls12_381.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_sanity_bls12_381.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_distri_bls12_381.nim", false), - # ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bls12_381.nim", false), + ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bls12_381.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mixed_add_bls12_381.nim", false), # ("tests/math/t_ec_shortw_jac_g2_add_double_bls12_377.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_sanity_bls12_377.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_distri_bls12_377.nim", false), - # ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bls12_377.nim", false), + ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bls12_377.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mixed_add_bls12_377.nim", false), # ("tests/math/t_ec_shortw_jac_g2_add_double_bw6_761.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_sanity_bw6_761.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mul_distri_bw6_761.nim", false), - # ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bw6_761.nim", false), + ("tests/math/t_ec_shortw_jac_g2_mul_vs_ref_bw6_761.nim", false), # ("tests/math/t_ec_shortw_jac_g2_mixed_add_bw6_761.nim", false), # Elliptic curve arithmetic vs Sagemath @@ -179,8 +182,11 @@ const testDesc: seq[tuple[path: string, useGMP: bool]] = @[ # Elliptic curve arithmetic - batch computation # ---------------------------------------------------------- - ("tests/math/t_ec_shortw_prj_g1_batch_add.nim", false), - ("tests/math/t_ec_shortw_jac_g1_batch_add.nim", false), + ("tests/math/t_ec_shortw_prj_g1_sum_reduce.nim", false), + ("tests/math/t_ec_shortw_jac_g1_sum_reduce.nim", false), + ("tests/math/t_ec_shortw_jacext_g1_sum_reduce.nim", false), + ("tests/math/t_ec_shortw_prj_g1_msm.nim", false), + ("tests/math/t_ec_shortw_jac_g1_msm.nim", false), # Subgroups and cofactors # ---------------------------------------------------------- @@ -210,6 +216,7 @@ const testDesc: seq[tuple[path: string, useGMP: bool]] = @[ # ---------------------------------------------------------- ("tests/math/t_pairing_bn254_nogami_multi.nim", false), ("tests/math/t_pairing_bn254_snarks_multi.nim", false), + ("tests/math/t_pairing_bls12_377_multi.nim", false), ("tests/math/t_pairing_bls12_381_multi.nim", false), # Prime order fields @@ -258,8 +265,12 @@ const benchDesc = [ "bench_fp6", "bench_fp12", "bench_ec_g1", + "bench_ec_g1_scalar_mul", "bench_ec_g1_batch", + "bench_ec_g1_msm_bn254_snarks", + "bench_ec_g1_msm_bls12_381", "bench_ec_g2", + "bench_ec_g2_scalar_mul", "bench_pairing_bls12_377", "bench_pairing_bls12_381", "bench_pairing_bn254_nogami", @@ -826,7 +837,58 @@ task bench_ec_g1_batch_gcc_noasm, "Run benchmark on Elliptic Curve group 𝔾1 ( runBench("bench_ec_g1_batch", "gcc", useAsm = false) task bench_ec_g1_batch_clang_noasm, "Run benchmark on Elliptic Curve group 𝔾1 (batch ops) - Clang no Assembly": - runBench("bench_ec_g1", "clang", useAsm = false) + runBench("bench_ec_g1_batch", "clang", useAsm = false) + +# Elliptic curve G1 - scalar multiplication +# ------------------------------------------ + +task bench_ec_g1_scalar_mul, "Run benchmark on Elliptic Curve group 𝔾1 (Scalar Multiplication) - Default compiler": + runBench("bench_ec_g1_scalar_mul") + +task bench_ec_g1_scalar_mul_gcc, "Run benchmark on Elliptic Curve group 𝔾1 (Scalar Multiplication) - GCC": + runBench("bench_ec_g1_scalar_mul", "gcc") + +task bench_ec_g1_scalar_mul_clang, "Run benchmark on Elliptic Curve group 𝔾1 (Scalar Multiplication) - Clang": + runBench("bench_ec_g1_scalar_mul", "clang") + +task bench_ec_g1_scalar_mul_gcc_noasm, "Run benchmark on Elliptic Curve group 𝔾1 (Scalar Multiplication) - GCC no Assembly": + runBench("bench_ec_g1_scalar_mul", "gcc", useAsm = false) + +task bench_ec_g1_scalar_mul_clang_noasm, "Run benchmark on Elliptic Curve group 𝔾1 (Scalar Multiplication) - Clang no Assembly": + runBench("bench_ec_g1_scalar_mul", "clang", useAsm = false) + +# Elliptic curve G1 - Multi-scalar-mul +# ------------------------------------------ + +task bench_ec_g1_msm_bn254_snarks, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BN254-Snarks - Default compiler": + runBench("bench_ec_g1_msm_bn254_snarks") + +task bench_ec_g1_msm_bn254_snarks_gcc, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BN254-Snarks - GCC": + runBench("bench_ec_g1_msm_bn254_snarks", "gcc") + +task bench_ec_g1_msm_bn254_snarks_clang, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BN254-Snarks - Clang": + runBench("bench_ec_g1_msm_bn254_snarks", "clang") + +task bench_ec_g1_msm_bn254_snarks_gcc_noasm, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BN254-Snarks - GCC no Assembly": + runBench("bench_ec_g1_msm_bn254_snarks", "gcc", useAsm = false) + +task bench_ec_g1_msm_bn254_snarks_clang_noasm, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BN254-Snarks - Clang no Assembly": + runBench("bench_ec_g1_msm_bn254_snarks", "clang", useAsm = false) + +task bench_ec_g1_msm_bls12_381, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BLS12-381 - Default compiler": + runBench("bench_ec_g1_msm_bls12_381") + +task bench_ec_g1_msm_bls12_381_gcc, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BLS12-381 - GCC": + runBench("bench_ec_g1_msm_bls12_381", "gcc") + +task bench_ec_g1_msm_bls12_381_clang, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BLS12-381 - Clang": + runBench("bench_ec_g1_msm_bls12_381", "clang") + +task bench_ec_g1_msm_bls12_381_gcc_noasm, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BLS12-381 - GCC no Assembly": + runBench("bench_ec_g1_msm_bls12_381", "gcc", useAsm = false) + +task bench_ec_g1_msm_bls12_381_clang_noasm, "Run benchmark on Elliptic Curve group 𝔾1 (Multi-Scalar-Mul) for BLS12-381 - Clang no Assembly": + runBench("bench_ec_g1_msm_bls12_381", "clang", useAsm = false) # Elliptic curve G2 # ------------------------------------------ @@ -846,6 +908,24 @@ task bench_ec_g2_gcc_noasm, "Run benchmark on Elliptic Curve group 𝔾2 - GCC n task bench_ec_g2_clang_noasm, "Run benchmark on Elliptic Curve group 𝔾2 - Clang no Assembly": runBench("bench_ec_g2", "clang", useAsm = false) +# Elliptic curve G2 - scalar multiplication +# ------------------------------------------ + +task bench_ec_g2_scalar_mul, "Run benchmark on Elliptic Curve group 𝔾2 (Multi-Scalar-Mul) - Default compiler": + runBench("bench_ec_g2_scalar_mul") + +task bench_ec_g2_scalar_mul_gcc, "Run benchmark on Elliptic Curve group 𝔾2 (Multi-Scalar-Mul) - GCC": + runBench("bench_ec_g2_scalar_mul", "gcc") + +task bench_ec_g2_scalar_mul_clang, "Run benchmark on Elliptic Curve group 𝔾2 (Multi-Scalar-Mul) - Clang": + runBench("bench_ec_g2_scalar_mul", "clang") + +task bench_ec_g2_scalar_mul_gcc_noasm, "Run benchmark on Elliptic Curve group 𝔾2 (Multi-Scalar-Mul) - GCC no Assembly": + runBench("bench_ec_g2_scalar_mul", "gcc", useAsm = false) + +task bench_ec_g2_scalar_mul_clang_noasm, "Run benchmark on Elliptic Curve group 𝔾2 (Multi-Scalar-Mul) - Clang no Assembly": + runBench("bench_ec_g2_scalar_mul", "clang", useAsm = false) + # Pairings # ------------------------------------------ diff --git a/constantine/ethereum_evm_precompiles.nim b/constantine/ethereum_evm_precompiles.nim index 1b88df9..b1254f0 100644 --- a/constantine/ethereum_evm_precompiles.nim +++ b/constantine/ethereum_evm_precompiles.nim @@ -12,7 +12,7 @@ import ./math/[arithmetic, extension_fields], ./math/arithmetic/limbs_montgomery, ./math/ec_shortweierstrass, - ./math/pairings/[pairings_bn, miller_loops, cyclotomic_subgroups], + ./math/pairings/[pairings_generic, miller_accumulators], ./math/constants/zoo_subgroups, ./math/io/[io_bigints, io_fields] @@ -86,8 +86,7 @@ func fromRawCoords( return cttEVM_Success -func eth_evm_ecadd*( - r: var array[64, byte], inputs: openarray[byte]): CttEVMStatus = +func eth_evm_ecadd*(r: var array[64, byte], inputs: openarray[byte]): CttEVMStatus = ## Elliptic Curve addition on BN254_Snarks ## (also called alt_bn128 in Ethereum specs ## and bn256 in Ethereum tests) @@ -142,8 +141,7 @@ func eth_evm_ecadd*( aff.y, bigEndian ) -func eth_evm_ecmul*( - r: var array[64, byte], inputs: openarray[byte]): CttEVMStatus = +func eth_evm_ecmul*(r: var array[64, byte], inputs: openarray[byte]): CttEVMStatus = ## Elliptic Curve multiplication on BN254_Snarks ## (also called alt_bn128 in Ethereum specs ## and bn256 in Ethereum tests) @@ -192,7 +190,6 @@ func eth_evm_ecmul*( # which is 31.5% faster than plain windowed scalar multiplication # at the low cost of a modular reduction. - var sprime{.noInit.}: typeof(smod.mres) # Due to mismatch between the BigInt[256] input and the rest being BigInt[254] # we use the low-level getMont instead of 'fromBig' getMont(smod.mres.limbs, s.limbs, @@ -200,8 +197,7 @@ func eth_evm_ecmul*( Fr[BN254_Snarks].getR2modP().limbs, Fr[BN254_Snarks].getNegInvModWord(), Fr[BN254_Snarks].getSpareBits()) - sprime = smod.toBig() - P.scalarMul(sprime) + P.scalarMul(smod.toBig()) else: P.scalarMul(s) @@ -323,10 +319,13 @@ func eth_evm_ecpairing*( r[r.len-1] = byte 1 return - var gt0{.noInit.}, gt1{.noInit.}: Fp12[BN254_Snarks] var P{.noInit.}: ECP_ShortW_Aff[Fp[BN254_Snarks], G1] var Q{.noInit.}: ECP_ShortW_Aff[Fp2[BN254_Snarks], G2] + var acc {.noInit.}: MillerAccumulator[Fp[BN254_Snarks], Fp2[BN254_Snarks], Fp12[BN254_Snarks]] + acc.init() + var foundInfinity = false + for i in 0 ..< N: let pos = i*192 @@ -348,15 +347,18 @@ func eth_evm_ecpairing*( if statusQ != cttEVM_Success: return statusQ - gt1.millerLoopGenericBN(P, Q) - if i == 0: - gt0 = gt1 - else: - gt0 *= gt1 + let regular = acc.update(P, Q) + if not regular: + foundInfinity = true - gt0.finalExpEasy() - gt0.finalExpHard_BN() + if foundInfinity: # pairing with infinity returns 1, hence no need to compute the following + r[r.len-1] = byte 1 + return + + var gt {.noinit.}: Fp12[BN254_Snarks] + acc.finish(gt) + gt.finalExp() zeroMem(r.addr, r.sizeof()) - if gt0.isOne().bool: + if gt.isOne().bool: r[r.len-1] = byte 1 diff --git a/constantine/math/arithmetic/bigints.nim b/constantine/math/arithmetic/bigints.nim index 7483f7a..7d53519 100644 --- a/constantine/math/arithmetic/bigints.nim +++ b/constantine/math/arithmetic/bigints.nim @@ -61,7 +61,7 @@ export BigInt # https://github.com/mratsim/constantine/issues/15 # No exceptions allowed -{.push raises: [].} +{.push raises: [], checks: off.} {.push inline.} # Initialization @@ -354,7 +354,26 @@ func setBit*[bits: static int](a: var BigInt[bits], index: int) = let shifted = One shl (index and SelectMask) slot[] = slot[] or shifted -# Multiplication by small cosntants +func getWindowAt*(a: BigInt, bitIndex: int, windowSize: static int): SecretWord {.inline.} = + ## Access a window of `a` of size bitsize + static: doAssert windowSize <= WordBitWidth + + const SlotShift = log2_vartime(WordBitWidth.uint32) + const WordMask = WordBitWidth - 1 + const WindowMask = SecretWord((1 shl windowSize) - 1) + + let slot = bitIndex shr SlotShift + let word = a.limbs[slot] # word in limbs + let pos = bitIndex and WordMask # position in the word + + # This is constant-time, the branch does not depend on secret data. + if pos + windowSize > WordBitWidth and slot+1 < a.limbs.len: + # Read next word as well + return SecretWord((word shr pos) or (a.limbs[slot+1] shl (WordBitWidth-pos))) and WindowMask + else: + return SecretWord(word shr pos) and WindowMask + +# Multiplication by small constants # ------------------------------------------------------------ func `*=`*(a: var BigInt, b: static int) = @@ -491,22 +510,93 @@ func invmod*[bits](r: var BigInt[bits], a, M: BigInt[bits]) = one.setOne() r.invmod(a, one, M) +{.pop.} # inline + +# ############################################################ +# +# **Variable-Time** +# +# ############################################################ + +{.push inline.} + +func invmod_vartime*[bits]( + r: var BigInt[bits], + a, F, M: BigInt[bits]) {.tags: [VarTime].} = + ## Compute the modular inverse of ``a`` modulo M + ## r ≡ F.a⁻¹ (mod M) + ## + ## M MUST be odd, M does not need to be prime. + ## ``a`` MUST be less than M. + r.limbs.invmod_vartime(a.limbs, F.limbs, M.limbs, bits) + +func invmod_vartime*[bits]( + r: var BigInt[bits], + a: BigInt[bits], + F, M: static BigInt[bits]) {.tags: [VarTime].} = + ## Compute the modular inverse of ``a`` modulo M + ## r ≡ F.a⁻¹ (mod M) + ## + ## with F and M known at compile-time + ## + ## M MUST be odd, M does not need to be prime. + ## ``a`` MUST be less than M. + r.limbs.invmod_vartime(a.limbs, F.limbs, M.limbs, bits) + +func invmod_vartime*[bits](r: var BigInt[bits], a, M: BigInt[bits]) {.tags: [VarTime].} = + ## Compute the modular inverse of ``a`` modulo M + ## + ## The modulus ``M`` MUST be odd + var one {.noInit.}: BigInt[bits] + one.setOne() + r.invmod_vartime(a, one, M) + +{.pop.} + # ############################################################ # # Recoding # # ############################################################ +# +# Litterature +# +# - Elliptic Curves in Cryptography +# Blake, Seroussi, Smart, 1999 +# +# - Efficient Arithmetic on Koblitz Curves +# Jerome A. Solinas, 2000 +# https://decred.org/research/solinas2000.pdf +# +# - Optimal Left-to-Right Binary Signed-Digit Recoding +# Joye, Yen, 2000 +# https://marcjoye.github.io/papers/JY00sd2r.pdf +# +# - Guide to Elliptic Curve Cryptography +# Hankerson, Menezes, Vanstone, 2004 +# +# - Signed Binary Representations Revisited +# Katsuyuki Okeya, Katja Schmidt-Samoa, Christian Spahn, and Tsuyoshi Takagi, 2004 +# https://eprint.iacr.org/2004/195.pdf +# +# - Some Explicit Formulae of NAF and its Left-to-Right Analogue +# Dong-Guk Han, Tetsuya Izu, and Tsuyoshi Takagi +# https://eprint.iacr.org/2005/384.pdf +# +# See also on Booth encoding and Modified Booth Encoding (bit-pair recoding) +# - https://www.ece.ucdavis.edu/~bbaas/281/notes/Handout.booth.pdf +# - https://vulms.vu.edu.pk/Courses/CS501/Downloads/Booth%20and%20bit%20pair%20encoding.pdf +# - https://vulms.vu.edu.pk/Courses/CS501/Downloads/Bit-Pair%20Recoding.pdf +# - http://www.ecs.umass.edu/ece/koren/arith/simulator/ModBooth/ -iterator recoding_l2r_vartime*(a: BigInt): int8 = +iterator recoding_l2r_signed_vartime*[bits: static int](a: BigInt[bits]): int8 = ## This is a minimum-Hamming-Weight left-to-right recoding. ## It outputs signed {-1, 0, 1} bits from MSB to LSB ## with minimal Hamming Weight to minimize operations - ## in Miller Loop and vartime scalar multiplications + ## in Miller Loops and vartime scalar multiplications ## - ## Tagged vartime as it returns an int8 - ## - Optimal Left-to-Right Binary Signed-Digit Recoding - ## Joye, Yen, 2000 - ## https://marcjoye.github.io/papers/JY00sd2r.pdf + ## ⚠️ While the recoding is constant-time, + ## usage of this recoding is intended vartime # As the caller is copy-pasted at each yield # we rework the algorithm so that we have a single yield point @@ -514,12 +604,12 @@ iterator recoding_l2r_vartime*(a: BigInt): int8 = var bi, bi1, ri, ri1, ri2: int8 - var i = a.bits + var i = bits while true: - if i == a.bits: # We rely on compiler to hoist this branch out of the loop. + if i == bits: # We rely on compiler to hoist this branch out of the loop. ri = 0 - ri1 = int8 a.bit(a.bits-1) - ri2 = int8 a.bit(a.bits-2) + ri1 = int8 a.bit(bits-1) + ri2 = int8 a.bit(bits-2) bi = 0 else: bi = bi1 @@ -531,12 +621,225 @@ iterator recoding_l2r_vartime*(a: BigInt): int8 = ri2 = int8 a.bit(i-2) bi1 = (bi + ri1 + ri2) shr 1 - yield -2*bi + ri + bi1 + let r = -2*bi + ri + bi1 + yield r - if i > 0: + if i != 0: i -= 1 else: break -{.pop.} # inline +func recode_l2r_signed_vartime*[bits: static int]( + recoded: var array[bits+1, SomeSignedInt], a: BigInt[bits]): int {.tags:[VarTime].} = + ## Recode left-to-right (MSB to LSB) + ## Output from most significant to least significant + ## Returns the number of bits used + type I = SomeSignedInt + var i = 0 + for bit in a.recoding_l2r_signed_vartime(): + recoded[i] = I(bit) + inc i + return i + +iterator recoding_r2l_signed_vartime*[bits: static int](a: BigInt[bits]): int8 = + ## This is a minimum-Hamming-Weight left-to-right recoding. + ## It outputs signed {-1, 0, 1} bits from LSB to MSB + ## with minimal Hamming Weight to minimize operations + ## in Miller Loops and vartime scalar multiplications + ## + ## ⚠️ While the recoding is constant-time, + ## usage of this recoding is intended vartime + ## + ## Implementation uses 2-NAF + # This is equivalent to `var r = (3a - a); if (r and 1) == 0: r shr 1` + var ci, ci1, ri, ri1: int8 + + var i = 0 + while i <= bits: + if i == 0: # We rely on compiler to hoist this branch out of the loop. + ri = int8 a.bit(0) + ri1 = int8 a.bit(1) + ci = 0 + else: + ci = ci1 + ri = ri1 + if i >= bits - 1: + ri1 = 0 + else: + ri1 = int8 a.bit(i+1) + + ci1 = (ci + ri + ri1) shr 1 + let r = ci + ri - 2*ci1 + yield r + + i += 1 + +func recode_r2l_signed_vartime*[bits: static int]( + recoded: var array[bits+1, SomeSignedInt], a: BigInt[bits]): int {.tags:[VarTime].} = + ## Recode right-to-left (LSB to MSB) + ## Output from least significant to most significant + ## Returns the number of bits used + type I = SomeSignedInt + var i = 0 + for bit in a.recoding_r2l_signed_vartime(): + recoded[i] = I(bit) + inc i + return i + +iterator recoding_r2l_signed_window_vartime*(a: BigInt, windowLogSize: int): int {.tags:[VarTime].} = + ## This is a minimum-Hamming-Weight right-to-left windowed recoding with the following properties + ## 1. The most significant non-zero bit is positive. + ## 2. Among any w consecutive digits, at most one is non-zero. + ## 3. Each non-zero digit is odd and less than 2ʷ⁻¹ in absolute value. + ## 4. The length of the recoding is at most BigInt.bits + 1 + ## + ## This returns input one digit at a time and not the whole window. + ## + ## ⚠️ not constant-time + + let sMax = 1 shl (windowLogSize - 1) + let uMax = sMax + sMax + let mask = uMax - 1 + + var a {.noInit.} = a + var zeroes = 0 + + while true: + # 1. Count zeroes in LSB + var ctz = 0 + for i in 0 ..< a.limbs.len: + let ai = a.limbs[i] + if ai.isZero().bool: + ctz += WordBitWidth + else: + ctz += BaseType(ai).countTrailingZeroBits_vartime().int + break + + # 2. Remove them + if ctz >= WordBitWidth: + let wordOffset = int(ctz shr log2_vartime(uint32 WordBitWidth)) + for i in 0 ..< a.limbs.len-wordOffset: + a.limbs[i] = a.limbs[i+wordOffset] + for i in a.limbs.len-wordOffset ..< a.limbs.len: + a.limbs[i] = Zero + ctz = ctz and (WordBitWidth-1) + zeroes += wordOffset * WordBitWidth + if ctz > 0: + a.shiftRight(ctz) + zeroes += ctz + + # 3. Yield - We merge yield points with a goto-based state machine + # Nim copy-pastes the iterator for-loop body at yield points, we don't want to duplicate code + # hence we need a single yield point + + type State = enum + StatePrepareYield + StateYield + StateExit + + var yieldVal = 0 + var nextState = StatePrepareYield + + var state {.goto.} = StatePrepareYield + case state + of StatePrepareYield: + # 3.a Yield zeroes + zeroes -= 1 + if zeroes >= 0: + state = StateYield # goto StateYield + + # 3.b Yield the least significant window + var lsw = a.limbs[0].int and mask # signed is important + a.shiftRight(windowLogSize) + if (lsw and sMax) != 0: # MSB of window set + a += One # Lend 2ʷ to next digit + lsw -= uMax # push from [0, 2ʷ) to [-2ʷ⁻¹, 2ʷ⁻¹) + + zeroes = windowLogSize-1 + yieldVal = lsw + nextState = StateExit + # Fall through StateYield + + of StateYield: + yield yieldVal + case nextState + of StatePrepareYield: state = StatePrepareYield + of StateExit: state = StateExit + else: unreachable() + + of StateExit: + if a.isZero().bool: + break + +func recode_r2l_signed_window_vartime*[bits: static int]( + naf: var array[bits+1, SomeSignedInt], a: BigInt[bits], window: int): int {.tags:[VarTime].} = + ## Minimum Hamming-Weight windowed NAF recoding + ## Output from least significant to most significant + ## Returns the number of bits used + ## + ## The `naf` output is returned one digit at a time and not one window at a time + type I = SomeSignedInt + var i = 0 + for digit in a.recoding_r2l_signed_window_vartime(window): + naf[i] = I(digit) + i += 1 + return i + +func signedWindowEncoding(digit: SecretWord, bitsize: static int): tuple[val: SecretWord, neg: SecretBool] {.inline.} = + ## Get the signed window encoding for `digit` + ## + ## This uses the fact that 999 = 100 - 1 + ## It replaces string of binary 1 with 1...-1 + ## i.e. 0111 becomes 1 0 0 -1 + ## + ## This looks at [bitᵢ₊ₙ..bitᵢ | bitᵢ₋₁] + ## and encodes [bitᵢ₊ₙ..bitᵢ] + ## + ## Notes: + ## - This is not a minimum weight encoding unlike NAF + ## - Due to constant-time requirement in scalar multiplication + ## or bucketing large window in multi-scalar-multiplication + ## minimum weight encoding might not lead to saving operations + ## - Unlike NAF and wNAF encoding, there is no carry to propagate + ## hence this is suitable for parallelization without encoding precomputation + ## and for GPUs + ## - Implementation uses Booth encoding + result.neg = SecretBool(digit shr bitsize) + + let negMask = -SecretWord(result.neg) + const valMask = SecretWord((1 shl bitsize) - 1) + + let encode = (digit + One) shr 1 # Lookup bitᵢ₋₁, flip series of 1's + result.val = (encode + negMask) xor negMask # absolute value + result.val = result.val and valMask + +func getSignedFullWindowAt*(a: BigInt, bitIndex: int, windowSize: static int): tuple[val: SecretWord, neg: SecretBool] {.inline.} = + ## Access a signed window of `a` of size bitsize + ## Returns a signed encoding. + ## + ## The result is `windowSize` bits at a time. + ## + ## bitIndex != 0 and bitIndex mod windowSize == 0 + debug: doAssert (bitIndex != 0) and (bitIndex mod windowSize) == 0 + let digit = a.getWindowAt(bitIndex-1, windowSize+1) # get the bit on the right of the window for Booth encoding + return digit.signedWindowEncoding(windowSize) + +func getSignedBottomWindow*(a: BigInt, windowSize: static int): tuple[val: SecretWord, neg: SecretBool] {.inline.} = + ## Access the least significant signed window of `a` of size bitsize + ## Returns a signed encoding. + ## + ## The result is `windowSize` bits at a time. + let digit = a.getWindowAt(0, windowSize) shl 1 # Add implicit 0 on the right of LSB for Booth encoding + return digit.signedWindowEncoding(windowSize) + +func getSignedTopWindow*(a: BigInt, topIndex: int, excess: static int): tuple[val: SecretWord, neg: SecretBool] {.inline.} = + ## Access the least significant signed window of `a` of size bitsize + ## Returns a signed encoding. + ## + ## The result is `excess` bits at a time. + ## + ## bitIndex != 0 and bitIndex mod windowSize == 0 + let digit = a.getWindowAt(topIndex-1, excess+1) # Add implicit 0 on the left of MSB and get the bit on the right of the window + return digit.signedWindowEncoding(excess+1) + {.pop.} # raises no exceptions diff --git a/constantine/math/arithmetic/finite_fields.nim b/constantine/math/arithmetic/finite_fields.nim index 8b2f328..f7223aa 100644 --- a/constantine/math/arithmetic/finite_fields.nim +++ b/constantine/math/arithmetic/finite_fields.nim @@ -317,7 +317,7 @@ func div2*(a: var FF) {.meter.} = let wasOdd = a.mres.isOdd() a.mres.shiftRight(1) let carry {.used.} = a.mres.cadd(FF.getPrimePlus1div2(), wasOdd) - + # a < M -> a/2 <= M/2: # a/2 + M/2 < M if a is odd # a/2 < M if a is even @@ -550,9 +550,6 @@ template mulCheckSparse*(a: var Fp, b: Fp) = else: a *= b -{.pop.} # inline -{.pop.} # raises no exceptions - # ############################################################ # # Field arithmetic ergonomic macros @@ -577,7 +574,7 @@ macro addchain*(fn: untyped): untyped = if i + 1 != result[^1].len: # Modify all but the last if s.kind == nnkCall: - doAssert s[0].kind == nnkDotExpr, "Only method call syntax or infix syntax is supported in addition chains" + doAssert s[0].kind == nnkDotExpr, "Only method call syntax or infix syntax is supported in addition chains" doAssert s[0][1].eqIdent"prod" or s[0][1].eqIdent"square" or s[0][1].eqIdent"square_repeated" s.add newLit(true) elif s.kind == nnkInfix: @@ -590,8 +587,32 @@ macro addchain*(fn: untyped): untyped = s[2], newLit(true) ) - + body.add s result[^1] = body - # echo result.toStrLit() \ No newline at end of file + # echo result.toStrLit() + +# ############################################################ +# +# **Variable-Time** +# +# ############################################################ + +func inv_vartime*(r: var FF, a: FF) {.tags: [VarTime].} = + ## Variable-time Inversion modulo p + ## + ## The inverse of 0 is 0. + ## Incidentally this avoids extra check + ## to convert Jacobian and Projective coordinates + ## to affine for elliptic curve + r.mres.invmod_vartime(a.mres, FF.getR2modP(), FF.fieldMod()) + +func inv_vartime*(a: var FF) {.tags: [VarTime].} = + ## Variable-time Inversion modulo p + ## + ## The inverse of 0 is 0. + ## Incidentally this avoids extra check + ## to convert Jacobian and Projective coordinates + ## to affine for elliptic curve + a.inv_vartime(a) \ No newline at end of file diff --git a/constantine/math/arithmetic/limbs_exgcd.nim b/constantine/math/arithmetic/limbs_exgcd.nim index ca292c1..31ee552 100644 --- a/constantine/math/arithmetic/limbs_exgcd.nim +++ b/constantine/math/arithmetic/limbs_exgcd.nim @@ -7,11 +7,12 @@ # at your option. This file may not be copied, modified, or distributed except according to those terms. import - ../../platforms/[abstractions, signed_secret_words], + ../../platforms/abstractions, ./limbs, ./limbs_unsaturated # No exceptions allowed {.push raises: [].} +{.push checks: off.} # ############################################################ # @@ -342,18 +343,24 @@ func matVecMul_shr_k_mod_M[N, E: static int]( d[N-1] = cd.lo e[N-1] = ce.lo -func matVecMul_shr_k[N, E: static int]( +template matVecMul_shr_k_impl( t: TransitionMatrix, - f, g: var LimbsUnsaturated[N, E], + f, g: var LimbsUnsaturated, + Excess: static int, + numLimbsLeft: int or static int, k: static int ) = ## Compute ## ## [u v] [f] ## [q r].[g] / 2ᵏ + ## + ## Template so that it can be specialized + ## when iteration number is fixed and compiler can unroll, in constant-time case + ## or variable and the full buffer might not be used (vartime) - static: doAssert k == WordBitWidth - E - const Max = SignedSecretWord(MaxWord shr E) + static: doAssert k == WordBitWidth - Excess + const Max = SignedSecretWord(MaxWord shr Excess) let u = t.u @@ -376,7 +383,7 @@ func matVecMul_shr_k[N, E: static int]( cf.ashr(k) cg.ashr(k) - for i in 1 ..< N: + for i in 1 ..< numLimbsLeft: cf.ssumprodAccNoCarry(u, f[i], v, g[i]) cg.ssumprodAccNoCarry(q, f[i], r, g[i]) f[i-1] = cf.lo and Max @@ -384,8 +391,11 @@ func matVecMul_shr_k[N, E: static int]( cf.ashr(k) cg.ashr(k) - f[N-1] = cf.lo - g[N-1] = cg.lo + f[numLimbsLeft-1] = cf.lo + g[numLimbsLeft-1] = cg.lo + +func matVecMul_shr_k[N, E: static int](t: TransitionMatrix, f, g: var LimbsUnsaturated[N, E], k: static int) = + matVecMul_shr_k_impl(t, f, g, E, N, k) func invmodImpl[N, E]( a: var LimbsUnsaturated[N, E], @@ -666,3 +676,217 @@ func legendre*(a: Limbs, M: static Limbs, bits: static int): SecretWord = a2.fromPackedRepr(a) legendreImpl(a2, m2, k, bits) + + +# ############################################################ +# +# Variable-time optimizations +# +# ############################################################ + +const NegInvMod256 = [ + # Stores tab[i div 2] = -i⁻¹ (mod 256), with i odd + # See "invModBitwidth" on "Dumas iterations" + # ax ≡ 1 (mod 2ᵏ) <=> ax(2 - ax) ≡ 1 (mod 2^(2k)) + # a⁻¹ (mod 256) = a(2-a²) + -1, -235, -141, -183, -57, -227, -133, -239, + -241, -91, -253, -167, -41, -83, -245, -223, + -225, -203, -109, -151, -25, -195, -101, -207, + -209, -59, -221, -135, -9, -51, -213, -191, + -193, -171, -77, -119, -249, -163, -69, -175, + -177, -27, -189, -103, -233, -19, -181, -159, + -161, -139, -45, -87, -217, -131, -37, -143, + -145, -251, -157, -71, -201, -243, -149, -127, + -129, -107, -13, -55, -185, -99, -5, -111, + -113, -219, -125, -39, -169, -211, -117, -95, + -97, -75, -237, -23, -153, -67, -229, -79, + -81, -187, -93, -7, -137, -179, -85, -63, + -65, -43, -205, -247, -121, -35, -197, -47, + -49, -155, -61, -231, -105, -147, -53, -31, + -33, -11, -173, -215, -89, -3, -165, -15, + -17, -123, -29, -199, -73, -115, -21, -255] + +func batchedDivsteps_vartime( + t: var TransitionMatrix, + eta: SignedSecretWord, + f0, g0: SecretWord, + k: static int + ): SignedSecretWord {.tags:[Vartime].} = + ## Bernstein-Yang eta (-delta) batch of divsteps + ## **Variable-Time** + ## + ## Output: + ## - return eta for the next batch of divsteps + ## - mutate t, the transition matrix to apply `numIters` divsteps at once + ## t is scaled by 2ᵏ + ## + ## Input: + ## - f0, bottom limb of f + ## - g0, bottom limb of g + ## - k, the maximum batch size, transition matrix is scaled by 2ᵏ + + template swapNeg(a, b) = + var tmp = -a + a = b + b = tmp + + var + u = One + v = Zero + q = Zero + r = One + f = f0 + g = g0 + + eta = cast[SignedBaseType](eta) + bitsLeft = cast[SignedBaseType](k) + + while true: + # Count zeros up to bitsLeft and process a batch of divsteps up to that number + let zeros = (g.BaseType or (1.BaseType shl bitsLeft)).countTrailingZeroBits_vartime() + g = g shr zeros + u = u shl zeros + v = v shl zeros + eta -= cast[SignedBaseType](zeros) + bitsLeft -= cast[SignedBaseType](zeros) + + if bitsLeft == 0: + break + + # Now process, the 1's. + if eta < 0: + eta = -eta + swapNeg(f, g) + swapNeg(u, q) + swapNeg(v, r) + + # We process up to 6 1's at once + const mask6 = SecretWord((1 shl 6) - 1) + let limit = min(eta+1, bitsLeft) + let maskLimit = (MaxWord shr (WordBitWidth - limit)) and mask6 + # Find the multiple of f to add to cancel the bottom min(limit, 6) bits of g + let w = (g * SecretWord NegInvMod256[int((f and mask6) shr 1)]) and maskLimit + + # Next iteration will have at least 6 0's to process at once + g += f*w + q += u*w + r += v*w + + t.u = SignedSecretWord u + t.v = SignedSecretWord v + t.q = SignedSecretWord q + t.r = SignedSecretWord r + return SignedSecretWord(eta) + +func matVecMul_shr_k_partial(t: TransitionMatrix, f, g: var LimbsUnsaturated, len: int, k: static int) = + ## Matrix-Vector multiplication with top part of f and g being zeros + matVecMul_shr_k_impl(t, f, g, LimbsUnsaturated.Excess, len, k) + +func isZero_vartime(a: LimbsUnsaturated, limbsLeft: int): bool {.tags:[VarTime].} = + for i in 0 ..< limbsLeft: + if a[i].int != 0: + return false + return true + +func discardUnusedLimb_vartime[N, E: static int](limbsLeft: var int, f, g: var LimbsUnsaturated[N, E]) {.tags:[VarTime].} = + ## If f and g both don't use their last limb, it will propagate the sign down to the previous one + if limbsLeft == 1: + return + + let fn = f[limbsLeft-1] + let gn = g[limbsLeft-1] + var mask = SignedSecretWord(0) + mask = mask or (fn xor fn.isNegMask()) # 0 if last limb has nothing left but its sign + mask = mask or (gn xor gn.isNegMask()) # 0 if last limb has nothing left but its sign + if cast[SignedBaseType](mask) == 0: + f[limbsLeft-2] = f[limbsLeft-2] or fn.lshl(WordBitWidth-E) # if only sign is left, the last limb is 11..11 if negative + g[limbsLeft-2] = g[limbsLeft-2] or gn.lshl(WordBitWidth-E) # or 00..00 if positive + limbsLeft -= 1 + +func invmodImpl_vartime[N, E: static int]( + a: var LimbsUnsaturated[N, E], + F, M: LimbsUnsaturated[N, E], + invMod2powK: SecretWord, + k, bits: static int) {.tags:[VarTime].} = + ## **Variable-time** Modular inversion using Bernstein-Yang algorithm + ## r ≡ F.a⁻¹ (mod M) + + # eta = -delta + var eta = cast[SignedSecretWord](-1) + var d{.noInit.}, e{.noInit.}: LimbsUnsaturated[N, E] + var f{.noInit.}, g{.noInit.}: LimbsUnsaturated[N, E] + + d.setZero() + e = F + + f = M + g = a + + var limbsLeft = N + + while true: + var t{.noInit.}: TransitionMatrix + # Compute transition matrix and next eta + eta = t.batchedDivsteps_vartime(eta, SecretWord f[0], SecretWord g[0], k) + # Apply the transition matrix + # [u v] [d] + # [q r]/2ᵏ.[e] mod M + t.matVecMul_shr_k_mod_M(d, e, k, M, invMod2powK) + # [u v] [f] + # [q r]/2ᵏ.[g] + t.matVecMul_shr_k_partial(f, g, limbsLeft, k) + if g.isZero_vartime(limbsLeft): + break + limbsLeft.discardUnusedLimb_vartime(f, g) + + d.canonicalize(signMask = f[limbsLeft-1].isNegMask(), M) + a = d + +func invmod_vartime*( + r: var Limbs, a: Limbs, + F, M: Limbs, bits: static int) {.tags:[VarTime].} = + ## Compute the scaled modular inverse of ``a`` modulo M + ## r ≡ F.a⁻¹ (mod M) + ## + ## M MUST be odd, M does not need to be prime. + ## ``a`` MUST be less than M. + const Excess = 2 + const k = WordBitWidth - Excess + const NumUnsatWords = (bits + k - 1) div k + + # Convert values to unsaturated repr + var m2 {.noInit.}: LimbsUnsaturated[NumUnsatWords, Excess] + var factor {.noInit.}: LimbsUnsaturated[NumUnsatWords, Excess] + m2.fromPackedRepr(M) + factor.fromPackedRepr(F) + let m0invK = SecretWord invMod2powK(BaseType M[0], k) + + var a2 {.noInit.}: LimbsUnsaturated[NumUnsatWords, Excess] + a2.fromPackedRepr(a) + a2.invmodImpl_vartime(factor, m2, m0invK, k, bits) + r.fromUnsatRepr(a2) + +func invmod_vartime*( + r: var Limbs, a: Limbs, + F, M: static Limbs, bits: static int) {.tags:[VarTime].} = + ## Compute the scaled modular inverse of ``a`` modulo M + ## r ≡ F.a⁻¹ (mod M) (compile-time factor and modulus overload) + ## + ## with F and M known at compile-time + ## + ## M MUST be odd, M does not need to be prime. + ## ``a`` MUST be less than M. + + const Excess = 2 + const k = WordBitWidth - Excess + const NumUnsatWords = (bits + k - 1) div k + + # Convert values to unsaturated repr + const m2 = LimbsUnsaturated[NumUnsatWords, Excess].fromPackedRepr(M) + const factor = LimbsUnsaturated[NumUnsatWords, Excess].fromPackedRepr(F) + const m0invK = SecretWord invMod2powK(BaseType M[0], k) + + var a2 {.noInit.}: LimbsUnsaturated[NumUnsatWords, Excess] + a2.fromPackedRepr(a) + a2.invmodImpl_vartime(factor, m2, m0invK, k, bits) + r.fromUnsatRepr(a2) \ No newline at end of file diff --git a/constantine/math/arithmetic/limbs_unsaturated.nim b/constantine/math/arithmetic/limbs_unsaturated.nim index 34174e8..d9c9847 100644 --- a/constantine/math/arithmetic/limbs_unsaturated.nim +++ b/constantine/math/arithmetic/limbs_unsaturated.nim @@ -6,7 +6,7 @@ # * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). # at your option. This file may not be copied, modified, or distributed except according to those terms. -import ../../platforms/[abstractions, signed_secret_words] +import ../../platforms/abstractions type LimbsUnsaturated*[N, Excess: static int] = object diff --git a/constantine/math/config/curves_declaration.nim b/constantine/math/config/curves_declaration.nim index edc4059..b2b57aa 100644 --- a/constantine/math/config/curves_declaration.nim +++ b/constantine/math/config/curves_declaration.nim @@ -128,7 +128,7 @@ declareCurves: # https://z.cash/technology/jubjub/ bitwidth: 255 modulus: "0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001" - # Montgomery form: y² = x³ + 40962x² + x + # Montgomery form: y² = x³ + 40962x² + x # Twisted Edwards: ax² + y² = 1+dx²y² with a = -1 d=-10240/10241 order: "0xe7db4ea6533afa906673b0101343b00a6682093ccc81082d0970e5ed6f72cb7" orderBitwidth: 252 @@ -159,11 +159,11 @@ declareCurves: bitwidth: 255 modulus: "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed" - # Montgomery form: y² = x³ + 486662x² + x + # Montgomery form: y² = x³ + 486662x² + x # Edwards form: x² + y² = 1+dx²y² with d = 121665/121666 # Twisted Edwards form: ax² + y² = 1+dx²y² with a = 121666 and d = 121665 - # or for use in Hisil, Wong, Carter, and Dawson extended coordinates - # ax² + y² = 1+dx²y² with a = -1 d=-121665/121666 + # or for use in Hisil, Wong, Carter, and Dawson extended coordinates + # ax² + y² = 1+dx²y² with a = -1 d=-121665/121666 order: "0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed" orderBitwidth: 253 cofactor: 8 @@ -198,6 +198,9 @@ declareCurves: modulus: "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f" order: "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141" orderBitwidth: 256 + eq_form: ShortWeierstrass + coef_a: 0 + coef_b: 7 curve BLS12_377: # Zexe curve # (p41) https://eprint.iacr.org/2018/962.pdf diff --git a/constantine/math/constants/bls12_377_pairings.nim b/constantine/math/constants/bls12_377_pairings.nim index 07c2b07..2088a9d 100644 --- a/constantine/math/constants/bls12_377_pairings.nim +++ b/constantine/math/constants/bls12_377_pairings.nim @@ -13,8 +13,7 @@ import ../extension_fields, ../elliptic/[ec_shortweierstrass_affine, ec_shortweierstrass_projective], ../pairings/[cyclotomic_subgroups, miller_loops], - ../isogenies/frobenius, - ../../platforms/allocs + ../isogenies/frobenius # Slow generic implementation # ------------------------------------------------------------ @@ -22,8 +21,7 @@ import # The bit count must be exact for the Miller loop const BLS12_377_pairing_ate_param* = block: # BLS12 Miller loop is parametrized by u - # +1 to bitlength so that we can mul by 3 for NAF encoding - BigInt[64+1].fromHex"0x8508c00000000001" + BigInt[64].fromHex"0x8508c00000000001" const BLS12_377_pairing_ate_param_isNeg* = false @@ -65,7 +63,7 @@ func millerLoopAddchain*( Qs: ptr UncheckedArray[ECP_ShortW_Aff[Fp2[BLS12_377], G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[Fp[BLS12_377], G1]], N: int - ) = + ) {.noInline.} = ## Miller Loop for BLS12-377 curve ## Computes f{u,Q}(P) with u the BLS curve parameter diff --git a/constantine/math/constants/bls12_377_subgroups.nim b/constantine/math/constants/bls12_377_subgroups.nim index 3d6dd1e..0a013b3 100644 --- a/constantine/math/constants/bls12_377_subgroups.nim +++ b/constantine/math/constants/bls12_377_subgroups.nim @@ -105,9 +105,9 @@ func clearCofactorReference*(P: var ECP_ShortW_Prj[Fp2[BLS12_377], G2]) {.inline # BLS12 G1 # ------------------------------------------------------------ -func clearCofactorFast*(P: var ECP_ShortW_Prj[Fp[BLS12_377], G1]) = +func clearCofactorFast*(P: var ECP_ShortW[Fp[BLS12_377], G1]) = ## Clear the cofactor of BLS12_377 G1 - ## + ## ## Wahby et al "Fast and simple constant-time hashing to the BLS12-377 elliptic curve", https://eprint.iacr.org/2019/403 ## Optimized using endomorphisms ## P -> (1 - x) P @@ -144,7 +144,7 @@ func clearCofactorFast*(P: var ECP_ShortW_Prj[Fp[BLS12_377], G1]) = # with Psi (ψ) - untwist-Frobenius-Twist function # and x the curve BLS parameter -func clearCofactorFast*(P: var ECP_ShortW_Prj[Fp2[BLS12_377], G2]) = +func clearCofactorFast*(P: var ECP_ShortW[Fp2[BLS12_377], G2]) = ## Clear the cofactor of BLS12_377 G2 ## Optimized using endomorphisms ## P -> [x²-x-1]P + [x-1] ψ(P) + ψ²([2]P) @@ -172,41 +172,62 @@ func clearCofactorFast*(P: var ECP_ShortW_Prj[Fp2[BLS12_377], G2]) = # # ############################################################ -func isInSubgroup*(P: ECP_ShortW_Prj[Fp[BLS12_377], G1]): SecretBool = +func isInSubgroup*(P: ECP_ShortW[Fp[BLS12_377], G1]): SecretBool = ## Returns true if P is in G1 subgroup, i.e. P is a point of order r. ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. - ## + ## ## Warning ⚠: Assumes that P is on curve # Implementation: Scott, https://eprint.iacr.org/2021/1130.pdf # A note on group membership tests for G1, G2 and GT # on BLS pairing-friendly curves # P is in the G1 subgroup iff ϕ(P) == [-u²](P) - var t0{.noInit.}, t1{.noInit.}: ECP_ShortW_Prj[Fp[BLS12_377], G1] - + var t0{.noInit.}, t1{.noInit.}: typeof(P) + # [-u²]P t0.pow_bls12_377_x(P) - t1.pow_bls12_377_minus_x(t0) + t1.pow_bls12_377_minus_x(t0) # ϕ(P) t0.x.prod(P.x, BLS12_377.getCubicRootOfUnity_mod_p()) t0.y = P.y - t0.z = P.z + t0.z = P.z return t0 == t1 -func isInSubgroup*(P: ECP_ShortW_Prj[Fp2[BLS12_377], G2]): SecretBool = +func isInSubgroup*(P: ECP_ShortW[Fp2[BLS12_377], G2]): SecretBool = ## Returns true if P is in G2 subgroup, i.e. P is a point of order r. ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. - ## + ## ## Warning ⚠: Assumes that P is on curve # Implementation: Scott, https://eprint.iacr.org/2021/1130.pdf # A note on group membership tests for G1, G2 and GT # on BLS pairing-friendly curves # P is in the G1 subgroup iff ψ(P) == [u](P) - var t0{.noInit.}, t1{.noInit.}: ECP_ShortW_Prj[Fp2[BLS12_377], G2] + var t0{.noInit.}, t1{.noInit.}: typeof(P) t0.pow_bls12_377_x(P) # [u]P t1.frobenius_psi(P) # ψ(P) - return t0 == t1 \ No newline at end of file + return t0 == t1 + +func isInSubgroup*(P: ECP_ShortW_Aff[Fp[BLS12_377], G1]): SecretBool = + ## Returns true if P is in 𝔾1 subgroup, i.e. P is a point of order r. + ## A point may be on a curve but not on the prime order r subgroup. + ## Not checking subgroup exposes a protocol to small subgroup attacks. + ## + ## Warning ⚠: Assumes that P is on curve + var t{.noInit.}: ECP_ShortW_Prj[Fp[BLS12_377], G1] + t.fromAffine(P) + return t.isInSubgroup() + + +func isInSubgroup*(P: ECP_ShortW_Aff[Fp2[BLS12_377], G2]): SecretBool = + ## Returns true if P is in 𝔾2 subgroup, i.e. P is a point of order r. + ## A point may be on a curve but not on the prime order r subgroup. + ## Not checking subgroup exposes a protocol to small subgroup attacks. + ## + ## Warning ⚠: Assumes that P is on curve + var t{.noInit.}: ECP_ShortW_Jac[Fp2[BLS12_377], G2] + t.fromAffine(P) + return t.isInSubgroup() \ No newline at end of file diff --git a/constantine/math/constants/bls12_381_pairings.nim b/constantine/math/constants/bls12_381_pairings.nim index f6fcda2..ae56845 100644 --- a/constantine/math/constants/bls12_381_pairings.nim +++ b/constantine/math/constants/bls12_381_pairings.nim @@ -13,8 +13,7 @@ import ../extension_fields, ../elliptic/[ec_shortweierstrass_affine, ec_shortweierstrass_projective], ../pairings/[cyclotomic_subgroups, miller_loops], - ../isogenies/frobenius, - ../../platforms/allocs + ../isogenies/frobenius # Slow generic implementation # ------------------------------------------------------------ @@ -22,8 +21,7 @@ import # The bit count must be exact for the Miller loop const BLS12_381_pairing_ate_param* = block: # BLS12 Miller loop is parametrized by u - # +2 to bitlength so that we can mul by 3 for NAF encoding - BigInt[64+2].fromHex"0xd201000000010000" + BigInt[64].fromHex"0xd201000000010000" const BLS12_381_pairing_ate_param_isNeg* = true @@ -66,7 +64,7 @@ func millerLoopAddchain*( Qs: ptr UncheckedArray[ECP_ShortW_Aff[Fp2[BLS12_381], G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[Fp[BLS12_381], G1]], N: int - ) = + ) {.noInline.} = ## Generic Miller Loop for BLS12 curve ## Computes f{u,Q}(P) with u the BLS curve parameter diff --git a/constantine/math/constants/bls12_381_subgroups.nim b/constantine/math/constants/bls12_381_subgroups.nim index 0e34848..040be75 100644 --- a/constantine/math/constants/bls12_381_subgroups.nim +++ b/constantine/math/constants/bls12_381_subgroups.nim @@ -101,7 +101,7 @@ func clearCofactorReference*(P: var ECP_ShortW_Prj[Fp2[BLS12_381], G2]) {.inline func clearCofactorFast*(P: var ECP_ShortW[Fp[BLS12_381], G1]) = ## Clear the cofactor of BLS12_381 𝔾1 - ## + ## ## Wahby et al "Fast and simple constant-time hashing to the BLS12-381 elliptic curve", https://eprint.iacr.org/2019/403 ## Optimized using endomorphisms ## P -> (1 - x) P @@ -166,11 +166,11 @@ func clearCofactorFast*(P: var ECP_ShortW[Fp2[BLS12_381], G2]) = # # ############################################################ -func isInSubgroup*(P: ECP_ShortW_Jac[Fp[BLS12_381], G1] or ECP_ShortW_Prj[Fp[BLS12_381], G1]): SecretBool = +func isInSubgroup*(P: ECP_ShortW[Fp[BLS12_381], G1]): SecretBool = ## Returns true if P is in 𝔾1 subgroup, i.e. P is a point of order r. ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. - ## + ## ## Warning ⚠: Assumes that P is on curve # Implementation: Scott, https://eprint.iacr.org/2021/1130.pdf # A note on group membership tests for 𝔾1, 𝔾2 and 𝔾T @@ -180,20 +180,20 @@ func isInSubgroup*(P: ECP_ShortW_Jac[Fp[BLS12_381], G1] or ECP_ShortW_Prj[Fp[BLS # [-u²]P t0.pow_bls12_381_x(P) - t1.pow_bls12_381_minus_x(t0) + t1.pow_bls12_381_minus_x(t0) # ϕ(P) t0.x.prod(P.x, BLS12_381.getCubicRootOfUnity_mod_p()) t0.y = P.y - t0.z = P.z + t0.z = P.z return t0 == t1 -func isInSubgroup*(P: ECP_ShortW_Jac[Fp2[BLS12_381], G2] or ECP_ShortW_Prj[Fp2[BLS12_381], G2]): SecretBool = +func isInSubgroup*(P: ECP_ShortW[Fp2[BLS12_381], G2]): SecretBool = ## Returns true if P is in 𝔾2 subgroup, i.e. P is a point of order r. ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. - ## + ## ## Warning ⚠: Assumes that P is on curve # Implementation: Scott, https://eprint.iacr.org/2021/1130.pdf # A note on group membership tests for 𝔾1, 𝔾2 and 𝔾T @@ -209,7 +209,7 @@ func isInSubgroup*(P: ECP_ShortW_Aff[Fp[BLS12_381], G1]): SecretBool = ## Returns true if P is in 𝔾1 subgroup, i.e. P is a point of order r. ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. - ## + ## ## Warning ⚠: Assumes that P is on curve var t{.noInit.}: ECP_ShortW_Prj[Fp[BLS12_381], G1] t.fromAffine(P) @@ -220,7 +220,7 @@ func isInSubgroup*(P: ECP_ShortW_Aff[Fp2[BLS12_381], G2]): SecretBool = ## Returns true if P is in 𝔾2 subgroup, i.e. P is a point of order r. ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. - ## + ## ## Warning ⚠: Assumes that P is on curve var t{.noInit.}: ECP_ShortW_Jac[Fp2[BLS12_381], G2] t.fromAffine(P) diff --git a/constantine/math/constants/bn254_nogami_pairings.nim b/constantine/math/constants/bn254_nogami_pairings.nim index 00b30f0..a273665 100644 --- a/constantine/math/constants/bn254_nogami_pairings.nim +++ b/constantine/math/constants/bn254_nogami_pairings.nim @@ -13,8 +13,7 @@ import ../extension_fields, ../elliptic/[ec_shortweierstrass_affine, ec_shortweierstrass_projective], ../pairings/[cyclotomic_subgroups, miller_loops], - ../isogenies/frobenius, - ../../platforms/allocs + ../isogenies/frobenius # Slow generic implementation # ------------------------------------------------------------ @@ -22,8 +21,7 @@ import # The bit count must be exact for the Miller loop const BN254_Nogami_pairing_ate_param* = block: # BN Miller loop is parametrized by 6u+2 - # +2 to bitlength so that we can mul by 3 for NAF encoding - BigInt[65+2].fromHex"0x18300000000000004" + BigInt[65].fromHex"0x18300000000000004" const BN254_Nogami_pairing_ate_param_isNeg* = true @@ -56,16 +54,17 @@ func millerLoopAddchain*( # Negative AteParam f.conj() + T.neg() # Ate pairing for BN curves needs adjustment after basic Miller loop - f.millerCorrectionBN(T, Q, P, BN254_Nogami_pairing_ate_param_isNeg) + f.millerCorrectionBN(T, Q, P) func millerLoopAddchain*( f: var Fp12[BN254_Nogami], Qs: ptr UncheckedArray[ECP_ShortW_Aff[Fp2[BN254_Nogami], G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[Fp[BN254_Nogami], G1]], N: int - ) = + ) {.noInline.} = ## Miller Loop for BN254-Nogami curve ## Computes f{6u+2,Q}(P) with u the BLS curve parameter var Ts = allocStackArray(ECP_ShortW_Prj[Fp2[BN254_Nogami], G2], N) @@ -78,9 +77,11 @@ func millerLoopAddchain*( # Negative AteParam f.conj() + for i in 0 ..< N: + Ts[i].neg() for i in 0 ..< N: - f.millerCorrectionBN(Ts[i], Qs[i], Ps[i], BN254_Nogami_pairing_ate_param_isNeg) + f.millerCorrectionBN(Ts[i], Qs[i], Ps[i]) func cycl_exp_by_curve_param*( r: var Fp12[BN254_Nogami], a: Fp12[BN254_Nogami], diff --git a/constantine/math/constants/bn254_snarks_pairings.nim b/constantine/math/constants/bn254_snarks_pairings.nim index 035ef2b..b82323a 100644 --- a/constantine/math/constants/bn254_snarks_pairings.nim +++ b/constantine/math/constants/bn254_snarks_pairings.nim @@ -20,8 +20,7 @@ import # The bit count must be exact for the Miller loop const BN254_Snarks_pairing_ate_param* = block: # BN Miller loop is parametrized by 6u+2 - # +2 to bitlength so that we can mul by 3 for NAF encoding - BigInt[65+2].fromHex"0x19d797039be763ba8" + BigInt[65].fromHex"0x19d797039be763ba8" const BN254_Snarks_pairing_ate_param_isNeg* = false diff --git a/constantine/math/constants/bw6_761_pairings.nim b/constantine/math/constants/bw6_761_pairings.nim index f82bef2..ab561b3 100644 --- a/constantine/math/constants/bw6_761_pairings.nim +++ b/constantine/math/constants/bw6_761_pairings.nim @@ -20,8 +20,7 @@ import # 1st part: f_{u+1,Q}(P) const BW6_761_pairing_ate_param_1_unopt* = block: # BW6-761 unoptimized Miller loop first part is parametrized by u+1 - # +1 to bitlength so that we can mul by 3 for NAF encoding - BigInt[64+1].fromHex"0x8508c00000000002" + BigInt[64].fromHex"0x8508c00000000002" const BW6_761_pairing_ate_param_1_unopt_isNeg* = false diff --git a/constantine/math/constants/pallas_subgroups.nim b/constantine/math/constants/pallas_subgroups.nim index 75d1ab6..6f6cd67 100644 --- a/constantine/math/constants/pallas_subgroups.nim +++ b/constantine/math/constants/pallas_subgroups.nim @@ -19,7 +19,7 @@ import # # ############################################################ -func clearCofactorReference*(P: var ECP_ShortW_Prj[Fp[Pallas], G1]) {.inline.} = +func clearCofactorReference*(P: var ECP_ShortW[Fp[Pallas], G1]) {.inline.} = ## Clear the cofactor of Pallas G1 ## The Pasta curves have a prime-order group so this is a no-op discard @@ -35,6 +35,6 @@ func isInSubgroup*(P: ECP_ShortW[Fp[Pallas], G1]): SecretBool {.inline.} = ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. ## This is a no-op as on G1, all points are in the correct subgroup. - ## + ## ## Warning ⚠: Assumes that P is on curve return CtTrue diff --git a/constantine/math/constants/secp256k1_subgroups.nim b/constantine/math/constants/secp256k1_subgroups.nim new file mode 100644 index 0000000..bc25125 --- /dev/null +++ b/constantine/math/constants/secp256k1_subgroups.nim @@ -0,0 +1,37 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../../platforms/abstractions, + ../config/curves, + ../arithmetic, + ../ec_shortweierstrass + +# ############################################################ +# +# Clear Cofactor - Naive +# +# ############################################################ + +func clearCofactorReference*(P: var ECP_ShortW[Fp[Secp256k1], G1]) {.inline.} = + ## Clear the cofactor of Secp256k1 + ## The secp256k1 curve has a prime-order group so this is a no-op + discard + +# ############################################################ +# +# Subgroup checks +# +# ############################################################ + +func isInSubgroup*(P: ECP_ShortW[Fp[Secp256k1], G1]): SecretBool {.inline.} = + ## This is a no-op, all points on curve are in the correct subgroup. + ## + ## Warning ⚠: Assumes that P is on curve + return CtTrue diff --git a/constantine/math/constants/vesta_subgroups.nim b/constantine/math/constants/vesta_subgroups.nim index 4a62638..1bdb87a 100644 --- a/constantine/math/constants/vesta_subgroups.nim +++ b/constantine/math/constants/vesta_subgroups.nim @@ -19,7 +19,7 @@ import # # ############################################################ -func clearCofactorReference*(P: var ECP_ShortW_Prj[Fp[Vesta], G1]) {.inline.} = +func clearCofactorReference*(P: var ECP_ShortW[Fp[Vesta], G1]) {.inline.} = ## Clear the cofactor of Vesta G1 ## The Pasta curves have a prime-order group so this is a no-op discard @@ -35,6 +35,6 @@ func isInSubgroup*(P: ECP_ShortW[Fp[Vesta], G1]): SecretBool {.inline.} = ## A point may be on a curve but not on the prime order r subgroup. ## Not checking subgroup exposes a protocol to small subgroup attacks. ## This is a no-op as on G1, all points are in the correct subgroup. - ## + ## ## Warning ⚠: Assumes that P is on curve return CtTrue diff --git a/constantine/math/constants/zoo_endomorphisms.nim b/constantine/math/constants/zoo_endomorphisms.nim index 5e5e489..6248341 100644 --- a/constantine/math/constants/zoo_endomorphisms.nim +++ b/constantine/math/constants/zoo_endomorphisms.nim @@ -49,3 +49,10 @@ func hasEndomorphismAcceleration*(C: static Curve): bool = Pallas, Vesta } + +const EndomorphismThreshold* = 196 + ## We use substraction by maximum infinity norm coefficient + ## to split scalars for endomorphisms + ## For small scalars the substraction will overflow + ## + ## TODO: implement an alternative way to split scalars. \ No newline at end of file diff --git a/constantine/math/constants/zoo_subgroups.nim b/constantine/math/constants/zoo_subgroups.nim index 046436d..0fbbd9a 100644 --- a/constantine/math/constants/zoo_subgroups.nim +++ b/constantine/math/constants/zoo_subgroups.nim @@ -15,14 +15,16 @@ import ./bn254_snarks_subgroups, ./bw6_761_subgroups, ./pallas_subgroups, - ./vesta_subgroups + ./vesta_subgroups, + ./secp256k1_subgroups export bls12_377_subgroups, bls12_381_subgroups, bn254_nogami_subgroups, bn254_snarks_subgroups, - bw6_761_subgroups + bw6_761_subgroups, + secp256k1_subgroups func clearCofactor*[ECP](P: var ECP) {.inline.} = ## Clear the cofactor of a point on the curve diff --git a/constantine/math/elliptic/ec_endomorphism_accel.nim b/constantine/math/elliptic/ec_endomorphism_accel.nim index 4a77859..97a289f 100644 --- a/constantine/math/elliptic/ec_endomorphism_accel.nim +++ b/constantine/math/elliptic/ec_endomorphism_accel.nim @@ -58,6 +58,8 @@ func decomposeEndo*[M, scalBits, L: static int]( ## We need to test the mini scalar, which is 65 bits so 2 Fp so about 2 cycles ## and negate it as well. + static: doAssert scalBits >= L, "Cannot decompose a scalar smaller than a mini-scalar or the decomposition coefficient" + # Equal when no window or no negative handling, greater otherwise static: doAssert L >= (scalBits + M - 1) div M + 1 const w = F.C.getCurveOrderBitwidth().wordsRequired() @@ -493,7 +495,7 @@ func scalarMulGLV_m2w2*[scalBits; EC]( mixin affine type ECaff = affine(EC) const C = P0.F.C # curve - static: doAssert: scalBits == C.getCurveOrderBitwidth() + static: doAssert: scalBits <= C.getCurveOrderBitwidth() # 1. Compute endomorphisms when P0.G == G1: diff --git a/constantine/math/elliptic/ec_multi_scalar_mul.nim b/constantine/math/elliptic/ec_multi_scalar_mul.nim new file mode 100644 index 0000000..c6cfa95 --- /dev/null +++ b/constantine/math/elliptic/ec_multi_scalar_mul.nim @@ -0,0 +1,411 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import ./ec_multi_scalar_mul_scheduler, + ./ec_endomorphism_accel, + ../constants/zoo_endomorphisms +export bestBucketBitSize + +# No exceptions allowed in core cryptographic operations +{.push raises: [].} +{.push checks: off.} + +# ########################################################### # +# # +# Multi Scalar Multiplication # +# # +# ########################################################### # + +# Multi-scalar-multiplication is the primary bottleneck in all zero-knowledge proofs and polynomial commmitment schemes. +# In particular, those are at the heart of zk-rollups to bundle a large amount of blockchain transactions. +# They may have to add tens of millions of elliptic curve points to generate proofs, +# requiring powerful machines, GPUs or even FPGAs implementations. +# +# Multi-scalar multiplication does a linear combination of +# R = [a₀]P₀ + [a₁]P₁ + ... + [aₙ]Pₙ +# +# The current iteration is a reference baseline before evaluating and adding various optimizations +# (scalar recoding, change of coordinate systems, bucket sizing, sorting ...) +# +# See the litterature references at the top of `ec_multi_scalar_mul_scheduler.nim` + +func multiScalarMulImpl_reference_vartime[F, G; bits: static int]( + r: var ECP_ShortW[F, G], + coefs: ptr UncheckedArray[BigInt[bits]], points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + N: int, c: static int) {.tags:[VarTime, HeapAlloc].} = + ## Inner implementation of MSM, for static dispatch over c, the bucket bit length + ## This is a straightforward simple translation of BDLO12, section 4 + + # Prologue + # -------- + const numBuckets = 1 shl c - 1 # bucket 0 is unused + const numWindows = (bits + c - 1) div c + type EC = typeof(r) + + let miniMSMs = allocHeapArray(EC, numWindows) + let buckets = allocHeapArray(EC, numBuckets) + + # Algorithm + # --------- + for w in 0 ..< numWindows: + # Place our points in a bucket corresponding to + # how many times their bit pattern in the current window of size c + for i in 0 ..< numBuckets: + buckets[i].setInf() + + # 1. Bucket accumulation. Cost: n - (2ᶜ-1) => n points in 2ᶜ-1 buckets, first point per bucket is just copied + for j in 0 ..< N: + let b = cast[int](coefs[j].getWindowAt(w*c, c)) + if b == 0: # bucket 0 is unused, no need to add [0]Pⱼ + continue + else: + buckets[b-1] += points[j] + + # 2. Bucket reduction. Cost: 2x(2ᶜ-2) => 2 additions per 2ᶜ-1 bucket, last bucket is just copied + # We have ordered subset sums in each bucket, we now need to compute the mini-MSM + # [1]S₁ + [2]S₂ + [3]S₃ + ... + [2ᶜ-1]S₂c₋₁ + var accumBuckets{.noInit.}, miniMSM{.noInit.}: EC + accumBuckets = buckets[numBuckets-1] + miniMSM = buckets[numBuckets-1] + + # Example with c = 3, 2³ = 8 + for k in countdown(numBuckets-2, 0): + accumBuckets += buckets[k] # Stores S₈ then S₈+S₇ then S₈+S₇+S₆ then ... + miniMSM += accumBuckets # Stores S₈ then [2]S₈+S₇ then [3]S₈+[2]S₇+S₆ then ... + + miniMSMs[w] = miniMSM + + # 3. Final reduction. Cost: (b/c - 1)x(c+1) => b/c windows, first is copied, c doublings + 1 addition per window + r = miniMSMs[numWindows-1] + for w in countdown(numWindows-2, 0): + for _ in 0 ..< c: + r.double() + r += miniMSMs[w] + + # Cleanup + # ------- + buckets.freeHeap() + miniMSMs.freeHeap() + +func multiScalarMul_reference_vartime*[EC](r: var EC, coefs: openArray[BigInt], points: openArray[ECP_ShortW_Aff]) {.tags:[VarTime, HeapAlloc].} = + ## Multiscalar multiplication: + ## r <- [a₀]P₀ + [a₁]P₁ + ... + [aₙ]Pₙ + debug: doAssert coefs.len == points.len + + let N = points.len + let coefs = coefs.asUnchecked() + let points = points.asUnchecked() + let c = bestBucketBitSize(N, BigInt.bits, useSignedBuckets = false, useManualTuning = false) + + case c + of 2: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 2) + of 3: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 3) + of 4: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 4) + of 5: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 5) + of 6: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 6) + of 7: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 7) + of 8: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 8) + of 9: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 9) + of 10: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 10) + of 11: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 11) + of 12: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 12) + of 13: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 13) + of 14: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 14) + of 15: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 15) + of 16: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 16) + of 17: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 17) + of 18: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 18) + of 19: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 19) + of 20: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 20) + of 21: multiScalarMulImpl_reference_vartime(r, coefs, points, N, c = 21) + else: + unreachable() + +# ########################################################### # +# # +# Multi Scalar Multiplication # +# Optimized versions # +# # +# ########################################################### # +# +# Multi-Scalar-Mul is the largest bottleneck in Zero-Knowledge-Proofs protocols +# There are ways to avoid FFTs, none to avoid Multi-Scalar-Multiplication +# Hence optimizing it is worth millions, see https://zprize.io + +func accumulate[F, G](buckets: ptr UncheckedArray[ECP_ShortW_JacExt[F, G]], val: SecretWord, negate: SecretBool, point: ECP_ShortW_Aff[F, G]) {.inline, meter.} = + let val = BaseType(val) + if val == 0: # Skip [0]P + return + elif negate.bool: + buckets[val-1] -= point + else: + buckets[val-1] += point + +func bucketReduce[EC](r: var EC, buckets: ptr UncheckedArray[EC], numBuckets: static int) {.meter.} = + # We interleave reduction with zero-ing the bucket to use instruction-level parallelism + + var accumBuckets{.noInit.}: typeof(r) + accumBuckets = buckets[numBuckets-1] + r = buckets[numBuckets-1] + buckets[numBuckets-1].setInf() + + for k in countdown(numBuckets-2, 0): + accumBuckets += buckets[k] + r += accumBuckets + buckets[k].setInf() + +type MiniMsmKind = enum + kTopWindow + kFullWindow + kBottomWindow + +func miniMSM_jacext[F, G; bits: static int]( + r: var ECP_ShortW[F, G], + buckets: ptr UncheckedArray[ECP_ShortW_JacExt[F, G]], + bitIndex: int, miniMsmKind: static MiniMsmKind, c: static int, + coefs: ptr UncheckedArray[BigInt[bits]], points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], N: int) {.meter.} = + ## Apply a mini-Multi-Scalar-Multiplication on [bitIndex, bitIndex+window) + ## slice of all (coef, point) pairs + + const excess = bits mod c + const top = bits - excess + + # 1. Bucket Accumulation + var curVal, nextVal: SecretWord + var curNeg, nextNeg: SecretBool + + template getSignedWindow(j : int): tuple[val: SecretWord, neg: SecretBool] = + when miniMsmKind == kBottomWindow: coefs[j].getSignedBottomWindow(c) + elif miniMsmKind == kTopWindow: coefs[j].getSignedTopWindow(top, excess) + else: coefs[j].getSignedFullWindowAt(bitIndex, c) + + (curVal, curNeg) = getSignedWindow(0) + for j in 0 ..< N-1: + (nextVal, nextNeg) = getSignedWindow(j+1) + if nextVal.BaseType != 0: + # In cryptography, points are indistinguishable from random + # hence, without prefetching, accessing the next bucket is a guaranteed cache miss + prefetchLarge(buckets[nextVal.BaseType-1].addr, Write, HighTemporalLocality, maxCacheLines = 2) + buckets.accumulate(curVal, curNeg, points[j]) + curVal = nextVal + curNeg = nextNeg + buckets.accumulate(curVal, curNeg, points[N-1]) + + # 2. Bucket Reduction + var sliceSum{.noinit.}: ECP_ShortW_JacExt[F, G] + sliceSum.bucketReduce(buckets, numBuckets = 1 shl (c-1)) + + # 3. Mini-MSM on the slice [bitIndex, bitIndex+window) + var windowSum{.noInit.}: typeof(r) + windowSum.fromJacobianExtended_vartime(sliceSum) + r += windowSum + + when miniMsmKind != kBottomWindow: + for _ in 0 ..< c: + r.double() + +func multiScalarMulJacExt_vartime[F, G; bits: static int]( + r: var ECP_ShortW[F, G], + coefs: ptr UncheckedArray[BigInt[bits]], points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + N: int, c: static int) {.tags:[VarTime, HeapAlloc], meter.} = + ## Multiscalar multiplication: + ## r <- [a₀]P₀ + [a₁]P₁ + ... + [aₙ]Pₙ + + # Setup + # ----- + const numBuckets = 1 shl (c-1) + type EcBucket = ECP_ShortW_JacExt[F, G] + + let buckets = allocHeapArray(EcBucket, numBuckets) + zeroMem(buckets[0].addr, sizeof(EcBucket) * numBuckets) + + # Algorithm + # --------- + const excess = bits mod c + const top = bits - excess + var w = top + r.setInf() + + if excess != 0 and w != 0: # Prologue + r.miniMSM_jacext(buckets, w, kTopWindow, c, coefs, points, N) + w -= c + + while w != 0: # Steady state + r.miniMSM_jacext(buckets, w, kFullWindow, c, coefs, points, N) + w -= c + + block: # Epilogue + r.miniMSM_jacext(buckets, w, kBottomWindow, c, coefs, points, N) + + # Cleanup + # ------- + buckets.freeHeap() + +func miniMSM_affine[NumBuckets, QueueLen, F, G; bits: static int]( + r: var ECP_ShortW[F, G], + sched: var Scheduler[NumBuckets, QueueLen, F, G], + bitIndex: int, miniMsmKind: static MiniMsmKind, c: static int, + coefs: ptr UncheckedArray[BigInt[bits]], N: int) {.meter.} = + ## Apply a mini-Multi-Scalar-Multiplication on [bitIndex, bitIndex+window) + ## slice of all (coef, point) pairs + + const excess = bits mod c + const top = bits - excess + static: doAssert miniMsmKind != kTopWindow, "The top window is smaller in bits which increases collisions in scheduler." + + sched.buckets[].init() + + # 1. Bucket Accumulation + var curSP, nextSP: ScheduledPoint + + template getSignedWindow(j : int): tuple[val: SecretWord, neg: SecretBool] = + when miniMsmKind == kBottomWindow: coefs[j].getSignedBottomWindow(c) + elif miniMsmKind == kTopWindow: coefs[j].getSignedTopWindow(top, excess) + else: coefs[j].getSignedFullWindowAt(bitIndex, c) + + curSP = scheduledPointDescriptor(0, getSignedWindow(0)) + for j in 0 ..< N-1: + nextSP = scheduledPointDescriptor(j+1, getSignedWindow(j+1)) + sched.prefetch(nextSP) + sched.schedule(curSP) + curSP = nextSP + sched.schedule(curSP) + sched.flushPendingAndReset() + + # 2. Bucket Reduction + var sliceSum{.noInit.}: ECP_ShortW_JacExt[F, G] + sliceSum.bucketReduce(sched.buckets[]) + + # 3. Mini-MSM on the slice [bitIndex, bitIndex+window) + var windowSum{.noInit.}: typeof(r) + windowSum.fromJacobianExtended_vartime(sliceSum) + r += windowSum + + when miniMsmKind != kBottomWindow: + for _ in 0 ..< c: + r.double() + +func multiScalarMulAffine_vartime[F, G; bits: static int]( + r: var ECP_ShortW[F, G], + coefs: ptr UncheckedArray[BigInt[bits]], points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + N: int, c: static int) {.tags:[VarTime, Alloca, HeapAlloc], meter.} = + ## Multiscalar multiplication: + ## r <- [a₀]P₀ + [a₁]P₁ + ... + [aₙ]Pₙ + + # Setup + # ----- + const (numBuckets, queueLen) = c.deriveSchedulerConstants() + let buckets = allocHeap(Buckets[numBuckets, F, G]) + buckets[].init() + let sched = allocHeap(Scheduler[numBuckets, queueLen, F, G]) + sched[].init(points, buckets, 0, numBuckets.int32) + + # Algorithm + # --------- + const excess = bits mod c + const top = bits - excess + var w = top + r.setInf() + + if excess != 0 and w != 0: # Prologue + # The top might use only a few bits, the affine scheduler would likely have significant collisions + zeroMem(sched.buckets.ptJacExt.addr, buckets.ptJacExt.sizeof()) + r.miniMSM_jacext(sched.buckets.ptJacExt.asUnchecked(), w, kTopWindow, c, coefs, points, N) + w -= c + + while w != 0: # Steady state + r.miniMSM_affine(sched[], w, kFullWindow, c, coefs, N) + w -= c + + block: # Epilogue + r.miniMSM_affine(sched[], w, kBottomWindow, c, coefs, N) + + # Cleanup + # ------- + sched.freeHeap() + buckets.freeHeap() + +func multiScalarMul_dispatch_vartime[bits: static int, F, G]( + r: var ECP_ShortW[F, G], coefs: ptr UncheckedArray[BigInt[bits]], + points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], N: int) = + ## Multiscalar multiplication: + ## r <- [a₀]P₀ + [a₁]P₁ + ... + [aₙ]Pₙ + let c = bestBucketBitSize(N, bits, useSignedBuckets = true, useManualTuning = true) + + case c + of 2: multiScalarMulJacExt_vartime(r, coefs, points, N, c = 2) + of 3: multiScalarMulJacExt_vartime(r, coefs, points, N, c = 3) + of 4: multiScalarMulJacExt_vartime(r, coefs, points, N, c = 4) + of 5: multiScalarMulJacExt_vartime(r, coefs, points, N, c = 5) + of 6: multiScalarMulJacExt_vartime(r, coefs, points, N, c = 6) + of 7: multiScalarMulJacExt_vartime(r, coefs, points, N, c = 7) + of 8: multiScalarMulJacExt_vartime(r, coefs, points, N, c = 8) + of 9: multiScalarMulAffine_vartime(r, coefs, points, N, c = 9) + of 10: multiScalarMulAffine_vartime(r, coefs, points, N, c = 10) + of 11: multiScalarMulAffine_vartime(r, coefs, points, N, c = 11) + of 12: multiScalarMulAffine_vartime(r, coefs, points, N, c = 12) + of 13: multiScalarMulAffine_vartime(r, coefs, points, N, c = 13) + of 14: multiScalarMulAffine_vartime(r, coefs, points, N, c = 14) + of 15: multiScalarMulAffine_vartime(r, coefs, points, N, c = 15) + of 16: multiScalarMulAffine_vartime(r, coefs, points, N, c = 16) + of 17: multiScalarMulAffine_vartime(r, coefs, points, N, c = 17) + of 18: multiScalarMulAffine_vartime(r, coefs, points, N, c = 18) + else: + unreachable() + +func multiScalarMul_vartime*[bits: static int, F, G]( + r: var ECP_ShortW[F, G], + coefs: openArray[BigInt[bits]], + points: openArray[ECP_ShortW_Aff[F, G]]) {.tags:[VarTime, Alloca, HeapAlloc], meter.} = + ## Multiscalar multiplication: + ## r <- [a₀]P₀ + [a₁]P₁ + ... + [aₙ]Pₙ + + debug: doAssert coefs.len == points.len + let N = points.len + + when bits <= F.C.getCurveOrderBitwidth() and + F.C.hasEndomorphismAcceleration(): + # TODO, min amount of bits for endomorphisms? + + const M = when F is Fp: 2 + elif F is Fp2: 4 + else: {.error: "Unconfigured".} + + const L = (bits + M - 1) div M + 1 + let splitCoefs = allocHeapArray(array[M, BigInt[L]], N) + let endoBasis = allocHeapArray(array[M, ECP_ShortW_Aff[F, G]], N) + + for i in 0 ..< N: + var negatePoints {.noinit.}: array[M, SecretBool] + splitCoefs[i].decomposeEndo(negatePoints, coefs[i], F) + if negatePoints[0].bool: + endoBasis[i][0].neg(points[i]) + else: + endoBasis[i][0] = points[i] + + when F is Fp: + endoBasis[i][1].x.prod(points[i].x, F.C.getCubicRootOfUnity_mod_p()) + if negatePoints[1].bool: + endoBasis[i][1].y.neg(points[i].y) + else: + endoBasis[i][1].y = points[i].y + else: + staticFor m, 1, M: + endoBasis[i][m].frobenius_psi(points[i], m) + if negatePoints[m].bool: + endoBasis[i][m].neg() + + let endoCoefs = cast[ptr UncheckedArray[BigInt[L]]](splitCoefs) + let endoPoints = cast[ptr UncheckedArray[ECP_ShortW_Aff[F, G]]](endoBasis) + multiScalarMul_dispatch_vartime(r, endoCoefs, endoPoints, M*N) + + endoBasis.freeHeap() + splitCoefs.freeHeap() + + else: + multiScalarMul_dispatch_vartime(r, coefs.asUnchecked(), points.asUnchecked(), N) \ No newline at end of file diff --git a/constantine/math/elliptic/ec_multi_scalar_mul_scheduler.nim b/constantine/math/elliptic/ec_multi_scalar_mul_scheduler.nim new file mode 100644 index 0000000..4f1e5ed --- /dev/null +++ b/constantine/math/elliptic/ec_multi_scalar_mul_scheduler.nim @@ -0,0 +1,611 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + ../../platforms/abstractions, + ../arithmetic, + ../ec_shortweierstrass, + ./ec_shortweierstrass_jacobian_extended, + ./ec_shortweierstrass_batch_ops + +export abstractions, arithmetic, + ec_shortweierstrass, ec_shortweierstrass_jacobian_extended + +# No exceptions allowed in core cryptographic operations +{.push raises: [].} +{.push checks: off.} + +# ########################################################### # +# # +# Multi Scalar Multiplication - Scheduling # +# # +# ########################################################### # + +# This file implements a bucketing acceleration structure. +# +# See the following for the baseline algorithm: +# - Faster batch forgery identification +# Daniel J. Bernstein, Jeroen Doumen, Tanja Lange, and Jan-Jaap Oosterwijk, 2012 +# https://eprint.iacr.org/2012/549.pdf +# - Simple guide to fast linear combinations (aka multiexponentiations) +# Vitalik Buterin, 2020 +# https://ethresear.ch/t/simple-guide-to-fast-linear-combinations-aka-multiexponentiations/7238 +# https://github.com/ethereum/research/blob/5c6fec6/fast_linear_combinations/multicombs.py +# - zkStudyClub: Multi-scalar multiplication: state of the art & new ideas +# Gus Gutoski, 2020 +# https://www.youtube.com/watch?v=Bl5mQA7UL2I +# +# And for the scheduling technique and collision probability analysis +# - FPGA Acceleration of Multi-Scalar Multiplication: CycloneMSM +# Kaveh Aasaraai, Don Beaver, Emanuele Cesena, Rahul Maganti, Nicolas Stalder and Javier Varela, 2022 +# https://eprint.iacr.org/2022/1396.pdf +# +# Challenges: +# - For the popular BLS12-377 and BLS12-381, an affine elliptic point takes 96 bytes +# an extended jacobian point takes 192 bytes. +# - We want to deal with a large number of points, for example the Zprize competition used 2²⁶ ~= 67M points +# in particular, memory usage is a concern as those input already require ~6.7GB for a BLS12 prime, +# so we can't use much scratchspace, especially on GPUs. +# - Any bit-twiddling algorithm must scale at most linearly with the number of points +# Algorithm that for example finds the most common pair of points for an optimized addition chain +# are O(n²) and will need to select from a subsample. +# - The scalars are random, so the bucket accessed is random, which needs sorting or prefetching +# to avoid bottlenecking on memory bandwidth. But sorting requires copies ... +# - While copies improve locality, our types are huge, 96~192 bytes +# and we have millions of them. +# - We want our algorithm to be scalable to a large number of threads at minimum, or even better on GPUs. +# Hence it should naturally offer data parallelism, which is tricky due to collisions when accumulating +# 1M points into 32~64K buckets. +# - The asymptotically fastest addition formulae are affine addition with individual cost 3M + 1I +# and asymptotic cost for N points N*3M + N*3M+1I using batch inversion. +# Vartime inversion cost 70-100M depending on the number of bits in the prime +# (multiplication cost scale quadratically while inversion via Euclid linearly) +# - The second fastest general coordinate system is Extended Jacobian with cost 10M, +# so the threshold for N is: +# N*3M+N*3M+100M < N*10M <=> 100M < N * 4M <=> 25 < N +# Hence we want to maximize the chance of doing 25 additions (so we need 50 points). +# Given than there is low probability for consecutive random points to be assigned to the same bucket, +# we can't keep a queue per bucket for batch accumulation. +# However we can do a vector addition as there is a high probability that consecutive random points +# are assigned to different buckets. +# +# Strategy: +# - Each bucket is associated with (EC Affine, EC ExtJac, set[Empty, AffineSet, ExtJacSet]), in SoA storage +# - Each thread is assigned a range of buckets and keeps a scheduler +# start, stop: int32 +# curQueue, curRescheduled: int32 +# bucketMap: BigInt[NumNZBuckets] +# queue: array[MaxCapacity, (Target Bucket, PointID)] +# rescheduled: array[32, (Target Bucket, PointID)] +# - when the queue reaches max capacity, we compute a vector affine addition with the target buckets +# we interleave with prefetching to reduce cache misses. +# - when the rescheduled array reaches max capacity, we check if there are at least 32 items in the queue +# and if so schedule an vector addition otherwise we flush the queue into the EC ExtJac. +# i.e. in the worst case, when all points are the same, we fallback to the JacExt MSM. +# - As a stretch optimization, if many points in rescheduled queue target the same bucket +# we can use sum_reduce_vartime, but are there workloads like that? +# +# Queue size is given by formula `4*c² - 16*c - 128` to handle various concerns: amortization of batch affine, memory usage, collision probability +# `c` is chosen to minimize the number of EC operations but does not take into account memory bandwidth and cache misses cost. +# +# Collision probability for `QueueSize` consecutive *uniformly random* points +# is derived from a Poisson distribution. +# NumCollisions = N*QueueSize/NumNZBuckets is the number of collisions +# NumCollisions / N is the probability of collision + +# -------inputs------- c ----buckets---- queue length collision map bytes num collisions collision % +# 2^0 1 2 2^1 2 -144 8 -72 -7200.0% +# 2^1 2 2 2^1 2 -144 8 -144 -7200.0% +# 2^2 4 3 2^2 4 -140 8 -140 -3500.0% +# 2^3 8 3 2^2 4 -140 8 -280 -3500.0% +# 2^4 16 4 2^3 8 -128 8 -256 -1600.0% +# 2^5 32 5 2^4 16 -108 8 -216 -675.0% +# 2^6 64 5 2^4 16 -108 8 -432 -675.0% +# 2^7 128 6 2^5 32 -80 8 -320 -250.0% +# 2^8 256 7 2^6 64 -44 8 -176 -68.8% +# 2^9 512 8 2^7 128 0 16 0 0.0% +# 2^10 1024 9 2^8 256 52 32 208 20.3% <- At half the queue length, we can still amortize batch inversion +# 2^11 2048 9 2^8 256 52 32 416 20.3% +# 2^12 4096 10 2^9 512 112 64 896 21.9% +# 2^13 8192 11 2^10 1024 180 128 1440 17.6% +# 2^14 16384 12 2^11 2048 256 256 2048 12.5% +# 2^15 32768 13 2^12 4096 340 512 2720 8.3% +# 2^16 65536 14 2^13 8192 432 1024 3456 5.3% +# 2^17 131072 15 2^14 16384 532 2048 4256 3.2% <- 100/32 = 3.125, a collision queue of size 32 is highly unlikely to reach full capacity +# 2^18 262144 16 2^15 32768 640 4096 5120 2.0% <- ~10MB of buckets +# 2^19 524288 17 2^16 65536 756 8192 6048 1.2% <- for BLS12-381, the queue size reaches 64K aliasing conflict threshold +# 2^20 1048576 17 2^16 65536 756 8192 12096 1.2% +# 2^21 2097152 18 2^17 131072 880 16384 14080 0.7% +# 2^22 4194304 19 2^18 262144 1012 32768 16192 0.4% +# 2^23 8388608 20 2^19 524288 1152 65536 18432 0.2% +# 2^24 16777216 21 2^20 1048576 1300 131072 20800 0.1% +# 2^25 33554432 22 2^21 2097152 1456 262144 23296 0.1% +# 2^26 67108864 23 2^22 4194304 1620 524288 25920 0.0% +# 2^27 134217728 24 2^23 8388608 1792 1048576 28672 0.0% +# 2^28 268435456 25 2^24 16777216 1972 2097152 31552 0.0% +# 2^29 536870912 26 2^25 33554432 2160 4194304 34560 0.0% +# 2^30 1073741824 27 2^26 67108864 2356 8388608 37696 0.0% +# 2^31 2147483648 28 2^27 134217728 2560 16777216 40960 0.0% +# 2^32 4294967296 29 2^28 268435456 2772 33554432 44352 0.0% +# 2^33 8589934592 30 2^29 536870912 2992 67108864 47872 0.0% +# 2^34 17179869184 31 2^30 1073741824 3220 134217728 51520 0.0% +# 2^35 34359738368 32 2^31 2147483648 3456 268435456 55296 0.0% +# +# The code to reproduce this table is at the bottom + +# Sizes for BLS12-381 with c = 16 +# +# Buckets: 32768 +# - Status: 1 32768 +# - Affine: 96 3145728 +# - ExtJac: 192 6291456 +# ---------------------------------- +# Total 289 9 469 952 ~= 10MB +# +# Scheduler: 1 per thread +# - start, stop: 8 +# - queue cursors: 8 +# - bucketMap: 4096 +# - rescheduled: 256 +# ----------------------------------- +# Total 4368 ~= 4KB per thread + +# ########################################################### # +# # +# General utilities # +# # +# ########################################################### # + +func bestBucketBitSize*(inputSize: int, scalarBitwidth: static int, useSignedBuckets, useManualTuning: static bool): int {.inline.} = + ## Evaluate the best bucket bit-size for the input size. + ## That bucket size minimize group operations. + ## This ignore cache effect. Computation can become memory-bound, especially with large buckets + ## that don't fit in L1 cache, trigger the 64K aliasing conflict or worse (overflowing L2 cache or TLB). + ## Especially, scalars are expected to be indistinguishable from random so buckets accessed during accumulation + ## will be in a random pattern, triggering cache misses. + + # Raw operation cost is approximately + # 1. Bucket accumulation + # n - (2ᶜ-1) additions for b/c windows or n - (2ᶜ⁻¹-1) if using signed buckets + # 2. Bucket reduction + # 2x(2ᶜ-2) additions for b/c windows or 2x(2ᶜ⁻¹-2) + # 3. Final reduction + # (b/c - 1) x (c doublings + 1 addition) + # Total + # b/c (n + 2ᶜ - 2) A + (b/c - 1) x (c*D + A) + # https://www.youtube.com/watch?v=Bl5mQA7UL2I + + # A doubling costs 50% of an addition with jacobian coordinates + # and between 60% (BLS12-381 G1) to 66% (BN254-Snarks G1) + + const A = 10'f32 # Addition cost + const D = 6'f32 # Doubling cost + + const s = int useSignedBuckets + let n = inputSize + let b = float32(scalarBitwidth) + var minCost = float32(Inf) + for c in 2 .. 21: + let b_over_c = b/c.float32 + + let bucket_accumulate_reduce = b_over_c * float32(n + (1 shl (c-s)) - 2) * A + let final_reduction = (b_over_c - 1'f32) * (c.float32*D + A) + let cost = bucket_accumulate_reduce + final_reduction + if cost < minCost: + minCost = cost + result = c + + # Manual tuning, memory bandwidth / cache boundaries of + # L1, L2 caches, TLB and 64 aliasing conflict + # are not taken into account in previous formula. + # Each increase in c doubles memory used. + when useManualTuning: + if 14 <= result: + result -= 1 + if 15 <= result: + result -= 1 + if 16 <= result: + result -= 1 + +# Extended Jacobian generic bindings +# ---------------------------------- +# All vartime procedures MUST be tagged vartime +# Hence we do not expose `sum` or `+=` for extended jacobian operation to prevent `vartime` mistakes +# we create a local `sum` or `+=` for this module only +func `+=`*[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_JacExt[F, G]) {.inline.}= + P.sum_vartime(P, Q) +func `+=`*[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_Aff[F, G]) {.inline.}= + P.madd_vartime(P, Q) +func `-=`*[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_Aff[F, G]) {.inline.}= + P.msub_vartime(P, Q) + +# ########################################################### # +# # +# Scheduler # +# # +# ########################################################### # +# +# "磨刀不误砍柴功" +# "Sharpening the axe will not delay cutting the wood" - Chinese proverb + +type + BucketStatus = enum + kAffine, kJacExt + + Buckets*[N: static int, F; G: static Subgroup] = object + status: array[N, set[BucketStatus]] + ptAff: array[N, ECP_ShortW_Aff[F, G]] + ptJacExt*: array[N, ECP_ShortW_JacExt[F, G]] # Public for the top window + + ScheduledPoint* = object + bucket {.bitsize:26.}: int64 # Supports up to 2²⁵ = 33 554 432 buckets and -1 for the skipped bucket 0 + sign {.bitsize: 1.}: int64 + pointID {.bitsize:37.}: int64 # Supports up to 2³⁷ = 137 438 953 472 points + + Scheduler*[NumNZBuckets, QueueLen: static int, F; G: static Subgroup] = object + points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]] + buckets*: ptr Buckets[NumNZBuckets, F, G] + start, stopEx: int32 # Bucket range + numScheduled, numCollisions: int32 + collisionsMap: BigInt[NumNZBuckets] # We use a BigInt as a bitmap, when all you have is an axe ... + queue: array[QueueLen, ScheduledPoint] + collisions: array[32, ScheduledPoint] + +const MinVectorAddThreshold = 32 + +func init*(buckets: var Buckets) {.inline.} = + zeroMem(buckets.status.addr, buckets.status.sizeof()) + +func reset(buckets: var Buckets, index: int) {.inline.} = + buckets.status[index] = {} + +func deriveSchedulerConstants*(c: int): tuple[numNZBuckets, queueLen: int] {.compileTime.} = + # Returns the number of non-zero buckets and the scheduler queue length + result.numNZBuckets = 1 shl (c-1) + result.queueLen = max(MinVectorAddThreshold, 4*c*c - 16*c - 128) + +func init*[NumNZBuckets, QueueLen: static int, F; G: static Subgroup]( + sched: var Scheduler[NumNZBuckets, QueueLen, F, G], points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + buckets: ptr Buckets[NumNZBuckets, F, G], start, stopEx: int32) {.inline.} = + ## init a scheduler overseeing buckets [start, stopEx) + ## within the indices [0, NumNZBuckets). Bucket for value 0 is considered at index -1. + sched.points = points + sched.buckets = buckets + sched.start = start + sched.stopEx = stopEx + sched.numScheduled = 0 + sched.numCollisions = 0 + +func scheduledPointDescriptor*(pointIndex: int, pointDesc: tuple[val: SecretWord, neg: SecretBool]): ScheduledPoint {.inline.} = + ScheduledPoint( + bucket: cast[int64](pointDesc.val)-1, # shift bucket by 1 as bucket 0 is skipped + sign: cast[int64](pointDesc.neg), + pointID: cast[int64](pointIndex)) + +func enqueuePoint(sched: var Scheduler, sp: ScheduledPoint) {.inline.} = + sched.queue[sched.numScheduled] = sp + sched.collisionsMap.setBit(sp.bucket.int) + sched.numScheduled += 1 + +func handleCollision(sched: var Scheduler, sp: ScheduledPoint) +func rescheduleCollisions(sched: var Scheduler) +func sparseVectorAddition[F, G]( + buckets: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + bucketStatuses: ptr UncheckedArray[set[BucketStatus]], + points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + scheduledPoints: ptr UncheckedArray[ScheduledPoint], + numScheduled: int32) {.noInline, tags:[VarTime, Alloca].} + +func prefetch*(sched: Scheduler, sp: ScheduledPoint) = + let bucket = sp.bucket + if bucket == -1: + return + + prefetch(sched.buckets.status[bucket].addr, Write, HighTemporalLocality) + prefetchLarge(sched.buckets.ptAff[bucket].addr, Write, HighTemporalLocality, maxCacheLines = 1) + prefetchLarge(sched.buckets.ptJacExt[bucket].addr, Write, HighTemporalLocality, maxCacheLines = 1) + +func schedule*(sched: var Scheduler, sp: ScheduledPoint) = + ## Schedule a point for accumulating in buckets + + let bucket = int sp.bucket + if not(sched.start <= bucket and bucket < sched.stopEx): + return + + if kAffine notin sched.buckets.status[bucket]: # Random access, prefetch to avoid cache-misses + if sp.sign == 0: + sched.buckets.ptAff[bucket] = sched.points[sp.pointID] + else: + sched.buckets.ptAff[bucket].neg(sched.points[sp.pointID]) + sched.buckets.status[bucket].incl(kAffine) + return + + if sched.collisionsMap.bit(bucket).bool: + sched.handleCollision(sp) + return + + sched.enqueuePoint(sp) + + if sched.numScheduled == sched.queue.len: + sparseVectorAddition( + sched.buckets.ptAff.asUnchecked(), sched.buckets.status.asUnchecked(), + sched.points, sched.queue.asUnchecked(), sched.numScheduled) + sched.numScheduled = 0 + sched.collisionsMap.setZero() + sched.rescheduleCollisions() + +func handleCollision(sched: var Scheduler, sp: ScheduledPoint) = + if sched.numCollisions < sched.collisions.len: + sched.collisions[sched.numCollisions] = sp + sched.numCollisions += 1 + return + + # If we want to optimize for a workload were many multipliers are the same, it's here + if kJacExt notin sched.buckets.status[sp.bucket]: + sched.buckets.ptJacExt[sp.bucket].fromAffine(sched.points[sp.pointID]) + if sp.sign != 0: + sched.buckets.ptJacExt[sp.bucket].neg() + sched.buckets.status[sp.bucket].incl(kJacExt) + return + + if sp.sign == 0: + sched.buckets.ptJacExt[sp.bucket] += sched.points[sp.pointID] + else: + sched.buckets.ptJacExt[sp.bucket] -= sched.points[sp.pointID] + +func rescheduleCollisions(sched: var Scheduler) = + template last: untyped = sched.numCollisions-1 + var i = last() + while i >= 0: + let sp = sched.collisions[i] + if not sched.collisionsMap.bit(sp.bucket.int).bool: + sched.enqueuePoint(sp) + if i != last(): + sched.collisions[i] = sched.collisions[last()] + sched.numCollisions -= 1 + i -= 1 + +func flushBuffer(sched: var Scheduler, buf: ptr UncheckedArray[ScheduledPoint], count: var int32) = + for i in 0 ..< count: + let sp = buf[i] + if kJacExt in sched.buckets.status[sp.bucket]: + if sp.sign == 0: + sched.buckets.ptJacExt[sp.bucket] += sched.points[sp.pointID] + else: + sched.buckets.ptJacExt[sp.bucket] -= sched.points[sp.pointID] + else: + sched.buckets.ptJacExt[sp.bucket].fromAffine(sched.points[sp.pointID]) + if sp.sign != 0: + sched.buckets.ptJacExt[sp.bucket].neg() + sched.buckets.status[sp.bucket].incl(kJacExt) + count = 0 + +func flushPendingAndReset*(sched: var Scheduler) = + if sched.numScheduled >= MinVectorAddThreshold: + sparseVectorAddition( + sched.buckets.ptAff.asUnchecked(), sched.buckets.status.asUnchecked(), + sched.points, sched.queue.asUnchecked(), sched.numScheduled) + sched.numScheduled = 0 + + if sched.numScheduled > 0: + sched.flushBuffer(sched.queue.asUnchecked(), sched.numScheduled) + + if sched.numCollisions > 0: + sched.flushBuffer(sched.collisions.asUnchecked(), sched.numCollisions) + + sched.collisionsMap.setZero() + +# ########################################################### # +# # +# Computation # +# # +# ########################################################### # + +func sparseVectorAddition[F, G]( + buckets: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + bucketStatuses: ptr UncheckedArray[set[BucketStatus]], + points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], + scheduledPoints: ptr UncheckedArray[ScheduledPoint], + numScheduled: int32 + ) {.noInline, tags:[VarTime, Alloca].} = + ## Does a sparse vector addition: buckets += scheduledPoints + ## This implementation is optimized using batch affine inversion + ## with an asymptotic cost for N points of N*6M + I + ## where M is field multiplication and I the field inversion. + ## + ## Inversion usually costs between 66M to 120M depending on implementation: + ## - scaling linearly with bits (Euclid, Lehmer, Stein, Bernstein-Yang, Pornin algorithm) + ## - scaling quadratically with bits if using Fermat's Little Theorem a⁻¹ ≡ ᵖ⁻² (mod p) with addition chains + ## - constant-time or variable time + ## + ## `scheduledPoints` must all target a different bucket. + template sps: untyped = scheduledPoints + + type SpecialCase = enum + kRegular, kInfLhs, kInfRhs, kOpposite + + let lambdas = allocStackArray(tuple[num, den: F], numScheduled) + let accumDen = allocStackArray(F, numScheduled) + let specialCases = allocStackArray(SpecialCase, numScheduled) + + # Step 1: Compute numerators and denominators of λᵢ = λᵢ_num / λᵢ_den + for i in 0 ..< numScheduled: + + template skipSpecialCase {.dirty.} = + if i == 0: accumDen[i].setOne() + else: accumDen[i] = accumDen[i-1] + continue + + if i != numScheduled - 1: + prefetchLarge(points[sps[i+1].pointID].addr, Read, HighTemporalLocality, maxCacheLines = 4) + prefetch(bucketStatuses[sps[i+1].bucket].addr, Read, HighTemporalLocality) + prefetchLarge(buckets[sps[i+1].bucket].addr, Read, HighTemporalLocality, maxCacheLines = 4) + + # Special cases 1: infinity points have affine coordinates (0, 0) by convention + # it doesn't match the y²=x³+ax+b equation so slope formula need special handling + if (kAffine notin bucketStatuses[sps[i].bucket]) or buckets[sps[i].bucket].isInf().bool: + specialCases[i] = kInfLhs + skipSpecialCase() + elif points[sps[i].pointID].isInf().bool: + specialCases[i] = kInfRhs + skipSpecialCase() + + # Special case 2: λ = (Qy-Py)/(Qx-Px) which is undefined when Px == Qx + # This happens when P == Q or P == -Q + if bool(buckets[sps[i].bucket].x == points[sps[i].pointID].x): + if sps[i].sign == 0: + if bool(buckets[sps[i].bucket].y == points[sps[i].pointID].y): + lambdaDouble(lambdas[i].num, lambdas[i].den, buckets[sps[i].bucket]) + else: + specialCases[i] = kOpposite + skipSpecialCase() + else: + if bool(buckets[sps[i].bucket].y == points[sps[i].pointID].y): + specialCases[i] = kOpposite + skipSpecialCase() + else: + lambdaDouble(lambdas[i].num, lambdas[i].den, buckets[sps[i].bucket]) + else: + if sps[i].sign == 0: + lambdaAdd(lambdas[i].num, lambdas[i].den, buckets[sps[i].bucket], points[sps[i].pointID]) + else: + lambdaSub(lambdas[i].num, lambdas[i].den, buckets[sps[i].bucket], points[sps[i].pointID]) + + # Step 2: Accumulate denominators. + specialCases[i] = kRegular + if i == 0: + accumDen[i] = lambdas[i].den + elif i == numScheduled-1: + accumDen[i].prod(accumDen[i-1], lambdas[i].den) + else: + accumDen[i].prod(accumDen[i-1], lambdas[i].den, skipFinalSub = true) + + # Step 3: Batch invert + var accInv {.noInit.}: F + accInv.inv_vartime(accumDen[numScheduled-1]) + + # Step 4: Output the sums + for i in countdown(numScheduled-1, 1): + prefetchLarge(points[sps[i-1].pointID].addr, Read, HighTemporalLocality, maxCacheLines = 4) + prefetchLarge(buckets[sps[i-1].bucket].addr, Write, HighTemporalLocality, maxCacheLines = 4) + + if specialCases[i] == kInfLhs: + if sps[i]. sign == 0: + buckets[sps[i].bucket] = points[sps[i].pointID] + else: + buckets[sps[i].bucket].neg(points[sps[i].pointID]) + bucketStatuses[sps[i].bucket].incl(kAffine) + continue + elif specialCases[i] == kInfRhs: + continue + elif specialCases[i] == kOpposite: + buckets[sps[i].bucket].setInf() + bucketStatuses[sps[i].bucket].excl(kAffine) + continue + + # Compute lambda - destroys accumDen[i] + accumDen[i].prod(accInv, accumDen[i-1], skipFinalSub = true) + accumDen[i].prod(accumDen[i], lambdas[i].num, skipFinalSub = true) + + # Compute EC addition + var r{.noInit.}: ECP_ShortW_Aff[F, G] + r.affineAdd(lambda = accumDen[i], buckets[sps[i].bucket], points[sps[i].pointID]) # points[sps[i].pointID].y unused even if sign is negative + + # Store result + buckets[sps[i].bucket] = r + + # Next iteration + accInv.prod(accInv, lambdas[i].den, skipFinalSub = true) + + block: # tail + if specialCases[0] == kInfLhs: + if sps[0].sign == 0: + buckets[sps[0].bucket] = points[sps[0].pointID] + else: + buckets[sps[0].bucket].neg(points[sps[0].pointID]) + bucketStatuses[sps[0].bucket].incl(kAffine) + elif specialCases[0] == kInfRhs: + discard + elif specialCases[0] == kOpposite: + buckets[sps[0].bucket].setInf() + bucketStatuses[sps[0].bucket].excl(kAffine) + else: + # Compute lambda + accumDen[0].prod(lambdas[0].num, accInv, skipFinalSub = true) + + # Compute EC addition + var r{.noInit.}: ECP_ShortW_Aff[F, G] + r.affineAdd(lambda = accumDen[0], buckets[sps[0].bucket], points[sps[0].pointID]) + + # Store result + buckets[sps[0].bucket] = r + +func bucketReduce*[N, F, G]( + r: var ECP_ShortW_JacExt[F, G], + buckets: var Buckets[N, F, G]) = + + var accumBuckets{.noinit.}: ECP_ShortW_JacExt[F, G] + + if kAffine in buckets.status[N-1]: + if kJacExt in buckets.status[N-1]: + accumBuckets.madd_vartime(buckets.ptJacExt[N-1], buckets.ptAff[N-1]) + else: + accumBuckets.fromAffine(buckets.ptAff[N-1]) + elif kJacExt in buckets.status[N-1]: + accumBuckets = buckets.ptJacExt[N-1] + else: + accumBuckets.setInf() + r = accumBuckets + buckets.reset(N-1) + + for k in countdown(N-2, 0): + if kAffine in buckets.status[k]: + if kJacExt in buckets.status[k]: + var t{.noInit.}: ECP_ShortW_JacExt[F, G] + t.madd_vartime(buckets.ptJacExt[k], buckets.ptAff[k]) + accumBuckets += t + else: + accumBuckets += buckets.ptAff[k] + elif kJacExt in buckets.status[k]: + accumBuckets += buckets.ptJacExt[k] + + buckets.reset(k) + r += accumBuckets + +# ########################################################### # +# # +# Statistics generation # +# # +# ########################################################### # + +when isMainModule: + import strformat + + proc echoSchedulingParameter(logInputSize: int, echoHeader = false) {.raises:[ValueError].} = + + const titles = ["-------inputs-------", "c", "----buckets----", "queue length", "collision map bytes", "num collisions", "collision %"] + const header = &"{titles[0]:>16} {titles[1]:>3} {titles[2]:>19} {titles[3]:>13} {titles[4]:>16} {titles[5]:>14} {titles[6]:>12}" + + if echoHeader: + echo header + return + + let inputSize = 1 shl logInputSize + let c = inputSize.bestBucketBitSize(255, useSignedBuckets = true, useManualTuning = false) + let twoPow = "2^" + let numNZBuckets = 1 shl (c-1) + let collisionMapSize = ((1 shl (c-1))+63) div 64 * 8 # Stored in BigInt[1 shl (c-1)] + let queueSize = 4*c*c - 16*c - 128 + let numCollisions = float(inputSize*queueSize) / float(numNZBuckets) + let collisionPercentage = numCollisions / float(inputSize) * 100 + + echo &"{twoPow & $logInputSize:>4} {inputSize:>14} {c:>3} {twoPow & $(c-1):>4} {numNZBuckets:>11} {queueSize:>13} {collisionMapSize:>19} {numCollisions:>14} {collisionPercentage:>11.1f}%" + + echoSchedulingParameter(0, echoHeader = true) + for n in 0 ..< 36: + echoSchedulingParameter(n) diff --git a/constantine/math/elliptic/ec_scalar_mul.nim b/constantine/math/elliptic/ec_scalar_mul.nim index dba6433..1fbff55 100644 --- a/constantine/math/elliptic/ec_scalar_mul.nim +++ b/constantine/math/elliptic/ec_scalar_mul.nim @@ -242,6 +242,7 @@ func scalarMul*[EC]( ## Those will be assumed to maintain constant-time property when BigInt.bits <= EC.F.C.getCurveOrderBitwidth() and EC.F.C.hasEndomorphismAcceleration(): + # TODO, min amount of bits for endomorphisms? when EC.F is Fp: P.scalarMulGLV_m2w2(scalar) elif EC.F is Fp2: diff --git a/constantine/math/elliptic/ec_scalar_mul_vartime.nim b/constantine/math/elliptic/ec_scalar_mul_vartime.nim new file mode 100644 index 0000000..e4c34c5 --- /dev/null +++ b/constantine/math/elliptic/ec_scalar_mul_vartime.nim @@ -0,0 +1,128 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../arithmetic, + ../ec_shortweierstrass, + ../io/io_bigints, + ../../platforms/abstractions + +{.push raises: [].} # No exceptions allowed in core cryptographic operations +{.push checks: off.} # No defects due to array bound checking or signed integer overflow allowed + +# Support files for testing Elliptic Curve arithmetic +# ------------------------------------------------------------------------------ + +iterator unpack(scalarByte: byte): bool = + yield bool((scalarByte and 0b10000000) shr 7) + yield bool((scalarByte and 0b01000000) shr 6) + yield bool((scalarByte and 0b00100000) shr 5) + yield bool((scalarByte and 0b00010000) shr 4) + yield bool((scalarByte and 0b00001000) shr 3) + yield bool((scalarByte and 0b00000100) shr 2) + yield bool((scalarByte and 0b00000010) shr 1) + yield bool( scalarByte and 0b00000001) + +func scalarMul_doubleAdd_vartime*[EC](P: var EC, scalar: BigInt) {.tags:[VarTime].} = + ## **Variable-time** Elliptic Curve Scalar Multiplication + ## + ## P <- [k] P + ## + ## This uses the double-and-add algorithm + ## This MUST NOT be used with secret data. + ## + ## This is highly VULNERABLE to timing attacks and power analysis attacks. + var scalarCanonical: array[(scalar.bits+7) div 8, byte] + scalarCanonical.marshal(scalar, bigEndian) + + var Paff {.noinit.}: affine(EC) + Paff.affine(P) + + P.setInf() + for scalarByte in scalarCanonical: + for bit in unpack(scalarByte): + P.double() + if bit: + P += Paff + +func scalarMul_minHammingWeight_vartime*[EC](P: var EC, scalar: BigInt) {.tags:[VarTime].} = + ## **Variable-time** Elliptic Curve Scalar Multiplication + ## + ## P <- [k] P + ## + ## This uses an online recoding with minimum Hamming Weight + ## (which is not NAF, NAF is least-significant bit to most) + ## This MUST NOT be used with secret data. + ## + ## This is highly VULNERABLE to timing attacks and power analysis attacks + var Paff {.noinit.}: affine(EC) + Paff.affine(P) + + P.setInf() + for bit in recoding_l2r_signed_vartime(scalar): + P.double() + if bit == 1: + P += Paff + elif bit == -1: + P -= Paff + +func scalarMul_minHammingWeight_windowed_vartime*[EC](P: var EC, scalar: BigInt, window: static int) {.tags:[VarTime, Alloca].} = + ## **Variable-time** Elliptic Curve Scalar Multiplication + ## + ## P <- [k] P + ## + ## This uses windowed-NAF (wNAF) + ## This MUST NOT be used with secret data. + ## + ## This is highly VULNERABLE to timing attacks and power analysis attacks + + # Signed digits divides precomputation table size by 2 + # Odd-only divides precomputation table size by another 2 + const precompSize = 1 shl (window - 2) + + when window <= 8: + type I = int8 + elif window <= 16: + type I = int16 + elif window <= 32: + type I = int32 + else: + type I = int64 + + var naf {.noInit.}: array[BigInt.bits+1, I] + let nafLen = naf.recode_r2l_signed_window_vartime(scalar, window) + + var P2{.noInit.}: EC + P2.double(P) + + var tabEC {.noinit.}: array[precompSize, EC] + tabEC[0] = P + for i in 1 ..< tabEC.len: + tabEC[i].sum(tabEC[i-1], P2) + + var tab {.noinit.}: array[precompSize, affine(EC)] + tab.batchAffine(tabEC) + + # init + if naf[nafLen-1] > 0: + P.fromAffine(tab[naf[nafLen-1] shr 1]) + elif naf[nafLen-1] < 0: + P.fromAffine(tab[-naf[nafLen-1] shr 1]) + P.neg() + else: + P.setInf() + + # steady state + for i in 1 ..< nafLen: + P.double() + let digit = naf[nafLen-1-i] + if digit > 0: + P += tab[digit shr 1] + elif digit < 0: + P -= tab[-digit shr 1] diff --git a/constantine/math/elliptic/ec_shortweierstrass_batch_ops.nim b/constantine/math/elliptic/ec_shortweierstrass_batch_ops.nim index 6e5bdcf..35841c9 100644 --- a/constantine/math/elliptic/ec_shortweierstrass_batch_ops.nim +++ b/constantine/math/elliptic/ec_shortweierstrass_batch_ops.nim @@ -7,12 +7,13 @@ # at your option. This file may not be copied, modified, or distributed except according to those terms. import - ../../platforms/[abstractions, allocs], + ../../platforms/abstractions, ../arithmetic, ../extension_fields, ./ec_shortweierstrass_affine, ./ec_shortweierstrass_jacobian, - ./ec_shortweierstrass_projective + ./ec_shortweierstrass_projective, + ./ec_shortweierstrass_jacobian_extended # No exceptions allowed, or array bound checks or integer overflow {.push raises: [], checks:off.} @@ -27,7 +28,7 @@ import func batchAffine*[F, G]( affs: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], projs: ptr UncheckedArray[ECP_ShortW_Prj[F, G]], - N: int) = + N: int) {.noInline, tags:[Alloca].} = # Algorithm: Montgomery's batch inversion # - Speeding the Pollard and Elliptic Curve Methods of Factorization # Section 10.3.1 @@ -87,7 +88,7 @@ func batchAffine*[N: static int, F, G]( func batchAffine*[F, G]( affs: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], jacs: ptr UncheckedArray[ECP_ShortW_Jac[F, G]], - N: int) = + N: int) {.noInline, tags:[Alloca].} = # Algorithm: Montgomery's batch inversion # - Speeding the Pollard and Elliptic Curve Methods of Factorization # Section 10.3.1 @@ -153,7 +154,7 @@ func batchAffine*[N: static int, F, G]( # ############################################################ # # Elliptic Curve in Short Weierstrass form -# Batch addition +# Sum Reduction # # ############################################################ @@ -192,7 +193,7 @@ func batchAffine*[N: static int, F, G]( # However, n inversions can use Montgomery's batch inversion # at the cost of 3(n-1)M + 1I # -# Hence batch addition can have an asymptotic cost of +# Hence sum reduction can have an asymptotic cost of # 5M + 1S # Compared to # Jacobian addition: 12M + 4S @@ -200,12 +201,18 @@ func batchAffine*[N: static int, F, G]( # Projective addition: 12M (for curves in the form y² = x³ + b) # Projective mixed addition: 11M (for curves in the form y² = x³ + b) -func lambdaAdd[F; G: static Subgroup](lambda_num, lambda_den: var F, P, Q: ECP_ShortW_Aff[F, G]) = +func lambdaAdd*[F; G: static Subgroup](lambda_num, lambda_den: var F, P, Q: ECP_ShortW_Aff[F, G]) {.inline.} = ## Compute the slope of the line (PQ) lambda_num.diff(Q.y, P.y) lambda_den.diff(Q.x, P.x) -func lambdaDouble[F; G: static Subgroup](lambda_num, lambda_den: var F, P: ECP_ShortW_Aff[F, G]) = +func lambdaSub*[F; G: static Subgroup](lambda_num, lambda_den: var F, P, Q: ECP_ShortW_Aff[F, G]) {.inline.} = + ## Compute the slope of the line (PQ) + lambda_num.neg(Q.y) + lambda_num -= P.y + lambda_den.diff(Q.x, P.x) + +func lambdaDouble*[F; G: static Subgroup](lambda_num, lambda_den: var F, P: ECP_ShortW_Aff[F, G]) {.inline.} = ## Compute the tangent at P lambda_num.square(P.x) lambda_num *= 3 @@ -214,11 +221,11 @@ func lambdaDouble[F; G: static Subgroup](lambda_num, lambda_den: var F, P: ECP_S lambda_den.double(P.y) -func affineAdd[F; G: static Subgroup]( - r: var ECP_ShortW_Aff[F, G], - lambda: var F, +func affineAdd*[F; G: static Subgroup]( + r{.noAlias.}: var ECP_ShortW_Aff[F, G], + lambda: F, P, Q: ECP_ShortW_Aff[F, G]) = - + ## `r` MUST NOT alias P or Q r.x.square(lambda) r.x -= P.x r.x -= Q.x @@ -229,8 +236,7 @@ func affineAdd[F; G: static Subgroup]( func accum_half_vartime[F; G: static Subgroup]( points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], - lambdas: ptr UncheckedArray[tuple[num, den: F]], - len: uint) {.noinline.} = + len: uint) {.noInline, tags:[VarTime, Alloca].} = ## Affine accumulation of half the points into the other half ## Warning ⚠️ : variable-time ## @@ -241,17 +247,13 @@ func accum_half_vartime[F; G: static Subgroup]( ## Partial sums are stored in [0, len/2) ## [len/2, len) data has been destroyed ## - ## Scratchspace: - ## - Lambdas - ## ## Output: ## - r - ## - ## Warning ⚠️ : cannot be inlined if used in loop due to the use of alloca debug: doAssert len and 1 == 0, "There must be an even number of points" - let N = len div 2 + let N = int(len div 2) + let lambdas = allocStackArray(tuple[num, den: F], N) # Step 1: Compute numerators and denominators of λᵢ = λᵢ_num / λᵢ_den for i in 0 ..< N: @@ -293,25 +295,25 @@ func accum_half_vartime[F; G: static Subgroup]( # Step 2: Accumulate denominators in Qy, which is not used anymore. if i == 0: points[q].y = lambdas[i].den + elif i == N-1: + points[q].y.prod(points[q_prev].y, lambdas[i].den) else: points[q].y.prod(points[q_prev].y, lambdas[i].den, skipFinalSub = true) # Step 3: batch invert var accInv {.noInit.}: F - accInv.setZero() - points[len-1].y += accInv # Undo skipFinalSub, ensure that the last accum is in canonical form, before inversion - accInv.inv(points[len-1].y) + accInv.inv_vartime(points[len-1].y) # Step 4: Compute the partial sums template recallSpecialCase(i, p, q): untyped {.dirty.} = # As Qy is used as an accumulator, we saved Qy in λᵢ_num - # For special caseshandling, restore it. + # For special cases handling, restore it. points[q].y = lambdas[i].num if points[p].isInf().bool(): points[i] = points[q] elif points[q].x.isZero().bool() and lambdas[i].num.isZero().bool(): - discard "points[i] = points[p]" # i == p + discard "points[q] is infinity => point[p] unchanged" else: points[i].setInf() @@ -356,17 +358,23 @@ func accum_half_vartime[F; G: static Subgroup]( # Store result points[0] = r -# Batch addition: jacobian +# Batch addition - High-level # ------------------------------------------------------------ +template `+=`[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_Aff[F, G]) = + # All vartime procedures MUST be tagged vartime + # Hence we do not expose `+=` for extended jacobian operation to prevent `vartime` mistakes + # The following algorithms are all tagged vartime, hence for genericity + # we create a local `+=` for this module only + madd_vartime(P, P, Q) + func accumSum_chunk_vartime[F; G: static Subgroup]( - r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G]), - points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], - lambdas: ptr UncheckedArray[tuple[num, den: F]], - len: uint) = + r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G] or ECP_ShortW_JacExt[F, G]), + points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], len: uint) = ## Accumulate `points` into r. ## `r` is NOT overwritten ## r += ∑ points + ## `points` are destroyed const minNumPointsSerial = 16 var n = len @@ -378,7 +386,7 @@ func accumSum_chunk_vartime[F; G: static Subgroup]( n -= 1 # Compute [0, n/2) += [n/2, n) - accum_half_vartime(points, lambdas, n) + accum_half_vartime(points, n) # Next chunk n = n div 2 @@ -387,11 +395,11 @@ func accumSum_chunk_vartime[F; G: static Subgroup]( for i in 0'u ..< n: r += points[i] -func sum_batch_vartime*[F; G: static Subgroup]( - r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G]), - points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], pointsLen: int) = - ## Batch addition of `points` into `r` - ## `r` is overwritten +func accum_batch_vartime[F; G: static Subgroup]( + r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G] or ECP_ShortW_JacExt[F, G]), + points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], pointsLen: int) {.noInline, tags:[VarTime, Alloca].} = + ## Batch accumulation of `points` into `r` + ## `r` is accumulated into # We chunk the addition to limit memory usage # especially as we allocate on the stack. @@ -412,27 +420,81 @@ func sum_batch_vartime*[F; G: static Subgroup]( # After one chunk is processed we are well within all 64-bit CPU L2 cache bounds # as we halve after each chunk. - r.setInf() - const maxTempMem = 262144 # 2¹⁸ = 262144 const maxStride = maxTempMem div sizeof(ECP_ShortW_Aff[F, G]) let n = min(maxStride, pointsLen) let accumulators = allocStackArray(ECP_ShortW_Aff[F, G], n) - let lambdas = allocStackArray(tuple[num, den: F], n) for i in countup(0, pointsLen-1, maxStride): let n = min(maxStride, pointsLen - i) let size = n * sizeof(ECP_ShortW_Aff[F, G]) copyMem(accumulators[0].addr, points[i].unsafeAddr, size) - r.accumSum_chunk_vartime(accumulators, lambdas, uint n) + r.accumSum_chunk_vartime(accumulators, uint n) -func sum_batch_vartime*[F; G: static Subgroup]( - r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G]), - points: openArray[ECP_ShortW_Aff[F, G]]) {.inline.} = +func sum_reduce_vartime*[F; G: static Subgroup]( + r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G] or ECP_ShortW_JacExt[F, G]), + points: ptr UncheckedArray[ECP_ShortW_Aff[F, G]], pointsLen: int) {.inline, tags:[VarTime, Alloca].} = ## Batch addition of `points` into `r` ## `r` is overwritten - if points.len == 0: - r.setInf() + r.setInf() + if pointsLen == 0: return - r.sum_batch_vartime(points.asUnchecked(), points.len) \ No newline at end of file + r.accum_batch_vartime(points, pointsLen) + +func sum_reduce_vartime*[F; G: static Subgroup]( + r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G] or ECP_ShortW_JacExt[F, G]), + points: openArray[ECP_ShortW_Aff[F, G]]) {.inline, tags:[VarTime, Alloca].} = + ## Batch addition of `points` into `r` + ## `r` is overwritten + r.sum_reduce_vartime(points.asUnchecked(), points.len) + +# ############################################################ +# +# EC Addition Accumulator +# +# ############################################################ + +# Accumulators stores partial additions +# They allow supporting EC additions in a streaming fashion + +type EcAddAccumulator_vartime*[EC, F; G: static Subgroup; AccumMax: static int] = object + ## Elliptic curve addition accumulator + ## **Variable-Time** + # The `cur` is dereferenced first so better locality if at the beginning + # Do we want alignment guarantees? + cur: uint32 + accum: EC + buffer: array[AccumMax, ECP_ShortW_Aff[F, G]] + +func init*(ctx: var EcAddAccumulator_vartime) = + static: doAssert EcAddAccumulator_vartime.AccumMax >= 16, "There is no point in a EcAddBatchAccumulator if the batch size is too small" + ctx.accum.setInf() + ctx.cur = 0 + +func consumeBuffer[EC, F; G: static Subgroup; AccumMax: static int]( + ctx: var EcAddAccumulator_vartime[EC, F, G, AccumMax]) {.noInline, tags: [VarTime, Alloca].}= + if ctx.cur == 0: + return + + let lambdas = allocStackArray(tuple[num, den: F], ctx.cur.int) + ctx.accum.accumSum_chunk_vartime(ctx.buffer.asUnchecked(), lambdas, ctx.cur.uint) + ctx.cur = 0 + +func update*[EC, F, G; AccumMax: static int]( + ctx: var EcAddAccumulator_vartime[EC, F, G, AccumMax], + P: ECP_ShortW_Aff[F, G]) = + + if ctx.cur == AccumMax: + ctx.consumeBuffer() + + ctx.buffer[ctx.cur] = P + ctx.cur += 1 + +# TODO: `merge` for parallel recursive divide-and-conquer processing + +func finish*[EC, F, G; AccumMax: static int]( + ctx: var EcAddAccumulator_vartime[EC, F, G, AccumMax], + accumulatedResult: var EC) = + ctx.consumeBuffer() + accumulatedResult = ctx.accum \ No newline at end of file diff --git a/constantine/math/elliptic/ec_shortweierstrass_batch_ops_parallel.nim b/constantine/math/elliptic/ec_shortweierstrass_batch_ops_parallel.nim index 38bddb8..3134b11 100644 --- a/constantine/math/elliptic/ec_shortweierstrass_batch_ops_parallel.nim +++ b/constantine/math/elliptic/ec_shortweierstrass_batch_ops_parallel.nim @@ -7,7 +7,7 @@ # at your option. This file may not be copied, modified, or distributed except according to those terms. import - ../../platforms/[abstractions, allocs], + ../../platforms/abstractions, ../../platforms/threadpool/threadpool, ./ec_shortweierstrass_affine, ./ec_shortweierstrass_jacobian, @@ -65,10 +65,10 @@ iterator items(c: ChunkDescriptor): tuple[chunkID, start, stopEx: int] = let chunkSize = c.baseChunkSize yield (chunkID, offset, min(offset+chunkSize, c.totalIters)) -proc sum_batch_vartime_parallel*[F; G: static Subgroup]( +proc sum_reduce_vartime_parallel*[F; G: static Subgroup]( tp: Threadpool, r: var (ECP_ShortW_Jac[F, G] or ECP_ShortW_Prj[F, G]), - points: openArray[ECP_ShortW_Aff[F, G]]) = + points: openArray[ECP_ShortW_Aff[F, G]]) {.noInline.} = ## Batch addition of `points` into `r` ## `r` is overwritten ## Compute is parallelized, if beneficial. @@ -92,7 +92,7 @@ proc sum_batch_vartime_parallel*[F; G: static Subgroup]( static: doAssert minNumPointsParallel <= maxNumPoints, "The curve " & $r.typeof & " requires large size and needs to be tuned." if points.len < minNumPointsParallel: - r.sum_batch_vartime(points) + r.sum_reduce_vartime(points) return let chunkDesc = computeBalancedChunks( @@ -103,12 +103,12 @@ proc sum_batch_vartime_parallel*[F; G: static Subgroup]( let partialResults = allocStackArray(r.typeof(), chunkDesc.numChunks) for iter in items(chunkDesc): - proc sum_batch_vartime_wrapper(res: ptr, p: ptr, pLen: int) {.nimcall.} = + proc sum_reduce_vartime_wrapper(res: ptr, p: ptr, pLen: int) {.nimcall.} = # The borrow checker prevents capturing `var` and `openArray` # so we capture pointers instead. - res[].sum_batch_vartime(p, pLen) + res[].sum_reduce_vartime(p, pLen) - tp.spawn partialResults[iter.chunkID].addr.sum_batch_vartime_wrapper( + tp.spawn partialResults[iter.chunkID].addr.sum_reduce_vartime_wrapper( points.asUnchecked() +% iter.start, iter.stopEx - iter.start) @@ -122,7 +122,7 @@ proc sum_batch_vartime_parallel*[F; G: static Subgroup]( else: let partialResultsAffine = allocStackArray(ECP_ShortW_Aff[F, G], chunkDesc.numChunks) partialResultsAffine.batchAffine(partialResults, chunkDesc.numChunks) - r.sum_batch_vartime(partialResultsAffine, chunkDesc.numChunks) + r.sum_reduce_vartime(partialResultsAffine, chunkDesc.numChunks) # Sanity checks # --------------------------------------- diff --git a/constantine/math/elliptic/ec_shortweierstrass_jacobian.nim b/constantine/math/elliptic/ec_shortweierstrass_jacobian.nim index 9515d36..8693aa7 100644 --- a/constantine/math/elliptic/ec_shortweierstrass_jacobian.nim +++ b/constantine/math/elliptic/ec_shortweierstrass_jacobian.nim @@ -37,11 +37,23 @@ type ECP_ShortW_Jac*[F; G: static Subgroup] = object ## Note that jacobian coordinates are not unique x*, y*, z*: F -template affine*[F, G](_: type ECP_ShortW_Jac[F, G]): typedesc = - ## Returns the affine type that corresponds to the Jacobian type input - ECP_ShortW_Aff[F, G] +func isInf*(P: ECP_ShortW_Jac): SecretBool {.inline.} = + ## Returns true if P is an infinity point + ## and false otherwise + ## + ## Note: the jacobian coordinates equation is + ## Y² = X³ + aXZ⁴ + bZ⁶ + ## A "zero" point is any point with coordinates X and Z = 0 + ## Y can be anything + result = P.z.isZero() -func `==`*(P, Q: ECP_ShortW_Jac): SecretBool = +func setInf*(P: var ECP_ShortW_Jac) {.inline.} = + ## Set ``P`` to infinity + P.x.setOne() + P.y.setOne() + P.z.setZero() + +func `==`*(P, Q: ECP_ShortW_Jac): SecretBool {.meter.} = ## Constant-time equality check ## This is a costly operation # Reminder: the representation is not unique @@ -63,21 +75,8 @@ func `==`*(P, Q: ECP_ShortW_Jac): SecretBool = b *= z1z1 result = result and a == b -func isInf*(P: ECP_ShortW_Jac): SecretBool {.inline.} = - ## Returns true if P is an infinity point - ## and false otherwise - ## - ## Note: the jacobian coordinates equation is - ## Y² = X³ + aXZ⁴ + bZ⁶ - ## A "zero" point is any point with coordinates X and Z = 0 - ## Y can be anything - result = P.z.isZero() - -func setInf*(P: var ECP_ShortW_Jac) {.inline.} = - ## Set ``P`` to infinity - P.x.setOne() - P.y.setOne() - P.z.setZero() + # Ensure a zero-init point doesn't propagate 0s and match any + result = result and not(P.isInf() xor Q.isInf()) func ccopy*(P: var ECP_ShortW_Jac, Q: ECP_ShortW_Jac, ctl: SecretBool) {.inline.} = ## Constant-time conditional copy @@ -337,7 +336,7 @@ func sum*[F; G: static Subgroup]( r: var ECP_ShortW_Jac[F, G], P, Q: ECP_ShortW_Jac[F, G], CoefA: static F - ) = + ) {.meter.} = ## Elliptic curve point addition for Short Weierstrass curves in Jacobian coordinates ## with the curve ``a`` being a parameter for summing on isogenous curves. ## @@ -361,7 +360,7 @@ func sum*[F; G: static Subgroup]( func sum*[F; G: static Subgroup]( r: var ECP_ShortW_Jac[F, G], P, Q: ECP_ShortW_Jac[F, G] - ) = + ) {.meter.} = ## Elliptic curve point addition for Short Weierstrass curves in Jacobian coordinates ## ## R = P + Q @@ -383,7 +382,7 @@ func madd*[F; G: static Subgroup]( r: var ECP_ShortW_Jac[F, G], P: ECP_ShortW_Jac[F, G], Q: ECP_ShortW_Aff[F, G] - ) = + ) {.meter.} = ## Elliptic curve mixed addition for Short Weierstrass curves in Jacobian coordinates ## with the curve ``a`` being a parameter for summing on isogenous curves. ## @@ -555,10 +554,7 @@ func madd*[F; G: static Subgroup]( r = o -func double*[F; G: static Subgroup]( - r: var ECP_ShortW_Jac[F, G], - P: ECP_ShortW_Jac[F, G] - ) = +func double*[F; G: static Subgroup](r: var ECP_ShortW_Jac[F, G], P: ECP_ShortW_Jac[F, G]) {.meter.} = ## Elliptic curve point doubling for Short Weierstrass curves in projective coordinate ## ## R = [2] P @@ -642,9 +638,19 @@ func `-=`*(P: var ECP_ShortW_Jac, Q: ECP_ShortW_Jac) {.inline.} = nQ.neg(Q) P.sum(P, nQ) +func `-=`*(P: var ECP_ShortW_Jac, Q: ECP_ShortW_Aff) {.inline.} = + ## In-place point substraction + var nQ {.noInit.}: typeof(Q) + nQ.neg(Q) + P.madd(P, nQ) + +template affine*[F, G](_: type ECP_ShortW_Jac[F, G]): typedesc = + ## Returns the affine type that corresponds to the Jacobian type input + ECP_ShortW_Aff[F, G] + func affine*[F; G]( aff: var ECP_ShortW_Aff[F, G], - jac: ECP_ShortW_Jac[F, G]) = + jac: ECP_ShortW_Jac[F, G]) {.meter.} = var invZ {.noInit.}, invZ2{.noInit.}: F invZ.inv(jac.z) invZ2.square(invZ, skipFinalSub = true) @@ -659,3 +665,4 @@ func fromAffine*[F; G]( jac.x = aff.x jac.y = aff.y jac.z.setOne() + jac.z.csetZero(aff.isInf()) diff --git a/constantine/math/elliptic/ec_shortweierstrass_jacobian_extended.nim b/constantine/math/elliptic/ec_shortweierstrass_jacobian_extended.nim new file mode 100644 index 0000000..d0cc7a0 --- /dev/null +++ b/constantine/math/elliptic/ec_shortweierstrass_jacobian_extended.nim @@ -0,0 +1,371 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + ../../platforms/abstractions, + ../config/curves, + ../arithmetic, + ../extension_fields, + ./ec_shortweierstrass_affine, + ./ec_shortweierstrass_projective, + ./ec_shortweierstrass_jacobian + +export Subgroup + +# No exceptions allowed +{.push raises: [].} + +# ############################################################ +# +# Elliptic Curve in Short Weierstrass form +# with Extended Jacobian Coordinates +# +# ############################################################ + +type ECP_ShortW_JacExt*[F; G: static Subgroup] = object + ## Elliptic curve point for a curve in Short Weierstrass form + ## y² = x³ + a x + b + ## + ## over a field F + ## + ## in Extended Jacobian coordinates (X, Y, ZZ, ZZZ) + ## corresponding to (x, y) with X = xZ² and Y = yZ³ + ## + ## Note that extended jacobian coordinates are not unique + x*, y*, zz*, zzz*: F + +func fromAffine*[F; G](jacext: var ECP_ShortW_JacExt[F, G], aff: ECP_ShortW_Aff[F, G]) {.inline.} + +func isInf*(P: ECP_ShortW_JacExt): SecretBool {.inline, meter.} = + ## Returns true if P is an infinity point + ## and false otherwise + result = P.zz.isZero() + +func setInf*(P: var ECP_ShortW_JacExt) {.inline.} = + ## Set ``P`` to infinity + P.x.setOne() + P.y.setOne() + P.zz.setZero() + P.zzz.setZero() + +func `==`*(P, Q: ECP_ShortW_JacExt): SecretBool {.meter.} = + ## Constant-time equality check + ## This is a costly operation + # Reminder: the representation is not unique + type F = ECP_ShortW_JacExt.F + + var a{.noInit.}, b{.noInit.}: F + + a.prod(P.x, Q.zz) + b.prod(Q.x, P.zz) + result = a == b + + a.prod(P.y, Q.zzz) + b.prod(Q.y, P.zzz) + result = result and a == b + + # Ensure a zero-init point doesn't propagate 0s and match any + result = result and not(P.isInf() xor Q.isInf()) + +func trySetFromCoordsXandZ*[F; G]( + P: var ECP_ShortW_JacExt[F, G], + x, z: F): SecretBool = + ## Try to create a point the elliptic curve + ## Y² = X³ + aXZ⁴ + bZ⁶ (Jacobian coordinates) + ## y² = x³ + a x + b (affine coordinate) + ## return true and update `P` if `x` leads to a valid point + ## return false otherwise, in that case `P` is undefined. + ## + ## Note: Dedicated robust procedures for hashing-to-curve + ## will be provided, this is intended for testing purposes. + ## + ## For **test case generation only**, + ## this is preferred to generating random point + ## via random scalar multiplication of the curve generator + ## as the latter assumes: + ## - point addition, doubling work + ## - scalar multiplication works + ## - a generator point is defined + ## i.e. you can't test unless everything is already working + P.y.curve_eq_rhs(x, G) + result = sqrt_if_square(P.y) + + P.zz.square(z) + P.x.prod(x, P.zz) + + P.zzz.prod(P.zz, z) + P.y.prod(P.y, P.zzz) + +func trySetFromCoordX*[F; G]( + P: var ECP_ShortW_JacExt[F, G], + x: F): SecretBool = + ## Try to create a point the elliptic curve + ## y² = x³ + a x + b (affine coordinate) + ## + ## The `ZZ` and `ZZZ` coordinates are set to 1 + ## + ## return true and update `P` if `x` leads to a valid point + ## return false otherwise, in that case `P` is undefined. + ## + ## Note: Dedicated robust procedures for hashing-to-curve + ## will be provided, this is intended for testing purposes. + ## + ## For **test case generation only**, + ## this is preferred to generating random point + ## via random scalar multiplication of the curve generator + ## as the latter assumes: + ## - point addition, doubling work + ## - scalar multiplication works + ## - a generator point is defined + ## i.e. you can't test unless everything is already working + P.y.curve_eq_rhs(x, G) + result = sqrt_if_square(P.y) + P.x = x + P.zz.setOne() + P.zzz.setOne() + +func neg*(P: var ECP_ShortW_JacExt, Q: ECP_ShortW_JacExt) {.inline.} = + ## Negate ``P`` + P.x = Q.x + P.y.neg(Q.y) + P.zz = Q.zz + P.zzz = Q.zzz + +func neg*(P: var ECP_ShortW_JacExt) {.inline.} = + ## Negate ``P`` + P.y.neg() + +func double*[F; G: static Subgroup](r: var ECP_ShortW_JacExt[F, G], P: ECP_ShortW_JacExt[F, G]) {.meter.} = + # http://www.hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#doubling-dbl-2008-s-1 + var U{.noInit.}, V{.noInit.}, W{.noinit.}, S{.noInit.}, M{.noInit.}: F + + U.double(P.y) + V.square(U) + W.prod(U, V) + S.prod(P.x, V) + M.square(P.x) + M *= 3 + when F.C.getCoefA() != 0: + {.error: "Not implemented.".} + + # aliasing, we don't use P.x and U anymore + r.x.square(M) + U.double(S) + r.x -= U + S -= r.x + r.y.prod(W, P.y) + M *= S + r.y.diff(M, r.y) + r.zz.prod(P.zz, V) + r.zzz.prod(P.zzz, W) + +func sum_vartime*[F; G: static Subgroup]( + r: var ECP_ShortW_JacExt[F, G], + p, q: ECP_ShortW_JacExt[F, G]) + {.tags:[VarTime], meter.} = + ## **Variable-time** Extended Jacobian addition + ## + ## This MUST NOT be used with secret data. + ## + ## This is highly VULNERABLE to timing attacks and power analysis attacks. + # https://www.hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#addition-add-2008-s + + if p.isInf().bool: + r = q + return + if q.isInf().bool: + r = p + return + + var U{.noInit.}, S{.noInit.}, P{.noInit.}, R{.noInit.}: F + + U.prod(p.x, q.zz) + P.prod(q.x, p.zz) + S.prod(p.y, q.zzz) + R.prod(q.y, p.zzz) + + P -= U + R -= S + + if P.isZero().bool: # Same x coordinate + if R.isZero().bool: # case P == Q + r.double(q) + return + else: # case P = -Q + r.setInf() + return + + var PP{.noInit.}, PPP{.noInit.}, Q{.noInit.}: F + + PP.square(P) + PPP.prod(PP, P) + Q.prod(U, PP) + + r.x.square(R) + P.double(Q) + r.x -= PPP + r.x -= P + + Q -= r.x + r.y.prod(S, PPP) + R *= Q + r.y.diff(R, r.y) + + r.zz.prod(p.zz, q.zz) + r.zz *= PP + r.zzz.prod(p.zzz, q.zzz) + r.zzz *= PPP + +func mdouble*[F; G: static Subgroup](r: var ECP_ShortW_JacExt[F, G], P: ECP_ShortW_Aff[F, G]) {.meter.} = + ## Mixed EC point double + # http://www.hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#doubling-mdbl-2008-s-1 + + var U{.noInit.}, V{.noInit.}, W{.noinit.}, S{.noInit.}, M{.noInit.}: F + + U.double(P.y) + V.square(U) + W.prod(U, V) + S.prod(P.x, V) + M.square(P.x) + M *= 3 + when F.C.getCoefA() != 0: + {.error: "Not implemented.".} + + # aliasing, we don't use P.x and U anymore + r.x.square(M) + U.double(S) + r.x -= U + S -= r.x + r.y.prod(W, P.y) + M *= S + r.y.diff(M, r.y) + r.zz = V + r.zzz = W + +func madd_vartime*[F; G: static Subgroup]( + r: var ECP_ShortW_JacExt[F, G], + p: ECP_ShortW_JacExt[F, G], + q: ECP_ShortW_Aff[F, G]) + {.tags:[VarTime], meter.} = + ## **Variable-time** Extended Jacobian mixed addition + ## + ## This MUST NOT be used with secret data. + ## + ## This is highly VULNERABLE to timing attacks and power analysis attacks. + # https://www.hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#addition-add-2008-s + + if p.isInf().bool: + r.fromAffine(q) + return + if q.isInf().bool: + r = p + return + + var P{.noInit.}, R{.noInit.}: F + + P.prod(q.x, p.zz) + R.prod(q.y, p.zzz) + + P -= p.x + R -= p.y + + if P.isZero().bool: # Same x coordinate + if R.isZero().bool: # case P == Q + r.mdouble(q) + return + else: # case P = -Q + r.setInf() + return + + var PP{.noInit.}, PPP{.noInit.}, Q{.noInit.}: F + + PP.square(P) + PPP.prod(PP, P) + Q.prod(p.x, PP) + + r.x.square(R) + P.double(Q) + r.x -= PPP + r.x -= P + + Q -= r.x + r.y.prod(p.y, PPP) + R *= Q + r.y.diff(R, r.y) + + r.zz.prod(p.zz, PP) + r.zzz.prod(p.zzz, PPP) + +func msub_vartime*[F; G: static Subgroup]( + r: var ECP_ShortW_JacExt[F, G], + p: ECP_ShortW_JacExt[F, G], + q: ECP_ShortW_Aff[F, G]) {.tags:[VarTime], inline.} = + var nQ {.noInit.}: ECP_ShortW_Aff[F, G] + nQ.neg(q) + r.madd_vartime(p, nQ) + +# Conversions +# ----------- + +template affine*[F, G](_: type ECP_ShortW_JacExt[F, G]): typedesc = + ## Returns the affine type that corresponds to the Extended Jacobian type input + ECP_ShortW_Aff[F, G] + +template jacobianExtended*[EC](_: typedesc[EC]): typedesc = + ## Returns the affine type that corresponds to the Extended Jacobian type input + ECP_ShortW_JacExt[EC.F, EC.G] + +func affine*[F; G]( + aff: var ECP_ShortW_Aff[F, G], + jacext: ECP_ShortW_JacExt[F, G]) {.meter.} = + var invZZ {.noInit.}, invZZZ{.noInit.}: F + invZZZ.inv(jacext.zzz) + invZZ.prod(jacext.zz, invZZZ, skipFinalSub = true) + invZZ.square(skipFinalSub = true) + aff.x.prod(jacext.x, invZZ) + aff.y.prod(jacext.y, invZZZ) + +func fromAffine*[F; G]( + jacext: var ECP_ShortW_JacExt[F, G], + aff: ECP_ShortW_Aff[F, G]) {.inline, meter.} = + jacext.x = aff.x + jacext.y = aff.y + jacext.zz.setOne() + jacext.zzz.setOne() + + let inf = aff.isInf() + jacext.zz.csetZero(inf) + jacext.zzz.csetZero(inf) + +func fromJacobianExtended_vartime*[F; G]( + prj: var ECP_ShortW_Prj[F, G], + jacext: ECP_ShortW_JacExt[F, G]) {.inline, meter, tags:[VarTime].} = + # Affine (x, y) + # Jacobian extended (xZ², yZ³, Z², Z³) + # Projective (xZ', yZ', Z') + # We can choose Z' = Z⁵ + if jacext.isInf().bool: + prj.setInf() + return + prj.z.prod(jacext.zz, jacext.zzz) + prj.x.prod(jacext.x, jacext.zzz) + prj.y.prod(jacext.y, jacext.zz) + +func fromJacobianExtended_vartime*[F; G]( + jac: var ECP_ShortW_Jac[F, G], + jacext: ECP_ShortW_JacExt[F, G]) {.inline, meter, tags:[VarTime].} = + # Affine (x, y) + # Jacobian extended (xZ², yZ³, Z², Z³) + # Jacobian (xZ'², yZ'³, Z') + # We can choose Z' = Z² + if jacext.isInf().bool: + jac.setInf() + return + jac.x.prod(jacext.x, jacext.zz) + jac.y.prod(jacext.y, jacext.zzz) + jac.z = jacext.zz \ No newline at end of file diff --git a/constantine/math/elliptic/ec_shortweierstrass_projective.nim b/constantine/math/elliptic/ec_shortweierstrass_projective.nim index 8e7bb4e..425f50a 100644 --- a/constantine/math/elliptic/ec_shortweierstrass_projective.nim +++ b/constantine/math/elliptic/ec_shortweierstrass_projective.nim @@ -37,9 +37,21 @@ type ECP_ShortW_Prj*[F; G: static Subgroup] = object ## Note that projective coordinates are not unique x*, y*, z*: F -template affine*[F, G](_: type ECP_ShortW_Prj[F, G]): typedesc = - ## Returns the affine type that corresponds to the Jacobian type input - ECP_ShortW_Aff[F, G] +func isInf*(P: ECP_ShortW_Prj): SecretBool {.inline.} = + ## Returns true if P is an infinity point + ## and false otherwise + ## + ## Note: the projective coordinates equation is + ## Y²Z = X³ + aXZ² + bZ³ + ## A "zero" point is any point with coordinates X and Z = 0 + ## Y can be anything + result = P.x.isZero() and P.z.isZero() + +func setInf*(P: var ECP_ShortW_Prj) {.inline.} = + ## Set ``P`` to infinity + P.x.setZero() + P.y.setOne() + P.z.setZero() func `==`*(P, Q: ECP_ShortW_Prj): SecretBool = ## Constant-time equality check @@ -57,21 +69,8 @@ func `==`*(P, Q: ECP_ShortW_Prj): SecretBool = b.prod(Q.y, P.z) result = result and a == b -func isInf*(P: ECP_ShortW_Prj): SecretBool {.inline.} = - ## Returns true if P is an infinity point - ## and false otherwise - ## - ## Note: the projective coordinates equation is - ## Y²Z = X³ + aXZ² + bZ³ - ## A "zero" point is any point with coordinates X and Z = 0 - ## Y can be anything - result = P.x.isZero() and P.z.isZero() - -func setInf*(P: var ECP_ShortW_Prj) {.inline.} = - ## Set ``P`` to infinity - P.x.setZero() - P.y.setOne() - P.z.setZero() + # Ensure a zero-init point doesn't propagate 0s and match any + result = result and not(P.isInf() xor Q.isInf()) func ccopy*(P: var ECP_ShortW_Prj, Q: ECP_ShortW_Prj, ctl: SecretBool) {.inline.} = ## Constant-time conditional copy @@ -153,7 +152,7 @@ func cneg*(P: var ECP_ShortW_Prj, ctl: CTBool) {.inline.} = func sum*[F; G: static Subgroup]( r: var ECP_ShortW_Prj[F, G], P, Q: ECP_ShortW_Prj[F, G] - ) = + ) {.meter.} = ## Elliptic curve point addition for Short Weierstrass curves in projective coordinates ## ## R = P + Q @@ -253,7 +252,7 @@ func madd*[F; G: static Subgroup]( r: var ECP_ShortW_Prj[F, G], P: ECP_ShortW_Prj[F, G], Q: ECP_ShortW_Aff[F, G] - ) = + ) {.meter.} = ## Elliptic curve mixed addition for Short Weierstrass curves ## with p in Projective coordinates and Q in affine coordinates ## @@ -331,7 +330,7 @@ func madd*[F; G: static Subgroup]( func double*[F; G: static Subgroup]( r: var ECP_ShortW_Prj[F, G], P: ECP_ShortW_Prj[F, G] - ) = + ) {.meter.} = ## Elliptic curve point doubling for Short Weierstrass curves in projective coordinate ## ## R = [2] P @@ -430,9 +429,19 @@ func `-=`*(P: var ECP_ShortW_Prj, Q: ECP_ShortW_Prj) {.inline.} = nQ.neg(Q) P.sum(P, nQ) +func `-=`*(P: var ECP_ShortW_Prj, Q: ECP_ShortW_Aff) {.inline.} = + ## In-place point substraction + var nQ {.noInit.}: typeof(Q) + nQ.neg(Q) + P.madd(P, nQ) + +template affine*[F, G](_: type ECP_ShortW_Prj[F, G]): typedesc = + ## Returns the affine type that corresponds to the Jacobian type input + ECP_ShortW_Aff[F, G] + func affine*[F, G]( aff: var ECP_ShortW_Aff[F, G], - proj: ECP_ShortW_Prj[F, G]) = + proj: ECP_ShortW_Prj[F, G]) {.meter.} = var invZ {.noInit.}: F invZ.inv(proj.z) @@ -445,3 +454,7 @@ func fromAffine*[F, G]( proj.x = aff.x proj.y = aff.y proj.z.setOne() + + let inf = aff.isInf() + proj.x.csetZero(inf) + proj.z.csetZero(inf) \ No newline at end of file diff --git a/constantine/math/extension_fields/towers.nim b/constantine/math/extension_fields/towers.nim index bc9f51e..4015ecf 100644 --- a/constantine/math/extension_fields/towers.nim +++ b/constantine/math/extension_fields/towers.nim @@ -301,7 +301,7 @@ template doublePrec*(T: type ExtensionField): type = when T is QuadraticExt: when T.F is QuadraticExt: # Fp4Dbl QuadraticExt2x[QuadraticExt2x[doublePrec(T.F.F)]] - elif T.F is CubicExt: + elif T.F is CubicExt: when T.F.F is QuadraticExt: # Fp12 over Fp6 over Fp2 QuadraticExt2x[CubicExt2x[QuadraticExt2x[doublePrec(T.F.F.F)]]] elif T.F is Fp: # Fp2Dbl @@ -704,19 +704,22 @@ func prod2x*( func prefer_3sqr_over_2mul(F: type ExtensionField): bool {.compileTime.} = ## Returns true ## if time(3sqr) < time(2mul) in the extension fields - + let a = default(F) # No shortcut in the VM - when a.c0 is ExtensionField: - when a.c0.c0 is ExtensionField: + when a.c0 is Fp12: + # Benchmarked on BLS12-381 + when a.c0.c0 is Fp6: return true + elif a.c0.c0 is Fp4: + return false else: return false else: return false func has_large_NR_norm(C: static Curve): bool = ## Returns true if the non-residue of the extension fields ## has a large norm - + const j = C.getNonResidueFp() const u = C.getNonResidueFp2()[0] const v = C.getNonResidueFp2()[1] @@ -908,7 +911,7 @@ func square_generic(r: var QuadraticExt, a: QuadraticExt) = when QuadraticExt.prefer_3sqr_over_2mul() or # Other path multiplies twice by non-residue - QuadraticExt.C.has_large_NR_norm(): + QuadraticExt.C.has_large_NR_norm(): var v0 {.noInit.}, v1 {.noInit.}: typeof(r.c0) v0.square(a.c0) v1.square(a.c1) @@ -977,7 +980,7 @@ func square2x_disjoint*[Fdbl, F]( # ------------------------------------------------------------------- func prodImpl_fp4o2_p3mod8[C: static Curve](r: var Fp4[C], a, b: Fp4[C]) = - ## Returns r = a * b + ## Returns r = a * b ## For 𝔽p4/𝔽p2 with p ≡ 3 (mod 8), ## hence 𝔽p QNR is 𝑖 = √-1 as p ≡ 3 (mod 8) implies p ≡ 3 (mod 4) ## and 𝔽p SNR is (1 + i) @@ -987,7 +990,7 @@ func prodImpl_fp4o2_p3mod8[C: static Curve](r: var Fp4[C], a, b: Fp4[C]) = n_a01{.noInit.}, n_a11{.noInit.}: Fp[C] t{.noInit.}: Fp4[C] - + b10_m_b11.diff(b.c1.c0, b.c1.c1) b10_p_b11.sum(b.c1.c0, b.c1.c1) n_a01.neg(a.c0.c1) @@ -1233,7 +1236,7 @@ func mul2x_sparse_by_0y*[Fdbl, F]( # Inversion # ------------------------------------------------------------------- -func invImpl(r: var QuadraticExt, a: QuadraticExt) = +func invImpl(r: var QuadraticExt, a: QuadraticExt, useVartime: static bool = false) = ## Compute the multiplicative inverse of ``a`` ## ## The inverse of 0 is 0. @@ -1257,14 +1260,17 @@ func invImpl(r: var QuadraticExt, a: QuadraticExt) = v0 -= v1 # v0 = a0² - β a1² (the norm / squared magnitude of a) # [1 Inv, 2 Sqr, 1 Add] - v1.inv(v0) # v1 = 1 / (a0² - β a1²) + when useVartime: + v1.inv_vartime(v0) + else: + v1.inv(v0) # v1 = 1 / (a0² - β a1²) # [1 Inv, 2 Mul, 2 Sqr, 1 Add, 1 Neg] r.c0.prod(a.c0, v1) # r0 = a0 / (a0² - β a1²) v0.neg(v1) # v0 = -1 / (a0² - β a1²) r.c1.prod(a.c1, v0) # r1 = -a1 / (a0² - β a1²) -func inv2xImpl(r: var QuadraticExt, a: QuadraticExt) = +func inv2xImpl(r: var QuadraticExt, a: QuadraticExt, useVartime: static bool = false) = ## Compute the multiplicative inverse of ``a`` ## ## The inverse of 0 is 0. @@ -1284,7 +1290,10 @@ func inv2xImpl(r: var QuadraticExt, a: QuadraticExt) = # [1 Inv, 2 Sqr, 1 Add] t.redc2x(V0) - t.inv() # v1 = 1 / (a0² - β a1²) + when useVartime: + t.inv_vartime() + else: + t.inv() # v1 = 1 / (a0² - β a1²) # [1 Inv, 2 Mul, 2 Sqr, 1 Add, 1 Neg] r.c0.prod(a.c0, t) # r0 = a0 / (a0² - β a1²) @@ -1337,7 +1346,7 @@ func square*(r: var QuadraticExt, a: QuadraticExt) = elif QuadraticExt is Fp4[BLS12_377]: # TODO BLS12-377 slowness to fix r.square_generic(a) - else: + else: r.square_disjoint(a.c0, a.c1) func square*(a: var QuadraticExt) = @@ -1620,7 +1629,7 @@ func square_Chung_Hasan_SQR3(r: var CubicExt, a: CubicExt) = # ------------------------------------------------------------------- func prodImpl_fp6o2_p3mod8[C: static Curve](r: var Fp6[C], a, b: Fp6[C]) = - ## Returns r = a * b + ## Returns r = a * b ## For 𝔽p6/𝔽p2 with p ≡ 3 (mod 8), ## hence 𝔽p QNR is 𝑖 = √-1 as p ≡ 3 (mod 8) implies p ≡ 3 (mod 4) ## and 𝔽p SNR is (1 + i) @@ -1662,7 +1671,7 @@ func prodImpl_fp6o2_p3mod8[C: static Curve](r: var Fp6[C], a, b: Fp6[C]) = # ------------------------------------------------------------------- func prodImpl(r: var CubicExt, a, b: CubicExt) = - ## Returns r = a * b + ## Returns r = a * b ## Algorithm is Karatsuba var v0{.noInit.}, v1{.noInit.}, v2{.noInit.}: typeof(r.c0) var t0{.noInit.}, t1{.noInit.}, t2{.noInit.}: typeof(r.c0) @@ -1838,9 +1847,9 @@ func mul_sparse_by_xy0*[Fpkdiv3](r: var CubicExt, a: CubicExt, x, y: Fpkdiv3) = ## Sparse multiplication of a cubic extension element ## with coordinates (a₀, a₁, a₂) by (b₀, b₁, 0) - ## + ## ## r and a must not alias - + # v0 = a0 b0 # v1 = a1 b1 # v2 = a2 b2 = 0 @@ -1881,7 +1890,7 @@ func mul2x_sparse_by_xy0*[Fpkdiv3](r: var CubicExt2x, a: CubicExt, x, y: Fpkdiv3) = ## Sparse multiplication of a cubic extension element ## with coordinates (a₀, a₁, a₂) by (b₀, b₁, 0) - ## + ## ## r and a must not alias static: doAssert a.c0 is Fpkdiv3 @@ -1911,7 +1920,7 @@ func mul2x_sparse_by_xy0*[Fpkdiv3](r: var CubicExt2x, a: CubicExt, func mul_sparse_by_0yz*[Fpkdiv3](r: var CubicExt, a: CubicExt, y, z: Fpkdiv3) = ## Sparse multiplication of a cubic extension element ## with coordinates (a₀, a₁, a₂) by (0, b₁, b₂) - ## + ## ## r and a must not alias # v0 = a0 b0 = 0 @@ -1932,7 +1941,7 @@ func mul_sparse_by_0yz*[Fpkdiv3](r: var CubicExt, a: CubicExt, y, z: Fpkdiv3) = var v1 {.noInit.}: Fpkdiv3 v2 {.noInit.}: Fpkdiv3 - + v1.prod(a.c1, y) v2.prod(a.c2, z) @@ -1953,7 +1962,7 @@ func mul_sparse_by_0yz*[Fpkdiv3](r: var CubicExt, a: CubicExt, y, z: Fpkdiv3) = func mul2x_sparse_by_0yz*[Fpkdiv3](r: var CubicExt2x, a: CubicExt, y, z: Fpkdiv3) = ## Sparse multiplication of a cubic extension element ## with coordinates (a₀, a₁, a₂) by (0, b₁, b₂) - ## + ## ## r and a must not alias static: doAssert a.c0 is Fpkdiv3 @@ -1962,7 +1971,7 @@ func mul2x_sparse_by_0yz*[Fpkdiv3](r: var CubicExt2x, a: CubicExt, y, z: Fpkdiv3 V2 {.noInit.}: doubleprec(Fpkdiv3) t1 {.noInit.}: Fpkdiv3 t2 {.noInit.}: Fpkdiv3 - + V1.prod2x(a.c1, y) V2.prod2x(a.c2, z) @@ -1983,7 +1992,7 @@ func mul2x_sparse_by_0yz*[Fpkdiv3](r: var CubicExt2x, a: CubicExt, y, z: Fpkdiv3 # Inversion # ---------------------------------------------------------------------- -func invImpl(r: var CubicExt, a: CubicExt) = +func invImpl(r: var CubicExt, a: CubicExt, useVartime: static bool = false) = ## Compute the multiplicative inverse of ``a`` ## ## The inverse of 0 is 0. @@ -2031,14 +2040,17 @@ func invImpl(r: var CubicExt, a: CubicExt) = r.c0.prod(a.c0, A) # aliasing: last use of a₀, destroy r₀ t += r.c0 - t.inv() + when useVartime: + t.inv_vartime() + else: + t.inv() # (a0 + a1 v + a2 v²)^-1 = (A + B v + C v²) / F r.c0.prod(A, t) r.c1.prod(B, t) r.c2.prod(C, t) -func inv2xImpl(r: var CubicExt, a: CubicExt) = +func inv2xImpl(r: var CubicExt, a: CubicExt, useVartime: static bool = false) = ## Compute the multiplicative inverse of ``a`` ## via lazy reduction ## @@ -2082,8 +2094,11 @@ func inv2xImpl(r: var CubicExt, a: CubicExt) = t2.prod2x(A, a.c0) t.sum2xUnr(t, t2) f.redc2x(t) - - f.inv() + + when useVartime: + f.inv_vartime() + else: + f.inv() # (a0 + a1 v + a2 v²)^-1 = (A + B v + C v²) / F r.c0.prod(A, f) @@ -2142,7 +2157,7 @@ func inv*(r: var CubicExt, a: CubicExt) = ## Incidentally this avoids extra check ## to convert Jacobian and Projective coordinates ## to affine for elliptic curve - when true: + when CubicExt.C.has_large_field_elem() or r is Fp12: r.invImpl(a) else: r.inv2xImpl(a) @@ -2180,5 +2195,44 @@ template prod*(r: var ExtensionField, a, b: ExtensionField, skipFinalSub: static # the final substraction on Fp r.prod(a, b) +# ############################################################ +# # +# Variable-time # +# # +# ############################################################ + +func inv_vartime*(r: var QuadraticExt, a: QuadraticExt) {.tags:[VarTime].} = + ## Compute the multiplicative inverse of ``a`` + ## + ## The inverse of 0 is 0. + ## Incidentally this avoids extra check + ## to convert Jacobian and Projective coordinates + ## to affine for elliptic curve + when true: + r.invImpl(a, useVartime = true) + else: # Lazy reduction, doesn't seem to gain speed. + r.inv2xImpl(a, useVartime = true) + +func inv_vartime*(r: var CubicExt, a: CubicExt) {.tags:[VarTime].} = + ## Compute the multiplicative inverse of ``a`` + ## + ## The inverse of 0 is 0. + ## Incidentally this avoids extra check + ## to convert Jacobian and Projective coordinates + ## to affine for elliptic curve + when CubicExt.C.has_large_field_elem() or r is Fp12: + r.invImpl(a, useVartime = true) + else: + r.inv2xImpl(a, useVartime = true) + +func inv_vartime*(a: var ExtensionField) {.tags:[VarTime].} = + ## Compute the multiplicative inverse of ``a`` + ## + ## The inverse of 0 is 0. + ## Incidentally this avoids extra check + ## to convert Jacobian and Projective coordinates + ## to affine for elliptic curve + a.invImpl(a, useVartime = true) + {.pop.} # inline {.pop.} # raises no exceptions diff --git a/constantine/math/io/io_ec.nim b/constantine/math/io/io_ec.nim index d4f9b74..4bb3ba0 100644 --- a/constantine/math/io/io_ec.nim +++ b/constantine/math/io/io_ec.nim @@ -14,7 +14,8 @@ import ../elliptic/[ ec_shortweierstrass_affine, ec_shortweierstrass_projective, - ec_shortweierstrass_jacobian + ec_shortweierstrass_jacobian, + ec_shortweierstrass_jacobian_extended ] # No exceptions allowed @@ -27,7 +28,7 @@ import # # ############################################################ -func toHex*[EC: ECP_ShortW_Prj or ECP_ShortW_Jac or ECP_ShortW_Aff](P: EC, indent: static int = 0): string = +func toHex*[EC: ECP_ShortW_Prj or ECP_ShortW_Jac or ECP_ShortW_Aff or ECP_ShortW_JacExt](P: EC, indent: static int = 0): string = ## Stringify an elliptic curve point to Hex ## Note. Leading zeros are not removed. ## Result is prefixed with 0x diff --git a/constantine/math/pairings/cyclotomic_subgroups.nim b/constantine/math/pairings/cyclotomic_subgroups.nim index dc614a4..508a093 100644 --- a/constantine/math/pairings/cyclotomic_subgroups.nim +++ b/constantine/math/pairings/cyclotomic_subgroups.nim @@ -392,7 +392,7 @@ func cyclotomic_exp*[FT](r: var FT, a: FT, exponent: static BigInt, invert: bool r.setOne() var init = false - for bit in recoding_l2r_vartime(exponent): + for bit in recoding_l2r_signed_vartime(exponent): if init: r.cyclotomic_square() if bit == 1: diff --git a/constantine/math/pairings/miller_loops.nim b/constantine/math/pairings/miller_loops.nim index 3616b07..482c50f 100644 --- a/constantine/math/pairings/miller_loops.nim +++ b/constantine/math/pairings/miller_loops.nim @@ -7,15 +7,17 @@ # at your option. This file may not be copied, modified, or distributed except according to those terms. import + ../config/curves, ../elliptic/[ ec_shortweierstrass_affine, ec_shortweierstrass_projective ], + ../arithmetic, ../isogenies/frobenius, ./lines_eval # No exceptions allowed -{.push raises: [].} +{.push raises: [], checks: off.} # ############################################################ # # @@ -23,60 +25,82 @@ import # # # ############################################################ +func recodeNafForPairing(ate: BigInt): seq[int8] {.compileTime.} = + ## We need a NAF recoding and we need to skip the MSB for pairings + var recoded: array[ate.bits+1, int8] + let recodedLen = recoded.recode_r2l_signed_vartime(ate) + var msbPos = recodedLen-1 + while true: + if recoded[msbPos] != 0: + break + else: + msbPos -= 1 + doAssert msbPos >= 0 + result = recoded[0 ..< msbPos] + func basicMillerLoop*[FT, F1, F2]( f: var FT, - line: var Line[F2], T: var ECP_ShortW_Prj[F2, G2], P: ECP_ShortW_Aff[F1, G1], Q: ECP_ShortW_Aff[F2, G2], - ate_param: auto, - ate_param_isNeg: static bool - ) = + ate_param: static BigInt) = ## Basic Miller loop iterations + ## + ## Multiplications by constants in the Miller loop is eliminated by final exponentiation + ## aka cofactor clearing in the pairing group. + ## + ## This means that there is no need to inverse/conjugate when `ate_param_isNeg` is false + ## in the general case. + ## If further processing is required, `ate_param_isNeg` must be taken into account by the caller. static: doAssert FT.C == F1.C doAssert FT.C == F2.C - f.setOne() + const naf = ate_param.recodeNafForPairing() + var line0 {.noInit.}, line1 {.noInit.}: Line[F2] var nQ {.noInit.}: ECP_ShortW_Aff[F2, G2] + f.setOne() nQ.neg(Q) - template u: untyped = ate_param - var u3 = ate_param - u3 *= 3 - for i in countdown(u3.bits - 2, 1): - if i != u3.bits - 2: - f.square() - line.line_double(T, P) - f.mul_by_line(line) + block: # naf.len - 1 + line0.line_double(T, P) + let bit = naf[naf.len-1] + if bit == 1: + line1.line_add(T, Q, P) + f.prod_from_2_lines(line0, line1) + elif bit == -1: + line1.line_add(T, nQ, P) + f.prod_from_2_lines(line0, line1) + else: + f.mul_by_line(line0) - let naf = u3.bit(i).int8 - u.bit(i).int8 # This can throw exception - if naf == 1: - line.line_add(T, Q, P) - f.mul_by_line(line) - elif naf == -1: - line.line_add(T, nQ, P) - f.mul_by_line(line) + for i in countdown(naf.len-2, 0): + let bit = naf[i] + f.square() + line0.line_double(T, P) - when ate_param_isNeg: - # In GT, x^-1 == conjugate(x) - # Remark 7.1, chapter 7.1.1 of Guide to Pairing-Based Cryptography, El Mrabet, 2017 - f.conj() + if bit == 1: + line1.line_add(T, Q, P) + f.mul_by_2_lines(line0, line1) + elif bit == -1: + line1.line_add(T, nQ, P) + f.mul_by_2_lines(line0, line1) + else: + f.mul_by_line(line0) func millerCorrectionBN*[FT, F1, F2]( f: var FT, T: var ECP_ShortW_Prj[F2, G2], Q: ECP_ShortW_Aff[F2, G2], - P: ECP_ShortW_Aff[F1, G1], - ate_param_isNeg: static bool - ) = + P: ECP_ShortW_Aff[F1, G1]) = ## Ate pairing for BN curves need adjustment after basic Miller loop + ## If `ate_param_isNeg` f must be cyclotomic inverted/conjugated + ## and T must be negated by the caller. static: doAssert FT.C == F1.C doAssert FT.C == F2.C + doAssert FT.C.family() == BarretoNaehrig - when ate_param_isNeg: - T.neg() var V {.noInit.}: typeof(Q) var line1 {.noInit.}, line2 {.noInit.}: Line[F2] @@ -122,92 +146,67 @@ func miller_init_double_then_add*[FT, F1, F2]( T: var ECP_ShortW_Prj[F2, G2], Q: ECP_ShortW_Aff[F2, G2], P: ECP_ShortW_Aff[F1, G1], - numDoublings: static int - ) = + numDoublings: static int) = ## Start a Miller Loop with ## - `numDoubling` doublings ## - 1 add ## ## f is overwritten ## T is overwritten by Q - static: - doAssert FT.C == F1.C - doAssert FT.C == F2.C - doAssert numDoublings >= 1 - {.push checks: off.} # No OverflowError or IndexError allowed - var line {.noInit.}: Line[F2] - - # First step: 0b10, T <- Q, f = 1 (mod p¹²), f *= line - # ---------------------------------------------------- + var line0 {.noInit.}, line1 {.noInit.}: Line[F2] T.fromAffine(Q) - # f.square() -> square(1) - line.line_double(T, P) + # First step: 0b1..., T <- Q, f = 1 (mod p¹²), f *= line + line0.line_double(T, P) - # Doubling steps: 0b10...00 - # ---------------------------------------------------- - - # Process all doublings, the second is special cased - # as: - # - The first line is squared (sparse * sparse) - # - The second is (somewhat-sparse * sparse) + # Second step: 0b10 or 0b11 + # If we have more than 1 doubling, we square the line instead of squaring f when numDoublings >= 2: - f.prod_from_2_lines(line, line) - line.line_double(T, P) - f.mul_by_line(line) - for _ in 2 ..< numDoublings: - f.square() - line.line_double(T, P) - f.mul_by_line(line) + f.prod_from_2_lines(line0, line0) + line0.line_double(T, P) + + # Doublings step: 0b10...0 + for _ in 2 ..< numDoublings: + # Apply previous line0 + f.mul_by_line(line0) + f.square() + line0.line_double(T, P) # Addition step: 0b10...01 - # ------------------------------------------------ - - # If there was only a single doubling needed, - # we special case the addition as - # - The first line and second are sparse (sparse * sparse) + line1.line_add(T, Q, P) when numDoublings == 1: - # f *= line <=> f = line for the first iteration - var line2 {.noInit.}: Line[F2] - line2.line_add(T, Q, P) - f.prod_from_2_lines(line, line2) + f.prod_from_2_lines(line0, line1) else: - line.line_add(T, Q, P) - f.mul_by_line(line) - - {.pop.} # No OverflowError or IndexError allowed + f.mul_by_2_lines(line0, line1) func miller_accum_double_then_add*[FT, F1, F2]( f: var FT, T: var ECP_ShortW_Prj[F2, G2], Q: ECP_ShortW_Aff[F2, G2], P: ECP_ShortW_Aff[F1, G1], - numDoublings: int, - add = true - ) = + numDoublings: int, add = true) = ## Continue a Miller Loop with ## - `numDoubling` doublings ## - 1 add ## ## f and T are updated - # - # `numDoublings` and `add` can be hardcoded at compile-time - # to prevent fault attacks. - # But fault attacks only happen on embedded - # and embedded is likely to want to minimize codesize. - # What to do? - {.push checks: off.} # No OverflowError or IndexError allowed - var line {.noInit.}: Line[F2] - for _ in 0 ..< numDoublings: + var line0 {.noInit.}, line1 {.noInit.}: Line[F2] + + f.square() + line0.line_double(T, P) + + for _ in 1 ..< numDoublings: + f.mul_by_line(line0) f.square() - line.line_double(T, P) - f.mul_by_line(line) + line0.line_double(T, P) if add: - line.line_add(T, Q, P) - f.mul_by_line(line) + line1.line_add(T, Q, P) + f.mul_by_2_lines(line0, line1) + else: + f.mul_by_line(line0) # Miller Loop - multi-pairing # ---------------------------------------------------------------------------- @@ -217,61 +216,52 @@ func miller_accum_double_then_add*[FT, F1, F2]( # See `multi_pairing.md`` # We implement Aranha approach +func isOdd(n: int): bool {.inline.} = bool(n and 1) + func double_jToN[FT, F1, F2]( f: var FT, j: static int, - line0, line1: var Line[F2], + lineOddRemainder: var Line[F2], Ts: ptr UncheckedArray[ECP_ShortW_Prj[F2, G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[F1, G1]], N: int) = ## Doubling steps for pairings j to N + ## if N is odd, lineOddRemainder must be applied to `f` - {.push checks: off.} # No OverflowError or IndexError allowed + var line0{.noInit.}, line1{.noInit.}: Line[F2] # Sparse merge 2 by 2, starting from j - for i in countup(j, N-1, 2): - if i+1 >= N: - break - + for i in countup(j, N-2, 2): line0.line_double(Ts[i], Ps[i]) line1.line_double(Ts[i+1], Ps[i+1]) f.mul_by_2_lines(line0, line1) - if (N and 1) == 1: # N >= 2 and N is odd, there is a leftover - line0.line_double(Ts[N-1], Ps[N-1]) - f.mul_by_line(line0) - - {.pop.} + if N.isOdd(): # N >= 2 and N is odd, there is a leftover + lineOddRemainder.line_double(Ts[N-1], Ps[N-1]) func add_jToN[FT, F1, F2]( f: var FT, j: static int, - line0, line1: var Line[F2], + lineOddRemainder: var Line[F2], Ts: ptr UncheckedArray[ECP_ShortW_Prj[F2, G2]], Qs: ptr UncheckedArray[ECP_ShortW_Aff[F2, G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[F1, G1]], N: int)= ## Addition steps for pairings 0 to N - {.push checks: off.} # No OverflowError or IndexError allowed + var line0{.noInit.}, line1{.noInit.}: Line[F2] # Sparse merge 2 by 2, starting from 0 - for i in countup(j, N-1, 2): - if i+1 >= N: - break - + for i in countup(j, N-2, 2): line0.line_add(Ts[i], Qs[i], Ps[i]) line1.line_add(Ts[i+1], Qs[i+1], Ps[i+1]) f.mul_by_2_lines(line0, line1) - if (N and 1) == 1: # N >= 2 and N is odd, there is a leftover - line0.line_add(Ts[N-1], Qs[N-1], Ps[N-1]) - f.mul_by_line(line0) - - {.pop.} + if N.isOdd(): # N >= 2 and N is odd, there is a leftover + lineOddRemainder.line_add(Ts[N-1], Qs[N-1], Ps[N-1]) func add_jToN_negateQ[FT, F1, F2]( f: var FT, j: static int, - line0, line1: var Line[F2], + lineOddRemainder: var Line[F2], Ts: ptr UncheckedArray[ECP_ShortW_Prj[F2, G2]], Qs: ptr UncheckedArray[ECP_ShortW_Aff[F2, G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[F1, G1]], @@ -279,62 +269,55 @@ func add_jToN_negateQ[FT, F1, F2]( ## Addition steps for pairings 0 to N var nQ{.noInit.}: ECP_ShortW_Aff[F2, G2] - - {.push checks: off.} # No OverflowError or IndexError allowed + var line0{.noInit.}, line1{.noInit.}: Line[F2] # Sparse merge 2 by 2, starting from 0 - for i in countup(j, N-1, 2): - if i+1 >= N: - break - + for i in countup(j, N-2, 2): nQ.neg(Qs[i]) line0.line_add(Ts[i], nQ, Ps[i]) nQ.neg(Qs[i+1]) line1.line_add(Ts[i+1], nQ, Ps[i+1]) f.mul_by_2_lines(line0, line1) - if (N and 1) == 1: # N >= 2 and N is odd, there is a leftover + if N.isOdd(): # N >= 2 and N is odd, there is a leftover nQ.neg(Qs[N-1]) - line0.line_add(Ts[N-1], nQ, Ps[N-1]) - f.mul_by_line(line0) - - {.pop.} + lineOddRemainder.line_add(Ts[N-1], nQ, Ps[N-1]) func basicMillerLoop*[FT, F1, F2]( f: var FT, - line0, line1: var Line[F2], Ts: ptr UncheckedArray[ECP_ShortW_Prj[F2, G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[F1, G1]], Qs: ptr UncheckedArray[ECP_ShortW_Aff[F2, G2]], N: int, - ate_param: auto, - ate_param_isNeg: static bool - ) = + ate_param: static Bigint) = ## Basic Miller loop iterations + ## + ## Multiplications by constants in the Miller loop is eliminated by final exponentiation + ## aka cofactor clearing in the pairing group. + ## + ## This means that there is no need to inverse/conjugate when `ate_param_isNeg` is false + ## in the general case. + ## If further processing is required, `ate_param_isNeg` must be taken into account by the caller. - static: - doAssert FT.C == F1.C - doAssert FT.C == F2.C - + const naf = ate_param.recodeNafForPairing() + var lineOddRemainder0{.noInit.}, lineOddRemainder1{.noinit.}: Line[F2] f.setOne() - template u: untyped = ate_param - var u3 = ate_param - u3 *= 3 - for i in countdown(u3.bits - 2, 1): - if i != u3.bits - 2: + for i in countdown(naf.len-1, 0): + let bit = naf[i] + if i != naf.len-1: f.square() - f.double_jToN(j=0, line0, line1, Ts, Ps, N) + f.double_jToN(j=0, lineOddRemainder0, Ts, Ps, N) - let naf = u3.bit(i).int8 - u.bit(i).int8 # This can throw exception - if naf == 1: - f.add_jToN(j=0, line0, line1, Ts, Qs, Ps, N) - elif naf == -1: - f.add_jToN_negateQ(j=0, line0, line1, Ts, Qs, Ps, N) + if bit == 1: + f.add_jToN(j=0, lineOddRemainder1, Ts, Qs, Ps, N) + elif bit == -1: + f.add_jToN_negateQ(j=0, lineOddRemainder1, Ts, Qs, Ps, N) - when ate_param_isNeg: - # In GT, x^-1 == conjugate(x) - # Remark 7.1, chapter 7.1.1 of Guide to Pairing-Based Cryptography, El Mrabet, 2017 - f.conj() + if N.isOdd(): + if bit == 0: + f.mul_by_line(lineOddRemainder0) + else: + f.mul_by_2_lines(lineOddRemainder0, lineOddRemainder1) func miller_init_double_then_add*[FT, F1, F2]( f: var FT, @@ -342,8 +325,7 @@ func miller_init_double_then_add*[FT, F1, F2]( Qs: ptr UncheckedArray[ECP_ShortW_Aff[F2, G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[F1, G1]], N: int, - numDoublings: static int - ) = + numDoublings: static int) = ## Start a Miller Loop ## This means ## - 1 doubling @@ -351,52 +333,32 @@ func miller_init_double_then_add*[FT, F1, F2]( ## ## f is overwritten ## Ts are overwritten by Qs - static: - doAssert FT.C == F1.C - doAssert FT.C == F2.C - {.push checks: off.} # No OverflowError or IndexError allowed - var line0 {.noInit.}, line1 {.noInit.}: Line[F2] + if N == 1: + f.miller_init_double_then_add(Ts[0], Qs[0], Ps[0], numDoublings) + return - # First step: T <- Q, f = 1 (mod p¹²), f *= line - # ---------------------------------------------- + var lineOddRemainder0 {.noInit.}, lineOddRemainder1 {.noInit.}: Line[F2] for i in 0 ..< N: Ts[i].fromAffine(Qs[i]) - line0.line_double(Ts[0], Ps[0]) - if N >= 2: - line1.line_double(Ts[1], Ps[1]) - f.prod_from_2_lines(line0, line1) - f.double_jToN(j=2, line0, line1, Ts, Ps, N) + # First step: T <- Q, f = 1 (mod p¹²), f *= line + lineOddRemainder0.line_double(Ts[0], Ps[0]) + lineOddRemainder1.line_double(Ts[1], Ps[1]) + f.prod_from_2_lines(lineOddRemainder0, lineOddRemainder1) + f.double_jToN(j=2, lineOddRemainder0, Ts, Ps, N) - # Doubling steps: 0b10...00 - # ------------------------------------------------ - when numDoublings > 1: # Already did the MSB doubling - if N == 1: # f = line0 - f.prod_from_2_lines(line0, line0) # f.square() - line0.line_double(Ts[0], Ps[0]) - f.mul_by_line(line0) - for _ in 2 ..< numDoublings: - f.square() - f.double_jtoN(j=0, line0, line1, Ts, Ps, N) - else: - for _ in 0 ..< numDoublings: - f.square() - f.double_jtoN(j=0, line0, line1, Ts, Ps, N) + # Doublings step: 0b10...0 + for _ in 1 ..< numDoublings: + if N.isOdd(): + f.mul_by_line(lineOddRemainder0) + f.square() + f.double_jToN(j=0, lineOddRemainder0, Ts, Ps, N) # Addition step: 0b10...01 - # ------------------------------------------------ - - when numDoublings == 1: - if N == 1: # f = line0 - line1.line_add(Ts[0], Qs[0], Ps[0]) - f.prod_from_2_lines(line0, line1) - else: - f.add_jToN(j=0,line0, line1, Ts, Qs, Ps, N) - else: - f.add_jToN(j=0,line0, line1, Ts, Qs, Ps, N) - - {.pop.} # No OverflowError or IndexError allowed + f.add_jToN(j=0, lineOddRemainder1, Ts, Qs, Ps, N) + if N.isOdd(): + f.mul_by_2_lines(lineOddRemainder0, lineOddRemainder1) func miller_accum_double_then_add*[FT, F1, F2]( f: var FT, @@ -404,18 +366,31 @@ func miller_accum_double_then_add*[FT, F1, F2]( Qs: ptr UncheckedArray[ECP_ShortW_Aff[F2, G2]], Ps: ptr UncheckedArray[ECP_ShortW_Aff[F1, G1]], N: int, - numDoublings: int, - add = true - ) = + numDoublings: int, add = true) = ## Continue a Miller Loop with ## - `numDoubling` doublings ## - 1 add ## ## f and T are updated - var line0{.noInit.}, line1{.noinit.}: Line[F2] - for _ in 0 ..< numDoublings: + + if N == 1: + f.miller_accum_double_then_add(Ts[0], Qs[0], Ps[0], numDoublings, add) + return + + var lineOddRemainder0 {.noInit.}, lineOddRemainder1 {.noInit.}: Line[F2] + + f.square() + f.double_jtoN(j=0, lineOddRemainder0, Ts, Ps, N) + for _ in 1 ..< numDoublings: + if N.isOdd(): + f.mul_by_line(lineOddRemainder0) f.square() - f.double_jtoN(j=0, line0, line1, Ts, Ps, N) + f.double_jtoN(j=0, lineOddRemainder0, Ts, Ps, N) if add: - f.add_jToN(j=0, line0, line1, Ts, Qs, Ps, N) + f.add_jToN(j=0, lineOddRemainder1, Ts, Qs, Ps, N) + if N.isOdd(): + f.mul_by_2_lines(lineOddRemainder0, lineOddRemainder1) + else: + if N.isOdd(): + f.mul_by_line(lineOddRemainder0) \ No newline at end of file diff --git a/constantine/math/pairings/pairings_bls12.nim b/constantine/math/pairings/pairings_bls12.nim index 3bd321c..e7745c6 100644 --- a/constantine/math/pairings/pairings_bls12.nim +++ b/constantine/math/pairings/pairings_bls12.nim @@ -18,7 +18,6 @@ import ../constants/zoo_pairings, ../arithmetic, ./cyclotomic_subgroups, - ./lines_eval, ./miller_loops export zoo_pairings # generic sandwich https://github.com/nim-lang/Nim/issues/11225 @@ -54,23 +53,29 @@ export zoo_pairings # generic sandwich https://github.com/nim-lang/Nim/issues/11 func millerLoopGenericBLS12*[C]( f: var Fp12[C], - P: ECP_ShortW_Aff[Fp[C], G1], - Q: ECP_ShortW_Aff[Fp2[C], G2] + Q: ECP_ShortW_Aff[Fp2[C], G2], + P: ECP_ShortW_Aff[Fp[C], G1] ) {.meter.} = ## Generic Miller Loop for BLS12 curve ## Computes f{u,Q}(P) with u the BLS curve parameter - - var - T {.noInit.}: ECP_ShortW_Prj[Fp2[C], G2] - line {.noInit.}: Line[Fp2[C]] - + var T {.noInit.}: ECP_ShortW_Prj[Fp2[C], G2] T.fromAffine(Q) - basicMillerLoop( - f, line, T, - P, Q, - pairing(C, ate_param), pairing(C, ate_param_isNeg) - ) + basicMillerLoop(f, T, P, Q, pairing(C, ate_param)) + +func millerLoopGenericBLS12*[C]( + f: var Fp12[C], + Qs: ptr UncheckedArray[ECP_ShortW_Aff[Fp2[C], G2]], + Ps: ptr UncheckedArray[ECP_ShortW_Aff[Fp[C], G1]], + N: int + ) {.noinline, tags:[Alloca], meter.} = + ## Generic Miller Loop for BLS12 curve + ## Computes f{u,Q}(P) with u the BLS curve parameter + var Ts = allocStackArray(ECP_ShortW_Prj[Fp2[C], G2], N) + for i in 0 ..< N: + Ts[i].fromAffine(Qs[i]) + + basicMillerLoop(f, Ts, Ps, Qs, N, pairing(C, ate_param)) func finalExpGeneric[C: static Curve](f: var Fp12[C]) = ## A generic and slow implementation of final exponentiation @@ -86,7 +91,7 @@ func pairing_bls12_reference*[C]( ## Output: e(P, Q) ∈ Gt ## ## Reference implementation - gt.millerLoopGenericBLS12(P, Q) + gt.millerLoopGenericBLS12(Q, P) gt.finalExpGeneric() # Optimized pairing implementation diff --git a/constantine/math/pairings/pairings_bn.nim b/constantine/math/pairings/pairings_bn.nim index 244fb9a..9c0be5d 100644 --- a/constantine/math/pairings/pairings_bn.nim +++ b/constantine/math/pairings/pairings_bn.nim @@ -7,7 +7,7 @@ # at your option. This file may not be copied, modified, or distributed except according to those terms. import - ../../platforms/[abstractions, allocs], + ../../platforms/abstractions, ../config/curves, ../extension_fields, ../elliptic/[ @@ -16,7 +16,6 @@ import ], ../isogenies/frobenius, ../constants/zoo_pairings, - ./lines_eval, ./cyclotomic_subgroups, ./miller_loops @@ -50,53 +49,45 @@ export zoo_pairings # generic sandwich https://github.com/nim-lang/Nim/issues/11 func millerLoopGenericBN*[C]( f: var Fp12[C], + Q: ECP_ShortW_Aff[Fp2[C], G2], P: ECP_ShortW_Aff[Fp[C], G1], - Q: ECP_ShortW_Aff[Fp2[C], G2] ) {.meter.} = ## Generic Miller Loop for BN curves ## Computes f{6u+2,Q}(P) with u the BN curve parameter - var - T {.noInit.}: ECP_ShortW_Prj[Fp2[C], G2] - line {.noInit.}: Line[Fp2[C]] - + var T {.noInit.}: ECP_ShortW_Prj[Fp2[C], G2] T.fromAffine(Q) - basicMillerLoop( - f, line, T, - P, Q, - pairing(C, ate_param), pairing(C, ate_param_isNeg) - ) + basicMillerLoop(f, T, P, Q, pairing(C, ate_param)) + + when pairing(C, ate_param_is_neg): + f.conj() + T.neg() # Ate pairing for BN curves needs adjustment after basic Miller loop - f.millerCorrectionBN( - T, Q, P, - pairing(C, ate_param_isNeg) - ) + f.millerCorrectionBN(T, Q, P) func millerLoopGenericBN*[C]( f: var Fp12[C], - Ps: ptr UncheckedArray[ECP_ShortW_Aff[Fp[C], G1]], Qs: ptr UncheckedArray[ECP_ShortW_Aff[Fp2[C], G2]], + Ps: ptr UncheckedArray[ECP_ShortW_Aff[Fp[C], G1]], N: int - ) {.meter.} = + ) {.noinline, tags:[Alloca], meter.} = ## Generic Miller Loop for BN curves ## Computes f{6u+2,Q}(P) with u the BN curve parameter - var - Ts = allocStackArray(ECP_ShortW_Prj[Fp2[C], G2], N) - line0 {.noInit.}, line1 {.noInit.}: Line[Fp2[C]] - + var Ts = allocStackArray(ECP_ShortW_Prj[Fp2[C], G2], N) for i in 0 ..< N: Ts[i].fromAffine(Qs[i]) - basicMillerLoop( - f, line0, line1, Ts, - Ps, Qs, N, - pairing(C, ate_param), pairing(C, ate_param_isNeg) - ) + basicMillerLoop(f, Ts, Ps, Qs, N, pairing(C, ate_param)) + + when pairing(C, ate_param_is_neg): + f.conj() + for i in 0 ..< N: + Ts[i].neg() # Ate pairing for BN curves needs adjustment after basic Miller loop for i in 0 ..< N: - f.millerCorrectionBN(Ts[i], Qs[i], Ps[i], pairing(C, ate_param_isNeg)) + f.millerCorrectionBN(Ts[i], Qs[i], Ps[i]) func finalExpGeneric[C: static Curve](f: var Fp12[C]) = ## A generic and slow implementation of final exponentiation @@ -180,7 +171,7 @@ func pairing_bn*[C]( when C == BN254_Nogami: gt.millerLoopAddChain(Q, P) else: - gt.millerLoopGenericBN(P, Q) + gt.millerLoopGenericBN(Q, P) gt.finalExpEasy() gt.finalExpHard_BN() @@ -196,6 +187,6 @@ func pairing_bn*[N: static int, C]( when C == BN254_Nogami: gt.millerLoopAddChain(Qs.asUnchecked(), Ps.asUnchecked(), N) else: - gt.millerLoopGenericBN(Ps.asUnchecked(), Qs.asUnchecked(), N) + gt.millerLoopGenericBN(Qs.asUnchecked(), Ps.asUnchecked(), N) gt.finalExpEasy() gt.finalExpHard_BN() diff --git a/constantine/math/pairings/pairings_bw6_761.nim b/constantine/math/pairings/pairings_bw6_761.nim index 071874f..b63273b 100644 --- a/constantine/math/pairings/pairings_bw6_761.nim +++ b/constantine/math/pairings/pairings_bw6_761.nim @@ -33,20 +33,16 @@ export zoo_pairings # generic sandwich https://github.com/nim-lang/Nim/issues/11 func millerLoopBW6_761_naive[C]( f: var Fp6[C], - P: ECP_ShortW_Aff[Fp[C], G1], - Q: ECP_ShortW_Aff[Fp[C], G2] + Q: ECP_ShortW_Aff[Fp[C], G2], + P: ECP_ShortW_Aff[Fp[C], G1] ) = ## Miller Loop for BW6_761 curve ## Computes f_{u+1,Q}(P)*Frobenius(f_{u*(u^2-u-1),Q}(P)) - - var - T {.noInit.}: ECP_ShortW_Prj[Fp[C], G2] - line {.noInit.}: Line[Fp[C]] - + var T {.noInit.}: ECP_ShortW_Prj[Fp[C], G2] T.fromAffine(Q) basicMillerLoop( - f, line, T, + f, T, P, Q, pairing(C, ate_param_1_unopt), pairing(C, ate_param_1_unopt_isNeg) ) @@ -55,7 +51,7 @@ func millerLoopBW6_761_naive[C]( T.fromAffine(Q) basicMillerLoop( - f2, line, T, + f2, T, P, Q, pairing(C, ate_param_2_unopt), pairing(C, ate_param_2_unopt_isNeg) ) @@ -79,16 +75,15 @@ func finalExpHard_BW6_761*[C: static Curve](f: var Fp6[C]) = func millerLoopBW6_761_opt_to_debug[C]( f: var Fp6[C], - P: ECP_ShortW_Aff[Fp[C], G1], - Q: ECP_ShortW_Aff[Fp[C], G2] + Q: ECP_ShortW_Aff[Fp[C], G2], + P: ECP_ShortW_Aff[Fp[C], G1] ) {.used.} = ## Miller Loop Otpimized for BW6_761 curve # 1st part: f_{u,Q}(P) # ------------------------------ - var - T {.noInit.}: ECP_ShortW_Prj[Fp[C], G2] - line {.noInit.}: Line[Fp[C]] + var T {.noInit.}: ECP_ShortW_Prj[Fp[C], G2] + var line {.noInit.}: Line[Fp[C]] T.fromAffine(Q) f.setOne() @@ -161,6 +156,6 @@ func pairing_bw6_761_reference*[C]( ## ## Reference implementation {.error: "BW6_761 Miller loop is not working yet".} - gt.millerLoopBW6_761_naive(P, Q) + gt.millerLoopBW6_761_naive(Q, P) gt.finalExpEasy() gt.finalExpHard_BW6_761() \ No newline at end of file diff --git a/constantine/math/pairings/pairings_generic.nim b/constantine/math/pairings/pairings_generic.nim index 291b5bd..d1847e8 100644 --- a/constantine/math/pairings/pairings_generic.nim +++ b/constantine/math/pairings/pairings_generic.nim @@ -21,11 +21,11 @@ func pairing*[C](gt: var Fp12[C], P, Q: auto) {.inline.} = else: {.error: "Pairing not implemented for " & $C.} -func millerLoop*[C](gt: var Fp12[C], P, Q: auto, n: int) {.inline.} = +func millerLoop*[C](gt: var Fp12[C], Q, P: auto, n: int) {.inline.} = when C == BN254_Snarks: - gt.millerLoopGenericBN(P, Q, n) + gt.millerLoopGenericBN(Q, P, n) else: - gt.millerLoopAddchain(P, Q, n) + gt.millerLoopAddchain(Q, P, n) func finalExp*[C](gt: var Fp12[C]){.inline.} = gt.finalExpEasy() diff --git a/constantine/platforms/abstractions.nim b/constantine/platforms/abstractions.nim index 13f13a2..b4f7436 100644 --- a/constantine/platforms/abstractions.nim +++ b/constantine/platforms/abstractions.nim @@ -54,4 +54,181 @@ const const CttASM {.booldefine.} = true const UseASM_X86_32* = CttASM and X86 and GCC_Compatible -const UseASM_X86_64* = WordBitWidth == 64 and UseASM_X86_32 \ No newline at end of file +const UseASM_X86_64* = WordBitWidth == 64 and UseASM_X86_32 + +# We use Nim effect system to track vartime subroutines +type VarTime* = object + +# ############################################################ +# +# Signed Secret Words +# +# ############################################################ + +type SignedSecretWord* = distinct SecretWord + +when sizeof(int) == 8 and not defined(Constantine32): + type + SignedBaseType* = int64 +else: + type + SignedBaseType* = int32 + +template fmap(x: SignedSecretWord, op: untyped, y: SignedSecretWord): SignedSecretWord = + ## Unwrap x and y from their distinct type + ## Apply op, and rewrap them + SignedSecretWord(op(SecretWord(x), SecretWord(y))) + +template fmapAsgn(x: var SignedSecretWord, op: untyped, y: SignedSecretWord) = + ## Unwrap x and y from their distinct type + ## Apply assignment op, and rewrap them + op(cast[var SecretWord](x.addr), SecretWord(y)) + +template `and`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `and`, y) +template `or`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `or`, y) +template `xor`*(x, y: SignedSecretWord): SignedSecretWord = SignedSecretWord(BaseType(x) xor BaseType(y)) +template `not`*(x: SignedSecretWord): SignedSecretWord = SignedSecretWord(not SecretWord(x)) +template `+`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `+`, y) +template `+=`*(x: var SignedSecretWord, y: SignedSecretWord) = fmapAsgn(x, `+=`, y) +template `-`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `-`, y) +template `-=`*(x: var SignedSecretWord, y: SignedSecretWord) = fmapAsgn(x, `-=`, y) + +template `-`*(x: SignedSecretWord): SignedSecretWord = + # We don't use Nim signed integers to avoid range checks + SignedSecretWord(-SecretWord(x)) + +template `*`*(x, y: SignedSecretWord): SignedSecretWord = + # Warning ⚠️ : We assume that hardware multiplication is constant time + # but this is not always true. See https://www.bearssl.org/ctmul.html + fmap(x, `*`, y) + +# shifts +template ashr*(x: SignedSecretWord, y: SomeNumber): SignedSecretWord = + ## Arithmetic right shift + # We need to cast to Nim ints without Nim checks + cast[SignedSecretWord](cast[SignedBaseType](x).ashr(y)) + +template lshr*(x: SignedSecretWord, y: SomeNumber): SignedSecretWord = + ## Logical right shift + SignedSecretWord(SecretWord(x) shr y) + +template lshl*(x: SignedSecretWord, y: SomeNumber): SignedSecretWord = + ## Logical left shift + SignedSecretWord(SecretWord(x) shl y) + +# Hardened Boolean primitives +# --------------------------- + +template `==`*(x, y: SignedSecretWord): SecretBool = + SecretWord(x) == SecretWord(y) + +# Conditional arithmetic +# ---------------------- + +func isNeg*(a: SignedSecretWord): SignedSecretWord {.inline.} = + ## Returns 1 if a is negative + ## and 0 otherwise + a.lshr(WordBitWidth-1) + +func isOdd*(a: SignedSecretWord): SignedSecretWord {.inline.} = + ## Returns 1 if a is odd + ## and 0 otherwise + a and SignedSecretWord(1) + +func isZeroMask*(a: SignedSecretWord): SignedSecretWord {.inline.} = + ## Produce the -1 mask if a is 0 + ## and 0 otherwise + # In x86 assembly, we can use "neg" + "sbb" + -SignedSecretWord(a.SecretWord().isZero()) + +func isNegMask*(a: SignedSecretWord): SignedSecretWord {.inline.} = + ## Produce the -1 mask if a is negative + ## and 0 otherwise + a.ashr(WordBitWidth-1) + +func isOddMask*(a: SignedSecretWord): SignedSecretWord {.inline.} = + ## Produce the -1 mask if a is odd + ## and 0 otherwise + -(a and SignedSecretWord(1)) + +func isInRangeMask*(val, lo, hi: SignedSecretWord): SignedSecretWord {.inline.} = + ## Produce 0b11111111 mask if lo <= val <= hi (inclusive range) + ## and 0b00000000 otherwise + let loInvMask = isNegMask(val-lo) # if val-lo < 0 => val < lo + let hiInvMask = isNegMask(hi-val) # if hi-val < 0 => val > hi + return not(loInvMask or hiInvMask) + +func csetZero*(a: var SignedSecretWord, mask: SignedSecretWord) {.inline.} = + ## Conditionally set `a` to 0 + ## mask must be 0 (0x00000...0000) (kept as is) + ## or -1 (0xFFFF...FFFF) (zeroed) + a = a and mask + +func cneg*( + a: SignedSecretWord, + mask: SignedSecretWord): SignedSecretWord {.inline.} = + ## Conditionally negate `a` + ## mask must be 0 (0x00000...0000) (no negation) + ## or -1 (0xFFFF...FFFF) (negation) + (a xor mask) - mask + +func cadd*( + a: var SignedSecretWord, + b: SignedSecretWord, + mask: SignedSecretWord) {.inline.} = + ## Conditionally add `b` to `a` + ## mask must be 0 (0x00000...0000) (no addition) + ## or -1 (0xFFFF...FFFF) (addition) + a = a + (b and mask) + +func csub*( + a: var SignedSecretWord, + b: SignedSecretWord, + mask: SignedSecretWord) {.inline.} = + ## Conditionally substract `b` from `a` + ## mask must be 0 (0x00000...0000) (no substraction) + ## or -1 (0xFFFF...FFFF) (substraction) + a = a - (b and mask) + +# Double-Width signed arithmetic +# ------------------------------ + +type DSWord* = object + lo*, hi*: SignedSecretWord + +func smulAccNoCarry*(r: var DSWord, a, b: SignedSecretWord) {.inline.}= + ## Signed accumulated multiplication + ## (_, hi, lo) += a*b + ## This assumes no overflowing + var UV: array[2, SecretWord] + var carry: Carry + smul(UV[1], UV[0], SecretWord a, SecretWord b) + addC(carry, UV[0], UV[0], SecretWord r.lo, Carry(0)) + addC(carry, UV[1], UV[1], SecretWord r.hi, carry) + + r.lo = SignedSecretWord UV[0] + r.hi = SignedSecretWord UV[1] + +func ssumprodAccNoCarry*(r: var DSWord, a, u, b, v: SignedSecretWord) {.inline.}= + ## Accumulated sum of products + ## (_, hi, lo) += a*u + b*v + ## This assumes no overflowing + var carry: Carry + var x1, x0, y1, y0: SecretWord + smul(x1, x0, SecretWord a, SecretWord u) + addC(carry, x0, x0, SecretWord r.lo, Carry(0)) + addC(carry, x1, x1, SecretWord r.hi, carry) + smul(y1, y0, SecretWord b, SecretWord v) + addC(carry, x0, x0, y0, Carry(0)) + addC(carry, x1, x1, y1, carry) + + r.lo = SignedSecretWord x0 + r.hi = SignedSecretWord x1 + +func ashr*( + r: var DSWord, + k: SomeInteger) {.inline.} = + ## Arithmetic right-shift of a double-word + ## This does not normalize the excess bits + r.lo = r.lo.lshr(k) or r.hi.lshl(WordBitWidth - k) + r.hi = r.hi.ashr(k) \ No newline at end of file diff --git a/constantine/platforms/allocs.nim b/constantine/platforms/allocs.nim index cf68176..36ebb3b 100644 --- a/constantine/platforms/allocs.nim +++ b/constantine/platforms/allocs.nim @@ -23,32 +23,37 @@ # # stack allocation is strongly preferred where necessary. +# We use Nim effect system to track allocating subroutines +type + Alloca* = object + HeapAlloc* = object + # Bindings # ---------------------------------------------------------------------------------- # We wrap them with int instead of size_t / csize_t when defined(windows): - proc alloca(size: int): pointer {.header: "".} + proc alloca(size: int): pointer {.tags:[Alloca], header: "".} else: - proc alloca(size: int): pointer {.header: "".} + proc alloca(size: int): pointer {.tags:[Alloca], header: "".} -proc malloc(size: int): pointer {.sideeffect, header: "".} -proc free(p: pointer) {.sideeffect, header: "".} +proc malloc(size: int): pointer {.tags:[HeapAlloc], header: "".} +proc free(p: pointer) {.tags:[HeapAlloc], header: "".} when defined(windows): - proc aligned_alloc_windows(size, alignment: int): pointer {.sideeffect,importc:"_aligned_malloc", header:"".} + proc aligned_alloc_windows(size, alignment: int): pointer {.tags:[HeapAlloc],importc:"_aligned_malloc", header:"".} # Beware of the arg order! proc aligned_alloc(alignment, size: int): pointer {.inline.} = aligned_alloc_windows(size, alignment) - proc aligned_free(p: pointer){.sideeffect,importc:"_aligned_free", header:"".} + proc aligned_free(p: pointer){.tags:[HeapAlloc],importc:"_aligned_free", header:"".} elif defined(osx): - proc posix_memalign(mem: var pointer, alignment, size: int){.sideeffect,importc, header:"".} + proc posix_memalign(mem: var pointer, alignment, size: int){.tags:[HeapAlloc],importc, header:"".} proc aligned_alloc(alignment, size: int): pointer {.inline.} = posix_memalign(result, alignment, size) - proc aligned_free(p: pointer) {.sideeffect, importc: "free", header: "".} + proc aligned_free(p: pointer) {.tags:[HeapAlloc], importc: "free", header: "".} else: - proc aligned_alloc(alignment, size: int): pointer {.sideeffect,importc, header:"".} - proc aligned_free(p: pointer) {.sideeffect, importc: "free", header: "".} + proc aligned_alloc(alignment, size: int): pointer {.tags:[HeapAlloc],importc, header:"".} + proc aligned_free(p: pointer) {.tags:[HeapAlloc], importc: "free", header: "".} # Helpers # ---------------------------------------------------------------------------------- diff --git a/constantine/platforms/bithacks.nim b/constantine/platforms/bithacks.nim index c22f811..85e972b 100644 --- a/constantine/platforms/bithacks.nim +++ b/constantine/platforms/bithacks.nim @@ -57,7 +57,7 @@ func log2_impl_vartime(n: uint32): uint32 = 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31] - + # Isolate MSB var n = n n = n or n shr 1 # first round down to one less than a power of 2 @@ -83,7 +83,7 @@ func log2_impl_vartime(n: uint64): uint64 {.inline.} = 36, 17, 19, 29, 10, 13, 21, 56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5, 63] - + # Isolate MSB var n = n n = n or n shr 1 # first round down to one less than a power of 2 @@ -113,7 +113,7 @@ func ctz_impl_vartime(n: uint32): uint32 = 30, 20, 18, 11, 13, 4, 7, 23, 31, 15, 28, 21, 19, 10, 12, 6, 14, 27, 9, 5, 26, 8, 25, 24] - + let isolateLSB = n xor (n-1) uint32 lookup[(isolateLSB * 0x6EB14F9'u32) shr 27] @@ -134,7 +134,7 @@ func ctz_impl_vartime(n: uint64): uint64 = let isolateLSB = n xor (n-1) uint64 lookup[(isolateLSB * 0x03f79d71b4cb0a89'u64) shr 58] -func countTrailingZeroBits*[T: SomeUnsignedInt](n: T): T {.inline.} = +func countTrailingZeroBits_vartime*[T: SomeUnsignedInt](n: T): T {.inline.} = ## Count the number of trailing zero bits of an integer when nimvm: if n == 0: @@ -151,7 +151,7 @@ func isPowerOf2_vartime*(n: SomeUnsignedInt): bool {.inline.} = ## Returns true if n is a power of 2 ## ⚠️ Result is bool instead of Secretbool, ## for compile-time or explicit vartime proc only. - (n and (n - 1)) == 0 + (n and (n - 1)) == 0 and n > 0 func nextPowerOfTwo_vartime*(n: uint32): uint32 {.inline.} = ## Returns x if x is a power of 2 diff --git a/constantine/platforms/codecs.nim b/constantine/platforms/codecs.nim index 0475f45..e69c85e 100644 --- a/constantine/platforms/codecs.nim +++ b/constantine/platforms/codecs.nim @@ -6,7 +6,7 @@ # * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). # at your option. This file may not be copied, modified, or distributed except according to those terms. -import ./abstractions, ./signed_secret_words +import ./abstractions # ############################################################ # diff --git a/constantine/platforms/compilers/compiler_optim_hints.nim b/constantine/platforms/compilers/compiler_optim_hints.nim new file mode 100644 index 0000000..e8f3448 --- /dev/null +++ b/constantine/platforms/compilers/compiler_optim_hints.nim @@ -0,0 +1,151 @@ +# Laser & Arraymancer +# Copyright (c) 2017-2018 Mamy André-Ratsimbazafy +# Distributed under the Apache v2 License (license terms are at http://www.apache.org/licenses/LICENSE-2.0). +# This file may not be copied, modified, or distributed except according to those terms. + +const LASER_MEM_ALIGN*{.intdefine.} = 64 +static: + assert LASER_MEM_ALIGN != 0, "Alignment " & $LASER_MEM_ALIGN & "must be a power of 2" + assert (LASER_MEM_ALIGN and (LASER_MEM_ALIGN - 1)) == 0, "Alignment " & $LASER_MEM_ALIGN & "must be a power of 2" + +template withCompilerOptimHints*() = + # See https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html + # and https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#Common-Variable-Attributes + + # Variable is created aligned by LASER_MEM_ALIGN. + # This is useful to ensure an object can be loaded + # in a minimum amount of cache lines load + # For example, the stack part of tensors are 128 bytes and can be loaded in 2 cache lines + # but would require 3 loads if they are misaligned. + when defined(vcc): + {.pragma: align_variable, codegenDecl: "__declspec(align(" & $LASER_MEM_ALIGN & ")) $# $#".} + else: + {.pragma: align_variable, codegenDecl: "$# $# __attribute__((aligned(" & $LASER_MEM_ALIGN & ")))".} + + # Variable. Pointer does not alias any existing valid pointers. + when not defined(vcc): + {.pragma: restrict, codegenDecl: "$# __restrict__ $#".} + else: + {.pragma: restrict, codegenDecl: "$# __restrict $#".} + +const withBuiltins = defined(gcc) or defined(clang) or defined(icc) + +type + PrefetchRW* {.size: cint.sizeof.} = enum + Read = 0 + Write = 1 + PrefetchLocality* {.size: cint.sizeof.} = enum + NoTemporalLocality = 0 # Data can be discarded from CPU cache after access + LowTemporalLocality = 1 + ModerateTemporalLocality = 2 + HighTemporalLocality = 3 # Data should be left in all levels of cache possible + # Translation + # 0 - use no cache eviction level + # 1 - L1 cache eviction level + # 2 - L2 cache eviction level + # 3 - L1 and L2 cache eviction level + +when withBuiltins: + proc builtin_assume_aligned(data: pointer, alignment: csize_t): pointer {.importc: "__builtin_assume_aligned", noDecl.} + proc builtin_prefetch(data: pointer, rw: PrefetchRW, locality: PrefetchLocality) {.importc: "__builtin_prefetch", noDecl.} + +when defined(cpp): + proc static_cast[T: ptr](input: pointer): T + {.importcpp: "static_cast<'0>(@)".} + +template assume_aligned*[T](data: ptr T, alignment: static int = LASER_MEM_ALIGN): ptr T = + when defined(cpp) and withBuiltins: # builtin_assume_aligned returns void pointers, this does not compile in C++, they must all be typed + static_cast[ptr T](builtin_assume_aligned(data, alignment)) + elif withBuiltins: + cast[ptr T](builtin_assume_aligned(data, alignment)) + else: + data + +template prefetch*( + data: ptr or pointer, + rw: static PrefetchRW = Read, + locality: static PrefetchLocality = HighTemporalLocality) = + ## Prefetch examples: + ## - https://scripts.mit.edu/~birge/blog/accelerating-code-using-gccs-prefetch-extension/ + ## - https://stackoverflow.com/questions/7327994/prefetching-examples + ## - https://lemire.me/blog/2018/04/30/is-software-prefetching-__builtin_prefetch-useful-for-performance/ + ## - https://www.naftaliharris.com/blog/2x-speedup-with-one-line-of-code/ + when withBuiltins: + builtin_prefetch(data, rw, locality) + else: + discard + +template pragma_ivdep() {.used.}= + ## Tell the compiler to ignore unproven loop dependencies + ## such as "a[i] = a[i + k] * c;" if k is unknown, as it introduces a loop + ## dependency if it's negative + ## https://software.intel.com/en-us/node/524501 + ## + ## Placeholder + # We don't expose that as it only works on C for loop. Nim only generates while loop + # except when using OpenMP. But the OpenMP "simd" already achieves the same as ivdep. + when defined(gcc): + {.emit: "#pragma GCC ivdep".} + else: # Supported on ICC and Cray + {.emit: "pragma ivdep".} + +template withCompilerFunctionHints() {.used.}= + ## Not exposed, Nim codegen will declare them as normal C function. + ## This messes up with N_NIMCALL, N_LIB_PRIVATE, N_INLINE and also + ## creates duplicate symbols when one function called by a hot or pure function + ## is public and inline (because hot and pure cascade to all cunfctions called) + ## and they cannot be stacked easily: (hot, pure) will only apply the last + + # Function. Returned pointer is aligned to LASER_MEM_ALIGN + {.pragma: aligned_ptr_result, codegenDecl: "__attribute__((assume_aligned(" & $LASER_MEM_ALIGN & ")) $# $#$#".} + + # Function. Returned pointer cannot alias any other valid pointer and no pointers to valid object occur in any + # storage pointed to. + {.pragma: malloc, codegenDecl: "__attribute__((malloc)) $# $#$#".} + + # Function. Creates one or more function versions that can process multiple arguments using SIMD. + # Ignored when -fopenmp is used and within an OpenMP simd loop + {.pragma: simd, codegenDecl: "__attribute__((simd)) $# $#$#".} + + # Function. Indicates hot and cold path. Ignored when using profile guided optimization. + {.pragma: hot, codegenDecl: "__attribute__((hot)) $# $#$#".} + {.pragma: cold, codegenDecl: "__attribute__((cold)) $# $#$#".} + + # ## pure and const + # ## Affect Common Sub-expression Elimination, Dead Code Elimination and loop optimization. + # See + # - https://lwn.net/Articles/285332/ + # - http://benyossef.com/helping-the-compiler-help-you/ + # + # Function. The function only accesses its input params and global variables state. + # It does not modify any global, calling it multiple times with the same params + # and global variables will produce the same result. + {.pragma: gcc_pure, codegenDecl: "__attribute__((pure)) $# $#$#".} + # + # Function. The function only accesses its input params and calling it multiple times + # with the same params will produce the same result. + # Warning ⚠: + # Pointer inputs must not be dereferenced to read the memory pointed to. + # In Nim stack arrays are passed by pointers and big stack data structures + # are passed by reference as well. I.e. Result unknown. + {.pragma: gcc_const, codegenDecl: "__attribute__((const)) $# $#$#".} + + # We don't define per-function fast-math, GCC attribute optimize is broken: + # --> https://gcc.gnu.org/ml/gcc/2009-10/msg00402.html + # + # Workaround floating point latency for algorithms like sum + # should be done manually. + # + # See : https://stackoverflow.com/questions/39095993/does-each-floating-point-operation-take-the-same-time + # and https://www.agner.org/optimize/vectorclass.pdf "Using multiple accumulators" + # + # FP addition has a latency of 3~5 clock cycles, i.e. the result cannot be reused for that much time. + # But the throughput is 1 FP add per clock cycle (and even 2 per clock cycle for Skylake) + # So we need to use extra accumulators to fully utilize the FP throughput despite FP latency. + # On Skylake, all FP latencies are 4: https://www.agner.org/optimize/blog/read.php?i=415 + # + # Note that this is per CPU cores, each core needs its own "global CPU accumulator" to combat + # false sharing when multithreading. + # + # This wouldn't be needed with fast-math because compiler would consider FP addition associative + # and create intermediate variables as needed to exploit this through put. diff --git a/constantine/platforms/constant_time/ct_routines.nim b/constantine/platforms/constant_time/ct_routines.nim index be0f153..596cdfa 100644 --- a/constantine/platforms/constant_time/ct_routines.nim +++ b/constantine/platforms/constant_time/ct_routines.nim @@ -112,13 +112,7 @@ template `*=`*[T: Ct](x, y: T) = template `-`*[T: Ct](x: T): T = ## Unary minus returns the two-complement representation ## of an unsigned integer - # We could use "not(x) + 1" but the codegen is not optimal - when nimvm: - not(x) + T(1) - else: # Use C so that compiler uses the "neg" instructions - var neg: T - {.emit:[neg, " = -", x, ";"].} - neg + T(0) - x # ############################################################ # @@ -175,19 +169,6 @@ template cneg*[T: Ct](x: T, ctl: CTBool[T]): T = # Conditional negate if ctl is true (x xor -T(ctl)) + T(ctl) -# ############################################################ -# -# Workaround system.nim `!=` template -# -# ############################################################ - -# system.nim defines `!=` as a catchall template -# in terms of `==` while we define `==` in terms of `!=` -# So we would have not(not(noteq(x,y))) - -template trmFixSystemNotEq*{x != y}[T: Ct](x, y: T): CTBool[T] = - noteq(x, y) - # ############################################################ # # Table lookups @@ -217,15 +198,3 @@ template isNonZero*[T: Ct](x: T): CTBool[T] = template isZero*[T: Ct](x: T): CTBool[T] = # In x86 assembly, we can use "neg" + "adc" not isNonZero(x) - -# ############################################################ -# -# Transform x == 0 and x != 0 -# into their optimized version -# -# ############################################################ - -template trmIsZero*{x == 0}[T: Ct](x: T): CTBool[T] = x.isZero -template trmIsZero*{0 == x}[T: Ct](x: T): CTBool[T] = x.isZero -template trmIsNonZero*{x != 0}[T: Ct](x: T): CTBool[T] = x.isNonZero -template trmIsNonZero*{0 != x}[T: Ct](x: T): CTBool[T] = x.isNonZero diff --git a/constantine/platforms/primitives.nim b/constantine/platforms/primitives.nim index be8a25d..fc98b59 100644 --- a/constantine/platforms/primitives.nim +++ b/constantine/platforms/primitives.nim @@ -15,10 +15,12 @@ import ], compilers/[ addcarry_subborrow, - extended_precision + extended_precision, + compiler_optim_hints ], ./bithacks, - ./static_for + ./static_for, + ./allocs export ct_types, @@ -28,7 +30,9 @@ export extended_precision, ct_division, bithacks, - staticFor + staticFor, + allocs, + compiler_optim_hints when X86 and GCC_Compatible: import isa/[cpuinfo_x86, macro_assembler_x86] @@ -48,6 +52,9 @@ template debug*(body: untyped): untyped = when defined(debugConstantine): body +func unreachable*() {.noReturn.} = + doAssert false, "Unreachable" + # ############################################################ # # Buffers @@ -111,10 +118,22 @@ template asUnchecked*[T](a: openArray[T]): ptr UncheckedArray[T] = # to a function as `var` are passed by hidden pointers in Nim and the wrong # pointer will be modified. Templates are fine. -func `+%`*(p: ptr, offset: SomeInteger): type(p) {.inline, noInit.}= +func `+%`*(p: ptr or pointer, offset: SomeInteger): type(p) {.inline, noInit.}= ## Pointer increment {.emit: [result, " = ", p, " + ", offset, ";"].} -func `+%=`*(p: var ptr, offset: SomeInteger){.inline.}= +func `+%=`*(p: var (ptr or pointer), offset: SomeInteger){.inline.}= ## Pointer increment - p = p +% offset \ No newline at end of file + p = p +% offset + +func prefetchLarge*[T]( + data: ptr T, + rw: static PrefetchRW = Read, + locality: static PrefetchLocality = HighTemporalLocality, + maxCacheLines: static int = 0) {.inline.} = + ## Prefetch a large value + let pdata = pointer(data) + const span = sizeof(T) div 64 # 64 byte cache line + const N = if maxCacheLines == 0: span else: min(span, maxCacheLines) + for i in 0 ..< N: + prefetch(pdata +% (i*64), rw, locality) \ No newline at end of file diff --git a/constantine/platforms/signed_secret_words.nim b/constantine/platforms/signed_secret_words.nim deleted file mode 100644 index 4fd50c5..0000000 --- a/constantine/platforms/signed_secret_words.nim +++ /dev/null @@ -1,195 +0,0 @@ -# Constantine -# Copyright (c) 2018-2019 Status Research & Development GmbH -# Copyright (c) 2020-Present Mamy André-Ratsimbazafy -# Licensed and distributed under either of -# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). -# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). -# at your option. This file may not be copied, modified, or distributed except according to those terms. - -import ./abstractions - -type SignedSecretWord* = distinct SecretWord - -when sizeof(int) == 8 and not defined(Constantine32): - type - SignedBaseType* = int64 -else: - type - SignedBaseType* = int32 - -# ############################################################ -# -# Arithmetic -# -# ############################################################ - -template fmap(x: SignedSecretWord, op: untyped, y: SignedSecretWord): SignedSecretWord = - ## Unwrap x and y from their distinct type - ## Apply op, and rewrap them - SignedSecretWord(op(SecretWord(x), SecretWord(y))) - -template fmapAsgn(x: SignedSecretWord, op: untyped, y: SignedSecretWord) = - ## Unwrap x and y from their distinct type - ## Apply assignment op, and rewrap them - op(SecretWord(x), SecretWord(y)) - -template `and`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `and`, y) -template `or`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `or`, y) -template `xor`*(x, y: SignedSecretWord): SignedSecretWord = SignedSecretWord(BaseType(x) xor BaseType(y)) -template `not`*(x: SignedSecretWord): SignedSecretWord = SignedSecretWord(not SecretWord(x)) -template `+`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `+`, y) -template `+=`*(x: var SignedSecretWord, y: SignedSecretWord) = fmapAsgn(x, `+=`, y) -template `-`*(x, y: SignedSecretWord): SignedSecretWord = fmap(x, `-`, y) -template `-=`*(x: var SignedSecretWord, y: SignedSecretWord) = fmapAsgn(x, `-=`, y) - -template `-`*(x: SignedSecretWord): SignedSecretWord = - # We don't use Nim signed integers to avoid range checks - SignedSecretWord(-SecretWord(x)) - -template `*`*(x, y: SignedSecretWord): SignedSecretWord = - # Warning ⚠️ : We assume that hardware multiplication is constant time - # but this is not always true. See https://www.bearssl.org/ctmul.html - fmap(x, `*`, y) - -# shifts -template ashr*(x: SignedSecretWord, y: SomeNumber): SignedSecretWord = - ## Arithmetic right shift - # We need to cast to Nim ints without Nim checks - cast[SignedSecretWord](cast[SignedBaseType](x).ashr(y)) - -template lshr*(x: SignedSecretWord, y: SomeNumber): SignedSecretWord = - ## Logical right shift - SignedSecretWord(SecretWord(x) shr y) - -template lshl*(x: SignedSecretWord, y: SomeNumber): SignedSecretWord = - ## Logical left shift - SignedSecretWord(SecretWord(x) shl y) - -# ############################################################ -# -# Hardened Boolean primitives -# -# ############################################################ - -template `==`*(x, y: SignedSecretWord): SecretBool = - SecretWord(x) == SecretWord(y) - -# ############################################################ -# -# Conditional arithmetic -# -# ############################################################ - -# SignedSecretWord -# ---------------- - -func isNeg*(a: SignedSecretWord): SignedSecretWord {.inline.} = - ## Returns 1 if a is negative - ## and 0 otherwise - a.lshr(WordBitWidth-1) - -func isOdd*(a: SignedSecretWord): SignedSecretWord {.inline.} = - ## Returns 1 if a is odd - ## and 0 otherwise - a and SignedSecretWord(1) - -func isZeroMask*(a: SignedSecretWord): SignedSecretWord {.inline.} = - ## Produce the -1 mask if a is 0 - ## and 0 otherwise - # In x86 assembly, we can use "neg" + "sbb" - -SignedSecretWord(a.SecretWord().isZero()) - -func isNegMask*(a: SignedSecretWord): SignedSecretWord {.inline.} = - ## Produce the -1 mask if a is negative - ## and 0 otherwise - a.ashr(WordBitWidth-1) - -func isOddMask*(a: SignedSecretWord): SignedSecretWord {.inline.} = - ## Produce the -1 mask if a is odd - ## and 0 otherwise - -(a and SignedSecretWord(1)) - -func isInRangeMask*(val, lo, hi: SignedSecretWord): SignedSecretWord {.inline.} = - ## Produce 0b11111111 mask if lo <= val <= hi (inclusive range) - ## and 0b00000000 otherwise - let loInvMask = isNegMask(val-lo) # if val-lo < 0 => val < lo - let hiInvMask = isNegMask(hi-val) # if hi-val < 0 => val > hi - return not(loInvMask or hiInvMask) - -func csetZero*(a: var SignedSecretWord, mask: SignedSecretWord) {.inline.} = - ## Conditionally set `a` to 0 - ## mask must be 0 (0x00000...0000) (kept as is) - ## or -1 (0xFFFF...FFFF) (zeroed) - a = a and mask - -func cneg*( - a: SignedSecretWord, - mask: SignedSecretWord): SignedSecretWord {.inline.} = - ## Conditionally negate `a` - ## mask must be 0 (0x00000...0000) (no negation) - ## or -1 (0xFFFF...FFFF) (negation) - (a xor mask) - mask - -func cadd*( - a: var SignedSecretWord, - b: SignedSecretWord, - mask: SignedSecretWord) {.inline.} = - ## Conditionally add `b` to `a` - ## mask must be 0 (0x00000...0000) (no addition) - ## or -1 (0xFFFF...FFFF) (addition) - a = a + (b and mask) - -func csub*( - a: var SignedSecretWord, - b: SignedSecretWord, - mask: SignedSecretWord) {.inline.} = - ## Conditionally substract `b` from `a` - ## mask must be 0 (0x00000...0000) (no substraction) - ## or -1 (0xFFFF...FFFF) (substraction) - a = a - (b and mask) - -# ############################################################ -# -# Double-Width signed arithmetic -# -# ############################################################ - -type DSWord* = object - lo*, hi*: SignedSecretWord - -func smulAccNoCarry*(r: var DSWord, a, b: SignedSecretWord) {.inline.}= - ## Signed accumulated multiplication - ## (_, hi, lo) += a*b - ## This assumes no overflowing - var UV: array[2, SecretWord] - var carry: Carry - smul(UV[1], UV[0], SecretWord a, SecretWord b) - addC(carry, UV[0], UV[0], SecretWord r.lo, Carry(0)) - addC(carry, UV[1], UV[1], SecretWord r.hi, carry) - - r.lo = SignedSecretWord UV[0] - r.hi = SignedSecretWord UV[1] - -func ssumprodAccNoCarry*(r: var DSWord, a, u, b, v: SignedSecretWord) {.inline.}= - ## Accumulated sum of products - ## (_, hi, lo) += a*u + b*v - ## This assumes no overflowing - var carry: Carry - var x1, x0, y1, y0: SecretWord - smul(x1, x0, SecretWord a, SecretWord u) - addC(carry, x0, x0, SecretWord r.lo, Carry(0)) - addC(carry, x1, x1, SecretWord r.hi, carry) - smul(y1, y0, SecretWord b, SecretWord v) - addC(carry, x0, x0, y0, Carry(0)) - addC(carry, x1, x1, y1, carry) - - r.lo = SignedSecretWord x0 - r.hi = SignedSecretWord x1 - -func ashr*( - r: var DSWord, - k: SomeInteger) {.inline.} = - ## Arithmetic right-shift of a double-word - ## This does not normalize the excess bits - r.lo = r.lo.lshr(k) or r.hi.lshl(WordBitWidth - k) - r.hi = r.hi.ashr(k) \ No newline at end of file diff --git a/constantine/signatures/bls_signatures.nim b/constantine/signatures/bls_signatures.nim index a44aa51..7d65692 100644 --- a/constantine/signatures/bls_signatures.nim +++ b/constantine/signatures/bls_signatures.nim @@ -9,7 +9,7 @@ import ../math/[ec_shortweierstrass, extension_fields], ../math/io/io_bigints, - ../math/elliptic/ec_shortweierstrass_batch_ops, + ../math/elliptic/ec_scalar_mul_vartime, ../math/pairings/[pairings_generic, miller_accumulators], ../math/constants/zoo_generators, ../math/config/curves, @@ -366,32 +366,6 @@ func init*[T0, T1: char|byte]( H.hash(ctx.secureBlinding, secureRandomBytes, accumSepTag) -func scalarMul_minHammingWeight_vartime[EC]( - P: var EC, - scalar: BigInt, - ) = - ## **Variable-time** Elliptic Curve Scalar Multiplication - ## - ## P <- [k] P - ## - ## This uses an online recoding with minimum Hamming Weight - ## (which is not NAF, NAF is least-significant bit to most) - ## Due to those scalars being 64-bit, window-method or endomorphism acceleration are slower - ## than double-and-add. - ## - ## This is highly VULNERABLE to timing attacks and power analysis attacks. - ## For our usecase, scaling with a random number not in attacker control, - ## leaking the scalar bits is not an issue. - var t0{.noInit.}: typeof(P) - t0.setInf() - for bit in recoding_l2r_vartime(scalar): - t0.double() - if bit == 1: - t0 += P - elif bit == -1: - t0 -= P - P = t0 - func update*[T: char|byte, Pubkey, Sig: ECP_ShortW_Aff]( ctx: var BLSBatchSigAccumulator, pubkey: Pubkey, @@ -456,8 +430,8 @@ func update*[T: char|byte, Pubkey, Sig: ECP_ShortW_Aff]( var randFactor{.noInit.}: BigInt[64] randFactor.unmarshal(ctx.secureBlinding.toOpenArray(0, 7), bigEndian) - pkG1_jac.scalarMul_minHammingWeight_vartime(randFactor) - sigG2_jac.scalarMul_minHammingWeight_vartime(randFactor) + pkG1_jac.scalarMul_minHammingWeight_windowed_vartime(randFactor, window = 3) + sigG2_jac.scalarMul_minHammingWeight_windowed_vartime(randFactor, window = 3) if ctx.aggSigOnce == false: ctx.aggSig = sigG2_jac @@ -492,8 +466,8 @@ func update*[T: char|byte, Pubkey, Sig: ECP_ShortW_Aff]( var randFactor{.noInit.}: BigInt[64] randFactor.unmarshal(ctx.secureBlinding.toOpenArray(0, 7), bigEndian) - hmsgG1_jac.scalarMul_minHammingWeight_vartime(randFactor) - sigG1_jac.scalarMul_minHammingWeight_vartime(randFactor) + hmsgG1_jac.scalarMul_minHammingWeight_windowed_vartime(randFactor, window = 3) + sigG1_jac.scalarMul_minHammingWeight_windowed_vartime(randFactor, window = 3) if ctx.aggSigOnce == false: ctx.aggSig = sigG1_jac @@ -571,7 +545,7 @@ func finalVerify*(ctx: var BLSBatchSigAccumulator): bool = func aggregate*[T: ECP_ShortW_Aff](r: var T, points: openarray[T]) = ## Aggregate pubkeys or signatures var accum {.noinit.}: ECP_ShortW_Jac[T.F, T.G] - accum.sum_batch_vartime(points) + accum.sum_reduce_vartime(points) r.affine(accum) func fastAggregateVerify*[B1, B2: byte|char, Pubkey, Sig]( diff --git a/helpers/prng_unsafe.nim b/helpers/prng_unsafe.nim index 194ddc2..44694b2 100644 --- a/helpers/prng_unsafe.nim +++ b/helpers/prng_unsafe.nim @@ -15,6 +15,7 @@ import ec_shortweierstrass_affine, ec_shortweierstrass_projective, ec_shortweierstrass_jacobian, + ec_shortweierstrass_jacobian_extended, ec_twistededwards_affine, ec_twistededwards_projective], ../constantine/math/io/io_bigints, @@ -153,10 +154,10 @@ func reduceViaMont[N: static int, F](reduced: var array[N, SecretWord], unreduce # so for 384-bit prime (6-words on 64-bit CPUs), so 6*6 = 36, twice for multiplication and reduction # significantly faster than division which works bit-by-bit due to constant-time requirement reduced.redc2xMont(unreduced, # a/R - F.fieldMod().limbs, F.getNegInvModWord(), + F.fieldMod().limbs, F.getNegInvModWord(), F.getSpareBits()) reduced.mulMont(reduced, F.getR2modP().limbs, # (a/R) * R² * R⁻¹ ≡ a (mod p) - F.fieldMod().limbs, F.getNegInvModWord(), + F.fieldMod().limbs, F.getNegInvModWord(), F.getSpareBits()) func random_unsafe(rng: var RngState, a: var Limbs) = @@ -282,19 +283,19 @@ func random_long01Seq(rng: var RngState, a: var ExtensionField) = # Elliptic curves # ------------------------------------------------------------ -type ECP = ECP_ShortW_Aff or ECP_ShortW_Prj or ECP_ShortW_Jac or +type ECP = ECP_ShortW_Aff or ECP_ShortW_Prj or ECP_ShortW_Jac or ECP_ShortW_JacExt or ECP_TwEdwards_Aff or ECP_TwEdwards_Prj -type ECP_ext = ECP_ShortW_Prj or ECP_ShortW_Jac or +type ECP_ext = ECP_ShortW_Prj or ECP_ShortW_Jac or ECP_ShortW_JacExt or ECP_TwEdwards_Prj template trySetFromCoord[F](a: ECP, fieldElem: F): SecretBool = - when a is (ECP_ShortW_Aff or ECP_ShortW_Prj or ECP_ShortW_Jac): + when a is (ECP_ShortW_Aff or ECP_ShortW_Prj or ECP_ShortW_Jac or ECP_ShortW_JacExt): trySetFromCoordX(a, fieldElem) else: trySetFromCoordY(a, fieldElem) template trySetFromCoords[F](a: ECP, fieldElem, scale: F): SecretBool = - when a is (ECP_ShortW_Prj or ECP_ShortW_Jac): + when a is (ECP_ShortW_Prj or ECP_ShortW_Jac or ECP_ShortW_JacExt): trySetFromCoordsXandZ(a, fieldElem, scale) else: trySetFromCoordsYandZ(a, fieldElem, scale) diff --git a/metering/m_msm.nim b/metering/m_msm.nim new file mode 100644 index 0000000..f5be392 --- /dev/null +++ b/metering/m_msm.nim @@ -0,0 +1,44 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + std/times, + ./reports, ./tracer, + ../constantine/math/config/curves, + ../constantine/math/[arithmetic, extension_fields, ec_shortweierstrass], + ../constantine/math/constants/zoo_subgroups, + ../constantine/math/elliptic/ec_multi_scalar_mul, + ../constantine/platforms/abstractions, + # Helpers + ../helpers/prng_unsafe + +var rng*: RngState +let seed = uint32(getTime().toUnix() and (1'i64 shl 32 - 1)) # unixTime mod 2^32 +rng.seed(seed) +echo "bench xoshiro512** seed: ", seed + +proc msmMeter*(EC: typedesc, numPoints: int) = + const bits = EC.F.C.getCurveOrderBitwidth() + var points = newSeq[ECP_ShortW_Aff[EC.F, EC.G]](numPoints) + var scalars = newSeq[BigInt[bits]](numPoints) + + for i in 0 ..< numPoints: + var tmp = rng.random_unsafe(EC) + tmp.clearCofactor() + points[i].affine(tmp) + scalars[i] = rng.random_unsafe(BigInt[bits]) + + var r{.noInit.}: EC + r.setinf() + resetMetering() + r.multiScalarMul_vartime(scalars, points) + +resetMetering() +msmMeter(ECP_ShortW_Jac[Fp[BLS12_381], G1], 10000) +const flags = if UseASM_X86_64 or UseASM_X86_32: "UseAssembly" else: "NoAssembly" +reportCli(Metrics, flags) diff --git a/metering/m_pairings.nim b/metering/m_pairings.nim index fff3f16..2480ae4 100644 --- a/metering/m_pairings.nim +++ b/metering/m_pairings.nim @@ -9,11 +9,11 @@ import std/times, ./reports, ./tracer, - ../constantine/math/config/[common, curves], - ../constantine/math/[arithmetic, extension_fields], - ../constantine/math/elliptic/ec_shortweierstrass_projective, + ../constantine/math/config/curves, + ../constantine/math/[arithmetic, extension_fields, ec_shortweierstrass], ../constantine/math/constants/zoo_subgroups, - ../constantine/math/pairings/pairings_bls12, + ../constantine/math/pairings/pairings_generic, + ../constantine/platforms/abstractions, # Helpers ../helpers/prng_unsafe @@ -22,19 +22,20 @@ let seed = uint32(getTime().toUnix() and (1'i64 shl 32 - 1)) # unixTime mod 2^32 rng.seed(seed) echo "bench xoshiro512** seed: ", seed -func random_point*(rng: var RngState, EC: typedesc): EC {.noInit.} = - result = rng.random_unsafe(EC) - result.clearCofactor() +func random_point*(rng: var RngState, EC: typedesc[ECP_ShortW_Aff]): EC {.noInit.} = + var jac = rng.random_unsafe(ECP_ShortW_Jac[EC.F, EC.G]) + jac.clearCofactor() + result.affine(jac) proc pairingBLS12Meter*(C: static Curve) = let - P = rng.random_point(ECP_ShortW_Prj[Fp[C], G1]) - Q = rng.random_point(ECP_ShortW_Prj[Fp2[C], G2]) + P = rng.random_point(ECP_ShortW_Aff[Fp[C], G1]) + Q = rng.random_point(ECP_ShortW_Aff[Fp2[C], G2]) var f: Fp12[C] resetMetering() - f.pairing_bls12(P, Q) + f.pairing(P, Q) resetMetering() pairingBLS12Meter(BLS12_381) diff --git a/metering/reports.nim b/metering/reports.nim index c8cdb65..96cf283 100644 --- a/metering/reports.nim +++ b/metering/reports.nim @@ -24,11 +24,11 @@ proc reportCli*(metrics: seq[Metadata], flags: string) = # https://www.agner.org/optimize/blog/read.php?i=838 echo "The CPU Cycle Count is indicative only. It cannot be used to compare across systems, works at your CPU nominal frequency and is sensitive to overclocking, throttling and frequency scaling (powersaving and Turbo Boost)." - const lineSep = &"""|{'-'.repeat(50)}|{'-'.repeat(14)}|{'-'.repeat(20)}|{'-'.repeat(15)}|{'-'.repeat(17)}|{'-'.repeat(26)}|{'-'.repeat(26)}|""" + const lineSep = &"""|{'-'.repeat(150)}|{'-'.repeat(14)}|{'-'.repeat(20)}|{'-'.repeat(15)}|{'-'.repeat(17)}|{'-'.repeat(26)}|{'-'.repeat(26)}|""" echo "\n" echo lineSep - echo &"""|{"Procedures":^50}|{"# of Calls":^14}|{"Throughput (ops/s)":^20}|{"Time (µs)":^15}|{"Avg Time (µs)":^17}|{"CPU cycles (in billions)":^26}|{"Avg cycles (in billions)":^26}|""" - echo &"""|{flags:^50}|{' '.repeat(14)}|{' '.repeat(20)}|{' '.repeat(15)}|{' '.repeat(17)}|{"indicative only":^26}|{"indicative only":^26}|""" + echo &"""|{"Procedures":^150}|{"# of Calls":^14}|{"Throughput (ops/s)":^20}|{"Time (µs)":^15}|{"Avg Time (µs)":^17}|{"CPU cycles (in billions)":^26}|{"Avg cycles (in billions)":^26}|""" + echo &"""|{flags:^150}|{' '.repeat(14)}|{' '.repeat(20)}|{' '.repeat(15)}|{' '.repeat(17)}|{"indicative only":^26}|{"indicative only":^26}|""" echo lineSep for m in metrics: if m.numCalls == 0: @@ -40,15 +40,15 @@ proc reportCli*(metrics: seq[Metadata], flags: string) = let throughput = 1e6 / avgTimeUs let cumulCyclesBillions = m.cumulatedCycles.float64 * 1e-9 let avgCyclesBillions = cumulCyclesBillions / m.numCalls.float64 - echo &"""|{m.procName:<50}|{m.numCalls:>14}|{throughput:>20.3f}|{cumulTimeUs:>15.3f}|{avgTimeUs:>17.3f}|""" + echo &"""|{m.procName:<150}|{m.numCalls:>14}|{throughput:>20.3f}|{cumulTimeUs:>15.3f}|{avgTimeUs:>17.3f}|""" echo lineSep else: const lineSep = &"""|{'-'.repeat(50)}|{'-'.repeat(14)}|{'-'.repeat(20)}|{'-'.repeat(15)}|{'-'.repeat(17)}|""" echo "\n" echo lineSep - echo &"""|{"Procedures":^50}|{"# of Calls":^14}|{"Throughput (ops/s)":^20}|{"Time (µs)":^15}|{"Avg Time (µs)":^17}|""" - echo &"""|{flags:^50}|{' '.repeat(14)}|{' '.repeat(20)}|{' '.repeat(15)}|{' '.repeat(17)}|""" + echo &"""|{"Procedures":^150}|{"# of Calls":^14}|{"Throughput (ops/s)":^20}|{"Time (µs)":^15}|{"Avg Time (µs)":^17}|""" + echo &"""|{flags:^150}|{' '.repeat(14)}|{' '.repeat(20)}|{' '.repeat(15)}|{' '.repeat(17)}|""" echo lineSep for m in metrics: if m.numCalls == 0: @@ -58,5 +58,5 @@ proc reportCli*(metrics: seq[Metadata], flags: string) = let cumulTimeUs = m.cumulatedTimeNs.float64 * 1e-3 let avgTimeUs = cumulTimeUs / m.numCalls.float64 let throughput = 1e6 / avgTimeUs - echo &"""|{m.procName:<50}|{m.numCalls:>14}|{throughput:>20.3f}|{cumulTimeUs:>15.3f}|{avgTimeUs:>17.3f}|""" + echo &"""|{m.procName:<150}|{m.numCalls:>14}|{throughput:>20.3f}|{cumulTimeUs:>15.3f}|{avgTimeUs:>17.3f}|""" echo lineSep diff --git a/metering/tracer.nim b/metering/tracer.nim index de34f47..8d7a4c2 100644 --- a/metering/tracer.nim +++ b/metering/tracer.nim @@ -57,7 +57,7 @@ var ctMetrics{.compileTime.}: seq[Metadata] ## Unfortunately the "seq" is emptied when passing the compileTime/runtime boundaries ## due to Nim bugs -when CttTrace: +when CttMeter or CttTrace: # strformat doesn't work in templates. from strutils import alignLeft, formatFloat @@ -111,7 +111,7 @@ macro meterAnnotate(procAst: untyped): untyped = procAst.expectKind({nnkProcDef, nnkFuncDef}) let id = ctMetrics.len - let name = procAst[0].repr + let name = procAst[0].repr & procAst[3].repr # TODO, get the module and the package the proc is coming from # and the tag "Fp", "ec", "polynomial" ... @@ -123,6 +123,24 @@ macro meterAnnotate(procAst: untyped): untyped = newbody.add nnkDefer.newTree(getAst(fnExit(name, id, startTime, startCycle))) newBody.add procAst.body + if procAst[4].kind != nnkEmpty: + # Timing procedures adds the TimeEffect tag, which interferes with {.tags:[VarTime].} + # as TimeEffect is not listed. We drop the `tags` for metering + var pragmas: NimNode + if procAst[4].len == 1: + if procAst[4][0].kind == nnkExprColonExpr and procAst[4][0][0].eqIdent"tags": + pragmas = newEmptyNode() + else: + pragmas = procAst[4] + else: + pragmas = nnkPragma.newTree() + for i in 0 ..< procAst[4].len: + if procAst[4][0].kind == nnkExprColonExpr and procAst[4][0][0].eqIdent"tags": + continue + else: + pragmas.add procAst[4][0] + procAst[4] = pragmas + procAst.body = newBody result = procAst diff --git a/sage/derive_pairing.sage b/sage/derive_pairing.sage index 538be69..6d6be9d 100644 --- a/sage/derive_pairing.sage +++ b/sage/derive_pairing.sage @@ -63,10 +63,7 @@ def genAteParam(curve_name, curve_config): buf += ate_comment ate_bits = int(ate_param).bit_length() - naf_bits = int(3*ate_param).bit_length() - ate_bits - - buf += f' # +{naf_bits} to bitlength so that we can mul by 3 for NAF encoding\n' - buf += f' BigInt[{ate_bits}+{naf_bits}].fromHex"0x{Integer(abs(ate_param)).hex()}"\n\n' + buf += f' BigInt[{ate_bits}].fromHex"0x{Integer(abs(ate_param)).hex()}"\n\n' buf += f'const {curve_name}_pairing_ate_param_isNeg* = {"true" if ate_param < 0 else "false"}' @@ -198,7 +195,7 @@ def genFinalExp(curve_name, curve_config): scale = 3*(u^3-u^2+1) scaleDesc = ' * 3*(u^3-u^2+1)' - fexp = (pᵏ - 1)//r + fexp = (p^k - 1)//r fexp *= scale buf = f'const {curve_name}_pairing_finalexponent* = block:\n' diff --git a/sage/testgen_scalar_mul.sage b/sage/testgen_scalar_mul.sage index ab12566..0689bb8 100644 --- a/sage/testgen_scalar_mul.sage +++ b/sage/testgen_scalar_mul.sage @@ -81,7 +81,7 @@ def serialize_EC_Fp2(P): # Generator # --------------------------------------------------------- -def genScalarMulG1(curve_name, curve_config, count, seed): +def genScalarMulG1(curve_name, curve_config, count, seed, scalarBits = None): p = curve_config[curve_name]['field']['modulus'] r = curve_config[curve_name]['field']['order'] form = curve_config[curve_name]['curve']['form'] @@ -109,13 +109,14 @@ def genScalarMulG1(curve_name, curve_config, count, seed): for i in progressbar(range(count)): v = {} P = G1.random_point() - scalar = randrange(r) + scalar = randrange(1 << scalarBits) if scalarBits else randrange(r) P *= cofactor # clear cofactor Q = scalar * P v['id'] = i v['P'] = serialize_EC_Fp(P) + v['scalarBits'] = scalarBits if scalarBits else r.bit_length() v['scalar'] = serialize_bigint(scalar) v['Q'] = serialize_EC_Fp(Q) vectors.append(v) @@ -123,7 +124,7 @@ def genScalarMulG1(curve_name, curve_config, count, seed): out['vectors'] = vectors return out -def genScalarMulG2(curve_name, curve_config, count, seed): +def genScalarMulG2(curve_name, curve_config, count, seed, scalarBits = None): p = curve_config[curve_name]['field']['modulus'] r = curve_config[curve_name]['field']['order'] form = curve_config[curve_name]['curve']['form'] @@ -197,7 +198,7 @@ def genScalarMulG2(curve_name, curve_config, count, seed): for i in progressbar(range(count)): v = {} P = G2.random_point() - scalar = randrange(r) + scalar = randrange(1 << scalarBits) if scalarBits else randrange(r) P *= cofactor # clear cofactor Q = scalar * P @@ -205,10 +206,12 @@ def genScalarMulG2(curve_name, curve_config, count, seed): v['id'] = i if G2_field == 'Fp2': v['P'] = serialize_EC_Fp2(P) + v['scalarBits'] = scalarBits if scalarBits else r.bit_length() v['scalar'] = serialize_bigint(scalar) v['Q'] = serialize_EC_Fp2(Q) elif G2_field == 'Fp': v['P'] = serialize_EC_Fp(P) + v['scalarBits'] = scalarBits if scalarBits else r.bit_length() v['scalar'] = serialize_bigint(scalar) v['Q'] = serialize_EC_Fp(Q) vectors.append(v) @@ -222,7 +225,7 @@ def genScalarMulG2(curve_name, curve_config, count, seed): if __name__ == "__main__": # Usage # BLS12-381 - # sage sage/derive_pairing.sage BLS12_381 G1 + # sage sage/testgen_scalar_mul.sage BLS12_381 G1 {scalarBits: optional int} from argparse import ArgumentParser @@ -232,6 +235,9 @@ if __name__ == "__main__": curve = args.curve[0] group = args.curve[1] + scalarBits = None + if len(args.curve) > 2: + scalarBits = int(args.curve[2]) if curve not in Curves: raise ValueError( @@ -245,16 +251,17 @@ if __name__ == "__main__": ' is not a valid group, expected G1 or G2 instead' ) else: - print(f'\nGenerating test vectors tv_{curve}_scalar_mul_{group}.json') + bits = scalarBits if scalarBits else Curves[curve]['field']['order'].bit_length() + print(f'\nGenerating test vectors tv_{curve}_scalar_mul_{group}_{bits}bit.json') print('----------------------------------------------------\n') count = 40 seed = 1337 if group == 'G1': - out = genScalarMulG1(curve, Curves, count, seed) + out = genScalarMulG1(curve, Curves, count, seed, scalarBits) elif group == 'G2': - out = genScalarMulG2(curve, Curves, count, seed) + out = genScalarMulG2(curve, Curves, count, seed, scalarBits) - with open(f'tv_{curve}_scalar_mul_{group}.json', 'w') as f: + with open(f'tv_{curve}_scalar_mul_{group}_{bits}bits.json', 'w') as f: json.dump(out, f, indent=2) diff --git a/tests/math/support/ec_reference_scalar_mult.nim b/tests/math/support/ec_reference_scalar_mult.nim deleted file mode 100644 index e73816f..0000000 --- a/tests/math/support/ec_reference_scalar_mult.nim +++ /dev/null @@ -1,71 +0,0 @@ -# Constantine -# Copyright (c) 2018-2019 Status Research & Development GmbH -# Copyright (c) 2020-Present Mamy André-Ratsimbazafy -# Licensed and distributed under either of -# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). -# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). -# at your option. This file may not be copied, modified, or distributed except according to those terms. - -import - # Internals - ../../../constantine/math/arithmetic, - ../../../constantine/math/io/io_bigints - -# Support files for testing Elliptic Curve arithmetic -# ------------------------------------------------------------------------------ - -iterator unpack(scalarByte: byte): bool = - yield bool((scalarByte and 0b10000000) shr 7) - yield bool((scalarByte and 0b01000000) shr 6) - yield bool((scalarByte and 0b00100000) shr 5) - yield bool((scalarByte and 0b00010000) shr 4) - yield bool((scalarByte and 0b00001000) shr 3) - yield bool((scalarByte and 0b00000100) shr 2) - yield bool((scalarByte and 0b00000010) shr 1) - yield bool( scalarByte and 0b00000001) - -func unsafe_ECmul_double_add*[EC]( - P: var EC, - scalar: BigInt, - ) = - ## **Unsafe** Elliptic Curve Scalar Multiplication - ## - ## P <- [k] P - ## - ## This uses the double-and-add algorithm to verify the constant-time production implementation - ## This is UNSAFE to use in production and only intended for testing purposes. - ## - ## This is highly VULNERABLE to timing attacks and power analysis attacks - var scalarCanonical: array[(scalar.bits+7) div 8, byte] - scalarCanonical.marshal(scalar, bigEndian) - - var t0: typeof(P) - t0.setInf() - for scalarByte in scalarCanonical: - for bit in unpack(scalarByte): - t0.double() - if bit: - t0 += P - P = t0 - -func unsafe_ECmul_minHammingWeight*[EC]( - P: var EC, - scalar: BigInt) = - ## **Unsafe** Elliptic Curve Scalar Multiplication - ## - ## P <- [k] P - ## - ## This uses an online recoding with minimum Hamming Weight - ## (which is not NAF, NAF is least-significant bit to most) - ## This is UNSAFE to use in production and only intended for testing purposes. - ## - ## This is highly VULNERABLE to timing attacks and power analysis attacks - var t0{.noInit.}: typeof(P) - t0.setInf() - for bit in recoding_l2r_vartime(scalar): - t0.double() - if bit == 1: - t0 += P - elif bit == -1: - t0 -= P - P = t0 \ No newline at end of file diff --git a/tests/math/t_bigints.nim b/tests/math/t_bigints.nim index 40bb398..9976126 100644 --- a/tests/math/t_bigints.nim +++ b/tests/math/t_bigints.nim @@ -19,7 +19,7 @@ import echo "\n------------------------------------------------------\n" proc mainArith() = - suite "isZero" & " [" & $WordBitWidth & "-bit mode]": + suite "isZero" & " [" & $WordBitWidth & "-bit words]": test "isZero for zero": var x: BigInt[128] check: x.isZero().bool @@ -49,7 +49,7 @@ proc mainArith() = check: static(not x.isZero().bool) - suite "Arithmetic operations - Addition" & " [" & $WordBitWidth & "-bit mode]": + suite "Arithmetic operations - Addition" & " [" & $WordBitWidth & "-bit words]": test "Adding 2 zeros": var a = fromHex(BigInt[128], "0x00000000000000000000000000000000") let b = fromHex(BigInt[128], "0x00000000000000000000000000000000") @@ -149,7 +149,7 @@ proc mainArith() = bool(a == c) not bool(carry) - suite "BigInt + SecretWord" & " [" & $WordBitWidth & "-bit mode]": + suite "BigInt + SecretWord" & " [" & $WordBitWidth & "-bit words]": test "Addition limbs carry": block: # P256 / 2 var a = BigInt[256].fromhex"0x7fffffff800000008000000000000000000000007fffffffffffffffffffffff" @@ -160,7 +160,7 @@ proc mainArith() = check: bool(a == expected) proc mainMul() = - suite "Multi-precision multiplication" & " [" & $WordBitWidth & "-bit mode]": + suite "Multi-precision multiplication" & " [" & $WordBitWidth & "-bit words]": test "Same size operand into double size result": block: var r = canary(BigInt[256]) @@ -201,7 +201,7 @@ proc mainMul() = check: bool(r == expected) proc mainMulHigh() = - suite "Multi-precision multiplication keeping only high words" & " [" & $WordBitWidth & "-bit mode]": + suite "Multi-precision multiplication keeping only high words" & " [" & $WordBitWidth & "-bit words]": test "Same size operand into double size result - discard first word": block: var r = canary(BigInt[256]) @@ -287,7 +287,7 @@ proc mainMulHigh() = check: bool(r == expected) proc mainSquare() = - suite "Multi-precision multiplication" & " [" & $WordBitWidth & "-bit mode]": + suite "Multi-precision multiplication" & " [" & $WordBitWidth & "-bit words]": test "Squaring is consistent with multiplication (rBits = 2*aBits)": block: let a = BigInt[200].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDE" @@ -309,7 +309,7 @@ proc mainSquare() = check: bool(rmul == rsqr) proc mainModular() = - suite "Modular operations - small modulus" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular operations - small modulus" & " [" & $WordBitWidth & "-bit words]": # Vectors taken from Stint - https://github.com/status-im/nim-stint test "100 mod 13": # Test 1 word and more than 1 word @@ -368,7 +368,7 @@ proc mainModular() = "\n r (low-level repr): " & $r & "\n expected (ll repr): " & $expected - suite "Modular operations - small modulus - Stint specific failures highlighted by property-based testing" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular operations - small modulus - Stint specific failures highlighted by property-based testing" & " [" & $WordBitWidth & "-bit words]": # Vectors taken from Stint - https://github.com/status-im/nim-stint test "Modulo: 65696211516342324 mod 174261910798982": let u = 65696211516342324'u64 @@ -401,7 +401,7 @@ proc mainModular() = "\n expected (ll repr): " & $expected proc mainNeg() = - suite "Conditional negation" & " [" & $WordBitWidth & "-bit mode]": + suite "Conditional negation" & " [" & $WordBitWidth & "-bit words]": test "Conditional negation": block: var a = fromHex(BigInt[128], "0x12345678FF11FFAA00321321CAFECAFE") @@ -499,7 +499,7 @@ proc mainNeg() = bool(b == b2) proc mainCopySwap() = - suite "Copy and Swap" & " [" & $WordBitWidth & "-bit mode]": + suite "Copy and Swap" & " [" & $WordBitWidth & "-bit words]": test "Conditional copy": block: var a = fromHex(BigInt[128], "0x12345678FF11FFAA00321321CAFECAFE") @@ -545,7 +545,7 @@ proc mainCopySwap() = bool(eB == b) proc mainModularInverse() = - suite "Modular Inverse (with odd modulus)" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular Inverse (with odd modulus)" & " [" & $WordBitWidth & "-bit words]": # Note: We don't define multi-precision multiplication # because who needs it when you have Montgomery? # ¯\(ツ)/¯ @@ -556,10 +556,14 @@ proc mainModularInverse() = let expected = BigInt[16].fromUint(1969'u16) var r = canary(BigInt[16]) + var r2 = canary(BigInt[16]) r.invmod(a, M) + r2.invmod_vartime(a, M) - check: bool(r == expected) + check: + bool(r == expected) + bool(r2 == expected) block: # huge int let a = BigInt[381].fromUint(42'u16) @@ -567,10 +571,14 @@ proc mainModularInverse() = let expected = BigInt[381].fromUint(1969'u16) var r = canary(BigInt[381]) + var r2 = canary(BigInt[381]) r.invmod(a, M) + r2.invmod_vartime(a, M) - check: bool(r == expected) + check: + bool(r == expected) + bool(r2 == expected) test "271^-1 (mod 383) = 106": block: # small int @@ -579,10 +587,14 @@ proc mainModularInverse() = let expected = BigInt[16].fromUint(106'u16) var r = canary(BigInt[16]) + var r2 = canary(BigInt[16]) r.invmod(a, M) + r2.invmod_vartime(a, M) - check: bool(r == expected) + check: + bool(r == expected) + bool(r2 == expected) block: # huge int let a = BigInt[381].fromUint(271'u16) @@ -590,10 +602,14 @@ proc mainModularInverse() = let expected = BigInt[381].fromUint(106'u16) var r = canary(BigInt[381]) + var r2 = canary(BigInt[381]) r.invmod(a, M) + r2.invmod_vartime(a, M) - check: bool(r == expected) + check: + bool(r == expected) + bool(r2 == expected) test "BN254_Modulus^-1 (mod BLS12_381)": let a = BigInt[381].fromHex("0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47") @@ -602,9 +618,14 @@ proc mainModularInverse() = let expected = BigInt[381].fromHex("0x0636759a0f3034fa47174b2c0334902f11e9915b7bd89c6a2b3082b109abbc9837da17201f6d8286fe6203caa1b9d4c8") var r = canary(BigInt[381]) - r.invmod(a, M) + var r2 = canary(BigInt[381]) - check: bool(r == expected) + r.invmod(a, M) + r2.invmod_vartime(a, M) + + check: + bool(r == expected) + bool(r2 == expected) test "0^-1 (mod any) = 0 (need for tower of extension fields)": block: @@ -613,10 +634,14 @@ proc mainModularInverse() = let expected = BigInt[16].fromUint(0'u16) var r = canary(BigInt[16]) + var r2 = canary(BigInt[16]) r.invmod(a, M) + r2.invmod_vartime(a, M) - check: bool(r == expected) + check: + bool(r == expected) + bool(r2 == expected) block: let a = BigInt[381].fromUint(0'u16) @@ -624,10 +649,14 @@ proc mainModularInverse() = let expected = BigInt[381].fromUint(0'u16) var r = canary(BigInt[381]) + var r2 = canary(BigInt[381]) r.invmod(a, M) + r2.invmod_vartime(a, M) - check: bool(r == expected) + check: + bool(r == expected) + bool(r2 == expected) mainArith() mainMul() diff --git a/tests/math/t_bigints_multimod.nim b/tests/math/t_bigints_multimod.nim index 898a052..64514b3 100644 --- a/tests/math/t_bigints_multimod.nim +++ b/tests/math/t_bigints_multimod.nim @@ -17,7 +17,7 @@ import echo "\n------------------------------------------------------\n" proc main() = - suite "Bigints - Multiprecision modulo" & " [" & $WordBitWidth & "-bit mode]": + suite "Bigints - Multiprecision modulo" & " [" & $WordBitWidth & "-bit words]": test "bitsize 237 mod bitsize 192": let a = BigInt[237].fromHex("0x123456789012345678901234567890123456789012345678901234567890") let m = BigInt[192].fromHex("0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB") diff --git a/tests/math/t_ec_frobenius.nim b/tests/math/t_ec_frobenius.nim index 80bfbe1..62b26a8 100644 --- a/tests/math/t_ec_frobenius.nim +++ b/tests/math/t_ec_frobenius.nim @@ -49,7 +49,7 @@ proc test( R.frobenius_psi(P) doAssert: bool(R == Q) -suite "ψ (Psi) - Untwist-Frobenius-Twist Endomorphism on G2 vs SageMath" & " [" & $WordBitWidth & "-bit mode]": +suite "ψ (Psi) - Untwist-Frobenius-Twist Endomorphism on G2 vs SageMath" & " [" & $WordBitWidth & "-bit words]": # Generated via # - sage sage/frobenius_bn254_snarks.sage # - sage sage/frobenius_bls12_377.sage @@ -214,7 +214,7 @@ suite "ψ (Psi) - Untwist-Frobenius-Twist Endomorphism on G2 vs SageMath" & " [" Qy1 = "77ef6850d4a8f181a10196398cd344011a44c50dce00e18578f3526301263492086d44c7c3d1db5b12499b4033116e1" ) -suite "ψ - psi(psi(P)) == psi2(P) - (Untwist-Frobenius-Twist Endomorphism)" & " [" & $WordBitWidth & "-bit mode]": +suite "ψ - psi(psi(P)) == psi2(P) - (Untwist-Frobenius-Twist Endomorphism)" & " [" & $WordBitWidth & "-bit words]": const Iters = 8 proc test(EC: typedesc, randZ: static bool, gen: static RandomGen) = for i in 0 ..< Iters: @@ -247,7 +247,7 @@ suite "ψ - psi(psi(P)) == psi2(P) - (Untwist-Frobenius-Twist Endomorphism)" & " testAll(ECP_ShortW_Prj[Fp2[BLS12_381], G2]) testAll(ECP_ShortW_Prj[Fp[BW6_761], G2]) -suite "ψ²(P) - [t]ψ(P) + [p]P = Inf" & " [" & $WordBitWidth & "-bit mode]": +suite "ψ²(P) - [t]ψ(P) + [p]P = Inf" & " [" & $WordBitWidth & "-bit words]": const Iters = 10 proc trace(C: static Curve): auto = # Returns (abs(trace), isNegativeSign) @@ -314,7 +314,7 @@ suite "ψ²(P) - [t]ψ(P) + [p]P = Inf" & " [" & $WordBitWidth & "-bit mode]": testAll(ECP_ShortW_Prj[Fp2[BLS12_381], G2]) testAll(ECP_ShortW_Prj[Fp[BW6_761], G2]) -suite "ψ⁴(P) - ψ²(P) + P = Inf (k-th cyclotomic polynomial with embedding degree k=12)" & " [" & $WordBitWidth & "-bit mode]": +suite "ψ⁴(P) - ψ²(P) + P = Inf (k-th cyclotomic polynomial with embedding degree k=12)" & " [" & $WordBitWidth & "-bit words]": const Iters = 10 proc test(EC: typedesc, randZ: static bool, gen: static RandomGen) = @@ -344,7 +344,7 @@ suite "ψ⁴(P) - ψ²(P) + P = Inf (k-th cyclotomic polynomial with embedding d testAll(ECP_ShortW_Prj[Fp2[BLS12_377], G2]) testAll(ECP_ShortW_Prj[Fp2[BLS12_381], G2]) -suite "ψ²(P) - ψ(P) + P = Inf (k-th cyclotomic polynomial with embedding degree k=6)" & " [" & $WordBitWidth & "-bit mode]": +suite "ψ²(P) - ψ(P) + P = Inf (k-th cyclotomic polynomial with embedding degree k=6)" & " [" & $WordBitWidth & "-bit words]": const Iters = 10 proc test(EC: typedesc, randZ: static bool, gen: static RandomGen) = diff --git a/tests/math/t_ec_sage_bls12_377.nim b/tests/math/t_ec_sage_bls12_377.nim index af502a0..f5764e6 100644 --- a/tests/math/t_ec_sage_bls12_377.nim +++ b/tests/math/t_ec_sage_bls12_377.nim @@ -15,22 +15,23 @@ import # Test utilities ./t_ec_sage_template -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[BLS12_377], G1], - "t_ec_sage_bls12_377_g1_projective" -) +staticFor(bits, [32, 64, 128, BLS12_377.getCurveOrderBitwidth()]): + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[BLS12_377], G1], bits, + "t_ec_sage_bls12_377_g1_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[BLS12_377], G1], - "t_ec_sage_bls12_377_g1_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[BLS12_377], G1], bits, + "t_ec_sage_bls12_377_g1_jacobian" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp2[BLS12_377], G2], - "t_ec_sage_bls12_377_g2_projective" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp2[BLS12_377], G2], bits, + "t_ec_sage_bls12_377_g2_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp2[BLS12_377], G2], - "t_ec_sage_bls12_377_g2_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp2[BLS12_377], G2], bits, + "t_ec_sage_bls12_377_g2_jacobian" + ) diff --git a/tests/math/t_ec_sage_bls12_381.nim b/tests/math/t_ec_sage_bls12_381.nim index ecd5326..38e0465 100644 --- a/tests/math/t_ec_sage_bls12_381.nim +++ b/tests/math/t_ec_sage_bls12_381.nim @@ -15,22 +15,23 @@ import # Test utilities ./t_ec_sage_template -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[BLS12_381], G1], - "t_ec_sage_bls12_381_g1_projective" -) +staticFor(bits, [32, 64, 128, BLS12_381.getCurveOrderBitwidth()]): + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[BLS12_381], G1], bits, + "t_ec_sage_bls12_381_g1_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[BLS12_381], G1], - "t_ec_sage_bls12_381_g1_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[BLS12_381], G1], bits, + "t_ec_sage_bls12_381_g1_jacobian" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp2[BLS12_381], G2], - "t_ec_sage_bls12_381_g2_projective" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp2[BLS12_381], G2], bits, + "t_ec_sage_bls12_381_g2_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp2[BLS12_381], G2], - "t_ec_sage_bls12_381_g2_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp2[BLS12_381], G2], bits, + "t_ec_sage_bls12_381_g2_jacobian" + ) diff --git a/tests/math/t_ec_sage_bn254_nogami.nim b/tests/math/t_ec_sage_bn254_nogami.nim index f4c4330..89b07d6 100644 --- a/tests/math/t_ec_sage_bn254_nogami.nim +++ b/tests/math/t_ec_sage_bn254_nogami.nim @@ -15,22 +15,23 @@ import # Test utilities ./t_ec_sage_template -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[BN254_Nogami], G1], - "t_ec_sage_bn254_nogami_g1_projective" -) +staticFor(bits, [BN254_Nogami.getCurveOrderBitwidth()]): + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[BN254_Nogami], G1], bits, + "t_ec_sage_bn254_nogami_g1_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[BN254_Nogami], G1], - "t_ec_sage_bn254_nogami_g1_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[BN254_Nogami], G1], bits, + "t_ec_sage_bn254_nogami_g1_jacobian" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp2[BN254_Nogami], G2], - "t_ec_sage_bn254_nogami_g2_projective" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp2[BN254_Nogami], G2], bits, + "t_ec_sage_bn254_nogami_g2_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp2[BN254_Nogami], G2], - "t_ec_sage_bn254_nogami_g2_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp2[BN254_Nogami], G2], bits, + "t_ec_sage_bn254_nogami_g2_jacobian" + ) diff --git a/tests/math/t_ec_sage_bn254_snarks.nim b/tests/math/t_ec_sage_bn254_snarks.nim index e6be63e..761d642 100644 --- a/tests/math/t_ec_sage_bn254_snarks.nim +++ b/tests/math/t_ec_sage_bn254_snarks.nim @@ -15,22 +15,23 @@ import # Test utilities ./t_ec_sage_template -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[BN254_Snarks], G1], - "t_ec_sage_bn254_snarks_g1_projective" -) +staticFor(bits, [32, 64, 128, BN254_Snarks.getCurveOrderBitwidth()]): + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[BN254_Snarks], G1], bits, + "t_ec_sage_bn254_snarks_g1_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[BN254_Snarks], G1], - "t_ec_sage_bn254_snarks_g1_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[BN254_Snarks], G1], bits, + "t_ec_sage_bn254_snarks_g1_jacobian" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp2[BN254_Snarks], G2], - "t_ec_sage_bn254_snarks_g2_projective" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp2[BN254_Snarks], G2], bits, + "t_ec_sage_bn254_snarks_g2_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp2[BN254_Snarks], G2], - "t_ec_sage_bn254_snarks_g2_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp2[BN254_Snarks], G2], bits, + "t_ec_sage_bn254_snarks_g2_jacobian" + ) diff --git a/tests/math/t_ec_sage_bw6_761_g1.nim b/tests/math/t_ec_sage_bw6_761_g1.nim index 4864bbc..94862ac 100644 --- a/tests/math/t_ec_sage_bw6_761_g1.nim +++ b/tests/math/t_ec_sage_bw6_761_g1.nim @@ -20,22 +20,23 @@ import # this creates bad codegen, in the C code, the `value`parameter gets the wrong type # TODO: upstream -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[BW6_761], G1], - "t_ec_sage_bw6_761_g1_projective" -) +staticFor(bits, [BW6_761.getCurveOrderBitwidth()]): + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[BW6_761], G1], bits, + "t_ec_sage_bw6_761_g1_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[BW6_761], G1], - "t_ec_sage_bw6_761_g1_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[BW6_761], G1], bits, + "t_ec_sage_bw6_761_g1_jacobian" + ) -# run_scalar_mul_test_vs_sage( -# ECP_ShortW_Prj[Fp[BW6_761], G2], -# "t_ec_sage_bw6_761_g2_projective" -# ) + # run_scalar_mul_test_vs_sage( + # ECP_ShortW_Prj[Fp[BW6_761], G2], bits, + # "t_ec_sage_bw6_761_g2_projective" + # ) -# run_scalar_mul_test_vs_sage( -# ECP_ShortW_Jac[Fp[BW6_761], G2], -# "t_ec_sage_bw6_761_g2_jacobian" -# ) + # run_scalar_mul_test_vs_sage( + # ECP_ShortW_Jac[Fp[BW6_761], G2], bits, + # "t_ec_sage_bw6_761_g2_jacobian" + # ) diff --git a/tests/math/t_ec_sage_bw6_761_g2.nim b/tests/math/t_ec_sage_bw6_761_g2.nim index e0c37e9..45cb27a 100644 --- a/tests/math/t_ec_sage_bw6_761_g2.nim +++ b/tests/math/t_ec_sage_bw6_761_g2.nim @@ -20,22 +20,23 @@ import # this creates bad codegen, in the C code, the `value`parameter gets the wrong type # TODO: upstream -# run_scalar_mul_test_vs_sage( -# ECP_ShortW_Prj[Fp[BW6_761], G1], -# "t_ec_sage_bw6_761_g1_projective" -# ) +staticFor(bits, [BW6_761.getCurveOrderBitwidth()]): + # run_scalar_mul_test_vs_sage( + # ECP_ShortW_Prj[Fp[BW6_761], G1], bits, + # "t_ec_sage_bw6_761_g1_projective" + # ) -# run_scalar_mul_test_vs_sage( -# ECP_ShortW_Jac[Fp[BW6_761], G1], -# "t_ec_sage_bw6_761_g1_jacobian" -# ) + # run_scalar_mul_test_vs_sage( + # ECP_ShortW_Jac[Fp[BW6_761], G1], bits, + # "t_ec_sage_bw6_761_g1_jacobian" + # ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[BW6_761], G2], - "t_ec_sage_bw6_761_g2_projective" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[BW6_761], G2], bits, + "t_ec_sage_bw6_761_g2_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[BW6_761], G2], - "t_ec_sage_bw6_761_g2_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[BW6_761], G2], bits, + "t_ec_sage_bw6_761_g2_jacobian" + ) diff --git a/tests/math/t_ec_sage_pallas.nim b/tests/math/t_ec_sage_pallas.nim index a34c83a..43bcc31 100644 --- a/tests/math/t_ec_sage_pallas.nim +++ b/tests/math/t_ec_sage_pallas.nim @@ -15,12 +15,13 @@ import # Test utilities ./t_ec_sage_template -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[Pallas], G1], - "t_ec_sage_pallas_g1_projective" -) +staticFor(bits, [Pallas.getCurveOrderBitwidth()]): + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[Pallas], G1], bits, + "t_ec_sage_pallas_g1_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[Pallas], G1], - "t_ec_sage_pallas_g1_jacobian" -) \ No newline at end of file + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[Pallas], G1], bits, + "t_ec_sage_pallas_g1_jacobian" + ) \ No newline at end of file diff --git a/tests/math/t_ec_sage_template.nim b/tests/math/t_ec_sage_template.nim index bcdac68..315e3e1 100644 --- a/tests/math/t_ec_sage_template.nim +++ b/tests/math/t_ec_sage_template.nim @@ -13,7 +13,6 @@ import pkg/jsony, # Internals ../../constantine/platforms/abstractions, - ../../constantine/math/config/curves, ../../constantine/math/[arithmetic, extension_fields], ../../constantine/math/io/[io_bigints, io_ec], ../../constantine/math/elliptic/[ @@ -22,72 +21,21 @@ import ec_shortweierstrass_jacobian, ec_scalar_mul, ec_endomorphism_accel], + ../../constantine/math/constants/zoo_endomorphisms, # Test utilities - ./support/ec_reference_scalar_mult + ../../constantine/math/elliptic/ec_scalar_mul_vartime export unittest, abstractions, arithmetic # Generic sandwich # Serialization # -------------------------------------------------------------------------- -macro matchingScalar*(EC: type ECP_ShortW_Aff): untyped = - ## Workaround the annoying type system - ## 1. Higher-kinded type - ## 2. Computation in type section needs template or macro indirection - ## 3. Converting NimNode to typedesc - ## https://github.com/nim-lang/Nim/issues/6785 - # BigInt[EC.F.C.getCurveOrderBitwidth()] - - let ec = EC.getTypeImpl() - # echo ec.treerepr - # BracketExpr - # Sym "typeDesc" - # BracketExpr - # Sym "ECP_ShortW_Aff" - # BracketExpr - # Sym "Fp" - # IntLit 12 - # IntLit 0 - - doAssert ec[0].eqIdent"typedesc" - doAssert ec[1][0].eqIdent"ECP_ShortW_Aff" - ec[1][1].expectkind(nnkBracketExpr) - doAssert ($ec[1][1][0]).startsWith"Fp" - - let curve = Curve(ec[1][1][1].intVal) - let bitwidth = getAST(getCurveOrderBitwidth(curve)) - result = nnkBracketExpr.newTree( - bindSym"BigInt", - bitwidth - ) - -macro matchingNonResidueType*(EC: type ECP_ShortW_Aff): untyped = - ## Workaround the annoying type system - ## 1. Higher-kinded type - ## 2. Computation in type section needs template or macro indirection - ## 3. Converting NimNode to typedesc - ## https://github.com/nim-lang/Nim/issues/6785 - let ec = EC.getTypeImpl() - doAssert ec[0].eqIdent"typedesc" - doAssert ec[1][0].eqIdent"ECP_ShortW_Aff" - ec[1][1].expectkind(nnkBracketExpr) - doAssert ($ec[1][1][0]).startsWith"Fp" - - # int or array[2, int] - if ec[1][1][0].eqIdent"Fp": - result = bindSym"int" - elif ec[1][1][0].eqIdent"Fp2": - result = nnkBracketExpr.newTree( - bindSym"array", - newLit 2, - bindSym"int" - ) - type - TestVector*[EC: ECP_ShortW_Aff] = object + TestVector*[EC: ECP_ShortW_Aff, bits: static int] = object id: int P: EC - scalar: matchingScalar(EC) + scalarBits: int + scalar: BigInt[bits] Q: EC EC_G1_hex = object @@ -102,7 +50,7 @@ type x: Fp2_hex y: Fp2_hex - ScalarMulTestG1[EC: ECP_ShortW_Aff] = object + ScalarMulTestG1[EC: ECP_ShortW_Aff, bits: static int] = object curve: string group: string modulus: string @@ -112,9 +60,9 @@ type a: string b: string # vectors ------------------ - vectors: seq[TestVector[EC]] + vectors: seq[TestVector[EC, bits]] - ScalarMulTestG2[EC: ECP_ShortW_Aff] = object + ScalarMulTestG2[EC: ECP_ShortW_Aff, bits: static int] = object curve: string group: string modulus: string @@ -128,9 +76,12 @@ type twist: string non_residue_fp: int G2_field: string - non_residue_twist: matchingNonResidueType(EC) # int or array[2, int] + when EC.F is Fp: + non_residue_twist: int + else: + non_residue_twist: array[2, int] # vectors ------------------ - vectors: seq[TestVector[EC]] + vectors: seq[TestVector[EC, bits]] const TestVectorsDir* = @@ -170,7 +121,8 @@ proc parseHook*(src: string, pos: var int, value: var ECP_ShortW_Aff) = proc loadVectors(TestType: typedesc): TestType = const group = when TestType.EC.G == G1: "G1" else: "G2" - const filename = "tv_" & $TestType.EC.F.C & "_scalar_mul_" & group & ".json" + const filename = "tv_" & $TestType.EC.F.C & "_scalar_mul_" & group & "_" & $TestType.bits & "bit.json" + echo "Loading: ", filename let content = readFile(TestVectorsDir/filename) result = content.fromJson(TestType) @@ -178,7 +130,7 @@ proc loadVectors(TestType: typedesc): TestType = # ------------------------------------------------------------------------ proc run_scalar_mul_test_vs_sage*( - EC: typedesc, + EC: typedesc, bits: static int, moduleName: string ) = echo "\n------------------------------------------------------\n" @@ -186,41 +138,51 @@ proc run_scalar_mul_test_vs_sage*( when EC.G == G1: const G1_or_G2 = "G1" - let vec = loadVectors(ScalarMulTestG1[ECP_ShortW_Aff[EC.F, EC.G]]) + let vec = loadVectors(ScalarMulTestG1[ECP_ShortW_Aff[EC.F, EC.G], bits]) else: const G1_or_G2 = "G2" - let vec = loadVectors(ScalarMulTestG2[ECP_ShortW_Aff[EC.F, EC.G]]) + let vec = loadVectors(ScalarMulTestG2[ECP_ShortW_Aff[EC.F, EC.G], bits]) const coord = when EC is ECP_ShortW_Prj: " Projective coordinates " elif EC is ECP_ShortW_Jac: " Jacobian coordinates " - const testSuiteDesc = "Scalar Multiplication " & $EC.F.C & " " & G1_or_G2 & " vs SageMath" + const testSuiteDesc = "Scalar Multiplication " & $EC.F.C & " " & G1_or_G2 & " vs SageMath - " & $bits & "-bit scalar" - suite testSuiteDesc & " [" & $WordBitWidth & "-bit mode]": + suite testSuiteDesc & " [" & $WordBitWidth & "-bit words]": for i in 0 ..< vec.vectors.len: - test "test " & $vec.vectors[i].id & " - " & $EC: + test "test " & $vec.vectors[i].id & " - " & $EC & " - " & $bits & "-bit scalar": var P{.noInit.}: EC Q {.noInit.}: EC impl {.noInit.}: EC reference {.noInit.}: EC - endo {.noInit.}: EC + refMinWeight {.noInit.}: EC P.fromAffine(vec.vectors[i].P) Q.fromAffine(vec.vectors[i].Q) impl = P reference = P - endo = P + refMinWeight = P impl.scalarMulGeneric(vec.vectors[i].scalar) - reference.unsafe_ECmul_double_add(vec.vectors[i].scalar) - endo.scalarMulEndo(vec.vectors[i].scalar) + reference.scalarMul_doubleAdd_vartime(vec.vectors[i].scalar) + refMinWeight.scalarMul_minHammingWeight_vartime(vec.vectors[i].scalar) doAssert: bool(Q == reference) doAssert: bool(Q == impl) - doAssert: bool(Q == endo) + doAssert: bool(Q == refMinWeight) - when EC.F is Fp: # Test windowed endomorphism acceleration - var endoW = P - endoW.scalarMulGLV_m2w2(vec.vectors[i].scalar) - doAssert: bool(Q == endoW) + staticFor w, 2, 14: + var refWNAF = P + refWNAF.scalarMul_minHammingWeight_windowed_vartime(vec.vectors[i].scalar, window = w) + check: bool(impl == refWNAF) + + when bits >= EndomorphismThreshold: # All endomorphisms constants are below this threshold + var endo = P + endo.scalarMulEndo(vec.vectors[i].scalar) + doAssert: bool(Q == endo) + + when EC.F is Fp: # Test windowed endomorphism acceleration + var endoW = P + endoW.scalarMulGLV_m2w2(vec.vectors[i].scalar) + doAssert: bool(Q == endoW) diff --git a/tests/math/t_ec_sage_vesta.nim b/tests/math/t_ec_sage_vesta.nim index 63ae6fe..29f215c 100644 --- a/tests/math/t_ec_sage_vesta.nim +++ b/tests/math/t_ec_sage_vesta.nim @@ -15,12 +15,13 @@ import # Test utilities ./t_ec_sage_template -run_scalar_mul_test_vs_sage( - ECP_ShortW_Prj[Fp[Vesta], G1], - "t_ec_sage_vesta_g1_projective" -) +staticFor(bits, [Vesta.getCurveOrderBitwidth()]): + run_scalar_mul_test_vs_sage( + ECP_ShortW_Prj[Fp[Vesta], G1], bits, + "t_ec_sage_vesta_g1_projective" + ) -run_scalar_mul_test_vs_sage( - ECP_ShortW_Jac[Fp[Vesta], G1], - "t_ec_sage_vesta_g1_jacobian" -) + run_scalar_mul_test_vs_sage( + ECP_ShortW_Jac[Fp[Vesta], G1], bits, + "t_ec_sage_vesta_g1_jacobian" + ) diff --git a/tests/math/t_ec_shortw_jac_g1_msm.nim b/tests/math/t_ec_shortw_jac_g1_msm.nim new file mode 100644 index 0000000..1e1fa8e --- /dev/null +++ b/tests/math/t_ec_shortw_jac_g1_msm.nim @@ -0,0 +1,29 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../../constantine/math/config/curves, + ../../constantine/math/elliptic/ec_shortweierstrass_jacobian, + ../../constantine/math/arithmetic, + # Test utilities + ./t_ec_template + +const numPoints = [1, 2, 8, 16, 32, 64, 128, 1024, 2048, 16384] # 32768, 262144, 1048576] + +run_EC_multi_scalar_mul_impl( + ec = ECP_ShortW_Jac[Fp[BN254_Snarks], G1], + numPoints = numPoints, + moduleName = "test_ec_shortweierstrass_jacobian_multi_scalar_mul_" & $BN254_Snarks + ) + +run_EC_multi_scalar_mul_impl( + ec = ECP_ShortW_Jac[Fp[BLS12_381], G1], + numPoints = numPoints, + moduleName = "test_ec_shortweierstrass_jacobian_multi_scalar_mul_" & $BLS12_381 + ) diff --git a/tests/math/t_ec_shortw_jac_g1_mul_sanity.nim b/tests/math/t_ec_shortw_jac_g1_mul_sanity.nim index 0b2e3f0..4c1ca9b 100644 --- a/tests/math/t_ec_shortw_jac_g1_mul_sanity.nim +++ b/tests/math/t_ec_shortw_jac_g1_mul_sanity.nim @@ -16,7 +16,7 @@ import ../../constantine/math/elliptic/[ec_shortweierstrass_affine, ec_shortweierstrass_jacobian, ec_scalar_mul], # Test utilities ../../helpers/prng_unsafe, - ./support/ec_reference_scalar_mult, + ../../constantine/math/elliptic/ec_scalar_mul_vartime, ./t_ec_template const @@ -50,7 +50,7 @@ suite "Order checks on BN254_Snarks": reference = a impl.scalarMulGeneric(exponent) - reference.unsafe_ECmul_double_add(exponent) + reference.scalarMul_doubleAdd_vartime(exponent) check: bool(impl.isInf()) diff --git a/tests/math/t_ec_shortw_jac_g1_batch_add.nim b/tests/math/t_ec_shortw_jac_g1_sum_reduce.nim similarity index 100% rename from tests/math/t_ec_shortw_jac_g1_batch_add.nim rename to tests/math/t_ec_shortw_jac_g1_sum_reduce.nim diff --git a/tests/math/t_ec_shortw_jacext_g1_add_double.nim b/tests/math/t_ec_shortw_jacext_g1_add_double.nim new file mode 100644 index 0000000..17d28f7 --- /dev/null +++ b/tests/math/t_ec_shortw_jacext_g1_add_double.nim @@ -0,0 +1,53 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../../constantine/math/config/[type_ff, curves], + ../../constantine/math/elliptic/ec_shortweierstrass_jacobian_extended, + # Test utilities + ./t_ec_template + +const + Iters = 6 + +run_EC_addition_tests( + ec = ECP_ShortW_JacExt[Fp[BN254_Snarks], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extended_g1_add_double_" & $BN254_Snarks + ) + +run_EC_addition_tests( + ec = ECP_ShortW_JacExt[Fp[BLS12_381], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extended_g1_add_double_" & $BLS12_381 + ) + +run_EC_addition_tests( + ec = ECP_ShortW_JacExt[Fp[BLS12_377], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extended_g1_add_double_" & $BLS12_377 + ) + +run_EC_addition_tests( + ec = ECP_ShortW_JacExt[Fp[BW6_761], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extended_g1_add_double_" & $BW6_761 + ) + +run_EC_addition_tests( + ec = ECP_ShortW_JacExt[Fp[Pallas], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extended_g1_add_double_" & $Pallas + ) + +run_EC_addition_tests( + ec = ECP_ShortW_JacExt[Fp[Vesta], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extended_g1_add_double_" & $Vesta + ) diff --git a/tests/math/t_ec_shortw_jacext_g1_mixed_add.nim b/tests/math/t_ec_shortw_jacext_g1_mixed_add.nim new file mode 100644 index 0000000..540078b --- /dev/null +++ b/tests/math/t_ec_shortw_jacext_g1_mixed_add.nim @@ -0,0 +1,54 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../../constantine/math/config/curves, + ../../constantine/math/elliptic/ec_shortweierstrass_jacobian_extended, + ../../constantine/math/arithmetic, + # Test utilities + ./t_ec_template + +const + Iters = 6 + +run_EC_mixed_add_impl( + ec = ECP_ShortW_JacExt[Fp[BN254_Snarks], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extendedmixed_add_" & $BN254_Snarks + ) + +run_EC_mixed_add_impl( + ec = ECP_ShortW_JacExt[Fp[BLS12_381], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extendedmixed_add_" & $BLS12_381 + ) + +run_EC_mixed_add_impl( + ec = ECP_ShortW_JacExt[Fp[BLS12_377], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extendedmixed_add_" & $BLS12_377 + ) + +run_EC_mixed_add_impl( + ec = ECP_ShortW_JacExt[Fp[BW6_761], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extendedmixed_add_" & $BW6_761 + ) + +run_EC_mixed_add_impl( + ec = ECP_ShortW_JacExt[Fp[Pallas], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extendedmixed_add_" & $Pallas + ) + +run_EC_mixed_add_impl( + ec = ECP_ShortW_JacExt[Fp[Vesta], G1], + Iters = Iters, + moduleName = "test_ec_shortweierstrass_jacobian_extendedmixed_add_" & $Vesta + ) diff --git a/tests/math/t_ec_shortw_jacext_g1_sum_reduce.nim b/tests/math/t_ec_shortw_jacext_g1_sum_reduce.nim new file mode 100644 index 0000000..5ebdc9a --- /dev/null +++ b/tests/math/t_ec_shortw_jacext_g1_sum_reduce.nim @@ -0,0 +1,29 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../../constantine/math/config/curves, + ../../constantine/math/elliptic/ec_shortweierstrass_jacobian_extended, + ../../constantine/math/arithmetic, + # Test utilities + ./t_ec_template + +const numPoints = [1, 2, 8, 16, 128, 1024, 2048, 16384, 32768] # 262144, 1048576] + +run_EC_batch_add_impl( + ec = ECP_ShortW_JacExt[Fp[BN254_Snarks], G1], + numPoints = numPoints, + moduleName = "test_ec_shortweierstrass_jacobian_extended_batch_add_" & $BN254_Snarks + ) + +run_EC_batch_add_impl( + ec = ECP_ShortW_JacExt[Fp[BLS12_381], G1], + numPoints = numPoints, + moduleName = "test_ec_shortweierstrass_jacobian_extended_batch_add_" & $BLS12_381 + ) diff --git a/tests/math/t_ec_shortw_prj_g1_msm.nim b/tests/math/t_ec_shortw_prj_g1_msm.nim new file mode 100644 index 0000000..b9a93de --- /dev/null +++ b/tests/math/t_ec_shortw_prj_g1_msm.nim @@ -0,0 +1,29 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Internals + ../../constantine/math/config/curves, + ../../constantine/math/elliptic/ec_shortweierstrass_projective, + ../../constantine/math/arithmetic, + # Test utilities + ./t_ec_template + +const numPoints = [1, 2, 8, 16, 128, 1024, 2048, 16384] # 32768, 262144, 1048576] + +run_EC_multi_scalar_mul_impl( + ec = ECP_ShortW_Prj[Fp[BN254_Snarks], G1], + numPoints = numPoints, + moduleName = "test_ec_shortweierstrass_projective_multi_scalar_mul_" & $BN254_Snarks + ) + +run_EC_multi_scalar_mul_impl( + ec = ECP_ShortW_Prj[Fp[BLS12_381], G1], + numPoints = numPoints, + moduleName = "test_ec_shortweierstrass_projective_multi_scalar_mul_" & $BLS12_381 + ) diff --git a/tests/math/t_ec_shortw_prj_g1_mul_sanity.nim b/tests/math/t_ec_shortw_prj_g1_mul_sanity.nim index 821548d..8cac4f5 100644 --- a/tests/math/t_ec_shortw_prj_g1_mul_sanity.nim +++ b/tests/math/t_ec_shortw_prj_g1_mul_sanity.nim @@ -15,7 +15,7 @@ import ../../constantine/math/elliptic/[ec_shortweierstrass_affine, ec_shortweierstrass_projective, ec_scalar_mul], # Test utilities ../../helpers/prng_unsafe, - ./support/ec_reference_scalar_mult, + ../../constantine/math/elliptic/ec_scalar_mul_vartime, ./t_ec_template const @@ -49,7 +49,7 @@ suite "Order checks on BN254_Snarks": reference = a impl.scalarMulGeneric(exponent) - reference.unsafe_ECmul_double_add(exponent) + reference.scalarMul_doubleAdd_vartime(exponent) check: bool(impl.isInf()) diff --git a/tests/math/t_ec_shortw_prj_g1_batch_add.nim b/tests/math/t_ec_shortw_prj_g1_sum_reduce.nim similarity index 100% rename from tests/math/t_ec_shortw_prj_g1_batch_add.nim rename to tests/math/t_ec_shortw_prj_g1_sum_reduce.nim diff --git a/tests/math/t_ec_template.nim b/tests/math/t_ec_template.nim index b75d6b4..dcd17c2 100644 --- a/tests/math/t_ec_template.nim +++ b/tests/math/t_ec_template.nim @@ -22,19 +22,36 @@ import ../../constantine/math/elliptic/[ ec_shortweierstrass_affine, ec_shortweierstrass_jacobian, + ec_shortweierstrass_jacobian_extended, ec_shortweierstrass_projective, ec_shortweierstrass_batch_ops, ec_twistededwards_affine, ec_twistededwards_projective, - ec_scalar_mul], + ec_scalar_mul, + ec_multi_scalar_mul], ../../constantine/math/io/[io_bigints, io_fields, io_ec], ../../constantine/math/constants/zoo_subgroups, # Test utilities ../../helpers/prng_unsafe, - ./support/ec_reference_scalar_mult + ../../constantine/math/elliptic/ec_scalar_mul_vartime export unittest, abstractions, arithmetic # Generic sandwich +# Extended Jacobian generic bindings +# ---------------------------------- +# All vartime procedures MUST be tagged vartime +# Hence we do not expose `sum` or `+=` for extended jacobian operation to prevent `vartime` mistakes +# we create a local `sum` or `+=` for this module only + +func sum[F; G: static Subgroup](r: var ECP_ShortW_JacExt[F, G], P, Q: ECP_ShortW_JacExt[F, G]) = + r.sum_vartime(P, Q) +func `+=`[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_JacExt[F, G]) = + P.sum_vartime(P, Q) +func madd[F; G: static Subgroup](r: var ECP_ShortW_JacExt[F, G], P: ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_Aff[F, G]) = + r.madd_vartime(P, Q) +func `+=`[F; G: static Subgroup](P: var ECP_ShortW_JacExt[F, G], Q: ECP_ShortW_Aff[F, G]) = + P.madd_vartime(P, Q) + type RandomGen* = enum Uniform @@ -65,15 +82,6 @@ func random_point*(rng: var RngState, EC: typedesc, randZ: bool, gen: RandomGen) else: result = rng.random_long01Seq_with_randZ(EC) -template pairingGroup(EC: typedesc): string = - when EC is (ECP_ShortW_Aff or ECP_ShortW_Prj or ECP_ShortW_Jac): - when EC.G == G1: - "G1" - else: - "G2" - else: - "" - proc run_EC_addition_tests*( ec: typedesc, Iters: static int, @@ -87,12 +95,10 @@ proc run_EC_addition_tests*( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - const G1_or_G2 = pairingGroup(ec) - const testSuiteDesc = "Elliptic curve in " & $ec.F.C.getEquationForm() & " form with projective coordinates" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": - test "The infinity point is the neutral element w.r.t. to EC " & G1_or_G2 & " addition": + test "The infinity point is the neutral element w.r.t. to EC " & $ec.G & " addition": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = var inf {.noInit.}: EC inf.setInf() @@ -124,6 +130,40 @@ proc run_EC_addition_tests*( test(ec, randZ = false, gen = Long01Sequence) test(ec, randZ = true, gen = Long01Sequence) + test "Infinity point from affine conversion gives proper result": + proc test(EC: typedesc, randZ: bool, gen: RandomGen) = + var affInf {.noInit.}: affine(EC) + var inf {.noInit.}: EC + affInf.setInf() + inf.fromAffine(affInf) + check: bool inf.isInf() + + for _ in 0 ..< Iters: + var r{.noInit.}: EC + let P = rng.random_point(EC, randZ, gen) + + r.sum(P, inf) + check: bool(r == P) + + r.sum(inf, P) + check: bool(r == P) + + # Aliasing tests + r = P + r += inf + check: bool(r == P) + + r = inf + r += P + check: bool(r == P) + + test(ec, randZ = false, gen = Uniform) + test(ec, randZ = true, gen = Uniform) + test(ec, randZ = false, gen = HighHammingWeight) + test(ec, randZ = true, gen = HighHammingWeight) + test(ec, randZ = false, gen = Long01Sequence) + test(ec, randZ = true, gen = Long01Sequence) + test "Adding opposites gives an infinity point": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: @@ -145,7 +185,7 @@ proc run_EC_addition_tests*( test(ec, randZ = false, gen = Long01Sequence) test(ec, randZ = true, gen = Long01Sequence) - test "EC " & G1_or_G2 & " add is commutative": + test "EC " & $ec.G & " add is commutative": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: var r0{.noInit.}, r1{.noInit.}: EC @@ -163,7 +203,7 @@ proc run_EC_addition_tests*( test(ec, randZ = false, gen = Long01Sequence) test(ec, randZ = true, gen = Long01Sequence) - test "EC " & G1_or_G2 & " add is associative": + test "EC " & $ec.G & " add is associative": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: let a = rng.random_point(EC, randZ, gen) @@ -212,7 +252,7 @@ proc run_EC_addition_tests*( test(ec, randZ = false, gen = Long01Sequence) test(ec, randZ = true, gen = Long01Sequence) - test "EC " & G1_or_G2 & " double and EC " & G1_or_G2 & " add are consistent": + test "EC " & $ec.G & " double and EC " & $ec.G & " add are consistent": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: let a = rng.random_point(EC, randZ, gen) @@ -244,12 +284,10 @@ proc run_EC_mul_sanity_tests*( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - const G1_or_G2 = pairingGroup(ec) - const testSuiteDesc = "Elliptic curve in " & $ec.F.C.getEquationForm() & " form" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": - test "EC " & G1_or_G2 & " mul [0]P == Inf": + test "EC " & $ec.G & " mul [0]P == Inf": proc test(EC: typedesc, bits: static int, randZ: bool, gen: RandomGen) = for _ in 0 ..< ItersMul: let a = rng.random_point(EC, randZ, gen) @@ -259,7 +297,7 @@ proc run_EC_mul_sanity_tests*( reference = a impl.scalarMulGeneric(BigInt[bits]()) - reference.unsafe_ECmul_double_add(BigInt[bits]()) + reference.scalarMul_doubleAdd_vartime(BigInt[bits]()) check: bool(impl.isInf()) @@ -272,7 +310,7 @@ proc run_EC_mul_sanity_tests*( test(ec, bits = ec.F.C.getCurveOrderBitwidth(), randZ = false, gen = Long01Sequence) test(ec, bits = ec.F.C.getCurveOrderBitwidth(), randZ = true, gen = Long01Sequence) - test "EC " & G1_or_G2 & " mul [1]P == P": + test "EC " & $ec.G & " mul [1]P == P": proc test(EC: typedesc, bits: static int, randZ: bool, gen: RandomGen) = for _ in 0 ..< ItersMul: let a = rng.random_point(EC, randZ, gen) @@ -285,7 +323,7 @@ proc run_EC_mul_sanity_tests*( reference = a impl.scalarMulGeneric(exponent) - reference.unsafe_ECmul_double_add(exponent) + reference.scalarMul_doubleAdd_vartime(exponent) check: bool(impl == a) @@ -298,7 +336,7 @@ proc run_EC_mul_sanity_tests*( test(ec, bits = ec.F.C.getCurveOrderBitwidth(), randZ = false, gen = Long01Sequence) test(ec, bits = ec.F.C.getCurveOrderBitwidth(), randZ = true, gen = Long01Sequence) - test "EC " & G1_or_G2 & " mul [2]P == P.double()": + test "EC " & $ec.G & " mul [2]P == P.double()": proc test(EC: typedesc, bits: static int, randZ: bool, gen: RandomGen) = for _ in 0 ..< ItersMul: let a = rng.random_point(EC, randZ, gen) @@ -313,7 +351,7 @@ proc run_EC_mul_sanity_tests*( reference = a impl.scalarMulGeneric(exponent) - reference.unsafe_ECmul_double_add(exponent) + reference.scalarMul_doubleAdd_vartime(exponent) check: bool(impl == doubleA) @@ -339,13 +377,11 @@ proc run_EC_mul_distributive_tests*( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - const G1_or_G2 = pairingGroup(ec) - const testSuiteDesc = "Elliptic curve in " & $ec.F.C.getEquationForm() & " form" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": - test "EC " & G1_or_G2 & " mul is distributive over EC add": + test "EC " & $ec.G & " mul is distributive over EC add": proc test(EC: typedesc, bits: static int, randZ: bool, gen: RandomGen) = for _ in 0 ..< ItersMul: let a = rng.random_point(EC, randZ, gen) @@ -362,20 +398,20 @@ proc run_EC_mul_distributive_tests*( fReference.sum(a, b) fImpl.scalarMulGeneric(exponent) - fReference.unsafe_ECmul_double_add(exponent) + fReference.scalarMul_doubleAdd_vartime(exponent) # [k]a + [k]b - Distributed var kaImpl = a var kaRef = a kaImpl.scalarMulGeneric(exponent) - kaRef.unsafe_ECmul_double_add(exponent) + kaRef.scalarMul_doubleAdd_vartime(exponent) var kbImpl = b var kbRef = b kbImpl.scalarMulGeneric(exponent) - kbRef.unsafe_ECmul_double_add(exponent) + kbRef.scalarMul_doubleAdd_vartime(exponent) var kakbImpl{.noInit.}, kakbRef{.noInit.}: EC kakbImpl.sum(kaImpl, kbImpl) @@ -406,17 +442,16 @@ proc run_EC_mul_vs_ref_impl*( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - const G1_or_G2 = pairingGroup(ec) - const testSuiteDesc = "Elliptic curve in " & $ec.F.C.getEquationForm() & " form" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": - test "EC " & G1_or_G2 & " mul constant-time is equivalent to a simple double-and-add algorithm": + test "EC " & $ec.G & " mul constant-time is equivalent to a simple double-and-add and recoded algorithms": proc test(EC: typedesc, bits: static int, randZ: bool, gen: RandomGen) = for _ in 0 ..< ItersMul: let a = rng.random_point(EC, randZ, gen) - let exponent = rng.random_unsafe(BigInt[bits]) + # We want to test how window methods handles unbalanced 0/1 + let exponent = rng.random_long01Seq(BigInt[bits]) var impl = a @@ -424,13 +459,24 @@ proc run_EC_mul_vs_ref_impl*( refMinWeight = a impl.scalarMulGeneric(exponent) - reference.unsafe_ECmul_double_add(exponent) - refMinWeight.unsafe_ECmul_minHammingWeight(exponent) + reference.scalarMul_doubleAdd_vartime(exponent) + refMinWeight.scalarMul_minHammingWeight_vartime(exponent) check: bool(impl == reference) bool(impl == refMinWeight) + proc refWNaf(w: static int) = # workaround staticFor symbol visibility + var refWNAF = a + refWNAF.scalarMul_minHammingWeight_windowed_vartime(exponent, window = w) + check: bool(impl == refWNAF) + + refWNaf(2) + refWNaf(3) + refWNaf(5) + refWNaf(8) + refWNaf(13) + test(ec, bits = ec.F.C.getCurveOrderBitwidth(), randZ = false, gen = Uniform) test(ec, bits = ec.F.C.getCurveOrderBitwidth(), randZ = true, gen = Uniform) test(ec, bits = ec.F.C.getCurveOrderBitwidth(), randZ = false, gen = HighHammingWeight) @@ -451,15 +497,10 @@ proc run_EC_mixed_add_impl*( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - when ec.G == G1: - const G1_or_G2 = "G1" - else: - const G1_or_G2 = "G2" - const testSuiteDesc = "Elliptic curve mixed addition for Short Weierstrass form" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": - test "EC " & G1_or_G2 & " mixed addition is consistent with general addition": + test "EC " & $ec.G & " mixed addition is consistent with general addition": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: let a = rng.random_point(EC, randZ, gen) @@ -481,7 +522,7 @@ proc run_EC_mixed_add_impl*( test(ec, randZ = false, gen = Long01Sequence) test(ec, randZ = true, gen = Long01Sequence) - test "EC " & G1_or_G2 & " mixed addition - doubling": + test "EC " & $ec.G & " mixed addition - doubling": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: let a = rng.random_point(EC, randZ, gen) @@ -506,7 +547,7 @@ proc run_EC_mixed_add_impl*( test(ec, randZ = false, gen = Long01Sequence) test(ec, randZ = true, gen = Long01Sequence) - test "EC " & G1_or_G2 & " mixed addition - adding infinity LHS": + test "EC " & $ec.G & " mixed addition - adding infinity LHS": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: var a{.noInit.}: EC @@ -529,7 +570,31 @@ proc run_EC_mixed_add_impl*( test(ec, randZ = false, gen = HighHammingWeight) test(ec, randZ = false, gen = Long01Sequence) - test "EC " & G1_or_G2 & " mixed addition - adding infinity RHS": + test "EC " & $ec.G & " mixed addition - adding infinity RHS": + proc test(EC: typedesc, randZ: bool, gen: RandomGen) = + for _ in 0 ..< Iters: + let a = rng.random_point(EC, randZ, gen) + var naAff{.noInit.}: ECP_ShortW_Aff[EC.F, EC.G] + naAff.affine(a) + naAff.neg() + + var r{.noInit.}: EC + r.madd(a, naAff) + + check: r.isInf().bool + + r = a + r += naAff + check: r.isInf().bool + + test(ec, randZ = false, gen = Uniform) + test(ec, randZ = true, gen = Uniform) + test(ec, randZ = false, gen = HighHammingWeight) + test(ec, randZ = true, gen = HighHammingWeight) + test(ec, randZ = false, gen = Long01Sequence) + test(ec, randZ = true, gen = Long01Sequence) + + test "EC " & $ec.G & " mixed addition - adding opposites": proc test(EC: typedesc, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: let a = rng.random_point(EC, randZ, gen) @@ -564,11 +629,6 @@ proc run_EC_subgroups_cofactors_impl*( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - when ec.G == G1: - const G1_or_G2 = "G1" - else: - const G1_or_G2 = "G2" - const testSuiteDesc = "Elliptic curve subgroup check and cofactor clearing" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": @@ -626,7 +686,7 @@ proc run_EC_subgroups_cofactors_impl*( test(ec, randZ = false, gen = Long01Sequence) test(ec, randZ = true, gen = Long01Sequence) - echo " [SUCCESS] Test finished with ", inSubgroup, " points in ", G1_or_G2, " subgroup and ", + echo " [SUCCESS] Test finished with ", inSubgroup, " points in ", $ec.G, " subgroup and ", offSubgroup, " points on curve but not in subgroup (before cofactor clearing)" proc run_EC_affine_conversion*( @@ -642,12 +702,10 @@ proc run_EC_affine_conversion*( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - const G1_or_G2 = pairingGroup(ec) - const testSuiteDesc = "Elliptic curve in " & $ec.F.C.getEquationForm() & " form" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": - test "EC " & G1_or_G2 & " batchAffine is consistent with single affine conversion": + test "EC " & $ec.G & " batchAffine is consistent with single affine conversion": proc test(EC: typedesc, gen: RandomGen) = const batchSize = 10 for _ in 0 ..< Iters: @@ -807,16 +865,11 @@ proc run_EC_batch_add_impl*[N: static int]( echo "\n------------------------------------------------------\n" echo moduleName, " xoshiro512** seed: ", seed - when ec.G == G1: - const G1_or_G2 = "G1" - else: - const G1_or_G2 = "G2" - - const testSuiteDesc = "Elliptic curve batch addition for Short Weierstrass form" + const testSuiteDesc = "Elliptic curve sum reduction for Short Weierstrass form" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": for n in numPoints: - test $ec & " batch addition (N=" & $n & ")": + test $ec & " sum reduction (N=" & $n & ")": proc test(EC: typedesc, gen: RandomGen) = var points = newSeq[ECP_ShortW_Aff[EC.F, EC.G]](n) @@ -829,7 +882,7 @@ proc run_EC_batch_add_impl*[N: static int]( for i in 0 ..< n: r_ref += points[i] - r_batch.sum_batch_vartime(points) + r_batch.sum_reduce_vartime(points) check: bool(r_batch == r_ref) @@ -838,7 +891,7 @@ proc run_EC_batch_add_impl*[N: static int]( test(ec, gen = HighHammingWeight) test(ec, gen = Long01Sequence) - test "EC " & G1_or_G2 & " batch addition (N=" & $n & ") - special cases": + test "EC " & $ec.G & " sum reduction (N=" & $n & ") - special cases": proc test(EC: typedesc, gen: RandomGen) = var points = newSeq[ECP_ShortW_Aff[EC.F, EC.G]](n) @@ -864,10 +917,57 @@ proc run_EC_batch_add_impl*[N: static int]( for i in 0 ..< n: r_ref += points[i] - r_batch.sum_batch_vartime(points) + r_batch.sum_reduce_vartime(points) check: bool(r_batch == r_ref) test(ec, gen = Uniform) test(ec, gen = HighHammingWeight) test(ec, gen = Long01Sequence) + +proc run_EC_multi_scalar_mul_impl*[N: static int]( + ec: typedesc, + numPoints: array[N, int], + moduleName: string + ) = + + # Random seed for reproducibility + var rng: RngState + let seed = uint32(getTime().toUnix() and (1'i64 shl 32 - 1)) # unixTime mod 2^32 + rng.seed(seed) + echo "\n------------------------------------------------------\n" + echo moduleName, " xoshiro512** seed: ", seed + + const testSuiteDesc = "Elliptic curve multi-scalar-multiplication for Short Weierstrass form" + + suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": + for n in numPoints: + let bucketBits = bestBucketBitSize(n, ec.F.C.getCurveOrderBitwidth(), useSignedBuckets = false, useManualTuning = false) + test $ec & " Multi-scalar-mul (N=" & $n & ", bucket bits: " & $bucketBits & ")": + proc test(EC: typedesc, gen: RandomGen) = + var points = newSeq[ECP_ShortW_Aff[EC.F, EC.G]](n) + var coefs = newSeq[BigInt[EC.F.C.getCurveOrderBitwidth()]](n) + + for i in 0 ..< n: + var tmp = rng.random_unsafe(EC) + tmp.clearCofactor() + points[i].affine(tmp) + coefs[i] = rng.random_unsafe(BigInt[EC.F.C.getCurveOrderBitwidth()]) + + var naive, naive_tmp: EC + naive.setInf() + for i in 0 ..< n: + naive_tmp.fromAffine(points[i]) + naive_tmp.scalarMulGeneric(coefs[i]) + naive += naive_tmp + + var msm_ref, msm: EC + msm_ref.multiScalarMul_reference_vartime(coefs, points) + msm.multiScalarMul_vartime(coefs, points) + + doAssert bool(naive == msm_ref) + doAssert bool(naive == msm) + + test(ec, gen = Uniform) + test(ec, gen = HighHammingWeight) + test(ec, gen = Long01Sequence) \ No newline at end of file diff --git a/tests/math/t_finite_fields_double_precision.nim b/tests/math/t_finite_fields_double_precision.nim index f521838..5fb6a6a 100644 --- a/tests/math/t_finite_fields_double_precision.nim +++ b/tests/math/t_finite_fields_double_precision.nim @@ -125,7 +125,7 @@ sqrTest(random_unsafe) sqrTest(randomHighHammingWeight) sqrTest(random_long01Seq) -suite "Field Addition/Substraction/Negation via double-precision field elements" & " [" & $WordBitWidth & "-bit mode]": +suite "Field Addition/Substraction/Negation via double-precision field elements" & " [" & $WordBitWidth & "-bit words]": test "With P-224 field modulus": for _ in 0 ..< Iters: addsubneg_random_unsafe(P224) @@ -197,7 +197,7 @@ suite "Field Addition/Substraction/Negation via double-precision field elements" check: bool r.isZero() -suite "Field Multiplication via double-precision field elements is consistent with single-width." & " [" & $WordBitWidth & "-bit mode]": +suite "Field Multiplication via double-precision field elements is consistent with single-width." & " [" & $WordBitWidth & "-bit words]": test "With P-224 field modulus": for _ in 0 ..< Iters: mul_random_unsafe(P224) @@ -262,7 +262,7 @@ suite "Field Multiplication via double-precision field elements is consistent wi for _ in 0 ..< Iters: mul_random_long01Seq(Vesta) -suite "Field Squaring via double-precision field elements is consistent with single-width." & " [" & $WordBitWidth & "-bit mode]": +suite "Field Squaring via double-precision field elements is consistent with single-width." & " [" & $WordBitWidth & "-bit words]": test "With P-224 field modulus": for _ in 0 ..< Iters: sqr_random_unsafe(P224) diff --git a/tests/math/t_finite_fields_mulsquare.nim b/tests/math/t_finite_fields_mulsquare.nim index af5f641..605c926 100644 --- a/tests/math/t_finite_fields_mulsquare.nim +++ b/tests/math/t_finite_fields_mulsquare.nim @@ -78,7 +78,7 @@ proc sanity(C: static Curve) = bool(n == expected) proc mainSanity() = - suite "Modular squaring is consistent with multiplication on special elements" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular squaring is consistent with multiplication on special elements" & " [" & $WordBitWidth & "-bit words]": sanity Fake101 sanity Mersenne61 sanity Mersenne127 @@ -94,7 +94,7 @@ proc mainSanity() = mainSanity() proc mainSelectCases() = - suite "Modular Squaring: selected tricky cases" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular Squaring: selected tricky cases" & " [" & $WordBitWidth & "-bit words]": test "P-256 [FastSquaring = " & $(Fp[P256].getSpareBits() >= 2) & "]": block: # Triggered an issue in the (t[N+1], t[N]) = t[N] + (A1, A0) @@ -141,7 +141,7 @@ proc random_long01Seq(C: static Curve) = doAssert bool(r_mul == r_sqr) -suite "Random Modular Squaring is consistent with Modular Multiplication" & " [" & $WordBitWidth & "-bit mode]": +suite "Random Modular Squaring is consistent with Modular Multiplication" & " [" & $WordBitWidth & "-bit words]": test "Random squaring mod P-224 [FastSquaring = " & $(Fp[P224].getSpareBits() >= 2) & "]": for _ in 0 ..< Iters: randomCurve(P224) @@ -341,7 +341,7 @@ proc random_sumprod(C: static Curve, N: static int) = for i in 0 ..< N: a[i].setMinusOne() b[i].setMinusOne() - + var r, r_ref, t: Fp[C] r_ref.prod(a[0], b[0]) @@ -358,8 +358,8 @@ proc random_sumprod(C: static Curve, N: static int) = sumprod_test(random_long01Seq) sumProdMax() -suite "Random sum products is consistent with naive " & " [" & $WordBitWidth & "-bit mode]": - +suite "Random sum products is consistent with naive " & " [" & $WordBitWidth & "-bit words]": + const MaxLength = 8 test "Random sum products mod P-224]": for _ in 0 ..< Iters: diff --git a/tests/math/t_finite_fields_powinv.nim b/tests/math/t_finite_fields_powinv.nim index dda04c9..3726dd8 100644 --- a/tests/math/t_finite_fields_powinv.nim +++ b/tests/math/t_finite_fields_powinv.nim @@ -29,7 +29,7 @@ echo "\n------------------------------------------------------\n" echo "test_finite_fields_powinv xoshiro512** seed: ", seed proc main() = - suite "Modular exponentiation over finite fields" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular exponentiation over finite fields" & " [" & $WordBitWidth & "-bit words]": test "n² mod 101": let exponent = BigInt[64].fromUint(2'u64) @@ -202,7 +202,7 @@ proc main() = testRandomDiv2 Pallas testRandomDiv2 Vesta - suite "Modular inversion over prime fields" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular inversion over prime fields" & " [" & $WordBitWidth & "-bit words]": test "Specific tests on Fp[BLS12_381]": block: # No inverse exist for 0 --> should return 0 for projective/jacobian to affine coordinate conversion var r, x: Fp[BLS12_381] @@ -210,12 +210,20 @@ proc main() = r.inv(x) check: bool r.isZero() + var r2: Fp[BLS12_381] + r2.inv_vartime(x) + check: bool r2.isZero() + block: var r, x: Fp[BLS12_381] x.setOne() r.inv(x) check: bool r.isOne() + var r2: Fp[BLS12_381] + r2.inv_vartime(x) + check: bool r2.isOne() + block: var r, x: Fp[BLS12_381] @@ -229,6 +237,10 @@ proc main() = check: computed == expected + var r2: Fp[BLS12_381] + r2.inv_vartime(x) + let computed2 = r2.toHex() + test "Specific tests on Fp[BN254_Snarks]": block: var r, x: Fp[BN254_Snarks] @@ -244,6 +256,10 @@ proc main() = r.inv(x) check: bool(r == expected) + var r2: Fp[BN254_Snarks] + r2.inv_vartime(x) + check: bool(r2 == expected) + block: var r, x, expected: Fp[BN254_Snarks] x.fromHex"0x0d2007d8aaface1b8501bfbe792974166e8f9ad6106e5b563604f0aea9ab06f6" @@ -252,6 +268,10 @@ proc main() = r.inv(x) check: bool(r == expected) + var r2: Fp[BN254_Snarks] + r2.inv_vartime(x) + check: bool(r2 == expected) + proc testRandomInv(curve: static Curve) = test "Random inversion testing on " & $Curve(curve): var aInv, r: Fp[curve] @@ -264,6 +284,12 @@ proc main() = r.prod(aInv, a) check: bool r.isOne() or (a.isZero() and r.isZero()) + aInv.inv_vartime(a) + r.prod(a, aInv) + check: bool r.isOne() or (a.isZero() and r.isZero()) + r.prod(aInv, a) + check: bool r.isOne() or (a.isZero() and r.isZero()) + for _ in 0 ..< Iters: let a = rng.randomHighHammingWeight(Fp[curve]) aInv.inv(a) @@ -272,6 +298,11 @@ proc main() = r.prod(aInv, a) check: bool r.isOne() or (a.isZero() and r.isZero()) + aInv.inv_vartime(a) + r.prod(a, aInv) + check: bool r.isOne() or (a.isZero() and r.isZero()) + r.prod(aInv, a) + check: bool r.isOne() or (a.isZero() and r.isZero()) for _ in 0 ..< Iters: let a = rng.random_long01Seq(Fp[curve]) aInv.inv(a) @@ -280,6 +311,12 @@ proc main() = r.prod(aInv, a) check: bool r.isOne() or (a.isZero() and r.isZero()) + aInv.inv_vartime(a) + r.prod(a, aInv) + check: bool r.isOne() or (a.isZero() and r.isZero()) + r.prod(aInv, a) + check: bool r.isOne() or (a.isZero() and r.isZero()) + testRandomInv P224 testRandomInv BN254_Nogami testRandomInv BN254_Snarks @@ -295,7 +332,7 @@ proc main() = main() proc main_anti_regression = - suite "Bug highlighted by property-based testing" & " [" & $WordBitWidth & "-bit mode]": + suite "Bug highlighted by property-based testing" & " [" & $WordBitWidth & "-bit words]": # test "#30 - Euler's Criterion should be 1 for square on FKM12_447": # var a: Fp[FKM12_447] # # square of "0x406e5e74ee09c84fa0c59f2db3ac814a4937e2f57ecd3c0af4265e04598d643c5b772a6549a2d9b825445c34b8ba100fe8d912e61cfda43d" diff --git a/tests/math/t_finite_fields_sqrt.nim b/tests/math/t_finite_fields_sqrt.nim index 8a0b0fe..a44d29f 100644 --- a/tests/math/t_finite_fields_sqrt.nim +++ b/tests/math/t_finite_fields_sqrt.nim @@ -146,7 +146,7 @@ proc randomSqrtRatioCheck(C: static Curve) = testSqrtRatioImpl(u, v) proc main() = - suite "Modular square root" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular square root" & " [" & $WordBitWidth & "-bit words]": exhaustiveCheck Fake103, 103 # exhaustiveCheck Fake10007, 10007 # exhaustiveCheck Fake65519, 65519 @@ -160,15 +160,15 @@ proc main() = randomSqrtCheck Bandersnatch randomSqrtCheck Pallas randomSqrtCheck Vesta - - suite "Modular sqrt(u/v)" & " [" & $WordBitWidth & "-bit mode]": + + suite "Modular sqrt(u/v)" & " [" & $WordBitWidth & "-bit words]": randomSqrtRatioCheck Edwards25519 randomSqrtRatioCheck Jubjub randomSqrtRatioCheck Bandersnatch randomSqrtRatioCheck Pallas randomSqrtRatioCheck Vesta - suite "Modular square root - 32-bit bugs highlighted by property-based testing " & " [" & $WordBitWidth & "-bit mode]": + suite "Modular square root - 32-bit bugs highlighted by property-based testing " & " [" & $WordBitWidth & "-bit words]": # test "FKM12_447 - #30": - Deactivated, we don't support the curve as no one uses it. # var a: Fp[FKM12_447] # a.fromHex"0x406e5e74ee09c84fa0c59f2db3ac814a4937e2f57ecd3c0af4265e04598d643c5b772a6549a2d9b825445c34b8ba100fe8d912e61cfda43d" diff --git a/tests/math/t_fp12_exponentiation.nim b/tests/math/t_fp12_exponentiation.nim index 0d3b643..405b769 100644 --- a/tests/math/t_fp12_exponentiation.nim +++ b/tests/math/t_fp12_exponentiation.nim @@ -175,7 +175,7 @@ proc test_invpow(C: static Curve, gen: RandomGen) = doAssert: bool(xa == xqya) -suite "Exponentiation in 𝔽p12" & " [" & $WordBitWidth & "-bit mode]": +suite "Exponentiation in 𝔽p12" & " [" & $WordBitWidth & "-bit words]": staticFor(curve, TestCurves): test "xᴬ xᴮ = xᴬ⁺ᴮ on " & $curve: test_sameBaseProduct(curve, gen = Uniform) diff --git a/tests/math/t_fp2_sqrt.nim b/tests/math/t_fp2_sqrt.nim index 8f372b7..41cc13b 100644 --- a/tests/math/t_fp2_sqrt.nim +++ b/tests/math/t_fp2_sqrt.nim @@ -70,14 +70,14 @@ proc randomSqrtCheck(C: static Curve, gen: RandomGen) = bool(s == a or s == na) proc main() = - suite "Modular square root" & " [" & $WordBitWidth & "-bit mode]": + suite "Modular square root" & " [" & $WordBitWidth & "-bit words]": staticFor(curve, TestCurves): test "[𝔽p2] Random square root check for " & $curve: randomSqrtCheck(curve, gen = Uniform) randomSqrtCheck(curve, gen = HighHammingWeight) randomSqrtCheck(curve, gen = Long01Sequence) - suite "Modular square root - 32-bit bugs highlighted by property-based testing " & " [" & $WordBitWidth & "-bit mode]": + suite "Modular square root - 32-bit bugs highlighted by property-based testing " & " [" & $WordBitWidth & "-bit words]": test "sqrt_if_square invalid square BLS12_381 - #64": var a: Fp2[BLS12_381] a.fromHex( @@ -98,7 +98,7 @@ proc main() = bool not a.isSquare() bool not a.sqrt_if_square() - suite "Modular square root - Assembly bugs highlighted by property-based testing " & " [" & $WordBitWidth & "-bit mode]": + suite "Modular square root - Assembly bugs highlighted by property-based testing " & " [" & $WordBitWidth & "-bit words]": test "Don't set Neg(Zero) fields to modulus (non-unique Montgomery repr) - #136": # https://github.com/mratsim/constantine/issues/136 # and https://github.com/mratsim/constantine/issues/114 diff --git a/tests/math/t_fp_cubic_root.nim b/tests/math/t_fp_cubic_root.nim index 6b6cfd4..9075425 100644 --- a/tests/math/t_fp_cubic_root.nim +++ b/tests/math/t_fp_cubic_root.nim @@ -23,7 +23,7 @@ proc checkCubeRootOfUnity(curve: static Curve) = check: bool cru.isOne() proc main() = - suite "Sanity checks on precomputed values" & " [" & $WordBitWidth & "-bit mode]": + suite "Sanity checks on precomputed values" & " [" & $WordBitWidth & "-bit words]": checkCubeRootOfUnity(BN254_Snarks) checkCubeRootOfUnity(BLS12_377) checkCubeRootOfUnity(BLS12_381) diff --git a/tests/math/t_fp_tower_frobenius_template.nim b/tests/math/t_fp_tower_frobenius_template.nim index 8699fe0..c981171 100644 --- a/tests/math/t_fp_tower_frobenius_template.nim +++ b/tests/math/t_fp_tower_frobenius_template.nim @@ -68,7 +68,7 @@ proc runFrobeniusTowerTests*[N]( rng.seed(seed) echo moduleName, " xoshiro512** seed: ", seed - suite testSuiteDesc & " [" & $WordBitWidth & "-bit mode]": + suite testSuiteDesc & " [" & $WordBitWidth & "-bit words]": test "Frobenius(a) = a^p (mod p^" & $ExtDegree & ")": proc test(Field: typedesc, Iters: static int, gen: RandomGen) = for _ in 0 ..< Iters: diff --git a/tests/math/t_fp_tower_template.nim b/tests/math/t_fp_tower_template.nim index 0be6502..724005a 100644 --- a/tests/math/t_fp_tower_template.nim +++ b/tests/math/t_fp_tower_template.nim @@ -69,7 +69,7 @@ proc runTowerTests*[N]( rng.seed(seed) echo moduleName, " xoshiro512** seed: ", seed - suite testSuiteDesc & " [" & $WordBitWidth & "-bit mode]": + suite testSuiteDesc & " [" & $WordBitWidth & "-bit words]": test "Comparison sanity checks": proc test(Field: typedesc) = var z, o {.noInit.}: Field diff --git a/tests/math/t_fr.nim b/tests/math/t_fr.nim index d8baa52..dfaa62b 100644 --- a/tests/math/t_fr.nim +++ b/tests/math/t_fr.nim @@ -76,7 +76,7 @@ proc sanity(C: static Curve) = bool(n == expected) proc mainSanity() = - suite "Fr: Modular squaring is consistent with multiplication on special elements" & " [" & $WordBitWidth & "-bit mode]": + suite "Fr: Modular squaring is consistent with multiplication on special elements" & " [" & $WordBitWidth & "-bit words]": sanity BN254_Snarks sanity BLS12_381 @@ -112,7 +112,7 @@ proc random_long01Seq(C: static Curve) = doAssert bool(r_mul == r_sqr) -suite "Fr: Random Modular Squaring is consistent with Modular Multiplication" & " [" & $WordBitWidth & "-bit mode]": +suite "Fr: Random Modular Squaring is consistent with Modular Multiplication" & " [" & $WordBitWidth & "-bit words]": test "Random squaring mod r_BN254_Snarks [FastSquaring = " & $(Fr[BN254_Snarks].getSpareBits() >= 2) & "]": for _ in 0 ..< Iters: randomCurve(BN254_Snarks) diff --git a/tests/math/t_io_bigints.nim b/tests/math/t_io_bigints.nim index 296c1be..9649e44 100644 --- a/tests/math/t_io_bigints.nim +++ b/tests/math/t_io_bigints.nim @@ -22,7 +22,7 @@ echo "test_io_bigints xoshiro512** seed: ", seed type T = BaseType proc main() = - suite "IO Hex - BigInt" & " [" & $WordBitWidth & "-bit mode]": + suite "IO Hex - BigInt" & " [" & $WordBitWidth & "-bit words]": test "Parsing raw integers": block: # Sanity check let x = 0'u64 @@ -98,7 +98,7 @@ proc main() = check: n == h - suite "IO Decimal - BigInt" & " [" & $WordBitWidth & "-bit mode]": + suite "IO Decimal - BigInt" & " [" & $WordBitWidth & "-bit words]": test "Checks elliptic curve constants": block: # BLS12-381 - https://github.com/ethereum/py_ecc/blob/master/py_ecc/fields/field_properties.py const p = "4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787" diff --git a/tests/math/t_io_fields.nim b/tests/math/t_io_fields.nim index 0d7f3cb..5050016 100644 --- a/tests/math/t_io_fields.nim +++ b/tests/math/t_io_fields.nim @@ -21,7 +21,7 @@ echo "\n------------------------------------------------------\n" echo "test_io_fields xoshiro512** seed: ", seed proc main() = - suite "IO - Finite fields" & " [" & $WordBitWidth & "-bit mode]": + suite "IO - Finite fields" & " [" & $WordBitWidth & "-bit words]": test "Parsing and serializing round-trip on uint64": # 101 --------------------------------- block: diff --git a/tests/math/t_io_unsaturated.nim b/tests/math/t_io_unsaturated.nim index 9314ce6..5cdc856 100644 --- a/tests/math/t_io_unsaturated.nim +++ b/tests/math/t_io_unsaturated.nim @@ -56,7 +56,7 @@ proc testRoundtrip(curve: static Curve, gen: static RandomGen) = "\n b: " & b.toHex() proc main() = - suite "Packed <-> Unsaturated limbs roundtrips" & " [" & $WordBitWidth & "-bit mode]": + suite "Packed <-> Unsaturated limbs roundtrips" & " [" & $WordBitWidth & "-bit words]": const Iters = 10000 test "BN254_Snarks": for _ in 0 ..< Iters: diff --git a/tests/math/t_pairing_bls12_377_line_functions.nim b/tests/math/t_pairing_bls12_377_line_functions.nim index bc8fb92..2b0dbb5 100644 --- a/tests/math/t_pairing_bls12_377_line_functions.nim +++ b/tests/math/t_pairing_bls12_377_line_functions.nim @@ -65,7 +65,7 @@ func random_point*(rng: var RngState, EC: typedesc, randZ: bool, gen: RandomGen) else: result = rng.random_long01Seq_with_randZ(EC) -suite "Pairing - Line Functions on BLS12-377" & " [" & $WordBitWidth & "-bit mode]": +suite "Pairing - Line Functions on BLS12-377" & " [" & $WordBitWidth & "-bit words]": test "Line double - lt,t(P)": proc test_line_double(C: static Curve, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: diff --git a/tests/math/t_pairing_bls12_377_multi.nim b/tests/math/t_pairing_bls12_377_multi.nim new file mode 100644 index 0000000..f4c438e --- /dev/null +++ b/tests/math/t_pairing_bls12_377_multi.nim @@ -0,0 +1,62 @@ +# Constantine +# Copyright (c) 2018-2019 Status Research & Development GmbH +# Copyright (c) 2020-Present Mamy André-Ratsimbazafy +# Licensed and distributed under either of +# * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT). +# * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0). +# at your option. This file may not be copied, modified, or distributed except according to those terms. + +import + # Standard library + std/[os, times, strformat], + # Internals + ../../constantine/platforms/abstractions, + ../../constantine/math/[arithmetic, extension_fields, ec_shortweierstrass], + ../../constantine/math/io/io_extfields, + ../../constantine/math/config/curves, + ../../constantine/math/pairings/pairings_bls12, + # Test utilities + ../../helpers/prng_unsafe + +# Testing multipairing +# ---------------------------------------------- + +var rng: RngState +let timeseed = uint32(toUnix(getTime()) and (1'i64 shl 32 - 1)) # unixTime mod 2^32 +seed(rng, timeseed) +echo "\n------------------------------------------------------\n" +echo "test_pairing_bls12_377_multi xoshiro512** seed: ", timeseed + +proc testMultiPairing(rng: var RngState, N: static int) = + var + Ps {.noInit.}: array[N, ECP_ShortW_Aff[Fp[BLS12_381], G1]] + Qs {.noInit.}: array[N, ECP_ShortW_Aff[Fp2[BLS12_381], G2]] + + GTs {.noInit.}: array[N, Fp12[BLS12_381]] + + for i in 0 ..< N: + Ps[i] = rng.random_unsafe(typeof(Ps[0])) + Qs[i] = rng.random_unsafe(typeof(Qs[0])) + + # Simple pairing + let clockSimpleStart = cpuTime() + var GTsimple {.noInit.}: Fp12[BLS12_381] + for i in 0 ..< N: + GTs[i].pairing_bls12(Ps[i], Qs[i]) + + GTsimple = GTs[0] + for i in 1 ..< N: + GTsimple *= GTs[i] + let clockSimpleStop = cpuTime() + + # Multipairing + let clockMultiStart = cpuTime() + var GTmulti {.noInit.}: Fp12[BLS12_381] + GTmulti.pairing_bls12(Ps, Qs) + let clockMultiStop = cpuTime() + + echo &"N={N}, Simple: {clockSimpleStop - clockSimpleStart:>4.4f}s, Multi: {clockMultiStop - clockMultiStart:>4.4f}s" + doAssert bool GTsimple == GTmulti + +staticFor i, 1, 17: + rng.testMultiPairing(N = i) diff --git a/tests/math/t_pairing_bls12_381_line_functions.nim b/tests/math/t_pairing_bls12_381_line_functions.nim index bfaa92a..df9e986 100644 --- a/tests/math/t_pairing_bls12_381_line_functions.nim +++ b/tests/math/t_pairing_bls12_381_line_functions.nim @@ -64,7 +64,7 @@ func random_point*(rng: var RngState, EC: typedesc, randZ: bool, gen: RandomGen) else: result = rng.random_long01Seq_with_randZ(EC) -suite "Pairing - Line Functions on BLS12-381" & " [" & $WordBitWidth & "-bit mode]": +suite "Pairing - Line Functions on BLS12-381" & " [" & $WordBitWidth & "-bit words]": test "Line double - lt,t(P)": proc test_line_double(C: static Curve, randZ: bool, gen: RandomGen) = for _ in 0 ..< Iters: diff --git a/tests/math/t_pairing_cyclotomic_subgroup.nim b/tests/math/t_pairing_cyclotomic_subgroup.nim index 2605660..c992fda 100644 --- a/tests/math/t_pairing_cyclotomic_subgroup.nim +++ b/tests/math/t_pairing_cyclotomic_subgroup.nim @@ -49,7 +49,7 @@ func random_elem(rng: var RngState, F: typedesc, gen: RandomGen): F {.inline, no else: result = rng.random_long01Seq(F) -suite "Pairing - Cyclotomic subgroup - GΦ₁₂(p) = {α ∈ Fp¹² : α^Φ₁₂(p) ≡ 1 (mod p¹²)}" & " [" & $WordBitWidth & "-bit mode]": +suite "Pairing - Cyclotomic subgroup - GΦ₁₂(p) = {α ∈ Fp¹² : α^Φ₁₂(p) ≡ 1 (mod p¹²)}" & " [" & $WordBitWidth & "-bit words]": test "Easy part of the final exponentiation maps to the cyclotomic subgroup": proc test_final_exp_easy_cycl(C: static Curve, gen: static RandomGen) = for _ in 0 ..< Iters: diff --git a/tests/math/t_pairing_template.nim b/tests/math/t_pairing_template.nim index 6a19be5..d0c2b3a 100644 --- a/tests/math/t_pairing_template.nim +++ b/tests/math/t_pairing_template.nim @@ -99,7 +99,7 @@ template runPairingTests*(Iters: static int, C: static Curve, G1, G2, GT: typede doAssert bool(r == r3) doAssert bool(r2 == r3) - suite "Pairing - Optimal Ate on " & $C & " [" & $WordBitWidth & "-bit mode]": + suite "Pairing - Optimal Ate on " & $C & " [" & $WordBitWidth & "-bit words]": test "Bilinearity e([2]P, Q) = e(P, [2]Q) = e(P, Q)^2": test_bilinearity_double_impl(randZ = false, gen = Uniform) test_bilinearity_double_impl(randZ = false, gen = HighHammingWeight) @@ -139,7 +139,7 @@ template runGTsubgroupTests*(Iters: static int, GT: typedesc, finalExpHard_fn: u stdout.write '\n' - suite "Pairing - GT subgroup " & $GT.C & " [" & $WordBitWidth & "-bit mode]": + suite "Pairing - GT subgroup " & $GT.C & " [" & $WordBitWidth & "-bit words]": test "Final Exponentiation and GT-subgroup membership": test_gt_impl(gen = Uniform) test_gt_impl(gen = HighHammingWeight) diff --git a/tests/math/t_primitives.nim b/tests/math/t_primitives.nim index 3be38d6..41443c0 100644 --- a/tests/math/t_primitives.nim +++ b/tests/math/t_primitives.nim @@ -21,7 +21,7 @@ template undistinct[T](x: Ct[T]): T = T(x) proc main() = - suite "Constant-time unsigned integers" & " [" & $WordBitWidth & "-bit mode]": + suite "Constant-time unsigned integers" & " [" & $WordBitWidth & "-bit words]": test "High - getting the biggest representable number": check: high(Ct[byte]).undistinct == 0xFF.byte diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_128bit.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_128bit.json new file mode 100644 index 0000000..1ba8f40 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_128bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BLS12_377", + "group": "G1", + "modulus": "0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001", + "order": "0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001", + "cofactor": "0x170b5d44300000000000000000000000", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x1", + "vectors": [ + { + "id": 0, + "P": { + "x": "0x4e7e6dfa01ed0ceb6e66708b07cb5c6cd30a42eeb13d7b76f8d103a0a4d491450be6f526fc12f15209b792220c041e", + "y": "0xc782515159b7e7b9371e0e0caa387951317e993b1625d91869d4346621058a0960ef1b8b6eabb33cd5719694908a05" + }, + "scalarBits": 128, + "scalar": "0xaa9b0e8fe9586648abf3f1e2e639ca1b", + "Q": { + "x": "0x1709a3d8ad0a9a3bcd36c5fe9e2caf59e66c3141fc95395f490aa72a85360cc1333b1bb4d36366bef24d1bd746a8fbd", + "y": "0x460d1258acdf0e164cccc297dc15cc53ba747da1f15306c975a512f0deca256c78a32b5190f295ac51d0de3640fba6" + } + }, + { + "id": 1, + "P": { + "x": "0x495d5c49ea83853e43291970c787231e1bedf49a115a98d1f9bd0cacdbd2e5fe05525bd26beee23aefe0d3b3b0ee59", + "y": "0x10c26876835bdef3fddc694cdee6312081e8dfb74811e41cab582ff0c57b13d2fa09e8551ba9f7c709daa3c04eb180c" + }, + "scalarBits": 128, + "scalar": "0x45078066192b74d2f3077f00f5bd1a50", + "Q": { + "x": "0x246626e09f8e81de8b6a84ebb20a23e5b4d1e9a28ddfc52ccca3682644004af5a0c503681517390c266752e6855c78", + "y": "0x23055dc0919c94aef168ea77d91c7b6b2cda2c8b9a1c040efa7baae0307b96b6cd1ac37e3287610ce949f99638fa1" + } + }, + { + "id": 2, + "P": { + "x": "0x276146db802e6733a211d7568c3d34ba8907aaa5d6bab8d979c35527197d43e479a34a146f23acc2440bf19b5ff372", + "y": "0x10f6f53790e338882fd9153337612340fb8f563794a4d5c7c4f4cfc50ec9582cb1538a159a859e3ddfa3849ad1cee7c" + }, + "scalarBits": 128, + "scalar": "0x1e64c537c6203d64905b63d034a4c247", + "Q": { + "x": "0xa59bf86e6d060e0940f7caf6f1c5c9981c3d5078ce9bf22a682bc57b5b16c5b6ecf9cd55e23716b083360dcfc635e8", + "y": "0x25ed4829d7b3a1d6f18ced65530d9ab243549d67fc2fdf36b4253d9b1431f2cab61e5e9591d40b902f89e9d415a1b4" + } + }, + { + "id": 3, + "P": { + "x": "0x287d4af5ab70d2fde1f4b727f59c413c13795b5d101484366742a4b16b14206854eb4084fa18a2416f1eaa872e5720", + "y": "0x3bfd2cc512e70a13bdf0c61fcf0cb7f58a5e2f018338d1af35fc2f3148c4771b2251d1d80c3607eed9fb9700f3e55a" + }, + "scalarBits": 128, + "scalar": "0x37046c3d14102a5aa3e9f46e33c70a75", + "Q": { + "x": "0x21c1cc07196a5ecd4ff65b6d4e9a0fcb64dc6a60ad2dfbccb66195a18845041bd50279f4f3f6627148df2c12b198be", + "y": "0xeb87ca33ea95c09970add25eb18010ec473bcd1392a2b654b46e872ad46bd388eaa701c6c7b24d2e323ed1333f4768" + } + }, + { + "id": 4, + "P": { + "x": "0x12be5bee25b9ffc90706402b7e498308161692b09eb425a7efd8a7f546a616243943041007fb11d5318fbab1246b9f8", + "y": "0x1ab7be2a845c024ec6bc3b65e59a20826f020f639bf7d15c895d9634e246c6a277cac8aec0ae4bbd2bd93a3e20fc5fa" + }, + "scalarBits": 128, + "scalar": "0x84062adbcf70582ea8cbd0388104f47f", + "Q": { + "x": "0x1919012b84c6e6a7715533bfe4e70b4b35e99c36507c7c7fbf3c36be040740b1a40a5c771f1f65035879ec4097fe71a", + "y": "0xba929e2b0fb36bfff08cc6c19fc1ba075ce6641a84f7dbc811046e6ba135145f35842fb9abf74dcc6c2e6d284d8058" + } + }, + { + "id": 5, + "P": { + "x": "0x1355619f057ede740deb2cd6d627f170b5958295bd29d875cdd617e5f78482b867593ea914da2fcfc0d2865c54ea73f", + "y": "0xdb1d484e52e9dc0655b377b978ab27e615a9887a50c3b5f6d65511f341d07013698afdb6d104800345f46fa8124257" + }, + "scalarBits": 128, + "scalar": "0x882db3e45eee839131bc7fe89ee4a859", + "Q": { + "x": "0x5a838aaf44e06076ecc16e9cdc4ebff6df52ecdd46bf80bb8d85827994966fe97174bc1a9261bc26899159aa9a1c5c", + "y": "0x9f227838c019b20301214f98d93b9d8ec2adc97b7451d2d59c688a89aecb5ea27ce3a25099cf6ff380e5a6924b9749" + } + }, + { + "id": 6, + "P": { + "x": "0x53468e89531095642ce00990013f6adeeff7921ecfe5af0b9414fda35c7b320f025f3ee3642c120729e4cdde1c4304", + "y": "0xc7e38b915133c6ea43b9c4f8abd55633db9463acdf24c4b124c4d7266e164d6668ddf02f6c5b38d2af56e6f198b35a" + }, + "scalarBits": 128, + "scalar": "0xacb5d62e3dcb16acfec66b6a9639e19d", + "Q": { + "x": "0x12cac7ddadd1f088651498718164c0cfbc4bd03477de6f68b7b24d3fc93f450fc4efab9a4f4dd3e9f0593dce838cfb6", + "y": "0x1a2c030bb7172d41ef69c5de917960011e73e5b0266113a67845dde1ff4147a96eac04d64990c24ec21166ac92cc819" + } + }, + { + "id": 7, + "P": { + "x": "0x3e2591281ea16be00881f310f46c71e51b47d7ee8e7ca9a7019e8ea8a358a666d1010d03c5f7b88d27e6f4b8052be6", + "y": "0x16b5df69f5044a5a03ef58c87fcded16667a863cac64f36ec9c2e34abe49351e1d9c2362e787234701cf425399fba0" + }, + "scalarBits": 128, + "scalar": "0x47c87b57b0ffa6e4acc601b44c062745", + "Q": { + "x": "0x76c0e32647ed84d8a93e0319b1ecb151c3322a8421f0f6eb4a5271b65c10c603af477a4f463cfd88fe93e73d9a0fb2", + "y": "0xb39a46e13bc2853a60f6d12b15b11238e54f22e5c671ca789ad1a98151dff1c2be629f34e5c26d94177d1d0b0e996f" + } + }, + { + "id": 8, + "P": { + "x": "0x1818c7813f111507e933e61309cf58708ab64a582b40788ab295b989b04d5d4c81fa9a6485370dbd9b81fb9cfa53dce", + "y": "0x2a45f42de4771c2e05117daeaf8e015631be6e287b4624924be75670fb4cba2f102bcd308a6bb92f71cb78dbdd9c94" + }, + "scalarBits": 128, + "scalar": "0xec1f23c50bcc7539c1b2bf408b3cae31", + "Q": { + "x": "0x16891716687097db20b9da77507f97052e38443417b01ed8ba894108e09a50c72853d63f36c325542d9d51051a48c8", + "y": "0x145f887eb34ef48456856174caa0ec9a196e067a89bf385b17558a8d00b8d4df7c83d2698f2619adf80ad09e0f6fd6b" + } + }, + { + "id": 9, + "P": { + "x": "0x177aac33b94be8ea0ac43541bde6557a02effcf0ad50a21f54e800376d4148d216f2b3b9c2d0fa02d668f82f1689ae9", + "y": "0xf03cfe76d507957d733499ff1d8e2be91b74c4806ae84336a63f757ea95d6eab39b66be1315dad7a95471b0544a7d" + }, + "scalarBits": 128, + "scalar": "0xae82ed32ae0dce28603d753132869747", + "Q": { + "x": "0x1241d1a3e3951da4b4533ab29b3c59228d0feaaf2273e3fcf1af694fc849a46d3401d020040d1153c283b7a78147815", + "y": "0x19a5d4f5e3e8d8c8664b993b07ae1ac9f28ca5d95c2ec44a12efa29fa72322af7e90d4d4713e721fcb6f18ed4e102c9" + } + }, + { + "id": 10, + "P": { + "x": "0x1728af4646c1de324a8a4583b3aa1cf1b4984f286ae1fff8c1f0f8d6da3e04f3ebd08dc90b4a3b7917b385822625d53", + "y": "0x289ec3a6099f8dda44000cd7be36f8ae2d58b4dfaca410336451a9bd3f774f377b706b50b5759830431b242130b180" + }, + "scalarBits": 128, + "scalar": "0xc28ab1fffa313a09140ad05d7de22f88", + "Q": { + "x": "0x10c78943d14640825a811f45882779860517f18b8f18cdd3568182ef9cb5030018ea0ae6ee32f9cc8db2ccab2e99a91", + "y": "0x27d9bca5cbb228458c47d0e6b6a62a1b1dda998786f46bb4ad26b488a59a4f7c165f6272118c31fd4d84e7bd2c2a4c" + } + }, + { + "id": 11, + "P": { + "x": "0x10041fbb361a1b74d9d047f30baecac29a8a2f3a59b1bb01374b6459373c1379a66c1535f94a37fefacb04100de3395", + "y": "0x3fa571473c9c4279c10ba1b73b8d432f599c26b393b71191f3b10bafb8dc9bd4f8422bb86f398da93c26be25420d8f" + }, + "scalarBits": 128, + "scalar": "0x85ae2bcd7326a51661bb91d8d229b94e", + "Q": { + "x": "0x11ff4fd5aace8e7c842af3e399fb7f15f1d95646cea40598b9870e46f1ce5d76f03f3ff7240e1a15cc31d521d77e13e", + "y": "0xa2352c2cef883238a3f390f26d9c214ecdf13b4b55f018d1640faf4c1ed675dace3dad3bd596595fa329853c92852f" + } + }, + { + "id": 12, + "P": { + "x": "0x30ce29566b3601bef30e5a2396234292d09e149b419c510924a1efb4a1e8d07f8b45b4a40976efd3142ab795bf696b", + "y": "0x19f9726ee1f191037d80b39f26d117b844ff7e1220c3b474d0db7f8b9f4663028f634c2c1bf805f6309b8bd44070bf7" + }, + "scalarBits": 128, + "scalar": "0xfa3c60ce06c019475dc88eb8544ef3d5", + "Q": { + "x": "0xf81ab9ebf6f6aeab5c72b22230714d8619f05743b15cedc39cf5a559574693fca91b13ab015f0ecbd6e50b1dbe4051", + "y": "0x1848e413ba45105969d9f2f4780037a3acb21cbc9122cd4b6e9707dc78d7939d59ac197bf786df3225776268e76e226" + } + }, + { + "id": 13, + "P": { + "x": "0x14f822c615c4856c4a4469882dea0dbbc5782c7986d1e9002b52692cd73806aff9318a7dff6e15614c00b2880415acb", + "y": "0x113db589e941ca78661a1aa1a24d759dfe4bdd9290c9e2f77141f3c0bb1016964a267cf1a0da6cdfa46442d0303e389" + }, + "scalarBits": 128, + "scalar": "0x4136523ea9b771bb688da5cadb6e9fe4", + "Q": { + "x": "0x203ea3027ffb931c9eb61b9ad51db2b3b36a5b53327534761599ac8d2c4d462a8f00a63d913cb9cb436fec3f414966", + "y": "0x11796a2dff2f536607e5c2fa9a0acb2e34248e20227b5a4e0b375ad1be9a3e8e0720425f12815a0fe6bcbd564060737" + } + }, + { + "id": 14, + "P": { + "x": "0x111ddb965dcddbe70c29cbeefe31005dd9f8d434168ec5db320d84c7478a189fa5d5e841e7a8935de2ee57ddf007391", + "y": "0x14b1d68acd93ebcd604d22981d2fee92a4cadc69c2ce43e80f574b750bde81d03e319dcdb482a2851292fe7fb18557d" + }, + "scalarBits": 128, + "scalar": "0xcd6cf922458072eb615f25df1b0d3134", + "Q": { + "x": "0x8ba5ae3a372dbc906493a1bbe9a7beec86699813d41ae2c2361784adfd5c2f1f1013c458ff8e3302d88fda14b8f645", + "y": "0xd306ef37f2bff511caa01f3563b9bead8f28885f2f5c985380b68d8d63be66d78ea87c0f716b2da72cf12c83508f13" + } + }, + { + "id": 15, + "P": { + "x": "0x2659401e0e0a94b1972a4af2b90c6eed19fcbf6885fafe3946f26c6a9af9477a9ec0825310c126701f948cac1003ca", + "y": "0xb1fcf62203f411f1f0fb493b5e41c755d078e9adde16b211656ff7dfc27e4fa80c55a753d31c84a07f72b1153bdbca" + }, + "scalarBits": 128, + "scalar": "0xad0f5d5a277be71a184937b73e97325d", + "Q": { + "x": "0x998ec09ea627bbfd91a1356ac1f6c5f18e76bd39e867b4b1e6e5f2813f309fea7e78c748e815bf00b1687e373d594c", + "y": "0x2feb6073385f799c5465e305a62abf31740f1f290b5417125b2b3804ec7ed2646eca12f510106f31a91d08dbf39ae6" + } + }, + { + "id": 16, + "P": { + "x": "0x1175183ecc5dd314b2b22fed08f26e4306272c809315566fc0fe4a8b616d62d1a67f6a29c3dbf8f90c7d44a1b0cdf53", + "y": "0x1425bb46f998c2b0d4237c2148545d032cba429c1dbdc02a3455f99fa2c8caf2ff5d4422f17c66a9869144c19fad7cb" + }, + "scalarBits": 128, + "scalar": "0xe682ca7ca0f3ea554b4854012e1f7bbd", + "Q": { + "x": "0x44c81ba36ca4c0098f0e0cb351c65e8393cc4ac15d72e3856ff6cb3490a5be3177834e820794d5160121170a3577b0", + "y": "0x9134a490c0b2026a8cf6d96cd721bdbf6ad7a5b0eb19971462cc07374433210996c525e8f0199bd1d619c18555c1b3" + } + }, + { + "id": 17, + "P": { + "x": "0x388ff699b293e2b42139555e7af19a5f636655c31bc04869ab0a452dd38ef7b546e765694e68a54531a9b2f89740dc", + "y": "0xdf590a9f4e0773416e3c791d38eb437e7ab6a7398677e8eb3c0b1d16a302de2063da4dfb888521f5f2953cf5f6da61" + }, + "scalarBits": 128, + "scalar": "0x479d68087db33f9edb3f7b2e4655fe0c", + "Q": { + "x": "0x245e0c34ea2f4d19758819d752d372437f02cd4167d5a6520c11666177d07a56c30295ffff0f212e2aeeda8f967620", + "y": "0x18265098461ab45c07803c736eaf6280966c0fd480b4cea2a602f3c34ea061c9fb9410ac057b86acb5a90ad6c8037bc" + } + }, + { + "id": 18, + "P": { + "x": "0x132800485152cb47c073a7d139899a7ec23dfd04c0d12e7eed5ed31dfd7e38d4035d5ad41f1e5b196a08620c3fc40f5", + "y": "0x12f124d004c3e65fabdbb4b2fa835971c99dd2d762ab5be3ee838899375c8da436cf98d15131974489868bc61d4c2d9" + }, + "scalarBits": 128, + "scalar": "0x9f00a8f966647a29b6c6e15898d87791", + "Q": { + "x": "0xa965603fbdba1e87f5276ed99c076258fc56b328d6645c82714b262a7d0c1bd3f109f6e35ab933c24aa2fc49c3e94d", + "y": "0x13d1ee63e7dac97f073a770dba122c95bfd3e623045a40e2c002c85e0a186967e978237990bcc9674a2fb05e512c195" + } + }, + { + "id": 19, + "P": { + "x": "0x9fba3eebf5c132e08aef9de4f3c1137ec741e6468e7c6721b2e639b5d95df2dbbd4020fa8b9f7684cf350aa3c5b6e6", + "y": "0x10b30f1d21c1a55c1c844dff3195991d4ca40805db35df7ec99076f21da4123d01ad5e17c36422bb38a672aba320cac" + }, + "scalarBits": 128, + "scalar": "0xb8f016734614949862a9f2be703935a5", + "Q": { + "x": "0x4bc54d5a6b087259a1305c078f6e250407f6ad9614a0a1ca152552fbfae033dd03b0e682fcbbd1ce30fe1d77a74323", + "y": "0xc683944a986123affb513255b54a3195a9c3b346e94c0dd04c5b9930f16757d72bc34c04aa126ce67f22d7c0254874" + } + }, + { + "id": 20, + "P": { + "x": "0x488b356cb215af435f2a74a4ac8d1bbb6232fcf23334431526c0eb2f274cf793829c5548900eaf932e91e24297f557", + "y": "0x8a4eda46c67bf4670684ac661d8fbfb69d9de5dcabf9364ebff9342ef52cdb138f07deac2e8004c4c48a26dd60554b" + }, + "scalarBits": 128, + "scalar": "0x3d8dfe73cb6b68207a89ea0c7b9e643a", + "Q": { + "x": "0x1080eff2cf1b3b5765aac4c347cbe299cef7e762b12b18ab92ae8b2ff3e2c4168f8cf03e2d628d3ce28c35f8e399fae", + "y": "0x5edaa8449a95f778b074f3e1075faf27fd1623aa76b36562032725f72d69a207326b7c1b346a48c2998623f4c8bff" + } + }, + { + "id": 21, + "P": { + "x": "0x5b9535489b3dcb564e5cd90160573433d161e3f5a3b97c098a01cf34ee81ba56fc12146d7b8fcab0a917918d182ece", + "y": "0xe7216eb6f2f42387b23e8f9e796e33822fb1bd55170f4aed03f8a3b9ce3df8200d5f51a04e6f136cbe015372c47a0d" + }, + "scalarBits": 128, + "scalar": "0xd40ddce44b970b7cd67d29cb5880f8d0", + "Q": { + "x": "0x7a835e88a24afc0783c09675c165b93c013729f5e05b320e850c1472d4a85e9ebf9dae1ff47b342720b523e55bfff3", + "y": "0xaaf9d57b5093314aa0cd9c718c8471dc1512f443e0c8011c075e0bbcf02be2cf508e49d48507a19e0a70db9412f9ee" + } + }, + { + "id": 22, + "P": { + "x": "0xaa47e9a81d1d3ebb7a48814fac401fa03d54d632db938dab2acf70943df4e04836817efd4af8a8f70628920daa66ab", + "y": "0x179baa0ca89576836fe3762e486ef95c01aa4d0c07a4b147a0114dbf055e765968704268bf7bd4b95d5567c49ea85aa" + }, + "scalarBits": 128, + "scalar": "0x9f78715604a94842ce30838a5c18f7f9", + "Q": { + "x": "0x18f230b98c3ae2dc8f593d9933e37106cd90f9cd426c380b98641f834c30338828ff9efb1f9d6e86e296f253f90c321", + "y": "0xc777781a05b434dfbb5b51f99acf2de59d911a1dbf89ca529b310815b96ba76786d5402b146f23d66bc06eb933f32" + } + }, + { + "id": 23, + "P": { + "x": "0x10ea6964b9c1eaad4ea93a2b50a9cedc6445f0b5c7e3e6433a1dd8e8594fb30507416d13a44339babdeb584ed623c5e", + "y": "0x13f66ac8f9cd08cc6209e1140e333ef16e3896fcba63474e1a73616e8d7f69c70a0570e377a31c7ed012ef4b70fea81" + }, + "scalarBits": 128, + "scalar": "0x7be9df6d017acbfcadb5031f793c06ed", + "Q": { + "x": "0x1900fa7431647ec5482c9120313603160b1cffdba27cba7f142e2ce57ad869c76504d79113134b7328907f966c74750", + "y": "0xe88ac8344a9860df995a96c3f14da8ae21df4c8b6c3c2b2231be3011375a72fb9bb4c5806c9a5c4bb866c4d8676c3c" + } + }, + { + "id": 24, + "P": { + "x": "0x1a5c888350e7bffe4e53d18ac6b94c616e9d12206690ba4cfd0f477a8f66e074ce8d7230a68c91abf214e38d686779f", + "y": "0x11586f7a72db6a1c5ade98aa8e34f08dc1179c63905bb49aae38c604b151e69cf0cfe6e3d56d79fea5c4f7f5bc13821" + }, + "scalarBits": 128, + "scalar": "0x231ebe12fbcfd6d3a12c17335ec9b638", + "Q": { + "x": "0xed30beb6e6c1c3eea3b866545598754b1c74f04dbb36056255798c7f1db24d4a29307bc7ad7e3815a247739811d31b", + "y": "0x19cadc4d81d4b91ab9b743d557ed5fcf20622fa92d9f7431930935074a9f2ce9cce9a28ffc7f60aeff0d274d55781f9" + } + }, + { + "id": 25, + "P": { + "x": "0x13934df3e3d800ec4a2a973b55f2c4bde93af0cf18af7b2d2e4efe76beb69ed8b9d1b46bfffde4c87d0d01f91d873a", + "y": "0x6a23e5b0a7239a35c8d3d88ca8978c029b8af443890cfc4602fc4eeaf0e1cfd7a812ed5d658928696dc9b675de31b6" + }, + "scalarBits": 128, + "scalar": "0xe3be7c42020e4e5f3d47ba88039e67d4", + "Q": { + "x": "0xc3a92a0a92c670391ae3a0b2ed0080d30a301139cf88a45d0969e6639c844d296d87c6e7cac6229b47ce536b95f40f", + "y": "0xc4d63afbb7fa8d07afb467697247beaa31f11d427ce0b946011dc8c46e7213b37267d816600b803433109561dcb6b0" + } + }, + { + "id": 26, + "P": { + "x": "0x213f7089633df705bf852dd91516ffbc4bee92c7a6f5f5944a3b17116293a0dc932c8ece15ed1eb217b2e78adbd97b", + "y": "0x18ba49b6ea522ea96d96527960923e35b148a04fe8c3d4e228d53e0191b0ba6c2d73e8abb947e81cb12d83f61fd4a17" + }, + "scalarBits": 128, + "scalar": "0x1673e44707f59e2eaee449fd48641225", + "Q": { + "x": "0x1f9502b1ed583d194a394e76b292c8538265a034bdbb0a7dce2033d75de0bc51f8a042c8ea598850d66aa651b864f2", + "y": "0x1107a9e95284dbe9b474b30d5e0afc6704e8883e0d87b756705fca1335eea7728ad384284a91d9d964323e350a159c3" + } + }, + { + "id": 27, + "P": { + "x": "0x10bd99bf5a870cd25f762d54abf5553da02c2c417221219651c366ddb2e6e887ff3fa4a79e8e7297c3fc0c377d39efd", + "y": "0xded01e4ab02a9d3c9019bb73f34dadf83fb5df8c25b4a40c5a9fa00d9f8c01b7cfe0c4a213c6b688135b06e8db6753" + }, + "scalarBits": 128, + "scalar": "0x33f9491e3269ff2de895375cc946ef4a", + "Q": { + "x": "0xe6164ce59b77f71d4bd901b4f0e1f0935e5ebaa0b045ab70cd9c0d8ac9073001350310a723f294a4f1bd9f882bdef4", + "y": "0x586743cdda76246e4e1ade6e99ec9395d3eb04933e50389644177638c724628da64fd9157302eb65bee47100b70491" + } + }, + { + "id": 28, + "P": { + "x": "0xd9b773201b05913f8ae27d7c894dd16542b3495324462e66e26ec3c2866f446b3bd97cad95e1aff0123f60d89286d3", + "y": "0x6a4ca5ef1dc12422d0211814b79a2c09e9113c160164263e165fbbecfb49b80edce9e37ba98a3411cd99180c73dd8e" + }, + "scalarBits": 128, + "scalar": "0x816a7cc005fb1546efc2c13d8643bf7a", + "Q": { + "x": "0x622ec1ced3fa4e14cb87b75c70bb901fbcd40ece8d434593aa208b2bb9649fdae6a09c5eabe9f8e0fa1d3ec2401fb2", + "y": "0xb61be6723195de1e77ddef845515232b05f8d228c9e9cbea6da9c0a096b3ea73ab09091fdad7d46988f61da73a18be" + } + }, + { + "id": 29, + "P": { + "x": "0x16ee1e218518d4b130a2f60b63845a05b8abfd0585b3c39c471d915d6ff81d269bed019f3f97a42aa650e8be45288c4", + "y": "0xae0e0564f7639d32ba981e0fd5357a1227cf7f00a310b94255a4769689476739d376f09414cb55fc8aa1792d215c86" + }, + "scalarBits": 128, + "scalar": "0x7b727060812eae0a48e31249ee16ef94", + "Q": { + "x": "0x1aca5ba8bbd2db89ef15cd715ce56b138cbb9e02ed7b1418289200459c4c3526f54a035b3a6fa625d90848b062857bb", + "y": "0xf936c1a0d227eba9e6defcd928c16995658c8d4f07cf0e9dce68f69bcafc84a4cecd1b79207c1946d9b5974b4c4622" + } + }, + { + "id": 30, + "P": { + "x": "0x288db700888cc6cc6e837953ecc629ba5789fff7cc32c76b2b0f8c7a85e0ca330806ed464af1c2c0c212bb851738c5", + "y": "0x224f78b078e7e77d29629f3ded67154e31b51a3019f7c2c0a69fe75d3e512f7dafd894f2b02a4ea6ea06acb1e8de47" + }, + "scalarBits": 128, + "scalar": "0x644b0fa53abe392b3fd7777b8d3ccc2", + "Q": { + "x": "0x1780c66def077b8d16866085f0391b2b30865a2d6e5b9a15fa8d3bf6879de0e2112a3a381ea8bce9b22b73579bca690", + "y": "0x6b0502a34ed6fa087099140b8c5f79be98eaf399556f1018d9018b0c048107783eae9f11a0cd06e02328819039b364" + } + }, + { + "id": 31, + "P": { + "x": "0x24c51872f69ca17cc00e9048449137e5856d16759d90600efa516749d90bda76e5e4023932dca5f6ffd2ff678d620b", + "y": "0x6714e83a724e770353c89126d7ef5646238f0c3507584e35ccc8d28dbe94cc7979119bd9cb39111130acd98c2c7d5e" + }, + "scalarBits": 128, + "scalar": "0x2504c5497acbadead3c6d90ab1ab94fd", + "Q": { + "x": "0x31c3d051d77be7e73afaa26d3719d328700e446527c9f1da1e1a6aa508aaf63089a2a935bbf724a9aaf935ffecaab0", + "y": "0x9baa601c1860d0585dc1a41af4ded64faf2f82787db31c1793ef47e1e51b362835beca160b47b6263a0202a3b9e823" + } + }, + { + "id": 32, + "P": { + "x": "0x6eabcb02d02cec109d7dee31812a3328fc55ca6f1c54779df895161465b4799d57df4f6f49441a49659b94640ca8e", + "y": "0xeade889826710bfe36c9be5a397d605c416edab78aef8c2b4cd99b8c2b26488c8307f4054eb355616e155e92162239" + }, + "scalarBits": 128, + "scalar": "0x1303fa1bd7dc4317ac41949fbda6bf22", + "Q": { + "x": "0x17054e047b23818789ca7a4c8570c034b5ef9e0c29a62e9db9faba14d5eceda68c22ae77c91c55ae7be851d797c3c9d", + "y": "0x16cb4523c79aff74d1198bbcd4dbdffaf354de4cc95b347e183adb38533d9c7284fc3e77bc00efe5dd857cb53488f8d" + } + }, + { + "id": 33, + "P": { + "x": "0xad632965e6217824b73583cc2289064d06d23ec0ea5cd52010e5f50e4523d55ef52f4e714dfbcd21e081e505bbc16", + "y": "0xa2fb2e3d7c24e0e5c5c523ae0324dab62d8181336ae8b3453dca02492e59a2eadcb87b504e4d6db74bf36067999a7c" + }, + "scalarBits": 128, + "scalar": "0x9a1bdcc64347d5aa0cf98e4c81e54330", + "Q": { + "x": "0xeb458189be92adc74f2962ded24ddac881ec4d6694a235cf5eacea83876b25509e6e41b60f29463501de5fdcd3ff58", + "y": "0x7382d008d656fd5e960f1db0775ae1f99f42c3f0b4dd05eb338f8e7ecbc4a76634c488d75c49afe45e5154b42e2cf2" + } + }, + { + "id": 34, + "P": { + "x": "0x10a63254fe9b79cfcba46497503df4597202293729df02430d48150d541f6f0637c8184f2ac17ecc393acd6a17f5c2", + "y": "0x4f075f85da79d912f281fcc6836a026f8ef0f81b82895e44df9373a66bcb75ca3c9e2033f394d34c1aeaadd3860753" + }, + "scalarBits": 128, + "scalar": "0x7512787e3234b1a6c595199161108c4d", + "Q": { + "x": "0x1123b9822c4417aedd73ab19db1d1b4f077fbb11c7eaed02ce388217bd8431858aac8fc17ea3e9c898e3ba99fa48a5f", + "y": "0x199489ac2687da83cbfdfdaf47c35017cab253de828b3f8dcb6f1a53bcf319012f02018cfdc119ba584eff95333bc19" + } + }, + { + "id": 35, + "P": { + "x": "0x6319ac4d94b79a0334cf239d88bc0d1ed6f1ea53081df7c935ee2c16a9e088cf2d1ed13465b065d0a3eeedbdd8b74", + "y": "0x180e8293fc6523ae533a9e29d2ed2099fc09f2c5395c5c7ea86252161b90a0ccc18725b004340a1fdf4573f15b165a" + }, + "scalarBits": 128, + "scalar": "0x1c413124dd59fdd8428cf3fd28db20d2", + "Q": { + "x": "0x23a74b891c912d708e1f66ecb8eef12a452f8d497d83a8a2fb169aa774e71b201020d9a89f2f1cc1e6c3c0fe4cbd6c", + "y": "0x2b08c76f79dd524de3912c465bb3ffe544c444f20baafb7e5770b50d5196c1782c889c9963db89ffa6ca147a96bf38" + } + }, + { + "id": 36, + "P": { + "x": "0x1111e29571f5bffa7a969674580d3f95585a983940263f2816bb310a804dceedf8ca8c6f0a7b286a8fc60760c323b63", + "y": "0x1548c948803b6677a6c48523220bb6efce2177666532020cfd76cb12a12273c2b77ba7f68e68d6191fd10aff2f9a844" + }, + "scalarBits": 128, + "scalar": "0xd43f6cd1ad51f001070d16cd4e8fb70d", + "Q": { + "x": "0x151a90b8dbbb49439093eca508c9939ed34219fcd7de071d2b1b9ba2708e94999a0391ddc3cae2ab65ccac50d62b0c", + "y": "0x16f25659173681cf0518105a14365f252cf475409204b2cd1742d5bd45ffef4a2ca9200ccdac7362f8b6a5948e8db53" + } + }, + { + "id": 37, + "P": { + "x": "0xc1b7d38844f9725af35cf14c5a81b3b231cd17673bf72798ae6208f202ed22a91fc8bd8d7cd7096c2487ebb31579af", + "y": "0x982a2337b841eef7adfe56c5f2a8ed47fab2d580f4f6984a0d866a80a94646b2dd9470f7752d7972f0f9a152e92e43" + }, + "scalarBits": 128, + "scalar": "0xa96847c540f26a02b972c1d322176bac", + "Q": { + "x": "0x19a5515db145672daa7042c165cd2e2aea1cfc8de803f8d9532cdb4e88959eca33a053369d6704946971ae752674b63", + "y": "0x2e179361daf368f7fee5cfabf0fdbb7dfd37027b4b40bc992307552d65911eb8f4c44a73aebd28c60b301703ebe7d9" + } + }, + { + "id": 38, + "P": { + "x": "0x16ad569ef9eb8b408cfdb9f190ac6e2efe95143846fe4a99d23e1e27f8edec4f06ad274f602809dab1a09a423f304ed", + "y": "0xd5152fa043863feaf4b4f08494c6200a1d9f66ebf17d041ce64cf4f5b0514508a47486b6f19d935da9b863d83304a6" + }, + "scalarBits": 128, + "scalar": "0x4337644111924b1dcc5f59b7145708d6", + "Q": { + "x": "0x65610857dfb4e0df73fd57f3b4bc9f430c42abf1f4bbe1310fd96b82a30b5a2dcc1540cacfa797b610135d5f702d2c", + "y": "0x143944a95c2bc38699a97945d66faeb00e314e2cf68217af067c4ad00e7e95233099359d3ece26fc660a81cf85358c5" + } + }, + { + "id": 39, + "P": { + "x": "0xed1c79d8d4d52f4013a086345fcd53dbe6d57b8049c38be765be6d8665648543974b1b69594806dd1cf93dc2a3c98c", + "y": "0x1d7e5972aa71555d56d73da82729ca046642e10350a47cc6b75c5f1a4b549a2538820f7a66215539087fe2f41935ed" + }, + "scalarBits": 128, + "scalar": "0x66f83070debb906ace6b600f5eeb959", + "Q": { + "x": "0x1493bd2869a247e47f96c6c4f927c4982560322c84acf2cdba3985db432067a5dda5f516a8a2375759a03bcff4d46c4", + "y": "0xa1a257dedbd2d32465bf515c6256c0e676e8da310d602c7d7f3e7f86561ebd53142403e56c266d9db64453b4c67eca" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G1.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_253bit.json similarity index 96% rename from tests/math/vectors/tv_BLS12_377_scalar_mul_G1.json rename to tests/math/vectors/tv_BLS12_377_scalar_mul_G1_253bit.json index 4f457c7..f90cf97 100644 --- a/tests/math/vectors/tv_BLS12_377_scalar_mul_G1.json +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_253bit.json @@ -14,6 +14,7 @@ "x": "0x4e7e6dfa01ed0ceb6e66708b07cb5c6cd30a42eeb13d7b76f8d103a0a4d491450be6f526fc12f15209b792220c041e", "y": "0xc782515159b7e7b9371e0e0caa387951317e993b1625d91869d4346621058a0960ef1b8b6eabb33cd5719694908a05" }, + "scalarBits": 253, "scalar": "0xcf815cb4d44d3d691b7c82a40b4b70caa9b0e8fe9586648abf3f1e2e639ca1b", "Q": { "x": "0x4a1203db4af8f0efc18c7ceb24999eb6e0dbdfc8f44a9edd5ba2f9eced38e81ecae287ab1c184eea8e8753d1178604", @@ -26,6 +27,7 @@ "x": "0x13d735b28405253dcc0bc60bcdc13633475ffc187d38a9b97655b0d0fa1d56c4548f11ea0a795391ee85c953aaf9b83", "y": "0x1693101123fd13a20f9c0569c52c29507ba1c8b6dd412660bc82e7974022f1a10f9137b4ba59d3f0aab67027cefec19" }, + "scalarBits": 253, "scalar": "0x913aa7b9fa2f940b70b6dcf538cc08da1a369809ab86a8ee49cead0ed6bfef6", "Q": { "x": "0x10e0e8582ec3456f7569473892c23997d004f2542d914fa75db8f1798ed8ce505836e8b7af5cf1503e14d85fadd65ee", @@ -38,6 +40,7 @@ "x": "0x6dd2211113cada09d3b96848cbf21ed14f6fc238b581c0afd49aa776980101e4ee279a256ce8f1428d3ed3f70afd85", "y": "0x3b406b4433a3f44f8e196012f50c520e876412fbcae2651916f133c1fd3899c79f676e1abba01d84bab7ad100c9295" }, + "scalarBits": 253, "scalar": "0x4cf47669aeb0f30b6c6c5aa02808a87dc787fba22da32875e614a54a50b6a0c", "Q": { "x": "0x3caf55e1f82d746df2bf47defbee127a3e6f7e79a9575929704b25489ffb801dbce07999acbddfd79352b0633a2708", @@ -50,6 +53,7 @@ "x": "0x18648abbe3261f93cbf679777eac66e419035041a967d1e6a0f0afdb92810d7122e0984f1d6efc8fe518500464ee803", "y": "0x7b6f518d4d06309aad4d60d29118310b6c8b17c7bf5db2251f4701b13b89a8c0f04bb5d0386785e55ffbbd7ecc445e" }, + "scalarBits": 253, "scalar": "0x69498486a06c18f836a8e9ed507bbb563d6d03545e03e08f628e8fbd2e5d098", "Q": { "x": "0x6a871d872673879fd23ec8c150f8d63e8130dc60343fc0c2ec9ff1b02e769e20eeec0288102ccec6ff2f6ac6973b4", @@ -62,6 +66,7 @@ "x": "0x745e9944549522486f3446676cc62fb666682e10c661a13b8110b42cb9a37676b6f33a46f9495f4fafb342d5809db5", "y": "0xbc595854bc42ccec60dd9ec573608d736aa59996cef1c2e8f6c5d424f525a6f3e3d4beeedfac6b959dbd71ced95b13" }, + "scalarBits": 253, "scalar": "0x6e08d8714102a5aa3e9f46e33c70a759c27253c7b0196c3e46c7cb42671197e", "Q": { "x": "0x18a967a80785de8ec6ac9d98cffa06a8c633b5fa0f36431a32f7bd955946edc3d55f79bfdf5335db405560a6cbe2415", @@ -74,6 +79,7 @@ "x": "0xf7b56cf212a8906ed77a758164c0bd05ce1fbd3ee3c4357e7a09b3aedc748a29ace254f1f6df35b8cb74361060337f", "y": "0x2640ef641d20fea19b28947833e53faceeafa57a8761b807049f3d707d70c01f1c69a57edd993d301a64517bf47f77" }, + "scalarBits": 253, "scalar": "0xa5c46d7a52938fed7f3093d5867f65361dc8b48c83bd7db490c26736196e20e", "Q": { "x": "0x434f024c4afd7b9a44375011d663af0ae0fe79442e9caf36518e053bb13d49998ec1d2da4bc1c4a812812119b3221f", @@ -86,6 +92,7 @@ "x": "0x43b387c12e4cc91fb1a5593b7671356dceb0fe6e6ac666d5bac94f2a44c8db54976b649a678aae038b21144de04e23", "y": "0x1a6366a50f1f9ba64eef73d82bec86177bf184be048a9d66326ccb0122203569ddcb8cf74445cadaff7f47a66d1b1a2" }, + "scalarBits": 253, "scalar": "0xbddd07231bc7fe89ee4a859a00ea1f9d236be9e7fd561303d566904c1b0a07c", "Q": { "x": "0x8ddb7a959483b51a1471de988146b7d5b166f660734b4d55166c5a23d781e923261927b1012dce73b822bb6e56bfd2", @@ -98,6 +105,7 @@ "x": "0x6984c9385a67081f97b3d33444077466cca1d0442a4da8c083a0957578e0b21011435b126a5ab143da9da1cf5b216f", "y": "0x18a87c7f5f6c5a8101773e63956b9addd4becf5177acc560d548e5331638121934842fdc9f654b3f456a7df5a2e471a" }, + "scalarBits": 253, "scalar": "0xb72c41a6ffaff0aacb5d62e3dcb16acfec66b6a9639e19d3128fd43c18e7dbe", "Q": { "x": "0x19279201c3c7a9d50b546aa99d3e1a6625fe2a7bc64a09625b683534638b9e87b9102d4dba6684956b6be7668a658c6", @@ -110,6 +118,7 @@ "x": "0xefc34595823e7333616f7768bc82f407268df6f029bf4c94d15f1785dc7ccc08f22e7301dfc48dadc0ea383c8bb3e", "y": "0x2459bd9f71977ef122d2102e8bfd07a5737066075058cfa8bcaa9f9690ed065919c844363ceaea6f9bb650906a535f" }, + "scalarBits": 253, "scalar": "0x8f90f6ab0ffa6e4acc601b44c062745f2935b3dc153d0da07977470080d5c18", "Q": { "x": "0x35d08b33e02579581905941975c8b1cc5be1c9670a7f7ef390daa363b0abd3571a802d8c27f156fba40573094f6c7a", @@ -122,6 +131,7 @@ "x": "0x3eec93c2a9c5fd03f0de5ede2fdac9e361090fbaea38e4a0f1828745f1d14a057d9fd7c46b9168bd95a45a182a3a62", "y": "0xe912dc7e95f90d91e3274ec5639edacb88be1b092c47c13d31a29ecd579885cc09f197f8207d23b2260ab10c94d5f5" }, + "scalarBits": 253, "scalar": "0x203300e949aff816d084a388f07c74b9152bb11b523543afd65c805a389980", "Q": { "x": "0x8c23ae9c51e7c92c6a59f0ed07a59f148b4d79394fc026931c264612041eedd3782e4f249bbfad1799212788c1a00d", @@ -134,6 +144,7 @@ "x": "0x1059566739d7e809f4e4d1aabad499f7e545d0d3726a22c38cb0e19d83ff2ad8687eb5d7252c600a1daccbaa77e7136", "y": "0x8b96eb20f3a0004ff700127a45f25063fc28e2f67efcb8441f4e5f62c45c75327a23b80849b88c50221d434687d3b3" }, + "scalarBits": 253, "scalar": "0x1b3da5ff83b40516def10b03cc800268b869b91528310a95e69fc0c24d27993", "Q": { "x": "0x1337449040d093bbc8bb045efabd39d0bd2c614e9d32a3fced300da578c8c7f8219fa94b4dce84b6f6590cec2a3c49e", @@ -146,6 +157,7 @@ "x": "0x137b08ddca0951faa2ba15e4f79d5f9832715730ab8b7a9ea62a957605fa02232de87dcecaf5049714f887e364580f3", "y": "0x9dddff8f5ea7bccc86af012cda80b58f56586c13c316345a5edf9e7221ea85687f4e7c2d551969e02150078f911b88" }, + "scalarBits": 253, "scalar": "0xb74095c9b7c6549479f9f8a1e2664eee2a887e6eaf9e9ed1e910edc66bb14f4", "Q": { "x": "0x196cbdc599661615105c79af664881b7b6c27e0998192788a8188a3537559b940e74aced53f0ea558bee9789089dc32", @@ -158,6 +170,7 @@ "x": "0x30ce29566b3601bef30e5a2396234292d09e149b419c510924a1efb4a1e8d07f8b45b4a40976efd3142ab795bf696b", "y": "0x19f9726ee1f191037d80b39f26d117b844ff7e1220c3b474d0db7f8b9f4663028f634c2c1bf805f6309b8bd44070bf7" }, + "scalarBits": 253, "scalar": "0x1fe7248aafa0171a278fea3359e5ddbfa3c60ce06c019475dc88eb8544ef3d5", "Q": { "x": "0x1a11c6e9eeb573ab8e302a9bbe5b0e223bab592ae806a2493a9370886e74ba39bd3c22306799d70430dc4c8e671cd29", @@ -170,6 +183,7 @@ "x": "0xa29c53534ed37be37af8f29756397abb64765b533550d339f691f04b4bfabcadba1dc8c4a61f60e10745e212bd1f10", "y": "0x6febfcfd023578c7554a609658c1f5457d2cb4fc469078f08493bb64039c091d88cefa2dfb816fe3be9dfb051c65a9" }, + "scalarBits": 253, "scalar": "0x10f8c2ca76ccf39f50a354204aabe0daa56da8fe08f90834486477294136523e", "Q": { "x": "0x5d208ce7a22006adf22c8a1ac04098fe4b9a9c2a6354b8b491a368c376c77bf226dcb21e7a49e51b0c66f44568b2a8", @@ -182,6 +196,7 @@ "x": "0x10848fe51aff7ab80b81954782eec8facaad3784a213c3e4968f605441426071eb860c6c2d0d01da11be074330a3548", "y": "0x13126e4d29b91c38a061e9c6248d64599f47e940138225f4adc085b35af68a81bc805bf52260019de5dd9842630c408" }, + "scalarBits": 253, "scalar": "0xd77b2fa252dfd15c053a2f557004feb0286877794e3c23f267e1397b6d73b7a", "Q": { "x": "0x116b1e65c835d9d8e042c1f7815b0c658fc41ba427e37a79a5c805b13d446eaf4e714fcead0a96b982f1de8359dc086", @@ -194,6 +209,7 @@ "x": "0x14d5afa9a746498411f1719e9f74cb387819458166e8cd553d9f32c31c922697b9fb12abfaac1ad55381010cd87da3a", "y": "0x2f0427b6590406c1f7fa1c87f09038f0d08369ed0693c39dfcae239a04d433fac6179cc29ca6f484678dace7c24bf6" }, + "scalarBits": 253, "scalar": "0x416af7fad0f5d5a277be71a184937b73e97325d7b47dcc7c4ca7b885041f91f", "Q": { "x": "0x18788422d3b4ff57f80127bddd8203ac64369ad90a48e6e52368f85b6a199cb16277f4814d8dca60e12d803008c93bb", @@ -206,6 +222,7 @@ "x": "0x1175183ecc5dd314b2b22fed08f26e4306272c809315566fc0fe4a8b616d62d1a67f6a29c3dbf8f90c7d44a1b0cdf53", "y": "0x1425bb46f998c2b0d4237c2148545d032cba429c1dbdc02a3455f99fa2c8caf2ff5d4422f17c66a9869144c19fad7cb" }, + "scalarBits": 253, "scalar": "0x1abce9e9c079c686864304d479d68087db33f9edb3f7b2e4655fe0c1da4993f", "Q": { "x": "0x125108089bf35c15169563909d6820273dd2f4f3243f3a04b26a86c8341a189b2869ad1b9f1c99ed2cd8d9f9649da2", @@ -218,6 +235,7 @@ "x": "0xf853b2d6f2c220c9ade11e7130d0c4fbf480c57787497fa0d55bbb77bb91cf608b8a109c0416e4f4f91de2d0c3c7da", "y": "0x461b751b6a2443e5f6a76861e65bf34d24a792e81fbc4b53a80b92798369e6ebf1602dbf0986cd807de9d4c3699922" }, + "scalarBits": 253, "scalar": "0x9d8ee5d0d1286c796cbc9dde632ce87ebc1ede7e148bd453d54c6f69f6f6a43", "Q": { "x": "0x16880d061cb3fbd6fd92eda9a9c13f85e015b225ab6b0056142ceb9bda6532a09c51f8c9f95e5929e4c83937370ba3", @@ -230,6 +248,7 @@ "x": "0x19f44738aaa54f5a88211584dfdc7de4bffaf2fff7f978ec18eeca1ff56a9792d4d27aa670b764d2690f97de0fcc088", "y": "0xb3c03b9c0a8efc24b23821e482bcbabe008834c0c6bf06b6202ad03bb9078cef16c25153a541144bdb35dc1cd196a5" }, + "scalarBits": 253, "scalar": "0x5b84be2ad592c1a73f4c23a9968584c200f386ef8ccaa504da72b1d649c067f", "Q": { "x": "0x40c1f223b3faea4cce4ea800e4495bbdb5084643aced9ab2df6e813e010d892872b4ccc6eff03c32eee4019178d46a", @@ -242,6 +261,7 @@ "x": "0x1d7ade04b0b494cf9a18204549a1e43670f61bb597affcdad332235feb05dd7b23f3c19389b3466733495db14bc0b2", "y": "0x1385cd962326c026e114f51ab5e838e740bc9026021c0a45c3ea8c2a06f85da40a2d786fcfc52aed63b5ba0f5673505" }, + "scalarBits": 253, "scalar": "0x4e3b311a9d5b6cf2a052731b8f016734614949862a9f2be703935a5e0cd43bd", "Q": { "x": "0xeeceeef376634d1b387e689d22c5cdb4283a7c30fa1db69a85aadeaa9087dca006a32c99cd6185d1547369f74942ab", @@ -254,6 +274,7 @@ "x": "0x190c235c2ded176e51400c6be1101417ce6fffdc54fdf9e18996ecc3b7336d957c2de096dc867ded034be25db356af5", "y": "0x11b315331297edd1ccdca050b9f350f191c33c33376f797e811eb93b67c19be4bf3c0eb8b00cd7b9c7cbc3a0884d610" }, + "scalarBits": 253, "scalar": "0xb101f1aace4f33a418c299971d9f1aea0b147bd30d3c622be93f105de665284", "Q": { "x": "0x60ae24af5636a2175345ca0a80ea2c1a0005bf7fef15ec7288ee07e140b6d9a9c0b1329b5a6659adf9a9c0934fcdbe", @@ -266,6 +287,7 @@ "x": "0x13e60f4a6ea38f083da305b6d7bb961f104657a0bc7cc3e07bc62d2b2fc3adfe353e5e2b00083b1b1cddc86d77f4a63", "y": "0x4e86375d04c3712c7986f1e40561e15cdc1d613bdb23b2fedab9865f3f20b14f355aa2f3e26058b3001ff6debf1baf" }, + "scalarBits": 253, "scalar": "0x128ba2a07c3eaeaf79e8798a5f5e6c5b68facc4d7a2548787be9df6d017acbfc", "Q": { "x": "0xd1fa9799346f831d300da85d02fee8c7b6b338e04c94a82b87646c8ec48eb653a32977c839e5a8fedf33b764041580", @@ -278,6 +300,7 @@ "x": "0x1ac8f1a07307d2893612240cdc90d4e6d09cf6213dc4c628eaadd20c45d6468419e773bbc52dcc7f96fd4156ebc4b03", "y": "0x1ac12cb428a81e6b5723dfb9d2e913ac3867071ed348a1e5b3e201e471575e0ce816ac99653f30c4e954cd9d8b33791" }, + "scalarBits": 253, "scalar": "0xbd936c7066316d3f86b077419a0c0fb9867d4612208241fc004b548f1f54fad", "Q": { "x": "0x7dc0495d3ba2ac3ec9e042852c5c8a2cb409177412ab8cf7e914efb7a4a79ea74be0d2d05ac0e21cfd94f8360d3dc9", @@ -290,6 +313,7 @@ "x": "0xd42cc74c705c69cbadb505c6bdd3945cb55643645fcd0dd4f8d03e0f8f6cb555e35878a2083ddf1822289e6984d1d1", "y": "0x9437ba66de87d02488b924d870a6aac9d559fdcc3dd4a11fb39a587405138c67d8b40ffacbc4c2c569216eace7426e" }, + "scalarBits": 253, "scalar": "0x125b0927fae0602054e45cbb2606d068f8caaf94e1c5986186301cec80171075", "Q": { "x": "0x566b4cba972d223e5ecf302db3abf9a1b5f635c695796d62db56290913f8b3f5cbf93340153d6782d9db190bc1a38e", @@ -302,6 +326,7 @@ "x": "0x1abd2a45d8a9271f700f33eeeab223b68ce7f1c3220c23584b8d19c4ac9eb1bffcfb849ac257787211cf4ebfaa80aed", "y": "0x1737af483d223a5e039e8715f2b529652e1b65f8a41d4a068f019f8057471ec91ea7a4db4401295de6c86f50b42e2fb" }, + "scalarBits": 253, "scalar": "0xbdb46c0eece9c8bac8a382def90b522b1d5197f09cf9f7cd98b710845ddb7b4", "Q": { "x": "0xe789cd635126c3375b33dba71787bf586cd3fdcd088d6649e6204499027af4662e96b7c20e50ccda28256cf3e2330e", @@ -314,6 +339,7 @@ "x": "0xb268217aba354ab4e990cf3ac64df96850490c7d7e4dfca5af149e282310109875348dc46425372e07257c0fd60444", "y": "0x9c74d5a1e5349ddc4e74514f6c2c23ad38a330c6ea4b9121db2b99dfd433d3394a6055d9968282255490454bf9633d" }, + "scalarBits": 253, "scalar": "0xce4e8733f9491e3269ff2de895375cc946ef4aacd3f4b2db5252c67101ade8", "Q": { "x": "0x195fc3204d6dea6414a5eff56329e1c1ce3ae7646ba85295d2b4801160a1464c96b370a874ec2e118b1a20f6cb7e0d4", @@ -326,6 +352,7 @@ "x": "0xd9b773201b05913f8ae27d7c894dd16542b3495324462e66e26ec3c2866f446b3bd97cad95e1aff0123f60d89286d3", "y": "0x6a4ca5ef1dc12422d0211814b79a2c09e9113c160164263e165fbbecfb49b80edce9e37ba98a3411cd99180c73dd8e" }, + "scalarBits": 253, "scalar": "0xbf62a8efc2c13d8643bf7ae7736547267af110611b331deef2b14bb7a12f17", "Q": { "x": "0xe8a6702c87c1465e535502290b1116d122ca62e440768dfd1b40bff78c6da5cd105ff12bda91e7363d9bb6f359db90", @@ -338,6 +365,7 @@ "x": "0x16d668cfb1cd8f3ccbf8f6fdad31b5bf3b1509aa2e17d2d5731b6fa6618730f4f2d58d692c082ae6ac1730d1667459e", "y": "0x10fdd5a6c3cf89e8fe4f908a99ec74d83107bdd071f07bb9cf6399eb83a72158e3bf19839e35236605aebbb708873d0" }, + "scalarBits": 253, "scalar": "0x56905360f50fadc7b727060812eae0a48e31249ee16ef94d0b905575982419a", "Q": { "x": "0x8b3d0eb8490198e3f188fd2958fb11522e26b7f015788b451478d87ad91c81261956897daf5cd0d687d1af01f9a44f", @@ -350,6 +378,7 @@ "x": "0x10a63254fe9b79cfcba46497503df4597202293729df02430d48150d541f6f0637c8184f2ac17ecc393acd6a17f5c2", "y": "0x4f075f85da79d912f281fcc6836a026f8ef0f81b82895e44df9373a66bcb75ca3c9e2033f394d34c1aeaadd3860753" }, + "scalarBits": 253, "scalar": "0xf4dd3101ad878e82d0ea59883e07402aa4b31be2ec48738a455a1352c253e52", "Q": { "x": "0xd5fe9d3786de4eae06df72da7ace296efc1e64c2bf91f9d5b4aa763b7ddf96d29966c493b485546088c915a01d5e3d", @@ -362,6 +391,7 @@ "x": "0xd5b8211ef9e900bffce9f3cd0c8192ed312d0986115c958a5f3fc6165a14b0477ca76e8b9001c122a893a370539ad4", "y": "0x5caa4a51cfb24184206f7ce8c374a991df2a0929ab43a9645c79dae48c143a59d427c6d4a93dbf5652e407007c4920" }, + "scalarBits": 253, "scalar": "0x3882624dd59fdd8428cf3fd28db20d28a94ba94a5e0a8fbc1ea4c3a25a41755", "Q": { "x": "0x167afd3babe791a31241bfc7f7b417fa0f2ee0083fc9424707414e7f28de55ff95744d324f57509fa6ff2d9c59068cc", @@ -374,6 +404,7 @@ "x": "0x6e7e8b036725a99e4dc1ce6d353fa8388d13221803e1d0fd53c60353de4add409f495c7b4e7d750cce796bd839abf4", "y": "0x17d059368fa0e6b4c1509644d65fcf2f767b30f0b6a0b8d50bcd71ec49999043e25dc81e17f48ed638b8efd9231fde1" }, + "scalarBits": 253, "scalar": "0x1a2d363a7d869f9592e8cf63f5df14451894f8d5dd7b41a3cac93a13a157a79", "Q": { "x": "0x19238977df4ca8f585af4d1871bfd4689f52df63a89bb3f5938e8512d1c95f620244030013f807128d2b229c89105e5", @@ -386,6 +417,7 @@ "x": "0xcb49fa5f22e9b25c6ee37c06d7db5bfe71ad40fdb9b8bbd23310854fcaaa36514660e26e3f3d3b40683221506008e2", "y": "0xad5d0cc67a9bbf6d9de2f40f24a2ea1e82b810bed1ac6e17177b8c0eb5c6101bd11d9f3b1cd7d5144992ac68a03fc" }, + "scalarBits": 253, "scalar": "0x828fa4ffc8d5bfb75c7df4fe8b731348c9235020195b0c0277d87f2528d2beb", "Q": { "x": "0xdb6bbddbfbeb8adf4ef28dd67f74dd764c7fcabf7d3958103bcd159f6d75a7e57c8fbb356044ea4285e4ab883c8591", @@ -398,6 +430,7 @@ "x": "0xeff19b81e8c019b4e66372deb4bbd5eb53e7fd28f50d191202219206ba790b1e7ad80072c07533cd110c6aa23f22fa", "y": "0x10fedf92b738516b1b69ff28fdd02160fb57db01ed9227ab469375a5f391aa24bdf4300a259b4570bd8bfda01fb709a" }, + "scalarBits": 253, "scalar": "0x3f1f2f3cf086cd1246feee0c5a2464cea3dba7e0b89aee64337644111924b1d", "Q": { "x": "0x5ac25bf2f486c4490940c4f778730e6901c1cffffe85b16629e24eed4fcd7b07f44edb924ec5bee3d84b006686a092", @@ -410,6 +443,7 @@ "x": "0x30b8bae257cd9754bfacae78ff6c56c4b5acb83d60a7e556bcda6d6c0fad2405f040b7b365f1b14cccd302285b89f9", "y": "0xc5e50cb86f60bec122f7c304549431a16f3522b7d7128c40bbdb9f3a525dcc402dce462152e1f19f80ae3430208d9a" }, + "scalarBits": 253, "scalar": "0x3c560ba9a44130e7b566b2ad39acc7cf178ccd0272b84dfcf53b10acb8e3be6", "Q": { "x": "0xbf61a3ed87dc003ab2f17cb981a33d1810bdefd6f0fb9b245c9647778a1fa6d41b526e2787c379076412dde07ab01e", @@ -422,6 +456,7 @@ "x": "0x10271d70d423e4da106933c84df4037af5be96296f905e6088a44eb0b0b0c2078eefaec55bc24078d4483d3e5f0f0c1", "y": "0x112a6a736544d6cbaf86498b9c24cc07be48818e7e10240a53ca7a3ec7ccae1904960b75ab09ffffa95ff7a6224aecb" }, + "scalarBits": 253, "scalar": "0x11e6bd418d7f4688bd95500c2c6bb17b54b1374c0b120613810a740f39319e05", "Q": { "x": "0x12ff92ec16179edea66c4cd8e47ee0323952432c8698f8b9cc8ce62ce1b7146f87888eecd77a7ff922dcc89b56fdb9f", @@ -434,6 +469,7 @@ "x": "0x1ad73f190dea64c1dbb1cb86989cd169040532af3b6abdca5da63de6472783e60b15cf8afad4590b933a275fa09f82d", "y": "0xd2adc75756597618fccc80bf152fb2dca16c5b8310824c2affaf622cc97aa223aaf0aed4fc9ea44d75eb6b1b0a3f1b" }, + "scalarBits": 253, "scalar": "0x6e48d6bc3ead3859bad81057e1e4f6d15f1f7b01cfc0434f536b7dd7226dc8b", "Q": { "x": "0x8519af36ec945f4d624a6bcc62acebbe006d78f664a7fd651b0989f830a80da1c158f4c6ec13572c2918b8c10644a5", @@ -446,6 +482,7 @@ "x": "0x8cb6a687ff4052c149a9f8ef6301cb9023a86eefa2eb1c4abc5f852d5a6101098efaa8f2d7d62a5e4c45e95d0d2148", "y": "0x16379adee9e0b4f24c8a7321b67633b4ca92a646315d19fd7d615d258228fe55788bfb9b43066358d3fd86b30ed5e72" }, + "scalarBits": 253, "scalar": "0x24acddcd653958352643dec812c75bee17f729b0cf1936df8c60669711d8ee", "Q": { "x": "0x17d03cadb318eccf24680c21609cf42519692c1c458b67f9bc41d892bcb6bf3d3df8d0c64c6960b01dcd1fe7b65e451", @@ -458,6 +495,7 @@ "x": "0x160f035c984fc14fc4feb1d03f2ddc4393693508e708fc7114dcde0a7b01a60b7ae26a7fa49517895faa9f05e10030e", "y": "0x30a35286590d25a199f19b6b160d0a35ade83191bcb4232fa709d73fa78a411120f2f3bca39beb8d4eb71633c76ee1" }, + "scalarBits": 253, "scalar": "0x48a33710b79c49635709fd11ca9b660302e17361dbc11623db76043fda45f83", "Q": { "x": "0xfec169b3323279c55ff2a6fbb2b5c6ad2db80f862ba24623af570ed752cfeb8126f35b62e3dba9a2ec7c95278daea5", @@ -470,6 +508,7 @@ "x": "0xc05a5beb427c59de69288fffebba18ad52aebe170f9d25eb6d33aee9909c2cef4ab8aff3277d286a34370b0e3a48fd", "y": "0xa18efa9f07c033c915282c43539cef367ceb33407b945d4e8cdfd507a16ce173817eda4d9fdaee980118ba599bc931" }, + "scalarBits": 253, "scalar": "0x2927e0845fe1a0f33ff628afb719e558d4ebf1a928e0c965eb224227e5ba3b9", "Q": { "x": "0x195c37ebf48c46aa59cc2e936e2e1809448bf5ad196bba905ef30a7c215453e40720f807d7028f93dd2dc64b3b87e5b", @@ -482,6 +521,7 @@ "x": "0x16a0ab8e16b4272940093ac7f56613349ceac9f476af5c5e415aef4580b630ce3588b2aa5bd3aa27e90716f7e02a330", "y": "0x4aa4fc5dc4617aa52d71d07f0d18b246e7380c081f6ad6e406885e4175fcd949b58aaca1ed5f4660790c84ba41b3c8" }, + "scalarBits": 253, "scalar": "0x82a86ac4d89d0e0bf2c9fe28e0fc0812d4267663157fe0ccb319053076a2449", "Q": { "x": "0x8b1161e6cb9406e0377bb1f7bc54b61d381a711768cf2df9ef010e98f5a6aff4f129b327b7a26506bd2ab5d4a15603", diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_32bit.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_32bit.json new file mode 100644 index 0000000..4ba66f5 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_32bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BLS12_377", + "group": "G1", + "modulus": "0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001", + "order": "0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001", + "cofactor": "0x170b5d44300000000000000000000000", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x1", + "vectors": [ + { + "id": 0, + "P": { + "x": "0x4e7e6dfa01ed0ceb6e66708b07cb5c6cd30a42eeb13d7b76f8d103a0a4d491450be6f526fc12f15209b792220c041e", + "y": "0xc782515159b7e7b9371e0e0caa387951317e993b1625d91869d4346621058a0960ef1b8b6eabb33cd5719694908a05" + }, + "scalarBits": 32, + "scalar": "0x4d44d3d6", + "Q": { + "x": "0x1057130d34ca3379e94b01e0a8ee12b909fdb2292ff04eca7995fb239a7fb3b363228e808a09d5895fdc1354ece0e31", + "y": "0x57047087dc0b9b2e24699da497c1e73ae8a51483f1ef13400c8741451b51f48e93080867ca54c7a0b84c362e0a9dc1" + } + }, + { + "id": 1, + "P": { + "x": "0x13d735b28405253dcc0bc60bcdc13633475ffc187d38a9b97655b0d0fa1d56c4548f11ea0a795391ee85c953aaf9b83", + "y": "0x1693101123fd13a20f9c0569c52c29507ba1c8b6dd412660bc82e7974022f1a10f9137b4ba59d3f0aab67027cefec19" + }, + "scalarBits": 32, + "scalar": "0x9fa2f940", + "Q": { + "x": "0xd6b9459d812d687c2868c712d563531bb9a9d16128e20a8ee8549244d6d144efbcd7123f1d78f236cc1b940b9c00af", + "y": "0xece76cc2774612dedc5206c8ff0e10f0456654db3a4de9eaa3df733296f1dd69e5c06400883e55fe88d3b753d16da3" + } + }, + { + "id": 2, + "P": { + "x": "0x6dd2211113cada09d3b96848cbf21ed14f6fc238b581c0afd49aa776980101e4ee279a256ce8f1428d3ed3f70afd85", + "y": "0x3b406b4433a3f44f8e196012f50c520e876412fbcae2651916f133c1fd3899c79f676e1abba01d84bab7ad100c9295" + }, + "scalarBits": 32, + "scalar": "0xe6c29527", + "Q": { + "x": "0x17313abb5413c661b2e7bf888236f4516c1917147a79d035ef607af5b226482aa47c017ce9545b10b35abc93cde1eb1", + "y": "0x14d5297d58a1e230817c95edafd7ac8830e63244bcf2d7ea11884512125a0af8ecc627dff082d094c3d4b75671b4f64" + } + }, + { + "id": 3, + "P": { + "x": "0xecbdf4684c17300a0801dfd8355dc4d8bfc04b11c03c9ac54cc80202285bee4fbccd8822e3b13fb8d5b0d0a62428ee", + "y": "0x3a78b6f7e1db6b08ae169aee93e26abe4573e26fac83dfd8582ad9633bce32581264f018079c3cc81171833f452bba" + }, + "scalarBits": 32, + "scalar": "0xa50b6a0c", + "Q": { + "x": "0x19ea1534dd1da7b4cf9689612241c66763f70d632da9ce42d14c8b80b41aa66ab6b22ccc45b386f82e1c26b1213af98", + "y": "0x170e3fd7835a4480620b6b4489fa70e12177254adb7630532a2c3a0362b7c743095f3b070bf7d2055c98f227b894f61" + } + }, + { + "id": 4, + "P": { + "x": "0xde4f1d56ab88aad99acc8393357f1e0f4cfce90b19246c7544a5743d4f6001326f41760958a76f267a0e16a7491135", + "y": "0x10d1cc433b08d47b7af8791f6ce7f16c0051a12264e2a5d1185a045a895470474f128c2dbf3fef31483ec028edcac0" + }, + "scalarBits": 32, + "scalar": "0xb35a6585", + "Q": { + "x": "0x177ec896092339fec731249507047823375fe6652adf1c3b3d2ff2be7e1a0de450c15f7ee3e1b5e6922d0dede80c8b4", + "y": "0x37922b41a66ccd5c366e08334478d9809e7f1cf5ded463293cee0af80a34357c5e50e1224b6388ec659591865cf9a8" + } + }, + { + "id": 5, + "P": { + "x": "0xf7b56cf212a8906ed77a758164c0bd05ce1fbd3ee3c4357e7a09b3aedc748a29ace254f1f6df35b8cb74361060337f", + "y": "0x187f956b3a7efec249fdd2bf46d63fb6d342a4d866db1d717eec2f2498bd73ff7eef39eb12266c354ee5bae840b808a" + }, + "scalarBits": 32, + "scalar": "0x6196e20e", + "Q": { + "x": "0x4da3adde05f383cfff4798ddafa3adf8ef76b0035f1c480611ad75284b8e9d146a723cd943bb1db690942baa30a7f5", + "y": "0x1658490c03b682cd6fad8017a910fe0f45e95a728f5a04574b00314e4d40a96d363d51c49310e2e27b37b44bb5092a0" + } + }, + { + "id": 6, + "P": { + "x": "0x117a76a26e3950b686d643c024eb63f4ae0bd0534aa634a6c0f549d2060d0c35a8b3ad39680980e96b643db0febf851", + "y": "0x10a340fab037ffcc7e4fecb87f6a7c3ad2d57d75854e77a3d3700efad701f8c5bc84ee7e85154c67d418784c0bc4cb2" + }, + "scalarBits": 32, + "scalar": "0xf7e16f51", + "Q": { + "x": "0xa9335a676102d3bb1eb5b2f2eb7df9ede4bbfab3cd0f57910d5d0992eecfa37f45d42d5116be04a0df32a3f3013f87", + "y": "0x6162765f9037dce159ed95ea4c841f30b23ef179b174bf10fe4f4c2d54deab083fe0d0140f994fadea1ce83addb80c" + } + }, + { + "id": 7, + "P": { + "x": "0x6ccb3c18dc7eaf4c7669e6dfd7dac7d9736bfc36dba7e6a78363f71d79a7d8c8e1d4bfb1c33e65544a444a2a8c2fd", + "y": "0x3830d0a273afa15590732364fc5ee8dc0166fd4af88a8cf0b950fd1cb7435eaeac7ec5aa9be655c67881110a07d6b7" + }, + "scalarBits": 32, + "scalar": "0x1aed611b", + "Q": { + "x": "0x74c410a7fc5a64af71f008e854df8623abc86a824ad698cd87b707c13b2e8ad2e25d913b74e35b45753f2a0145ab62", + "y": "0x1e69016e55319d1f508889ab1638f0835a7b22311b470ed582be662b1d14d5c234f4442b5c31450261578d7467a602" + } + }, + { + "id": 8, + "P": { + "x": "0xdcab756e4bcce2297990174a4e6fa59df2a9b91791e1c48d1c2c0feacd99ba645b8fe7d4e15cdd68c065679ebdb92a", + "y": "0x155b6274ccaca11b4c10b00d7b767e02b59049d1c86c9066fa250f792d04d948475f6b7e1564610c97b921115c1665e" + }, + "scalarBits": 32, + "scalar": "0x80fdb34f", + "Q": { + "x": "0x454877f23980c200791ec31377bf79dc5d233a48f5d8903c5c69a8ede45d7b68e70d004b0e42516a732e5f431e8410", + "y": "0x8dc82f7b00bad862e43769e19b1d05955cbe8aa2bcd135153b1e2a874d76e65476d1e2075fe4b46098b97cc1870e7e" + } + }, + { + "id": 9, + "P": { + "x": "0x105ace4bd8d8889206646898cd1acfa44b6114b7486134988fd9472cc38152c4df277fd2a9f4feabdf480eb9b237860", + "y": "0xbd63cf69ab74fb62f1ab8f67b8a8a3dba38f117584dba49675bea94b04151fa86aded541c31ede0d6dd9b8b0c60375" + }, + "scalarBits": 32, + "scalar": "0xe949aff8", + "Q": { + "x": "0x164784cad9fc18b9d7aed6659b50f347dab991245b1b4ed30a5da40dea163265ac12915f195caba1b3bf002171c6cef", + "y": "0x271b41dc9dec4d84e1ee0968741e9f6196bd8a8f1dc301576072f8c7d861ebe4e09317750b703606713e3726e73c07" + } + }, + { + "id": 10, + "P": { + "x": "0x1059566739d7e809f4e4d1aabad499f7e545d0d3726a22c38cb0e19d83ff2ad8687eb5d7252c600a1daccbaa77e7136", + "y": "0x8b96eb20f3a0004ff700127a45f25063fc28e2f67efcb8441f4e5f62c45c75327a23b80849b88c50221d434687d3b3" + }, + "scalarBits": 32, + "scalar": "0x24d27993", + "Q": { + "x": "0x594b669d39422b551493a771d9b7c91c11e786c90c2b650b3479a3435ed6cc424906fccc76d2e8f1393f3236005637", + "y": "0x18fbcc1940e0c7482ca3fe5710a73aa1ec89fc0fd14429665ec7f76a6a5d493b0efaf1b9c060bbe9d2132af6b216637" + } + }, + { + "id": 11, + "P": { + "x": "0xc2abd04cb3f29c317042a32673bf051f92c5c201fc5c7cb30f04d3137c04e8248f868786ef0d9fa68a96a3790dc35a", + "y": "0x30e1c26781416e7fc7c6c5f79c7c8518636c5d6e5ae9b8c49a95356d17c3025eab71de7bbc76c1d20e9fd46cfa148d" + }, + "scalarBits": 32, + "scalar": "0xda39ff17", + "Q": { + "x": "0x3863c14b8c7935c969ff190da40f9bf43d3445449696fcbd63e13150ecf480b1b424108cc9d97d9099868a065f73d3", + "y": "0xbdc39d7dbe8e50fdf674221dc339edf575897e3f593f7feaa9dda1cd23aabbae5b5ae7e7b93d34f17da48513f97118" + } + }, + { + "id": 12, + "P": { + "x": "0x11b275a5be4b6dae528cd6939f359036dfa30eed04550010963ed0af362bf098a08f3518ad9d8d61b9aea1759b595b7", + "y": "0x12eac95fc5e18db1795239dd96f09153ad3d864776f70fd8dc037761e350f32f99976bb66dbbdea795a2d42843e9ab5" + }, + "scalarBits": 32, + "scalar": "0xb4294fba", + "Q": { + "x": "0x11b97373489668ac50f11880cb2d205492550b749f3e6351e9b01b0b9479e2184770ca20fa966b4180f2ee05cd0a5d1", + "y": "0x1f41e31c37ecc3de23624031828fdd74a6d410156ce8aa5bcde2efb06723e7f890ef542dd92e61ef05089e73e19483" + } + }, + { + "id": 13, + "P": { + "x": "0xf792d4fb95370e0e368e63da617a22f04a8b3ccd4815be3593067460b9f65e38870b780b8936cd78a895a54b76ceb0", + "y": "0x2b76e48716dca5a8654852d5e5e9c2a194c0a90a2cc5b6edaebe602f9384f064c8f473a5546f976566ba58d2c0f4b5" + }, + "scalarBits": 32, + "scalar": "0xb9b70552", + "Q": { + "x": "0x1068d2996871ba1549ee710225d3963db4189ade33a1206613d342cb2844fff235a231a2942ffa9cfc0c17529d528d1", + "y": "0x836b1659ad1dceba6a07813a01efb74650963fcdbf230e9faca3b4810b75f3abac118900ae5bc8da7ae9c38a3685a8" + } + }, + { + "id": 14, + "P": { + "x": "0x6bdf09e11ba10f23635e6161a3068aca8ca7626aa8bd9c32f391df6dd50be2aa0058d7a13822b011dd017a4061b78d", + "y": "0xbda4ddba96a6069abc1107b74f268f9091dcf4a489b21be1748e810ad62a673f5791789b18983324c490da59d07a93" + }, + "scalarBits": 32, + "scalar": "0x61bb91d8", + "Q": { + "x": "0xa93b7a167c3d3050eeab20dad1c423382496ea31ad0e002d3e3503ce3ab6e699ad3523f5ea6de0d782618191e34025", + "y": "0xe8860008b10a5f6e1f914db2faae73f1a0301716f6ae010a972f9677f8bc9619aaac7769aca6c06b51f3f6b95e3f80" + } + }, + { + "id": 15, + "P": { + "x": "0xe79beaa4371ad4efb16b3701f8b714a49af3a107e70ea6d93c9700501ec0a2243124cb579acf5d1b6ba67c58ee6c22", + "y": "0x17c143bb22e854b7efc1561989083b682eccf66b1c4b1214ae0e3c5ac3ce24ea84036eb2c1bfc68c7effc250c88d2bd" + }, + "scalarBits": 32, + "scalar": "0xba58c87c", + "Q": { + "x": "0x3bb4f00291dd16f7afea5e570d0072641e90c90b7c01d259421655628c9ac404f943381f04641e6057cfc2bf7ff4a", + "y": "0xbe1a2f9b373ae3300e1c7b40a95e48060dee422c7049a9de1d493ea3b08b49e52331694f7b8a9b6ca892ca71fbab7a" + } + }, + { + "id": 16, + "P": { + "x": "0xc9afba388614f83defd373c9a2c659ccede503b1311c03510ce3dfe61f22e3942d7daae7672c971ae9e16b6221f992", + "y": "0x986b8a41f37035668c6476cc6746003fac0ec6b24c1788ae6f64d77ca6d9010587669beca6cd9bd6703ac686614863" + }, + "scalarBits": 32, + "scalar": "0x4aabe0da", + "Q": { + "x": "0x180c894164bd1ef2ce4f546f209286232a3344ae7fcbec8ff11e752096b0fa977e3bb3c566d3469d5dbe95c2408fd36", + "y": "0xd53e454c36f8ce22fda2ffdb22d48b5b1390f5a9b27d7dd5cc0abfcf93a8a8a13738316f56a448134528e16a9d7a89" + } + }, + { + "id": 17, + "P": { + "x": "0x847795fbd5c3287cf629316a1e9b9be53f360543f51240e2c360c58b3400201f7df9ce4b090c040d26616c1db25c59", + "y": "0x175138315c89f4f7a9a7132dbc7abb225bd2c939bc798d7db06c650185405ea7677e2040e6ad888c613e49ad9a5642f" + }, + "scalarBits": 32, + "scalar": "0x871bba98", + "Q": { + "x": "0xd25af63839a5fdba1c0336c620f4b04d9acaf6482a2b073561cd69d70841c7fc28ec8f41df20134e21eaebf0886626", + "y": "0xe44f27dd0e4180f70c7815464e8d7ae1e0d96136fcf76f9139cf419a698737362954c64f6ec465fcaba18b7991137f" + } + }, + { + "id": 18, + "P": { + "x": "0x111ddb965dcddbe70c29cbeefe31005dd9f8d434168ec5db320d84c7478a189fa5d5e841e7a8935de2ee57ddf007391", + "y": "0x14b1d68acd93ebcd604d22981d2fee92a4cadc69c2ce43e80f574b750bde81d03e319dcdb482a2851292fe7fb18557d" + }, + "scalarBits": 32, + "scalar": "0x1b0d3134", + "Q": { + "x": "0x133938fe659c9e637a552d44d545ed8c80923af744afdc020ac3b8a0540487bbd8829012c0c12f54708e19ad6a73676", + "y": "0x94bbc266f1ba8d6c499e7414de8960d46db7ffc44f302887235f44dbf7d1bf129415c6ea4dadf086a08e53b7431fd7" + } + }, + { + "id": 19, + "P": { + "x": "0xf4554be6154353d830d01466379bccdea911c068c6daaa02c8f2ccf23667b581a11765e77f4e57e9b00e27bc70abfb", + "y": "0x18e1669530a95c2227a5675a79c8b6723ce8d3be4bd751e2c3478221027f0cece214fcfd5f897591fdc4b1a8a03242b" + }, + "scalarBits": 32, + "scalar": "0x3736a09a", + "Q": { + "x": "0x337646035ff868f112ca030ef63c19b986aeb5e53f6005c510a166a37449329756fbb24796e84e55f73c117545cc39", + "y": "0x188c44d1cde2698fa71b9b13cb7eea01b9c9fcc043f27e3afb1f4f205aa39efe2e62772f54cdabb1bb25c8c94da86de" + } + }, + { + "id": 20, + "P": { + "x": "0x1664c58ecb3b403552d91b730f5031748d16ea6842a63f9388ad874b075a243a2fd93dc259311d1e4ea12938398f326", + "y": "0x174a70945cde4ab7f8947e3f7beb0882c795f94c7c39258a31c2107b29474090cb06d97032b1d4e04b7c29ad76bb03a" + }, + "scalarBits": 32, + "scalar": "0x16943478", + "Q": { + "x": "0x389cf80895f490fd064b4bb6c37f8b1c9662e29d8cb053a181f0930aa5475971a5095fe3c25a3ce4466079b41d8c61", + "y": "0x1a8b209df722017bab4f6e9e64fbc4c520183090989f424582632107bc9bc43f94db7f5613d3ae2174217b138fce57a" + } + }, + { + "id": 21, + "P": { + "x": "0xc1e320ea932e82419049c46222ff2be549b3cfd86402a0dd96e4690c20598c03f04469724adf486ab1d0ae2b05080b", + "y": "0x6ed914795baaf1e49a59703ec3a8b3102c98df53ec7aeaaa87337154a1067e180a8cb32a715196be1696eadf236f05" + }, + "scalarBits": 32, + "scalar": "0xad592c1a", + "Q": { + "x": "0x113ee3478c69bffbaff6cf5e3e60e5515ef7297d96a6f7edfe09b71c03e8bd70100e33485d478cb98d731a83321b252", + "y": "0xcbc29bb8a99cd5a867623e7355c2bf27d7a6424d0b7d7d667aab36537ab6aa2d716b71970821037835caca060cefe2" + } + }, + { + "id": 22, + "P": { + "x": "0x1d7ade04b0b494cf9a18204549a1e43670f61bb597affcdad332235feb05dd7b23f3c19389b3466733495db14bc0b2", + "y": "0x75dd6cb592a4e85829b66ec142c5aca61710f0a0d352eac2b4b96d1999c225d66885bd3303ad51aecd645f0a98cafc" + }, + "scalarBits": 32, + "scalar": "0x5d24d0c3", + "Q": { + "x": "0xae4f6d5930e7fe04056bc5bc82b70189246288c478ed10c331a771ad4727a4b70ad30c42421bf874e2b1ea228b15f6", + "y": "0xb9df150a8f12e8a693620727985e8977b82d05fed95a3ee87e85fc82afa74e4b503dec7a95a0478bf890861fa96fdb" + } + }, + { + "id": 23, + "P": { + "x": "0x190c235c2ded176e51400c6be1101417ce6fffdc54fdf9e18996ecc3b7336d957c2de096dc867ded034be25db356af5", + "y": "0x11b315331297edd1ccdca050b9f350f191c33c33376f797e811eb93b67c19be4bf3c0eb8b00cd7b9c7cbc3a0884d610" + }, + "scalarBits": 32, + "scalar": "0xcb6b6820", + "Q": { + "x": "0x18b2020293e5a51985b010b93d21fc7725e53df58e0954d0f99ca05a98d779554cd481e748500b8cb3b5d17e2ccd6a9", + "y": "0x2f3c6847fcee68ba29a7fec51bf7f2f7bf19bb51094b54bf2ff82ec5522f83bf4c76c217ba0b4bdaf5e4906c880a3" + } + }, + { + "id": 24, + "P": { + "x": "0x1901bea4f8473d1c6a27ef1eb2ec66d2cb832dc9e378b2a4f07009100d471352355883302aba05b91391c3efaca9bab", + "y": "0x1200a3eadce9d5d18ef22409985b6638c23ccc39ff8e05490c1b09451e7bf791d005cd932c1c8b2fdc1eecee14f6cc9" + }, + "scalarBits": 32, + "scalar": "0x71d9f1ae", + "Q": { + "x": "0x8343246697bc538d4c1bcde941e025564bdcf4ac2f4172c847717d4e8599a3c285bed7e9b2febaf9d390f19c3893e5", + "y": "0xe4361200ef0248d00c3e088e5ab1ff330a6d80bd688491481c0db15c52e7e001b7a6047d3766a67935a0cda5390760" + } + }, + { + "id": 25, + "P": { + "x": "0x7134b182010726342af592adba2380ff55a6d6c6da71c758ba099db427ec19ba751eec28fdd2219a934d58dc3926f6", + "y": "0x16e8d485b6e89cbe8459425123f86a31b1d911d6b5a9a4636d8f2dfa0478b248ef4e4d0ecd5b683804d284ba75299bc" + }, + "scalarBits": 32, + "scalar": "0xfbda19c3", + "Q": { + "x": "0x5eaac304c8cfdf8fa5b50cb2273b0a92cbc30e04a5c538343161cb0edf6fccc7683fbffbf27f9a3d345fa961593273", + "y": "0x152a6bc13e0bcda1f2c44d9d2afd7db87b2a1b9e4ddf9b3ac7662de03d3168020e3e6b7084a6d28f7e3296a08cd5b34" + } + }, + { + "id": 26, + "P": { + "x": "0x54ed3f8dfe6d6a17c82300d94088ee7c1f38a21b7b28d0283b278193afaee320e6dc3ec591720d1082266daa0ee45b", + "y": "0xe5e8397fb94ce14d4138862a62ee02d3998d6e94b3d3f57600f182979258432b6cff862e871b2f753c6b573dc983e6" + }, + "scalarBits": 32, + "scalar": "0xcdf78a9f", + "Q": { + "x": "0x7698e3e6f8f2c305bda1fe666ad859648b02348e033117304abbe44e45294ec944b171192bba7a3c56a4a048835f82", + "y": "0x1627b906d3898370940e8a3688c3e3560e189ecb49b66a2fb6fe9ee5ee669aaeb8a67e1f5e695c6b80b4394805f4c9d" + } + }, + { + "id": 27, + "P": { + "x": "0x309102e56efc107631f19905b995367f4b1ba26ded1b940923abac734a8c691f5578d16e572c2f2f5b127d6e78f749", + "y": "0x19adaadcb449f46b6b1d722057c76194b176997832bfaf1c198f08d6fc27a3c970da10cc0f833dc08149fce4162b2fa" + }, + "scalarBits": 32, + "scalar": "0xa269e587", + "Q": { + "x": "0x5c45c4d2f2d2684161f6173716ad8d7438aaf6ac144d064f099438d864e9aa6b0224529687cf0f1ef611928fd00cc5", + "y": "0x1158e64350579567e90e09402a25285f70c7695fd23ecb9d2d65af980c9cb0ecd55ef63415f12e057c8381199a97839" + } + }, + { + "id": 28, + "P": { + "x": "0x1791410c0b2533bbce8a7b04557ed1da0294d5c2e858773b951da247927e6443376bc6e6c618842cca58a85768bf90b", + "y": "0x959c2db40541552f00e17142661c70fdbf72b37544c5f876036ef8ddc1264aa6668c9a68d9c66274e8454df308f64d" + }, + "scalarBits": 32, + "scalar": "0xd64d287c", + "Q": { + "x": "0x16ce84a8262cf78a5eef2c703a888000725d01464a122d2c244ff10ef6f08069bfb307805a76aad51f8e8eb4df9b9f4", + "y": "0x1409a61322426225ded16b739a8666d2494203406e5eacf946b1facd9b44a91cb5148ebd07941a3f0cda4f8540b2892" + } + }, + { + "id": 29, + "P": { + "x": "0xb268217aba354ab4e990cf3ac64df96850490c7d7e4dfca5af149e282310109875348dc46425372e07257c0fd60444", + "y": "0x111c57075dfdc4ce9ec916f1d351d176cea36c23a0ac7fdfd183695da35142cddc0fcee56697d7e5fb42fbab4069cc4" + }, + "scalarBits": 32, + "scalar": "0xe895375c", + "Q": { + "x": "0xfc663f8ec7bae755db76c8e8b8cec82852fb5a72fcd615e101ea86b47adf69f562344b2bbf72f575cc9a7351fd0180", + "y": "0x168b8bb1ed9af39c93e0080360dc9a286239e59e5eb17bb20f1d5a57b0c917ce96953d5c12fce322694ddb539a78088" + } + }, + { + "id": 30, + "P": { + "x": "0x12a10717b41454ecc5f438d380f139bf3fdc93df4b0ab64fd5056c4d903fce89c4d62ce42837a739bd7553d6aefaa79", + "y": "0x14736bd4e003dfbff095bd621b3fb6fc3b5f11dd245e2bc797cd3171b0f2984e9fca0ea52911f47d6bc6353a85b90a8" + }, + "scalarBits": 32, + "scalar": "0x5775e7ed", + "Q": { + "x": "0x3fb56e49813df8d91f5dad82dae0b7122ea23d7a8ee0c4cff90556f6080de67cf87f0fa455ceeb7eafaae3056a56a6", + "y": "0xb411999c90bc1df57a38b6940fea8fd5a8185fad10d806c37b585bac4e7f235246af851958ab2858681e99db43a672" + } + }, + { + "id": 31, + "P": { + "x": "0xc8b03f0d994486c7cf8b3127e81bbc2b0dde008d8196772312f35bcdbb5028b01471125ab124e960002b6c5263bd51", + "y": "0xd2b09ed86b44272e7841d30b64e03a78a9a79ba48b04647b992be8c0a016d5c4370e2d3e1a332ffe7ac9e099a8f5bf" + }, + "scalarBits": 32, + "scalar": "0xdd9c8404", + "Q": { + "x": "0xa3dfed57d22a4f728c6266dba3459caa7345ed38e6c612579a6d7946e7a54519c917ad838f2c1658361dff81db6577", + "y": "0x157fa9cdb52b77486bbcaf4cda383db4323ce2d183591c2009c33be5e7668d7d87bb55d41055205b28f31f3954be699" + } + }, + { + "id": 32, + "P": { + "x": "0xc01fb4cb70ae917ec4bf761beeb69c0d0a3c0157547203ad2862d03f4e4336fe17dbf36559d18d856315e1db50a53", + "y": "0x134e84c965b8ea4f15fe5d74e87ca7829b52ddac7642c98f8c1df084123b1a96a44de6a593418793eeae87a61be13c" + }, + "scalarBits": 32, + "scalar": "0xf4e60003", + "Q": { + "x": "0x441888658e00d0bea10f004e9ecc27d4cd2e56bda272cc5618a77ced79148859507332e3780dc7d0914efc71178914", + "y": "0x1d0deb9afb432322230d780f462a63380c22f684b9af74a2dd4dca8117eb46e4ead2506431b68ca20adc7585e95a57" + } + }, + { + "id": 33, + "P": { + "x": "0x1ad5a2be4145fe09b2b81cad1ecfd4dbb1f2c00ed7c595aff9f359b563eb950c46c7d691fa65d77fbda379ceb03240a", + "y": "0x45b9f6ab37276bb88f8d1127f3eacc0c79f5d8bab0a046dfe82965b24bb26c31a1db69dcc887874acb2af479be7c74" + }, + "scalarBits": 32, + "scalar": "0x98f4d528", + "Q": { + "x": "0xe2cf2e4546d628f420fcadc2870620d03e21c39da699cec813c60dca5a27da533870c8dbe6c6f9767f03790d539c7", + "y": "0x14ab5f99e46194c4b30aaabc34444b687559179389c585dd8d3662a46f96abcad1de6a77e61458653ad38438765121a" + } + }, + { + "id": 34, + "P": { + "x": "0x10a63254fe9b79cfcba46497503df4597202293729df02430d48150d541f6f0637c8184f2ac17ecc393acd6a17f5c2", + "y": "0x4f075f85da79d912f281fcc6836a026f8ef0f81b82895e44df9373a66bcb75ca3c9e2033f394d34c1aeaadd3860753" + }, + "scalarBits": 32, + "scalar": "0x83e07402", + "Q": { + "x": "0x12b2e4a1f27f001502dd2a99d197516484c68ba1087f0722467a94a95fe1f46b2ae4ebae2e34e4a4ee73f58974f2d85", + "y": "0x1693dff62714c741266d6c93b5b1d7901ef5d6cd1ccedd5300b5af2bfe32b00c570d4cf9859d737b8a53d637d20df99" + } + }, + { + "id": 35, + "P": { + "x": "0x19dc2c0828a7b07d6e2d16b635961bbba99b553d3fb977960b74688388f7eb4ea9253ca79873f9abf1d54c3d2929518", + "y": "0x1057e70a4191aa460eed3e93a612293183d0870a5f2c951b02426fa728ed41cfb864f0a13c1535b75ba3b729d1958cd" + }, + "scalarBits": 32, + "scalar": "0x28db20d2", + "Q": { + "x": "0xf2a8a0ddedbcc0436d142625718ba87ac42e2543cbe426d36646f526db5d283807b0b70f3e76c51361b48cc5b82b7f", + "y": "0x130dce33a43d131b75bd470d90d519f27c3cee7ff27b2f44752010dc735a0df97b050a84a6e3127b3921c5ac6347a9e" + } + }, + { + "id": 36, + "P": { + "x": "0x1111160cace5c42ba854699704d93e01ab8c029481823e2892eba7f8a06a9aa8b8e4f724723e73c79d2a38df6972a18", + "y": "0x19b14583ffce377856f1a53cf4a6ccf2681ca26d91f291a1f37337843543dea2a1c796b693309eea68c2edddf272b7a" + }, + "scalarBits": 32, + "scalar": "0x599e5779", + "Q": { + "x": "0x7fec955beebf216ae448491fe35c6fc6f6e8e8421a30a09b0da5fc380eea14ba65a2fcb5c0fb04e39555b8934f89fc", + "y": "0xda85e4ab54996714b5f85b3f2a7f25f6db7a1df89b7798c0c07a35084ff269baf021162b23e81525f781e061d01e36" + } + }, + { + "id": 37, + "P": { + "x": "0x8a4444e930e63887c5d223d66435ef76a525e3be16c4297ad342734e8e805f33090831b5c1e85a5d845ba7e81fae54", + "y": "0x7cca17db84b56a921f098e532231addea3db74ff7c855d56fc262dafb382e4a8a926f991707bc8adb0f308053b0411" + }, + "scalarBits": 32, + "scalar": "0x3f5df144", + "Q": { + "x": "0x6b7a75c4cf68732341324436405bc6c69d717f99a6d3a1d56584b3ec59e403061e36a6250229d76682c00456d3a0d4", + "y": "0x154c3f8f279a18a86eded96f8af1fa046347caa737668d245c724c0ebf6fee90da39fcaf7a1d07f645cf0ac9c24fd34" + } + }, + { + "id": 38, + "P": { + "x": "0x121bdbf98d14b45df164453e0d23f5597f0d46e4516459c122126245ce7ffcc3b1297e4b1ac2a90fb3aedfc41749f05", + "y": "0xc234d67539416b80959f3f6841b659333ee7fe5fa5fbff350d044a0558325100bc28775dfd10c277f5f3b8117db28c" + }, + "scalarBits": 32, + "scalar": "0xd43f6cd1", + "Q": { + "x": "0xb08c9bab3bc532c49e8dbd7fd460c2c74705722d26e7e0d8062a75266092bfcf62a25f29f6c3aafcb612b41c8ec103", + "y": "0x12d6e24505495e587e1b4876bbbb4b0e8912c176de89a86e5f96bb0ec5ac930517d6ffbaba0256e727cfff7f9210156" + } + }, + { + "id": 39, + "P": { + "x": "0xc1b7d38844f9725af35cf14c5a81b3b231cd17673bf72798ae6208f202ed22a91fc8bd8d7cd7096c2487ebb31579af", + "y": "0x1161022e00ccefbce8d0769a6aea04dd228271d80001cf6d4e5dbc5396001b9642dc8d3388ad2871217c65ead16d1be" + }, + "scalarBits": 32, + "scalar": "0x9b6d4544", + "Q": { + "x": "0x141d091557eaae940c2c1f105f0ef7ca634be6c7cf3ac328d8292d269653b930e6395a2b53fd2e7f5dc16f5c7698145", + "y": "0x19ca05169d7ae4b63a8cd145cc233c52f86e39c6eb37cb9620a2ef79a3214e781ef74cfabe2811ec20decb8dc306fa8" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_64bit.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_64bit.json new file mode 100644 index 0000000..b63feec --- /dev/null +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G1_64bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BLS12_377", + "group": "G1", + "modulus": "0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001", + "order": "0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001", + "cofactor": "0x170b5d44300000000000000000000000", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x1", + "vectors": [ + { + "id": 0, + "P": { + "x": "0x4e7e6dfa01ed0ceb6e66708b07cb5c6cd30a42eeb13d7b76f8d103a0a4d491450be6f526fc12f15209b792220c041e", + "y": "0xc782515159b7e7b9371e0e0caa387951317e993b1625d91869d4346621058a0960ef1b8b6eabb33cd5719694908a05" + }, + "scalarBits": 64, + "scalar": "0xe8703f57aed5e3fe", + "Q": { + "x": "0x37fcc456ec5251b06529ba98bbbc631206898d5bd42f651ff4142c46f2588a2f48d2156f92950f4216bed40fed8988", + "y": "0x6e015b09239cbf14253fdaef27398f68ab734e8cc4b872eb9c0df1c506fea4714ec9c2674228667448c458e0ef6cdf" + } + }, + { + "id": 1, + "P": { + "x": "0x10ad71138d643b69dbcd0a13b0ec0d5fc33e8d543d6ce25582bba03afe24a52fc490a5f8e52be1e7325fc336e21d9d0", + "y": "0xd01ed96516b7d5748149eddcb7eb29f3211a04f7cded983580b7d459ebf8b8c103802f75a8fba563989f9818321e82" + }, + "scalarBits": 64, + "scalar": "0x82bae7a404ebfd8", + "Q": { + "x": "0x87a918b978b5aedfe6cd48cdaba1fe2ade363dc98e163ce70d2cac73ce0f05344f71c58d3ac747433f7977adde67b3", + "y": "0x17c8d62625b83dc8ecdc9b6d4566c2f6cc27a731e2becef691a9d205ce90fbd6619c8413fbebae41153bf4afe24df05" + } + }, + { + "id": 2, + "P": { + "x": "0x276146db802e6733a211d7568c3d34ba8907aaa5d6bab8d979c35527197d43e479a34a146f23acc2440bf19b5ff372", + "y": "0x10f6f53790e338882fd9153337612340fb8f563794a4d5c7c4f4cfc50ec9582cb1538a159a859e3ddfa3849ad1cee7c" + }, + "scalarBits": 64, + "scalar": "0xc3659423d6fdafb7", + "Q": { + "x": "0x173b3703f213fc6ccf5669ca95422eb01f299a5bff8a000976f478625d07ee3511f4dd64bcc9bfea02c99451f6a7ae0", + "y": "0x4c9ee41096034380ded8f3e585cec36d631378ff52a38cd8a8f89edf11152cf138d76933d800e5e337e8144f37d431" + } + }, + { + "id": 3, + "P": { + "x": "0xf7b56cf212a8906ed77a758164c0bd05ce1fbd3ee3c4357e7a09b3aedc748a29ace254f1f6df35b8cb74361060337f", + "y": "0x2640ef641d20fea19b28947833e53faceeafa57a8761b807049f3d707d70c01f1c69a57edd993d301a64517bf47f77" + }, + "scalarBits": 64, + "scalar": "0x52e236bba52938fe", + "Q": { + "x": "0x14ea59ca0f28a055083ef078abd8902c48aa65de8402618504d5bf686a3608e7b3229ffa392fd13cf7719176de4a51d", + "y": "0x70db44711f9b74849c695f2949acc5f7cd32538334f8e2aec6ac74acb3f0bf2a2020755b1f96a317ff2168717b6350" + } + }, + { + "id": 4, + "P": { + "x": "0xaf4cb1889796474529bbcac6dbc3921e20e228cfedf590628d538e5701cee5bcd8d86a8337d0cf1cda4232cab66801", + "y": "0x13ad5a60a4d8bb9213a8ef625f6750b0c25ba0bffe2c551645f8e8e04d1db7305f26b59e9b1fb86a1d45a56f3e2b3e8" + }, + "scalarBits": 64, + "scalar": "0xaddae695bdf55ffe", + "Q": { + "x": "0x12848cac316a1b19595eee57a8d9ee4cd63555993ab61d3eff69ab5d5cd493312083ab26269cc0c123146dfa3bec539", + "y": "0x12aa7ca517020dfc895bcec4873c35aa0205a9738debe7eb8bd884f64544f6528d02820249de49b7bc0613290d73a6a" + } + }, + { + "id": 5, + "P": { + "x": "0x77bc48525eac502255f97e4c0402f369337922f8507fb9a9ef5c5c706d38d91e518889df4cebacddeb39f69c40babd", + "y": "0x4df77fc824063a8be2bd7533048c1d447ea99d9cf69063e931059dd0de417628ca787dc3b0aef72b48d2649eb50361" + }, + "scalarBits": 64, + "scalar": "0x2e8149e21a7dc7d0", + "Q": { + "x": "0x128d196917dd5e6046c052aade0c0c2408484619e38a1f8cb510845b01fa7498202bdb94e639bcc4b41dd65397d123a", + "y": "0x613e8624ad95ff98b71d81d01e55e3ad8c61bb3450879cb68016f9fb088dd33da5e19c103022efb2de4844b31ffa1" + } + }, + { + "id": 6, + "P": { + "x": "0x10af8d7dc57ca555857eac2b0f50a5c9c9f1a6069910edf1b335eb94ca0aa753d1f237cc14ec2bfc52e2c8f05575635", + "y": "0x9a34368a596c75fa5cd97b004e57dddda52612e431c50249da3f4e236b01bb61632f24a161bb81143d98258be3e457" + }, + "scalarBits": 64, + "scalar": "0x72db2a4d1faaf0e0", + "Q": { + "x": "0xff414850fb431753a3c5ab9a54046b58188e97e9f33562f6eab0a091270d2641c678089554e2a98020873cec931f6f", + "y": "0x100aa7eb08214b16c9b9cfe08398684dafb4b91fc62d557eb422ec23b98af385510a5914bc5de044d9d5655f08b2270" + } + }, + { + "id": 7, + "P": { + "x": "0x189af53ae2deb756dc0d934d29fdc78a6fb9f1fc39bd0a724586e807d2ff88c3292c113aed37a51739b97d6974782a0", + "y": "0x1356e361aa1a5c525da22b1216aedecff2a9b2c0ae13ce033a18a9c927a750aa04fe0e4accfffa52b02ad712c12a863" + }, + "scalarBits": 64, + "scalar": "0xe2a1634b242d1762", + "Q": { + "x": "0x131c854c17a56df4044ad55384ba275ed868f2f17b1f47948343ca3d86843c4e7bc01fadade5d749e6827e0684f904f", + "y": "0x556ccff67cecd38e3dde4cdce7a4129cf9ef65fda93eb2e65e5bff218d2c1a1a3baec11e55f34447201ff1dea803d8" + } + }, + { + "id": 8, + "P": { + "x": "0x28601d6ea840eecb698b208b23ade8f18d63a082cb429226182feca093a6d3d8d88209cc16a2640aace52a2f8a0fb5", + "y": "0x8cfc2eaf9249b60fdaf49f143850297319d1a6a104f51647b8ef61e3eba5ef12d9f04180ed73585266a257fcaafbfa" + }, + "scalarBits": 64, + "scalar": "0x7d9670df5b9f69e", + "Q": { + "x": "0x8bff6583ff2745a3c7af146a6f0cd5ddbdcddc01eba2bfb08ab8b996f457959c903fbe29002faf689183ca5b56fb3a", + "y": "0x87401f031f2700da2d383c36ce9667ce8396b9ef4efce511f005594bf0fa642cfa78e42e6aafc6071a76a0570cbe34" + } + }, + { + "id": 9, + "P": { + "x": "0x18669b870b9ff2867418be5b13bd2f688c38bc4ba12ad51f4f5f980a7cc28bb63e404047174c3f5310dfb3f1e75928f", + "y": "0xa91f6ef5e560138ce1d5ce84ac3e98036d5c74e61018a3546511cbc81067d65f2cc3cbc70524862a08a538830c8fd5" + }, + "scalarBits": 64, + "scalar": "0x84a3e2fb246a4582", + "Q": { + "x": "0xded9e4863cc708fded87dbb0359d0938df52588a052c0533762e214bac391b2708d28bd239ec64abab63f34c41f439", + "y": "0xff9c8d7f8a24b5b6b8025a8ff74ffb9ff4c57e5342431ca139c33a78887bbad6c383b89f6f3eff36fffd7469c980cf" + } + }, + { + "id": 10, + "P": { + "x": "0x16627c2c1f801d46d1b6f1b893fd1e1128790dd25fafe2e2257b6823fe2026c9fdda4f84be911464abc5fab0eb9a736", + "y": "0x196f2bb1d399f619925de879455b18776e989da95a52746f1d1e59f8ff36108b0b62a0e987af0451724ef1e5cd12c7b" + }, + "scalarBits": 64, + "scalar": "0x4aabe0daa56da8fe", + "Q": { + "x": "0xd6d7f7831e83f3e6ea8cc995890d1f3ef1edde94afdca6faca75e70df643125d7ad1b393c612bd5cad5062769962c2", + "y": "0x87783f153625e668374efdda6fe93b8caf32b26c1f07a0be309af74a33eb759e252e924d951180515887e2acc7c3a3" + } + }, + { + "id": 11, + "P": { + "x": "0x847795fbd5c3287cf629316a1e9b9be53f360543f51240e2c360c58b3400201f7df9ce4b090c040d26616c1db25c59", + "y": "0x3926c301fc719b4ba0948d90d99d88f465ad5f652d7ab743ec9bdfa1b54215a0937b4021952777bef4db65265a9bd2" + }, + "scalarBits": 64, + "scalar": "0xb6d73b7aacd57a50", + "Q": { + "x": "0xc7d722c3c07288ebcc8782837977a8e7cd65f1240b19fb5d4682bc6789e5db2290038a1ec4b1e2dae0bd2ae3bca75", + "y": "0xa22cf42434ceb6bd28766b5be86cbfb1ccfe7a1cbaa24117747d83f9f0042b385f48a9d93844f132449bd12599598" + } + }, + { + "id": 12, + "P": { + "x": "0xb7d77f03f2a5ce04ecaadbf3ec291d50181e3246a233813373dc1a5cd1360b91e68d3ae10e7fcb9bb84cc8de026b7f", + "y": "0xa75b1c818d95955933c89c136cbb4f2c21db5ec05b1b44c7d078585864ae6c48bb066a9746870ddddaf6dfadeade76" + }, + "scalarBits": 64, + "scalar": "0x3e97325d7b47dcc7", + "Q": { + "x": "0x4032dde50be9263b2a545eabf751962c5973e961eaa24c4a32e68402766e1fb73d7806e0e7885285724b699ca76004", + "y": "0xf84700a93f8f15a5557878c110b2774643f861735a4714f91373948a00da049e3f48f718e40831d8ca9556f48288ee" + } + }, + { + "id": 13, + "P": { + "x": "0xa90e7d1940604ba1e6894260edca58fbc30c592a0b3c6699869147736fe3471b291fc805236a6893c830d7df80188a", + "y": "0xc9c56a9848a61e92a2fc35a4b964433f6a312dbf11caac59741395b5a5dd0b68e9fb4ac8f03991d1075f512112c8ed" + }, + "scalarBits": 64, + "scalar": "0x9c079c686864304d", + "Q": { + "x": "0x778e0848a51a18e4c1855474a3bf100bc3f6a2fd26ae0fd4e77db6ddbc4b33426c25718506e6a0d8be6350f5e7a2a7", + "y": "0x87adfdfd10ebaa8ca909904de98f2a7178866da7eda31e0e8f135971eab34fe65bb62a0aecbad5f35c82027012401d" + } + }, + { + "id": 14, + "P": { + "x": "0xf853b2d6f2c220c9ade11e7130d0c4fbf480c57787497fa0d55bbb77bb91cf608b8a109c0416e4f4f91de2d0c3c7da", + "y": "0x1681ed0fc5aeca6e0445e580abaed47ccfe326018d55743cb4b569d4085de192b19fd1670f67933048ad62b3c9666df" + }, + "scalarBits": 64, + "scalar": "0x963a166ecbfdb19c", + "Q": { + "x": "0x12a645b6ee5ddf6d60008cfea75e94892ecd2a75c232a6da3687fabb6de6dc5329324f5d35111fca6d50b2747e6fa34", + "y": "0xa1599e75cd9f6727f739d34dff667b8f8568eea208e6051f4ca7a11c5ef9f5e6f56a6c79dfbfb0286fb9f5a79fff7" + } + }, + { + "id": 15, + "P": { + "x": "0xadd6d181bea282932ecf7477d25856e2c862ad17ab160f61b084eb4269cc70b5c05177b271d2290fe236ce375c13fb", + "y": "0x172e93c9f1d4f7f51b925ae52147f8cba19ab8c9df82d26797b86ca10984cadac18dfca0a4a4cf79414f951bb25ef7f" + }, + "scalarBits": 64, + "scalar": "0x703935a5e0cd43bd", + "Q": { + "x": "0xdc99f28a544863c38370a5e8b7782d0487ceb1fcff98ca3e0d91e59bc857ab5324ced274d1e308a9f1b13b19d111f", + "y": "0x11f6d3f2f0f09e1dc40677a5d213c04e4579d56b6f46371d4fc8e9b39f7d48d515abaee5d46bbd34e0c5aada0728a8e" + } + }, + { + "id": 16, + "P": { + "x": "0x5c0f6f47ec6ef817cf5e5689ac126f3cf36e1c1d0da91b238af803357308bea061c59f83313305d00d207efbd66da4", + "y": "0x1505b4c5bd0e8a2e8119998fad3f9a952b01326413dc2c57e211734abbdc769d8a9731d06e0c11fb50379f3f1445757" + }, + "scalarBits": 64, + "scalar": "0x14b8081bc079e72f", + "Q": { + "x": "0xa3993b085a32f56f6da693852714ef5b8362be01c28afa9b5cce59109bfff1bfe2c7d81c341ca7458f9895d9b99360", + "y": "0x174712582bf40c458ced34fe3282df8913db5af69ba5991ddbeecac04d9f840b5eefa207199cfe76d4c903a0371d847" + } + }, + { + "id": 17, + "P": { + "x": "0x14ece987a8a40180597ab82a4cc622d3096f38bd4c5609f4796064fe0083a71ef72c5c83f9f551b13de1c2a25811b18", + "y": "0x17dc2b8d955f8747fd4cd574224c37ac1f36e57b3b24ea713e7b9ea9b5c192e02d0f6bb4ad01409c544a41961198cc5" + }, + "scalarBits": 64, + "scalar": "0x2b7e05c1d569d5e1", + "Q": { + "x": "0x2fdc561411d4156961ea352b97ebdde8fbc5bbdbad98e8d5d0edd63b5c9757b657c99856158efd84bc110db90880f4", + "y": "0x1408a6f8da2ae9cb81043ac70c8f9f63a5cbefe9e149b432000093650115ae329ecd98e2e6e93c88b793f9d9f773966" + } + }, + { + "id": 18, + "P": { + "x": "0x10ea6964b9c1eaad4ea93a2b50a9cedc6445f0b5c7e3e6433a1dd8e8594fb30507416d13a44339babdeb584ed623c5e", + "y": "0x13f66ac8f9cd08cc6209e1140e333ef16e3896fcba63474e1a73616e8d7f69c70a0570e377a31c7ed012ef4b70fea81" + }, + "scalarBits": 64, + "scalar": "0x98941d025d5e17a6", + "Q": { + "x": "0x2bd254911f40b8a74eb722e12232ad6f76e3caa374154ecdbb93ddbbc2682fed4f082603baa5715caacfe998fcda8e", + "y": "0x67bbcf5601d8f88cfa099a4e8feff87af96ff4953075ae7e28d7124f8b0055b504941b74314e32892d3afb2ddaca4f" + } + }, + { + "id": 19, + "P": { + "x": "0xf2c70a88dbe3985d9fbdef1e199c3df4e711dbd894b98f8a3d1861ef728ae14b9cebc9f7aacd2df608dd06bfb878dd", + "y": "0x8c36175fa0d820cfe3b317104fa5f13a6142a2b32da12fbf20d839f184719a23fda5136854441ce4cd27740aa24680" + }, + "scalarBits": 64, + "scalar": "0x2606d068f8caaf94", + "Q": { + "x": "0x1a64e3fee9cbfaac7e6b0a4664f0e3a50892fa18cc11e6362be117b0b1a9ed953f5516dad6592d0518a899899849ed", + "y": "0x128b8cf9598535a24c7ff5a8018103a1e92e15ad9d03a9e2395bd22c0823bde482ee0e7bf1df35349120ccd1adb3a99" + } + }, + { + "id": 20, + "P": { + "x": "0xd8737707fa19942e8b375264f93c74010ddbe44891bc6fed3121aadeadf2334bd8ecd73f05e85aa0d95f2a090372ce", + "y": "0x370372730f5d153f46f1ec4ad4fe9bf90625359ff1f2fb7d2a73b688530a8e6607df4ab74ae4acbaeed3a0f7ba2dfb" + }, + "scalarBits": 64, + "scalar": "0x7f59e2eaee449fd", + "Q": { + "x": "0x89b23dab62e76959516792001ebe7146401d3a0aed684606218edd5834edeb0cab8a7c9a22fb3dc7c25beea48e03da", + "y": "0xe91a590b727b77f4313236e5be7e138115523fe9c8770b35bd7c4adeb9760c1a8d24e5e91a9396265c5e7be7241eda" + } + }, + { + "id": 21, + "P": { + "x": "0xfada927da73a4cc83b7896f36f5356980a58f2bbecb7c34cd8f4e96cdfcce5ce4aba7e858e6117f3ff18471b578c30", + "y": "0x12e060757d80d74340683ef18b23aef144fc8b17b4b62b65f9a0bbbe518ab0193bd219223a4593b41c84341f2b6fd82" + }, + "scalarBits": 64, + "scalar": "0x6eb7fcafc810f0e7", + "Q": { + "x": "0x2e85abd1d0373c6e943a3325f0599b6a8a7e42c5ed41128fcd5512c9fb230730a5d82b0cc1c576d131d703727a2cbe", + "y": "0x14e7e99d5f7eb87fb308b91ef2eaa75c9cd14a0d899a170eeb046693828487531223b1d309153791e395eb1a62f45a9" + } + }, + { + "id": 22, + "P": { + "x": "0x1ab95e08008ab16a340ea3463f7ed9d9811c94dcefb675b19a4d7f43c8e46d8dc551abbc39e48675d32a0b83a75e963", + "y": "0xfd576d66a170feadff4d06f2c2b408e7c19e5cc40106ee567644bd23fddefaf84fda1c5af674b17fda93c02475f304" + }, + "scalarBits": 64, + "scalar": "0x816a7cc005fb1546", + "Q": { + "x": "0xf8e916b8452fcc86c14c960843ec2d0e0879bfaefd80155d8d7a0f4ef695076c8e9324b5906f78819086f9e10a83f2", + "y": "0x125b0ab3df8c0f000eb6d42df6046ef7860b9593117ae9fc7ce6ffa3f5309d29ce958354b52e9071a3d1b6ffe8ff5c5" + } + }, + { + "id": 23, + "P": { + "x": "0x16ee1e218518d4b130a2f60b63845a05b8abfd0585b3c39c471d915d6ff81d269bed019f3f97a42aa650e8be45288c4", + "y": "0xae0e0564f7639d32ba981e0fd5357a1227cf7f00a310b94255a4769689476739d376f09414cb55fc8aa1792d215c86" + }, + "scalarBits": 64, + "scalar": "0xf50fadc7b727060", + "Q": { + "x": "0xf4becc8795c3c9109accec79a4e8b3db1e9baa048fb899f4fafa5ce32ea582cacc807dea95bbe31bb9e00f5c3be844", + "y": "0x1683d5646018bbbdaad908bf6675d6dee203b4d88a630d679a35b6cd8c5e3011c5c84032396c83f357f8dec9173923d" + } + }, + { + "id": 24, + "P": { + "x": "0x10a63254fe9b79cfcba46497503df4597202293729df02430d48150d541f6f0637c8184f2ac17ecc393acd6a17f5c2", + "y": "0x4f075f85da79d912f281fcc6836a026f8ef0f81b82895e44df9373a66bcb75ca3c9e2033f394d34c1aeaadd3860753" + }, + "scalarBits": 64, + "scalar": "0xa455a1352c253e52", + "Q": { + "x": "0x45ec9aec50ce86493d974c85cc8129c909d4c7f33048f454fbb2caaa87910d400a3cb4d04b51e5edb7779826fabedb", + "y": "0x4f65188ffc4a87f65385e3eb1217401dfc38f628ff99509cb60524e46cfb533f42e62053dc667ca8d0d1dca8917ef3" + } + }, + { + "id": 25, + "P": { + "x": "0x167f73e4ec6421a0ae8a9060691d93daaa489aa427deb795eb25ede236f9507e7bfa504198eb7cd3824ee7247ffbe64", + "y": "0xf60aea024e147460f11fedbf3cecad1191af71de740b7f899b75d729bff89193fa2e230f99eff5e8541caa7ca03a30" + }, + "scalarBits": 64, + "scalar": "0xed10e8c959f0184", + "Q": { + "x": "0x188cea1973d42e58ce73652aecb5893ea5d3aeb8bb972e9a27011b4eb68bc635c45d53a53eb74f1b4c1100f51e5df55", + "y": "0x1d53b53e31ac14d4cb37f47de95307489dd9ce5c7bcdea1381739712756373cb65813fac2d95e8b684443d4d3dfb73" + } + }, + { + "id": 26, + "P": { + "x": "0x52b5ce5f51f207fe7671f485b68bf8412c3a81d4e5864cc240ec3437b4c33f542ae1757efe14bd383244c131ee41cc", + "y": "0xe1940118da22ed69b7e4730a65b8eeff52133bc042f9965ae9d70e6bab69f0ef417cb5127bbf65d9f6864c3adf524a" + }, + "scalarBits": 64, + "scalar": "0xe676313be7ff73a4", + "Q": { + "x": "0x18e016e2b2523aa3b13acdf2ba928ef80d5605204b4ffdadfb38e9d373630b1f5f0008e431f76668fb5f29129dfcd07", + "y": "0x9b518530b542787191fb6f24b7c1ac2389e2f8213e26eba55c3f09f1561e0e9409cd9576c1e9530cda28fd803a806" + } + }, + { + "id": 27, + "P": { + "x": "0xec65bff5e09ef125ec519e09bd007060fbfe82cbd4e61582134d3997aeeb5576511602ec013a3942fb4d11fd5c503d", + "y": "0x8cbcc3edf8ad4f872cbfd8b40619cbcd52743e34e33a98757260dff5bf97c2c3fc2303b67d003172333e2138412110" + }, + "scalarBits": 64, + "scalar": "0x4e8fb70dd2fcc952", + "Q": { + "x": "0x1dc7e8f3c3932e95da62529bd5a249cbaf85a1efb1334e781e82573f9c933eece4ac5d68b72e3ec5512b57224561e4", + "y": "0xf7bafd658d1e5e4c036f3cbce6f2c387ba9a0f987a3a8c7dbc371cbfe87e02df5b4f05f99f3230f49fc924700c2208" + } + }, + { + "id": 28, + "P": { + "x": "0x152e399555872bdc255d370b39a67235a4e0176244605c854f67458e5d6be9ddb4892bfa6621bd4fc612478ea656052", + "y": "0x10b16b4407eee33e1d4ac936dd7e182d87c15c46fbc5a8f3ffda92bad5ccdb4c01a41faf0412fb4bf5537eafee16f10" + }, + "scalarBits": 64, + "scalar": "0xfc9cc134478b4a19", + "Q": { + "x": "0x574db0116d0a0db96c617020e110dd1d2fcbf0ea79ba6f6f9c5a1971760850ea1b88717059e4ec289893e80a014be7", + "y": "0x195c57e4fec6634e2a9c1073284ac6f8c3118b8c1ba184470c8162254f3b7bf41ddf46c45c6ea05bf509b3df8e7b53b" + } + }, + { + "id": 29, + "P": { + "x": "0xe0e750bb5741b9638bf5023f84dccc1e41cd70ecbad5e5b6ea8705daf57c280257ef315d2e05653bc9d9e1a0ecbcbb", + "y": "0xd627fa1c5d5936e7853643292c57b4ea3e1a55a9580164abc071f63561f8e1c50a205b3b9bc41a4b92b3b3f11e2f55" + }, + "scalarBits": 64, + "scalar": "0xc9b541aa43c55bbd", + "Q": { + "x": "0x190802f97dca9fd3099af8e5c3ece93f8b33567850c9cae6e579818142b0ac677a4d54609af199942c97edc5ae6f5d5", + "y": "0x2ca0e66e8ed1e4fff7c492ed1deae17472816fa39fde4710d70f9cb78da7e78d81df6eea185cd9ac150d10ecb5558" + } + }, + { + "id": 30, + "P": { + "x": "0x18a94118e21ba9878ec8b21d924af094113a94262b80f239c6e0fa91ca159006d7f5bdacf01847c62ee99b97d4740c8", + "y": "0x1d28e18a0157d2fd105c3a14c6beeb355d29adfdcb5e0d21bf7f36cbdf0c449c2b343732b67ade60bff08d35ed6b1f" + }, + "scalarBits": 64, + "scalar": "0xcf086cd1246feee0", + "Q": { + "x": "0xe408b3114f149387ee20e51695cc3c5c4415527e1dd2790247a0ceb9ca30264046f0c94f4329814fa0ea92daf0aca5", + "y": "0x1a82b8b7bcd118863ffc666c2972dd03125241afbc99e35b6cc0a6f64269fd0462b828dbe852d21525e2aeb3a1eafc1" + } + }, + { + "id": 31, + "P": { + "x": "0x30b8bae257cd9754bfacae78ff6c56c4b5acb83d60a7e556bcda6d6c0fad2405f040b7b365f1b14cccd302285b89f9", + "y": "0xe855395f55b02c05180dfd684cb50978b3a4d0491e0102de3786907fb6ea33d6dd8efe0ead1e0ee58811cbcfdf7267" + }, + "scalarBits": 64, + "scalar": "0x59d0a657355acbf5", + "Q": { + "x": "0xaaa3d43d59d654da275b3607a61eaa6b3d7d5a7917e3d0c71e14d0230f7f3f76303c4e513ccd10c5ab191650834b8d", + "y": "0x16de4da20f298f097634bf2ca45683fe5acec00eed6f279c8c11ed552b2aa0073ce4d104f03686eb31de10c83cc77ae" + } + }, + { + "id": 32, + "P": { + "x": "0x248673965b720d4a603a1a247fa53233d17863b05f168bb735c0785060aeaba9a1fdc614a85b05c49ad478d7f56f11", + "y": "0x276ca10ae4afb8d83a3d3da3047049044a3b894c9e29961167520f3d10b9072d4e1d95997fc3f4783eede484873caf" + }, + "scalarBits": 64, + "scalar": "0x8f35ea0b8d7f4688", + "Q": { + "x": "0x13aa45c1bfd1082978736bfc27ffecd4cb2a8a64b9f1114e809b08ccc97a5390d4d3c040f5df814e1c2d90940c28d53", + "y": "0x29899f91065e11d0ebb428f12c86ed39ba54f75bcf0a96456d0cb18827ac46b82ec2e94be460f687558c67a7eed26c" + } + }, + { + "id": 33, + "P": { + "x": "0x257ab9af91fefd0d7795fca829becf6aa3383d336b7bfc066ba8f356225f60bc61e1a95fd799c02cea37501937ae1b", + "y": "0x290ff8b3726344eb6ec410fb5bb19aba35d332c349904ca2e7847485a57507dbc1a5179e4ab25e3bb961332936a9ab" + }, + "scalarBits": 64, + "scalar": "0x1cfc0434f536b7dd", + "Q": { + "x": "0xfe8f540a36ffb53ce0f143ad7463451437d6e5e1565f3fea92f2450f8313c8ff83cf15746fe0325d273dea6eba9466", + "y": "0xf33ebb9d630fbafcf29d0101e2f17e03762f1cf3f3596615b6135f65131b1b0325e9f2abcf172cff58624d9d99f674" + } + }, + { + "id": 34, + "P": { + "x": "0x111e93d3c1e7679bd01a2be2dc825c3cd3ccf552fa8fa2c195861af1817defc236e818e8156bb78b8d31f316c2c8479", + "y": "0x118494e70b86cbd1d678de1de5a9e41601fa88921c71158a7a882ae84e874237568db064b44ba67fc9738453bfcc640" + }, + "scalarBits": 64, + "scalar": "0x91fb3b85fd97917f", + "Q": { + "x": "0x5d97ea2e10a3ff711a769f5689bfae2d9437d44817a0e101c03d0e455243040d436a9726aa7fc21c7ee804f55dd575", + "y": "0x139df0bcd024d4c0645c7793ae2a97125a8e86f73194a9ae37d5973b63851b650d20a9224998d827e7e2565d54511b9" + } + }, + { + "id": 35, + "P": { + "x": "0x13768f572ad975575a4b84d08a68a027600bb64e7a9fa8ceaf846be53cf510253fc87ab95567a3edfc860064d816c62", + "y": "0x532c5c53b0babdb744c0d0e5a50a66238f42354d23c8f2f301d570f36a199e6a2146e2a4e538ddaa4304d17774ecdd" + }, + "scalarBits": 64, + "scalar": "0xc812c75bee17f729", + "Q": { + "x": "0x2b3a19ca91f744c620e482a001e4efe63c645ba1023ad0bbf56dc56757160858bcb587b7f9ac5fa1082cf8b4335d83", + "y": "0x11d157349b26bbf10dc1118b8ee14f9eeab29b3e43b62c2c7acfd368d187688af65b3bbbcac90854159958c86ae27b1" + } + }, + { + "id": 36, + "P": { + "x": "0x2b03e7c6c0113ab944e50b84196bec0a14d97a3d749114c6bb28e069e65ca4652ae6c08d0a5e2d89cf94228ef4716e", + "y": "0x1917d9ad860a15c4cbcc5e80898e9491c87f21eb6f615957e4e36ddf0286f489f4d24879860b4a0230fa33ed89dbce7" + }, + "scalarBits": 64, + "scalar": "0x66d6486953fc0df4", + "Q": { + "x": "0x105216a5c2ed332e9e456f23b15fc5db74bdabb3c5b2321d93c7237c6737f52a8025c96fe47caa759c266c6fa346d61", + "y": "0x25a1062546b64dbca2d16461708df4c92f2d480649f433739c1b20eaa5101552b07b817fff73b984cec6f278caad00" + } + }, + { + "id": 37, + "P": { + "x": "0x7d0530fc5ca57d443885185d03c3c548d7ad899514c67101999a8e1b085fcb90f225197795022edea911f0f2b9c6f8", + "y": "0xc04c3bc8435a8a44dc786767808916a0363e95e52d43b670322873694a4f69c6fa2ebdbb00d530e9fe657bc9252a41" + }, + "scalarBits": 64, + "scalar": "0x7d7140604b529cd4", + "Q": { + "x": "0xf0e23fb74d675e96db2e12197166f74508e88201b2aeeb2e7c353e8c7fec5ed1b233574869e9a9f1997c77ad28b42", + "y": "0x897a399aebdc49a33b18eb438a638122f06892b6ab8608e11a8619f2c61c244bf893a124e023d278088853d0b30663" + } + }, + { + "id": 38, + "P": { + "x": "0x1367aa5293f9b326049efe648700bff1960a063b490fc0052cc41c67c81bb65dcd372e54f1e09ed905efa4bc3a55bc", + "y": "0x1a578b042ce748e3264c8106e6edf43f0aa536ce34d0ce82ab2d3f1ca5ecf40a060832b443226eb9631238f3c7dd47" + }, + "scalarBits": 64, + "scalar": "0x90354c7df1b09099", + "Q": { + "x": "0x1ab43647cadab3b3bc269decd81c9a7beff70dc238bf9ed97273a678364e2ed50a1185de5a90bc274a9428b03ded199", + "y": "0x129045d4d6235c1915e3b29d446d57a8773f470dd106f12390777677b35ce500cb5e00e9c6425dc3dd7e5e07ddb1d3c" + } + }, + { + "id": 39, + "P": { + "x": "0x1772069e4baed0745c51b2874a0f6d9e503e7e8a576a912c06ab0c11f24f1cfd091ef1b68401db86a2a3dbcf85d052", + "y": "0x622af90df8daaf2a5bc069ea1d5726b7f86252ee476298aea64c25459a91be27e61fd2e818104aa05a557e9778d3af" + }, + "scalarBits": 64, + "scalar": "0xbcd1de1a99956590", + "Q": { + "x": "0xb76f1fb18a31afe2b2c73dffb012ce416746e2b3e3969f251b7ed291caede83da2a62abf79792b22b4cfc3c370ff29", + "y": "0x1987d02c1016de45a535df50bf2bacf61694bc2f25ebd1b231b740b0ff79670fe206fe14e0fd00c3e7b87f969c37f37" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_128bit.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_128bit.json new file mode 100644 index 0000000..40f5926 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_128bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BLS12_377", + "group": "G2", + "modulus": "0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001", + "order": "0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001", + "cofactor": "0x26ba558ae9562addd88d99a6f6a829fbb36b00e1dcc40c8c505634fae2e189d693e8c36676bd09a0f3622fba094800452217cc900000000000000000000001", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "D_Twist", + "non_residue_fp": -5, + "G2_field": "Fp2", + "non_residue_twist": [ + 0, + 1 + ], + "a": "0x0", + "b": "0x1", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0xab080b20561040388b5b0e22af3c27f68ad41d5bf57de5b89bc5fd688d41b7949daaaf78dc87ff070f3be842c54232", + "c1": "0x1a80a67d56d1e44ebeaff0b560cc05a21feb39f02bf32910125161a665364ddcd2417183b7970563991556cd7f2f046" + }, + "y": { + "c0": "0x16e3a6b142cd3ae7ecc4e8cf253c99354d65ff2b734bc87d6aa4e2a92eef56b20f70eb39fba31f3908526e5e3853a25", + "c1": "0x12eebda917ccac5823163ef8e49b8b67f72dfd1daa7f9a1a3f62918f7e82f29daa9b4efae38487b7faa01d949896369" + } + }, + "scalarBits": 128, + "scalar": "0xfeb1d23979e3f6321624f33531e78a45", + "Q": { + "x": { + "c0": "0x8d640b284bf52049f5cb3968db0833219feb83c8b926d1a9de9c8e9564ccb877171b50d94983aa91123ddc1e78f7e2", + "c1": "0x1a5e682767136a7260610b1e3a05f1eae529b7520424bf5d61410cbc67116b03c3ac6f9ad38c5a3b8fd98046e852dc8" + }, + "y": { + "c0": "0x3658b4278e5e59e9d5fdcbf5a10fd6f058dbb5f6b7c497d5bfc7bf3d245158629b0ffcd2a41bec7b8d95fc65bd656e", + "c1": "0xab2a2536dd3e5d7b11d1694bf77596caa9843bb9dd43871e23717e9ab9a44cdf06340844261641a81b5139b3e3190d" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0x2a7285cc4159989534e7c3599f94e3b617573c3748e63e2ca427226efae3f6eaeca40b320bb4f6c020f0cfdedc5b0c", + "c1": "0xfee465b0f252fb1feca108c9148bda2d44bdd2ddac843852de0f36706476e51b48e092d9fe2f8cc2134b1a120bc25d" + }, + "y": { + "c0": "0x9203fdeaf18cf0f65adb349eb16559445d36979cdf71d0748721d988a0ecc78eb78eeb148bb0f840b3613643a80ff2", + "c1": "0xc8f31fa8c1c5af7040f889381ed0c581db4dd58159cea6b9c08f9143ec51bdfe7c5c2bb6bab52a891d451943ab24ef" + } + }, + "scalarBits": 128, + "scalar": "0x9dafcb6b453e965061fcfa20bb12a27d", + "Q": { + "x": { + "c0": "0x11073ecffa7e85e2c7570f2cd0486d8855cb0de601e388d6506b9ab7be2f7e134291bc9a146a2ccda6040586f49939", + "c1": "0xe130dc403b771646052fd103e2b1394700bdf4801eec8264fa34753f232ce42d1534ecae74c4705494de26a0ff9758" + }, + "y": { + "c0": "0x20ac535d05feb82414b873dc7f3eaaa385937c3a08e2675d10b4545e15be682f22cefb9940ae8ec70d4ac49f9dc23b", + "c1": "0xd8220e42a798d9197f89457b90378d9e2505de9e70d6ea36e1dac468ac5e24f3f664c54f691cefbbed7ae177bfc19e" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x144dff01ae522f66f5f660c1d9ff85e3717dba80a4d6fd6f47abe7bfc61891ff48386dcc3cc78fd98b0713f154970df", + "c1": "0x9c73aabaedfd0b82712c4acd40fd8262068e76bedbd0ba49951172fc797f3b74e1c04d938550f792b0391cd3bbcdd9" + }, + "y": { + "c0": "0x2b85285ba713e04e3758d346451865c7f5891a51d22e391c6d18139b7f8db064e9f706d88cbee03fb46c67f8ff6d33", + "c1": "0x49b4e31b824954c7de495c465bac862eb617ca42089d1bc257428952d49561afd62eff867b0c732331814054473a7c" + } + }, + "scalarBits": 128, + "scalar": "0x7243455c578a963e81b389f04e95ceaf", + "Q": { + "x": { + "c0": "0x11442b9107fd0f15ea162b546fdce74b1bf15af9ca1a6dcd1aba013cc02b17be4457779f40bc923c989969cb7ed7b19", + "c1": "0x319d38a7faab3ee3c75bc028df897437b41b3e0b3257b7d10c3a487a23a16e3eb53e74efe759ccd9a329a89fe141e8" + }, + "y": { + "c0": "0x64718923745110ea3b479c80154ecae4439cbad7793f5a93d5bf409b251b7fa76bd8b823c8238789182c8307240d12", + "c1": "0x122781908bfe103c2ea9f42383fb06b8a1ca4eb2820689a2fa45e5f45b51f583ebad53b477a5950b70b076df815e420" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x12d1a06e5f8239e69ff51404b9e63aeb6afed83dea6b97271730adb4b2f63a7b16f00a53d02b9afda4ca3968e1beb8d", + "c1": "0x12cab4b6881e45dd25f0bcac74ff292bdf56de098965a58f6fd1ea77b48f32b605f29c4af3ec18561bed40cda99637" + }, + "y": { + "c0": "0x10014195b78e9ffb441f957b83b974e41a9af33231790fe6328f15986e7d494be59e5fc4d141c3a0989d0f3736bdd2e", + "c1": "0x6bc2c94a81eb9b3d4d0485e93e9abb6fbf1190eb830e3ebae83ad73564bca2d1dced8f730b400be2c91fad8802d91" + } + }, + "scalarBits": 128, + "scalar": "0xde849ed53f855238a4889a43682fc5de", + "Q": { + "x": { + "c0": "0x126a8fa0827cbd6ea553e50b460876b9057a6b6cda7288c37aeb5b335695691872acbc286fa43d47801672d7e8dea05", + "c1": "0x144eca92deb7c68fe202c610b586be9bb4ad0bad0690ca329ddbce9e9828c1ff5333bfcc83c205868a94c671086d91f" + }, + "y": { + "c0": "0x6f5918fff4fa47a735ddbb527f378dd41fe4ae05c3efaae1ae52ec63a10a7678940b9c75269a4718571c42dc82fa84", + "c1": "0x3834491ca4ad5aa1eda7fc7e8c0c297b2dd39cf6c1fdeb4fe5bd7c2bd95a1c8ede8f28c210b79e2054e2314ab523db" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x8ce7d16a1669124bd8f824aba010aced577842c98b24d2d2c3a54714d34a1959591df06fbb49e95f224df79ed6a4d2", + "c1": "0x197e66de3c17014370dd79dabb89f6bc9d701a3f1b8e47060b4855361cebb9895a296aadd7e6b81c64307c710f0a691" + }, + "y": { + "c0": "0x430d6c3e65428c8ee55a46eb9bd1e5db94acbb557be69694dbad2ff9dc8c413197f5858e543f1360cea32d9ed75cba", + "c1": "0x10f3d492f150aae690de9ee25c6b9a45f94f7508b661a36c30b139b374cef76e80528ac032497c1881be3914fbc0412" + } + }, + "scalarBits": 128, + "scalar": "0xa5f6ac9d1085a890088c51eac4edfebf", + "Q": { + "x": { + "c0": "0x1abdf343d8a4e6aabe0d97a3f26113236dfa2a296d7a84b3bc09759ef6e6300d60ccdd00e527fd47e1e1bd44ef65d6a", + "c1": "0x12efba5f8082fd178be28b018a66aab434ab5786f0bf010204dcdf10142dbb179d2a802f4f4a5eaf2df433bf1cbe6fc" + }, + "y": { + "c0": "0x6780947fbbe2879c3f14a8248ba4e1bbfd9593429e26d8570a48f10444de1124fdd76877c2cce97c40866b7bfb267e", + "c1": "0x10efe7d2d49c6eac70607fa9d4a3e60b1edadb7bb069b5876ce785d07ce056924c730695842cdc81301f431c9bf3d7f" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0xd1549e8cefeec81cb07abc8b5dd484012005f38953bfc67c1897b28bfe157c02e65aa08d140b34733618fcb72079be", + "c1": "0x2e0c0cf2ff5065ac567f5ee30eb312e519128d4f732f0f026216150666c1df7c521f1dc6027cad46ec949d9c019862" + }, + "y": { + "c0": "0x84f44ca6b8b4c2cf1fc1bd0e346bb2666db3ee0aeef25e1dbe9ae5f175e09efc45ad9a3c917d27a04b909ac571fae1", + "c1": "0x130af6082ef7adcca63fc2580c9fa36c7865ac333b06e3acad7b2191c124f894bea5d5b06f8485b76fcffa2a6ab495a" + } + }, + "scalarBits": 128, + "scalar": "0xbd462e08b0bc81c48f645759bb5d0512", + "Q": { + "x": { + "c0": "0x61bc600bd4dd2f98453b1402ed7105aab107c4887853047d2587796cacb7b5480c204176d57dc20d0fea102a3ef270", + "c1": "0x107e5493591863e493e7074ad86bc738d9878a15e2dff9d7c79b62d602602b7427dff9553e28776a873b94597615b54" + }, + "y": { + "c0": "0xb7eed3c3383406bf6314ff9e1df69c40e811ac49eec11b4228bee526b4b2065e32e48e142e0dc7ac391b11165975e0", + "c1": "0x2f262748fd1324c6c4ca7fe33f58c9d93ef360d8c2eb79a1675a49c8a76412b7610b736137d5acdb692dae730335ab" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0xcf2b43aa12aa304bee814bf9cdbe48b0d0b8b908760f645396afa395895a6ece359a582df1f48960ab040d94ed08d2", + "c1": "0xd3c91c4a24bffcde99e2258da4f8ce2017d8626123e7e122f0db5a865e0660321debe69fbbfb856b9e98e6f6f096b7" + }, + "y": { + "c0": "0x786b98f4cd4266c920552ed61b104216bddde5a66cdd2a78acf6a5f997741b02ab0e92d811475c208bd2d219c9a34b", + "c1": "0xee22776efa9c2a38669ba5939a324009a69ac16403b851acbe52d8699912d81b289e155e8100d21e110fbd68b5b374" + } + }, + "scalarBits": 128, + "scalar": "0xc5a702877f0161ed2339c026fb9841a7", + "Q": { + "x": { + "c0": "0x166c6a53577129c3fc0430b62dd6b138a7775e3a43667bb10c4da6ad0bafd3ea2f5fe8f2765d122b73d8eb06dd65c57", + "c1": "0xfb7d28b230345129da877093b454815b4c0c7730485a86c3f56e0e83cb77236a9b069030f0483594ce2d2141a0aa47" + }, + "y": { + "c0": "0x1364bca604a1c77967f55f9f74368224647795080dde036f3c9a956b890f70188a138a3b11356acde6e7deab355d890", + "c1": "0x16c67ebadaebf6984aeef339bd362ca5eaa146573c4cb93acf2ee28fdf9a7302a74374af9ad90123a6e48798cd89d9a" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x7a6689b91f601b1d89b1b76abf9f9c14f4d96eb76d88544891e24e764d64479be9f58337c67a01a07b86c7c5aa317", + "c1": "0x1fea36f076268c30bd01c425039ea4c35510d9f3ae778441e5040544c032b3a50f0898127791049a01b5c475e16f7d" + }, + "y": { + "c0": "0x13893c701cc64cc8ebe25b23bce3caacb2ae634e41bf58deac35548e5d9fdcef8f45bc90b9e3e9e279c9326d74b3190", + "c1": "0x10782178b2fea93b1ff9e9c8ce25816e5c1ca2142840c66b8a16ec3005d76dc569afa39cc7e2ee0a51f3703d05dc47c" + } + }, + "scalarBits": 128, + "scalar": "0x66f91dfc384c81ed51e8b03bc8fed68e", + "Q": { + "x": { + "c0": "0x10c0cf027035e1fe52fcbcd3329d6bbae3c3ff4a9e9ad0d3dfeeb426d01ebca856702e59790bdf75b6436c96d36f731", + "c1": "0x64aa4518ad0bb5bd0033c879c6ae7780ae299d3695479a308dd37698abe1c5f02c9d8b7c3d41b063ba47d759e285bb" + }, + "y": { + "c0": "0x1763f75379066200046ee6f07e522c6ca7b1a668519cd7eafa9b8826c9a20eee81ddc73fc85639a56cf015f10aa3f12", + "c1": "0xb79d110607395f55c0141639333eb57dfbff7e5fe33a2551e3229a745736f8097c655d51f6f16fc6f15327333b8e6f" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0x34f05b8df472e9acb4d2592fd67bef2f832fba14dbe975bccd27e8a74a11d16ad6c612b2576b7dac5391107fbeabb3", + "c1": "0x79404b9324e46d65dc3444e3db23e15c2644977aacca31c6939e32a5bca91c987067d9821fa0d371d28e5e19960e6b" + }, + "y": { + "c0": "0x9bcd600a88806f2eb52283970d4ef01e4f60bf9ec2f191ae85925adc58aa8a415b82f2b058119aa8355e2a36aea082", + "c1": "0x828700c801f31973f85483fa15ea1d377a3dd859a8323f14af695af74c7dfe642cef5e3831d93a5d6454fef12fed38" + } + }, + "scalarBits": 128, + "scalar": "0xa926046ab6790c3dbf0b397b36edc274", + "Q": { + "x": { + "c0": "0x1884b01704f42afb528d05bab118b27a7dfd645ec5c73d2ac8391bdf5ec16c1cda7523c77494ea0c0ba82bfe2851fb5", + "c1": "0xc556de4b270bcbe2e8a0947397fa539d805cdab694b934b5be44c059f69c4ce402161e7b5c89aa1750e7c1f2ce0c50" + }, + "y": { + "c0": "0x154849545edc04e5c5653ff40ab2b977486d1844799acfe9b4495437c78932748c67f982d9c9ac42a57f64c4e799ae3", + "c1": "0x4c9750d50db28f8c4f23c5d037382adf049c464f7ad7f4ba05997b796ecd45a916b5c27459c62ba664c1ff82d10839" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0x10e6ac5f51723e47d687ddb87c217eaaba0ba33d868b5e12619258ec56ebc34ab0af7fe8ad4f084a9ed39ddff29aa3e", + "c1": "0x13a67f4ae8d12f200af974c66f4e0dc379f7847896ed9d372a4e8f26f9c2517a16275fa824b9bfe22da4908956bc523" + }, + "y": { + "c0": "0x1711eb5b298359191b573214bbc2557e5a0676aaebfe2cb95bd14f61d60847c40c8685f543fd1852babc0935712d271", + "c1": "0x1a54466a96fe974b2dacdf776cefbe41860cf99d27dc39e20d516c1f8c55fab544e60ca19e827ae2a3a328972f3d561" + } + }, + "scalarBits": 128, + "scalar": "0xe28bbb5536d11a924f1f41241aa36f69", + "Q": { + "x": { + "c0": "0x15e16cf94413d18bf6c113170df262176c0ef82fb59c1a4793aba20ce6bf8dd90e668aa2a256471d8098fe0fc80727f", + "c1": "0x1a7eb9d23344bf1e3c78212d389b391d51030ed6642f61b1cdabe55efa09d65f05483eb0e78c33e74190390eaf29ff6" + }, + "y": { + "c0": "0x19cb3a2d2907a42bec1e00d77ad7c4f4e1ca7ed46d9d8bae04c068eab0315c0bb533c5c5a7a68f351cab3bd4ad0a459", + "c1": "0x9ad1e9a2b521e60c77003084d2d3522530860e21c92a1e7a39c937df26f2f8faea20826f8d354254c77fe5a2957cc3" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0xfb195415d3ae27fb1dfe3d7f497acbf6d358ead11df05b66fe31d154bd4a3c06fcfa9810d087b4a1ccca108aecf2d0", + "c1": "0x15946b24884ed125b785975e019b8806c904045e440d58914896902679a2a5a3b1e7d1106294ae3a0e072067dffea9c" + }, + "y": { + "c0": "0x9c718cb003eb96328abc63b80ae5adde7e2b0ba5b897c61fb0ba5c798544e41f5d0e37ec48be6325b9f36c4f94bb07", + "c1": "0x948f405c1fa9a30c90aaf73c7923268c1ece1acf5745eea9ced10ee6ad62520fed5a151361c21701d5428be440130d" + } + }, + "scalarBits": 128, + "scalar": "0x9dbc592a8284b9d368fce48f392b9588", + "Q": { + "x": { + "c0": "0x572bfd728fc4871317024db9d7a3e070bd0a9a955162ce02fb04811f239bc0ce3c6255859bc3ef51553c69caec1f5b", + "c1": "0x10e4c1e84eac76896a75652930e621a1c68275eb404be1e1ece33dec16f4ad92e5994f0a3ac66a54928a07c2a8457fa" + }, + "y": { + "c0": "0x13d84dd858d6dcb2dcb35e0243d04aa2385a75f85ce3f041967bacea747eb0b8392fff003fc1c7a11741ce043cd7ecb", + "c1": "0xcdaec1106ec9f49029064b5ffa00862bb7d6be40ad161d0ad25195c9cf22e7f15a879f085cebf7607261e700737435" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x10a71421240ac1ced1a41e6eb15d208a5e2fc4ac0d9ac65173f4181ddf286ed1218f44fa0c82d0214d3c22d455fa094", + "c1": "0x7d97fcb89845feddf3328414939570ed33bf6a6b67587f240db01a1b5fafd04503106be54f099207fc6fc59ad8c9be" + }, + "y": { + "c0": "0x189a4df6df515e5c6a1be69426ea5dc2122fbc6bebaec7854aeb0b2f242bdbfa18467ed75f0e7f9be02ce603c1f4006", + "c1": "0xa406a43a43e715200daa17fbb721d3408bddad88b6a3a35f00c8bbb36f4203b7eb0348f8e13b83fe2dcc29c27f345e" + } + }, + "scalarBits": 128, + "scalar": "0xe3c2794cb91662dc87b8c94932806b73", + "Q": { + "x": { + "c0": "0x11903b57e5e7919bd2b82283aabcc0b65c8ba6029c86b40d2e46bfb8232d7118ff2fef5c6068aed6dcb31bacf8a1921", + "c1": "0x1414eb4550bd22f8917dd454f885ad2b546c66b8e1a142613df5b9dca5cf8a3606e113bcb6640b1e9f7f9f1b0f03c5f" + }, + "y": { + "c0": "0xf551cd630d75e62057d9418fa15ea1a3e4967d17b2c85591b64326a3b1de49ce0572e93b521651cc81d045ddc8f831", + "c1": "0x109bd2444ac2f4cb0fe72da3b92be5de7f660b5fca1d88862dafed428f96a08a1180c278a04074def14992c6ce58b73" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0x127bd276def3a89c8276501cc18360090954aa0ade73d1c9ba33df92336c231eb309cc504d4802c48e5ddc5114da266", + "c1": "0x739b038eedb17a9cd00bef4193b03b7749f3160c0ce240ad630b7ffd55c97dbc888503d09f182de825ca46e3e51f1a" + }, + "y": { + "c0": "0xa532be14170277133c2659483b1d14ca5033dbf15a58c925347689e76513ee257912fe0ba4f79c0b36d3cdd05f998f", + "c1": "0x1395f412124c175f2007deb14f791b0aeda7ec1f94041b84f93c90554ce97abd29fec455f5d3e510eb85429267d429f" + } + }, + "scalarBits": 128, + "scalar": "0x88885a4259bbd4e852efdc63c8bda982", + "Q": { + "x": { + "c0": "0xc336d11ffd3d41c2a482d27b726cef44b71a684d926ae9dc3b08ea33db8320882f8c498f028cd83b9a00b0e9871d06", + "c1": "0x1a814e66b90a549ed8cfd075cc766b1ee2674f123392da767f2791a482bf2ce640df50a764a16a85cf106807874646c" + }, + "y": { + "c0": "0x10e5233c7727d0504e94d926465c09ee5bde28aae46dc9886b8e4e133d5d891a282a53d97067606dd9e560a282f618c", + "c1": "0x11e6aea3267ff8ac0ebe93aa43d2fd62389432202655a3249f19b8c3eb1e7693805a08a7d81c9c81df6e2dd122f4719" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0xdc5315f65a594a46a499cdb282b2921971fe85310df17917dbd347fd072f6fc4d6686de2c8cc64071f581388fb5eb5", + "c1": "0x10b0afd026c32e568ed92a59b4dbf72b4f57585531fbad6f4939c545d990e2481c397fd05803fb574a41713693f4d2a" + }, + "y": { + "c0": "0xf15443223470344bd46d0b878c0892054f4f939f08c47b4709a4f629ce6a6e7d20d75839f5c99bb943be241ad0fe75", + "c1": "0xa97c8a6b29779695ff9e05e04a020e9ac8a72bc4ebabcb1c033bf5dd49e1ae36b7f04bd5fd42287dea3b5812a6b321" + } + }, + "scalarBits": 128, + "scalar": "0xf185f6c6cf34ebf5cc5e2728a5d7c3cc", + "Q": { + "x": { + "c0": "0x5feb57a88f447a51619233d6bec2d1962845e71cc62b8f9c547c5c6fbdf1ddecef2ea0b899dadec4b69c2675caf79e", + "c1": "0x175673a4f0ab4efdfb68f569f6b94d9c0b48a8ba30b1cfbca64cafe43d041270500fb4f481ad5119df49bfcb4f84f52" + }, + "y": { + "c0": "0xfcdaa0b27732395bb63f1167f99cb1703fcfbd0899fc4626413d30023170cb38bcfbedc388d80cbb1a91064b935253", + "c1": "0x129b5d5d1406c9d427d692f1a4b06677332fbfd8363e263d7642ff0968da158f8c469105447be352c257272816ec9ce" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0x3114eed1dfcc94d708e9919a2fb605e9cb8f784a78412bac762c7662f403b4c590211f4871859e91f412542eed7f19", + "c1": "0x1f9b23008e2381ce27d72688398f345c66566898b789fa3c3ee334930d9de3b4abef032507e94f0f686a4a6dec742c" + }, + "y": { + "c0": "0xe056aee9615c4602d6057fdb6f1b2ac5e6b2e0589b20ddd6f92227acbf5de235a1a6d0d3702205c30bda7f5b1b900c", + "c1": "0xda7dcee2a122b003c4d2e2fb0517b421efe3b2243e0f90b7a75c1ced2f26a22b465d9ae6b0487367d01d31133329ac" + } + }, + "scalarBits": 128, + "scalar": "0xf0dbccf1e68f814a06563249c5869254", + "Q": { + "x": { + "c0": "0x12b9d1fd6cfc740c7b496ef80f38006a3a565303f8c1d9a5574c7845f60f86a13914f99f43575dfdba21e7becd09f4b", + "c1": "0x6c89a6d54bfddb7978336f62850674012938159ae6cbbaf6759c4a90e6345a99301575e0ea7fb8b383b9096b5c63df" + }, + "y": { + "c0": "0x72a1392bbba39e51144435a73933381f2eb6e9def0e843e222ffe7cc5e1bfa880f3646c5496d5bd9b34b39a0d001eb", + "c1": "0x9c7b43fa1ce8d84e89aa38e2e91ada8fdfde21245df18f9df02dc4bda0a1d358219b91b16e3daa9ce8dc7c0c691614" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x115be6b28e3f68d7f9984b3bcd9bab8cd3d161ad8045666e0ce33f83a5f11659870dfda7c27661d584c52fd1c73cb82", + "c1": "0x1207143f7cdd54e04da3759b8b35f775db66f5942ea32f3fcf600ae829e6cdc5a53b5fe4369452ae4272ac0ca9a578b" + }, + "y": { + "c0": "0x85460414e7d70a8f196717d0cc8f6aba796fd7543dfe6ebd4ca7244ffb223d26777be6d052eca2af0ac8fc2a2c5aac", + "c1": "0x1ac09d01edc222c21ccc28fda8acf83d25cce919253babde8e4bc7ad2d1ff4e016bce408899226eaf16212ad1c15ba7" + } + }, + "scalarBits": 128, + "scalar": "0x39976aa1455c604f147f3bb42718b8e4", + "Q": { + "x": { + "c0": "0x104dca6a4ef014338065d13fc10874eacfb5b0f6558495b04c0a331f1182715d02ddf767f5a3f7e8e40af09f9204b9f", + "c1": "0x11cf5b000c7324002f0e75f816aa663a56d4eae5fbc0815a56840cf0448e58a2b87b9d8437a03fdf5878dad9c90d3cc" + }, + "y": { + "c0": "0x9fa7f281f63233fdd65809d5a8161dd8ef389bd08759f547a54020654d77775ae90875f71de1f149a4f1c71573e0ba", + "c1": "0xc23cfce9a1aac3c4903ed0f01eea3644abba76ffe32995cd32f80c0accb4efc7426f9e9974ee69049b8c9a8b6fc4a8" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0x1236a36624e1e05886034d8863a89057724ba896c0723fb9711f51686882829bba7d981bfcea3b7f0cd88b175dd7ad3", + "c1": "0x19745a21c164fe86c4f254bde239325718d6c82e47dc187fa95dcd0c6e4be3b38fec1e9c88ea3e9675d0af5843e3064" + }, + "y": { + "c0": "0x98c523ca8c83b398894670945b9359b5661ebf2f160c115262338fa8c0d31a0c9ef897c9c7979005652fb411e28485", + "c1": "0x14a31228039af3e9b9475a9c8ed8921bbeb0aeec17edb3758c9e58f1232d302421c84b9aaf2cd985c0eab16eb6c86e2" + } + }, + "scalarBits": 128, + "scalar": "0x4119765821e395273500e7bcf90fea66", + "Q": { + "x": { + "c0": "0x162dfd52082d730e5927d6baa378de9553caa28fbb186166d2d416241b791c164cf0a0ec72f239630cfd72919bd1b26", + "c1": "0xa4d34fef3cf31e7059065f264a0e7ab6f42c870ed0b52470d664a41c274ba3c4b39f3a0f67f4f2e52e3a9bcd37b7b5" + }, + "y": { + "c0": "0x82673a03dd81b3f8662797ca9165af576e444214a5695979b14f6368735220d013e67835e7bb019c002426d201dc8f", + "c1": "0x1416f15aa7fb9f4f2d14bc9ee9f36f165d846596f6e34c2d619c06240f0d71e42adb52bf5b1ced8ebe1fcc419af91d4" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0xede37c639a43b18d7a78011fc0fcf6b151692c0f6dc9e023a83ef1196046ec6e1e2274b6b37dc236e3285341a97d87", + "c1": "0x1242fb3a1de8984d903f6e78d9082a48170d25112a5645b28aac09ceb1efaf99477b8b5ccf6b0bf99ba20e5487b08c5" + }, + "y": { + "c0": "0xab814942f5312a6c87de930a02dfe48dc2cf0abc9f42128645969b580d0a53ccec7d6f4fc27ee468de7b429ca16711", + "c1": "0xc15ba1b2777489f97c464240d02a43214ce5279dc756e36e3162f72de43995d5368e4b1f5557164c1e1a9168c403bd" + } + }, + "scalarBits": 128, + "scalar": "0x766600c855bee99c1081a14b529da4cd", + "Q": { + "x": { + "c0": "0x14dc101b814a2758a49ba4ddb78ba64efb8ceba5abf80bc2db9afaf63f9a87cdffb38aba8c260ffbbf4e3997fa07ec4", + "c1": "0x16c31f9d7d6c3132827d8afa6e280b693651eabd4c7d0373205c6c092cd0e7440f7578ca02c0d623b94945615a05e1b" + }, + "y": { + "c0": "0xfceba019b87e88a8a5bc5b0927d3df27ea9ce5be92e64fcb9345e2add3c2d1d0a2bcc176e8790b33e7969fa8bbebd9", + "c1": "0x48a1fd88f0ce06d326ca371e8a0c98af02d21cff9298840a15b87c5b226e13b7491ee7ff500cfc0b611bdfb63176b8" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x1fc168d7795f1f9f5b92aa9e8f6c41a70a5a96b7848d5cb0d23146c29f32758a3ce1bc5692c5b4212a48d807f0c1a9", + "c1": "0x69ebc371b7df15df94eda74d33d366412b069a613b631e606c1e05cbed418a9fa8e71a80b62fd046e4e71ae62f0e7f" + }, + "y": { + "c0": "0xc7cf636c953142d9dc857577263931e947dcbb0df39a333a6fec10c5267633048165709b8a4229d2d313043ad4df17", + "c1": "0x127f63a8a1c5a9ca04656f70b67113f2e7eb0479112470fbeea93a82a724833eedd205c14d2facd1ac8f2f67f611356" + } + }, + "scalarBits": 128, + "scalar": "0x7d9ae7067c7abed7cd1bca14a7a7a018", + "Q": { + "x": { + "c0": "0x978fb7ee29115825627b923cba8a9499262520b9ba8bf664751162d312b2f9015a63db9274f2235f3ce50dcb373188", + "c1": "0x14ed3bf319339f2ba3c54422a1aab3466061b7f279a47ec5f685b2cc57abf57446f4a850862edfa798072b3e61c76" + }, + "y": { + "c0": "0x18b9e4a37019f2ced559f759c1f4af6e5932458419aa5aae2e361431a38ee133658d91d1a5ac5a7c456dbaf8f3d88a3", + "c1": "0x139947aaafee232d10bfca74446debd66b157d8f54e2b41ee47e3522bdb0fb808e264ea1676f6b89afd7f30f6c3d936" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0x16f89f0c8bfeb83052c4d970a710c3250be74672924d154a9463ab44921fe8dd5bc5b7c4ff7cee0dc7e49cf0b9d2262", + "c1": "0x2e312a7f701b8b5021e4aca3d45de8112fe8ff9f432324ad73fd5f86230fb29a64656118b8382ecc7c77e74dee6b0b" + }, + "y": { + "c0": "0x11d7e7378104e855370b8539a473381ad8114b36b5ee57a90cd3378f17dbc168e8cbc2c75fb2c4922361b691b21789f", + "c1": "0x10656b07ed4f443c33bc8c6dc8211256e06b02c9c5695ab9d626ed4783c643e9a4330721ad63c130ee941686e1e6ddd" + } + }, + "scalarBits": 128, + "scalar": "0x9ad47a7be7c1f6d98ad27e801692da2c", + "Q": { + "x": { + "c0": "0x141ff3d7bc39cb8d34970f58dd6a191ce900c72f131c4e7208e3fda9bb0b7b61b512ef8b32fc97ea20444f26a414fee", + "c1": "0xff016f90803cfe6e0fddf5cf69db67a1795b4e987fc30e67db6d527c70357e24414f8e9ba978e2078159fb4d8f9cef" + }, + "y": { + "c0": "0x1197227488e64e7bbdb17f6e98f3381fe41e48f86a7235d2ab6cb24693ddfe756835cb23506554981f472cc6b458a4d", + "c1": "0x8b37a127ec29d271645a6fbf3e5798286f4cbeb688198feb4a184a255669f4c239c09c89d5475b583b2a2ede31a041" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0xb9bdb72b62d7d467a74113a5de717d9284e5caa5d6329b071602525d5a87117b0b94c6035d227ff34be4f43beb39cb", + "c1": "0x105995c507a8ac09f28b1835d1f830917447ced06b107f4c03f30f26ba6b003af9ac695ca2b69f36c11201dad595e8f" + }, + "y": { + "c0": "0xea3bb6d4c55f0e4760ef55096bc52fe03e4a9b5686453b4a0de3515c55e6967ddd4636537551f472f2a4e63e68aef", + "c1": "0x92f4f155a3169e5b3da2648d4b925596c430c5072fba1a32e7edd39a780be24298bcf0ad841be75e92b5e198a52f0f" + } + }, + "scalarBits": 128, + "scalar": "0x7b5784be267a56f33e69c8f62408f318", + "Q": { + "x": { + "c0": "0x13e47a94fff6e9f522e85e0178401a84545b7cf0caed1574d32bc92401c3a3d76c34d62054bc0af1904644f433408a1", + "c1": "0x1cf1cfda629604d4165549912e242831898b7a74f76a40021d0a4b02ee7b2122cd13deaebb54a5f11becbd2776f588" + }, + "y": { + "c0": "0x1993ee7fcee7b24b35c7824b58d28115487f7624d0bfd26da492c545cf6604d387b01228820a7a2526b7f5f8ce6da78", + "c1": "0x14fbff0f4e1ff6ed22d727123d62a9c6c05b7ad4aca9935fd625756596183d266952760df1b4d8584d324a9908e84c3" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0xd14bfdd612274a26670716b1d1278dc33c8f67ee76a1164bfe5dc448416ee6c6c38c0c9747391186bf025d974f937c", + "c1": "0x18dce2f7860ec7bdaf8f9b0f78cfd3c36414acd53f44e106255fc38d47798326736688cda8e50031f8c3e69b2dc5a84" + }, + "y": { + "c0": "0x19707676e27470417afcbb3744518752d61a921dc2451c666e8a31605ca8894daa705e8de7010923fdc430863856bec", + "c1": "0xc9c7c9183f8217888df751e5b973ff783c1d9a66b95bb6778c2000b90bc29f3a65769a702151b1f3fa50e044d35f64" + } + }, + "scalarBits": 128, + "scalar": "0xeb707734a69e126646ef9d605f96488f", + "Q": { + "x": { + "c0": "0x166ded2a810b86f85f4d2fdf74ec6da87330288f76cd76498633e6d6ad26fa0782234819ce3389ad85006ff4683c619", + "c1": "0x6d15f550659979c02b6940fa68da4ca2a9f66bb2a17756594570a51b013cc399d33b4442b9bad15cff982c88b41d0f" + }, + "y": { + "c0": "0x1a106a8581ea7c64070df53ff2f6a9f282b598a56aaa791f74093a7653e405c82f2ee29aae0ee0b7340c037284975b4", + "c1": "0x474f96db98ccba7b59386e4269306d21db840b3db6dcf58f90453010314ff3b6a56f438cdb4066a7e67bbd99dd2863" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x19dafd41821e266f66eadb95082a2675fa19eca7469d078f25fe7bb643141df5c6b689d4d4d03d7fee9e8ac030a9da7", + "c1": "0x1d9671b58ee23c27920a968a6587d51bd852de9c55eb82863f2ad70f8959e623cc08177b56c130ad04fced545e1efc" + }, + "y": { + "c0": "0x7edec8656eaa4330098b36e57dcf2ca09aef5f170890294a9b497aeb8d2ac67c95d53bbd804a80b0da33cd00c6531", + "c1": "0xe4022e8a0a22d0e2c2368972a100f2956072272935547853dbb6cd930e70d48297036e32ed059629430ab9e37a6e11" + } + }, + "scalarBits": 128, + "scalar": "0xe1bd8c591560d3fe8466fb548fdb4f9e", + "Q": { + "x": { + "c0": "0xb2dc666a39d9c013156f348e28e35dc0b2da0c0ad59c7f4e1bb032f72ce875e8d75cbaeccd2277cd0d9c0198699e3e", + "c1": "0x349f7d94ec65e70a52dd11aaf7a148d91fdb80439137ec917a60b01e18044195cc6ed04a5938d6df86cd67ef38eba0" + }, + "y": { + "c0": "0x18d2bd7e5b65765c8e089812d73cf5fa2df01938ee153f4104cdb35c4acd4ddaa2864f3cdd597c9f0b56742539b2dd5", + "c1": "0x4543954548f0959639724ed93063c9fc412a863c9c4d847b7eb13bdc10a52bdfe5fa595f5f67382bfeb8c5694c494f" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0x4931c9055262b2fc0b60c061f987dba50931d1d8dfab1d16a17e6315ba5f194f4adf647db9d56c6e7230cfea080b23", + "c1": "0x173f6947dd018e09f0cc045d1c911d252e8d4efef64db428f06ae640b1addc233624dedad7b034cb65dc133a21b02b0" + }, + "y": { + "c0": "0xd376cd7f4d7d2686356092cf12584e39a963cdde4ac575431abffaefc1717716f11e11226d6a02690804e8644a3ce2", + "c1": "0xc9c8749f77ab3262aa51d226d7ee2dcab4852276cd5b72fd7331f3adc2c97a99fa510be5f7ee76051e9a83f73b397" + } + }, + "scalarBits": 128, + "scalar": "0x5e2297b5d155ee2e2838653ab8724efc", + "Q": { + "x": { + "c0": "0x923299a26ffe15b16b62d0c158c4ff83fdbe099b0d0e36a04213cf991cd002c4dac935b8fb3f3fb60e4cf532fec969", + "c1": "0x150f0b2edc3a285abe841da44e37a8005e6580ded3de7be88f744a00c0d03b334464fef3ec92a015b5552ee04cff681" + }, + "y": { + "c0": "0x474ed9f127a015e6b4005b21d6b0843d365bdd8e02da335238b7b323402b9da64977ce838bb42bf2d53fc0fc549abf", + "c1": "0x142b84133b2310c514116d62b95c7861f0e40c53c63c87ba7867f56cf1c03848295ed2c8bb5c6c0114414e6f74182b9" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0x12e3d8ad9fd09426f9b87ac19218204c742ce80667a47ffa313e31a215040d01b5f10e8468d79cae00221483a94499e", + "c1": "0x766a9b9dbfb59db827b9866eec907b725589687d4f8deaf8bd5ad1ce4eadc2de14cbcd6e107fd37d11ff5442ddc5f7" + }, + "y": { + "c0": "0x10d1c4601e05e64fbd7d4e1480120b62b9bd56801b62db72f9bca488e2bada14b8efab6abf9ae16d9e46d7c6203dfe5", + "c1": "0xd4b5e4a7b8117f6d314e6a1e333f4e31cee9b44f916b34ec00ed95edfb8767b9221a2076eba765ed26057069e7dec2" + } + }, + "scalarBits": 128, + "scalar": "0x4c7acebbb3a463084258ca815f09b097", + "Q": { + "x": { + "c0": "0xce66dd14f92d8ac7571373b18966be017e5e8e7829793c18716b948517f0b3c1087829c680a109a3e7eccd00b123a1", + "c1": "0x2df5f50860c86757062131762af1062c5a87aefcafd4d3c8dc055d057a92dfe3918515250353a172ae444d5d26036d" + }, + "y": { + "c0": "0xfe397e46d9d33df79873d2dbcf5e9493abfd1ddf0b1c3a0a87a20cded0c4ab900d27bf3248ad53c44496d4e5356258", + "c1": "0x16fbcfdc3405477077984787ac587e7fbebac83bcc8c83f9aefaa1970214cd3e1c1b98016ab6388ff5ca990fd0caeaf" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0x30dd96bb2fcfa738b9ccbcb36f43ffe66ad981ca9fad3ab4b19f187dcbd83a527898ac483682f633ca79a08a06b6f1", + "c1": "0xad73fed39b093a9b77dc19591c971cac077b935f5c1e3752f7a7d7c2ff402f4344221a383186bbbfc643c42408b1ff" + }, + "y": { + "c0": "0x1977485f79df58cbf658387607bbc10f228565f9f88751def8205a3ef89615885730ed571aec1d2cbbd9463b5cf7454", + "c1": "0x1ad725d8c9ab2f9cadc4b73bfda9d820bb028edd23d987aaca2db767696c79c1c8d85960bf4d1fcf16f3f860f75f825" + } + }, + "scalarBits": 128, + "scalar": "0xd28664d0cc6e65abbd142c44140d95bb", + "Q": { + "x": { + "c0": "0x1787496ee8b866de0238feb52c742dcbd1955c50bcc8d6a6cbc6b34c20c426b2390b542f09d1c4e56e55c0cfd62e103", + "c1": "0x9524c1d0dab09c88045214c361952c471677eaa29ff2253295fb91e074b88d46a5dd02a516d3e07b5524916df2791b" + }, + "y": { + "c0": "0x183c39ab8d27c763babebe405a64470f88d344c031a1f72dd00895325dc1623034b5968592fcc5fe34e6a3ac1968a29", + "c1": "0x1686043d3fa241af2b9666194b66eba4998c394e2a1ff41aa71d7e82008ba6cc69e53dcb41618d45103ce6cac5f74b7" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0xfe75ad0e9c23c5ed4da9aa2ad9020b8cf22be9c24c40399754d27c11940d5906c856ba57be586776d75f16c215efc5", + "c1": "0x9228d1bd7ad795459444fb7ddce3b096da46ec8c8b0b3c275ef2648cd30f8a1f46e9ab00a1afb4178df67db03d5add" + }, + "y": { + "c0": "0x3d4271749a60e01677c453b284a1a69530f8669a93799572281e2c6504445d3ce18f40e65c62379818a1057490af98", + "c1": "0xa28de18a8dce25e5c9e55eec06f9986ec7d944dedac2153f16e04dab90d916860630c9801b88560dd7b04e21c6149d" + } + }, + "scalarBits": 128, + "scalar": "0xe5a501e620956c52745845fce8fbf7de", + "Q": { + "x": { + "c0": "0xa5d068c408810d0e178dd26a5aa01db35518b247b3c18ceea3fa2fc17e67bcf4f23a94656c8790d935e8896d253f78", + "c1": "0xb5f428165484ff612b0c7fa3540d6a0f93b7aeb9f2143b4d5fcde0838ad41389e42eb698d1cfa436f289b24186018f" + }, + "y": { + "c0": "0x1a646b85955078604091377082544ab9d6c17f5ff58d9a05975c35825cdbe1ce3db2eceb7a6ed7f613284e4e135c0f6", + "c1": "0x15143003985b0d9538f4eeb70d8efaa84198de5f227bf9500a83a4c164f0770d527be9fdf218c5512e57526b4f1b74c" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0x190b5e871e58997cc33637761918cc7317808197ce0a71df3e37e1d1258e522240fa15edd1bf8c9f540dce3c44365dc", + "c1": "0x74930dd2e7bb695d762ab4c47c1301d063536de5efbaa220f164d1ba4f62783ff28163c048a4f380b29ef33331ef33" + }, + "y": { + "c0": "0x7b94e52bf508f1aa88182c0c545fdc887a1f4c0840f2e401808e20f2dcf47b90a62feedf1906549ec68a45df3f58", + "c1": "0x3e42ed000c50608a33f652109df1aa2915bcb07d7ffdebb5cd5d8516def636e4a2045d87417f5de9e4cefbf2e8f996" + } + }, + "scalarBits": 128, + "scalar": "0xd3682f60446cc80cfbc5bc4fe8a1eb96", + "Q": { + "x": { + "c0": "0x60f42f64942cf93af216c7977ca4cc833c2aedec834d60dfb7399fc4fb2899f56cfd4be1a1bb21f5eccd9bedca7ebf", + "c1": "0x102b32879d8691d207ef6e207a7728677766a85c8059c820867db6509f2d38b65d50edb1cb8924cfc89ea73be751900" + }, + "y": { + "c0": "0x1aa23a8cafbf6f178221979f78056bd363505e01af7bfda0a3db398fd24cf15b5dbf5e740e748deeb02a03c0a647a01", + "c1": "0xbef148bc434c3968d95b34daed0d95792db0c51bc6e5e2160e21189725efe37e85944b1bba079386598b0fad48fe14" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x6cf0143db0c581f052cd80e1524d0bc8dba990b644d5ae50d9b82e951b241f36237ad17404f5aeaea1abf170ca299a", + "c1": "0x17495d32025f25d26750aa297e244cf4edb98cf26fc6130cc6fa2dac86d251f727dc0b3855efd49cc17feb71bcb49fe" + }, + "y": { + "c0": "0xbf838b9d9e0e08bd130de1a84eb8b219d2ac3ee8c94707aa127976944744503826a526c5b72c44cc705e9cb705a6d8", + "c1": "0xa18d854554628c12c3add729991b821a4eb3ae2e290d89c91409ffaf461f0e9d153b6809872147caedf9c6d9116f91" + } + }, + "scalarBits": 128, + "scalar": "0xe406607824011499de19bf06e395a037", + "Q": { + "x": { + "c0": "0xcbfeeb6e6a4dc1f874ca8d8c35bbc58d4de03d72fae9543a245652ed23c40cbbd513d568dc79034dad61d846373f7d", + "c1": "0x1218a0e8ed08017d429593f4fb14c127304bf9bf47dace196911db9177204b73859e5ae5f17b057cd48e8fd16f41f70" + }, + "y": { + "c0": "0x1411426f2089631049e4897091ecec7c993fa406c1b2982622268802b162698deed29369ee39041b309eeb257872cc", + "c1": "0x93bd34a386106d3c8354642934a5a047f827d1cad50234e7fe2984812fc33e1811b83a4a385cda9d9657f16b2faf19" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x1ab88e19b58c3783d4996cffdc31e977e564eadafd043c1da6e8b0c5014abea2c7eb86dd7f0c9dfcdc092a65aef9a07", + "c1": "0x1191ec30f990c1d829aad0828f68ad852b6551f755d5a72a14bde4ffcd2d79c2e3cd3cad3560f685f908d414d4b63a1" + }, + "y": { + "c0": "0x1a40b4cd5d044640c4d3e97d578b614c5c82f549084f73cd61dcc9a996a1764020601ab0bb6b1b6a8559b4ccce0667b", + "c1": "0x6f5a703d6bbf91cdae93d510c1983e332928f3dc92a0af19f4723bf86bed7dc73f45d6b13124d48ec49e59e6197873" + } + }, + "scalarBits": 128, + "scalar": "0x851fa686ea3c1559cb1a61f7f81de172", + "Q": { + "x": { + "c0": "0x1184990df2689d7cb70fc1726ce3aa1953f34e4313dc4a8fc3c4d3ce30722077fe45963b80e24d18795f37f46c1073", + "c1": "0x12cc3385a758c72d2fb5a28378162ec3a93eb5755ebb9fd0140e1562ce83b460ce182d5ecd09745434bd4c171249efe" + }, + "y": { + "c0": "0x3d5a25fdec385aac25c802388823ed2ff5b1f82862e6e631d4ca5b335f64b606589abeba784bda1b482479a13244a8", + "c1": "0x1e425f074f3c669b422c6bf1b797af37587a6f772373fcafdfa79d405ff767d1480937301b2a29bc073da782c95663" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0x436f294198eca026d1bc6423592de91c7244e12586f0ddc1ba4027aae391abe42c9bc721274d12cdb4538373dac1e5", + "c1": "0xfc17f92148e3b16018a1c7938c85e1a7ead887a57e7fe8bc3ff62f386dcac881c221b845169dbb1701659489cf1e35" + }, + "y": { + "c0": "0xa0f723e448ff33e73b53c06dc610941d2bf4d772ecb9a885b3a111c2507e40d3277e5541b086ce496e157800c5df26", + "c1": "0x66b3022e0e2b7b8aab69cd4542c2dc14bf445e266ea782f058b297b4cf00817e41d13fd01d0125baa58393ea6373e5" + } + }, + "scalarBits": 128, + "scalar": "0xb9b993a0cdbf3062dcaefbcf4aa4cb50", + "Q": { + "x": { + "c0": "0x871b6c1928a9e088c3dd810f855fd40d49bb0a0375bd9ddb74d584fc081dd8ae02a8814997321a098cffaa6d7690e5", + "c1": "0x247cc13bd2b9a5903ce97c0f5da7d41a103758cd6a3f2955bb6fa86f280102649c32ab957116cb09a30c0efbfe75e0" + }, + "y": { + "c0": "0x65d1b607f3a778dfd063f660560d5031b42617e70fe6296d17fba169b0b3e00f7cff259a4f6606df5e483462d15c3b", + "c1": "0x112df792ad30a81a99fc8c6692a15df58715509ef9f7275415420f5078b188c38b203cc57718d9a9d8be3dc49a5213a" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0x2f8e96e5199c7f7194e0e52070be67878f3bdfc728ca8f942a4717ca8180d40570b821893367ef23fedf5e9d652ffd", + "c1": "0x8c97439d026f11d677d818c7e071569b745a907cca1695ffd1e2d58110d9ab287ef7adb805b3196d53a2bff500538f" + }, + "y": { + "c0": "0x1f0d0b1e65ac4b969159cd78ffa55075c076e164532ecbb7bc025ec573e3b6996a172982bb70f93e6a083c1286dcbb", + "c1": "0x178c5de7b5f582c5b80841e231d620292c6fdcb818d1df98e6f837f3be781a639a6c0c30bbe1b7aa576977f294c21" + } + }, + "scalarBits": 128, + "scalar": "0x700ba8824914011302b2f3c5183ab1e6", + "Q": { + "x": { + "c0": "0x1597ecfecaf5927f9110804b2f0f0120704a3201bc085179a30e19ba864d80b9e39986eb74a643f4a51302f8cd9db58", + "c1": "0x17aacade2d67ef7ddec546d83b10929ff8e04becf8b4431c824b2824cc2f5380e71118d496c690f6b3360967b02558b" + }, + "y": { + "c0": "0x705d62f7e0884af46ccfac2b623c703d42cac76def0f613985265b31f8e5aa7b0f78f110131e896eb5fb3728658b38", + "c1": "0xdd71b740ee9a47eb5cd4bbbc616bf646c033f872bd91c4af55bb245c6bfdf00f9216995ec5d9a663cc2f965db14a97" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0x642ed79e7db46645205646e1d1bf7cd1ce95f4559f3586e96ded8f0b4b892510103a8344ba1830ec6a4c3c994cf11a", + "c1": "0x749f9e853fd991b951c2c45ee6040bf642d5a12f0b7370a46999208e0fdfa6ea30a132497f0c0f9a1af73e302de969" + }, + "y": { + "c0": "0x17407a7b2f616a8b38fd3caa46d6ffee97ea4325a7211618e8a5dbbb72557718bb96aaebf46c50d8010beba46706e14", + "c1": "0x52b3da57f517972d2f10cdec7f9aa2036a87b13c5d1dc1a308c939503d04cc78220c7ec30e1ebe4579d9c2a6b8cd1c" + } + }, + "scalarBits": 128, + "scalar": "0xa5a25e8a3794e2ef421b9754b553ab5c", + "Q": { + "x": { + "c0": "0xee9d407bbdbea1c5a5eda96a5228b1d2b3283558a050eb62eae442badb41f3222d87bb8da45aedfed5e4aecc62a574", + "c1": "0x7c5d14dfe4693e0601ca69d49b299fa81333ad81cbc168c7ef7cb6556c41f0210d21df500ad46e95caf81510fc2624" + }, + "y": { + "c0": "0x152eadcf2391ed3b998d738c90ca0f4409071dfc6b6ccb2c5461643e948f79d9d036d492b89684945d0216328166cc3", + "c1": "0x16e49c61459a5f758e1ce791c050056c6a87bc704eff1f7948d09cc13b2231bac79952088dccec283dfb8ea94815c09" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0xdac9f82d08159dff152d96c04fef7f4b304ca9b85ba4747a056e4a565109ad4807179571537b57b3430220b7a6ffce", + "c1": "0x5f9f3b429844b46907b25120494dd25be1968790fb42e0bb89803f92868cd3b054d8658e3d135541b74eea10815795" + }, + "y": { + "c0": "0xedefaaa7673ec85af07774590a2d44f9c291c7844c14ea1c562efbbceb0974895ff6e81b3ffed807e6c9eb93bbcdaa", + "c1": "0xd479f103fbdc472586654fa454048fb3e3c12e1ed35c1cf9c7709b1056f7db0c640cc3e1d9165de3c12d4b48c68251" + } + }, + "scalarBits": 128, + "scalar": "0x1b37c257d4b06b4da29941d89fc868cc", + "Q": { + "x": { + "c0": "0x12c461640380a85e253523ca7d06cc9b686c2489fdaeec0c24f390c958f28d5638472ab6f3e08ed6a11495a9a9c5acf", + "c1": "0xb961a47399b58344a1df6e667bfab0ba32505492ecdc43787700a02d7d865931b1892f5325b4101b19cf03927be3d4" + }, + "y": { + "c0": "0x136cfc48e0d612634c1e45652484e9894ff7aa1bf5c23198aa293668fac698466d8aca54055dfe3978eae5692bc0c0c", + "c1": "0x121ea32e5f41601bbb922c11444b80274c682b0fb640f732ee8efcd31a02d411303dcbcb4efc21ee1addbe94f04088b" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0x16da79bdc8c5d6b71f72b9eb265db24dbf3b89e8d7a9075437635309cb1adfdee02c04e2a163f570e1b6c95bfd207f8", + "c1": "0x480d326cff2f34582ab127df7e1843bdf36c8b6efeb3d2c9bc84b40978a676669d0c430c1bc7b17107814d3d8125aa" + }, + "y": { + "c0": "0x2f9b93a8dfe80ee16be330994b7807afe0c4ae868a6c72a98b029128eb1440b1a33cd4e4f32735028eb7b5e93c1bdf", + "c1": "0xd2c952cf208bb6d5aaff4973ae5fe76e31f90d1822fb397229f6f2c84c0f5c00c1340598eeef05fa40aeb1207e5cfc" + } + }, + "scalarBits": 128, + "scalar": "0x8d799bd67e1ff8bf6604ebe96d4e7a68", + "Q": { + "x": { + "c0": "0x1a68c17b3d26f758aabdac887821df1733e2ed0f1136ee61e9d45bf10fcf701c40e1763ed3102234d7ccb4f380b0fe5", + "c1": "0x7e3e0a61e223b0b5bf983bcab650a342be06987082a0a5cc4e07f030b274213278b04d6baea2fd0e5dd37d0c8d472b" + }, + "y": { + "c0": "0x5cb013814f4afbd60df88ba3143f3d091a5a01728f941954b81c832b21b0ad884c460ad9b15bcbc5fae2460e73933", + "c1": "0xb96761149e9d85a3c1df06dc2551462c774eb4c270ae21147a0dad8719259a1b02c19446264dc0b38c5bd999ffff17" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x1063552a239d44202da097a581ced9a200d46cd05a60cf5eb91f655351dcecf0e04d4c65426991cdb71264e8d116a9", + "c1": "0x78760b39b12b42f748766bd3ab7d2c4551ce2e6fe2f66d1f5a959ccc198d6395f6a2d935cd9f7a7b9c41d4bd4ea0e7" + }, + "y": { + "c0": "0x1a3452af185cce15e82e7951dfa95b4c153db0c68b9954d6a998f159fd3593d2848982193bc1d45dc73a730047ca8a6", + "c1": "0xaef01c071b08ca5e5d36137309e4147e4f9971eedd8944dd43cb2d988adb48b0b8b6afdae321a7c54a8a06454a4328" + } + }, + "scalarBits": 128, + "scalar": "0xcbeb4cfee7d50043649bc34b5d4fdd", + "Q": { + "x": { + "c0": "0x1fea500402d1b96942ca6f957ada5970fc8076922a5ac4bb16263401d11d357e7ec3ba00ab4b3659a5f645520484f7", + "c1": "0x1a4d7f7052e32feed0779fc2e5e83213c4d8bcb7a285cfae564c9fd38342b5d0776b8763e39afa4ee8b60cad50706fd" + }, + "y": { + "c0": "0x166ba8b4ad1eee3a9cbf6602669317f164a8098fbc460cb69ff5754147478be52197ce9250a5831d7768b8e514621ef", + "c1": "0xf79b4df32456d66a24ff9637e482ef2105dd35348626ea5a3a83c81187a630345ae0fe4afbb2f843c4ef4279a1262f" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x11c9029fe5c3ae63fb8e07b6262b68bf82f6492db780714a8b8e21157eb76c008afad9ae6508c92adc35d72f01888ae", + "c1": "0x896e9c5ed9e5817cdb6dfa573d78fd0006013a0338dc00d289cc32e0bf675878281bb3bbbf1fa0790db084aa5f1b83" + }, + "y": { + "c0": "0xc1f75b7bce5847758c8530ee3dfd0c1c1ca1b3e303399234ef651218270c1a2672de11999321111205ab90e1ec97fd", + "c1": "0xba666c0e304e554e6625b1e61fcd75527e760d5028b53645170da1f5e727c126dbd3f38d2d9d00eb8cf97f77d75c96" + } + }, + "scalarBits": 128, + "scalar": "0xd4da125afafe37554881b31e2587e358", + "Q": { + "x": { + "c0": "0x8a17013b3a860566d64093a59e29303968ac595e528778f26395b5d2a83513a95b1feea85d387c8d9d084530c49b0", + "c1": "0x189e223fe461ed130b7b6bdc82f7970ed2f31c39466a5e62431758a73675c0b781ef082123cc3e165a2b000032cab79" + }, + "y": { + "c0": "0x13fea0546b77774e0a34153bee3ad6c2ff70578e3e45e2c6df520cb924ff31b6836d7dc70b761d4d208b056daf3d7e5", + "c1": "0x13952ff88c6c365c2541799643116dc016d629e4926d079a94f24401a9229bb7170cecb67ae3b58a4f9efc09d49117a" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x35d6798410bf52ea4d8023cd806475edd6472e7896c51e51559494477fe595ab316eb5bb5d8b49156c4a8917535481", + "c1": "0x690f977cf6111d140d0c45994a7ab3a2c1e0cdabf0498d845a5a1d6f390dd99682fdd31764964560a65e0e2d6a0ef" + }, + "y": { + "c0": "0x13a962599a5e196b400620c585b05e51b5cd0aad81d3637c8395f1d66f30b5a3c4eba1409ad9d22d5ba5112877c1c4c", + "c1": "0xd4d1386d57eac29e9cda604d404cd9226b4f57ed8a0ff404d1fb4c439858e99512150b3b2d7e4890d96619ffca3841" + } + }, + "scalarBits": 128, + "scalar": "0x930e899eda817416af33ca14df09f728", + "Q": { + "x": { + "c0": "0xbd19810dd758afccaa03e173adff92e9a41547cb7b15eadbc0f06ed026c8a29acfd880c91fd72b6c5e95dcfaa12d3c", + "c1": "0x15159e2c771f4659881c81dc37aeff8cdbce7fbd52e4d7951ddf6cb5ad0e4aaf64a99a3e874cb9fbf32f3a8383434a" + }, + "y": { + "c0": "0x8b23f528a1594db2357c897c1dc62846225672f7e3fd0bcb29ccde247151952f3b6a97e851e298d6752b3dba634391", + "c1": "0xd75be1aadbede1f7cb7b34940947a35c156d0a0e1c346b0bcd2dc7f2c473d832aaf94ac7551c06f251e6d9e5700030" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x14ef14d8e7b4de2a92f0dcdf96f394d6be998003b48da14c207181307009ca95a2fe6fb93596cfd432cd4827e623a10", + "c1": "0x12cfa6de404ce5ca8caf8749c83dafeacd4cdb27c429e9bbac49e0bff3237186d8cd09138d189de354b9a8bde22481b" + }, + "y": { + "c0": "0xc076bd18652c9efeb85e0ec80a9a0259557cffec6ef4b8314ce164a5772a6c3ba37d0cdae80fb57086a91e70449cb", + "c1": "0x12309b0dee793d1218e19e34d19fe2db496dd3e21784f9126c4b094a666ba24b57a9c8ddb00fa1345bc06cacf2ae2a2" + } + }, + "scalarBits": 128, + "scalar": "0xb35abdd6293d7ab83525019c0d7f46a2", + "Q": { + "x": { + "c0": "0x999ad95abb75bf3a22ed56070f1950930afe58cc5659d351f61f5204d36382eb61a106908251dc3fc8e7cbb68a29e0", + "c1": "0xe96ae17bb23864eb7efd7fd7d84cf5cab8191f2f7d5cb622766f97206176328ee04669107003245fd29ebca69f8b04" + }, + "y": { + "c0": "0x169363d10ce78fd07b49a5e2ecb60eab1720de382e69b5bb342faec6194c941ad96e1a3c8c35a650f6d95f68888f1df", + "c1": "0x6a9cc8e7c6101e741423ef093fe00162b05ea7c4f80d5b269b1ff2f58d433e55ab2c9f284a4cd9f1744049ee049950" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0xfcb35d857333d88e6f7129b130894a1a025b95600b4d594219d1f70143514f3bf029b5d68efe675b90be5f6f07d270", + "c1": "0xe5f6d9d4f5fe00c45ff1a6d63046fc2991f32a41e7a4af0dcc52a2c31203a9bf2364a41f62916723d94aa5ed8401d3" + }, + "y": { + "c0": "0x63da9ddee6934a08815b589f351fb4bd2294ef1f8a25546b5bb175ccec4c2a0abaf5e590378044b844db2a34fc1d62", + "c1": "0x3748f83896693eec1ae9769109de2edf9ff5cc92cae37ae452cb98902b5b292b266f404e65eb82498e9f8bf8c83316" + } + }, + "scalarBits": 128, + "scalar": "0x64c35c0d9f6341b249dc318c956608e9", + "Q": { + "x": { + "c0": "0x63c34fdace167f529a66178aaa4379a569614a4db0729415a09f20b38118579f1c1d49a5a0d03c3c07610ad39ad2e1", + "c1": "0xabc5b5938ff36bbe2c5a625fa1109529481bcedfcd4267be981c0ea37f8ddf15812afb9a545b6267964b925c8ea8b9" + }, + "y": { + "c0": "0x2842252011280e38e7240e4d71842135e9c8936efc753a1a7cbbc1dd3a72d9ff85c9fe0459c7e40b647cadaee61b6f", + "c1": "0xc7f2bf8011b80a3c6e0afd25afab639fbfeaf1bc23a84b387252567c9e939e4381795e9b5c787b19a09eda85329367" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G2.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_253bit.json similarity index 97% rename from tests/math/vectors/tv_BLS12_377_scalar_mul_G2.json rename to tests/math/vectors/tv_BLS12_377_scalar_mul_G2_253bit.json index b878cbd..76ce100 100644 --- a/tests/math/vectors/tv_BLS12_377_scalar_mul_G2.json +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_253bit.json @@ -28,6 +28,7 @@ "c1": "0x12eebda917ccac5823163ef8e49b8b67f72dfd1daa7f9a1a3f62918f7e82f29daa9b4efae38487b7faa01d949896369" } }, + "scalarBits": 253, "scalar": "0x774340850f83bb192b29307e9b2d63feb1d23979e3f6321624f33531e78a45", "Q": { "x": { @@ -52,6 +53,7 @@ "c1": "0x17c8960a47ea043b81acecad1c56b287eb09436fe7739b122afca82a4406664172f159f7971c71584a11c07f05a862e" } }, + "scalarBits": 253, "scalar": "0x50b392d2e7200e40515f675415d71a3eb5f02abbccaf42dcb77b2550a69c021", "Q": { "x": { @@ -76,6 +78,7 @@ "c1": "0xaabe6c9feb20bcfb68e1d4a4daa7eac856ee818fa54ba9628d82e7ed0e057bc3fdd8709ed6c630a3d9eb4195b448e4" } }, + "scalarBits": 253, "scalar": "0xd06ad767a953eb0ae126b764fcf9583ab50420730311af7d2b1c643a4e5b8f2", "Q": { "x": { @@ -100,6 +103,7 @@ "c1": "0x14d84ef523a6734cd26ed1412b6e3c4d23a0c5a9752f4902ab46abc286d265f50a086af9ecdd8f03e9539a1df170c33" } }, + "scalarBits": 253, "scalar": "0x9bde0fcb2da232a8507ac66a7c7422d0112a50bebe904792d43dfec443d86be", "Q": { "x": { @@ -124,6 +128,7 @@ "c1": "0x821ea08b0857fea85e0fa61e9c79a56188b2699118390b2acaeb6053e44af65fb091e38f05be46a68f703ac7f61254" } }, + "scalarBits": 253, "scalar": "0xa923bb520914b82ea44b16129671e0d4906bb9774f7627b13d3817fc2de121a", "Q": { "x": { @@ -148,6 +153,7 @@ "c1": "0x5aefc260542351828c2a7325d8aac3e7e954f070f3e8a5ba8d8bc40604a0a92b88048dff6a41ceb46949285c3c5426" } }, + "scalarBits": 253, "scalar": "0x10f43f368ecb344d0636809104edbc0f61eb3094a0f15a900d26aeead09cd1c3", "Q": { "x": { @@ -172,6 +178,7 @@ "c1": "0x958d11d762deca6f9d35c7f078d6b737e2a22c66b4115d8477f5d6a70d307034d3fa474a1753d49fcbb6262041b1cc" } }, + "scalarBits": 253, "scalar": "0x11ec1943f2b149e991f1e8035fc86ae1dfb12fa18736ed458a39c77b4093a33e", "Q": { "x": { @@ -196,6 +203,7 @@ "c1": "0xcad03ded8e7c42164d8b24ec3cffea23f8177338926b1a3ed7b91243e103c279dcea8b135af40350387db78c2d670e" } }, + "scalarBits": 253, "scalar": "0x17229a30580750c1f2b196c75ae2a5aa5d528dfca4ecafc72acd5b28be21a32", "Q": { "x": { @@ -220,6 +228,7 @@ "c1": "0x99c24cd63c88c151524319ea76336b78cb821840da63d1e4c7408e1d65b2eb24e9300e7c4a92afbfdcdb8a5f9fc9f9" } }, + "scalarBits": 253, "scalar": "0x117efc66135de516e814e8a0cd0bcb57a03778e98811a7774bfd4b558c5b3266", "Q": { "x": { @@ -244,6 +253,7 @@ "c1": "0x852561e740cbeff4852f3f7d9999ab1f2c5b62f1f5bcbb949b45c45c88806cfc4fab4604a21250302af338aa6035d4" } }, + "scalarBits": 253, "scalar": "0x6ddb84e2bc7914cf4e25ae1c8736ecb2ce4a6a2250ed4d300898044ef9855be", "Q": { "x": { @@ -268,6 +278,7 @@ "c1": "0xff3ee6f352f19a76efed37eac7397af0a51813804087c60c96dbd854986d187a17c006c97950de608c644147dea7e1" } }, + "scalarBits": 253, "scalar": "0x1035e170eabc82625344eecc8044f688a14896a0cdd03130694a81338a510572", "Q": { "x": { @@ -292,6 +303,7 @@ "c1": "0x1442de232535385f9240b06a144b1725ea1f914886b28146a395c8f55450b8b95232bb77b779236b36f5b39e4673daa" } }, + "scalarBits": 253, "scalar": "0xaf4a6e3b968137703bdc46ce87e2b737eeb68ee0dcf75921d80075254ff1649", "Q": { "x": { @@ -316,6 +328,7 @@ "c1": "0x4a34c672340864274c42d830b394d114c381c2017cde9749086fa28b8b041cc9c13ab976f5b4f3111532933e6b69f9" } }, + "scalarBits": 253, "scalar": "0xb5363848735700bc821a7a4a2568720b4177ddaee9b4aa27d7ed795a8057d26", "Q": { "x": { @@ -340,6 +353,7 @@ "c1": "0xa406a43a43e715200daa17fbb721d3408bddad88b6a3a35f00c8bbb36f4203b7eb0348f8e13b83fe2dcc29c27f345e" } }, + "scalarBits": 253, "scalar": "0x1f1e7a7ef63899b369a15639d4acb97ceb17ddf9c95eec36edf5a3ee3c2794c", "Q": { "x": { @@ -364,6 +378,7 @@ "c1": "0x19e52b3860d5638b6780e24ef221ac0b2d39599347a4fa6db35d73f9661e433f94e604e911a68edcb9ad03517a1c3b3" } }, + "scalarBits": 253, "scalar": "0x3641ab676f9ec6a285b66cacafd66c6cc21b8fc69f89f57b2202d83248c16cc", "Q": { "x": { @@ -388,6 +403,7 @@ "c1": "0x6aefd824386ba94f1e7a9062c4d928484e98db343c79016261019450905cdc711cb9f753d9aa334cee94a13b949528" } }, + "scalarBits": 253, "scalar": "0xccb4caf00a8006d7699836444c0f7fe43a9c147c692af5040ab1092e6846b26", "Q": { "x": { @@ -412,6 +428,7 @@ "c1": "0x149d6818eeb5e8cb2a3020ca840e4c207a87c412f1d46fa32805793e87c9e5e063b0755817e9b39dfd5f439cf3c6d81" } }, + "scalarBits": 253, "scalar": "0x10ed1da7d49cb23feb27d74851980098173bc40027996a989025e4a853c0e09a", "Q": { "x": { @@ -436,6 +453,7 @@ "c1": "0x4a95c629d51786914b92c356e42b02ed6aa464e501c14a330eef7e0315435a3c97e1955accd683a7983cec209c1c01" } }, + "scalarBits": 253, "scalar": "0xbf2c4692995f15a76375f9fec16663181f4bc69a7e7717f7e0cba7903ed35d1", "Q": { "x": { @@ -460,6 +478,7 @@ "c1": "0x119696aef90b53f6de3b89478695d7d2f9db89cceb9f6423c47ec728621805f71eb4bc3e0717b2d65dfa0e81515e795" } }, + "scalarBits": 253, "scalar": "0x4999e4d91d15207a38c8481dda0e8e4b26ae60ee93558056535732379831d5a", "Q": { "x": { @@ -484,6 +503,7 @@ "c1": "0x165d4bde299a8484ecfe41654c046264e78c392cf416fbc3dfabe4ff46afc965601e87cd016009aa08d4cec952062e1" } }, + "scalarBits": 253, "scalar": "0x105844111a548723cfb66a5cf2cff88c85dc4a45859806cb444a206505c18cf7", "Q": { "x": { @@ -508,6 +528,7 @@ "c1": "0x57064bef61ce3774ebaaa41f08ddb4fe5733e5f2d9febd4e10f566ac985af3a1bf527b58dbaa980de17b2eb129d502" } }, + "scalarBits": 253, "scalar": "0xbc1b29b908d58af7778b162f478b8540b1c2c4a50116dcf71c8018da9ee45f", "Q": { "x": { @@ -532,6 +553,7 @@ "c1": "0x5b710d6fc7bc4be50b79aed7ce6623e0a2c01a944031e810d3e57f45ca79a981ad095418927d5c9b9ba78c104c3bb1" } }, + "scalarBits": 253, "scalar": "0xc0dac6a14474f135d4380544c19a534cc89b1286ccdab5199646eb19d31572f", "Q": { "x": { @@ -556,6 +578,7 @@ "c1": "0x2b502b8d45a13b43fe2f4c50076b74df561cc5cff4aa9d1869ccf3680c931ccc62b75c29c9e6cd3f7dbb21ffa1cbd0" } }, + "scalarBits": 253, "scalar": "0x1218eef07685d572f28a59e3cd731fbbaab6ed9a76603bbfdd31c2f6490fbac5", "Q": { "x": { @@ -580,6 +603,7 @@ "c1": "0x11d4548c8fc9956a5e567e32b23132407557cab6e67b037455f9ca5b1eb389a9c8d431b3193d05ea89818197bdf47c7" } }, + "scalarBits": 253, "scalar": "0x8fdd885f1c0336e4deba119dc8a81430a00eeccf1028ec5d62aba2a0f81da0", "Q": { "x": { @@ -604,6 +628,7 @@ "c1": "0x19eab60d45ee9e565336978cf447eef71a9b23ce14813c6db13e46e790eeb8b7154f322914697cc2d2b7bcc78ff3f90" } }, + "scalarBits": 253, "scalar": "0xa55a53a28457b26c0177c97aa827cf439be416b0d453cbb3d2b765870d0d58c", "Q": { "x": { @@ -628,6 +653,7 @@ "c1": "0xbb43989a40eba251ff49d01b3643abacb4c8d37803f9445fdc1a416f90525adbdc84b22107b5325672d3020af940e3" } }, + "scalarBits": 253, "scalar": "0xd2e92d55991f61f9161c70b39d76eea16f899c12f4ab9112b88cb24c75efb4f", "Q": { "x": { @@ -652,6 +678,7 @@ "c1": "0x6bc602b63a2b6496d70cc213dec1baca237174200da6e9660112781857459f52a878c6948a2cae55db62b9bf4b54d7" } }, + "scalarBits": 253, "scalar": "0xfb5c87cbd2180816ad42acd68041732efc7aab96fcbad8a431854c6862d505", "Q": { "x": { @@ -676,6 +703,7 @@ "c1": "0xaab00d825e3ca629b6da744e514b2c5460f9e7cfc6a679d3e9a80e089aef229a95cdd107397f5e8c8339af158a9491" } }, + "scalarBits": 253, "scalar": "0x720026e328dde137b31fe25a08a00523351abc790f6405dbbdf12ae6e48bd02", "Q": { "x": { @@ -700,6 +728,7 @@ "c1": "0xf4a6a31d9d3876a867c6e2bd22d489b678dad51a346ab6b4a2a2ed65d9edb0f1f7cdea976b95ca498957639c25cbc5" } }, + "scalarBits": 253, "scalar": "0xa2beb2ec9c6a0a4a0863a0775440943e72d58436b104e7a016a5fdbfde95a64", "Q": { "x": { @@ -724,6 +753,7 @@ "c1": "0x93387cc145b8b7a6abb30153efded1578e4d4962d5283cbfe3cfbced42f11813a8788b7edc2db91b3bd0f4c60578f2" } }, + "scalarBits": 253, "scalar": "0x9b50c131e8e2ad4a030798ead36ba13763f032711f3a2afbc3e33ecdaf931e8", "Q": { "x": { @@ -748,6 +778,7 @@ "c1": "0x7a139cbd1c8005779f7256e7805645490292a97ce45ec569b6c2f26b208d0a74cf9774bc2e3baa57b7b42e40bce1f4" } }, + "scalarBits": 253, "scalar": "0x1143005cdf9d1b37bc0bb53fdf5ce0228463be0bddbb6884e25f3c97d66fc7e5", "Q": { "x": { @@ -772,6 +803,7 @@ "c1": "0x1410f0a7cecec2a88a963a73a8a59137994c1217b74e96009ba72c3e317715b140279bc152b30804d0cf94162db21a7" } }, + "scalarBits": 253, "scalar": "0xc42af7872353d25fd1229a2633752e9f978d91333962e72839885e074141b19", "Q": { "x": { @@ -796,6 +828,7 @@ "c1": "0xe698e4cdce08821d80b22ec87cfc80ea35f834cf3edcec500349eefadbabd56c15992384845129048aa7786f4cb2ec" } }, + "scalarBits": 253, "scalar": "0xbf056c447086a6ca7506f41e9158d7d9d50cef1ccb1ed9374228d5b61ad2a6", "Q": { "x": { @@ -820,6 +853,7 @@ "c1": "0xdb70f348a48533f0900676f8f2e953abf0e0e5e8d21855acc96b3cf1bd38a4164a293e971110fa8ac8114edf81a305" } }, + "scalarBits": 253, "scalar": "0x621d93d5779b355bd32e3c381cfd371f26ec534825175cf544611a1eeea615e", "Q": { "x": { @@ -844,6 +878,7 @@ "c1": "0xf3d3da0994c29577d4e00e86817bc5c7a463e5b0cc5e58d9dc548dc422203ef02f8950a2d262ff997bc6808828a36b" } }, + "scalarBits": 253, "scalar": "0x9064434b3910f87a67ef765d5333e2e307a6776d9c2780d7752b316d4da125a", "Q": { "x": { @@ -868,6 +903,7 @@ "c1": "0x116a3262a72bf6eb4cb32bd04feb6a0296a6f662f09c7bbf24e58f79ee31581be30f228e81ba57dd51d4ef0c8efadb0" } }, + "scalarBits": 253, "scalar": "0x6280f3ecb9f7f79bf2a6d315c34bb3608f56c1aa01964e972acf12cb35abdd6", "Q": { "x": { @@ -892,6 +928,7 @@ "c1": "0x1236f018a642959dfc4f329760f019f4346e8f8dbfaa925618700b7024defb063e15b371dab7059acb63d43bbc2bf85" } }, + "scalarBits": 253, "scalar": "0xf09c5e72bb8913046cad795ac55cfa7b46c4dfc05e470ef894465c5970f9246", "Q": { "x": { @@ -916,6 +953,7 @@ "c1": "0xb39d2ec295d93aea0a48992ac72cd5c81ba5540f10f6b57eb5c1e59d9a29c2feb5db44b6e61c88a65786699424b222" } }, + "scalarBits": 253, "scalar": "0x9cd0f09b5db13eb48361d970b68d09c44ff7965907a98c1643a1e677bb6ed60", "Q": { "x": { @@ -940,6 +978,7 @@ "c1": "0x571d18711d78e84d144cc3da5fb6bbfb6adb7208b850e191c7b5ed5c042d0a49973d91585af5f6711ca57d19730ce5" } }, + "scalarBits": 253, "scalar": "0xce136dc2be3c35bcd981d687e8fe25b36c9a1ac7d5609d7577a28f3b267462d", "Q": { "x": { @@ -964,6 +1003,7 @@ "c1": "0x1adb162f90e8219f4db0a2499282347ff1fa9b7339e22862b2e22ec8bcf7b3e1939619a0c0e5f6f695a673cec675cd7" } }, + "scalarBits": 253, "scalar": "0x1c211ba91d40d2a8e3028962cca5a3c8dee44ce9b9a45735f6cbd825ee1b795", "Q": { "x": { diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_32bit.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_32bit.json new file mode 100644 index 0000000..13f0488 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_32bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BLS12_377", + "group": "G2", + "modulus": "0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001", + "order": "0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001", + "cofactor": "0x26ba558ae9562addd88d99a6f6a829fbb36b00e1dcc40c8c505634fae2e189d693e8c36676bd09a0f3622fba094800452217cc900000000000000000000001", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "D_Twist", + "non_residue_fp": -5, + "G2_field": "Fp2", + "non_residue_twist": [ + 0, + 1 + ], + "a": "0x0", + "b": "0x1", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0xab080b20561040388b5b0e22af3c27f68ad41d5bf57de5b89bc5fd688d41b7949daaaf78dc87ff070f3be842c54232", + "c1": "0x1a80a67d56d1e44ebeaff0b560cc05a21feb39f02bf32910125161a665364ddcd2417183b7970563991556cd7f2f046" + }, + "y": { + "c0": "0x16e3a6b142cd3ae7ecc4e8cf253c99354d65ff2b734bc87d6aa4e2a92eef56b20f70eb39fba31f3908526e5e3853a25", + "c1": "0x12eebda917ccac5823163ef8e49b8b67f72dfd1daa7f9a1a3f62918f7e82f29daa9b4efae38487b7faa01d949896369" + } + }, + "scalarBits": 32, + "scalar": "0x31e78a45", + "Q": { + "x": { + "c0": "0xef2fe7d0b3d2653bd598755b33f5f9e7062f1ae9d27c7d95e30607eeb4cf422a298ed0703107446c6b41fec0b20f25", + "c1": "0x105a1a9704e2bf9f9e69b7df34d660e99ab5b59c288439c754b23aebea59ed7be56c57cecc093cd5895f5bc9e461c79" + }, + "y": { + "c0": "0x99c69db02ef93d55693cf30003c0c7716b0f009912b48e783068c34a0f76417a6410bdee0292e40f74c66298bc42ef", + "c1": "0x760caf2f2ed4833f17d02d9b9e38fa9de831fb9f08be047e6aedea659492beedb6e8b9b459bcee3f9b06c7c5a52daa" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0x4c8ddd862162301ccc86065e00408735882a734a2883d67c91859b1760bbf43b07b1d8f5feb68c90aa2df48677005a", + "c1": "0x18582863788f8b78328091b1f948765bc7f650a6b7a053e035e02fcdd35eac1ad2374ad1e15ebd36a10faff9bf8eff0" + }, + "y": { + "c0": "0x4f0872037473e0220cb0974ab2262bdbaf65146bbca5f0474eead69776aaf281d8bfcf72d2c08215833c49c0abf6a6", + "c1": "0x14b4fdacb4921ee46d216825b22801a293494dedcb38f8a8a1a319c295625b533588d2799cd57b5a0b0cfe428f14322" + } + }, + "scalarBits": 32, + "scalar": "0x21f024be", + "Q": { + "x": { + "c0": "0x155ae3fc441e4aa5bacd2968cd546dad528e1029b4bcceb7e476a225971f5f5cca6f8ed9ce1da3ba9eb98fd9938d97", + "c1": "0x64ec115eda4e95dcb5c2f03adfd3870a37a0efc6764eb3e35bc2970d6bfd0dcd8ac38881463f5fca9b488d0ce29937" + }, + "y": { + "c0": "0x1a55d8dcbfa77492db76f830e82e43b0d27cf91a3088a831e8f3a7747f2a796d1e511652744fb045cfbd2ec87e001e4", + "c1": "0x1b21669d5e9f811ade8f2c855a4be6d3d0a0b743916fede471e4886aa9834e3fdcdaa5a93258c4f7f879b87f6bf803" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x17f1cf8a2944780ed7e23c433183e2eb8b4c1db163192e783431538f391bf777812feb1d960ccb4c5d626b205d7d4fc", + "c1": "0x1171c0bf0e1d0baaf229a9009f43143adca3005a7e9698c4bc742834cf3ba02407fb0024d8174052ba71811eb5fe322" + }, + "y": { + "c0": "0x114fcd5c7f34b90ca2e08fc39e774ea731b93a673dcabed1495c702147ffce2f3deb2add026a1b25c5bbbceaeb6f285", + "c1": "0x14d84ef523a6734cd26ed1412b6e3c4d23a0c5a9752f4902ab46abc286d265f50a086af9ecdd8f03e9539a1df170c33" + } + }, + "scalarBits": 32, + "scalar": "0xc5c5c90d", + "Q": { + "x": { + "c0": "0x19bd2f46c74d01efdec2915973076ab28d96b4e97799ae3ca71c04a4a1225ad91cbc7b3475968a57e8e06f6517d5aa7", + "c1": "0x2f33ac39ea630b18e45020dd4ded766d28e6c878bf10246a12fad817d6630f3dbd7658416b2b29bb8a1881791d581b" + }, + "y": { + "c0": "0x121a7a71be6fff1b0795d3914e928e790c9d1c8aef5b9558d83e26f903dc164f1ee49110bb912c825071fd6d25d1869", + "c1": "0x102cad20201e83cde6df39d38de53fa426bb31353e2070612b724029d466164261c6e685b95fae5c0158e581e2b6f46" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x15c551ae2f1dc42b3b13eaaea4f52e34a00c2f9edf5e1a53764dda002dabc21d216759031b5d0c8ecc2a33a798b632b", + "c1": "0x1273d331016ce73675e53d302323e8b7b1eedcb9e67734fe49b7ed40a8658b74848d6371abc3a03e29a964609368663" + }, + "y": { + "c0": "0x143207d65e618392ea6043998755c12ee3b955ba1171e250eee41fe68cdb2fb3fdbfd28b2156c801089cae3f7fe5dea", + "c1": "0x1d6ebc156c7b853ab7f959c442b64772e2f8fe395ea1b5496c8991cb832286e2383c30c9e9fec6bfb8a04fe965665b" + } + }, + "scalarBits": 32, + "scalar": "0xb045deac", + "Q": { + "x": { + "c0": "0x6aa6b5c10267e84383161d093c7829cad604fa45583be5e9e4669526c5c7438c905b826e5b4b1290f2cd905213cae4", + "c1": "0x1509834847394c45ddaea7d4366b2304319e6271a68c2ff319d09dc7a062495dc02d50a1502a95d7c9e2b81683701d3" + }, + "y": { + "c0": "0x14eabc0818282ef3346ad58efe2fa8998746427d4b7d69c69ae37a39658427fc149112b663fc1c48ed8bf7de94909d5", + "c1": "0x7354d1bfe5cf92256456312afca9344faa5654f0e27f6aad544655b039f4e1fcadee830811ab999e19cbdc8d35cfbf" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x159d3f9e8d461e68df26729e98da84cfb23fa8a2d9322fd26ce0ccdaba1b00734705c0735e4b166656ad549abb934f3", + "c1": "0x1e403fea43ec6c696c10bc223fe11c85f6df2db144e22488d9d5315f47bb2c760edcfba84177a6f14247531efba4a0" + }, + "y": { + "c0": "0xf2a7951dbb40565de6b4db889509cec250e43c7bd141a866a3e2d90fea65fcf44510dd65f7a3b94c7dd08405a59081", + "c1": "0x6450f028f8451930ecc02767b65c50ead1bce0e8140ca5b6bc3816c7044ecee085b0bd43de7c49113f12ae7cf2dc91" + } + }, + "scalarBits": 32, + "scalar": "0x6c96accf", + "Q": { + "x": { + "c0": "0x1959bab9e42e81125c2598ad44ff585cdd1e72fb3dae197948128443fffabe5b5b15536f3f0910666bcb62b2e41a661", + "c1": "0xf2ad47655c0477508418e8f326b2ab7328d255668292a4d8e14e306eb17ff0616e07d020c8d913e71750e2e60b6d83" + }, + "y": { + "c0": "0x1468aed8fd07bfc644dc1239da67a102137bc4c286c72d5ea180c88128e84e27bc55b669aa0954e67a9a3ade570d6d9", + "c1": "0x395e0b2ebe462f85e5360ec322429167a0305527bbc4cb1f268cc3a64395a00a3d8c49ffa06c3d4fd0e48be6866442" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0xcd725995b25251858c5de05ce9d8310dc0eb6b93ec0ac2a37449b2dfff142c649d32aa6f0802472d88c3eaa8ed1270", + "c1": "0xa2317ba64cf7fd8bf267962d10c314f821fc4631e17b2a15fd1348d6953a11366a1bf928b0ff8879823723476fe3d6" + }, + "y": { + "c0": "0x179da24ae2c30567b05731ccb4d7fe75ca128028937a07a518551371d482e590ba7cbed938e3932275cf0fad5eb93e8", + "c1": "0x2d12b8ac6edfd21c88d4b0e88e60a810a774dceb2b245a5d8f07ea892f672ae0431eb390f25a32600d8b95e4634dc3" + } + }, + "scalarBits": 32, + "scalar": "0xc11bb33d", + "Q": { + "x": { + "c0": "0x149b8bec1508cd650c693459fc462df0f77499044b6e609543b8a1714912a705a310fe9df047b2034b81ab8e07fcc15", + "c1": "0x11e0231de9cb1ef78e0d82291c43e72728d0d7b0c6706fac773c1f8f07fe7183699ea03373e19fc0f70d2a464324316" + }, + "y": { + "c0": "0x1885c991e53474bce4d9c499ed37500d6985b101ff5beb2e33974277954433351a60fcd1772332cb5e006fce6b1d10d", + "c1": "0x108ca6270306f0e7546164249d5ea906f2f8aceb67a95658c3eaff385927bac87a846fc090b2619a2ae7f0e5fcc66ce" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x131025f234ef679cea903bf5557f059703484f94823ba17b02b7d2c94379deb6a79de9aab1ff0b1af049d875312c80d", + "c1": "0xe8dc412050cfda7683b9cdce161924df14b1e5818236826ad9f70da0417c07eb1c80d4f8541533782d70e5d94f427c" + }, + "y": { + "c0": "0x5efa2947dd8eefbac69c7ac196cda881a863538560be354de39f6a06975d3952546c8689c98d59ac83159fcbdfeb81", + "c1": "0x185387e1064a991a08fd4f40015725c44a1c26f19b4764f0dc9815454d4d741ac671a7b4b83cd5a5bb01041a885ea8f" + } + }, + "scalarBits": 32, + "scalar": "0xcf2b2211", + "Q": { + "x": { + "c0": "0x1088fac65e613f94f951069bcf617a54e0b8fa093be526a5e83e6aa15e85b8a16c455e9e1d601c763e0747c92176662", + "c1": "0x1379363a12d4794a06f14ee2e4808a1ba6e137bd37dbcfc08bfcc4b925b69e279b84032fee9757f666f694d73d0e713" + }, + "y": { + "c0": "0x18df1dd0ea219c41ccafb3f79020dd2084a574ed14ea8f1cd45c94c58c4d17c946b3ab5b8f7c5b9c214fce9259a356a", + "c1": "0x597d9c669d9eb8860ebe68082614ac7ed24b4ede83670f42e758c338dbbd5fd96b76d2aa6b8f257bbb64e3d22102f0" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x1244164a5f8f3defc0a0ad1e9fc03f72077124f768c2de20262eec36ba0628f7efe7974381106a2efcd65c8250a5866", + "c1": "0xdd3402a7e7f3841a7d5051131b702265f73ecaac58b213e7c4cd8d1c1f92362ae0c6637965ccb924d180914e94c0c5" + }, + "y": { + "c0": "0x4917cf4f9006b878104dd874b21258d593f480d9263094eecabb9211b713b3b752b1a4508fd5eb04cda3b8e763b21f", + "c1": "0x1442de232535385f9240b06a144b1725ea1f914886b28146a395c8f55450b8b95232bb77b779236b36f5b39e4673daa" + } + }, + "scalarBits": 32, + "scalar": "0x54ff1649", + "Q": { + "x": { + "c0": "0x129127ddba65c4a7fa9ecfdb122169cd82ccc3e78fdfeeac73e36d42ca4bb4ab34ac675c7a6e25d6035e94afbdf3bee", + "c1": "0x147712769dbe642b06fc837b5b124d85bb3772673b8d8af66b2b0d0566ceda308c5ebeefde953745f4fcec269b9297d" + }, + "y": { + "c0": "0x10eecc572ead5d9be99fda38a470338eed848bb1b99e8ff61c51ca1b50ce5fd60704fe5d4a32f9d0fe36aa9b520abc3", + "c1": "0x19a8a20863c7c4e708b7f0c9f57b42d685011968899ad73dab30dc4a2cb9b5eb34d46ce3bd3018dd9c1da93a3f127eb" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0x945ed7f5480afd70a9999ac2c4cd5802c165b28adde9645e83860bb585ca4d71bc2b2fe5e92677c070bd95b975a41b", + "c1": "0x557ceab47755a9e70186f24e8fccb6bd543d9e04c4b035da6d082ade1ad7f0f38291bc6d1504bcb54058f5a4a09bbb" + }, + "y": { + "c0": "0x1476d51f7d196fbeba04f1970ee942af5e5c32df2aa7464091d67dcf0059b8549a97979e6f310e761d45c89f7713482", + "c1": "0x40e95a31ed15c6fc9f87626f278e665ae300fb7e30c3e46b32e7cf03f6b114d0d75cc4955dc1e57cb6021dd45018cf" + } + }, + "scalarBits": 32, + "scalar": "0xf1419984", + "Q": { + "x": { + "c0": "0x1ecb201ba5e417ceaa42718407af4b5469eaf0961b9343e8d82667db3156908ea8c8ff5e20fda820564dfd906a0b6b", + "c1": "0x815fccb9dceef2cb1d18f42b360a0161a786c96053da1621ffc7678e84f12209846af3d7f3db964b4b91f319072e9a" + }, + "y": { + "c0": "0x19acaf908f1c85d112046b66869ab244c32e6b829bd78179288290dda47e2b62f04659443eff9b8e6cd2bbc182275c3", + "c1": "0x156eaaa5acc617e83b5fab6171b36ea50ec471e457f0a06916268863003cb4d06f12dd3919a8d9e271e15379553c9b6" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0x10a71421240ac1ced1a41e6eb15d208a5e2fc4ac0d9ac65173f4181ddf286ed1218f44fa0c82d0214d3c22d455fa094", + "c1": "0x7d97fcb89845feddf3328414939570ed33bf6a6b67587f240db01a1b5fafd04503106be54f099207fc6fc59ad8c9be" + }, + "y": { + "c0": "0x189a4df6df515e5c6a1be69426ea5dc2122fbc6bebaec7854aeb0b2f242bdbfa18467ed75f0e7f9be02ce603c1f4006", + "c1": "0xa406a43a43e715200daa17fbb721d3408bddad88b6a3a35f00c8bbb36f4203b7eb0348f8e13b83fe2dcc29c27f345e" + } + }, + "scalarBits": 32, + "scalar": "0x87280f13", + "Q": { + "x": { + "c0": "0x13e0f8322751e95aa22b4c24071e829e755ba17572bd66eef718edf6b52be497fd4f8fe0276c16d6f8f564a7508b6c4", + "c1": "0x1079117924a228bd7d8520eada2e89efe88d9584f8538a4d06af9c65fd1afaae67c4cb28622d433440683caf6ac204d" + }, + "y": { + "c0": "0xc9240f412549b1afa976108683c3e51f054ac3cfb4e37854ae94ed1989357f8a1ade670648d90f2d352fe286e32573", + "c1": "0xd52e1036cb7e853c08a09968d454f88bd7401f9ba5d030eb5904f742702e8c893d6d621d2907bbdbf5c109cd2ccfbb" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0xba4db7486bb1e18301d51a184c8a9424e290ab47a6e8089700a404667b610f7bb2e55c1b434033c338ea2f2a28a2d8", + "c1": "0x4d0db57e2ef621a1380b476d4401f26d5a1952a9bcd42e3d84bd110b584428e754e2a82d3208eaf6cb90da7f7881a0" + }, + "y": { + "c0": "0x12c1b27f62df69510a34958264cfc293ce59a6efa411fba3a6fa8f15a17e1c33ff74077432b1b73aa8ffd629ec663b5", + "c1": "0x6d8bdf361858309f7c0de6f37370c28925c01976b4026f7d7e77bf6edd63f72cc3772e60c2306c483b4e19bbde5896" + } + }, + "scalarBits": 32, + "scalar": "0x15325d38", + "Q": { + "x": { + "c0": "0xdc756d091e98fe640364df655d8a6487f79c7be94306bfb12b0853d95ac23804f20fdaad33e18fea00809b4e686b2d", + "c1": "0xbb8245b5d71fc0bec65a642329342ef637e79b55bcfe304bf81b590661f9578e89ec8c0a18f3bd3e6d7651741405fc" + }, + "y": { + "c0": "0x16792f6d52955442313773433bcfefbc8944e0d33c0e3aeb68b08874e001e8686edc49ecb93338eb34222e64999d510", + "c1": "0x13e4c4b3a987dfc77226bbb13aec86cdf92d3a9f36b50a4ffa67c96dbf353f574a27a8ffc34587b3c443a2a4822de3a" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x925d2b6300900381e146a0220b9de14cfebf731072ab8c2a95f29239c498f85022c6dd83b4ba18825e8ec93e38f4d6", + "c1": "0xeaa972e47d7557561b1a0cb5ea0998ecf4527f191f8332eabd77ca15555974f430bbd2a86ca34e3b6aa46b7a3a95fa" + }, + "y": { + "c0": "0x49d126497b6423537c769d9a69d27bd10b272587c265827080f0594dffbc8454109e5582fc627323e6a87353437500", + "c1": "0xf16bbbcfcd2aff57fd67acba0dc7737245a580576a1f660bfaed48e662bbf0b1f13f548d37286c8c123b8b4c587b03" + } + }, + "scalarBits": 32, + "scalar": "0x1f989c8", + "Q": { + "x": { + "c0": "0x15d412d3c97818391019cff035119b49c3fa15383a4ebef68016807ae146adeea00320d57e06a1fbbd3f46239933de4", + "c1": "0x17820611e3982eff9d99f4eec59d8df2969eee28ffbbea4a945012090a7095164367c0270ca3a822fd7feced7c46f47" + }, + "y": { + "c0": "0x5614393717b32bb4703e26162e0f0fe52be6acac97f459dccacf8f5c89aa9388c91512a64f9412bb4a72a4b2bbcf05", + "c1": "0x82bba3d5a4a68e2233a13f4a4f0b37a2cb6b5ae1abbdecd4a06a8fb93432b1ff93a6650403c4013dfacd58a5977b74" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0xd88eb4fe3e8e5a651cbbb3548a15583a019a1becc84d915474ba9db8c13eff563c74ff8df117c2485e14b045de4550", + "c1": "0xca5f6ee3fd849d97c5fcce062cb9f3c66ea72a0db50d0e6cff9793f045b7c2fedc7161b3f9bee9d738ea87bebc23bc" + }, + "y": { + "c0": "0x847b743c7f69101bd880dfc32aa00d5751bbcd9cae5e271aed0c87ab2e5fd3bccdb9ef76d93734000bcffebe35c543", + "c1": "0x1757b592f407622c39329b8839752d7a81070cbbe58b7a526c82104f0c7ca81637e0439fc866e2d2aed3535d3141f9b" + } + }, + "scalarBits": 32, + "scalar": "0xa494529e", + "Q": { + "x": { + "c0": "0x47feb4b95e805ab901d651c606a0a35e71f73fa9b04260715ef761110319b8ab86bd36f0ff2ccd8592e0a88d988f78", + "c1": "0x12de700b63c437e719835b5f552924dbfa5b4e5b6b844000e9f6c84ecc146a8340ecdb996e7dbd8ae9d8fef2e6e0cdb" + }, + "y": { + "c0": "0xb1fa6127ee96471b1a640eeb77dee64961b38af6f70ec3edacb8c59fd708be0547faff660b06791afea0a623a95bcd", + "c1": "0x4d95093e94c2534f6d484c3533441981ebb702e812a80940fb97ef4a0274c10c8eb3f1c94bd04e090c34cb40f49e48" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0x75939f074ac26a2cfb38a1f8f5236e34d8f9096b70f9c8284f0be4d56a984f447a35549b88cf14c131eb8168a02a5", + "c1": "0xfc63be4b9833cebef5f76953c444467c862ee545b9a8ab8ca06b1411c65b5e14e2d87f5d83985890f9c28e4bf28f0e" + }, + "y": { + "c0": "0xf50fb5f3b61379362f0497a88d19aea3db8596780715cb85c0e19d37b6b6614e11da7e1e56be2ae5a14bce2502482b", + "c1": "0x2a4ac08b9e87754a549a73185046dc5dcf4406a32785544023991a830510d40214fb5c3f466d3046ba41d7597c7b5f" + } + }, + "scalarBits": 32, + "scalar": "0x576c71d", + "Q": { + "x": { + "c0": "0xe15f22a4984321308ab156b72585468e9185e305f404b6c6c25c6faefdb046e842014aa363185697d1d5e6c207dc14", + "c1": "0x18f9c08216cb2fad7986ed0ff50ad7c13529be10956b196264c89f717fd689befc88054ee9d3dc2d6218ab4dbe861d" + }, + "y": { + "c0": "0x1796eb43111e84af2eecdfe02b39746d959f34636c8f3b059db81d2c02cafb713a97d842165d8617508f28d10070d0a", + "c1": "0x13faaa0f595995dd2b249bd9edf325defe873860da850ca7b702c41210de7fd546581d4b5294bf16a8766a981c128ae" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0xcbcde5fcc9f3ae5347b9d49c274bbd9a471340a8e46aeda3c938710fa83e2d3fa53b6c78e1fd1fa67ff9a5bd036938", + "c1": "0x105227a026d803c57ad2c6c069f58edb117979f453d5b146a294353316111bb1759e2aca9db24d2762a24f31980eac9" + }, + "y": { + "c0": "0x11dbd9e48380d5e389dad7d518b576593d303a5813451a412f1e5db2e5ba2cead9fc1ebb8d44dc1e0bf9ba52c398642", + "c1": "0x17d03c54f8052c5944fd601d34c0ec982f40c82069e511624e8c6a4ffcce34f6e130b569aa7f7cbe4efd3b1796b76fa" + } + }, + "scalarBits": 32, + "scalar": "0x2a0f7d64", + "Q": { + "x": { + "c0": "0x16e4b640e0629d2e95980ab94dc5ef5ec6443f666c8f43090571f75dae9e0aa5ec3dd8210d54f17839d24133fb4353f", + "c1": "0x4b0f92f48c8d4769f8fcb7bdfedc25ce8e465707da37d1ede7d00141b393fb867ac85456d276f05158c103f3936b81" + }, + "y": { + "c0": "0x813c2c818092a986b03948ba76806094abdfda6a2f29e94933e5afbdb86a154fa284366e4f694d04fa02df586fcca9", + "c1": "0xe1cc8c03a9071f5709c0789277fc3d3cd8439f3dff35b34aaf9524788eb0db2f8587a45f98502970a7b92f11ae6023" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x140e0bc306571b76c0b91cea1bee0e704c993797bd9ef09b7b135c7543e3e78412e89d2f206fcc522dcafdae99f3ca0", + "c1": "0x16e52a8a2318518ad34f7920441adaae2c0e9e0961c14e580c2f3ff2be780e548e49059466f43b5bd27b53d9a934269" + }, + "y": { + "c0": "0xa851dcd3bc962766c930a2861575a049822092756ab12c8100ce01ccc18b40bbb7c225942a2679b61c6cc1ead5a9c6", + "c1": "0x414fb7868511a093332b1f2e45539e491fc4a1ba8d37d8761ea8dbb96285e3d45347ea28a9cc4f968f3cfe9694d252" + } + }, + "scalarBits": 32, + "scalar": "0x75821dde", + "Q": { + "x": { + "c0": "0x18365556a3da0ec7fc264039139a3fb3649123531fb35fb19900da6b5609388c8077b731b69a1e319ac6b7b8fc3945c", + "c1": "0x6d373eeeca0c1003ffb91dcd73551cc5a799d097ce24814fe441b24d4ff816a3fcd0f35c1512307e87695b56664438" + }, + "y": { + "c0": "0x18b621025e71b12568f7e2b0dacb7238be180afcf26cffda24ca95a15fd2d98fd3920033c6a57962fa59edcf5ecdf8e", + "c1": "0x2948c1efec3ae766a9f42b30b5afdf4ec8378249b64b106c54b8b6aff8a62a1f83f6915ab7e2f0ab35d6ce172f29d" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0xfee6076caebba33a48af93ff0ff2b0d4dca52c14ac10a70bb9309f841e6c7be940c338819d76db3e4a3366b789a155", + "c1": "0xb59758f692cd30a1ef4a60438738317d7f7e447bf52d69268d6a264309312c04f4cbb534a26fd26dfff9389e656c56" + }, + "y": { + "c0": "0xc3131bb32064e022936deba38848b8c90cd8b2bf24f424cf04333cb00860ceaa3b6573f2e1afbbddbcc78094e1c6d5", + "c1": "0x18cb38acbb4e2949decf567d31319e2bee249d5afc15a10899e6f7d800a1fc13bf52dd05e69b6619565b7a87e733b0c" + } + }, + "scalarBits": 32, + "scalar": "0x27996a98", + "Q": { + "x": { + "c0": "0x13ecb35b2fc01114a8e489acc16ed2fe6f593728fc163b23ed558cc1e40c438ad9f333e4bb5b902d0c093432f9f77b8", + "c1": "0xf3ee42269ff3f8a95f6aca996a4a3d736ea0d7d086b9b2a59f86c12483d414466f4eb26768d77a288dd6199fe32d35" + }, + "y": { + "c0": "0x1036fcaf12b8fc1496b23c63ab2bcd3f1372fdade10e85deb7f1b8efdc163e6a90d45d51f311c5e1f984e51bd4e2835", + "c1": "0x12a2d5cb588a2168a32484068c993e432c3b0bc003452dfb8b5ebd3b55dd866c7b28bd00aa432d7fb3eaf7810e032fd" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0x22704c5733cd79bdc55e01991b9e1d99418f414167ad3af005aa044cf05a26588aadd7294ffbfba8fe239fb451a3f5", + "c1": "0xe97d735001647d3c18eacf3ec9cd4797a1e4bea316441aaf78950e9b0f17483001266a1673b49f0b0bcf54546ab343" + }, + "y": { + "c0": "0x174d9f8bf0a6b46531250894120fe49f99c63006205759c66d2d8fa21c8a7d576642dc3eb0a690d59dd4a16eec1e1fd", + "c1": "0x165d4bde299a8484ecfe41654c046264e78c392cf416fbc3dfabe4ff46afc965601e87cd016009aa08d4cec952062e1" + } + }, + "scalarBits": 32, + "scalar": "0x5c18cf7", + "Q": { + "x": { + "c0": "0x2032bb7bc961c6044651e9a0bc1c549a007135e4a72ba48d883f98ecfccffa8229f9d455ec916b4d757e3a7aa33ec6", + "c1": "0x6d166177af821677054dbf5bace6ff898d7b87831a659b3467bf6df4c397522df9e9957adc483aa667f3ed6ecf43e" + }, + "y": { + "c0": "0x6acbe30a030ec5e9c6ab94f8d79257795df2f7693f85420d2a194014bc068397ec79b71456771b5b7cc01cdd447a1c", + "c1": "0xed344e9245cfb94a181f77ada0c629efe43f2f9e9a4002ebb023f013734c90a738e8a92ab02ebc18f290223bc7a6ff" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x127f1257b9de0cf06ee355e77f71e071acafa4811f333a6448bc06b7a22fdb51c6ea1b4c2eaacb812ac565da3023043", + "c1": "0x3dfde3aa1a5e4ae922f013813872f360fe3f3dc98cd00d7efa7d349a043bd5b0d48c56acbb187d3222e7dc417888e9" + }, + "y": { + "c0": "0x20d2ba230801cea3303d579d4a52c7c5cf1040d732d105341b1738d885e922e05ec30e0ce928ecb7bb96e1bd16b2ed", + "c1": "0x16f9427b2f7d2bbf7c49df56406622eee18729a836239830c5d86c265986b64cab156da5b78db7eff1350df2909a795" + } + }, + "scalarBits": 32, + "scalar": "0x9f526a79", + "Q": { + "x": { + "c0": "0x1441aafe0b8c916dad2517737fb094b261fcd79c979deaa77b84bcaf1b86a0d8d630199913f624bb03da446a8b736f1", + "c1": "0x84a8fd6fab4eb1a706221f9e1d3a35139c8770370f23bff6419f29b5be83157832b7f0662e0872f6c5b399d3a78c0" + }, + "y": { + "c0": "0x329f0eabb9b21fe79b1c477232124c61a679fbd8c7f24ef31570eae4d39c565457c1e4f995877f44f451cc4e653225", + "c1": "0x153bc5b36fb29acd0b22efa461974d32224571b60ef8304be2224c87015a91b9c09e64d970b052f93be821758fcb898" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0xcb90cf4c8faf216f1a5f04b132e99a11f3f1f61e0dd9e5251d7b06acb6ef7368f673917e32c2d01d511917dae1b6fc", + "c1": "0x33c10db2cc93bc2cd1d86167169dc12a498706338b0d19a52b388dad01cf581b4597105d30727b767831d1a82a3b37" + }, + "y": { + "c0": "0x10a3dba1c7990f75cd99669929d5b5aae30b1815797ed7a1822a3fe9a5ee0e907e614e18f01033c8bc7bbfb889a5375", + "c1": "0x127695926a90ac6723ab3261da97b6da8ff05722ca90ffabe19a5651f6d04036e068c84461fdfb4112b35761c7df4b1" + } + }, + "scalarBits": 32, + "scalar": "0x320d6290", + "Q": { + "x": { + "c0": "0x2d1074ea1ae91d1d5ec6a82c558649145acafabf8267fb0882599960e59ab1f8f6589fd5a48c93e9bf1e99f8f13631", + "c1": "0x171bd7e298a6c797739a2ce598ba3188f34993e09940135821ecfff0d7dc883f8097f9381d7d93b0b087a82b33258f1" + }, + "y": { + "c0": "0xc3be914476a5bba31cb363c36f791c6fa41ad5bd84d35fb3723650e7735b1f1aad3e8439c6e4c6230f752771791a72", + "c1": "0x16eed36731c8201175c8f1f10440205a1c887bf2cb5ed89233c075c0e882ee09c601cf78435917a526dbd28b6a425a3" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0xfd8633b83ca7aa08a49fdc0738fcb35b7c245e8c7d4a5127ae9c785d602219e0cde6d50525b8f6bfecd7b730057070", + "c1": "0x18056dbd897cd66c4cd42d23fa7172add5c75587d021b70a97708aba7eb93369eacadb711a3e7e7efe3e4935670bfee" + }, + "y": { + "c0": "0xbeb037e5ffe3403802c46e3a2430f0e66ef4246bfa11c9fa426c3e71eddbdeb348f7d4095874e085ca5f62af3809c6", + "c1": "0x942a21a0999934ac67db9d81482b6b9547dc2bd75f5ab4d3425e2ad4f6049fb0a66e48de16ade6a23eedf4bce601dc" + } + }, + "scalarBits": 32, + "scalar": "0x967162c4", + "Q": { + "x": { + "c0": "0x1efeda28db5df4ca329dbc5235197c3690198989bea3db9997960c8d53c6881645a32017e67ceab6ff11ed3e3eaab9", + "c1": "0x48727e152c91ae91e5ca24626d088aac84473df509b40604779d74825599f7354281cd5a2ec1909d525980b28888e9" + }, + "y": { + "c0": "0x1ab927d5b585961b327952fe51865839b37dc4dd3c4fc855a2b372ce3ef6343f5d8a184e30760819e7be60832c676b1", + "c1": "0x578946cae4f179f59e19cdf6850ee040bcd4a639d3787009b539ab91c3d2f6c99e3972c3fb0a8200adfd4e687b93d9" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0x16c4c55416f439f258fd626c02ec183231e5235073911ca8af440cbec23f6a8f7db97415a78d3afab5813944071d4a8", + "c1": "0x191ae101a1350af9fd58731268e5a5a23984e95b6d57237f801aa106f83d513037b41319edac599e525d5fe2d85fd48" + }, + "y": { + "c0": "0x1a6c4177ee1bdd603a1b5156985533248795d3fc29fcbf5b4687c57aefe2dad8a845660b3bc3de87c45e4659cdc7aeb", + "c1": "0xfcf143adf3a3dc37a8ce0737b0f26f77a02f36a7e28193aedc97dbd956c363d391c3b71bbd84cb46e86b7c6052ad83" + } + }, + "scalarBits": 32, + "scalar": "0xacaf3f77", + "Q": { + "x": { + "c0": "0x1535182304feff875cacb757474230214cdc5e0a3628861e66c5888e6b476c18567a69ae092f0e5c6461b45702e1dae", + "c1": "0xda97985a9587be1a57897a07abf4ea830f60af64773a906a00f5859acea8f121505d55d4cc4561baa0a49486d6600d" + }, + "y": { + "c0": "0xd23dc18282bc9a26bcb0e8ffdd275426d7c3a5680835d62bafda95d1bbb40b1af1c3b3b60ee185e257826e10b46d40", + "c1": "0x83a18473ede6aeff8759a7b7f1864297c51055a8b5df1ac252c7b50f221a8afcc0daa5ce78ac4ed1876c75d0103a78" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0xaba2cabfd2ee8fa0ada437e5d6219897c19d860485b7e2aab6db56855c746d79b2ea88ac81b515c749b6f8907982f8", + "c1": "0x112259f6d25fc1c364bddd71570f121e1d9ce9228adc6c7706689f16c3e32ea26808436db2bcc3f32cc3477abc497c9" + }, + "y": { + "c0": "0x589d3ac0e3ed53eb3af755c6d18dc10ad8493acedb526bc8656d2a41f3dd14d4737a3d17872b49e0a75df2241ab54f", + "c1": "0x3339c06fe5cd90e34077bd9a6d2298b40ae5c6cdcd91f35fc94a2b1eac20f798f9874a4ffcfb6ebcaaea20cd815621" + } + }, + "scalarBits": 32, + "scalar": "0x572b7737", + "Q": { + "x": { + "c0": "0x1344b76f878fcfb9b2090183608cd7ec858e1104eee160fe47deb43611da27598d832257f9b6c44032276b329cc9690", + "c1": "0x4a63970561e28f3b63bba0c0bd9a183c6955b2b0ac95fb8e3d6b6aa7329d8995159051117ffd6692793daa4a2e345e" + }, + "y": { + "c0": "0x60deff0a50c57fa8c759d8b14f4ec479f7a7a3f4941b17a9aef366af2202d6960e9589d816b24d62d978b7cafe1807", + "c1": "0x3044ff33def762e9990c72d81e7feadf3070afa865820d3ab3195392e070262327f8ca6db8e3bccb05907b28958b05" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0x609dfac069cf4163b3a64824d491c042182ae28913a88e58e1d692e8d8f7d2bf9a5f8b1144cf69b95066cfa55fd529", + "c1": "0x48bc55925398456d75610a4ff7ae54b0d717adecc88372b3f083cd0eebb2c0920c1274366390950313486b9bffaad8" + }, + "y": { + "c0": "0xe4f43ab3d8ae900f4cc8b8c1b55b1921160799a7e1ef9345482c6182dd515c8f1ad1b1c6623bd4bda3761723fcd54a", + "c1": "0xe6b635ef1638cdb8ac72956c41439ba0c7a665bb699df77cbd3470736338107bd24e882b186db8322336bdfe6059b2" + } + }, + "scalarBits": 32, + "scalar": "0xef711ea2", + "Q": { + "x": { + "c0": "0xe39c34a00a2f2b37cae952d21edc81844818da7c3f23e0986e8d8ed5ecfd1c57fd490b4ccafdc7e2d8e5122cb1b35", + "c1": "0xa6a548d74d5313bf87c6f96a52d871daf45620c09f501071ec7b4b1545b2dcd6561aaa1c17fab33a4a22382d7c74d0" + }, + "y": { + "c0": "0x11fdb021a1e8a58672dd43d390749fbcf5827cc0b6f9fb2e4dbe15eb6cc95548e40a3d074f5a0ea98b5f67ea913b9fd", + "c1": "0x62fa9f9cf2718af594ae80516401bd850f959525a8a2508f66d26c7d4be967c99c650f8f0f192cb3221e7934513188" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0xff30008e1519a42a02c929e00c930474d9e59373ed582657b7c5d13542c205cafc125f1809c5f91e7f74f1a0ad47a2", + "c1": "0x173c5f49bfe27c4fd8b738d098b4692db0ed8baba0eb56222bd7fb3aac377f931fd8d307e52dd9f539d15d0baec9829" + }, + "y": { + "c0": "0x48db7c5ad7c4979fb77f9d127e995308e420319192ba1220ada51a00c2450e0e254c67843c592ccbc96129b06f3ec0", + "c1": "0x32209f4735b265a96839868eae8b24ee5298c4fa22c06583dbc8be979fcbab7ec77083e7a16d10bdc93b8b78e28bf3" + } + }, + "scalarBits": 32, + "scalar": "0xce4f854f", + "Q": { + "x": { + "c0": "0x139de9037a19f314b93ee4b33ee1c8e50d7d3f0189813ae907ff46b4cab7eed31aed16143578efba824207a528848b9", + "c1": "0x7d24da9d308b0cd75ea58b82917675316d6c5eb7aeeab9acd7a27ab32f5c2f9db7fd75e1014f297f4c41f743b260aa" + }, + "y": { + "c0": "0x6649abbe7eb03fc9aceab357af21a1618ba381cb13e042ee8ad5e45d204939ad3c02fd5f4dab05dbf3a7164011c3ec", + "c1": "0x148a85173570cfe760d17dd1f07d8e6f1317d90cd271855c22d4ce07997d74425df4f4860331f743d653ea48ed90e97" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0x887e4f32c4645d3cd51c336580ed39da0eef872776935b3275aac2f7e3b6fe5ac80b17caa8123d2c9b0496c736519", + "c1": "0x1fad2f29ebae1b37cb69b2bdb214b0bb921235b35228cb36b8d3b55d475f779043bd3aae0f2c86e08a477b86158ecb" + }, + "y": { + "c0": "0x178700d41095ef0263a20fe0733e06e9b37b28ca39ef45f1369ae09734cfbeabe1b65ec203c0d13458a81ed32a96d29", + "c1": "0x149da9d7c185aca328e1d3b664db0e967dd8db96b82dc6d304555639f1c860a10fb005bf5b2bcea1084763eb1175950" + } + }, + "scalarBits": 32, + "scalar": "0xcc53a65", + "Q": { + "x": { + "c0": "0xbdbfb16c74130df1ff5f17b0c8930ad6d71426a217e74e5a2ccae50f9358d693ba1cdd6983f60dd996103012b3be29", + "c1": "0x1aca33e0621b3a71c95cc17aa427c0d43f6d0becb61a4c61bd20cabff1dfb85cca63540fdc2ae275daa55ae5093ca5" + }, + "y": { + "c0": "0x186b41ec1fefb64f72872a7eb742901f884673ab90b5091e4a697fcc50ae812ee4301dd36543df76a9ba024fc8da763", + "c1": "0x227b503bec6826e47a87af55f93d7cdec4f037d4c744b26dbdc946382c77cbf743e039c8f67bcb062d803cceed8efd" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0x1999a38942e4e06c22c3e2b186ed0f2a4a3f6502ce02899681d3745ce484ca7cac23a2e90899c0cc330024c5209e844", + "c1": "0x17f9b2621362a23ad07cf8bf40cec731ef571ae0600362ca03d1f4816fd75b7a8edc7fe5c608339ac7ae87c1a45e36a" + }, + "y": { + "c0": "0x16d7ee3450a90ed1436102455ae4624ae402692e4de0cef6402c2235eec5f3feeca5cf3d206e362a0312f8531da4a99", + "c1": "0xf009951fe13f03bedd6b6c2268d19c7d62027a9cc5a064c09e909c8c4141b50557a5215d6ef7cb0681f21eefac68ab" + } + }, + "scalarBits": 32, + "scalar": "0xcceb1c28", + "Q": { + "x": { + "c0": "0x15f2915c6d62a8632fbf9216061849a416259eb0b59cd0edc42e056f3a1848e46bc2680d5c3256c63ee017a89326b8f", + "c1": "0x19d024395bf80eb67029ee521e5be06ba04c5235a3cb9e90b43b623a2248287152e7d472744cb6103c91153d9c21662" + }, + "y": { + "c0": "0xd6a2d46b2c5dfff182aa207fdbb6f2b9516ba3dc887111e764f953f3cf4c2c94b667ccf045c9ba30e0ef3b51ebf41a", + "c1": "0xc972607947822f62976bce7fbd4acfa59259acb744b7cede9e3efdf595ab396ec0f9f2ca5cb0b82c654f2b196b4487" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0xf77d2927ef2ce7ad017e9fc2c9ff483fe28a1cfc51381ffa5758fae7960328ae528c74d4e96dfc6d0da18b837c9b4b", + "c1": "0x1760997c9d23ffaf4cfe37a2be68e6582aaa5a85553da43350f7932a9819e9d12322443acf0c78b30148639181e0d46" + }, + "y": { + "c0": "0x4402e2426278ad90c6b3952c82ee43b4252c6e5148d6479b3be0052bae931584dcfa8af8e47d88f92c2bda4c9e623", + "c1": "0x177d81b3a2f3f62bc265b3e57e22fc2c7b5b844c881d10637637fba488986eda1932e86c046053bcf9de76298d448dd" + } + }, + "scalarBits": 32, + "scalar": "0x8a578987", + "Q": { + "x": { + "c0": "0x6a5d8de66bc26d52bdaa81f0cd8e72652265d3362c52c1f6658182fe445c2bee03f4c0d14ca7ea815e3a6cc9b32715", + "c1": "0x6f9b1d2733f4cd873cc3d200a79247faf07ddacf305247621697f53b519e3c1e9bf6c15bcc8fc6db8caa265ed248f1" + }, + "y": { + "c0": "0x133a8df820c8d8f54fa27e9c19ff122989aa10a2f3276eb1173251fc0690232beaf0530c222e75cf35bf9b0205233ee", + "c1": "0x12fedd920b57438c7310711901b40ff73e89d3d20e35fab88396941c458aadc8ce81e6c2cc08e8719c29ce2ae21f1a7" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x10c8fcb77ad007eb7b6c46fb14f84d7c60ff9ae08d1cdec7b3a258bc27dffc3fe16cad116656d276b7e01a8a2e0b2", + "c1": "0xff722eec4098787facf8407aad5c2f34beae7649640d02fc1f680bb4def1513ec3d1c24d5f05f54d8efa8cf8952e72" + }, + "y": { + "c0": "0x147d27f6db32b7a117ec51d3311ecbcdffbbd49714d2ba5fe667886659df0ddc3c8968fba0bfd82208f1c0fb69ca805", + "c1": "0x1666cdb57ef9b82e9db0a45bf68acc90452e3f824118ebaf89891a4bb40e2376ba6164e2cd7ec1391b4386174fd24b7" + } + }, + "scalarBits": 32, + "scalar": "0xdb1729e1", + "Q": { + "x": { + "c0": "0x262dada65f3f0290b4c86783a6293fec54d3ae3dd4f0efb653ef99ef2b859003fba84063d5146d705751cbcdc8967a", + "c1": "0xe441aa5cd2e81f4fcd1668485b5b402d661adfa39009bfd573afe1c03e6f5b416cbcc26930e66c57d01840017d4246" + }, + "y": { + "c0": "0x43e4cabca92f21431d9e0c2f783313b54d094fb14e0837f82574db00ec2fc3060d8218fa1c5ca708683da7b507d4cc", + "c1": "0x938fde18da20ad6184d3018a763ab2083428356d17d5126904e5056d9c627ef667174c9c30c19ae1a3c0d8ad249753" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x105d3cc621257eb337b35e7b89df3d9c077a9e213c3a4850b00291d04829a4be5cb27ed96207c394cbcbbfa3e77ce1", + "c1": "0x10ef7123e231405ba8b121c5102629e115a49af0a199fbe56c24a15a6ad3256765e425e2f46c9504d61729019b217fc" + }, + "y": { + "c0": "0x109c0410f78cd2ad4fe192cae802ec25f5e4f4eb5e34982f5de072e0da2436a21685eb290a1dc1a12ae4fe9f7e2a2ee", + "c1": "0x119768c111c9664dfafaecaacd9393aff938fc527c822ccde40d1e369e5b55342aa42aa31f04f7c746da52d5192ab62" + } + }, + "scalarBits": 32, + "scalar": "0xfabc76e3", + "Q": { + "x": { + "c0": "0xbb01aa71bf76b5d242071e51ed2c6df9f150b01bae4ea5799ceca4bf2d697365729e9d0fe838a2cd8fe555478b6b31", + "c1": "0xeef7dc1a4ae0120d03234ac1d6709c4de6fe6b56b3b3050bf3565894e225e58656e90279a4ce79a10619e1a2312317" + }, + "y": { + "c0": "0x162168a6c241e739e3b299da60cfc02c1092aa00bf0b79d97ef61ab603508207b519cdb6c74cab660841c899c824f94", + "c1": "0x69542e68f69a3a72644bd5c24e11840af01fe68e357d177d773e97e0d643500ad38482dd739f96648e12c2cc820d42" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0x7c5bb5d3043fd3c39beb59eea4bafae1a30296f04a6a0d7caa05faf1cbc1d5cba38d8a30cf14a650b92f02b8f13b80", + "c1": "0x16d9c28df510a0e0d15cdf89bce75c82a723ab28d339164da7edea080abd9d3ec2d45648a4b9e4de71a2d80dee8b821" + }, + "y": { + "c0": "0x1249e85235950550c06cbdf595a162c7214e7242b1823a34d0c6aed3aa4410c14424102e34f54648d6cbb6588b10e9", + "c1": "0x10ffdc4c7ccbafb5cbd03a2af36a7615f8b777950ec17022b047fc5963f5ce9067503764542a6159eed21311356caa8" + } + }, + "scalarBits": 32, + "scalar": "0xc25f8079", + "Q": { + "x": { + "c0": "0xd090ba2993f16a31c37a7e9baec177cbbc071d998053323236a5b946c1dc70e5288a72f3ebc865acaff374142dbc1d", + "c1": "0xd484a45f4f38588a128d913c374750e76bf521040c71ded1c6fa104e7adff7b88722fc7f776ad7a96acbaf61e9db95" + }, + "y": { + "c0": "0x83c4ce6aabe306716519782db1031d927c00f6ad18e9417719f84b60dd9dff1e3670a61badca0e1d9f9a029ab52e01", + "c1": "0x9257046d379a82c37a09d9e40632561382b2932d547fc02220dffb0fd7ba1687e4131195f2bd15600f790611664581" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0x323c56052fa2f6aa6ac109aef7b2a165477a7869b7e14cce0375bef0a57744dfeb8b54d5f541b69b51ed918b57ce3b", + "c1": "0x1187ec7f21d818b2952922ef3cd72ddea71c09a520bbb284c1f3b6eed30fc4378c0fd0b6491896e6a2b6af9ee8c4a4e" + }, + "y": { + "c0": "0xbe6947403cce65ad2a650e8c31e205e36e194d66f8d720f26eee95e911de0656fc99bcaa370e7f8a31de08958d0ac2", + "c1": "0x6848f596482b6a3d825e59607538f2e9b2483a46fb6e4e5d81b8c8e9945c9d455198c7d6995667d196f7a8d6128ea9" + } + }, + "scalarBits": 32, + "scalar": "0xa1d8c47a", + "Q": { + "x": { + "c0": "0x78b357c040206343e7205c13898dd0858534d2377848f96bf3a8b8d9e18f775e346a4a5f0f6b717c397b2f3d1a7aa0", + "c1": "0x800c9a732b2919a7c898234b0093c33fcecafb9c5d529f2db71b290c8cce3b8d1fa7f1a4440a992cfa87045d90a2cf" + }, + "y": { + "c0": "0x18f6b6b496bef417d99c595d2a03c2d3e94a216620861feb972db45851b3450306ef937327621edcc468d9e508373c4", + "c1": "0x421eba9698c9411140f2ff6b7d7fa4c6014f85e328ab4ea0e0ba9d7b639d3e2c2a068d38d1432a600134c513390abd" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0x2700cdbc8e8f6d91359990b5ca0d3895aebfdb0e2c0fe78637b0ddf71fc1dadcc8d55a008049d7eb1b7f620f08ad91", + "c1": "0x993abafc629f94e2a5797cbe777902b940e2c72cd892c353958bf442499ea417b1ea471d0362ea493d53a48b759d1d" + }, + "y": { + "c0": "0x55e5d1e3a6de955ddef228a48cc8de8a18219a3819e6372e9e0d81f0cffd31151e1641ccf92e568491e9d23d562cfa", + "c1": "0x13f6b9d18f18efd8624f19003fbe93120d58ef589fb4cef05b42f7d9b6d6aa68b0445d4f9708e76e4189ca07cde095" + } + }, + "scalarBits": 32, + "scalar": "0xe40ec07b", + "Q": { + "x": { + "c0": "0x157aaa2c052d5d9378d859fa060e1b544fe60582049d8cee6de2ba2b110f2cfa9a60f53176038d61520936d1d0887f9", + "c1": "0xc18829ff5fe3bd5f57fe5cca456bbeecb0a42043b6e2d60860267841372d80adc5e36d4d634b8f6379ca8097bbbc77" + }, + "y": { + "c0": "0xad4865e5026e4047aad6095d056ea6fd0f6de769455ebcaca2d42fff9b46d1150a08c1d471594a8d07ff5efc760bc2", + "c1": "0x121280de67e742a09034c35b7c3238327feca42dce8d7a78b775bb698f3fead45800168513b142405f218fbf7e3543a" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x1769c161eeefd5227cfd9a6365b52d8eb61c68349cb33934ccc63f20cc40de864e15813d6dd641ad57b5765ba714398", + "c1": "0x14b9389868e82c59c53d7cc3a22b8486e314c581abd462447e43b162cd56f3a6398c6bd50e7f3d45bd95404f840d98b" + }, + "y": { + "c0": "0x4366ef73b8befbfc28648810fb6c7717044ed2612965e31245b9839da1565ec139133dd0f7f813c103b0e00471aae0", + "c1": "0x13567696ae740a666481ee9647446ca6f7cf2ae96c3bcca31f9e0e14754ab15a26ac6066a72e8ca32f09f8099573e89" + } + }, + "scalarBits": 32, + "scalar": "0x163e6ab", + "Q": { + "x": { + "c0": "0xfdc363d8cf2c07e55723cb541f779c1bf78fd70faae3b34c2f9f877d85ed4ad24ff2eb573e922cde38136a9ecc79a2", + "c1": "0x164547d501e77e80a7942c44428226b9788f404275c980df68be2c61eabb8d01929409689c67f204644d46be5b0bff9" + }, + "y": { + "c0": "0x2ad01e3e5755ca8d4aa2eea1371a90b8b74ebb95cac1bd9ef43036c957da1010519284d2fcef4b9a0baa2616ea263f", + "c1": "0x314216879062c396bfad457dd5d73bdd328ac5b477c78ba126ab06b086ea991a5fa82c039950b3a4ccf762cdc0f05f" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0xdb842c38de6008cb9c31136b0d43b11bedd24fa88fb44a839343919e4ee67cddc798ef02d3ab55f6f0914ddeccce32", + "c1": "0x185288f58c1cc2588996257be7f4b9c46070e0f80746e5173ccf23c87208c796f7e86ff7a3e66faefb04e4e0d8973cb" + }, + "y": { + "c0": "0x19dfbb2f7cccce60c2295d1c2d77fccb4688a2988680b33002b1d6a1108a8b9e3ec054c268fdbd0fd52504be14ad5cf", + "c1": "0x1510adf213381ce9d12db67dae3ed1e5e0092cab78e7f93046d093b5bae453b4a1df293c1e4717fbbd78352a583da2f" + } + }, + "scalarBits": 32, + "scalar": "0x72353d25", + "Q": { + "x": { + "c0": "0xa5754fcec6172d506b7ad8420a13af25831adfd4ba48db1d8755077422d8b05f618edb911ad583c0c5b75ce84066de", + "c1": "0xb46de7b1a11811c677512db6c7fe79fadc4f09d48c58c047441360a686d5eb8e14e4b51d568a3c206f2daa032f082c" + }, + "y": { + "c0": "0x16c6132c6fc66ae3b77179b60a2b912bf05fda962e3ef608037a90cabb0368a100202aef6d4ef4b4aafd0caefd8519a", + "c1": "0xbc9c0f70cec7c949f8e267d3c3b2d43c5b0f0725715bf01fef0b356f375cc489b82516419dc9bc99af16b9e7c5276d" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x13f05516fd186a5ae2f852338841bbd661b968fc4ac77854beba76634a97def0f82c7660f2ffda499252150d264be1", + "c1": "0xaa9e4b3e552ddffb43a527a702ddd55323a3f92a281346536ed093ae1558366a7ea1369f125ccfd873cb02c4d9b34b" + }, + "y": { + "c0": "0x65d55f9b0e216620432f96c4c5ba5ebbcd6aadd329b87e01bf2c8af75fad523d71f83023722bd356829555b4238ab8", + "c1": "0xc7a16149f70868a8ba5391a4244cba2fece1be31b636a2cef01840bf2d9c2aaaf5c420ab7baed7807e188790b34d15" + } + }, + "scalarBits": 32, + "scalar": "0xc070b45a", + "Q": { + "x": { + "c0": "0x17d2c3068c1dcbde6dbd1252bc3789a7b89dd69615411d9e341d9490ef3fff5c0b3dfade7dc27257db8084329e6a187", + "c1": "0x32d40af968e085ab0833c211738b4c462807b988f90b0ead9dde540d98c8730fd841867405c6c994625a18802ee6c7" + }, + "y": { + "c0": "0x118a3b91d2594a1f73827a17217a5ae7fac819943d36f92b1e549cc1869549f3265431cd5aca56d81f41be986fcd298", + "c1": "0x2d9dd7334291e3a83d064e03de8d4da5c19a61a707d6b4b6e8a58701e8ae1c2b30c233233e663569f20149861d9b07" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0xd15b5bbb5cb53543b7a07ace9390914d356dcd48a97dc89ce4e1408dfcd75d58913af6abe41ef86e52f386d9173039", + "c1": "0xdffae5e86d2a8d09834399fe8f867eeee308d4067fd80dacee018b7d03c75a15c79830b74a7fa4383d2e7349eb3aa0" + }, + "y": { + "c0": "0x4bc7ae31b39c80a2e12ce1910e588ee4da7c5b022f83fe4b97957c386950614e1fcbeac7e140d4b806fd0c3e4c2415", + "c1": "0x51552ea46537b4861ec6df4196238ad128f6be5f97b0a0489809c85e147cfb5c33bfc6486714b5eb771da468fe7736" + } + }, + "scalarBits": 32, + "scalar": "0x7beb4639", + "Q": { + "x": { + "c0": "0x32b81dc77f7c6655e7ee2ffe3513f4105ef4ca7c22dd11415300da9d0ee39ec87232428f88cd5381cf6d7f0bb8fcec", + "c1": "0x1820d284c965607538e9118e8a0edf63e6c082b50441c086506028461e9a7cd47d29cb8e4c83e4dd330193f615c0279" + }, + "y": { + "c0": "0x138cd539ea23c65b9d46823513e9dc5e75830be6c72a1cb9ad3c98e169a595d4a282fe57fcb8ba57d4ce6a575282704", + "c1": "0x1e3231a8c67557f33567558f943b92ad9d416d60ba950eee4cc646bb11597db83c147d6497fc70cbbf50591bbd0a91" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x38168c01fade76cd79f6f5eea40a9575cdd40f354a61b904a13d20b5f3c683ecb290cacb158e48e7850e3df09c59cd", + "c1": "0x10d89be0c486ec13f082746dde909134f717571caf9f6b59ac3868823a09a198eb5cd80252d8f9a3f0841bdb19d2477" + }, + "y": { + "c0": "0x91bff134f2886bef8c37ca16984b362aa042877d9ccb1b91a09275727577296b5c344e4e10a3c2a08e9f857262a3e3", + "c1": "0x2d6cfd243680cafe99c0f79f2d9958af0b6f916a16563f8dffe9d4f15bac1f1bc158a81a3fe219fe534d01b2ad4b9" + } + }, + "scalarBits": 32, + "scalar": "0x557c3f83", + "Q": { + "x": { + "c0": "0x11a817aac318008051a05277c311df1325925dd25eb20237c6e5afe1c7939e5e632597d32989e18b7d331246252cd94", + "c1": "0x24f4a7ac25286355f377c19ba7e6a4b09e80e610e3c12a2a018581e68ae6f9a172b7a07f121ea8ffb1fca93b380e13" + }, + "y": { + "c0": "0x2d8fa9f0b23ebcbd84e45e9bb68782c8cd278959ed450312ced8cedc929c42accb8c9ac3a6983e4fe0aa469a430ff", + "c1": "0x3f9db4b2988f8c037bf858f0301142ed7d22d89f3c885c1e950308e2a219371963d0b5f2384feb75f56dd21a366b5f" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x13a343d952584d64749f1652351b760b1313b634a8fe8bb3fd9a8076297fb39b2e713de84bc19df01c2bec02fe08286", + "c1": "0x1518b751cfe0f74312e7bffe1334a87ce49d7e7ada9ddc10979e5b33e3003ec06b300989cf234d8b5358959b5f1f21f" + }, + "y": { + "c0": "0x110dedd0618b2056e9d6a83496882bdf62a4507bd4e7fe4137d8de3c45ba1c1f22d30983b6987ffb8ab6c38f4bf3998", + "c1": "0x767b0ee15c5143037553ca36f7d64c13c708f980b5f2c26438b1c0fadf4ad9e6163638b8d96b3ad754d09506ca12f7" + } + }, + "scalarBits": 32, + "scalar": "0x164a6bee", + "Q": { + "x": { + "c0": "0x9ff155b778a84a40588eb023863f1c6adb0b6f60090974e772e4578851309b00ebe483f049c0b9e12392091b70597b", + "c1": "0xa2e064365528c94e71516ca61ffc1bd3b80adcd2dc68f7cd754502f0c86c80cb44b4586bd260f78e87e6d8f1f5df4c" + }, + "y": { + "c0": "0xc9dceeae37480768d8392f4a2e9a2fb26345a023c4ecc3ff2fec223842b6207c9fb2abda7664f6fcfc03650cb69658", + "c1": "0x1154af0aec5731e0fab54c46fc7e1cc28a60f23fbdbe376b951bd0cc8cb11afda2529d997b31fe5765816b37a305584" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x190458c36ceac1b1d06ef1b9543a7d2d050d2afe114f7a9d15acb57a94181948eaa0046a65e42d5b94c6c789384b7cd", + "c1": "0x19ff488ad47d2ad6f478f7ee5f617f10f92ddd9270627b21856354223bf8ddaa00a79e7832f4c102a387927b5ac9a69" + }, + "y": { + "c0": "0x18bffed9509441d71e0548e1ba55386400537b4038db40f0643516801d684a3d91beb63edb477bf8428b056495c7cf3", + "c1": "0x42839c8a1555a7c5d459312cb008ee7bb7222fcf1a117e9f290a649fe37232c51447f8d5547ce5c9ae477014249edb" + } + }, + "scalarBits": 32, + "scalar": "0x34d87dc3", + "Q": { + "x": { + "c0": "0xc93db5618b6c381dbb4c9a09f2a5769a629536d7819d87b8a948a403d47e301ca4b1376b4baf7b4baf85f2d1b0b33c", + "c1": "0xe003857d584fa502740b9e21d23adce04332973a77abdafa72e86cf2442a8fa9061532d39e6907973c905e0a658d9" + }, + "y": { + "c0": "0x10ad2ba8576866a33c297068720d8e119f94db468807cfc236e5f03c65ec5d7f28f58ee46797799dddce529e4a18fc4", + "c1": "0xe196a9a044988d41d0afe25217c58bc0ffaa2dd21a3f4ab5c5e24c7f524314e5f7ebc5ed282ae0f92e44eb69f97bb0" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_64bit.json b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_64bit.json new file mode 100644 index 0000000..c0614c3 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_377_scalar_mul_G2_64bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BLS12_377", + "group": "G2", + "modulus": "0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001", + "order": "0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001", + "cofactor": "0x26ba558ae9562addd88d99a6f6a829fbb36b00e1dcc40c8c505634fae2e189d693e8c36676bd09a0f3622fba094800452217cc900000000000000000000001", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "D_Twist", + "non_residue_fp": -5, + "G2_field": "Fp2", + "non_residue_twist": [ + 0, + 1 + ], + "a": "0x0", + "b": "0x1", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0xab080b20561040388b5b0e22af3c27f68ad41d5bf57de5b89bc5fd688d41b7949daaaf78dc87ff070f3be842c54232", + "c1": "0x1a80a67d56d1e44ebeaff0b560cc05a21feb39f02bf32910125161a665364ddcd2417183b7970563991556cd7f2f046" + }, + "y": { + "c0": "0x16e3a6b142cd3ae7ecc4e8cf253c99354d65ff2b734bc87d6aa4e2a92eef56b20f70eb39fba31f3908526e5e3853a25", + "c1": "0x12eebda917ccac5823163ef8e49b8b67f72dfd1daa7f9a1a3f62918f7e82f29daa9b4efae38487b7faa01d949896369" + } + }, + "scalarBits": 64, + "scalar": "0x1624f33531e78a45", + "Q": { + "x": { + "c0": "0x1e54086ab759c74afc065c2035562e37f26f041df725d36209f4ab9937816ab2eae089aa8b148b03ae93167d558fcd", + "c1": "0xe3758b8c3fbd7f92486fbb79e2074e921f6956493849c26497c6dff498ad92eb4017b9357e4682a3809005ea2ab76b" + }, + "y": { + "c0": "0xe28ff9a7f3f460af7bd675816693149d4017f683cb221502f0e21a71ded0a10332b4a4eeafc8eb396af0932f640b0e", + "c1": "0x11b227cec41dcb953440b2c96029a013406e605188059d0a1388ccc1feeea8a8442cfea6fe5abc5d1421cc95273666f" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0xd75975f545c7c5900dc5a2642be0bbee3ecb904d38821eb5a01bfaffc4f4b783334fca4c778a8d367753b6e3881b2c", + "c1": "0x65f2eb1725f15b6bdd104a70cdf0c8771b16fc4e2fbd2717d67cd198e9128b6b0ee4fabe4dfdcf4eb2d8b082ea6ff7" + }, + "y": { + "c0": "0xfb01afb1e68ef6332ab065d00cb7fbab7e0b76f5416a6e2e3d9bc64efd7a57d0364c3ec1a4e9dee3f84b223cd8261c", + "c1": "0x14d1dd2521372710ad55703ce90e1b5f679e012df88b32c8b8f687ea22c68f95a7d43bf13c3a84ac77965c4547a5365" + } + }, + "scalarBits": 64, + "scalar": "0xab50420730311af7", + "Q": { + "x": { + "c0": "0x192b8360dd6d801ff55c0569bdd40f86e48284b3474ba053ac21336a0a6b89934f4c61f8f3ea658b7299eca3b5a618c", + "c1": "0x4e299edd393b4fbddb11e5df14adcbb1052dbfe3b639ac63052acc9497240d4adeabf54ccd509c1bcfe35403cd16fb" + }, + "y": { + "c0": "0x2ae1a958580f6b489991831f7dcbea8356cae33f92a8c45c2c883b01ae2158dc9656da80d4ed1f1b8421131e713e49", + "c1": "0x6811ecde9ba97c95bf7bb0f662f6a69d2559ec3ede88ed699a13a276de053c35da606e03a9990a0d46034e782c95ae" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x1083d45ec93f553e5f25cebe8237f7e09517abd7667cd13055b89b3ab5e0d06de8fc45a61539659a5fac184f4cfc8d1", + "c1": "0x1ce850af063922ae1be306a550bb72f0f6e1ae8e793924ebd4abd185b9acc096f080f4bee204d521f0432154661878" + }, + "y": { + "c0": "0x9d591c3bd786221e57547f0494b5d38fba3c8a935913950a6c971507fe0ccd2584ea94c5deada3ef0a04c4aab380cf", + "c1": "0x190f70865ebe858402bddcac2481060597bb99acba060516525034684752d641c914cf6ca23ff33df7fe95548709e3d" + } + }, + "scalarBits": 64, + "scalar": "0x911d182ec0eb99ab", + "Q": { + "x": { + "c0": "0x4ec2ffa10f731d329bb50fc8025ca4f5e71aa7583f141911cb0a7e33415c110e2705de0a16bb1187455d1eaade2e50", + "c1": "0x8139c1e47d58d9bdc6fcf9344c08098ec024a52485dcf0f4fa43f4752674d44011720b564b8aac27039bece125ca" + }, + "y": { + "c0": "0xd38e48f97d7cc55847e3ea6398203ac71c8238c67b37e53dfb0025a31236504559ea2f0225770b261cb45dedf6a955", + "c1": "0x1083ca144ccd83bcfb76517cb7bdcca10ccb1b9c02af4601fecd4b6e12f9a359997a5c00f4dcf57cd37f935c22262d2" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x8ce7d16a1669124bd8f824aba010aced577842c98b24d2d2c3a54714d34a1959591df06fbb49e95f224df79ed6a4d2", + "c1": "0x197e66de3c17014370dd79dabb89f6bc9d701a3f1b8e47060b4855361cebb9895a296aadd7e6b81c64307c710f0a691" + }, + "y": { + "c0": "0x16b2cd9d95fce5e3755ab79810577553e8e2d37ab792cf88a17b4ffc02cbbbee57367bea1abc0ed243a1cd26128a347", + "c1": "0x9efcfce8b0063c5d2d1bd246da8f96ba8de2a2758ef9585be84e9482bc58892f0634982cdb683efcecdc6eb043fbef" + } + }, + "scalarBits": 64, + "scalar": "0xebe904792d43dfec", + "Q": { + "x": { + "c0": "0xa594f4e1c642a37e224ce5702f9ff6443de099923eaaf8714e11a0fa2ad13ad986b3a98749746ebffb6c8f40dc306c", + "c1": "0xe1b03c005a13ca0d4fb3092fcf973b0c85896cde7162d731c41fe43e336774b6100194ede34cadffe81c2aea13cbf4" + }, + "y": { + "c0": "0x330163e144e4f82c38e3b776d628807798d8fa01b06f59552b7965ad6c81b28e3b9fe49d82ab61d65a1c23620c1cf4", + "c1": "0xdf48c90ff87c287744dc1539e5fb1a90882fe05a4fe76963a0245278aa492f06ff1ab71d9b7095e000db889fb3af74" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x124905191c10b49a1ca6b128aa0304645e25f0ac8611471a788be4c0f4e0c5c0af2dabe1eaf53ec57365a9df8748b29", + "c1": "0x1702430a83df3a852b06e597f92f4858dada360745865f49c51ca1e4b284ce35682819fe1260c50079d27ead3a24387" + }, + "y": { + "c0": "0x5fba9a9a5cde550a3068770ea5ed966139cf7f3385048d07df077fe224fca255ec928dc885b2ac58967306cc5d7df1", + "c1": "0x7472b2ada2c9b5012b4f7e24e9c7cf33a2258bdde76c89e37a7cdc3e32071a1858e3fa3fc2a4c86e6d3c8134f01f20" + } + }, + "scalarBits": 64, + "scalar": "0xc2de121a3406b734", + "Q": { + "x": { + "c0": "0x1129d0498c386ef94c4396c7773aed78c7c8e3303069bd3bc5213df9b827d34c884649655bd287afaf330e74232ba93", + "c1": "0x4360f6399388523401a9340205e7f2e751a56e564c80fa78ac82f8396b28ee04e093d384944a7d3a1919629e1535ef" + }, + "y": { + "c0": "0x13510cc6fbefb5d84f5a20ea0bdf2ef7c58db17224c5b3af123277f5044d1031acbe6db4d662021838c002d79f2cf2c", + "c1": "0x106545e77972c600357a6d17937a5bc5876869024b074fc003df81b5e402e40a51eef8fa5a9afd89cacde72e99fc66" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0x7a6689b91f601b1d89b1b76abf9f9c14f4d96eb76d88544891e24e764d64479be9f58337c67a01a07b86c7c5aa317", + "c1": "0x1fea36f076268c30bd01c425039ea4c35510d9f3ae778441e5040544c032b3a50f0898127791049a01b5c475e16f7d" + }, + "y": { + "c0": "0x13893c701cc64cc8ebe25b23bce3caacb2ae634e41bf58deac35548e5d9fdcef8f45bc90b9e3e9e279c9326d74b3190", + "c1": "0x10782178b2fea93b1ff9e9c8ce25816e5c1ca2142840c66b8a16ec3005d76dc569afa39cc7e2ee0a51f3703d05dc47c" + } + }, + "scalarBits": 64, + "scalar": "0xef7a08e2f38447a3", + "Q": { + "x": { + "c0": "0x18213bb011c15941b5850b086f943f97adfdbf23b356bb7f65c974b41fe4f0f409e891125ea363e05efea039f866b", + "c1": "0x131aab114387fa9442b617ec7266b0858abf4e5d73ab435d3188bc9c0f07c512ab029647cef8dc4c3728214a058f525" + }, + "y": { + "c0": "0xe73a443ef34ba55bb9a8863271080c61e7d0739dcaddbc51de857c7c6844b07ca225ed9675b1989bc5dab72d9d4c36", + "c1": "0x97019b415e90b8de59ee22e0253800d1f2aea420077cdaff923123611819e0740b795a744623585b0e20713b42c7cb" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x141bd1201cdf866a827e8087e3700a0aca14694bf237ba29b7e888ac475b001a5a434083a2d6ae42855bd9ffe7f99c6", + "c1": "0x72521057219e11320aa47a66b9e92cfc7a145329c6b375985cb643c3d4e594f1fbd0d9d2191d0487684591d3ccae84" + }, + "y": { + "c0": "0xcd39f88beef3d00d728c366d0246cf13b8935270ea4e2e68e2a0c3eb102b09d28ad0855ad2fe13a5e98331fd2cf147", + "c1": "0x110e5777fe817387285c08260049ee9479414a5ff7b9065ce3204b2afc313f560e591a4ed60149b5a222018531ebc49" + } + }, + "scalarBits": 64, + "scalar": "0x91a297cd258f5fc8", + "Q": { + "x": { + "c0": "0x1a6f65e9f7c6e290cc25343ef8fba724e1f6e99e6e4a1e9527df9c0ab0f172fc039f519aa23a1057454ce5e3dd2102", + "c1": "0x129d62762e1a3b9436857134a3c37ea8cfa526dfab5ce210c1d099c5faee3e3a3c80bdfee86ec64295307a9e847d331" + }, + "y": { + "c0": "0x98406ca7b41eafecc33402e22224673990ecd33db64144cdba5ba76c0faf640a13910ad7882273686cb85fa49eb3d5", + "c1": "0x16a1c117bedb9142bf84fb956d8172f0ee73a0a42d3297cb0f6210d11e3225157a2f3ed3824b47c994673c44948f2d5" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x17b83961fdfe7c7ea87e015107c81122b7c9cbebb6bf1b110b71629efab5f1acffd1b3c97272011abd6ee8911171c04", + "c1": "0x17e7ffa25da9e4e71977799b8f62cea249abafe2e909d8017f7407c93d3df7fa791f7240752232132e94901f9685fe8" + }, + "y": { + "c0": "0xbfb3f30d824a2bc4228334e114c620d929c00fa0fb9cf056d07e7b96514fc45cabd37bb5e0cdae8181f4832eee83d4", + "c1": "0x5625581ecdc74c60f92540eb7b0936a2d1b4a6e23942d90a9b3fd05f0082a4d09149e511c9f6c0dbeb75e5685504ca" + } + }, + "scalarBits": 64, + "scalar": "0x57c217ff73b58602", + "Q": { + "x": { + "c0": "0x95903ef46809c36bc1e2bfe57c9323332463851b27866e079387cedd7e3d03efe508215c6a38c08dcb54aaefd6fce8", + "c1": "0xc9a97c90b729d0c01a1e4d1c6ec6098e7ae846729497ee6daaea7425b602acb3d80a4122f382c6478655a5b01992d2" + }, + "y": { + "c0": "0xac1c7887007ad0b69ca6610e132cef7e0609ece12f61905e7972370cf1ef5be943e9d17417138195ce4ad7c168865b", + "c1": "0xf05ab4d70e6c33f92240d790af3981d6f6f45d426bfb481dc64534c9be16dc6ad3ef83790a2d260ce22d30ea489b61" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0xecdee1daf8607d0813a0b056df4006b0e51ce0e0fafe5b9dbb92cb231149ea0b32fbbc35b6e2c8fd92c7d03f8567bd", + "c1": "0x1708adf355af9d7c6ccc54ff58030b20004bc46000327a4b814eae250e7c385984b64b414b7aee38bf702f5177445b7" + }, + "y": { + "c0": "0x1184b105fb54ce829efc26813ba38b1fa765a90764ee90ebd062ba9954e50490f85df693f4764599329cfe60b55c726", + "c1": "0x5b9180de1b4b23c02a781c1f79eb24e0f5e092cbfbd53ae03f970e1ee162550b98a6a9388f9f224737aa455b3b4945" + } + }, + "scalarBits": 64, + "scalar": "0x9dbc592a8284b9d3", + "Q": { + "x": { + "c0": "0x8af4541a93134e7661ff495fd70d69e71225ec18fb329b9440102667d9d3b41b550ae760dc591257a7e70397108cf7", + "c1": "0x8eec876cebdb6120de20413b0b7f96d68945c50508e6cd7aa06fecf8a169702bbf8dbf8d894bd973d03271e9da8586" + }, + "y": { + "c0": "0x17d34b84e0ea3948e5adb63ae4af4f13c1d670bdbb1ab80355f4207088a142118573069d524b3688385490fb6bcc72b", + "c1": "0x6596bb50993600484007a2f3cc01b5957678aef86491cff268433cce6d61561d659275816a9dcaf2052ad1debfb28f" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0x10a71421240ac1ced1a41e6eb15d208a5e2fc4ac0d9ac65173f4181ddf286ed1218f44fa0c82d0214d3c22d455fa094", + "c1": "0x7d97fcb89845feddf3328414939570ed33bf6a6b67587f240db01a1b5fafd04503106be54f099207fc6fc59ad8c9be" + }, + "y": { + "c0": "0x189a4df6df515e5c6a1be69426ea5dc2122fbc6bebaec7854aeb0b2f242bdbfa18467ed75f0e7f9be02ce603c1f4006", + "c1": "0xa406a43a43e715200daa17fbb721d3408bddad88b6a3a35f00c8bbb36f4203b7eb0348f8e13b83fe2dcc29c27f345e" + } + }, + "scalarBits": 64, + "scalar": "0x87280f13f4def17b", + "Q": { + "x": { + "c0": "0xdc6108a15a38255695c5a8d26fe47054187ab15ed5713662615d7fe3e9c7e1d5d18dd6dbd25c32c0daac7f56c4201a", + "c1": "0xd2ed2722d29668d13ed5aace17af68a22371c6052aed665fd460da17d5b228aa6fdf1a545159cd07983f50b38ad73c" + }, + "y": { + "c0": "0xacfbcbc1d5d0390d4717db097be4b6fe71bbeeaa7210fa6e9c82a2833710f0055ff9096ec3d4eb2b03ede3d1874e78", + "c1": "0x136a44d41af4f418cf784000f4439536d7bf99f03499bed4978d2322a9749363ef72e8523dbbd7b2d96e750fcfeff53" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0xba4db7486bb1e18301d51a184c8a9424e290ab47a6e8089700a404667b610f7bb2e55c1b434033c338ea2f2a28a2d8", + "c1": "0x4d0db57e2ef621a1380b476d4401f26d5a1952a9bcd42e3d84bd110b584428e754e2a82d3208eaf6cb90da7f7881a0" + }, + "y": { + "c0": "0x821f1e21971a55b597bc6846544d11dd3d3f8406b3f3d4e483b93e5ff1663cd7141cccecd4e48cda78c29d61399c4c", + "c1": "0x140ae66e1acb8ba26bef7d9792dd87890fd19d98a41111fa174ea704b2be408ea47e615cf3dcf943ccd71e64421a76b" + } + }, + "scalarBits": 64, + "scalar": "0x4653366d15325d38", + "Q": { + "x": { + "c0": "0x18dbecaa7a319f7a5fe10ad4fd0d6abfd6dae9d92201f37e3ea721c90281644464c469eb2745304db7580350757efc8", + "c1": "0x152a741a4303a3dd1f15239fe6aed6fbbb0451b7f51fcfabd78bb3c6312a3182c45cd5da139a80338dadae2daa5a676" + }, + "y": { + "c0": "0xdadb2b3ef5094c973db120d1bb294baedd1a35aa9804be7fee204f35ac0f274f3c155ae7f2aa951207c87b54c1553a", + "c1": "0x10cc34814a5f269e808223d383968afaa8d61462c86fd244179b460ffe6ddce2d8fd0a8c7bcbb1a2fd8d41fa6bae3e9" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x7db006286c2f7541945f1279aef49502d732427b84fda8f8681c520a3692ca6518eeae9450c323942a1c31c318bade", + "c1": "0x267842d4a3ac891f662147848aad6ee52fef266003c34fc4775d34af0108455cbad70ae34520a567ec1c320bbdb650" + }, + "y": { + "c0": "0x4811c32969b7631372a640929aff1d42991f07cde9ec0271f97dfc145465d02c3989284457a4a6bb575c7a0fdc157e", + "c1": "0xbb1a4456172cd0aa4a52a1c8ad8825265d9573a0ac8685ef7fe01763fccc69ca3f3f5cbe09024bd44043a1dba3b98" + } + }, + "scalarBits": 64, + "scalar": "0xb2202d83248c16cc", + "Q": { + "x": { + "c0": "0x514128f4290a3af1207b8aaee50397f0232e9f794a14c43bdc2ab9462ca83e37b383a01b15dab72d132e577268f479", + "c1": "0x19abf7a35eb8f3bba0e1ef9cf09e8eae2d12b8a88e790cbdff2f0185bb3341dce0ec5abba0683abd6327d545d137e67" + }, + "y": { + "c0": "0x3ec67c446afe323c8cebdeccbb99b090cc5495fc344d90a7f17d40b81a821acca19ada5f4d5f2f2a411dcebe0c9e89", + "c1": "0x6ef728c05a895fea69782324994bc628e45afaa23ed15c6aff8b088a84b3eb6861430760aca82026e04b526d1f5e1" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0x115be6b28e3f68d7f9984b3bcd9bab8cd3d161ad8045666e0ce33f83a5f11659870dfda7c27661d584c52fd1c73cb82", + "c1": "0x1207143f7cdd54e04da3759b8b35f775db66f5942ea32f3fcf600ae829e6cdc5a53b5fe4369452ae4272ac0ca9a578b" + }, + "y": { + "c0": "0x85460414e7d70a8f196717d0cc8f6aba796fd7543dfe6ebd4ca7244ffb223d26777be6d052eca2af0ac8fc2a2c5aac", + "c1": "0x1ac09d01edc222c21ccc28fda8acf83d25cce919253babde8e4bc7ad2d1ff4e016bce408899226eaf16212ad1c15ba7" + } + }, + "scalarBits": 64, + "scalar": "0x98c356e18650f56c", + "Q": { + "x": { + "c0": "0x17c5e11d7a6caa6d95b9e96dc7b40e2f3b5821778a5af1af5619a29c3f742d9543f5507334ec64902188454ca9ad1ea", + "c1": "0x1ae4cf05d6d12655f6c7cc194c012cf223e10e7fd6971c96f108c99b0bd247dc65b981532933d8c5bdce785bc89095" + }, + "y": { + "c0": "0x52e65c977404ffdcc3391e8d8851a2bf4b657db8984dc5d91a19dd3bda9d77080781d683d63b54ff166f6c8349fb3b", + "c1": "0x1659fa9cbcff12c92e1fc95c18f28969112b942cf58f1e8ba5f1af691ef7ff40cb24709d3a47c2c96f6ff6c627c48ed" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0xaa285700456ad86fc43fcd226c6413781fc06f7c6229556b031daaed66bfa848ae8c691da48f181614fdaa93b9ac2c", + "c1": "0x126f4a4894df06e5d84c34a11994946e35aaaefe637ee9c19db3b979253673141df70860b7f97f54f0a5a15672e87ba" + }, + "y": { + "c0": "0x19212742b3f9356d2c0bbbba5e2198ce14526d777b9d3c44dedcb9ad52e3b5fd6e8f8d2ec5bc0d82d6f1f35185796f8", + "c1": "0x80774a068a0baf04bf72aef8b026c76e442ecbd9fa81f502e89e4e6a116c4bb7b8aa0f515b03814ce956763db1ef8a" + } + }, + "scalarBits": 64, + "scalar": "0x622409afd6e0a731", + "Q": { + "x": { + "c0": "0x5512165515b4b2991967e0bd4446be19cb2d8ae1cd0fa71cb08c40f2eca085f9b88816f1d6f10e69e52ce782fb9b67", + "c1": "0x18e84814bc823129d40c8abd3e82e667eb18ac8697564c6f26a4e097e5993a2cd067ff37b8599dfa6bc5c624174cb66" + }, + "y": { + "c0": "0x6b1545347ba1599699c481671f9838c7ec1273aaaa08df3474a32c5d24d865ccad7e8d9ee74975ab3aac0d4523eb21", + "c1": "0x181d0db690980cc2629fd34f6b42d494059f640ebf6cff4c1c8655fb7bef47081c45cad62b9bc311f1a3f1c5774e4ba" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0x6f608fa241170ce9617e3c8eaa0fa7e7c8ca8d2c68aa5abf2383ed7400c46363bc0e7e451d7862d5b59aa645fce13a", + "c1": "0x148c43ae9126a6dc20a4ab8e7af4e018e682be7c1f1af3f538e1062b318b055bdd248e5483a28892f4d3c7f007a9cc0" + }, + "y": { + "c0": "0x1803ab70e83697168cd3023a49e510b208b09e7f9f9a1ad976923c596ce9a7c9dc81959fb3176897d4816c20a75d4cc", + "c1": "0x6463c488d9b25e139803b3c4606479127a5db1d1d7cc94ec730a9bd18ca9a210d055eeae8164c6a532cbc630c39280" + } + }, + "scalarBits": 64, + "scalar": "0x9025e4a853c0e09a", + "Q": { + "x": { + "c0": "0x8374d607600941f04e482ed7cbecc3a9691e38000da80df85901c38419c6737966546fae4f7335247c77980cf2289d", + "c1": "0x16c6b3da1b096c007db2c4807814dbe3266b726bdd0f4219d266c030fb99ed7b3022a450e1938af86f04d03b03d7b9c" + }, + "y": { + "c0": "0x10e6b9e88b9c258a4219d1f4886bc433f50615ed450c58a76875552e9a793f3c14561487b67f8b8171e5b70cc56f303", + "c1": "0x1a2902b8ed78819667a3f506f54c0e967face412da4a869040af5819483bc6d3b8f6fd956443fd09c191ac6730c723c" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x434e0a185e4ad4ca89d4b824bccc1fb3d5bf0bf6c7c98f5619a1c4c99a6731556f1b1d4c8d9b4e8421c8797c53f619", + "c1": "0xf78382a6eb6de182cf1486a08359cc316247472c46d05cb291d0fe439a1ffc6b77a9fdddd59b16debbf09499239541" + }, + "y": { + "c0": "0xecfc15192088828c372fc9e8cf0d1c445d04a44050f834a00018bfe481d636d1cc69349a736e59b670368b8841bdba", + "c1": "0xae5fc6b76351bcc1ea7c4279af070e1c94d35dc60babdd9127aae5001ab15883f7cfeb342e129faa71320f3d3be1eb" + } + }, + "scalarBits": 64, + "scalar": "0x529da4cdec5a5734", + "Q": { + "x": { + "c0": "0xbf911e288874c6de48745853a0343390aef499dea3e3c83d48d75071b31ac02db03a30dcef599ca8493341aff361d8", + "c1": "0x19bb24f1e891bcae6ee39337d805bafb7ad04ccc74e95aa7964fde1623aa8c7769492138a90083b427ad523815d2194" + }, + "y": { + "c0": "0x4d43727a91ffd92726b37139b50a8c6c2880361932893fe3f06e996cc43dd92091c338914ccd4ae304960cd8628e90", + "c1": "0x151f5d95b6301572648aa98fc2014a9d7deb732ee90b5a82ab9ec19ff3cf94f0192c586ce08a394e2d831b89d51bd03" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0xf95cf96ca18f58e374c79cb1f4f8ed8b0842e7636fb19a3e8ffbf07ea1999d03ab8240ebda68d7b36c164ff21c0bf6", + "c1": "0xc053c5f7834c0e47399f0346d2bab9d2811ccb8d999ebaa88e2ede97e6be89be875e8a4a6e1e38a2e6e8e60170301e" + }, + "y": { + "c0": "0x969912dea005330d457b2de217d5f21532b07eed87d3c931890141891b9ccf75572b4c0d8be1f8a2dfcf6312519f6", + "c1": "0x9823dc29824c142a788701f18a3d0dad88758d9eeaeed23bf38df8715ee71138584c594b1a24637f58c59d99226d4a" + } + }, + "scalarBits": 64, + "scalar": "0x51a466622be4c88", + "Q": { + "x": { + "c0": "0x141b98239249a6bd240103d32f028a0bf06dff99e7dfe1ad7ed073b83a07a51193ad79383c193e3fe42fdecb6632283", + "c1": "0xd399570e3073b2651e06cba2680c7b200ea27ceb42ffb9b17d01b2fac9b85593e6b762e16e6b54d3a56f02018151ca" + }, + "y": { + "c0": "0xd67622bb7a2898d6521a7e96a24e1a2751889148c9fab258a1e064e81268f361b92f78579282dddae693276c5cfa51", + "c1": "0x783b67e2108217f0b2b25831c439832b31033b93cfabea29d702c864833e6606408a121666bf25d89b698d1de04893" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0x4a60f05c6989970fd9a1cbe965e6a3cec72f9ed74f6318231d7e2a1741dd427d78db7b1d92811b2f6d49f3e306464b", + "c1": "0x18ef4a353607e340ac9f9c8ea443e45a6693f24cd76606fa11e2b0d24282ceaf19a7c0a546a2e990140cf87069b9e59" + }, + "y": { + "c0": "0x80f1f018bd7586020a1fffaa3c1ab5a816b8d54454da37760ce6db3337292a91aa748f01899e6cf0941bd73f8f71fe", + "c1": "0x3ca494be110e9af4c46c22709f1ab3ca06c453822971204a6c96e6e6011cf7261defe8d54820e16d7457f9f06b0aea" + } + }, + "scalarBits": 64, + "scalar": "0x10abc493a7f86b04", + "Q": { + "x": { + "c0": "0x77e169e63f9eae74d9838e0ca43196efe0729f7d6bd351e46c854a937c54cf302f521dcfba9941a3687f8039ccef6c", + "c1": "0x8bebc3feb5078a15e98374b5d20b1ed502ef13b0b64d496e80b6a9483174d6b31c97fbbb323d5bf5b5252f682f9c79" + }, + "y": { + "c0": "0x3656333098f3a595f7db33e8f1864f78c93856f463a04e6dc399dadc1302d889654796df4ea86ad9368dea82fefbcf", + "c1": "0x156dc75e4780c6a4899d5cca104191f895f0f76fb5dbcb8d621e5fc6da02e5ea46beea3da67bb274a7f2a46b5855d0b" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x1233d23bb6c5be7f0a34a6cc6359b7df78b65fe69c0926721205ff6c17e503678d3cdf7fd47ec4e685e76026628d559", + "c1": "0x61939f30fb2de3617968d5139785d1d06e1ce836df568e845861434796691ccce452c5782ff0f21414992501f848af" + }, + "y": { + "c0": "0xb4411024b7249d8a5464214bd02d86379d9e954ab89ecaad8db7a4714d3240eb037ffbb7501912b17e71a95f0c5be9", + "c1": "0x88d68c5b1b98cd11e7ff1504cb3c20f7f5d66e1f0dde204fa9741f1884af799b04465120411a17639046d5e921b655" + } + }, + "scalarBits": 64, + "scalar": "0xa5832eeb8600933d", + "Q": { + "x": { + "c0": "0xdee876a122d4a3d9ef06f392d47a865b9092784b84a6a6de8ba0739e2d1d98ce76ba84291b330c465aa576d563011", + "c1": "0x86b1fc8296de61645765a893f72fb90201a6405d0280bea47992cb5b14b2d0e54f423e1a3a58c7873dff8ba00facdb" + }, + "y": { + "c0": "0x1525d8f886407fdf09528eaa2ff3de36b8e3e21deb1b4ee34947d815e0334f443aa167463a899880658d311059f3192", + "c1": "0x9db85d65dc5aae2b1e71e77e61d1789742f4564301215861f98fbdf7b2f1f4f796c55bafb0d14635e9ba17c639192f" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0xb9bdb72b62d7d467a74113a5de717d9284e5caa5d6329b071602525d5a87117b0b94c6035d227ff34be4f43beb39cb", + "c1": "0x105995c507a8ac09f28b1835d1f830917447ced06b107f4c03f30f26ba6b003af9ac695ca2b69f36c11201dad595e8f" + }, + "y": { + "c0": "0x19f968aaa78baf9e1c4f6cb1c0a8ce81c1ef5494b8caf3b6a5283faa443e996af2d88e0cac8aae13dd995b19c197512", + "c1": "0x11b4554c221fa4c6afd635bdf55b6e5835ea92df9c55974ec0b745c1f913c1dd472a053827be41926760a1e675ad0f2" + } + }, + "scalarBits": 64, + "scalar": "0xbc9d694f4ae38661", + "Q": { + "x": { + "c0": "0x681316ab160ab4894aff6da069f5cf63bd19a163c1117e04a48d1f783e41a3372f91465a8fa1acc3c982ad3c5a608f", + "c1": "0x16991ce73652f765b8ad4708f0f29e0ac52235f1a9185997fc34d80806f9573d013dd6fc116cd51a83fe07e14779d6" + }, + "y": { + "c0": "0x186be01992b572b512711ff2d3388d863dec1735c1a9426dcc18ecbc7486527d76972c33226386e9c73cdd9b0888ea5", + "c1": "0x7b75d699f85418efdb77c5d12d89c0c088786f907d79baafbbd72e807964cf40ebde7e51622eee2e09aaa0da248547" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0x18c783cebaa8c270eea86798f22fe4cab203bd9f2b0744966e03bdc1e655b89c0533e05313219990f58fa7bdea185d3", + "c1": "0x155aac4b40276398ecb51a3395f4f29790766aa8b8159b637ac4e3b6b5cf0a5cefd806c8e6b21ac6d9b3aad3c348dea" + }, + "y": { + "c0": "0x113ff89ba18e6466a9c066bf5f82ee62f820bb93d7f5251dffc1a1733eddda40b1fde3502f9ddb04ae00abdc9864e23", + "c1": "0xdc5126189cd2dad837f18cc06de4c69beceea5e53a3efd8e780f5384c71d5ab172a1e77ecaeeebfed71df7cfb14a9c" + } + }, + "scalarBits": 64, + "scalar": "0xabcc01ebb8d3716a", + "Q": { + "x": { + "c0": "0x4beec661e12aba9722b58bc8fb86d6c339a64bebf503066f9d773950e228ca889b50236f2bed42bb0c9dc0bdae29a6", + "c1": "0x1734ddac20d5071197d5fb8868942e2c620aa54ef82a84d78458e78958641efe507edae2aaaedb49c54377254dde4f3" + }, + "y": { + "c0": "0x19ecc680f6bc13e53dfa7855997dd14027de51db8e9bff86ef022dc76dbd4b589ccd7ec63a19fe11a9a444ca27dd14c", + "c1": "0x142b9ddd6b93ee4c861add2ea42b97a234ac4e6a53f65be6d25b6b667509c98a27cffab59b2f913862e01fe07aee5ec" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0xef615f742459eb45bcb26d42053ce3778adde161e5424e7e56d29807862ec7325a4eeeca6462a4ab54683012c7a34f", + "c1": "0x2f53fdb80ed88598d3063312a62621a10ad11d5304b644806035688dc872755d67fc048f1a888335ad0874a3421ea3" + }, + "y": { + "c0": "0xe9d524b12935bf117fe485d5d378d4eeee68677da8a407a6e4c3bae660134bb62ebcd9decce50d877a7741ae783bf1", + "c1": "0x4ecd49e6c060d1974c8a7eb61f6ae28e1f89aa9b6ee8fc3d37641bba4312dffe9c200035af2793723acc7485129c1d" + } + }, + "scalarBits": 64, + "scalar": "0xfae2b8732477a502", + "Q": { + "x": { + "c0": "0x166ba78784d974cb50edd391f3ac5f9621ff6e6d3dda61ce29d38e4b783c4371beb21b88aae0ffb9eb793a09674821c", + "c1": "0x115f3bfc4f304e1839ecbc0ad6f82eb72bffbd046f9dcbd60f08792401d71c04b364a9e0b2fce9e06537100013b6af8" + }, + "y": { + "c0": "0x1a45c863c59284e112c01f47fa9761bd6056be3aadf66c79f8249e84e70016031dff0eff59472aeeec143b2eedd5d7c", + "c1": "0x4cff82ff3fc451237a839839abaaff0137364596c0c7d74ab7f93da5b93ebbf064160b7b12725f5e0376f9613c06dd" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x30dd96bb2fcfa738b9ccbcb36f43ffe66ad981ca9fad3ab4b19f187dcbd83a527898ac483682f633ca79a08a06b6f1", + "c1": "0xad73fed39b093a9b77dc19591c971cac077b935f5c1e3752f7a7d7c2ff402f4344221a383186bbbfc643c42408b1ff" + }, + "y": { + "c0": "0x16c5c020271b5e06d582390c258d2a27fa8393616c9e712f715c8bca7fe6a791984e6ebe513e2db94b2b9c4a308bad", + "c1": "0xc7e88b2a5df0fb5eba4cacc6abb90e72b1052eb77b14725086b943728063fa7dd7ae240b2e0393998079f08a07dc" + } + }, + "scalarBits": 64, + "scalar": "0x8f011634bc9c5e53", + "Q": { + "x": { + "c0": "0x345f1529194fb6ca4fcd760c13617030169eeb4c446a29efcd5f56ea8f7ee28d2615cc201206c97fec9216e913cd6a", + "c1": "0xb673c4704eff4f2d33ab5aa092f2ab7e95ce71a28ef42e3f50d6280b6bbf44d48a9a0d29c231e011836f9b978aa4ee" + }, + "y": { + "c0": "0xb06963e5247e9e6a0b96f4af12192ea8a92f518f9fcf088bed8919ffc1f75ec9cb49f5a54e9cc61953319a2591222b", + "c1": "0x11f553e3947911f468df1d991690b1f61a9cc07b71f057befaccbd8a963a785ccf475688da4ccc42ac38992aab6f6f2" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0x8a8477ef80b72cd974294f61ef8e1519ce7ebdfb2cef53cd619893a3ef973e4ee2c47da75947b05f989c4c7f42ec87", + "c1": "0x17db8ab6a6ba78b097964e8165b2c3bff164b2ec6b60f29683f0513797a131bcaa75da569a8bdf4ae4675435508ae8b" + }, + "y": { + "c0": "0x194e03d49a7672d70adfed713b98958c1089636f2d87f18015835d8af56970ed639edb8b31ad2e9816615dda9709c8d", + "c1": "0x89f716ea13886761463120c99df217f8303741de8f0a4abdb9b6d82bdbcd22d62fb871b2f74d8be084b0b52e22d5e" + } + }, + "scalarBits": 64, + "scalar": "0xfde95a6472047ff4", + "Q": { + "x": { + "c0": "0xef61549746f158738acd9ad501b053f32d1dc9034a1fbef635f11cac4f0700cc174c42425be53314f4f49d9d2c3dee", + "c1": "0x2289233a148484dea007abd6cdb6ba01aa2480beaeb167355a4b4e3050074d9523ef0b6c5ac519b908a90a086995df" + }, + "y": { + "c0": "0x1c05126302d80e7f7788c36d0125609fcac283fb852953c5e8df47197c783a31331b3394e6a5d4f9cfb1c2cc8d3a26", + "c1": "0x234bb528fde8da7490110386401b492d946b853b7720dc3c76958be5b5985275ee13a6ea325b983539e099de30bd4b" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0xaffd42d7de6ccf5f591fadf0d4f6c3c0f3c1c87ebb719cc0a6d0a535f7f8ca9d9bcfa81d00ebc2835444ce5805bcfd", + "c1": "0x121898f8241875231b5f7fbabee7300f8d22a9bf4e6989157443ebb6bd7e9a5f0b9a8b38ee2bbe626fe9742744b4187" + }, + "y": { + "c0": "0x65b57722480c7bda30f259cf21d693d2349d0707a7137dbd2555b9ac38d0446b27a8f1f0344e88fee976adc5a8aad6", + "c1": "0x7e3182c7cd953db4f2877af0bd028262f42aa9973b91a4a13f265c7e20c28f236d20f32845e9a9a33cba2dd8d294f7" + } + }, + "scalarBits": 64, + "scalar": "0x28f9d201cceb1c28", + "Q": { + "x": { + "c0": "0x14d1c37a6d618239f12bd2741faa7ce513b1bcbf4963cfedc5218292d98746fa435a643e7a68ec92d882fc6548787b9", + "c1": "0x1533417d2b3da7bac5fc629310f58dd2e4756b0bb0a717d5445fef725d3f4f0be7e70d60b485fff6755e24518e23e71" + }, + "y": { + "c0": "0xc49360f48a2e4c244903e4bbab1a20bb985bb4ee32796f5afcb93d40a7d6db1beb0bca76321cd26270d91608c11e32", + "c1": "0x15a0c3a0426713ad1278a9d451037d4774871f659c72a55a8bba9b65de71e08de92ee8e9ed494c8a76393e86fa08ebe" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0x17ca4ac79dc3ed79ab7b409afd85f8786f08fd599489ca48eceb70bc6a37f4e14931a2300a95e783649b094e7aea52", + "c1": "0x140923a111a9227ed37d810d74cacb66228f76f284eb35ebf98ac41762d4b2d2983ae963c97871e66f427906da3d1f9" + }, + "y": { + "c0": "0x25dd3af759a166ec0f165278bce910a83303873e44ff9ce1bdfc1e0e18512479fa48fd0e27aaefa2a6e86224ea0a4e", + "c1": "0xb2f75a4d73bb9d3c669dfc84bb6ec5dbdca92d11504960393958a09463e9e7114bec512531faf7ce1d865a190c99eb" + } + }, + "scalarBits": 64, + "scalar": "0x183ab1e68e100566", + "Q": { + "x": { + "c0": "0xb313489a017466ab8c7348855f6dc28c59c436b84a5aef378495e1d48fdead738802d632e0ce764deaa3f0f7fb64e9", + "c1": "0x4332e2a2c86bde39cbb279addc6d3b59595ef03985c4c6cc34a7d94b13d60f198f446df20567dad4eae871db422fab" + }, + "y": { + "c0": "0x1aa60a2a0a206eae075da886bddcc46535673a03d742b7d543520b2e14055a1d1becd22ef56b7deb3732daeddadced", + "c1": "0x6a169fa0ed9d4aec455827b19c1fd6093f0c53c3b9b04177142e5aa6812143683c9b4b9768c8c81eb1927bbe3fad3c" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0xbae35b051a7c1fd68a7a479fa679f28fad22239869d3cdfd2e827d3681596bc00dae9f6cd0d3cc7dfcc6c356d6138b", + "c1": "0x10599fe0d44185e58c408fe4844017aa64a5a57722863c0fb1659cc3541abce2791286f45d93daff49c020d4a98a403" + }, + "y": { + "c0": "0x2333c46ed831b54ff494552ed7d2ff06b495461fa587496ffba110e9e964f33ddb14df7eeb367664c3e3df40ef28ed", + "c1": "0x443079285da7f134553157f57335b423d90cb0d5fd00db4a815f39cfd1cd2dc3fc1eea249dea7b5bfa9409d52f2b0" + } + }, + "scalarBits": 64, + "scalar": "0x3549af73a1d8c47a", + "Q": { + "x": { + "c0": "0x13e0c1dc67838994f8e75cad84991b1da849ca01cca025de0b235246a14a623cb3129a1403d9834dfd76d79499212cc", + "c1": "0x11146f983f7c3b175a1735341e6e4d89eee0643acdd52507c3c86e7e30adc957579449f06798b87e64149c02eafa932" + }, + "y": { + "c0": "0x4cb2f8a05c4ada2d84601dee96d3546f06240a9841f600235733f960b029058cf4bccc07f93de048e66fae442f242a", + "c1": "0xba0d53f91589a7cc215c2f9890c3584014a09084dbd0246bbcfedfa82c793410ee0d10e7b2ce5dec524dad22c0cbae" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0x642ed79e7db46645205646e1d1bf7cd1ce95f4559f3586e96ded8f0b4b892510103a8344ba1830ec6a4c3c994cf11a", + "c1": "0x749f9e853fd991b951c2c45ee6040bf642d5a12f0b7370a46999208e0fdfa6ea30a132497f0c0f9a1af73e302de969" + }, + "y": { + "c0": "0x3a329e64cefa4212ab31f5c833d93c30a435c0a683022d9069047402e3f08e8b51f29570b93af304f80145b98f91ed", + "c1": "0x15b866bbfcff953990bf4f28021ae9916b85241c497f5cd7bea98f669cc43339ee950c56cf1e1423f8ee63d594732e5" + } + }, + "scalarBits": 64, + "scalar": "0x8e6ba660f532be16", + "Q": { + "x": { + "c0": "0x1215606d1af0fd95c2af5b71f2bd39262961079e169ca69ebffef9b68404eb45dad3988bdfc74a9c917d6c47cbf4c65", + "c1": "0x8aed7acb362ca25b9f63d693a0ee521d7ba923f4d5754daadb9187835b48df09fd5292ef53e399d424900c8534f79a" + }, + "y": { + "c0": "0x336adbf461c980481eacbd1cc15f3ee15fd893bd85ae63032c3be8972fa0137a1ffc5c3b5376f527a88d4f36a99fea", + "c1": "0x50d0662a278e4e083695ba774a188e7d3705721674538c3d120035b97083f9f4bd6141517e9a6eee4f0dfb41dbe26f" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x8bcb8bb807a566eea3f7dc6f7b9a77f4941053dcbe41ec785f448894f2a96b489939bfb65d05a9572345147353ff5e", + "c1": "0x16185ac75154c9cf80861000696011ab83e6dd69c6a877d8fbbfba71dc9d200d3d5b007d4b8d9cc3efe7e4345cc5686" + }, + "y": { + "c0": "0x1bba0a6973bb4a3bf37e3973e0d00d7b6c637de4badfd9dd42c891045480fa54abfd7f17e80720193b7c9d484f8a00", + "c1": "0x1112aca2930b51c7284fa569a51ab0cb5cda757910f0fb88a5efba8b635e8e4399db3d8238f36594162bcc80750f10e" + } + }, + "scalarBits": 64, + "scalar": "0x834eedab30b9bfd4", + "Q": { + "x": { + "c0": "0x105d84845b178966cc074cac5f1567653c60c65f96b63cd8cba3f721118b74c1049dcfd8e67803a61cc9021e45e4ba5", + "c1": "0x142eb1ced03094286bfca7c937863f434e10b2f44e325c4d2bf6e6c89e8d8d0ba92ae0a5d68d987c79c5fb4aa881b19" + }, + "y": { + "c0": "0x93e5a91a109fb5087d4ba2e221988f0db72c9969ea9e791ef12ec7329e377da52552c1826d2efd3f539dc52209fad1", + "c1": "0x9d6119367a5b75511af3643dd0af3297b5542085413ea5eb39161ae9f8528c4cd94738bf6dcd45747d0c8405e3b7b8" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x1608247992db9fe6a0ab2ad458de4fe7926b2b2b7e7db609dc8d9ce9801ad1c8f74e1a7df6908d5e9d46ca9cc5e9b23", + "c1": "0x1409028853bf7fefa5ca61234d2b8adf5bba16bbe2ae9881702cab71ded5f6191e52e99a4844e33aef804473c547b97" + }, + "y": { + "c0": "0xdca412438a4099d4c599fad51e4a9a2649f8c2ea063429e27b611ab0ac71430ccbaad4e9b6171d40e4664714ab2956", + "c1": "0xd8e7a4bea73195fb1b4ce527839d4c80b57019cd86663cea39f1468319bf75ff4e5b61b88a714e39c944cd309f5cf6" + } + }, + "scalarBits": 64, + "scalar": "0x16985281c070b45a", + "Q": { + "x": { + "c0": "0x16ab7b671e78668b364bc5d07674fbe4ab90b973596ac7b9822bfef1ec7cf895c05bbf187dd985e9d58d777344ea2bf", + "c1": "0x110f3c362e8386ac5daa7a288e5b001e04622cccd5d28dbdd2d8bc2fef6898fff61c3c80f2f981f6fbe23ff7cf20d4e" + }, + "y": { + "c0": "0x6dab16fc9b092dd57396ab5bc5440d86dc1815f7be8ba2c076a69c88a6104e17b2f0222bc7bd3990c66c0bd3300731", + "c1": "0x19640d6e89729c1f79d689dac6a6354c2e80ae11fa762bbac531004f6b826a59a8622557fb976ff1beabe1bd630b2e9" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0xe7fb3d913866d8e4fa84e6206c22a1c40572b080678c88498fe164e9bd37980d72c0478bda3b0fac4cc6d15f510c5d", + "c1": "0xcb3dd519a82d8dd4ce5abb3a79fbf1b7f5ac3b0bef96560c4b2695c59be38eb7adb8a9144bfec6fef0b4a2791e8931" + }, + "y": { + "c0": "0x1f81c4ba0e61aef17aeccfdcb77d153c6ce163b95853218f812056a7efd0457e05e880ce24daf90790a6a807914a08", + "c1": "0x18dd9ac9b284d36c0732e8b8ba0f34bfbcc8da639cc5415b70ad5399ed0b662ad3180b30b408db96efb54f9a10b90f" + } + }, + "scalarBits": 64, + "scalar": "0x4b13c5ee116b1d74", + "Q": { + "x": { + "c0": "0x3b3e7818adb4145d83ec18568cfd411658c7093f9c4ac1c4762d692e2883eb70e166d354a4fda909f8c230e0ff9e94", + "c1": "0x8c8941c5ecf3047b402cb81eced90fced50346684a1ff347b9974bdd4ff34a04d3236764ce1ca0ceeb455b5d14090a" + }, + "y": { + "c0": "0x25f163f02fdeaa2ed6380f19f9f8924e8a9e36094f4e2fd2dca6c71c5fea5ff1c03072c62c9eb6e7060502c2536fb7", + "c1": "0xe89f089402ce3694e3793583b29a2ad5084f0a157b8f0920db8652e0dcb53463691f941b100053b319910f699d4c2" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0xfecc1a60e82676095104d40d4a842da8ebce7848e0978c386cb2fc918c5783e79e6c644f6f732121f65d619fbba568", + "c1": "0x19a3b9a976dc905c604251027f8359e35e6bf3d7ab29265f343cfa7f340d66d78b33bc5d08aaf8661c0394442c18d2f" + }, + "y": { + "c0": "0x139d72650def27d5d9f9e5ad87f58c6584400fcd8ded041f63cf800d4b2f8de1960ed326ecdbbf67cd48aec72ec9392", + "c1": "0x9e830216cfec509cb4225054c4d2959c5283510729997f5af598fec2f222fabad13fa378400937066eb38602c0f9ed" + } + }, + "scalarBits": 64, + "scalar": "0xf017258fc40b9ecc", + "Q": { + "x": { + "c0": "0xc63620eb24190a1c6150d03ceec2b7983dcfa7f65877b761fd3aa0cda06d459dac742155ca8ab63bb6ebdb0aa6b4c3", + "c1": "0x56bbf3fd27a7a6552d3869ccda54fa0fa9e8dfc3be8391cc5f94e0df295bbebed053922e403f148aaef72917b17355" + }, + "y": { + "c0": "0xd8e3fc8f3a0a07699205a6353e272ca39b316468b33cf1198a5fd4d9fdfcd32a740ebbbd196103767ee032e1231f19", + "c1": "0xacc72a565b5cbeb0b2c09ed183fa6441d489b6413790089a4a12a839d6abd36d18abf7ff227ba118d8818095ee5ec9" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0xa1910f2df28f5e176b40bce7ef27728c8c9a4be15ffe3a99b473a8e95b2132f07df797fe3058d648659c713e4e4016", + "c1": "0x1f1a6a70ddb588a5d4f1b6120f0f95dfdaef0c603d61e7e07a422ee035d5eb6625608d457516841de2b84e6e99f476" + }, + "y": { + "c0": "0x46eb45a5c42cc592f6e7f48abf399e68f743d16ecd9a0e34fbcf735453110e6e5aa0dfa1597d183b176edbee7d1df2", + "c1": "0x140a1bf7809b9a5638b4e7363bee03056509e3afaf924a16445507aa803ec0d75f66c09b1e2bad8382ad1b393f93b20" + } + }, + "scalarBits": 64, + "scalar": "0xc324e4dd93c4df79", + "Q": { + "x": { + "c0": "0x11602cec5e0078ae60cb9bd93be02f88c64596a76bcff4bea153deb98f2307d49b3d3505160466db80e7710da7b1503", + "c1": "0x14c62ee395fe228767aa602bc3edab48afd76de05314a2a3f74b75c29137319e26967c778fbf7daa50fcdb6ac94a2af" + }, + "y": { + "c0": "0x11eacc00adadc838d987dd1256439798104684e0b2b960d90c603a4406d3ef203ac363e33ec2cb8a9eb5baae52d8fe2", + "c1": "0x1920e8b4977c82a9ab56f766c6d9e1b3354d4fdf6512e9b34c577c29e13e457764dcf0849ba1a658c9f2ff7fac77e86" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x7a105562bc8cdc888942bd23c5bacc141cb7775b9a35f843ab545055ada631e9623aedb06e237b7fcd63c8234bd4a5", + "c1": "0x1c1c15dca41c4222aadf0e9a7dfab4a3a3ad204a15e8feeb5e77290e29a1191e8fd07d39da5dcb4b89af9cac0d3c99" + }, + "y": { + "c0": "0x598c4c27bd094273d7924027ec408cc6ba1d75d6d1229e68fface4f05f92a56233ad4190887faaf50e5db5c7476ffd", + "c1": "0x12ba1f6a343c97993e305d59606a2921187b695bde640664d4848cbe1fdfbe9c2df71ab8b13e09e6336180ea5626fc8" + } + }, + "scalarBits": 64, + "scalar": "0x672a9b8c4f98850c", + "Q": { + "x": { + "c0": "0xb72aa069095df8259331a9853b6351373f659ecc8112fa57168c1ee2e63ea860e5cbf3e2455870562e42b0afa5c9d8", + "c1": "0xb3576d4ad276f804dedba6e1df7fc790ef2e27f03ba72c6f4675ac3da5d8a77b7e211a4ffc090daa2b34fcf13e6f31" + }, + "y": { + "c0": "0x189d12161e7fcef187862d587a7aa93cde8f18fdcee1298b23b3fa83ad5359fc44a3d00768b87871fb7e83f5f7a423", + "c1": "0x19b40220a5c86c173439a1fc35c5f82ab439242eb20b4c8e482a92ff09155935becee3cbafa1d41ad97359f49493eb4" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0x1173c581322906e3050bb3397fa56b357354222f17e36affce7d1b5b5b267f349086940976b8572b383dc98f0a7fcb6", + "c1": "0x15d90478fc2f5ffdff99474f75fe0cd411e4f773976214b27882a80b9f83d791daf341165914fa349818ad0e3408e59" + }, + "y": { + "c0": "0x140963badc7294f87c314060bd7ccd56a97a484f98dedffc7833ca662c64833f892410f746ae0172c6395c81dda2a6d", + "c1": "0x2b4c85db8ffb449bde06ff58519c3b535c7b3e977b1a4e2ed5045d9120dd86f07c98e5b440c458e77090283f75e2d0" + } + }, + "scalarBits": 64, + "scalar": "0xa15f137a12534d70", + "Q": { + "x": { + "c0": "0x14e4dbebda8e0f8d842783ccd39298b646be8e0a037031269d361590e7490fe9d0278b4f281a526cecedb809bc384a5", + "c1": "0x818e16660318308cb12a32552499b61ad0657dd4cd74e96611aadbb545153d1ddf58a6ee24b6b56c7e95e0a73b22b2" + }, + "y": { + "c0": "0x6c45b2f46e05a80da512cd452fccdfca731a3eb54965a6fb67cc51bedba1bdc33f3074a3c6963e93a08fa20e99ba64", + "c1": "0x6a94aca1b6211df455fde9938e409c29f69127fa4dd05d35c49f186f269fd878e2071be3e6104f784314e0165a6c32" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x17a7533bcb7633ec923b2651a4c5664795ce21892500eeb3502fa1e65c7ff56dcd98ea773b99cafe4efbc94e33d88f", + "c1": "0x1623037a9f0f7de325ed4880e10e5719003c2ae8cce8751874f211b64514838709540a61445ffb6cd8715cf4cc7d48a" + }, + "y": { + "c0": "0x1335377fc8ce78f371f500686ac883b7c6257e7cb64e8821db899146ccfdf9ad11aa720e9dab06328e33eaeadf4d189", + "c1": "0x15082bbafdbedd60d8367e278526ba8970975fabf65c6172cbc3d39d895f9edc5aeb160eaf8f541f9ecc87ed4ca3532" + } + }, + "scalarBits": 64, + "scalar": "0x11a2d9da23050000", + "Q": { + "x": { + "c0": "0xa8cf1757ebfd970b132d6e27c71a8ae2ec70a1a8c40acd856afe4938f62a59e817b3327871ea2e068979a88a55ba0a", + "c1": "0x1c3caf0cc8cf6b673e290fd2b484a625622668dd2c24cd448c44f28fca66b2893a656c1f68e31c42368fd71253cbf0" + }, + "y": { + "c0": "0x39c9dc263d91dde1080c023b5d46ffc80dba7ec9a13b7546a8585705ac80661f3e1c23f31cb2d426b814f847189108", + "c1": "0xa57ae20c2dfb1fc18e7db5075692b60c255b31ae587cf108babe52353337db5c076de4290e5f8ac0d0a3dfc330af50" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x15b638d8511f805e10126c2447aad47e1eb5e55cc3c13837c42b42bc86c93e1d34bdc14f208638217d97412d3710c8d", + "c1": "0x150a8bcae028eda78a904c559e33d9c6d357ba009ae863056a5896ba724ad3f8b7b8e3c00eaa58cd5ffda88234c5c5e" + }, + "y": { + "c0": "0x17366572575e28aa560c1848ce564613f37b6759ac99bae6b7b31831a3cee9a66ca20d70d6c944ba6536b6bcd9548f5", + "c1": "0x4d7b3e32f1480a549e3e417fdc706ed2fc56af837bef857e80efefb2b3db930dfccded431f77a0c44f76a7e38ac0f2" + } + }, + "scalarBits": 64, + "scalar": "0x4d1f5c118dd0024b", + "Q": { + "x": { + "c0": "0x768c3a628bcf252fbb548e138fe87a7f363a25b4d69f960b39c01d21dfac894f3842cb4c204d5627b5aa54c879e9d0", + "c1": "0x8320453a206ff0bbf17dff13a47afbd7b3bc52ed0a9fb9fc9df54949e5b8e6d91fff507a44bd9768c6227812eb591" + }, + "y": { + "c0": "0x1675e879ef46c67b84e9c63fdc3078229b8308a67a3eb690765787d3b89fcb69cef9c7c381abc65a937fbcae7425876", + "c1": "0x103e37ee48e8cfef8e2ea638744d79491825f61a0853446ae7a7414c5d7d567d50ebf549ccdb63d00d2198bf54492ae" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x5994c043568937df554bd139337906f5422ff71add56b00d80299058abe744ab65ced2085f6642467a6fa2dec9d3ae", + "c1": "0xd42d26298fe79a1feb3e67a08830bb714ccf9246dfc24810a5dd7e47556f89c6ab65d4b3bc09301fcf8ee7fba33a45" + }, + "y": { + "c0": "0x4830822bfc7507870a6b42941e354d6b1e7c4b489b6fb181df85d738ad4c56ddc590b820f3375acf52179f7a2d1559", + "c1": "0x11bf42a47133d2cc9a46692ac78caba82ed9b6fa9130a47ebb454c36c02b4716876e37db8b8dfc5fd62aa614f87e999" + } + }, + "scalarBits": 64, + "scalar": "0x1f521b6401cfc369", + "Q": { + "x": { + "c0": "0xe9951ff831fe0fa692ae7a0bc3de103f63cda66e9a1b794130d70d899dc14c605dd395519c5c2d5efc6b07899ae1a3", + "c1": "0x1887d780b6da08fba01ff0356f202304dde4e6c33e0402ec3072a94dfc7a37169fb4ad047919149bbe046ff9d9eacbf" + }, + "y": { + "c0": "0x7dadad9e17f25e820165cbd3ca6c7a8e132441df5d7502c47c341622124628ec677a548603449f9eaa0ebd179bb39f", + "c1": "0x1a8ae0f7a1f67ef7f7197a6b3a51c2838f46ea72b1a5675de1fa8cebd24e61ce1cac2d8eab64a039f2462627933a7a9" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x12a8d92fde0b56b425ea5cedc8e60dfc6afcf05910fcfe587a04ff16fe91457062fca0a605cff064c46c8c93302a89a", + "c1": "0xfb8de093b4ab685ab3c7f918d34a5487c4b7cdb0021b40a557af919649aa1b9e94c0dd12c7995bc426ae36f4296442" + }, + "y": { + "c0": "0x17b0a562a0100fd84c00e98e96f3ac00d6ac07350bab75c5f9fb7941958ce53e64275f1c2343672293b91a753475e17", + "c1": "0x29ce2bfc522aa996b470cbac58561bf663212fb0fbd9338777fd1484b4b7da22591fc0be5c9e2b123f9df3374daf3d" + } + }, + "scalarBits": 64, + "scalar": "0x831fd4a659c9cfe", + "Q": { + "x": { + "c0": "0x7ff0d4f78398f05df87bbe65a1b224aa6bc86d1b072c6ca27705afc37bdaa030fdd24a8ba6e7f2890dda3f8c353fd3", + "c1": "0x5848c867475366fd3ad56f3450578413ed8b71cff4d610334e55d240238c81510ae977e70618a57f301e0140ae2c6d" + }, + "y": { + "c0": "0x710a5b61c53f3326209a4e21978c2ce63d4b09a50d3adab1ed31c600ef382d2c2c0bd97ef59e72ce88bcb43a6996f6", + "c1": "0x41d7ad97dc46dcd79a2776434d4c96889ee8371eeaebbc312320bb1ff9fa9895dd8dc4bc3306408951771a73f652ac" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x52debc5299f3fd222005fc2f4b0659a1e5b0eef3ec82cde739e2493df550be197b34018a0128d98fe2c39d9cab0695", + "c1": "0x9f60e908192e50f12dc1da8a2dc0ea39653c72fcae621658f72e5cf0fd84e776f7aa53081544c7116361d1ef77c314" + }, + "y": { + "c0": "0x10ebb624ffece75f4ac9f90f3650e11004710ce257a91ab416809872af2d1982040153676e456b30c71764d77a15d79", + "c1": "0x183cbb0bc4bd1c2ae6539501f9ea88281f207e6982003560e7b1b9f3f767e7e5c3f7ea54d2b2f446c1fb175afbde805" + } + }, + "scalarBits": 64, + "scalar": "0x7d9e776ac88edc13", + "Q": { + "x": { + "c0": "0x1455194d3445b161ade74b086960fce8ee931e76c4581d999b1e8dab2e74b267fb3ce14ad8599160bee74a47bdaf48c", + "c1": "0x10c46cf114c9fbe4271e30964400674304e097bd9587aa6d815805aabc5a5a05641d4e9fdf87811bd24f6530af949af" + }, + "y": { + "c0": "0xdbd1f0f6da0ee971e3de1fdda43a758429032e634acd446413c871726198618f47f4b8d86fdab4798093b58a685ccb", + "c1": "0x4568baf512c01a2f51008b42bc540e7577131dc46d540fd8629a241669077f8eb3cfb012cb1cfa47c83a8c75a6de3f" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_128bit.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_128bit.json new file mode 100644 index 0000000..7a697bc --- /dev/null +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_128bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BLS12_381", + "group": "G1", + "modulus": "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", + "order": "0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", + "cofactor": "0x396c8c005555e1568c00aaab0000aaab", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x4", + "vectors": [ + { + "id": 0, + "P": { + "x": "0xf9679bb02ee7f352fff6a6467a5e563ec8dd38c86a48abd9e8f7f241f1cdd29d54bc3ddea3a33b62e0d7ce22f3d244a", + "y": "0x50189b992cf856846b30e52205ff9ef72dc081e9680726586231cbc29a81a162120082585f401e00382d5c86fb1083f" + }, + "scalarBits": 128, + "scalar": "0x47374bc93251360d6c81c21add62767f", + "Q": { + "x": "0x336429ee08bd6b0b702a8d5e130e05cb9c1bc7ef379d0a3e5f475241be2990613575857d61d3c63b4a052ad5b0484e1", + "y": "0x15432e0253032b891fef51d9389759591acc14370deaeeb53c12995751a6063b6e480c7a557779aebcc828cc881a027c" + } + }, + { + "id": 1, + "P": { + "x": "0x1109824292fa113626eb56969924a6b831c52870282255e4e9fd8bf3878b6b99a1419cd2a04efe86f3bd7e71d8d54155", + "y": "0x18c9a2c292210376f95b6ed61330c3b7b4226815705cdc22866c6e9803e82f344ae934b0785bc877185bb24d8d6ed35f" + }, + "scalarBits": 128, + "scalar": "0x2e710af4fb76c55f615c2a20b44ca90d", + "Q": { + "x": "0x17e25bdca35e9274aa2ed20e6376872cc822d2c3db2dd3abd19bdfb46a1f5c49c1d4c8a64339c7ae3e81ba92fee6f31d", + "y": "0x48812a268c8de187dd734356aa2b38bf79dff6b09b91b8f294b987c9a9fcb7fe23b60d3200af7d8f7fb32b75544969f" + } + }, + { + "id": 2, + "P": { + "x": "0x12739f11b633ee73c1a49c63106be86f422c6fc9471516972599e44665fc2d9fcf049ae03e55561e3435aaac2cc74d51", + "y": "0x18f21e7a85564bac37800ee156eaaf17703875a3edb753e5d7661feefb6f56beb00d6506a4d72402296e2cfaddc10e0c" + }, + "scalarBits": 128, + "scalar": "0x716403f060640d8391fe99b45d5d84f0", + "Q": { + "x": "0x11776948bab0e0e1c325de33ecd18b4af2e40699f521a5d9803af1568d584f14466738031606958cd772c79fca9b74", + "y": "0x46e0f4968d4f42084dbb1d8c93bc50c917f006a8aa3d5b66d9926fdf6c296591b1db53ca77e4769de3ce0541da63d6b" + } + }, + { + "id": 3, + "P": { + "x": "0x2482015e48b6c423810ddfab05eb0b02bfa45d0609640a5b52a82c78564da709c32acdbdc647f1e23092e46969cf315", + "y": "0x797b14fc67a3839b88d41a9b41dd7cdfb50832fe06e7ee09d816f5dfc184b0e5776516506707b3dc6b0e5e34e27aba3" + }, + "scalarBits": 128, + "scalar": "0x39dc82cf2db059d9000bc61f29aabd86", + "Q": { + "x": "0x56447f194c611f4ada6ea0536a06515a5b5607fcf2737aea35fdc41930e5adbd60309d27194b4a148e32e67d9bd8cfb", + "y": "0x36355a0882031c68aac68517de1b8e13306f38a4df57330c62ae1a68d17eeee85d07f0e308f20a8798f9c7d48b0d316" + } + }, + { + "id": 4, + "P": { + "x": "0xcc1623c316dd2f15201d2476f8a643d57cba2613896e2c7a754d8cbfee7da51879cb70ec7aaae8313d9dbfc788e7a47", + "y": "0x2054b37fd776cf2110e5570a499763e7c0cb72d32682b4a448b4450914c84114665164a10f88b04949a9261dfc419b" + }, + "scalarBits": 128, + "scalar": "0x8159682baec2e4aa66e02f88cd7aa29e", + "Q": { + "x": "0xebb6ffb3c993aff9d7915e24c9d97021194b7800829072154b270c77aace265ac20b54df9d84f72eb40344ea9a35927", + "y": "0x195394de64189b5a38c9c5d3ed59a3b6f4c2fb4849bce6ec3b508263c6a01fe5ab4fc08a731a9dfa615337dbe9e36a3d" + } + }, + { + "id": 5, + "P": { + "x": "0x16d64987cef75b39e0a3f7d139fc842266f6be776835e86116e0b1aac432c369fc55509e426a3bff8b69a976bfccf4d7", + "y": "0x1639dc75f6b4b655931d33f6827e258419c628dedff98657d0efd34ed66d3cd55481da8544263485f1ca4c2de385ff1c" + }, + "scalarBits": 128, + "scalar": "0x45078066192b74d2f3077f00f5bd1a50", + "Q": { + "x": "0x2a8d9fd4698cfabc0123b84d3aa778db90bf480cba3ff71605acfaf693565cbbaf4993b5ede8ce4234be580627a18ac", + "y": "0xcd8f529cf94229fc5414dd345dd516abf896ed9fe4ba549a5162c75304fd605dbf1361bc874ccfddd3f9c96ff96b0e5" + } + }, + { + "id": 6, + "P": { + "x": "0x19bbcb60f0d5ca1dacc74270a5136aba556753d7f7d4ab2e457e2d7b8a7bf9d0e96dcf694618a7d5ada4c633dbc713cc", + "y": "0x120b22768f5180aa7f0fd5c7e04b8e07a2d633273051820003f6988465ea1acd513b8d09c2a6408b9524441d1fb8be86" + }, + "scalarBits": 128, + "scalar": "0x39b8a895c99ae56a1789fb56267a3b37", + "Q": { + "x": "0x704fc64a429bb134501e7117e1c31b6c10c345aa1f1512aebcd94ef91ee81e11c0f9dadb58a7c0871ab9f70254768e6", + "y": "0x666a4ea8876f551130388fe71854f02aee890bd3443aed2945f9e36c8d08608dd15ab475916ac6235a010200428846b" + } + }, + { + "id": 7, + "P": { + "x": "0x2615f843e8fe68d4c337bcf83b2cf13cbae638edd0740f1eac520dc2146afa3b8d36c540878c1d207ef913634b1e593", + "y": "0x1787d6eeeceb6e7793073f0bbe7bae522529c126b650c43d5d41e732c581a57df1bfb818061b7b4e6c9145da5df2c43e" + }, + "scalarBits": 128, + "scalar": "0xfbec24ccb36e2cae3806d82275adcc03", + "Q": { + "x": "0x108e63d038b2bc6262752cf9f3ba61c2b95d979a465bb63c554ebbe741815d50a830b2a4859b3c7dbaadb41545376bbe", + "y": "0x98b42746c737cf6426484cda1068136fa248134caac8a26f953d412abeba8353e6b2797964bb8e2714c3c7765146781" + } + }, + { + "id": 8, + "P": { + "x": "0xf33f083bc8158684632722562e2645c5458771b3066a92301af79229b8d1c60874445782f68f3072b4ab4cfbeee4e36", + "y": "0x13463af74716d532aafb2729da90544b1994c7ca133b142226af249cd1457c6eace394c4312aaf85ab7b8946187f9cbf" + }, + "scalarBits": 128, + "scalar": "0x18385b37ad0721c0d8e1d4915acf27ca", + "Q": { + "x": "0x162af287c2b1c09a5ac518e99e7e1920d2aba399ad3ca0c9b4dae6b7cc9dd380a76b674ccc75fa75638a8bf003518d50", + "y": "0x121e52cf2e8b3cef673c0201040cbeaae40f6f324dd93f2b00080f1a396584867898937e4105e2d06139c1625ddfb480" + } + }, + { + "id": 9, + "P": { + "x": "0x99418712e6d995f79d18c88cf369bbf80c752ebe94e6f56a6a9b5cf0ab1a356a5096ed704a75370fa4aee8c1144192b", + "y": "0x14f29ae2ef31179882d4a5977a9f6d22e7ae723d767833a635425c5154e9c805111f42d9e47f0d169ed53c2503e33aad" + }, + "scalarBits": 128, + "scalar": "0x84062adbcf70582ea8cbd0388104f47f", + "Q": { + "x": "0x147957d1ae427d05670df64dbc0d8198f0427e4b311e0a103160174e2ec8ee6e527617496d8177e735e4ab171c105b02", + "y": "0xba9b24e0ef94bc24bb24fd65b5b2991cbe4c708b3a239e7f78aa24475843f71db963565aafdeb9056e5a8b5bdcd609c" + } + }, + { + "id": 10, + "P": { + "x": "0xae2f17c1645a492c8ca3fa4a979640e42c338dcb0462a5b6868c66ba0851276184fc6379563769ae36779647bead5c2", + "y": "0x18c40d4a7d82084d73283d027e11ef909e2b6fe62647363d7189bcc5b6c5cca2f39fbed336db4b3c7e93fd855dbed9bd" + }, + "scalarBits": 128, + "scalar": "0x882db3e45eee839131bc7fe89ee4a859", + "Q": { + "x": "0x38cac5aaecf82f2e8871a41047b360e515b62838d45b41e9b545b800e7e4ada0847caec6f19a0ff77de584a43e0658e", + "y": "0x17c302faa1201e6f9e6860704909fc47892c516d46ab4a4e5d2e0737b6cf823ef0c11190cea98d5c13a2e597d29cfc67" + } + }, + { + "id": 11, + "P": { + "x": "0xf401c2eafb6e74578a11a36d26a75a677ef8a64932f2f0e98701c15ecaf30f9064f05682a9cb47e210987ebc01a8d3", + "y": "0x16ef238dccff44c9d06066b55b8c8b12ab282e57d191ae93efacc8c0c2b098daa8a1bb82895bae0c50107b72d2a4edfb" + }, + "scalarBits": 128, + "scalar": "0xacb5d62e3dcb16acfec66b6a9639e19d", + "Q": { + "x": "0xadab7cd88c04cbbc062c98a266cd49d2c0721f675e098412097e3f55d92969bdb6b7dbf027dfccf8441fb235038425e", + "y": "0xb3df3c5ec916b4e053f8b0569259ffcd314d5f0a4e9772d68c7bbe8681111dd10efe61783f5094122825ae1414aace8" + } + }, + { + "id": 12, + "P": { + "x": "0x60b382ee87d2caed716495e16fa4ef4f51ddb77abae0842a44984c1c77deb31ef2e0c41bf86f4590e48a0ab3790448b", + "y": "0x9fd90ed8ec195fb59568c9a8d01d0d914f3b69be9929e628fbc72102fe71114bde600040e2b76901614bd4f629cce89" + }, + "scalarBits": 128, + "scalar": "0x74f3bf8ac0225a9edfa514bb5666b15e", + "Q": { + "x": "0x931f3f077b44e36cab7b93a82c1db492247984a20205cecf2edabcb2649381c4cb06399d3cc59155932042aae1272be", + "y": "0xb6bf5415ed4768af785c5f798d2b480a4cae773f52e449723134d3a2f541ee2063b5d9664e268728b813cd6b318c7cc" + } + }, + { + "id": 13, + "P": { + "x": "0x146ae9eaeae0a00bd71795be6e2526e0cdd235a7a09c8de701aa96b5aa7814317ba7d90250fa407d470e629a91ce77d", + "y": "0x1843546379142e89d437a538f68679ea4b6996a353e044387fab32c77cd76d7f35281d297f35162803e0c07d94c5be63" + }, + "scalarBits": 128, + "scalar": "0xba5695456f1256c81a51ff49dc6be772", + "Q": { + "x": "0x96d903153d7a40f684ffd8785dd71f62dea87f1aabdd7b0f45484f2f3265e574b9e2fd9247dff6a86e1390d0b7fab08", + "y": "0x3fbedb2dbf9e0604bbb31c6f10818bae6ac11a9d2ca655358c4b8b5356b538d85e33e3340f228a6e0f3f4a4cbbb0105" + } + }, + { + "id": 14, + "P": { + "x": "0x15496d9b2770c13ae0d616521e3ba20e39af677d92b3242c17b177c02677ad868d81049303e9fe7a49a0c18647432d93", + "y": "0x963e13c3018e5de1f824b35e4179e347a3b9268c3bcec2626838d4e06a4ae51d46db392bd6b667097790d0cfb437bbe" + }, + "scalarBits": 128, + "scalar": "0xb7a418f5b127e0c81783ff7fbb3656ae", + "Q": { + "x": "0x2760a78be3ae34e669cbe1257e9fbebd6e97ad5c06ecbcf3557d45a2caf7ebccfd44bd837b5dae4e6363614cd34dbab", + "y": "0x52c0c1140924e2c526e5992356ee24c8261f05ed364b20d595eea206e5d0a0b0345aa12c06eccf179257bf71cc41788" + } + }, + { + "id": 15, + "P": { + "x": "0x13196f01b7ac307525661f5c157c992768f74a07251947321f00701595ee597b47e522329cdfad5b530f08546348a29d", + "y": "0x19ad8253d1cafeb9c2741e11a909ae09c73cd18fa5ccfad7ea2e921ceddf7213c25b93eb4b44d5daf9dda0f30c673db3" + }, + "scalarBits": 128, + "scalar": "0x88a03f37e956b2e46c1c07d0da5d7baf", + "Q": { + "x": "0x10b12ef39037e875d118b7e54f3d95438c8384fae6fc7a7e9371fb7220b35ed525d6c4146a05d5f3563cbacddff17ca4", + "y": "0x188ac0bbecdcd75930831b9b1cb395298af006b786cf5de2a63ed9f84173904008ed5535a1651f6800901b030038339a" + } + }, + { + "id": 16, + "P": { + "x": "0x9ecc4b29cfa536d500839d7c63323dc1458581bad447e04da54b36a3fc1543e5882bb52c9dfd88a15b75b7b46034707", + "y": "0x11b37e94e0bc2f53227ccb455ea090f1532734c252a26e80e2b90d6b82c7112758daf06619920b2d896d3a9a38063a85" + }, + "scalarBits": 128, + "scalar": "0x9b7c6549479f9f8a1e2664eee2a887e6", + "Q": { + "x": "0x11427ac0496bcbc13270f400e8667d44e7b31d4be1754b2e426ec6cfb24ecaf10393a16976d1c88d110567150736b2bf", + "y": "0xcfc71e205c9a0759d5ea0108121222742bbf94a22a567b61d86b690514240285f31a0701e195a41b778934e423c00ba" + } + }, + { + "id": 17, + "P": { + "x": "0x149241d1c702e57cdfd91ae5a8786775a5488be08ff594a66819ff97eb35f7206b6a7431f9baf4f03d28604fa7920728", + "y": "0x80a165919ee7a889f5b54199976e86b62d0e8560802b68f0addee680f4fded5d7af53dadeaa517d4912a87806721936" + }, + "scalarBits": 128, + "scalar": "0xf90a3b876c7143e09b542c9c14706bdd", + "Q": { + "x": "0x17dbcbd051d6b6d592371254d44461e9f68f941c11e4d1547a891936b3d1c3c7ad78273b6f56c912cee8bd280308a1fb", + "y": "0x1015b62db1756b8f8e1f07e02464e1fb116ee449f5cae23e041b2786ee3c0f739e5c4930665a55b83c71003c3e3e28d1" + } + }, + { + "id": 18, + "P": { + "x": "0xe9de20e285a46756b413864698f6a9d1875ff303a395b1e852d01f996f1e873930a8b830c16af551d98b4cd8e9927ae", + "y": "0x186c9c96b8b25d2d5dfc0c9737d4ced876b3cd817bf25576ae3d76b1bacca5ab0aa82eac57b1ad475c549f19b312387" + }, + "scalarBits": 128, + "scalar": "0xc85cd2bb0fe0aada1d20d9ee343b98e7", + "Q": { + "x": "0x452778a58992952248f70f3c0b5fc92712f0cc2ea3a54bee455bb4b714f5f378e983264353dd1f3004862fd426fd5e9", + "y": "0x68525bc499e716e86841e4530ae81531ea8006ce81b5731884370e821d83d7e7032c5191c1d8f2282e43c145213abda" + } + }, + { + "id": 19, + "P": { + "x": "0x49fed6a2bfaeffd78a808e0c9e5d9d248920c6c40900f7779b98580c44aa2d4c345907e8fb8c662a833edbefc755cce", + "y": "0xa2dd6c067d72fd0904772e91cff0ebef27d9b0ec5cf7da7edcee5a86050ece7ed7ea612980449418925b5e66f05dc80" + }, + "scalarBits": 128, + "scalar": "0x252dfd15c053a2f557004feb02868777", + "Q": { + "x": "0x12153ca229d1be7281008dc5a3dcd26a3224042fb89792c754285232c004dc734ca3cb86a7846a1e670fdb953919d9b4", + "y": "0x18e38730d665562d695f25e51842b21763674a12d3bc31df474161b4521716362cf53468f45c166b57dde823dffcaedc" + } + }, + { + "id": 20, + "P": { + "x": "0x1762cb2e92c80fe3309c51976d0989b530eb45bf6ba345d728f1737bbf3991a3e0d1686ddbd28979c20e6047bfa66fa6", + "y": "0x2108436b0d1409211fe12b2b1921aaf12d1784aa20e1137eefa4a5586e935bbd4e22e4c639e7efa58e7c7d38d47dd2" + }, + "scalarBits": 128, + "scalar": "0xf8faadf3b0a6960e052a92551d54e979", + "Q": { + "x": "0x15092babb2d379e519f9a28d700d50d8b4e41952ea93f8a0e3f3c3011c5c61ccea36a78e0a5704fcfab7f3a1d0ecf539", + "y": "0x16e56bb645f22742557795b7c05db3e8bd465c016d84fa6b3df2f14aa7a4ca23baca29b390cefd6e1466e16dfa85b13f" + } + }, + { + "id": 21, + "P": { + "x": "0xbba459ed113a9dff3932522e058037c74af0f51b17dd9b63dd9ed95892169935cc87577fb8002206e077845acbb06ce", + "y": "0x95d60d82f6e117ef1b3ad846c4416814f1bd5989e2aa74f01ab8fd63d28d3d291a515b0d7ac3fb746a705545137968a" + }, + "scalarBits": 128, + "scalar": "0x15746a0dfb50144578334eb8d1e2f6b0", + "Q": { + "x": "0xf2a0bce9a2827e1e2c94464b8b973047c54f2f186fc96f571e6b5cfc7fd340c84f91595be318b162e1d124c3ecd33b1", + "y": "0x5c9c507b6768b84d58fd04a224d7ac99812dbb1f84b6a3911c777d3760a56306bcbb3fd3b40ed1a1441964f3f5df281" + } + }, + { + "id": 22, + "P": { + "x": "0x110024107c51ce5a5036d2423fadeff348b19196beddeb2c6b65ddae5f21a187b43eef5a54ebd2ff23b3e75594a73c6f", + "y": "0x568109d79caab88736c927b766294800f3d2bbe5ed66543a278b4d2e889116cc59c365a84aceed6bab9ac23008ef9d1" + }, + "scalarBits": 128, + "scalar": "0x8c25dc144e1fa7a1e5bbdf82993aa33c", + "Q": { + "x": "0xbdbbc2ce2e9642b1efdf3fabb97c00b7e5aacc4c90519cdb01847d51df1db0c872edd408e177ab031f3491405cc42fc", + "y": "0x1814cab338cc6d9cd3c14da053f2077bacc1f05a74fc07e093b89f7fcaf32182cbb854ee9d206237f9c72e1d285ad7a3" + } + }, + { + "id": 23, + "P": { + "x": "0xe148cabebe9949162673b27cae38a0c7460546c99d7fcd380b1d701477bfa1919c0b5f8c8fa01f4e012db973d32c704", + "y": "0x792bc8e4dc59076868a0599203dac878c5b3b81a4aa581532718c2c0b8fe33c28078d2014a80a29afa7ef57564c5b4e" + }, + "scalarBits": 128, + "scalar": "0x17acbfcadb5031f793c06ed98941d02", + "Q": { + "x": "0xdcca9224744a50359727e8cbff30f62c1d17e19bd628816782b2cb5ab623ff6ac3b6b89f8b2737d92f926a476bab61b", + "y": "0x137e61ca39d6b284f1e2785e80d25b03d01365017249028b1cca1bc08a3bd1b0971d9713020ff13efe8e1a55290482c8" + } + }, + { + "id": 24, + "P": { + "x": "0x1924ed3233fd751d5fb3134805b38fa06b231e84f40f0507eb0fa17c96116fbf4dd4c9a6d3cf16b69c9dfb33a8653027", + "y": "0x28de78b6ac8ff27b4f0b73a7705bc6c7ebc3ce4a82c196c63d450efd67e926b671c780f3012c1f60515d21ba5ee18fe" + }, + "scalarBits": 128, + "scalar": "0xcdf78a9f3335385a1d981fe2ec65a406", + "Q": { + "x": "0x159521546579e558ae0af2b31fc42853090effd169f3b8452df9942c59bffc69b4b5fb6f4d347d2cac9ae27e24635353", + "y": "0x105819b8a77b252b4113a97b77bbd08bff08b11d5702176e1e97f595182a6b48a8b711963dc11ecfaf5af9b3b8e03ba1" + } + }, + { + "id": 25, + "P": { + "x": "0x92647d5134206a8bc8d84d648da5049a8dfa843969e69c0e9578e2b50568a7da6ebf909cd23196fa1279d43594ff3d8", + "y": "0x8b9be07b04567e6d6de2673982a5c637f89b346698d47fbb78406c4d66105ae2849ad46d40033ca00dd2695ef0e9b5" + }, + "scalarBits": 128, + "scalar": "0xd64d287c740767a4feca010392d84938", + "Q": { + "x": "0xa3afd333b0476582f80d9a0cb0a7d19ed6862bfb1639e2eb2690b23db8b839d4470fb4f6a2a647938446bff9e7e613f", + "y": "0x5685ead3f59c7faeb9d91c8e0cbe7798e76750d76e7435ccca9ce1e8067125ce4863c59e09d2e676c71a742073803e2" + } + }, + { + "id": 26, + "P": { + "x": "0x15c42746387dc681935e941acd95eaf10eeb1aed84a2dfef33443b3d2936cf4936fe788b5306ecc5b317b7aea16cc740", + "y": "0xa2ed64ecbcf9911319a9527b7b1c824404a0d39df3b636be5a383d9a174595c7b6512ea30aba97aa4a9e43b55034f25" + }, + "scalarBits": 128, + "scalar": "0x7d711adafaaed588e9734aeb0bbc79bd", + "Q": { + "x": "0xce6897fa3dd508069ccb41d1be4a0bc366a726562bb51a3439bdefd6a135d73f56b830a1ae070ef1e8ebf2f4c082ba3", + "y": "0x7a42b4f9fedc4786c1c39ee8207125d4cf64fef76ba588115475a7c29e37cb5e8c72b4ae5ed9f510830a49c1d42827a" + } + }, + { + "id": 27, + "P": { + "x": "0xe19660ac68077efa1351656b36ae5f8ca25c309e875ea8891f9401e881d8f59b4c70c72a04472396f49ffa47e21e95a", + "y": "0xb35155bb2abe56ba255504acbbf0229b7925f023f593cd184e1ed810e0a608b9be69528a7c8d776af90284297fe9d5b" + }, + "scalarBits": 128, + "scalar": "0xe5c0ab4f86defd33eaf7be9c7a15509c", + "Q": { + "x": "0x17ade35ab846885ce03885a54e145ed32a034d9ac26d8836992654adf59563e145ee99070358e44008514d99df5c745e", + "y": "0x160e6a9b0f513224c41047edc3b23b19285da92314b37a80b87b5bdc9c529cc8848032b3634e101ab0831767a0e98de5" + } + }, + { + "id": 28, + "P": { + "x": "0x442649e05b0bad71e1d7cce41997f796f04611deb638c23e8087969375199f4997c3b01be431d4ad29f04c7e307bba9", + "y": "0x716568acf40291befb701f2eb6d841bafa44acedbb24d4065c54916670abdea9e2b1530a4a5d07f0c7c75c4885ca42b" + }, + "scalarBits": 128, + "scalar": "0x850714f972e93d12cd3c75c22a74569e", + "Q": { + "x": "0x14a5079366b36400e3c5ada99c4942f78fc8e35cc80b5d9f3b15b6ef89c3117cfe2d77051bfb4a1f9a096abb5d44df50", + "y": "0xd7452e7d93bf4662ab0c13094dcd00ca46393f57fb13551f68746f3cbbdc0b076a12ea3a71643972f0138b8d1b58366" + } + }, + { + "id": 29, + "P": { + "x": "0xdfbf3c5933b16023da82ab10c62a6556521cd6bff3fbe7302b8dc770a8c257a773ebb58684dedfa22600de83792c770", + "y": "0x4293e4416516e1cb4b16c5060e3d30c6bd08a09de1ba61b87d8593dd6c3cc573ff189718570b770813cdf7e5ef68321" + }, + "scalarBits": 128, + "scalar": "0xe71366301a9851f34a9e8df70ea05452", + "Q": { + "x": "0x16910ca70caa6621052be2054e158a046bf1f2c6da55ea2ace6e7370aee3eea245f013647d6044e6a1254a97be97c631", + "y": "0x1019d81187bcbce4cd0957e47e830002c0a9e4de8a0139240dd6fff84124edd7398727ebfb6d07a9d88cf28aae92cf70" + } + }, + { + "id": 30, + "P": { + "x": "0x13ae5b1232a79ccf4fbb84886bd9e863479e2260841a851be627492e6bfcde7c28860e8ff879c32ab0f7d262bd1eb6a", + "y": "0xe11587bd7b903487e8cf86bca61965dc675abe4f4496b469e61888d3e1400d6715244d46d27dd369a9564f8a5223c13" + }, + "scalarBits": 128, + "scalar": "0x832d366412b785d298f4d528f51b9628", + "Q": { + "x": "0x168f2617e788d75e9e10662239465040755af4e2accb593906676ed3549974b8dd996250073e2c3f6b20c86e258b8fa7", + "y": "0xd6d378ac4215bdab71ec0d987cca02f03ed2aa9857f4fdcad1faf37ad7cc9e114f8dcb7d8e2eab42e3453b0c5b83740" + } + }, + { + "id": 31, + "P": { + "x": "0x1c297277d718f43641e8fdc28320cfe09b9769c31679ec7ebfafb259e0f6a0d1e3ecf5b7e5fb4de8a53ca4422a44b0", + "y": "0x10407f1a28e4d35fbb6dfec454946124cb66eeed0019f2c0ed52ac1d23eee3f19d092919157c507d8333326440aed2f0" + }, + "scalarBits": 128, + "scalar": "0xb489b6dd2cc09593fb9f7eb0469c0cad", + "Q": { + "x": "0x12599f0dff019dc8038a52c24f51607b29cba42fbef0f77216e42f59d98d92da3e6172923e181f6ee3c0a61be6eb852a", + "y": "0x8e2fcc66a3f2c471a840c5eb2f6abce698a7994097ea97f525ecc0ffeeda4c5f7065f629f2854910345749d92babe9d" + } + }, + { + "id": 32, + "P": { + "x": "0x1795d84f3b0c1d4da358825f805244fa86dd2ca72f073b261782e56a9cc572c65ecba2129f411e9af26639f2fee5afa2", + "y": "0x13b7754974368084e5c4ff4d99418fbf0aa898481df44137c540522d666097989d8c14e2b84f4143ebcd3e69879ad84a" + }, + "scalarBits": 128, + "scalar": "0xbd479583af46042e7debff95271abf17", + "Q": { + "x": "0xaea31d4eecf21ecf2cad37ff89fd1cabcf68b8fb6e9269b5b808f42764c51a4c1ca8b90a74792b6ff478bf501de5b3e", + "y": "0x5b7ca1fb304018d4e11d2fc8fc749d4abe57930207fe746dd952b16d3b700a444782bf63ff4c09cef2eac2785119c29" + } + }, + { + "id": 33, + "P": { + "x": "0xf4eac0f008eb494ae2ea7b9580999b8289b15e73d5be5742d671c66753277d53b106b863d831bf3206658988188815b", + "y": "0xf0eef733ef96eaec3176508ac0551a36e8c1efabf1f2b76fe5897c789e8cf339fa94d784a1303d6463de9ad7cac605" + }, + "scalarBits": 128, + "scalar": "0x528d2beba96847c540f26a02b972c1d3", + "Q": { + "x": "0x122065a0cba4ab4a532db46f1a5960a7f3ec62cb8b3262b1933ca40e303b009f230a7f08a44365a436474f8a1e7998c6", + "y": "0x1050f67612c5363d9f889b6e547f184aa1b209d09772a1874c8a6e5e75ae698a871293efe1b95656fd40d05c869a0fc2" + } + }, + { + "id": 34, + "P": { + "x": "0xe0c00e0d11739f75a338ee6a06b3f2460a11c6ce7dabf1d30fa81b7dfbcdb133216bb3cab16bc080212d93c4e648a8a", + "y": "0x158caa313843cda812ebd6059c1d2f04febe6b5e9e7b57975cf859153e54736ccfdc81a5c3ad3a97e290a1c38cff51cf" + }, + "scalarBits": 128, + "scalar": "0x84855c8f1e2b05d59a44130e7b566b2a", + "Q": { + "x": "0x18a16dafcdcb3e85405c29564a828b8940e17d07374cde78e93c2005ed22467eca2a458e5c9cc67969f96b4d5160c991", + "y": "0xbb6efdc04c32793b6ef5a6cd81afe53d51217c5244907cae002c4982a370d746ac99d8e087437fd46f0b5e4c848b127" + } + }, + { + "id": 35, + "P": { + "x": "0x166ec1a3b558de9436848d058692af048e28fa1851662f9fdbdf2be709b77e281023023b7a32c3255eec80ac06522a4e", + "y": "0x1dc03295b78ce39edfe76cd9b16dfde6810feb1895d1b185e488b049496f05d35ca767ada7bb4ced6b771c1e7bd2334" + }, + "scalarBits": 128, + "scalar": "0xb120613810a740f39319e0596e52015", + "Q": { + "x": "0xb54ba17536348d2f8cfbcf90336d18baf38910cb1ace359e9ab578d7ba0ea093c56696259cb7e7ae03a3cc136994e3b", + "y": "0x19f579a6d5cd269be16908463b2acfadbc1c3e58f618c6e74db919894f16077f73504f5dc0a69c001b7b4cafc53884" + } + }, + { + "id": 36, + "P": { + "x": "0xe2480df90e263c686cd8591a3faa258a79b5acc2df7f667b83ac7d7f3d6a8cf0676f785dc9413cd655f0e32b922de69", + "y": "0x1667ad1beb3c0976012ea7e6228b9b8ad158b8802b261030f0f2faae5c197730fbd18c4f5de6e9ef3d0f11a63c05c963" + }, + "scalarBits": 128, + "scalar": "0x9e0dfa5e26ec56be4c68be3b91a7e483", + "Q": { + "x": "0x167a685a09ab190e59cf70ca2c782210810d053464793a1cad913677893dbc2014f86061af38e7c50636718b5d38cb7b", + "y": "0x157616296943d93432c3695e157444062a12af8dec519eb98f261bcd8e7d95e9125a2303ae9853ab465b4547cb18b914" + } + }, + { + "id": 37, + "P": { + "x": "0x1164cc199107863bdf625e2600afd32c764bd20c13a4f8ca2af597569836dde2aab458b9eaf347a3b4b4ae43ec1b1ee5", + "y": "0x24b297c134dd31b8ad691709d86dd8b781013267b476cd2e722139a4fecfc22a6d6851fdaa2544958a7e90bfa9f9bf8" + }, + "scalarBits": 128, + "scalar": "0x8fedccdb3e4e85ca0cacdff1c6213380", + "Q": { + "x": "0xfd0e50623b2502546949f215eb9e5da9448a84c0d213240d1182e0326f6627ee2f29a979a641f840482fd405c53b85a", + "y": "0x5e1c1e55d83b7fb401f6ffe886bb94dc671482c7a12abdb01578c22ffc0ca536f56a005004ecf17c8410d6872d939f1" + } + }, + { + "id": 38, + "P": { + "x": "0x1649c4afc5c0feb50524c9799bb8e4c347a1ace2ad27dde092759447690d9d7b7499c4ad237ec5151d9cb6ad91d00f45", + "y": "0xd97d565f5d800a2c84904a4257b48dc70af7ee2ff420cce5deded109f3ccb6651471f74adf443fd6b06a887e59efea6" + }, + "scalarBits": 128, + "scalar": "0x90354c7df1b09099dcd7e5b9373dc6fb", + "Q": { + "x": "0x10bd410f48db5df418e79e691bda4d1973f1a48cac15b922630c7d01bcec7b224a9606026a3df898bd38b4940ee93447", + "y": "0x154d6d9fffea0c2b7e8ab821fffe67a8214b9f9cf7031b25e6c16b22da27808e7f4e0f15e5df08231ac5236b8df40356" + } + }, + { + "id": 39, + "P": { + "x": "0x19d3b65c45e920c23127feaee64a9d6e14cc8c87a676f0ac2661cf5d1aed6091b1f0257ecd217e3974bdea3bcfab41fa", + "y": "0x14fbff7b40991d5bf9446040c02c04054cf11b468af6a5238fd6a48692d654c4e7cf40d42527915f962518bc362b1a47" + }, + "scalarBits": 128, + "scalar": "0x3620978242df9a8800115372ea9a85ae", + "Q": { + "x": "0x14ae27e89f928ebc52b48bc164673e5e51f534b6b1e4e97f01b78bcc37364ae95cb424dc639b2f60fc1d3d44be48045f", + "y": "0x16eb6ebccd875d3f40bf417ef2e1d4f9bb46b2aa339f684ec5c188e32d7ecaa818725b550532cb9a1571335460e00768" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G1.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_255bit.json similarity index 96% rename from tests/math/vectors/tv_BLS12_381_scalar_mul_G1.json rename to tests/math/vectors/tv_BLS12_381_scalar_mul_G1_255bit.json index fbb15e9..d8a6b4a 100644 --- a/tests/math/vectors/tv_BLS12_381_scalar_mul_G1.json +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_255bit.json @@ -14,6 +14,7 @@ "x": "0xf9679bb02ee7f352fff6a6467a5e563ec8dd38c86a48abd9e8f7f241f1cdd29d54bc3ddea3a33b62e0d7ce22f3d244a", "y": "0x50189b992cf856846b30e52205ff9ef72dc081e9680726586231cbc29a81a162120082585f401e00382d5c86fb1083f" }, + "scalarBits": 255, "scalar": "0xf7e60a832eb77ac47374bc93251360d6c81c21add62767ff816caf11a20d8db", "Q": { "x": "0xc344f3bcc86df380186311fa502b7943a436a629380f8ee1960515522eedc58fe67ddd47615487668bcf12842c524d8", @@ -26,6 +27,7 @@ "x": "0x17d71835ff84f150fabf5c77ac90bf7f6249143abd1f5d8a46a76f243d424d82e1e258fc7983ba8af97a2462adebe090", "y": "0xd3e108ee1332067cbe4f4193eae10381acb69f493b40e53d9dee59506b49c6564c9056494a7f987982eb4069512c1c6" }, + "scalarBits": 255, "scalar": "0x5f10367bdae7aa872d90b5ac209321ce5a15181ce22848d032a8d452055cbfd0", "Q": { "x": "0x21073bee733a07b15d83afcd4e6ee11b01e6137fd5ad4589c5045e12d79a9a9490a3ebc59f30633a60fc3635a3c1e51", @@ -38,6 +40,7 @@ "x": "0xf92c9572692e8f3d450483a7a9bb4694e3b54c9cd09441a4dd7f579b0a6984e47f8090c31c172b33d87f3de186d6b58", "y": "0x286ede4cb2ae19ead4932d5550c5d3ec8ce3a3ada5e1ed6d202e93dd1b16d3513f0f9b62adc6323f18e272a426ee955" }, + "scalarBits": 255, "scalar": "0x4c321d72220c098fc0fd52306de98f8be9446bf854cf1e4d8dbae62375d18faf", "Q": { "x": "0x4bb385e937582ae32aa7ba89632fcef2eace3f7b57309d979cf35298a430de9ef4d9ac5ba2335c1a4b6e7e5c38d0036", @@ -50,6 +53,7 @@ "x": "0xec23ff3435b8ebd5e8e0a879d432e11eb974161664b1341fd28f1ffc4c228bf6ada2ae4a565f18c9b66f67a7573502d", "y": "0x10c4b647be08db0b49b75320ae891f9f9c5d7bb7c798947e800d681d205d1b24b12e4dfa993d1bd16851b00356627cc1" }, + "scalarBits": 255, "scalar": "0x1738857afb76c55f615c2a20b44ca90dcb3267d804ec23fddea431dbee4eb37f", "Q": { "x": "0xdc7ae7801152918ee3c13590407b4242a80d0b855a0bf585d3dc30719601d2d5d9e01e99ae735003ecb7c20ef48265", @@ -62,6 +66,7 @@ "x": "0xdf127083c2a5ef2388b02af913c0e4002a52a82db9e5ecbf23ee4f557d3b61c91ebcfe9d4973070b46bc5ea6897bca1", "y": "0x318960aeea262ec23ffdd42ec1ba72ae6fa2186a1e2a0fc2659073fb7b5adfb50d581a4d998a94d1accf78b1b3a0163" }, + "scalarBits": 255, "scalar": "0x19c47811813444020c999a2b263940b5054cf45bb8ad8e086ff126bfcd5507e1", "Q": { "x": "0x5f93c42fd76a29063efa2ee92607e0b3ae7edc4e419b3914661e5162d6beaeb96a34d2007ff817bc102651f61dca8d1", @@ -74,6 +79,7 @@ "x": "0x101123de23c0f240c583c2368c4118dc942db219c55f58cf54acd500c1fcfa06f651ad75319ebf840cbdb6bddea7fde4", "y": "0x5268587d4b844b0708e0336d1bbf48da185aaf5b948eccc3b565d00a856dd55882b9bb31c52af0e275b168cb35eb7b0" }, + "scalarBits": 255, "scalar": "0x43ffcda71e45a3e90b7502d92b30a0b06c54c95a91aa21e0438677b1c2714ecb", "Q": { "x": "0xf9871b682c1c76c7f4f0a7ca57ad876c10dc108b65b76987264873278d9f54db95101c173aed06d07062efc7d47ca0c", @@ -86,6 +92,7 @@ "x": "0x1457ba1bae6eb3afae3261941c65c93e3ae7d784907d15b8d559100da5e13fd29e4a4d6e3103b781a95237b7b2d80a8e", "y": "0x6a869a47cb48d01e7d29660932afd7617720262b55de5f430b8aa3d74f9fd2b9d3a07ce192425da58014764fc9532cd" }, + "scalarBits": 255, "scalar": "0x64ad0d6c36dba5368e71f0010aebf860288f54611e5aaf18082bae7a404ebfd8", "Q": { "x": "0x93e540e26190e161038d985d40f2ab897cbc2346be7d8f2b201a689b59d4020a8740e252606f2f79ba0e121ccc9976d", @@ -98,6 +105,7 @@ "x": "0x2615f843e8fe68d4c337bcf83b2cf13cbae638edd0740f1eac520dc2146afa3b8d36c540878c1d207ef913634b1e593", "y": "0x1787d6eeeceb6e7793073f0bbe7bae522529c126b650c43d5d41e732c581a57df1bfb818061b7b4e6c9145da5df2c43e" }, + "scalarBits": 255, "scalar": "0xb0ac3d0e685583075aa46c03a00859dfbec24ccb36e2cae3806d82275adcc03", "Q": { "x": "0xd95ed29c2e15fd2205d83a71478341d6022deb93af4d49f704437678a72ce141d2f6043aa0e34e26f60d17e16b97053", @@ -110,6 +118,7 @@ "x": "0x10bc0c4e1ed87246a9d4d7d38546369f275a245f6e1d3b882e8c9a7f05bc6ee8ff97a96a54084c2bef15ed8bfefb1465", "y": "0x1782377e5f588576b5ab42fea224e88873dda957202f0c6d72ce8728c2d58dc654be77226fbda385d5f269354e4a176a" }, + "scalarBits": 255, "scalar": "0x23941bb3c3659423d6fdafb7cff52e0e02de0ac91e64c537c6203d64905b63d0", "Q": { "x": "0x83f1e7e8bd963c1ccd837dae7bc9336531aaf0aee717537a9a7e2712e220f74cdb73a99f331c0eb6b377be3dafc211f", @@ -122,6 +131,7 @@ "x": "0xbe4f9f721d98a761a5562bd80ea06f369e9cbb7d33bbb2f0191d4b77d0fd2a10c4083b54157b525f36c522ca3a6ca09", "y": "0x166c315ecdd20acb3c5efcc7e038b17d0b37a06ffbf77873f15fc0cd091a1e4102a8b8bf5507919453759e744391b04d" }, + "scalarBits": 255, "scalar": "0x4203156dcf70582ea8cbd0388104f47fd5a18ae336b2fed8458e1e4e74d7baf5", "Q": { "x": "0xc72bc7087cd22993b7f6d2e49026abfde678a384073ed373b95df722b1ab658eb5ae42211e5528af606e38b59511bc6", @@ -134,6 +144,7 @@ "x": "0x5c0d5fcd2ff364b5a73bacde4abbf7fe98a1dd4e4abed78fa96244f13c1003cc0e28ebd59d2de32d8d7a5c999e1cb82", "y": "0x62615902a6feb46093cc77f7c9c7c4f75193f5d211e72deda9d827f3cf3334fcbd3093c66ed431fadb45dc21dbd7fee" }, + "scalarBits": 255, "scalar": "0x318c79935f61fafa8cce97b2d3b058a35b9620d76ffaff0aacb5d62e3dcb16ac", "Q": { "x": "0x3b5d47b85d3663a6698d2ea3fe9ea989fbf10e43dc8aa443455c6dc75581631023f2c7d279d02f334989cd5eb001fe", @@ -146,6 +157,7 @@ "x": "0x146ae9eaeae0a00bd71795be6e2526e0cdd235a7a09c8de701aa96b5aa7814317ba7d90250fa407d470e629a91ce77d", "y": "0x1bdbd86c06bb81076e4027d4cc532ed190db4e19fa4ce86e7859fd979d988a4e983e2d5321ee9d7b61e3f826b39ec48" }, + "scalarBits": 255, "scalar": "0x5c8a95d81b523543afd65c805a389980ba5695456f1256c81a51ff49dc6be772", "Q": { "x": "0x1f1c7a2d0c4c04a4371dc9d07ee996460b52536892449e7a2e0a798da7f31ee0ae8ce1c4bca4d55777ecf17ceda697a", @@ -158,6 +170,7 @@ "x": "0x12d9ac1c4b4342bb601efa9505776936b6a4d8289fa9cc8186e74a59af4b0d9c46a29ebf1dcef8098ec90794a9ea6958", "y": "0x13b00f64c1193d63f547bd09290178f4b9f6f954855133e8966511d3affbb7e0c7241fa273da690b1a7b95d83e7fc665" }, + "scalarBits": 255, "scalar": "0x45c34dc8528310a95e69fc0c24d27993530ad70672db2a4d1faaf0e0b7a418f5", "Q": { "x": "0x859b304ef906eb070370941471d0249922f627d465ba4766e38a6dc62bf3ff63710c4736c085daf79dfe8f90025ef8c", @@ -170,6 +183,7 @@ "x": "0x99372e61aec8df9a76b4258de660f05bd48c8318500c95ce7f4641e629a7d62c079a9a33e63fb2515e3694a24931e9b", "y": "0xf27fd12ad4f6d025b55c3c4e3125f8ccbdafe19c0d266259aad94acd5b378119915a3910fd8a0c6b16a7c4999e683df" }, + "scalarBits": 255, "scalar": "0x60d95fa08b3cae31b7ed148e02dcd60107d9670df5b9f69ecb7fb6066bc96bb8", "Q": { "x": "0xf401672d1446064175bcab3db95df157da4a0039510529f7207dc338db548d6015827b811f67f9d9dbbccd6d16d18f1", @@ -182,6 +196,7 @@ "x": "0x56d0418931fbce9fb682b6f03cec8397136df53ffdb3c6d3e0501b6c5561179e06c02cd067f335fbe96a51a6e7dbecc", "y": "0x217ad0d71c2bc2ffb23f52c4a6d7ceca769d60af7bfddff32c19f375b7cb441b6b690ad65f6c33c559719abd7160b17" }, + "scalarBits": 255, "scalar": "0x5d7173feea4ebba2fc41fadc5ddcba3a3cee7f6e3ec71fdd7d7f9145b9b70552", "Q": { "x": "0xaedbc4bb487e906e83746be51b2aa85840a73cd5ed36d08308ce3e05b77042e777ea2d57ea5a91b17a4d8c6af86095a", @@ -194,6 +209,7 @@ "x": "0x149241d1c702e57cdfd91ae5a8786775a5488be08ff594a66819ff97eb35f7206b6a7431f9baf4f03d28604fa7920728", "y": "0x80a165919ee7a889f5b54199976e86b62d0e8560802b68f0addee680f4fded5d7af53dadeaa517d4912a87806721936" }, + "scalarBits": 255, "scalar": "0x3638a1f09b542c9c14706bddf9bd411747489f3d398a5c286d28f3a950e33406", "Q": { "x": "0x16bd4093541e6e1dcb9dc8beb1516d44936777d60a622a19728e5ef8a62aa0a591783af82c3e0acdae2bf2b4191990c9", @@ -206,6 +222,7 @@ "x": "0x7b1064b140ba94fec9cc0d39c366e5ed1ad94119b55c5276ad6401964bc3d0b6ddcf3beacdc3c22d6c21f20e44b4235", "y": "0x5e88ccfe4e4940c9d976516c1718fb5e06e1db70090d9d943b8b7c5e83da8860e827a42101281b7825e8d97f10fa78e" }, + "scalarBits": 255, "scalar": "0x43e30b2b76ccf39f50a354204aabe0daa56da8fe08f90834486477294136523e", "Q": { "x": "0x65c6c95b5a263ee620be43c100f63ae9958bb011466bd0fa3246c050d369219126146e588ca5cf7b2d0276572ba5d20", @@ -218,6 +235,7 @@ "x": "0x11a781f450bd0a92e10ffa3295ffc6cd21fc0342445ac385955653d1459857256bee38163939d03d546b9ecc99c0f68a", "y": "0x11ab37cffd53718d515b971d7b758eff175918827f5596f309a9cfff841559ada81736581b592c3d84285d92bfd32dd2" }, + "scalarBits": 255, "scalar": "0x566abd28ece240d97585e5bf871bba98e2eb57415b359f129c0c3f54f72900b6", "Q": { "x": "0x37e9c94e86733e8f96b803f6250bd568c5443ad8b8fbf16d58a9e0df254a60b5eaaa85f5f493b8cf36ed75b61a0d4f6", @@ -230,6 +248,7 @@ "x": "0x97ede383a40480da68d425b08ab0085d537c3369a63262401968713554cfc66a22026fc16c6f07e546527b7022587f1", "y": "0x146d0c345100bc217a35af37fe2d5113f951b1ee916b3fae34a17c2a9fb7f6fbc3d48da392b1fe99e7f2fa272cfbcc3a" }, + "scalarBits": 255, "scalar": "0x5cbb76c17df070ab2bea372815ac6277062b27569ad68343fd4ec3d4dafdf6a", "Q": { "x": "0xab189cd52d8a56804bf89b4cfce5bb883496661b2b1efc815391fe9c7c47542ac5ebf83269afc2be4dfac65f9e42703", @@ -242,6 +261,7 @@ "x": "0x1762cb2e92c80fe3309c51976d0989b530eb45bf6ba345d728f1737bbf3991a3e0d1686ddbd28979c20e6047bfa66fa6", "y": "0x2108436b0d1409211fe12b2b1921aaf12d1784aa20e1137eefa4a5586e935bbd4e22e4c639e7efa58e7c7d38d47dd2" }, + "scalarBits": 255, "scalar": "0x3ed99fcfdb3f7b2e4655fe0c1da4993ff8faadf3b0a6960e052a92551d54e979", "Q": { "x": "0x435ec5230b3cf7ea43c4770e836c2287b4e399838efe2f699350b200da3501d332e4850d724f2ed214c10ebd44c701e", @@ -254,6 +274,7 @@ "x": "0x175a91d65b8a73b1202f96489dd7ea2ba3c90c88d3bf1ac32fcb38bbdf57613d755a2a0431ee0344fbf3438e779db973", "y": "0x17e74f122a4a0aa2a48a4c9f7eaed6b5232eac6a059630ba783caaf9cd0d2bd1b828307f8b85753e24080c5d20c59a49" }, + "scalarBits": 255, "scalar": "0x16e12f89ad592c1a73f4c23a9968584c200f386ef8ccaa504da72b1d649c067f", "Q": { "x": "0xa1770b84c906b50205d23016233490583837d2d5032ba9dcbbb1f8db41588cd9ddb034111724d6029ef411e627305eb", @@ -266,6 +287,7 @@ "x": "0x16f8de5ba05c41620d915eed03e7169d2c2e2662db70387cd72ff92a9b59203b81d77bd666d1b16515378c37d2679116", "y": "0xc84c6fb110e2c9c1aa872103e8f19d9c2ddcfd7ab569d1400ba31f4ee1343426e2a66a9000e64f8959cee4ce866e20c" }, + "scalarBits": 255, "scalar": "0x206a80f9bb17e5c1999589b36027cf083b6303189f00a8f966647a29b6c6e158", "Q": { "x": "0x10fcedf23fe5691957b148d1d0506b83fafefa001d8cd5261a1cfe1d01db4ddf358160bc8f590698be8262022eb98b06", @@ -278,6 +300,7 @@ "x": "0x1692476e5e45776beefd3ed27efc0bd4483c604b3ba2341b3f213c3affe238362777ec262645ec1cc10ee70daee2d249", "y": "0x172e0eed5e2fd3b47a3cdb4a252a4ced49210338e8995c4f7b4e975f3aed8a015f59c98a62201d07fbf77589903cc1c7" }, + "scalarBits": 255, "scalar": "0x4fbc38ab04a94842ce30838a5c18f7f9834b9103c755c800861d377c55b22ae4", "Q": { "x": "0x1564f4eccad61eeb966acf1897653988ffb2589d51e4df3b9b57443f73b4872efda447133b49591861c69429cd80113d", @@ -290,6 +313,7 @@ "x": "0x12dcdd85a8dbef6329adf4d2697af5549bdd8bd8d8887967736de5eccbff23341d8ef4ef59993893cf10d37a4174b5d0", "y": "0x1500833024089b79f247a7ed9b27f2d76090535c0236e77fa6e732e68323160a45df7985b5d7f4893faf817e2ee6f83a" }, + "scalarBits": 255, "scalar": "0x56da818f793c06ed98941d025d5e17a6d80bbc42b7f49003e4c0dfdf3f0dabb3", "Q": { "x": "0x12b06a230a3066c4c0e0559706cdcd6824c36ae0cad5c6d4ee8a8051327caa0a44b9fc63de72ebd98631d10a59024d99", @@ -302,6 +326,7 @@ "x": "0x8cc360c2e5da78a2b23db62ed8858d888fbc60ee9782ba0ba9b658a4af1715e6916b70884c3fbd6352ea07e843c197", "y": "0x98cd6c1099c0e6a3ee74aebd5206072fa5723645c17f94cb614e0a3a11cb839b4fd774462f9bfb9e6969c1151f765c5" }, + "scalarBits": 255, "scalar": "0x6083671fcc66dc084ad73eba100830555fcfcc5eccaa6acb27cda0d3fa8d6f64", "Q": { "x": "0xd5c1d32be6da76e1e7ab4f9e20115da3feba4edc1b7937069046e76a08fbfdb863a6e801d59f4cdccb0f55c23526dd3", @@ -314,6 +339,7 @@ "x": "0x15c42746387dc681935e941acd95eaf10eeb1aed84a2dfef33443b3d2936cf4936fe788b5306ecc5b317b7aea16cc740", "y": "0xa2ed64ecbcf9911319a9527b7b1c824404a0d39df3b636be5a383d9a174595c7b6512ea30aba97aa4a9e43b55034f25" }, + "scalarBits": 255, "scalar": "0x3facf17aee449fd486412257a8275ad7d711adafaaed588e9734aeb0bbc79bd", "Q": { "x": "0x572b9821aa82fdd8df5304170ddbb7e7cf84b992dca76b7271671427771f778c8af895fec84fd7ca0e32ea6128c2d52", @@ -326,6 +352,7 @@ "x": "0x194d9fb9724d20018b4bb04703314c4d13253e2299571ec4a25b2a186ceb68d2333652517d48239eb9eaefe73fbb76c6", "y": "0x3e5f1a463c10ef52426f0f405e7f4e01e12014918f4462a8abbc3f755bc0e9cb907f7511282be1aab3fb9e8b5accddd" }, + "scalarBits": 255, "scalar": "0x64a377a5acd3f4b2db5252c67101ade845d2cb346eb7fcafc810f0e7a47f6ec1", "Q": { "x": "0xed3e051329d494c325c3085a7b9c31ab13f12129ccf654165c93d267866afc7d7ed5702e78af1ed56fd15b564657e3a", @@ -338,6 +365,7 @@ "x": "0x101802892f2045592e97744817c76508cc9403e0cf121e3e933a7fa9924961e9b97427bbcbcc2c8b6c00524b42b23d4f", "y": "0x136d1c3034e6e8d96cbbea77652194aa81e239f0cc1aa8efa5f05b81dd2135a5ac3a3fd9b8190e1ca752cc67318243ee" }, + "scalarBits": 255, "scalar": "0x24718924ee16ef94d0b905575982419a7cf31d125775e7ede5c0ab4f86defd33", "Q": { "x": "0x5655300f7c0529e910c03a3998ddd9f143db103348fdcc588d4ab28c82fb57dc1a52755b966bab6f18e9b3341f87b95", @@ -350,6 +378,7 @@ "x": "0xa77a5edd27d0afdd2fd80309306bf6049373bc8dce8abc9781f95136410d99cab0175eb99496c9401371bc309343aed", "y": "0x132c9bd87f12274ab9bd27d774f725524ac8ff0d86730f83140b8934b475d2bd938643d0b31324710ac0a40d00546739" }, + "scalarBits": 255, "scalar": "0x3b19e00f0644b0fa53abe392b3fd7777b8d3ccc2ccc418e8b0b8134c534a4933", "Q": { "x": "0x8db80b53344589cb5fd89c1a5bb52228144aed731493ee367219250a76c659776b56785f72d558464ea8bddfa9cde35", @@ -362,6 +391,7 @@ "x": "0x437eeb155cff94f5bf1306ac8c2f300094cefbec895af1c2fe1d098269e3a557ec59691fd738f062e23e40fe050c9e8", "y": "0x2ce40f0e5e793939b896415d1e199f187fc577484be4af6615f16376fac5c09116c037206c39c36d7002612adbb94e5" }, + "scalarBits": 255, "scalar": "0x2d89c587f7e36c5728ec2aacfd11d45e1a01a594f4e6000307db63bc09513460", "Q": { "x": "0x154048f38964d45cea0f0b5c2c84898287530e7bcf94e8c878d464fdba652c3b539487617abae4cd9a5513f89f67435", @@ -374,6 +404,7 @@ "x": "0xe36b6e98ccac03518303dd49635beba1a2c9cacc0b6490df11098cdec0b5199a6f954d831da1cb7ae2ca0fbe24ce8cc", "y": "0x20d8203ca0ed08a783e3639d24b5dcbca7a65e25a88d4c831be21f073aa80a1451ca95dcc61dae0f754280a40d0ef9c" }, + "scalarBits": 255, "scalar": "0x128262a47acbadead3c6d90ab1ab94fdd4a69370f816313ff8a20649df5be028", "Q": { "x": "0x102fb51fc5ae72abced7dc1250a69d46105a980ba6d573511dbc9f5ca81ea7441afe87690157cb5100f831509d964b54", @@ -386,6 +417,7 @@ "x": "0x529b559005eae27f192a56e4f934607821556c234ecdcd85e01e9340420aedcbb7de5c98d2086f287fa2e1cbfa9a2c0", "y": "0x1744e3070a3862c8ff67ad8b53b21e06281146c7ffadbab75959827f35e395c8cc52fead55322c553edeebe9134fac3f" }, + "scalarBits": 255, "scalar": "0x418c8f7dceddd870ce5200263c9787401bb0fb339a1bdcc64347d5aa0cf98e4c", "Q": { "x": "0x14ac8564f2d61fda2b4ee5c73e66a9beaa4be413f9bdab7d7a2d3a9cde250d419f2ac849d44962f53ca3bfb9f425d7f", @@ -398,6 +430,7 @@ "x": "0xea554e37dc92836928eb689ef6a32026a169e425d6dac13a7cf22eb669389cfddaedcbd6ea6aef9fc39b3e3a403c7ed", "y": "0x6e63f4df492b91bc043f307701fade6fc525ff3306b4439646d537557e6dcb7ea86b4d02c35ddfa28121ad543eb5e76" }, + "scalarBits": 255, "scalar": "0x575635311121c25969a513404d05bea2edb9df6083f45c0c4874e21a0ed10e8c", "Q": { "x": "0x1806367828979a1716ac776b85e9d9e815c34a62516070c5f841f0ba95069074900fcc15a51ae087ff059699cb25b4af", @@ -410,6 +443,7 @@ "x": "0x5b468d26269e6c8f942e44a6b144202e8f33653993da91e8c50844ce25f6320c68c0690a0764c879cc39d18fe61d777", "y": "0x6a583e5fe9c277ae52f88dce00c691d167c168dada34aa6f02e2a45299fedfbaae7228ef0d4f5a8b76bbc1942b5a8ed" }, + "scalarBits": 255, "scalar": "0x54b423e240f26a02b972c1d322176baccbcaa65ecefbaabcfa13706e40984a1a", "Q": { "x": "0xead9341c4ace405f1a5c789fa04ca565e23629348526ddf389b1beb8d931162a36df93e87906df33a0df2af8733d821", @@ -422,6 +456,7 @@ "x": "0x17a352e7334b566b1546347e1c95f987e24236db45adf6f95fd1d2ebaa4ba800ec1366f47d25e388eee73504987cbaf1", "y": "0x1511973d183cafa684a3ec66eb524fe0123899a26230c79a415434444c730839b00f28cc908ea3a0100c0a5539a43017" }, + "scalarBits": 255, "scalar": "0x2a589ba60b120613810a740f39319e0596e52015b5e08eda138167f7f8e547a2", "Q": { "x": "0x65aff59bde2bf5883c3b376f7ec390c5f909e214e491f0d7c8af9f49c88e16a7504b4a464b873ed7b8b744e944f4eaa", @@ -434,6 +469,7 @@ "x": "0xe2480df90e263c686cd8591a3faa258a79b5acc2df7f667b83ac7d7f3d6a8cf0676f785dc9413cd655f0e32b922de69", "y": "0x1667ad1beb3c0976012ea7e6228b9b8ad158b8802b261030f0f2faae5c197730fbd18c4f5de6e9ef3d0f11a63c05c963" }, + "scalarBits": 255, "scalar": "0xaf8fbd81cfc0434f536b7dd7226dc8b9e0dfa5e26ec56be4c68be3b91a7e483", "Q": { "x": "0x1d601c7fb050e0c6377ce434dcfad5609901da50593823e28ca9165afc195c2f995e90ca7fe9720e11ec67ea379536a", @@ -446,6 +482,7 @@ "x": "0x11206eae189e6f6c425ccd156c44a9bf47dfe7aec2662e80ad6f7b3887ec9557093cfe9d194c650f679bbd27c6b38a0e", "y": "0xa31c646e1a04d62d85bd9c9e67c23c97154aaa42ac545c93f53a95bb09d71f656824103c1785a17fd99c5bdcabe7b1c" }, + "scalarBits": 255, "scalar": "0x92b375cd653958352643dec812c75bee17f729b0cf1936df8c60669711d8ee", "Q": { "x": "0xf01101650961413ca5e63867765e30a3ba2f1883083c79f4245043f432737c5d580ec44175474331c624ca73d471ea4", @@ -458,6 +495,7 @@ "x": "0x13043b145f1609d166491f437dc3e6a5bb8f1bd996b1fea2ad45466e8762e32005434c2e07b41e6fc3a7e8c3d3349259", "y": "0xcb6157d54ef3a35381613d37f0e78aab7b62432e2963d39a5b3b77ff90410bc90ad0130078b52af8a75d544da1ead4f" }, + "scalarBits": 255, "scalar": "0x261f80993a9b2b3b7d7140604b529cd424519b8d0b79c49635709fd11ca9b660", "Q": { "x": "0x3b114854b55b3eb759b7eebdcf57fc1954563b0f89f78fe6f3e89544a30b1c48eeefb904783e6fca7a4bfe01150c850", @@ -470,6 +508,7 @@ "x": "0x176f190ce4ae35c59df395f4b7328290e306b6f89e7e9416fe288b8edcc4559f545e113685dcc34bc0cd97f2d8142858", "y": "0x101342fb41568dd0e55e0e2818c56e3057f2b819ec0d47aa02b7a92fff7602fee261fcdc8c5aa4a0c7aca6cd7df38fbd" }, + "scalarBits": 255, "scalar": "0x3c8dd3f490354c7df1b09099dcd7e5b9373dc6fb1724894f8707335afdb11f58", "Q": { "x": "0x17a5fac1d13235f455cc0c9390dfa82c9d8b0acd7059088a6fbffb86c3db2f495889c2b08257f13b999ec3846ddeb4c", @@ -482,6 +521,7 @@ "x": "0x19d3b65c45e920c23127feaee64a9d6e14cc8c87a676f0ac2661cf5d1aed6091b1f0257ecd217e3974bdea3bcfab41fa", "y": "0x505126ef8e6c93e51d74775831fa8d21786303e688e6d9bd75a2e1a63daa15f36dcbf2a8c2c6ea023d9e743c9d49064" }, + "scalarBits": 255, "scalar": "0x7321fe3d7514d44c3782d62712b677b23620978242df9a8800115372ea9a85ae", "Q": { "x": "0x394a9521bdc89e2dfbba7c334174daa9721ad433705000aae9ebf53caf607e263eb4ad0a905ac106184e10ac6caadee", diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_32bit.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_32bit.json new file mode 100644 index 0000000..00cbcd7 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_32bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BLS12_381", + "group": "G1", + "modulus": "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", + "order": "0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", + "cofactor": "0x396c8c005555e1568c00aaab0000aaab", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x4", + "vectors": [ + { + "id": 0, + "P": { + "x": "0xf9679bb02ee7f352fff6a6467a5e563ec8dd38c86a48abd9e8f7f241f1cdd29d54bc3ddea3a33b62e0d7ce22f3d244a", + "y": "0x50189b992cf856846b30e52205ff9ef72dc081e9680726586231cbc29a81a162120082585f401e00382d5c86fb1083f" + }, + "scalarBits": 32, + "scalar": "0x8b8a538", + "Q": { + "x": "0x1e6c7b69320d0e3599cb190095f64f2a4d83edf9d08e50648d76ff6f0fc7a9de62c69946caff2d746745dbcfe72fa48", + "y": "0xb907f2b384267fe23741626c28896d09da312dc7bd2a7647d9c2f48fa8529eecf6346ad780008dfb4a90b596ecefe83" + } + }, + { + "id": 1, + "P": { + "x": "0x7c6591b6f0f3e65cd85c710f4f74bedff080df12fbcb8f6711bcee9584a9fe4d3eba6a9464f8bf6b807ad11457e4336", + "y": "0x1d05b6287e10143c0989c52c817c68d28a8e070e566c379681ff2074c2132980e9a5a03a1a0914b76e97aa66b0d4fbe" + }, + "scalarBits": 32, + "scalar": "0x32eb77ac", + "Q": { + "x": "0x128ed107a98aaf4b171fb25c143eb84f55eec60eab6b7070d12afa370abc5d7ee26aeafc67436c4ba994b6bd4b3e6076", + "y": "0x151c8af4e46ae1d70fc90d1921db5b4d26d1975591b62943d5e71e0b07e0b2614b2548ab03597e98803daba67f85a90a" + } + }, + { + "id": 2, + "P": { + "x": "0x17d71835ff84f150fabf5c77ac90bf7f6249143abd1f5d8a46a76f243d424d82e1e258fc7983ba8af97a2462adebe090", + "y": "0xd3e108ee1332067cbe4f4193eae10381acb69f493b40e53d9dee59506b49c6564c9056494a7f987982eb4069512c1c6" + }, + "scalarBits": 32, + "scalar": "0x1b0863c4", + "Q": { + "x": "0x16bc494ceceab4c8e2221db8d770593b43e0e7ef47f12d533fcef5e44d4b3f8e8cd687b9e274e31a16be9d7af80f12ef", + "y": "0x3872261aa496e9dc5dafa2032d02c5fca1268f7bb340aaecdebb13822099954b38e6d20a6f61332170dceb89dab7efa" + } + }, + { + "id": 3, + "P": { + "x": "0x161c69cdcb0b2cff389b8a359bd4d7acb9de80d958a639cbcd0d1d06c3903469eb000a23305d0a188eef44305ef3cdcc", + "y": "0xa13a3358db0105647fcac1ce35fac1bcaeede283624d62ac8fddfd3b2ba16dd4230dccc7cfb92fba8b7eeab14a4d915" + }, + "scalarBits": 32, + "scalar": "0x30ad81ab", + "Q": { + "x": "0x19f1ea6b4bb2e31a0d44a9fd7af91a3d128dd7c9c80b8a295a77b8768152532549cc3fdc2a45e1c2d459bca67f76fbd8", + "y": "0x153ffa16f5cd149926dcd7b5918ceebff36501c3a2d3ea9aecf8f0e44724f114a3495b70b095c7798bc42e5f7aaf034" + } + }, + { + "id": 4, + "P": { + "x": "0xcf92de30b4923840fec92b075c21c94c4d8c5053c778cbf90d1b882f35de4edef3c454c718fafd18d832817a8590be9", + "y": "0x70347e13baf56b9b40af24f4a28f89cc3ea9188edf33b462bc957cb00f6c8911a0e2e66faac37fba41877c5ab99d29f" + }, + "scalarBits": 32, + "scalar": "0xe627704", + "Q": { + "x": "0x891b8cb2570296b76e8d9f7af5b006ac1273cb36bec8c7350bd51e67ce8d298b38129c3eedb3bfb2d5576e427ed9fd9", + "y": "0x1982b74b6d15baa7276a4443cc15a287b9a4fef5e004bf27df21b9f90e14d766a3fa68755dbb1ce3af12b088318238b7" + } + }, + { + "id": 5, + "P": { + "x": "0x93f6d4ff2dc0a0d0b289df1888188fdf75a7abe322a6aadb266df982c6ad0232e40acc4748d99e2b29133de9be47aae", + "y": "0x225bf3bfac68aeb49d0bdc6cea3656f74fd91f4ec15f2e82ef9894d67a075197a2404f84c6543e2b6261553096f51f4" + }, + "scalarBits": 32, + "scalar": "0x29aabd86", + "Q": { + "x": "0x18763c6ee6ce383be0eb071b856bcb37e8718e1532547124a47aca77cfa1a6f825f2bf278ab4dd94b5a9522bb7040af3", + "y": "0x132f9cafae97a5b2545640d8923e17f3b2ed0ed8986a9cf9b66a88ec891d712a366414729112fbeeaeeae5d01d08ee" + } + }, + { + "id": 6, + "P": { + "x": "0x4ae921e97b123b7b995856c360326294af8e3398d523310155f99f485ba96e6e8af7ceabfd168f73c99252880933610", + "y": "0x9e6570847d63f28a3779e8ee35a4d538502e8a812424c9a1afd29d92d771a538cd2b0c528f47ca05185e7eae1b82797" + }, + "scalarBits": 32, + "scalar": "0x747d8380", + "Q": { + "x": "0x122fcd989a6a3f3df160037423a40dca7143dafabab6ba446a86701ff65e02bbdbb513b9d429b7bd48200327b4ace3a", + "y": "0xbab96928c97ee5c343ab7cddcc84b1cd515fa9e79a96accfcc6da03b19002c3cc489d1e6f2a694e6fea22924b1cc012" + } + }, + { + "id": 7, + "P": { + "x": "0x101123de23c0f240c583c2368c4118dc942db219c55f58cf54acd500c1fcfa06f651ad75319ebf840cbdb6bddea7fde4", + "y": "0x14da8c6264c7a1e9da8da47f718fb849c2f1a08f3a3c25f32bda75a04e5a18ce9680644b950150f192a3e9734ca0f2fb" + }, + "scalarBits": 32, + "scalar": "0xc2714ecb", + "Q": { + "x": "0xda0bf2592f2a1da56e54cc6b4bbd734c62a3e4b2291427fa0a2d2f2b3e6e7989c3f154199bf8ca2787a364386b0d1c8", + "y": "0x2bd6cad3509fd397ca5188915e6f0b1d6215733cfb7b0e28fd28c7b6a12b994b9565989da272354c1a148cfe5d8b08a" + } + }, + { + "id": 8, + "P": { + "x": "0x1208568a44cc13148e4e4c386deb712d451956a18d29ba206c02586ac1e385b8852f7965a16219892d30a5fe46fb2640", + "y": "0x92e433fc8a5f5eb47221bacc116d96e8858c19308be25a41705adea7e7ee7dd7839628e7dbca2e3827098704bfe7286" + }, + "scalarBits": 32, + "scalar": "0xb35a6585", + "Q": { + "x": "0xb61a7c59250e2381a74f7ea750fff45a46d56509b1cf1e275d7545fc06a66ca5e722fd14965353e10bab1c152dc07dc", + "y": "0x6ea4d832e533557aae3a1c5fc9d23aac5beea513cf9c2dffddd75fb8cecec335c0a3e363525eb34fc4325a09282fbfb" + } + }, + { + "id": 9, + "P": { + "x": "0xbe4f9f721d98a761a5562bd80ea06f369e9cbb7d33bbb2f0191d4b77d0fd2a10c4083b54157b525f36c522ca3a6ca09", + "y": "0x394e08b6baddbcf0ebcaaee6312fb5a593fab14f78d9a4b75d111d3ed96d7e31c03473f5c4c6e6b6689618bbc6dfa5e" + }, + "scalarBits": 32, + "scalar": "0x74d7baf5", + "Q": { + "x": "0xaae7a4dcbaf2aa2c7d94b5fb8768cabd70aa7258357dc83d6c96cc7b907eea957fdca2db00791fac8c9271bc95d65f1", + "y": "0x17ef8358a0842210c88a10ea242234436289dc5326d76ffcf12cd7dd1d4cd443f9ff98f2698f45b30ed9454da29d2791" + } + }, + { + "id": 10, + "P": { + "x": "0x118276735b2a90424901683ea97ca952e9d07e32e6103860dc2f79e0977bd85dc394213c2ccbec217e68a4d9e184776", + "y": "0x19aa73bf242436080d5c83fc186844225392e426d4f188da55efb8b9c072e905c6c5018083c77449b66837fb52931a4" + }, + "scalarBits": 32, + "scalar": "0xc1b0a07c", + "Q": { + "x": "0x15015b4432f231a508ec7869918398a07762d9aff556eb6d33d3f020b6e00cee5502ba15298c495d05cf971d83be728c", + "y": "0x19dbc0bae222f7b3e9eef4b882ee16ea5600d68397d63f728c5f4a063d0530439e7a81f2d5ce3b6f8e52b0603a7826c3" + } + }, + { + "id": 11, + "P": { + "x": "0x52d11071520273b521751e5d56b7c9604882b59929c0bed839bd7e2666aee26626b399ec9f75a7a520a1b596fa30be8", + "y": "0x4afbd7de3bdfff5e255cb4fda50fee4c231085b93ebfc646655a1ceb2b662da3dab71931184c81970610f935de36317" + }, + "scalarBits": 32, + "scalar": "0x1aed611b", + "Q": { + "x": "0xfb0f365ea60507387331a1b3c08fd10e6bd19956a854a148e19e5a0798575d39ba7b0f16cfe28a61b3b07be8cd74c5f", + "y": "0x14f0c7a6e84a7ed69198f03a28d3715d551b5b52f5608680207d49473374239fd897047daf4b5f7ec261b2aca430dee8" + } + }, + { + "id": 12, + "P": { + "x": "0x77a17f74283edf389a7cdba249658d774c65f3ef48bb6fd68c6afdd6ff586048abb0b22e132f64fa915f3ab40025736", + "y": "0x1548dfa4c45a57d07e3750003c5541a9b2d4e90b313301ab944e0bbeee088145de50ccf5abd0a3707af4f8fef2fbb42a" + }, + "scalarBits": 32, + "scalar": "0x74f3bf8a", + "Q": { + "x": "0x16559423efd487c2f612334415ca6242ae0a4c86977b1d75a622b568b488379ce67a4d3264e27b4ba2d24cf95756c962", + "y": "0x11ab7fd857e96c9bbcab283ae7b900d1b8f7d89a9ca76be95844c59355dc94749005bf3ec347dd21ede07a56b694b768" + } + }, + { + "id": 13, + "P": { + "x": "0x146ae9eaeae0a00bd71795be6e2526e0cdd235a7a09c8de701aa96b5aa7814317ba7d90250fa407d470e629a91ce77d", + "y": "0x1843546379142e89d437a538f68679ea4b6996a353e044387fab32c77cd76d7f35281d297f35162803e0c07d94c5be63" + }, + "scalarBits": 32, + "scalar": "0xdc6be772", + "Q": { + "x": "0x1725bb079251ad350b662b1c6bb414c2c1da002a9e52c61324a34f0a357bea8cb71395698441466db1bff48b4cf1a413", + "y": "0xca89352cdf782f851cabc5c0690751f86cf7b1424f0b99f8279b09a1fe95c5c5487a599281cb716eead54a8fac4e677" + } + }, + { + "id": 14, + "P": { + "x": "0x1978eb71e394838a4d6a8d8c10d17c8c776dd0066268bf9462112a7520af90b4d70cee45af20fa6ac987a184b45c775d", + "y": "0x4f7a8b298ea8063cd81181a04997a5087e9d8b2b9af7b43183f3e42bbfe8aebd2780dec4627726aad1b301920f4c746" + }, + "scalarBits": 32, + "scalar": "0x88a03f37", + "Q": { + "x": "0x79442ba371272511fbc937dd2cfb5c32128bb7395d97c60ca04ab0666a3512752558726f5dfe153ff0e076d031246fb", + "y": "0x2d348813b82afe22bd084db5cb13c9b44d037bbb131dd0156c95b3706e066c7e4389a66d8f6f5c951f3e0941f3df928" + } + }, + { + "id": 15, + "P": { + "x": "0x9ecc4b29cfa536d500839d7c63323dc1458581bad447e04da54b36a3fc1543e5882bb52c9dfd88a15b75b7b46034707", + "y": "0x84d935558c3b747289edc70e4ab1be6115016c2a0e2a43e8477c53573e9e4fcc5d10f9897c1f4d23091c565c7f97026" + }, + "scalarBits": 32, + "scalar": "0xb4294fba", + "Q": { + "x": "0x10a37a78d206ab23fc43e8e66bb32861a5e0a6f5353505d8b32cdceca13de6d5eb4aa3a941120c7a20d1bf3f90313af7", + "y": "0x3d278e83bcdb1c7aa33c7fad61dc1836954b30f56eb6f263933e695ef3b21b1d07be1b7ca92412e2aa4b6cc3a9cbdd2" + } + }, + { + "id": 16, + "P": { + "x": "0x56d0418931fbce9fb682b6f03cec8397136df53ffdb3c6d3e0501b6c5561179e06c02cd067f335fbe96a51a6e7dbecc", + "y": "0x17e964dcc7bd2a6a4ff7b289f8de2feabd0d7579fbc534c0346f33699b3441e267f56f514b5d3cc36467e65428e99f94" + }, + "scalarBits": 32, + "scalar": "0xb9b70552", + "Q": { + "x": "0x1959481a69e1bd99ba817cc8c70608be139c2a4377d6289f175bbd0e8e7515c1bb31f0c3c17bbba06a207c4cc7584217", + "y": "0x78f21497c7dde161c89cc8510457bc64f397c86f6558a2d4a92c0f394a3678ac38d5154403a45281ded149084b3bec" + } + }, + { + "id": 17, + "P": { + "x": "0x170fc07bb445e586822c86def3a3bcdf9cf4852621be9d0495aa5e6c7b32ef8a1acca52414465a8f1022838b53241233", + "y": "0x8dd69c5b50a8b40f456dc1ca420e0df713c8c9c9a63f0a4cc74d4552ceb3563291ad4962c78bab49c32bfb44e74fc4" + }, + "scalarBits": 32, + "scalar": "0x61bb91d8", + "Q": { + "x": "0x828db4ef059ce32c734e50e5bf7d5f36b94200a88d5632a61b417540ad4be7754a9c6c3376f0a4143a872cbdec00e35", + "y": "0x51a26852df9f448f2103fc8f0730c8ef07e65a6268402d8abe0c06f1444c05c4bab1993d262f14c563faed22f3e4be2" + } + }, + { + "id": 18, + "P": { + "x": "0x174d0bf464228d5545d129fe45f93818ab1cb9d019888539656e29f27cf96ea04cc49e84e3080ccd7da06d17b8b58ed2", + "y": "0x155fe68423128709a55a98139ff9616cd2698d03e2d64ef4963831d77ac72c6e49aaa5b9966853a619531cd8404a3f7a" + }, + "scalarBits": 32, + "scalar": "0xba58c87c", + "Q": { + "x": "0xc735e70f452b344eadca2574990c475ed46f13744e3609ac142c64d180e65046e1d2699b89680a8a8e1709cda72786", + "y": "0x86eec3c0aacd7ca86c7bc4f29f8e7c8d00f61a8ff1437f49b19e44beb24258800d7be1260b6983664df4e6e81b1cc12" + } + }, + { + "id": 19, + "P": { + "x": "0xa995b66a1a4ffd6fabd680db36759dddb5c6490e7539a7c7a7caa7e05d87eebc11397c4ce6d0a85ebc51ccfc36e1cc7", + "y": "0x6c8a789e2d007e44fb9b8bb39068e58bf49117f4f0852a2d9883e94a6c8ee247813eaa978b9849de94d6ea9ccb90ad1" + }, + "scalarBits": 32, + "scalar": "0x871bba98", + "Q": { + "x": "0x118763ff22ddcea9d916847feb375f60695595594ea3a036567cb4d63b126da673adc3177ec46f93efc2049244847c7c", + "y": "0x288dedff136d21b94109c5b42c4d9661eb344a87518c0c33656ee849d82107991cb54e6110f9d7e7073249d70510db4" + } + }, + { + "id": 20, + "P": { + "x": "0xc606af8897934691f1268f8caf617a2c9e99e53b92f5bcfb9dd53a097a439863ccd5a8aab6127cebce8d4077b561de7", + "y": "0x11c32b0039d6a9c3138027ebfcce4149e9b319e3af1095771e64d536dd33a6396063bbe03a98960ae21a00581436e0ee" + }, + "scalarBits": 32, + "scalar": "0x1b0d3134", + "Q": { + "x": "0x17f8c0e11c79e05051de70261725aec8d4308a48ffd2d55f5ffff9683007aa53965a0c52f7e936a20ceac2480327ec3e", + "y": "0x131b3dc3e471a6b0633f74d3c3dd0a7c2480c82b4f994fd63d3245595fe08c5d46c1a5b94be021567cdbb7113984b48c" + } + }, + { + "id": 21, + "P": { + "x": "0x3a0513c04eec850c24d259df0bb1debdfb1d74679d3602ba0385af17155f1c6359c07c9b05e63a0e63732888e2269ea", + "y": "0xcbd3801c82704e8f6e2e4f62bd9a00ab2a9aa8fd6516a99b52b75165cb75b001267775f54a5c3d83d9c7e2fec7edaf" + }, + "scalarBits": 32, + "scalar": "0x7b47dcc7", + "Q": { + "x": "0x6bb2360167bfd681120258c4375b8637f1ade707325e8de9f3fb4e6a77c9997ca920beca728ff0113beafe1315c4154", + "y": "0x1159c1f735cf1b1329a4ad2827a874af7496e0c02c5b9f76d337093a5b4172a8b407318fb65f50c25415b299f84044da" + } + }, + { + "id": 22, + "P": { + "x": "0x4a02e28bf143fb5c4d4e61e973f398992447cdc9601c690e0b133f1564515c4e147f59f46d83768b27bf24ba6c979bd", + "y": "0xa06495abf6090db7fc22026ea250f7088deec3eeb5f4f7f1c4593862a250f0e1b1bf01d96b29a5a18367fbd93c6bb93" + }, + "scalarBits": 32, + "scalar": "0x479d6808", + "Q": { + "x": "0x199c83d29e973f71d7cab80ed06df98824d15c6c243e66de1a7e8318cf81f19ea18766a34a4ec701e0351f048e3de802", + "y": "0x1732e3da1b16a2f0900b3b718145f25c6a1e20c2dee5998bcf3c4f5adb85834707fad6bdbec6f6ebbe1fb5818917c94d" + } + }, + { + "id": 23, + "P": { + "x": "0xc55fda76d46fa0908b806d7539c290c087d6eaffe947ccf904ee633b8f7064885698a740b2c8de846a9f37b43b28d64", + "y": "0x19fcb2d61342b19c2826600b4d1714258fcd2b7fae022b93edd021d6bbc151111e8dc9ed75dd9029cd063db0a039e8aa" + }, + "scalarBits": 32, + "scalar": "0x963a166e", + "Q": { + "x": "0x13da9e19f3a046450a46c14345713b89cbc62415b503fd342b2249a899f4026abc620f49de8b0e346ae54d3f7430494d", + "y": "0xcaf585c8c1834ef448514098745c9b7ae1cecf93eee86b944295a6ea4d51c083401d72e5b7615dfaccd68a207a06f0b" + } + }, + { + "id": 24, + "P": { + "x": "0x10471438d9ad230367d7c042ba048fcf17019398904c341eca4c6a1f443122873d22415a2ef104ad50deb614ad970fb", + "y": "0x128a411e93836c3402b995c4646682592062f7a2175c4dd4e50050f30c9cd47e89c967fe1c454bfe740f90b38323a56f" + }, + "scalarBits": 32, + "scalar": "0xdca09171", + "Q": { + "x": "0x514a2c427cf901e62f7a121d7a706d4cbc33e05df1edf4a414fd48860b7c85287b691f49d9f34ab950198f74fb4d73b", + "y": "0xd4688db2971602544c1cde589e290b32d2993899b37fb8ba0ae15875f06f3b47f125f123a09cc7fc774f1dfd83f2de3" + } + }, + { + "id": 25, + "P": { + "x": "0xe3e863326c723276346c8f0592281a24716316e5601c511afde1619ca4c5c43424d0a1061734765eee36113f206a226", + "y": "0x1464aa14ad32bb137abedbe635e2ab41415a7cec11b0ebd469c69498d3cc91774b5e721563045a115c19652a1a5e208a" + }, + "scalarBits": 32, + "scalar": "0xb8f01673", + "Q": { + "x": "0x196bff3a57ff4aece575df3821ec7146d062eac524bbb018af5b7b0d8af6e989d87e50c4f1021d7f7586a64e389527c9", + "y": "0x1757435391b78649ee8beccc0a0ee220dd13dd9f084c3b2cf4ac09a12349047ebce4c2de20bf4248d72efe01e4dd1618" + } + }, + { + "id": 26, + "P": { + "x": "0x148edd5b06ece0e0e7debec975a5f080808fbb3c8e1a603affaaad5b28339b150b3f5d2b9c0ce906a0acab327663f10a", + "y": "0x12df62eadb9a99ea85a0ca8bbc59abfd65333df9e5e2cab8038a097c2e77f3e9d30e832c8e66f7790880597a4a954b7a" + }, + "scalarBits": 32, + "scalar": "0x7b9e643a", + "Q": { + "x": "0x16e5174df49da91c4d412b36f7fc6ade52aa2dbaaac1707b300a2f3edffc665fd94ff6af3b018a4022c111b92cdbe224", + "y": "0x118a12a2a19b94090be309e7336ae64373f1fa202fd2ac57297a0e381da6ec5dedad2253992f1b0e686461152900fedc" + } + }, + { + "id": 27, + "P": { + "x": "0xea47d61cc4baf714d181a79b27b73b621e5643b6a9950d9991472794772a3a347a4d911f48a343028540d86f7eaa312", + "y": "0x3a5e9f5ca3db244d291b6dfb61b91c0f6ae39fbd22dab59873aa3ecd6462206e490d279399d553d5e062c46445960f0" + }, + "scalarBits": 32, + "scalar": "0x5a4e34c5", + "Q": { + "x": "0x13706bf8974eb8440a38a630164901ed7ed1120b8c5af33149ca1ceb5d57c69553b375ec91b692ca2723cbd7932cce04", + "y": "0xdec1256027389e05242419a8736fde3d4007d5a39e1c1ca1337e3aa61877a738adbd038af074949fb728b1181df9949" + } + }, + { + "id": 28, + "P": { + "x": "0xfa8173ab34ab0c9ae7edab399ec7ce2d7ded7b3bb16cdf0677327cecf58ead849a9f283b3ad4d586203e272672a76da", + "y": "0x13513ae1f66868ee77948fe0af6bc6e65e679310dec6237296be8984d6f73ed89b902a83d67d50b69e3c717848602494" + }, + "scalarBits": 32, + "scalar": "0xa5678fc3", + "Q": { + "x": "0x6b0131de70871cc1d8bf0b88d39a1093c8a15ca9284140b7a56c3259dee2142b086d0e86d8947e897c0fc28693f98e7", + "y": "0x103ae63c8f6e44016a5d80e49feb11ea8914d8a05eea8a2da4ed1e403fb9f7ea54d73d8e931ebdf78b77ff799d79f8d0" + } + }, + { + "id": 29, + "P": { + "x": "0x12dcdd85a8dbef6329adf4d2697af5549bdd8bd8d8887967736de5eccbff23341d8ef4ef59993893cf10d37a4174b5d0", + "y": "0x1500833024089b79f247a7ed9b27f2d76090535c0236e77fa6e732e68323160a45df7985b5d7f4893faf817e2ee6f83a" + }, + "scalarBits": 32, + "scalar": "0x17acbfc", + "Q": { + "x": "0x251a5ed4bbdc7aea507fecd18e907d0b50e2376c461038fbccc2edd80c9d62e3c20b39664d41b376ac6f63feaf4529", + "y": "0x1513bf3dac367b6b90b6e6dee98c4eafeb9be3cb53746d6d247fd3160dd70892a2bdc19808508eddc12096f16f5bfe7b" + } + }, + { + "id": 30, + "P": { + "x": "0x1924ed3233fd751d5fb3134805b38fa06b231e84f40f0507eb0fa17c96116fbf4dd4c9a6d3cf16b69c9dfb33a8653027", + "y": "0x17732a5eceb6e772962af07bcc45f06ae5bb0ea04b58f953035c81b1203263b8b78f87ef81413e09b4e92de45a1191ad" + }, + "scalarBits": 32, + "scalar": "0x5020f926", + "Q": { + "x": "0x56fc5c0f9aa14c2e8c4febc50b73691caf420db237c6b47532ff33258ffa99fb9de5c30898f80762b29396d7d4dc8f7", + "y": "0x1c0b4802c0536d2aa5ceaf81c0cd4037cd1cb0e85caff87c0ac85d9aaf9d4a7cc260af245264304c568d077f80e8ca5" + } + }, + { + "id": 31, + "P": { + "x": "0x14f176daf3e04a3179bb407ab0519193e60052787a3d8d96025cb7635c491fb5f41c0b4280d9980d1b1b8dc47a86031f", + "y": "0x16a4bab6248a7daca80c4f46d65d55b9d78101b170837b191f641a859379a89af4d6d0a5b89f30f31270aa3f6a38725f" + }, + "scalarBits": 32, + "scalar": "0x2606d068", + "Q": { + "x": "0x1696bab42d2c22c972069a10851d650a314a708c13108b49f1928ab847bc101d695e42673391ba9b5460cd2338b1e775", + "y": "0xf5a30b258208eb5d1a86503bf291b4bc6462dcc554cfc214e986b865fcd2fd23d7c3c717917cc3f4b5ce64040dc1417" + } + }, + { + "id": 32, + "P": { + "x": "0x11a05200d2acc6a41bff9ca503f04da150023e732e9b8c59b11832081ade8e031228d911de62f6229113014a92ec52d0", + "y": "0x9c9f9257168d09c0a277a6f0815e5dedc5942df3baded6f520e7762e3790dec946adc84c3c87cd63e8bf9bee6d56e65" + }, + "scalarBits": 32, + "scalar": "0xaee449fd", + "Q": { + "x": "0xd5cfc86ae5cbf193e96f6e1c57dd1b93df79cd8fedfb5d939816e03a1b0b1ba153f4d53e115c44faf904835e95a00d5", + "y": "0x13eba05dbeb89d7d251d2e75fe99d3d373f12fecd1a5d613bad6280c21d18cb28b6371a03dc6b4b35b3a72671ebdab58" + } + }, + { + "id": 33, + "P": { + "x": "0x194d9fb9724d20018b4bb04703314c4d13253e2299571ec4a25b2a186ceb68d2333652517d48239eb9eaefe73fbb76c6", + "y": "0x161b2045d5bed7a526f4b6c23d63b7f746654a3bda90cc94dc750ea9a0f4e78765a408ad9ed141e50ebf46174a52dcce" + }, + "scalarBits": 32, + "scalar": "0x6eb7fcaf", + "Q": { + "x": "0x14a855a9054948ca0a1d9cdc1cdd694ced60ec551e4a94832030bf5059a24680326f999227e97f7fbcdfb432bfce8a8", + "y": "0x11c0efdcae4a77c0673c03f17856f7e483c74c563978a74da252c9726ae4a539f502ede4278ee9766734b754944c8cd" + } + }, + { + "id": 34, + "P": { + "x": "0x82661134d1c0dd8d58ad877ddbc88dd03b2d639c945e710c9d2817ba9194c7632567b09e814280e45f00a11e1224d26", + "y": "0x5747f289ad126e446f97b91a3f702008a53a46a9b002620462104a52a44036ebbc2fe4bf086ae42871be36afbdb141c" + }, + "scalarBits": 32, + "scalar": "0xb3fd7777", + "Q": { + "x": "0xa72cdf08bf75ed62136b016a842048ad67b9986f5a9d721eeb9b490de490b19f2cd73056f0d4577e41ce58262145407", + "y": "0x31a0be19ba5a5eef127fdf9fc358f5ff9fae26283d96858b0b4587d0452e651904687a7d77f16e221097fb434f49b7d" + } + }, + { + "id": 35, + "P": { + "x": "0x51f38e6f97c403a87040bc2d923daf77e2e1737f883d83051098efd25a2ac13481bc5e61cff7f205ef7e202c4a2493", + "y": "0xbf5de08067493726055d85f85c8c2dbeea490144ea19376f1a817de80a19d0d14573eaf01f40438dacecde3ed376d85" + }, + "scalarBits": 32, + "scalar": "0xece1e905", + "Q": { + "x": "0xb035cc12115710c0f27b2a9ca84047a1bc959a6f46bb5ed051f4b9ab87c95078ae8986bd719cf985c34a18d3af3b428", + "y": "0x51a771da53b70df4a360a4d9f94a98a2330d3a1a0a935fa51692da9d4ca55d3ffbca77ba91e52f32f3bf92bd31b5f7f" + } + }, + { + "id": 36, + "P": { + "x": "0xea554e37dc92836928eb689ef6a32026a169e425d6dac13a7cf22eb669389cfddaedcbd6ea6aef9fc39b3e3a403c7ed", + "y": "0x6e63f4df492b91bc043f307701fade6fc525ff3306b4439646d537557e6dcb7ea86b4d02c35ddfa28121ad543eb5e76" + }, + "scalarBits": 32, + "scalar": "0xed10e8c", + "Q": { + "x": "0x58cc82d4f447d54426a0de0087597b87457e3a4acaa80de3dfe8dffe5853c9710de12bc0e80eac6e1a8bcd8984f546f", + "y": "0x172d569490df1ee686286392b041422cda3f9788a93017647e842cdbf0cce3247acdb800705d70459078058f1437081b" + } + }, + { + "id": 37, + "P": { + "x": "0x130a3573030a92846d50883fc850d94d15b9a432e76be085deb7598ffbd6a4ab70e6f7291008db1c8a5a95097ee80c13", + "y": "0x14fae8d05d2a1d0a7daad4ac714f2026223ca407d0b3c0efbcff401735342e1c2663260e464a812a5a9982c6bf54f4cc" + }, + "scalarBits": 32, + "scalar": "0x165f0093", + "Q": { + "x": "0x934a6dd59ef61afad41e963d3144651085673fa1c33b6f4a385cd67dc72d7db24ccf812e918170a13da2176a5f5d4e8", + "y": "0x1165bb7b55c8e948e7f5b411911835a2877ddaee319d94a50e7feb4287f1ef471ae6918c7f7c1df08e37d85d3c10d571" + } + }, + { + "id": 38, + "P": { + "x": "0x18d05268651a83d0f21b7a1431d223e9b05acfda8f17bb6eccce2df25e9f5a4b87fb24c8c41b19c715aa72bc3c1e97be", + "y": "0x13a0154640346aaaf8208ede97a16640d395ad97af7bdcbfc12c5bf9cd05de1dde9c79345cf085b2e8f1ae924908d716" + }, + "scalarBits": 32, + "scalar": "0x10a8dfa3", + "Q": { + "x": "0xbcd7f18e8bee6bc9c2cac786168c66e56bf24dc0ff161f39a8d429e256704232b4006fb861565ee56d7fd052275f90f", + "y": "0xff06a0e836a6a67d8b595c7b4ce60ca0fd0bb2a6d0a7b35ca4a14cd93fd122d712b76e4f51654210a23d34a2a40ae5d" + } + }, + { + "id": 39, + "P": { + "x": "0x1332b0b8020a3019fae7b38b6c247437344d04594338845dd22553acd4b35911c140456275a2c1aade264ae9f61f5157", + "y": "0x4cd4f84203a747793303f06411139805a95eb5c0523fcd3061fbdc25cf0f560cc0f93863fdb6e20425056c139d08942" + }, + "scalarBits": 32, + "scalar": "0x59d0a657", + "Q": { + "x": "0x1394f84c852a88a76e41cf18b253cffa9a96abf4f5f2a369ab1a2a855d4dcce70e54b1b71ce13c805c0b001b0fbdd7f8", + "y": "0xb213d29cf2477206dee5276923f32c17b48427e036f2c78b3d966a98a5aa8db402f13bb597c4ce43d1f24c7ea494761" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_64bit.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_64bit.json new file mode 100644 index 0000000..b66bb62 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G1_64bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BLS12_381", + "group": "G1", + "modulus": "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", + "order": "0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", + "cofactor": "0x396c8c005555e1568c00aaab0000aaab", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x4", + "vectors": [ + { + "id": 0, + "P": { + "x": "0xf9679bb02ee7f352fff6a6467a5e563ec8dd38c86a48abd9e8f7f241f1cdd29d54bc3ddea3a33b62e0d7ce22f3d244a", + "y": "0x50189b992cf856846b30e52205ff9ef72dc081e9680726586231cbc29a81a162120082585f401e00382d5c86fb1083f" + }, + "scalarBits": 64, + "scalar": "0xed5cf2789f7cf5b5", + "Q": { + "x": "0x1309777655b840eb84a46700295f9e1ca4417e788d9e770da4959b39a8f54d610640da1211ed3759fbafcb51739ce6d", + "y": "0x162b67b1b9ff1d4f8c2772a880f58b7ad1eaf09f8c55b67fbfc7a8748f17734ca1fa2f301f5caa52e29cc9bef50f816c" + } + }, + { + "id": 1, + "P": { + "x": "0x4506056b1d34c04c31dcb0fa0fd3b5919ceaaed08298e8cbf8f67b2fe7fca51e86a0d4a6c83a80dab66f4e91ac54a3e", + "y": "0xbf488e181dfe9529cc44c27e992752790d8c9a3dafabbb1eea15810817bfd73e3ae8e3af76b1f65027618c8dfc998de" + }, + "scalarBits": 64, + "scalar": "0x209321ce5a15181c", + "Q": { + "x": "0xe038e08bc644a8fc3d38017ec5508cea6f55083623503cec1015faa6edbe1cf7b6ecc18aac9d4598059452bd8d1dc21", + "y": "0xf1c456b85b3e08221f9f23c95e603534e0b304ab8828111258595b627307af14ca58c44bdd2cc1867c6125aa17ca242" + } + }, + { + "id": 2, + "P": { + "x": "0x161c69cdcb0b2cff389b8a359bd4d7acb9de80d958a639cbcd0d1d06c3903469eb000a23305d0a188eef44305ef3cdcc", + "y": "0xa13a3358db0105647fcac1ce35fac1bcaeede283624d62ac8fddfd3b2ba16dd4230dccc7cfb92fba8b7eeab14a4d915" + }, + "scalarBits": 64, + "scalar": "0xdffbdda402c93079", + "Q": { + "x": "0x17024ae26009b305604f5f924dd8265320a02deac046e982f38749da5dbe123a7dfb85d5401c553a3b71b9fb95a69e05", + "y": "0x95383dc9ed8eb23a5972e170c4c99c3a6a6e5ce28eeddb708367ca4074665199f288f85fb601512593ba7661432d77c" + } + }, + { + "id": 3, + "P": { + "x": "0x502266a82e58a6defdbda296159a82d544b191cdd9ff0f28c1e21b2008d0bcff37aac0a24c1c9ea4f622e88fe690149", + "y": "0xdc935102d8a84887a950a9903260a0451ae60fa22ac2f04ae43c61e3143090649a49851ebf3ac9ba695ae29d60d473" + }, + "scalarBits": 64, + "scalar": "0xfb76c55f615c2a20", + "Q": { + "x": "0xb52aba7b4b1ab7a207ce1d3d0b23adf451aad55a5a5c91c85253a905e005777ede9d7ada5e0f927dd6a8d37aec3daa6", + "y": "0x19bc06a144bc3335f70d4de7b36a68df03a82eeb9cef7caf13f8efdd140e46f541b311c68f9fc966094bf64b7c76b4c6" + } + }, + { + "id": 4, + "P": { + "x": "0xdf127083c2a5ef2388b02af913c0e4002a52a82db9e5ecbf23ee4f557d3b61c91ebcfe9d4973070b46bc5ea6897bca1", + "y": "0x318960aeea262ec23ffdd42ec1ba72ae6fa2186a1e2a0fc2659073fb7b5adfb50d581a4d998a94d1accf78b1b3a0163" + }, + "scalarBits": 64, + "scalar": "0x263940b5054cf45b", + "Q": { + "x": "0x118bd048325e56f96f6c5d73a163350cad3bba326fede48e84f12738029971029da617ebf5015d2ace21f7fc1dce43c8", + "y": "0xddd5c0a054661f75bfc0e10ec64705a3a89e3a0cda151272e9f20fbb2b11ee632fe41740e74f137102be7bcd17b930f" + } + }, + { + "id": 5, + "P": { + "x": "0x1222b58d922ca24aba0e7ef52066454a8f58d4baf9886161e746d9d2c91b1262158a33a2e352e4a4dfab737a0e13a40b", + "y": "0xfc0673d708af56534c38fc97bfd44961b95ed088d54f86a20c885fcc4bd6ae37bed203638457a9039d62126ab0dd84a" + }, + "scalarBits": 64, + "scalar": "0xc3ddee8138f1ad31", + "Q": { + "x": "0x90bb61ac720f1c2d670cf888f5a933e05321a44a33976d80fc709c544811e68e71306f3c2ca45f1bcae69e8041c6ded", + "y": "0xe1f4c852c3f2ffef28f3fb20c80a61b4511402bb502a04c68d2877ae4e9f85f8d526cfea27301cee28bf3afd2a956e4" + } + }, + { + "id": 6, + "P": { + "x": "0xeb207a6e9ef4de4295c4f4f2d82a046c4fd357cc6ce88a30088d9b0fa01293ee2ac623d3e08e11366e22c4d6503ea36", + "y": "0x11d5203e27b9c83aa3c57acd0e1966606be3df47938b349a247149ab1479bcdf30a5ea8bf2a4daccb38f51ba94aaa8a" + }, + "scalarBits": 64, + "scalar": "0x918fe196e5c973d6", + "Q": { + "x": "0x19237034cd10a0fc80f3a2bd821c4ef2f8b8ac9e9452ea663b77ecb06e39ffe92f319b378724cfaac22547bba0794485", + "y": "0x14225a18a6354b4253c84b5915b1bec85cec26ea162bc64ffda80d44ac67b102bf5cebc78bd70dfc3ee7f9917f72923e" + } + }, + { + "id": 7, + "P": { + "x": "0x7b633cf2b9a6645d69c476c433bbd25ae40f5b317fa3893c52b6db601fd8d53d5d0adb03af2c32e249669879578154d", + "y": "0xaad031032fb1319374cba413a0eab624e9fdb4c92a946a32050f1f3d8ce0b8f2f24324ebea902bf8b23edd7b5d43863" + }, + "scalarBits": 64, + "scalar": "0xe8703f57aed5e3fe", + "Q": { + "x": "0x10352984e593700f6722aa11e53da1b5b94f063fff0276a8617f0c05ac6385693082fdfed5cd97eab4aba36c1de9b1a1", + "y": "0x18a03ea6da3f59bb99656f3d9023893a557c072ba1b429b048c728adb121ffd90b70960997f764e9e2070637d44705f1" + } + }, + { + "id": 8, + "P": { + "x": "0xdd663ade070ccf9c275d889e34f0873fa6120215725021e421136d410e7d3ba8a96e71ed069d2ce796ff427f2e94445", + "y": "0x1662c1660956c88101fd89eff6b4d21601667e9f286f1101944b8b7374771217f11a9b2e747e41576790f7fa8bf2817f" + }, + "scalarBits": 64, + "scalar": "0x4f86ce29a51a4149", + "Q": { + "x": "0x170af7a7ad0fbbeecd2777177340f2f90049ae9c576599c810c9f02ad4bada360fd63902ab1ef81b9804774de00e260f", + "y": "0xf8db82284b067099067a370b6c7dda2d3deb825230d46def48bcf3b67f7fc71efa1dbab4432e5f236226434a4afdf9e" + } + }, + { + "id": 9, + "P": { + "x": "0xb6bb1118d71294e32be7fb0e03786f850f8c3c47910a1bd1a4d696786fc59c8198c0b4f90db2ea0cef9e384ac3c14d1", + "y": "0x156603c7f938ce8379e6bb0f725b88705681b5d9be8fa55066264851f8fe7711b260171b48d487776888b595db1bde7e" + }, + "scalarBits": 64, + "scalar": "0xe6c295274eab6594", + "Q": { + "x": "0x811fc4d380c63624fabd136280b51c90857dc6b6adc8c7b8566aa24b752db2f82bf82e6d84889a1222be11f8a7b91bf", + "y": "0x155dae56e4609b7ae2df94261924c5c418d0a66f27b48c2af0a3d6833f23c93c2d27b75bf0a1f9161dec2df01e397730" + } + }, + { + "id": 10, + "P": { + "x": "0xb3da1435e0ba6973b80b3684347ab872d66b2bcd3c72958df2e1030a36131e67e5fce4b37f1a839a0d67f2392ca0809", + "y": "0x183c4df403dda20da4667d1a8a4b475fec9307d02c736a32149760f58c5850d60a83570e52eea79eedcc74b72d9e162d" + }, + "scalarBits": 64, + "scalar": "0x45e03e08f628e8fb", + "Q": { + "x": "0x103ef852c2a0dcf688abf7a630f684e32a4dc553ba222549059b9ef29296031341ec41f9926e610b449012585e002d5d", + "y": "0x10d368c6a006fcfe89aabb913542a4a6ec168117e6f0ad3131d2c789f9c7c06f93ffe289d64e13e3bb21af2b350e70db" + } + }, + { + "id": 11, + "P": { + "x": "0xbe4f9f721d98a761a5562bd80ea06f369e9cbb7d33bbb2f0191d4b77d0fd2a10c4083b54157b525f36c522ca3a6ca09", + "y": "0x394e08b6baddbcf0ebcaaee6312fb5a593fab14f78d9a4b75d111d3ed96d7e31c03473f5c4c6e6b6689618bbc6dfa5e" + }, + "scalarBits": 64, + "scalar": "0x458e1e4e74d7baf5", + "Q": { + "x": "0x479835e2e5d727e0575c60de58fa3bcc4b4fc7fbd353c00f74ff6e086ec131449888cf86112b5ce508c45d81c0e80a0", + "y": "0x7b00a9a46c956e269ae3351adb8eb9ee8edfffdc3ca0e4cfe30442f8460a8e50efed2faee1423ced8349d3f79682c44" + } + }, + { + "id": 12, + "P": { + "x": "0x10a8b757c6ab7e99458fee9176da5c16d254f59a0d7afbd761d73566d6bbfefa7e45b58855b9c1b442421c6f0e8b4140", + "y": "0xc427d4bab34802176e5b0d911840be0768825ce58ab97b7ec2a3597b3e0e873d78557088dde4e5719a17a77313e8e42" + }, + "scalarBits": 64, + "scalar": "0x5f0035a647c87b57", + "Q": { + "x": "0x195453429f45c2e695d67e5bc07237bbd4509e66d702f3663cfb774fb574eb6a774aab81d22ba07bca6bf757bcb0561d", + "y": "0x1419ff42b1108c7d83811a0d76b77a9d24d313acd85c298df7484413b3fe646d1131bca5bea46d20d804c0c0cef1d8cb" + } + }, + { + "id": 13, + "P": { + "x": "0x4287778d07cdb83a658a27d3a39dc72f1e83db8c22a970f8192c58a71f9840d6193e71e8edcd05178ae4b1b06a091f2", + "y": "0x10f4b40ac89589a725a60c449cd7772e4094ea6dc8149912658b5d44e232f66118565cfdac9eefbb19b90883d75eea24" + }, + "scalarBits": 64, + "scalar": "0xbbebe21067e336c2", + "Q": { + "x": "0xabecc3e7ffacd75887bc8f61db037b34e96f17884f6015d5f53cf41ddebb04d303f532a022c5e9a2739b0a3664959f9", + "y": "0x15cf5c60ea4bc24551265a335273c18fbb22e38d2898eefa5f7dce389d58917e10ffb3cb91fc6be8602680b25cbfdd7f" + } + }, + { + "id": 14, + "P": { + "x": "0x166ae1d280df0d1240f65d4c492bc446545ebced6b6e34e03d3c65aba61bf12099968aaf41bc0f879d9ade5d0a6cc944", + "y": "0xe8b00f64386d94edc0c567d318226fbbedfcf1e2429036bd4576e634414f7bf9a8fef3d049f5ce997e102ff2ce4a62a" + }, + "scalarBits": 64, + "scalar": "0x72db2a4d1faaf0e0", + "Q": { + "x": "0xa81a228e932a5beef0769a66670985be5b9cc5d3420535e5420006be3c7ee3ebbe16cd484678f1f84256ffd1e2f5", + "y": "0xfda843c232e91c5c9f97b7838922285051b19c0e38b10f09f2a95e67f1482c0c22b2ff06b6171c8cf3df0fe280bc6ac" + } + }, + { + "id": 15, + "P": { + "x": "0xa2e12b89f04cc3f319630b319ce1082bc2e7a63791a875fdddbb32429fe5f2360da0149a6a298a54e1633d5a3c89b4c", + "y": "0xf59e2532665e8c4544788e4e482dcaa17cf2f4e9c7c7fc4a26c3b72d3ab85acc0f58c5f003343ec6372fd81e5624626" + }, + "scalarBits": 64, + "scalar": "0xe2a1634b242d1762", + "Q": { + "x": "0x122d60332ec247287152962116f47d8e5b1422db002b5458e75dfbbb42fc0c8c2d334245756afac3e8a81aeb773da41b", + "y": "0x99390ac3d83fe660513d3377f4c0d5182de27ef8528054df90018ad79c25715f3b7a61946b978924bd87f348f638a22" + } + }, + { + "id": 16, + "P": { + "x": "0x57d7ff19c5cefa4b965addc401f82b39b32723efc5c427389a68445ae2a18f78d836bbe3a4c36c47c5a54e7737f48c5", + "y": "0x11b1c0e697b9480a5b77d95087b99bf59963f82efb473fc04160779a1099f2116d061d51ce0dbebaf70305082aa361a9" + }, + "scalarBits": 64, + "scalar": "0x7d9670df5b9f69e", + "Q": { + "x": "0x1008ba769da36e9f75938329610e9a46414c1614cb04c63323832fd73c95eb36b1238795824942869b817dfe51e12285", + "y": "0xc723b1317fffe63cfa43f9a2bde801f2745a7798999ca4d2c7d5ac65cc8b43826dc85121e040abe57b2313576383a19" + } + }, + { + "id": 17, + "P": { + "x": "0x18c014a00bce63dd3903ec2a9392c678ee9a82abcf88869a35a5b7488c5cbf00706b8eeb26b84325cef690b17f48cc1b", + "y": "0x13b86f4aa014f955dd7da5c86683bf61edadb973bc9802c79d28343056600564b06b5fdcbb972cc18347baf9ba9c1215" + }, + "scalarBits": 64, + "scalar": "0xf896ff8d5ba04ae4", + "Q": { + "x": "0xb613780bbba714d3d8ff58c43be7b2434b6bc921ec98b55c811dbd2742df17016459ce587f7299b97775bba3b9cffec", + "y": "0xb7160a7e989cde9db66e29ca40881e9b9c2f7e08406c4be4e5aeab043c4d70d85b6adcdb8f41b9297a5194ec6b663a3" + } + }, + { + "id": 18, + "P": { + "x": "0x49f7956545e2e871c75763edba12bb64d61270b9f8b9f2ad7bac7c885ddaee3d4b2b9624f08ac391da929c17f7f568d", + "y": "0xee2003b55880243d7cf572b4cf73fccaf6d80ea2ddfd24d92109161ed9c593d17fbcc136ff82b79a546ee2c448792b8" + }, + "scalarBits": 64, + "scalar": "0x20b5e6f20a9a2eba", + "Q": { + "x": "0x17a3078e06e9295db8b379282009fb4af2c9b41a710582fd83b68149e6b3c63740aba373f98a1a82c667a6e422bcde55", + "y": "0xed35bf977345f4890313c8b3ba7b16362c168d34f98077340b959af3a60d353448050bd519d8011df824a8b802904ef" + } + }, + { + "id": 19, + "P": { + "x": "0x12b8194720ab4706788a955093a41d805eaff672b3d09cdcee9865cd95fbd4694e62872dc8d5353b147583d8e37125d1", + "y": "0x11a617601ddecb9904ff871b196205c61bbf0f4da042ae8a3c3fd99ede4d06d36210e000f4a117a1f8f177a7348556f" + }, + "scalarBits": 64, + "scalar": "0x486477294136523e", + "Q": { + "x": "0xedd906042130818c4d3bf1dec14f7ace93feda5887f0877acbb7b8e98223b52e291178e45aab1ca3d8074a9d7427c3e", + "y": "0x1949ebe5dbc9f9a2870becdae51b1ae0ef1d3737b83cd93509b538001a2313bb240984d6765cd95c41f84f5a3c84fff6" + } + }, + { + "id": 20, + "P": { + "x": "0xfe5e0660a8ca48c008eeec2767d425686d2656e17993eec16941325b3a861aa37f101e11a62fa48a56684648c063627", + "y": "0x101b048c60aec9e76e55d091432177bc68fec44944b28020721083ee662c08fa8ae2f785aca81d292b396f1a59f5e176" + }, + "scalarBits": 64, + "scalar": "0xb6d73b7aacd57a50", + "Q": { + "x": "0x75267c0584c2c6679d7e8ab041bd59cac59a9ac6838451dde0b0a4421cf6810911499b43fbd635cad0e26e7edfd91a9", + "y": "0x12ec704c89252dcbe845b34d7d7a969e80d12126a7e94f20a4ad0140df23521e92568a1b1be1733ca5dcc2d6495cdc3f" + } + }, + { + "id": 21, + "P": { + "x": "0x18460311d37752e3f44312bb865fe7f2e266a3d44cc6a5a7e56c2213714f8bbe206de796e1e6be8fa48d70a169115995", + "y": "0x1976d267f8e8d8e4eff264f67087d838513f31f28e6021bbb502c8a97d12ad53667c9d2c29f2638c4e5484f2b072bdfe" + }, + "scalarBits": 64, + "scalar": "0x17df070ab2bea372", + "Q": { + "x": "0x161f7f7bd701515bb8ec1c61b674a05802b15be06244779ed49e03149d56e2f79a09129651f8fe082998e3ba602b573a", + "y": "0x1800ca3f13d8f30025fb7278a7bf86462330d11a275db00195f0ed7e8d38fe94bfd9b976c5fe2b17ffa684e10d929689" + } + }, + { + "id": 22, + "P": { + "x": "0x1762cb2e92c80fe3309c51976d0989b530eb45bf6ba345d728f1737bbf3991a3e0d1686ddbd28979c20e6047bfa66fa6", + "y": "0x19e009a6ce72d29129fbc68b18328b2c734a3400496431abe8412dfb9e4262c8615ddd19eb1a181014708382c72b2cd9" + }, + "scalarBits": 64, + "scalar": "0x1da4993ff8faadf3", + "Q": { + "x": "0x2bfc264d309a1cb55a949f9d5562e9567220414bf0c8bb018a7b8ea1074e29409f730c3bf9d98fff3c1b9e84806e4f", + "y": "0x17f353724a2c68867b5cd54c7938dd506074f8727f96d0e76bbb6ba982184174dcea89bebf22ade21de712823bcfbc28" + } + }, + { + "id": 23, + "P": { + "x": "0x178334f3ff0f2094fbeb6d838e4c95fba4302d13d14f5a36990d798eaa0785c17eda4084b0094ec10feb327c03716171", + "y": "0xd2d52f51352b25ec94708ad38c418daab879851c1f90bce50ea8bdef05f0ba213c6b5fda5c77a20b16a4df0cd239192" + }, + "scalarBits": 64, + "scalar": "0x8f9418f3a190f5f6", + "Q": { + "x": "0xd6d19c7afe824e77a5ec2cf1773cb9cfb6cda3e9f39177d746ad3475553f1ddd18862cce9a0565923ba6f2df2eea71f", + "y": "0xf666ffa0b32679bd48c1a5edbaa958d6fe6d572bafabe07235c3ea141786d886800ec4e60368a75fab70e7c602e75a3" + } + }, + { + "id": 24, + "P": { + "x": "0x807c89d6afb88a73df24fd9dfaea9b7c00dfe9f7f606e43fb41a362f4baf048ce84059343bfff7bd5cea5882eca189f", + "y": "0x16c553216a03c11c8fbb0cbc0da5955ec7cdb225b57fbb90586c390091bcef64014ddb02415b9a5c323ce29127ef9f22" + }, + "scalarBits": 64, + "scalar": "0x963a166ecbfdb19c", + "Q": { + "x": "0xe4d1b506e022ab809b46de624bd82a28342706b4e0e15664f1cb4d0b614a4923491bcecb1699df2cad16bdb2aa7e1f0", + "y": "0x12de68ab4617419da069a5a3cb5bc57f64f3a1b0a135955ee547a8703e64d016529f83a83578e7dfb288b638916d906d" + } + }, + { + "id": 25, + "P": { + "x": "0x10471438d9ad230367d7c042ba048fcf17019398904c341eca4c6a1f443122873d22415a2ef104ad50deb614ad970fb", + "y": "0x776d0cba5fc7a66486211f1dee52a7e441453e2dc28c4ea823081adea1421a594e29800950eb40145ef6f4c7cdc053c" + }, + "scalarBits": 64, + "scalar": "0x703935a5e0cd43bd", + "Q": { + "x": "0x128d8ff3b2ab10413ac5fb314a2e822228dbb73da85bdbb50f983e90fb7544fea01ec259b9c5302b0b45a047faa76861", + "y": "0x19a7531ac6eceadaac09b1007d866133f930e4dbd1b0b49a60bcfe9a83e2c89fde56827fcbc989b03557ca0f95496c80" + } + }, + { + "id": 26, + "P": { + "x": "0x110024107c51ce5a5036d2423fadeff348b19196beddeb2c6b65ddae5f21a187b43eef5a54ebd2ff23b3e75594a73c6f", + "y": "0x568109d79caab88736c927b766294800f3d2bbe5ed66543a278b4d2e889116cc59c365a84aceed6bab9ac23008ef9d1" + }, + "scalarBits": 64, + "scalar": "0x9f78715604a94842", + "Q": { + "x": "0xb78968a7766c98fadbf611cc6058a7fe661fbe829218ede60d63f9add9164305ee0ade60cb2f21621389fc6c1c67d87", + "y": "0x999f2cfd49068b4747f0cdef01df9de3acfef3d62f12ab875e85af9cf284dadfb50f1d4e020b2a851ced1f4d5615ce" + } + }, + { + "id": 27, + "P": { + "x": "0x74a5cc267b28d229c6bee3c57b447b0d050049fac649e7d70b3afc1df9aca8e92fa82593826271b50651078f1bb3033", + "y": "0x20889218bf21b41d11838ae2062abf708fb33d2aba509df10f692b45262180a7512a235d89a5816abc30a6d426b2f4a" + }, + "scalarBits": 64, + "scalar": "0x73d67e22fbda19c3", + "Q": { + "x": "0xa81234ac0dc6064086b0ee46eb78d5ea06590978b363c6082f699a3108b2aead2d4853d380f69635fe208b72a8c4834", + "y": "0x4f0a747918437a1ce3bcfd317748cc7e61c072dbfb16e6e663f407dae3320e362d630cff73fd1655ddb2b573e63c1eb" + } + }, + { + "id": 28, + "P": { + "x": "0x13b1c3cef0df6f9b00367e073646c7dbe893755691c658979dbf142c263ea78d5e5cd22584527f69243485d9e1c34924", + "y": "0x76759ede227623f5a268a5a61834688cf4642c2faefce2ee8520b76b5dd41719de054727dd1b4d8d7954c452a006c68" + }, + "scalarBits": 64, + "scalar": "0x2606d068f8caaf94", + "Q": { + "x": "0x102f0989e52a062c0d0bee3a5d18ddb67b04258c54449c18d41458dbdbff314307df1ae3187d4e0548a0fb96c60bde53", + "y": "0x174981ac762f832e7cd270bccb87de728c5c270fbfeed8120935297acd1e167e5349d930db09857b80f9d9422541f8d6" + } + }, + { + "id": 29, + "P": { + "x": "0x11a05200d2acc6a41bff9ca503f04da150023e732e9b8c59b11832081ade8e031228d911de62f6229113014a92ec52d0", + "y": "0x103718c4c81715fe40f42d473b35c6f8881e08a5b7d7255015225b3e1337e8378a412379ed8b83297b730641192a3c46" + }, + "scalarBits": 64, + "scalar": "0x7f59e2eaee449fd", + "Q": { + "x": "0x193e48440a6e0b40382a0c6af9a429f668198edf81f5c712add624ff982daf76852696cc7813a71d27ca9090e60c5b95", + "y": "0x147591e56f8058f04b603b477607948853c0fbcea6b84feb702d0c6a3f75d4347d7345ad600d86a870bf1f332a7cc834" + } + }, + { + "id": 30, + "P": { + "x": "0x1a52a9f7e4a5d94f7edbee5ce8ef51f7562334aaf29849d2c97886865a5f815cdf9e0738e7ac58fa183093de19ba1a3", + "y": "0x1fdf1468b264d5131f1d976ad391ebe4a1bd9a4532ae32431a2248c01b693c4136d9efcc5630b3d47a1c2b159b1bbef" + }, + "scalarBits": 64, + "scalar": "0x611b331deef2b14b", + "Q": { + "x": "0xacb6c97ffe48af47d6dcba8f06b363fc5f81160b9a089ff8102ced04da4b0e09151d484fa7c635b509b9019d9d68ae7", + "y": "0x1130c87061e433f9b60aa39c1c82fa38f112e3223a227492a6fffce85ea39da0ea7d2a27e041fec76581f621a0a0e469" + } + }, + { + "id": 31, + "P": { + "x": "0x82661134d1c0dd8d58ad877ddbc88dd03b2d639c945e710c9d2817ba9194c7632567b09e814280e45f00a11e1224d26", + "y": "0x148c92c19eaebfb604222c249f54aad6da23a71a5884ec9f210fcdfbcc6cf2b562e901b2c0cd51bd32e31c950424968f" + }, + "scalarBits": 64, + "scalar": "0x53abe392b3fd7777", + "Q": { + "x": "0x877112813b647a85d52e14b1a1afeda45881dcb2bc74a585a6c0c47e941b8fdb5559c70b9c48ebb6c659385a4a92994", + "y": "0x11ad87d40d8099cd1e7e330ddf3aa02ede42a32db65b345394257b0e83ed0e5887b2ccd3e05b29b441adb26322e56294" + } + }, + { + "id": 32, + "P": { + "x": "0x104cfd907a75bdb64f89874dbdf1627d3b7516cea47f1551fd4377178e2c87c2df8db928093994332dc74b77a8cc085c", + "y": "0x18c876ccbb76ae52d938df2206e155c9ab13a2bcf8a905b4e54b483cf8c1c09f40a348164669b287cdabdf65036ecc3e" + }, + "scalarBits": 64, + "scalar": "0xb489b6dd2cc09593", + "Q": { + "x": "0x81e8407ee3cd7f150210a6104acd9dc9eb12b89c5b6e859e613a8ca967370580926ad1e2f54e0f751c8e609bec3880a", + "y": "0x6e363af5b1bc9c925d46071221ef7b1abbab8a5a9812f16f0537821ed3fce73499b574430010689c2e752493a4a0f4e" + } + }, + { + "id": 33, + "P": { + "x": "0x1795d84f3b0c1d4da358825f805244fa86dd2ca72f073b261782e56a9cc572c65ecba2129f411e9af26639f2fee5afa2", + "y": "0x6499ca0c54966156556a868aa0a1d1859ceb33cd590d187a1f0807390505e8b811feb1bf904bebbce31c1967864d261" + }, + "scalarBits": 64, + "scalar": "0x8a94ba94a5e0a8fb", + "Q": { + "x": "0x5773cc5a53e79426141097fcbdec4565cafbd737aaeafd7ad6390b81810fc213454b8ee4399a0575385cc0f07ad362b", + "y": "0x867393b7a8d6abdb23771977b4d7c32bf57088754d460cff1975d4a6f2df9f58a40803c7176b55d77af071b33d27573" + } + }, + { + "id": 34, + "P": { + "x": "0xde50a5de033f41faf238b38e325eb40fcd29bdd288220a62926c99f4cf31bb6a5a00b2ce254f7b11d042bf5a217ec9", + "y": "0x171ff74de3d9fc593cec964d3663f3eed72467ccb82fb2a2fe54257d8d58ec4980a0d142b8ff65ec1f1cef5042b1f24d" + }, + "scalarBits": 64, + "scalar": "0x599e57795162ba2d", + "Q": { + "x": "0x132cea64f748a2f30decba350b287aa042852693f67b68f2ab47352eb5b71ff8ee25139adadeaf2003f7f2e6a71ed125", + "y": "0xa8e2895026c27152ef532c12ea9ae7bbea1c5c537441100347576a85c9032f5c83593aa738dfb1434c117c76445396e" + } + }, + { + "id": 35, + "P": { + "x": "0x5b468d26269e6c8f942e44a6b144202e8f33653993da91e8c50844ce25f6320c68c0690a0764c879cc39d18fe61d777", + "y": "0x6a583e5fe9c277ae52f88dce00c691d167c168dada34aa6f02e2a45299fedfbaae7228ef0d4f5a8b76bbc1942b5a8ed" + }, + "scalarBits": 64, + "scalar": "0xa96847c540f26a02", + "Q": { + "x": "0x52ac1566a3310a877d5dadfa94b239902a56a41a63636022d01d1b99dd9a429a7305f2a03b806fa3e1066cb04f5a32a", + "y": "0x19bdf179450110013eb3ecf45ddf8eacb80cd7100e15c3880087dd7db737186489efabe42e0617150fd3eee0180c948b" + } + }, + { + "id": 36, + "P": { + "x": "0x152759e142259f25fd316cfe00ff2c0c4b82a1f95102f431280b23da1ac7ec61c1f4891d6e9e61870cebfa7190d4615d", + "y": "0xa383b55915b3b52719d79db2f9043eaab3fdb350281a62abb370fad576175c4ce2227c6a239b124a81225250dfc7a8b" + }, + "scalarBits": 64, + "scalar": "0x9acfac111c9a008a", + "Q": { + "x": "0x16c2098215f4fb9fdee5d20a7ba02cce754d7e3ea6ae7a6893d1e7b4d710c6decaaea88264968fcad11320fb5650591a", + "y": "0x586515449179493cc56832745c1be90a1825bbe6fbf71c9c4e3eae6085192b9d8395070fcd72ed6b16cea62d4e2e6bc" + } + }, + { + "id": 37, + "P": { + "x": "0x18635b16d83e5ba6cd087325ccdea37700fb6dafb5469688173d05adcf3467b13c779572559574515e4d2854f7f647b8", + "y": "0x6de6418c60f2e28b38f9bead53257b4e443a2c1a60f5c83167c0dc6984c662f46a07db27e53b1c2fb677d2065585410" + }, + "scalarBits": 64, + "scalar": "0xd88e2c617962f4fe", + "Q": { + "x": "0x6956be3e5cff7dec55dd48c43753faa7d138b4700721fdf9c32770b66cd21c89f29ec6f439627d037ec6430edc62ff0", + "y": "0x12b8bb672a3279c26e4770426ebe5f524753a3b43fea92ae05875432f182bf8e88312216c96a102e5ae702295ac25cbb" + } + }, + { + "id": 38, + "P": { + "x": "0x1869cb80e565f5087c4006e5028952f2003a9c5a6c57b960bd04c116d01802ac42c43880a5dd231af0b1c10bdf4a68bf", + "y": "0x1872643d13f347a74f9c2c3425d54bf070fada2098274eb0987b8880a620a6f580c703da31c5f12ccdffa65bc4035827" + }, + "scalarBits": 64, + "scalar": "0x84855c8f1e2b05d5", + "Q": { + "x": "0x26cb381db22ae408944264b17303da70ee86c80dceb888e612f6fff93d0322a3f88132358127a74972d68897b82de89", + "y": "0x9a80d662b4a65eb4ae1dc99146602df36640d1db50e1ab73a6c946cfc01ae5445c584ce94910c00ea02ce161ed3ddc1" + } + }, + { + "id": 39, + "P": { + "x": "0x166ec1a3b558de9436848d058692af048e28fa1851662f9fdbdf2be709b77e281023023b7a32c3255eec80ac06522a4e", + "y": "0x1dc03295b78ce39edfe76cd9b16dfde6810feb1895d1b185e488b049496f05d35ca767ada7bb4ced6b771c1e7bd2334" + }, + "scalarBits": 64, + "scalar": "0x810a740f39319e05", + "Q": { + "x": "0x9f46d67c69be84106aea0b8f2b96fce484988c6779663b6b7efe1b4e0badd13d371a165a423070024d0e72a21b0b1e6", + "y": "0xa20b5713016fd792f9149a5c07a228dc6f31167c74c08d79a47745cf6652af2a127081be6f670e86278e2b2d6dcd307" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_128bit.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_128bit.json new file mode 100644 index 0000000..ff76089 --- /dev/null +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_128bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BLS12_381", + "group": "G2", + "modulus": "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", + "order": "0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", + "cofactor": "0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "M_Twist", + "non_residue_fp": -1, + "G2_field": "Fp2", + "non_residue_twist": [ + 1, + 1 + ], + "a": "0x0", + "b": "0x4", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0x9ec4d4d15b8634a7a2b220486ad93735e96420b6d59596f767628f91b32b8a2a10789c0b9a7d2c919741374866166bc", + "c1": "0x12297bf829cabe2ba92e6699328a14c604ab14327748c6943ead5eb163df03578187d26f61a8aa67a9a31a690b3a8f58" + }, + "y": { + "c0": "0x1408cc29c231f4378b7221eb2422e8c1ff34b7bfeaa6751453ffef5580326c73bb40b340ac059186ee70e500675533fb", + "c1": "0x12564f85a81cccfdf565f3d55da3edbce5bd7a8aea7c26f1eceb36f656804642d4eb1018da9e3984fdd0c8145824b1b4" + } + }, + "scalarBits": 128, + "scalar": "0x896f0985b7cd42bccdb005f2d4dc2726", + "Q": { + "x": { + "c0": "0x717309d731a7acfdd4386f962d3d9ed52ba918b1d6f4d2ce31b9bab7149fb1a72f8a902b9a286b0982b851bb734c100", + "c1": "0xd37565ddfcc9f22a7f16af044b5324068a99f13adb49429d953b6de361cdbe8be3ade4d84cf4846ae6282bb719fc801" + }, + "y": { + "c0": "0x33a06554eff024271d64c2a7e4c9411c774bc7e47cbd097e74672cee9dafe3fced6d4579ce9dbff687eddd672ce9729", + "c1": "0x10c3a1ec901253da8230b6cfe3523c64a7cc8bf66b3b89d2edd1458a805a55dcff410a0846a11aafc4237013b4220702" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0x3634639b643931444523a8f37b12437e8dc856a4386f0373356a7fb0e14479cf3f1798fbb292baf5b1dbc32deb2852f", + "c1": "0x13330a2a16e622008f60ee20bc6e829468e7649cdd86834c0bfe2d7b7e670766ff0db76c53e723c7665db0c8a8a02831" + }, + "y": { + "c0": "0x5b490938a114eb26a0504012a660d772b0c79ff08424235703fcbf725850c14b867b650512f6feb9f492df70c4d4e1", + "c1": "0x17f5c1b47a85e80ec5f9d495841f0255ee0644f4d975503e4c96f07a71ba1caeca05f872fa8923a357cb34399444d71" + } + }, + "scalarBits": 128, + "scalar": "0xde849ed53f855238a4889a43682fc5de", + "Q": { + "x": { + "c0": "0x1375e8618cf400e817eea6d87c2e310f50fc1e128266b164d605ace16880d15518ebb38210576ffbbcd9ac60fe33a608", + "c1": "0x14491614854aeb65449884be287b7df238a1b56786d11bc1bf9b1b393ad87d3be596e04a442412dcdc22fbfcd4f56a4c" + }, + "y": { + "c0": "0x65ea1447a3210336b540bbced8fb717d487a9ad2e8a0daf52f8b057fb9eb87d16fdc2c2587ff5a56cbd1ab25f1cc7ce", + "c1": "0x1763e3f321041f3ecbe9017f2a80b8be5c55591ffe1c1663fdd10af731387c3ca5176a33a1680c643aae6269436df913" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x55995901fa3fbb9114a8cfb4e7f2512c3aedd7831bb77a43282cfdaff6ba73988c62ee6236fb6e03e77c8b67f86c77", + "c1": "0x10831d9b968d0917cd34a752fbafcb9f3ba443ca53a16c49701b363395a2b5f2150a884bd764a0e7486a30dad9ff705" + }, + "y": { + "c0": "0x33a5dbcf5441c837b7c9e027c915b1867f177ae8895c669371171195cc330816135aacaf11faf5d79605bd0b325794d", + "c1": "0x163f7bbba492af9671521454995ef8bbb2fd9de31a857e3b33c919df95ebb0aa79ee16adaf3433635fae870294635426" + } + }, + "scalarBits": 128, + "scalar": "0xbcc9efc551e1fa001adcf98a861a8e5b", + "Q": { + "x": { + "c0": "0x16d512bb0c21f121163779677dd754f6d66ece5c9bb66ec1ec31cc55c25fd29c848b790190587cfb926ecb2dfb9e4b32", + "c1": "0x196604d3a7a7e12885de3f6b513e48df9b72ce9fc40ab821c55bde4071ed27e78f818df90d5f8811d3e6cbb7e96fe95f" + }, + "y": { + "c0": "0x1660cf3e60f5fc45b2a0ceb5ddaf5c55ed04441f8eefbdbceefad6b6135845e9097b194b31059b28641bdea50885a1f", + "c1": "0x14a2f9652e93d5f4339b5787b982dd9389fb413a4c59bbe955e8436d1d7bc6bda2496aa8590bf51f5b776f77c577bc8b" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x1c7b11774b43bf4a6ce4b81baf1f1f391012de8a4e869c2e5fc1ec4289cc1d569dcd7d3412b4f7e6c6da28c344355b0", + "c1": "0x14a72b78a0d94f1d01aeb0c59e9d05a4c25fc0c85620e957a527d8293252995b1ef27dad7462a1f437402b2893ce3604" + }, + "y": { + "c0": "0xa74b871734f9006a40b96029b8b8f7e6b074f8f6bbbd26160d5d3336e1a094054d5296dee9508ce140df62706bcca4c", + "c1": "0x143e9e909a4beff0712b7e38c94bd88092eb041194c68bcd8d9d015c600a83d4a8a82a4200d9e09d21b8528ba409ebde" + } + }, + "scalarBits": 128, + "scalar": "0x740d51b120e95f96a3bc2ecc5b8896ba", + "Q": { + "x": { + "c0": "0x577b0bc8b25ff6f179c3966d073a63a3bed73474e5ea7f8653952cd37179b7fe933db355fd821b5af779723e1f4a888", + "c1": "0x150cad8b2b3f29539da4a682ccdf32ae58a00f3d38bcf94754c231dab34ee98761c600775dc3636b1bec80212128cf65" + }, + "y": { + "c0": "0x19c643affcbaf82c14c32e334740a24eb4221b80796e9270294f0ae6760d64649a5285849ac5a7c7532651cc9fd416f3", + "c1": "0x8d239c779b0f9ee1c69bf535b8cd2c5e1e2fc061563d2f2343b557cc6dda7554769a986403dc97c7484257bb48c253b" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x11dacfd890b0bccaabb6e65a048d5b6631183f5c3712224a869a95daad65e39c175957a462e8bfbe4bb548cb444f12d9", + "c1": "0xc2c0d81f7b7a2fe3dd129d6dfe09397de2f076f8fc83dc4f8b2878448b3adee4f9362dd8eb63ccd0c729991f25a33ae" + }, + "y": { + "c0": "0xc647f683b0797e1a4365e44db4d279a679664ae746aaa75ae8ef17433835c0495df050db626abd5e463d86b0110834d", + "c1": "0x6737c7d201804b7bf359e690b45752483333bf8e80c0c570dadf8f24f142a6012519253b17ca38113f2e1e54095afc3" + } + }, + "scalarBits": 128, + "scalar": "0x3fd686afe1057cbd49541626583d839d", + "Q": { + "x": { + "c0": "0x18e4a9ccdbeaeb5f3425e8ae561b025e730c38aaefaf1d91c5c25be81c61e070dffb371fdf50a3639b70f9de74c6e73a", + "c1": "0x13d7a104c79b184fa8f87837e23c6a9e4902260cf39ea4aa699d1a13dfb31193e972862b3e70dca4368186141766d16b" + }, + "y": { + "c0": "0x10e2f9575db846c63430a578a2ac2e924526484776956e6c560ee6382ee72a530cbcba7b443579e746d3411a98d4952", + "c1": "0xcd329f49d44992b50cc13405a8098f059d6a85c85b7a21d20c9f5defcadb18e4493f30510ef937d9e04734addeefcf2" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0x1814ceb24daa7da4281b0faaa94a102137e41c59d7331497a66284f8d54be2cf807266b5105f979fd526f27891edcd9e", + "c1": "0xfe878dbc4b56e0be318b073439f796a9643a46bacc1f628411830dfdf619112a43e15dc9455658e94a7082747b5cad3" + }, + "y": { + "c0": "0x171aabecb95166e7f06db461fa039ac8f03f83f0bf1ecf609279c94f93347b2d28808659690beb78acb2c960035aa0a7", + "c1": "0xd12d0ff1afff594e147c31ec050ff8c410cc0b7885eba0008cfaa064837aa35cd56d31643fa219bf9a6515bf2d8d041" + } + }, + "scalarBits": 128, + "scalar": "0x4565ea0847c0fb2e1e513cc6cd67499b", + "Q": { + "x": { + "c0": "0x3711234b339effdd232db516aafe0781edf5b20c431ae52107bbf10b0f50dde2e7d45b6dd459dad7933f6967dbf3c6b", + "c1": "0xc12e4f9954defb3e086f4efb978394cf0fa09616cab898ed83053e97e541d2cba216863527948f3c83c62b3544ef394" + }, + "y": { + "c0": "0x15c9cd33411e067b6297469fdbaaae7cb5f120c639d5511ec166aaa9ebc7373a72afd886e6504786f039041919feb5e6", + "c1": "0xa3e206b9c59b5b5a1e1539fedc33eef5f49efa4a10f4a104dbf5eb386126ad42d777fe2f2e2e85507c6219384363765" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x14f5551202d0cfe099cef410b81824ab4bd0a2ff26a37f4236720a3b5476fcba1fe56faeafc6e29ecbff82ad64b1c472", + "c1": "0x529e6cd6f9964efe40836fd65a5be39cb42c8005145302aca0abd8f295896d702593f8f2c2d797f1626788940a2e206" + }, + "y": { + "c0": "0x1633f656c1ffe99e964facd2ea5c1358813dce2063326ba05736742814a929ebf8a18823ae7d66dcae1dcf28c30e87d6", + "c1": "0x6411ab80c3b0bb10f360865c378419e494e89c883738fd1299b5426956f82fe7459788a90c1835b57e8d3d687f686c7" + } + }, + "scalarBits": 128, + "scalar": "0xa926046ab6790c3dbf0b397b36edc274", + "Q": { + "x": { + "c0": "0x178a426b51547a36de990654238374807c64b0a43be3b6adcceb38538b5287d58bd2a35b6012563045c8877cfe969677", + "c1": "0xfec23c16a86482364d0b89874fdaa6838fd99989d180d1f29b29204e0ab867d4b6dea6cdedbe0b98079f0512c61ebcd" + }, + "y": { + "c0": "0x111ed9153c302eab45d191cc835c744b5e66f71b746536772ecebf7bc16d4765b5d00e8d00fdf3e7bc92560bb6d0e957", + "c1": "0x8215ff8e0d16e297e81c830f0ce7e32553056bce6c9f695367f316f3ee9b0b3c173a91efc570322cd3cb20deac22a6d" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x112404b9f9becd6e8356a288144c55d90847ea2a2d833b5ae949a3714adc2c105f713405a5d3fc2f83e89049118aa687", + "c1": "0x81796a6ab4e2cb25169168576ae48221e6b0bf0ff9a74244c5e53c602b62bcf4e4840d5e0d68a77540e9ef4fd65c839" + }, + "y": { + "c0": "0x192212f352bb80bd0e4bb5705fffaed63043ca4511a08275a46e597a5f23e954abd39aca8b15221d8bf034d00d95a307", + "c1": "0x16c4d349aced834d5f643ef7f8fa57eadd60898234c68f773a858a2cd14bb44f375881a6e80ff90328382b68ef73d307" + } + }, + "scalarBits": 128, + "scalar": "0xdb144f9f4d88528c392a01171ec91b10", + "Q": { + "x": { + "c0": "0x14bef544bae3ce70722971d4bd7eb1fcc2574c066661017ef4d6fbcc5863392265a3a86af7fe147a6f2b22d31621e91c", + "c1": "0x482905cff8508f4c6cb247a6ef22c88711d640d9860e8ca3a33994c7b7be06b605dba90869b3f55c886c7db9ac23804" + }, + "y": { + "c0": "0x92f367ffb124de358ee48cfbb8b8d0ab7020bc4c03c416fe0c229dd15834383d01e3b83b7685f3444a0b4386863a3ab", + "c1": "0x319a2a387d4490fbe0dc6dc522420d08f83006061a70461e978dc8eb4fc7edde8054a05d87e982d2133196a44b6d2c1" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0x181e9409e3e1a6273ee493658ba939ddb983ac0a1b6013baf39b9b9971200084381ab1c48228cd3136d7fb9d6c812c88", + "c1": "0xdbd58e3b3535c08f8a20c714868339edce24a55a9de688dd3526a7849f56daacb1c991f28a083d46054d6cd6e48aaa9" + }, + "y": { + "c0": "0x7258276944f9a5e9f62b34c07026d588cd29e722f1670547d5f6e8e8e51e7a96e1d84486d9f9b8f0740cf5e6d92b26d", + "c1": "0x38fed3077c527424be26b17ee552f4a477320b070dde1719b3fae430bf31d40640729532383c567c914c9b2dc6c505f" + } + }, + "scalarBits": 128, + "scalar": "0xe3c2794cb91662dc87b8c94932806b73", + "Q": { + "x": { + "c0": "0x145247d357d01d2ea55758e7188d71442b0acdb95197f4ff60aa92049556e3f152786aee7bcd8ab8f11a467879e2cb08", + "c1": "0xa729271675f6bd861ff096166069f591347508ca2e9acc7f0634c53dd9ff1c3b8c4d451d1aa7e325a438312d7bdd429" + }, + "y": { + "c0": "0xac119611a37c06a9253a6c1aec28e08dd562e911383cb953dbd1900df81e23a2ad29b4650b2fa2ec0cef64de5369157", + "c1": "0x156bc11e9eb85b62848e8389f433a02ff167dbdd922555e594a8259922a6e209f6f9adc69fdba1419526e30848ad4fde" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0x117f196bd1d8dfe103b6906d6eb6c3e52e09288736c3868ec21d020b6ae37a50a8196c4af5ffe2cc13e61b73e8d0227", + "c1": "0x76aa5fbe549841ad9d96e359fa1e71c42e2ebd3ace86ea78527906ccdcfb5c7547d7b5335bbb508720e7af8f92df2f3" + }, + "y": { + "c0": "0x15bd16cae17f126c4080c53a4bacb3cb2c201402428834bd14aa14d4631db96daeb08edea7532be445d22150467698ea", + "c1": "0x96ac73323d19df97be232c4adbb263f632842237f2948b16c936c414334c15a218bc1f86cf4b7f725cfad9903bee6c5" + } + }, + "scalarBits": 128, + "scalar": "0x52efdc63c8bda982977b452e894045a0", + "Q": { + "x": { + "c0": "0x17ac5b59259e9e1841984535c52030c536ce395e341200552dfc923cd51d94bc2fdb824ee5fa206fade30b452f4d0df2", + "c1": "0x14d990b70c3ffd32feec8dfed0fa78a3b44762250e1686043e8c27fdeeb52daad0bb38f57fe0b9d33771f180e24f7826" + }, + "y": { + "c0": "0xd94688f87899f04953d571ff60303b1af5fbbe3c65db398dc3f06250e502d07b46106a26a84ff2d75d7459a534b4dfd", + "c1": "0xa0212a632198b75b28bc64d37ca767475d988c0e30ac0a8c2b8d37abac0ad2d7adbe5073a8b3d0204a7d3e4070352b7" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0x1351d04d654ded15143444c1fd089b2cb33c2d811db5ab1de41096adf25568fd5472f54a457ac871b3bc8ea267d66fb2", + "c1": "0x10782c7511ddafcfbf1a7eb2494be0a2d86b8df6417c7b05fccca03ce3b9f9262a968683ed66c9193c62fdef70e53d5a" + }, + "y": { + "c0": "0x726975baad393005145eee353d0f1d52cc34e295744b6a8e83b34043a9d3e4a2eba223dacb5cfef7fe9d57972ec4e4f", + "c1": "0x14316f66ad398fe23c06b322ffca79f5cea482607eef9904cae97fac277f323940f8593cba290187d0cb9957750dc3c3" + } + }, + "scalarBits": 128, + "scalar": "0x56bdb53ea6c80e9e09f42ba9f0dbccf1", + "Q": { + "x": { + "c0": "0x3ddb04ea9235799f9c817d8357987ec846c81d3ab9af599428d559b85e9a8a9864bdd86e5ee771447e40fa537218b04", + "c1": "0x145e69690e7e552b6bbe349c2bf7d30c236455986064c6d70379ba2e001f6a9371465a5966d4c9d5b0ea04be5335521" + }, + "y": { + "c0": "0x177a004649faa4ae1880196ea7b23cbd4ada75c77d56bbb71d03ef028726eb3de95db5d634cb9e801f7e77fbd4fda707", + "c1": "0xd44525eea9e1e8c311fa5fddaf4c72c8f5428e9c9883f4fd8e834111578db0c4d89a8a0c2d5098b69bece3f8f833c00" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x7a38f98681bd07fb3c763a27701fdecbb630116cfdd667a79575e538afe991c61b980c9f4e92ce41580c12767af18bd", + "c1": "0xb29d4e2b4c2ae5e3e42f4b6a4fc5769ea9b10c5bd141ebca892fc512dfee78ec4487a4b2cacd8f2d3f78843acc4ffdc" + }, + "y": { + "c0": "0xe82a497457a0b5c05431233ced92568c8ba08bd83c71deffb72d3778aa8516722a081ca694bea6c185af67df5abd5d", + "c1": "0xfa1fe961243378bf68dfb046d929f161150d4d5bbbda8ae00550053186c70edbaf2003db20a695275c248abfd6a8adb" + } + }, + "scalarBits": 128, + "scalar": "0xe0ae2bfc47d29fb39e3349023d463b5c", + "Q": { + "x": { + "c0": "0x1556869107443216af5ba98265a2dbb34bd4c5d6488c83c231c89ea7bc165bff6dabeea1f8a3c3d73491457bd971807d", + "c1": "0x8e716330540683b7598b80a04f154f74d51df26b927c5a3c8733d731095f851948406d24b788a91433e736e50aaafa8" + }, + "y": { + "c0": "0x11071bbfba7d92c57aadb6c264f3b8db7973b37f4b3d8ba82c6474634f76b226750dab0e5efad4d4ee4fb0918d5fd4b1", + "c1": "0xe382a78ca9b15d3674d8f1ec867528679c95b564774c4e24d997bf90fde5a82aa3c7bceaa38d93a4559ffa97dc95c34" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0xca025feb775bd63e5c21c21561cc55da8e3eb6ef7efd1ce9a4f2627c832c25ae0966f798b23c1865b09119ec3560f02", + "c1": "0x12018e6d08f1dc25fa72bad36cda3a985c2a6932ca2547a133082311d1e3fd4b8445ddf5700363ac05a86fa37d2659e" + }, + "y": { + "c0": "0x150cd237b0c34e219e5976d05a51fb254a1daa5b1d5dcd04f3cb7c6c51f439e1bce36a5c3edc8cc39d1d4d7023e0f46e", + "c1": "0x122fbabf7e6a807b0b52d3700f1c39a08f011cc90837ff5cab12d15c0a4e5c0bf26bf562ee36488575ddad452db1873f" + } + }, + "scalarBits": 128, + "scalar": "0x65729cd4795e0b8303a34cbc04fec881", + "Q": { + "x": { + "c0": "0x16ddd6b4b931cc7a2e37242f2e565c7ecbc26c43396498c89b9648674c9866cae19040edd70bcc99d3f0b6578f32f062", + "c1": "0x78edd771c47dd4a48e8cf58235f7aedb830cef7d72612ba6e19a34c60bb960e1cf4536f519dff2652faac177f1cd4a1" + }, + "y": { + "c0": "0x93852dc1a9d5ee8a170ad96cd7ed925cbebb1ce5072a9200221232f3e88f37010f1f6f4b3be4ff5146e5c4e849e0175", + "c1": "0x9fd29f65277d2a3b82faab5898577ed865a859fe105265d6ecc7517cdbaf4121d466c126475d3962bad339e22535d" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0x4031c4749e876b9b6699a6911ee8134e568138202c13d3e370be232248b582920c38c66f2eb5d3707383d64f143e8ff", + "c1": "0x8f7909e08d8b729a7af4281293cbf1da546d8332fc94ebff286f14384daf624bab2651c4ddb0db561969fbebc55ae18" + }, + "y": { + "c0": "0xf6200aad189b1fbad2f412f26de8fd5f4637b6348cca3de9dcad61484b83b978b4bf1f02d24775fa1dea22e42c58e9f", + "c1": "0x18387cfb894ce4b68960fbbc9b5cda57e5c029c4d3526afcc6f771586a108d08774c5fd62ee9fbcd9a7b81a4d0d75e03" + } + }, + "scalarBits": 128, + "scalar": "0x80154c4c9507505f1016d16ad182a00", + "Q": { + "x": { + "c0": "0x145b661c610a0b95cb4aaf979cbb69ce7d1d0534b6651fd5fbb75532bc4fc78685ca4154960bcc2e80fe640f26b3357c", + "c1": "0x15948e98c17d4cc4a1320ffcd3f859ba4db5a42d4ba5125a480e78c604b11657dddb145d82d8765585283786716678ca" + }, + "y": { + "c0": "0xea0bd695667ee7c6ebac041fc70d3d3a3c7e3d1f05265a81353c546b4d4e617055e55d352f9702fd5ae4fc0af214c39", + "c1": "0x87861485182e599f7b9776bb3cfeba1b62cd475eb2f5e3aa3f2a7db24582ad7c08898cd7533360a06ff1f3806381ca0" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0x1b23d15d3a3cade68e9b6eb2f7cb8a14ff983f1921d71b9ddc6b1c925b2518a50066e0dfccc247a8183e1f2685e73a4", + "c1": "0x41d2b53b32009826796b131092d131b3450aefb7a5ef2f755634f748fb07741110e0147668b301a440e6861d6493ef0" + }, + "y": { + "c0": "0x159d8e87bea89f65b1a7b99023e8c3e0b40216e6fec60e1f2008038c215b87f2dfdf50a3b73ad2e0bb7834f2f29d1e71", + "c1": "0x3f2a867e83c53f45953e66f19795522b14fafeb15e3655fb8423800f1f886e6ee151edb5bdad28191d3d14f4b7d4747" + } + }, + "scalarBits": 128, + "scalar": "0x1624c2eb9ceb2a64448a87ff032244c0", + "Q": { + "x": { + "c0": "0x6227d22205c5c1c7130846a7847d9030ac327655250ad0104f87a7720d12ded2ba54003ce0acf762f5921b315f44933", + "c1": "0x82bba7b19f226b13d632c24eb4556faf62f6ea5ea105fda68ba618f0ecbcd9c2798e0b65b3ebc0efc339472e8b8d816" + }, + "y": { + "c0": "0xaeff708db3d5d82727ad34e4fca17d106ba48cbee887940a5037ae31d86b052d8b1e9dfdc1fa731cbfc875aa9e0011e", + "c1": "0xdb92044f61be1a1500d64302a100f24f58af6332b62031f33dc625b5c8ccca62be9962594ebf0492d3413515208dc26" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x6ef7eec115f7d924cb5db05f978cb5962b7727b854a347fc70807f4022b763e2242fb544f37684717ade279eb9f65e7", + "c1": "0xa30525e99e4c0a8f6d96d56f31187834a30471e945badc5ff28c159e197bfe6ff66bfb8dfc8d01362897ee35b2c6c78" + }, + "y": { + "c0": "0x10e43d96036e878b642fb1df5c7bfb93c457e3141f4a583e70eebc6a009b8c1ef65659ff2d769a391fcba01433985651", + "c1": "0x580a514dffaf88b2a23b1228f602811a5f7b59b41c038ec4cb85e388ac05948064336be61e8261f45d8ba49a0ba9573" + } + }, + "scalarBits": 128, + "scalar": "0x85a51298934dbe2f6899278bb2ae08ec", + "Q": { + "x": { + "c0": "0x2522c6ea16710fbd4d2cb8cb9a77d876fd71fd329309d0081f95818b0a19568764bfd172dc9646ae45eb00360564a50", + "c1": "0x16d6012989eba2e124d4b6c39f2abf8e2008864503c10b6e5411df48b912b807f6d32931a5fe36eeb9cbb07fac07d3e6" + }, + "y": { + "c0": "0xa0ebb72f5bb91e664d16a351d01af4204678a70ef0a5ada95f9cc915838ee1e84d3a580c8a89c97759d439975ce7125", + "c1": "0xd8f191ecc2061c6a9666575243153211eb5b195632381a760cdbdcc17f4f458f9a8afd3ad244e46186b2ca0972d0aa2" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0x7e9ffd46ea75985a94be7c5415e18113fc7a9a9ee62ca8861bb33ee7ce7f1dbf1389d84824dd68f9cfa41e337b86cfc", + "c1": "0x8659c4bb3864c291cf6ce575cf58a8f30cbc6fdeea3916d426f21ceda5a94126f0857926c98d953e9205ad009dcf109" + }, + "y": { + "c0": "0x121fd5c2238fe3eeba00efef985dd7bab8b6ef7e3394a646486c8e7af4db8d59889f41e9bf4a9d0bfe7c89ee5deb8607", + "c1": "0x54c5d5e946b4f02f9ab64b6237b217a96f5e2e2796f8fe575ab55bee11218baa5bf59482b0215aa5b6571d21a4e2323" + } + }, + "scalarBits": 128, + "scalar": "0xf60d9212463ac4669ad47a7be7c1f6d9", + "Q": { + "x": { + "c0": "0x145f897ca5e2d183df651311d5c2dabd63734f27cf69b521a319a07d056043c38a1cd28e5fb01070f7a75723ea8f3a2e", + "c1": "0xcc39df5abfb3818fb0f6bbb50c3d8a56534fde815f87460361f487d54319b388761eee7ee7cda1b859c6422124fa898" + }, + "y": { + "c0": "0x138e67fc148973f50f348bdb802b6f3ff296aba41c8306831f0de57457de4b43f0118c7444dd83ab394b8da4980e7ac3", + "c1": "0x1832b6dbbf8cac85694779af6ccfd3ac2468e507643d1b29335c8dcfb7c3ea2271a6d45da52acd0da6ec013ad3c2ca44" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0x46c379c59ac8139da1cc3c62e08008124662bfe17ff4d80b24845d441d3e89785d54bc3080e04a0701b0937c23ddf4d", + "c1": "0x19a35eecbc8469fadba0265cbabba1345668948e6a28e95adebb5f08e801661c2a8756e450ec016e6227600d5c3b1962" + }, + "y": { + "c0": "0xd3bdb97c8aa37d69abb727e93ded0fd46c1e4bb1fe675b8b26e896de2a0dc99abec67330a34c354a4c03109902abb6a", + "c1": "0x114f06c99a753152ed8f5851e8eb04e90eba1b8ca30ed21342d71526a1cb1ea94f3b52bde29af1cc777dc65655d8d65c" + } + }, + "scalarBits": 128, + "scalar": "0xf6c1909c0ef08c7f97c775d94a30e36b", + "Q": { + "x": { + "c0": "0xc3299544272bb07aeb90d8c513a4c6bd4e7d94afa27bae3c97972ef02d77f8eedd8802775f9352e93a135882edea7c7", + "c1": "0x429e3c673f34033f57e5aa765ce09b13c7065f0ab4881221aeeca084c41853245f3d5755b04890f09fa5ed2ca93e48d" + }, + "y": { + "c0": "0xb4cbc1621309fa9613eaeea470d3c56e4974ff595e55912268b8ef5f24208a32db501e114e68dc16d40636828578b06", + "c1": "0x7ff29b9a5a0cd0a8fe6ae7911f1db153522aeb4eec9b77ac54c4739256df8ea220b3590beb44043534293b829bc740f" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x183814688e1b0321143c58704da918173e3ece9cbd855d0be539bbec7f4c26242b496c8cd88d3ace510c6408eb116544", + "c1": "0x146396a2398b5ca1b46af896f3359cb0a29c1882d6bc8569feb57bb4c4736c65997fe115a33736c6c4e63ee26b225223" + }, + "y": { + "c0": "0x151956c965ddae5c45673ae39d9b41084c49905a2f06bfbdc21da8934a02a0d769660df0cfd04ae42487aa71765661df", + "c1": "0x127faf51040658bc8f55be6406aaabe47593b53fb016730930fe76ff85a7ab07a23bd08c105ba8c062457d586d2b4f61" + } + }, + "scalarBits": 128, + "scalar": "0x5e0ce26859a325f734b402d4deaf3e4b", + "Q": { + "x": { + "c0": "0x69ac368f190e726bdfb9250ba44944cce3f70534712af87d20dc9bb7a0088328808eecca08c777ad86c1b02ab6b02f2", + "c1": "0x18253f22a70d566956b42da758d5f1c924cec345992ef70fd78e6ae7242be90c99b8d70830ede33f2174a3de93e9498" + }, + "y": { + "c0": "0x4353ab34e4ab08280843891c422da08db047ff39702afa341014a64aa3b3195b94194459cf0e1d71074ab2b7597df0", + "c1": "0x8e27103779039df1fba216c7bec5e9a1c76253f9326feb4616a898ab148cc1d7ab7a5b0483dc596f819abdc37846d97" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0x1527b5fbe9286b2606f15ca977d28b308602c1454ea30b64be639dce3017d31837be4a1ae5ca30c74cafcde98dc91c6b", + "c1": "0x16b62d89fe0650947a96f8f3dfeab5fa2ea5cdba6402eabbb498b352e0ee84dadb46378fb8d42d2b52b34e22ad02efdd" + }, + "y": { + "c0": "0x10b617b7491f65f166d21f9ea873d8ce06aa2bd4ffbf580ab6600f4b23fd81ec06fe00a4389d94da5552d8078cf4e06f", + "c1": "0x1035b70fdd86c6489e6445eb944768f75d980549d7f2b647752fccf53ec344304283fc7dafe8b23df42ecf4aa5f70947" + } + }, + "scalarBits": 128, + "scalar": "0xae125cb82513aeceabcc01ebb8d3716a", + "Q": { + "x": { + "c0": "0x16913284ce182af1ce76bab416e018ee94a41307246f11c9fec7ddfe4033802d0eac505de2215745d94ba5fe8fc63b26", + "c1": "0x9c8d02fae6e07e0106618bc65aaa24950ee2565055b3bc92b60641efe6da5edf08b4efe6078a2ee466154d638133890" + }, + "y": { + "c0": "0x2f102b9b96ad0ef67cec7774f262f00937773219fddf3411c01d9bfd3d1907091efa6564b30dd64ff439536d3a442b6", + "c1": "0xdbb574ab94c875a7f2d5f0e48381df1e823bcabf4b63a2173067296cd5fc31fd91275730d990c49ebd8092f5fc17ee2" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0x9dea871347dde2a74c904b6171cee10822087d50d848c96a3b58da7238545c0b8959fd4f9e5ce8dd94bf10d62c74c4a", + "c1": "0x7d3d980925980223dea074542d3b86677cff2a7be58a4edfafe038d937679f34cc0550fb9268deaec2e4b1dc39cb457" + }, + "y": { + "c0": "0xfe12da170a4b905b83bdb4fdb532aae101a8c8139c327aa7e0140b160538cef15d7ee12246454f0e271476c8a100a7b", + "c1": "0x16e409e1074c87b9e559c2cee448cea3daf6c92dead3cc91f88474704a8aa6ba16bedccf718aa01c8e607ee42727432a" + } + }, + "scalarBits": 128, + "scalar": "0xb36b7e6f524d2c1fdefa115b286b9386", + "Q": { + "x": { + "c0": "0x5e50c1439f5f1d92f1efe76d3002e487390518061b31f742e51bae8b8d1dfcb79c253d362574c359f28c2fc53f4c833", + "c1": "0x76333ab8b34163c28a5dbbad3e45f9a1ca842c5efc5772be53f69833e755ee89ce2720938bf3173dbd1e4bb26eaa176" + }, + "y": { + "c0": "0x183afd82eecabef97e3ada00bea413b2f723bbf7090f9a8598f079eca949e390d4e47841764b253ba9378aa943616871", + "c1": "0xac224e62d947e1de154cb866b1ad441329d0540549402478f98ed27d0e85f04dc5efee8b03bdbd3c0cee6798f5759e3" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0x16da9606493c56685321079ae6e2b672ede396efaedc3ed5710a70df756140a8600c1354301d6313a52e24fe4577c24c", + "c1": "0x2f17e6a7bcd966586dbab3092ce102476723e28d4bb66c29479b851c36cc95852cc039bb9af7cf828da0a1559067209" + }, + "y": { + "c0": "0x184b634c0c5593b06ed0162e5cd35333cfe08cbcb4aa942430293f596cecdbb20105084cab3c5af92d7234e9d2d588a6", + "c1": "0x189b7d25d502234553ab219b7331a0a908568cf6e48b4d0acb7adf4b1e6969c542986402408add64e2c6a30d216ce101" + } + }, + "scalarBits": 128, + "scalar": "0xcd2964b05a27b07ed40aeda77201a19e", + "Q": { + "x": { + "c0": "0x107fcb35dccd7491710ada601805235c0744a497cddf5cbd98950a4ca2f177c293610a2bffe0525a78cd7b240b8743a8", + "c1": "0x36c58aae1fca1b64c94abb4d434e9f5abc4928bd807e53ed8267114979f37ce692609bab435b0ca69e027583b365f05" + }, + "y": { + "c0": "0x47592be724d0d4dc1a394544a2b15d502c7ad36557876124a6fdacf5da35b42f6e81dbfb6302d16c6c79dbe9f1d55af", + "c1": "0xc29815c134ae27b6c69de3d94262ad90ca530d52f1b276f8ebc7abd8aca14f0218ec4a4e2c65a13401427695d04a8fa" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x16753eefb454537cab8fe3d03d86965048bfba36bee97b06c14d058834d93b0eeb58fa366385e7892ac9351bb68d5067", + "c1": "0x1413c07a00aef38c23338095d499aeebf592088bf3daa46b03a4b6729f8db5066ec8457097785c7c08ed1edeb0dcbcd3" + }, + "y": { + "c0": "0xadb9ebacefc9e8e8dc5c1ec1f04a764f7819bcf7e32bfdddabdce4757912376dff3f5dee8aefa0a0e147aa2b05f6d97", + "c1": "0x6ad07df3a617547760eded469299199089eadc3c4c5a941955a9757c603e131a5f1ef2ed6a51a0198e26ea0d78fd238" + } + }, + "scalarBits": 128, + "scalar": "0x41ad3842f54a63dbb5623e57dddfc49d", + "Q": { + "x": { + "c0": "0x72eebdf49d8ea80caadcff947322b39213ad4cdb8284d3b1fff1c04149b270b354ff9bb71b1d61762399ddf7ebea5d1", + "c1": "0x1137c44b4606daced584051dba4a827ec6ada350406f96784a1263a054d5ba531c441eb2af7922ce8f8c94edb446b947" + }, + "y": { + "c0": "0x1ad04112813a99e23574d6a9e740fb35ec76c5605c155f4830ebf4d35ed5a6b1e9f61f05e154290f499a03889fcac33", + "c1": "0x6623aa3d58cda3361648cad2fb426deb6b6df177a4cb963d816a451b4828d0110d4b64e76bf5341b86d57fa33f08795" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0x17d78ebc693bf2230ba89f9991e87e1bc9373da4d173a2b5aa899d44ebc822270afa7179a51a105f7e1fd129b7d55846", + "c1": "0x19fe7c9155209bd8fe960690410039fdf81233703ece363dd455138f691c9c30fc3f9800008ca81d2c12b399ecd85707" + }, + "y": { + "c0": "0x16fd018ef45d4b9c51a05157445b52a8c97e6282be8573f72d83e3e630f902e3125a14fc7a73f51820a8d46086a97095", + "c1": "0xd4c3a52c1765fcfdc08256e7e0920f0a850e44337eb0d392c6fba7de044d07bd76cdb0d9d9d400329fb4c8680dd9bf4" + } + }, + "scalarBits": 128, + "scalar": "0xeac0d328f40f424d7fe89559951c9a40", + "Q": { + "x": { + "c0": "0x198c2342a6240cbecb7402452dc490cd8f40a69f32dca83dc3cafe42d77071c34441434332fd6b07dc1a86da72b2864e", + "c1": "0x127d0b74e581b20114940250e9da18859a3cbfd34615b2c988cfb6f958c768396205a1ef5fec29d2040ca150042a7b88" + }, + "y": { + "c0": "0x12b582827038fcce8b62789fce952eaca0d40011392ecc7dc03c627bf09a04360fe7f37523daa1180054703ed31316c2", + "c1": "0x1198cec07fb7ec606c9e1d49b4902669eb7b4b334042c3d9e2293e1d785200d12ccea63f7ebd737c114ec41511494dcc" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0x1632f03cca35dfe6b1413ae607c9aa99f5dcd1ccc8fb1b9ec0258f6a0a651d97b30cd08eba8f55be60616fbd138cf3e3", + "c1": "0x33a16556214e4160be07c9ff1801163cf96d06db6179e18172d56c011f6896f7fa34787af7263da2f6b1e2174aab254" + }, + "y": { + "c0": "0x108109aece72e29fc71d30ef80094accb851fcb8cd698c4a19141be2bb30def7c79b0a1004ac00954d3d5ade98f948dc", + "c1": "0x199c5b798c915d117e1e1eae6db7eb43f08018a90ca0311372b1683cb99c235e01ea2115f52f1f7dca60dcc4c6ddf731" + } + }, + "scalarBits": 128, + "scalar": "0x87a4bdaf23d1bed5c4d9ea272c526f87", + "Q": { + "x": { + "c0": "0x28dee40c1f2e61066c1d6d5882f822f0cad5e93799c5ebc3616eee8a283d4f5386b39449afbf9868d065b1df6528f18", + "c1": "0x18559154d98c9889e5b43a792d87dd42ee22f78c5dcb3dbc88fb9361c59d313c115b1ced8bcc314867f269cb1e1c7fd3" + }, + "y": { + "c0": "0x217e9d6b69eca148bd48390978a293f350c437e37ae4c4ffc37cd0602c5a834c126446233684d8edb3a5178887e2702", + "c1": "0x1175f8dddb53f5afd7bff460a5ec1be325b34c9edba4c39f7986dbb9a3fb90a22f21d8c7c3c4f78e6344ae395083bc6b" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0x55a5be668bc7dd1bd45d53d01bdf099c4271fdda2e49aa536bc6b0c54ad59a8721c1e6b2ed5f06013fb8c556b5ae8e7", + "c1": "0xe836312aa25bf5e339ae8c17bad1e04f624ca1b86b18b8baa64b0537dc39bb814437a0c8a5d455ba3117ada30363c46" + }, + "y": { + "c0": "0x2e871c4e58c0d29b05674ae2a4c4f2030eb42713e6223a80e7417dc98c3661afbb8d5c895e7167450c078aaeb02bbe5", + "c1": "0xd2e3759cf97f1685e376623c7b1ab1f24e8134fca644947c7b1d46f909d778f53b9b8cad2dac019f77c2bb064c50475" + } + }, + "scalarBits": 128, + "scalar": "0x8276a32faca1f4324ef6a8c8cdb4e16", + "Q": { + "x": { + "c0": "0x8bb9dbedb4b9f9ebe688a05a262dd80555f7c5b4d4af865e98a492f5bd36f1aed6e4e5d27053be2a1409cab67bfd5b1", + "c1": "0x18f17a03dff7818aadb9faa1007a2344baec02dc96d716ccd20b9bbb060d0fe3c8c5d598a7cc3a037c87ad1aa9ab1a9d" + }, + "y": { + "c0": "0xad39381ec2f064b2562eeeff10bb44d34cdf6cb53c543d89879ee317adf5b49a36b9bcad862dc871085dee6c68ec50f", + "c1": "0xa403774dd6afc50a8699cb0404819e5ed8674b4c46cdfefba8a71de34f7a88b35001362a258a2d661201870d0688ef7" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0x119d6ad8541af30a947abd803be0717f8d12ce0a7b9f70300838363b6859c6abd0488bde1f0b3e88090da39415eeb880", + "c1": "0x147a7ac0cad4e930bbb3bbed9d259886b5b502b80faf4c45552ee5855cdc3d71cb7f65938a0f87d136f5ca6581b2cc0b" + }, + "y": { + "c0": "0x6f58739889d5c6d81082c000644636bf3d253242cd358077b5bd7caf9b16cd6eb8c22a7607885e6aabeab68974466a6", + "c1": "0xac98de7d2584c52a892881762f40389b27f549186ab662f61a7acff64bf28ff9612b5665daec4ec4085ae9e35884727" + } + }, + "scalarBits": 128, + "scalar": "0x5761d34ac64b2a38a4e31b66c6fbf685", + "Q": { + "x": { + "c0": "0x1951627c5ee6373a3f83f3c77c8349851872a917327e3687666e84c46c668e9751cf8e70255388739375ad2ad9570ceb", + "c1": "0x10f2e5bbe4d93723ff0510574ba7e6b8425315ac6c7d9a28b208903c403d3f7bf7020979debeb906d9a3dce94ba50e62" + }, + "y": { + "c0": "0x1545c4d7bdb062c23fccd296376539a8571dfd0a325d1abf17450b427449271cac09198c33be6ec143d039c04a53fb2f", + "c1": "0xcc3ded26d1db56b4e4ea5dd96ad8a859497cddb05c31308a36906a13284d1490675df67fe2457ce46abcee49ec826" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0x11d3a6005fea281316c65e8002e7341f5aa809f5382c5ac2939e068f0cdf4686e16cbe7002d0b9510937aef6d1fba1a3", + "c1": "0x35d98e6c70d2f451c0de59daae81c0492ecc5b7aec5d813bf5693f4f09fa9c41e7e31da23507ce080fd71b5a52337f5" + }, + "y": { + "c0": "0x184a6ae85f35c744c6e4dcdd1a512afc93599db5ec3a0d86f9506a18df62077d5de01b1bbe209939eaedabb041a74df9", + "c1": "0x18385441954d10d276a38702b634c8a26fd8ec7dbd864f419e3906cd71c31fe4e015737ce8d28761a809b9735c4331ed" + } + }, + "scalarBits": 128, + "scalar": "0x84ec424b596a04cddb1729e1e603fe8d", + "Q": { + "x": { + "c0": "0x73b860e6db54409716adeb9fa51ebe0fe73d7add4f9017755bed0c85c79902f3f9d6eae83247703d048c578eca0d339", + "c1": "0x119e23a947381e18c8c05c3cac4673966bcefc39c0bb6c82ed6df2c6fdcd93ebea9e2284797e9e731ac13b2a08d6b526" + }, + "y": { + "c0": "0x126f8056760d83d38b050189871f272948862c09c6ae58275ce9854e1c1b74cef2a91b27d41790b437a69ac05d4804b9", + "c1": "0x195956dba99ec2494164edd976999ca3efe09e48148fcbcf79965300ab08236f4ed0fad5d3b05c6ea4b6ee13eb5eaf16" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x15be36fef4d04c745f2f437e87541a0edd8492adbcf0e680cdf1448a9663dba0737613283c1d8d0aa8a813cfea0adec4", + "c1": "0x2c6d092527e2ddaab25708d9394f9be0b2b8f24fe18e5bb22c40427a2245b5e5627c2bf18f49c3e20a80f94e97e5542" + }, + "y": { + "c0": "0x7444bca36d2939296e1eb5f7571eb5a74c82bdc97ab32e7dbc24436eb250518eec4f6b2b3747a6d57a14ead1109788", + "c1": "0x110df1751d4c6d109b97b31231a1f59eb35fe9af3a087b0cc1b43191f18efc3bd73e17fdcab40858dd448d09c03c6916" + } + }, + "scalarBits": 128, + "scalar": "0x58871de882a93d7a00e6c6c57f66535a", + "Q": { + "x": { + "c0": "0x117ab3394d568a3391c250c2496d5f344a32c0d24744a746264257a5e76d9f965929ce6fab98ab7cfc05954e2967f46b", + "c1": "0x19db79e4680953dcea622e1b0ecb1a1cd56e98aff934ea6f24357178ab8cb12c71aaa3ba92b2f279a1c529776080295a" + }, + "y": { + "c0": "0x7bd9757d51e6d71935ec4d11512bb628f9e503e692e61800848d77d3fa1d2eccda9862e61d801b4ae2a119644de0c7e", + "c1": "0x8b56b54832cffc06e8cf7482a7ffb3891832c171783242725d0a1d661fb611b895374b05ce546d1fb064ceef595d304" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0xf0511c23a48aa252a5e73f6793dace0a87a5ead3afe5f8ab89c1670b05f33dcaec8545f3be87cda0d9de30bda15aad7", + "c1": "0x19c58e760f7b32b229c34b7a187cedcfb981428eb943b681453eeb88f969bcb2830885d6367eb1a9ec3bc2500cc0f9f1" + }, + "y": { + "c0": "0x3b34593efa2a12c0dee3e7fd928f6cd344444e08d5a9fe111c2f3a23909d4fe756afcbfa6c328f366bb467ffedcaea5", + "c1": "0x1807eb08f599158282a5e2450d25e307115400e1149d5cdac88b229823689d64b34bb8a378e4b9b0d923aef3c549a5f5" + } + }, + "scalarBits": 128, + "scalar": "0xa1d8c47afa61a7874151cd9e9e6f0287", + "Q": { + "x": { + "c0": "0x14563cccc429a3243a0f30ba576c0d57c67f4f3fca1964160c29ea3351dc586097360acd3159dbb5ba1c196b81f3590f", + "c1": "0x1377bfc16aa2224bac3bd7c8aeb9bcf8dafaf8b7c1c73cc92d082b6610a63c8dfb32816726b57e47aef32de7d460bcfb" + }, + "y": { + "c0": "0x189aabcf4451b5f356016e51dbe0be59bbee9568333177f57b7b4efbcc4a00504d5d1e9c3aae4e4c805c00dcd31b0a41", + "c1": "0x124dd89fd768f69941c30f62099529c89d784651517ba49417ef855335a84c2d34faf94e4d4205a3b734cdaf779d4b76" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0xae38ab0b61777181e2d45b44e0809a25299e5ffc2ccd3a194b5062684102c83ff0e40e0ea338011da30338d18dfae7a", + "c1": "0x15227598a846851495d46fc024f4c7b2270f2e6bc480d8fcad6bfd0fb9365877828d535397cb750d05f034938cf3860a" + }, + "y": { + "c0": "0xc4d6662ff74df8430f36e94c45b2060a7a88d5cbb042e45e5024069c5ca9498b05033e1567b24c92dcef7b8fd2a7290", + "c1": "0x21309abcf9feffc26bf13e54677c359cd0d2f11f26c099b5b3538645f5fa3e2e903f1e04912d4acc87c587921208feb" + } + }, + "scalarBits": 128, + "scalar": "0xcff854c01588ab3ca0d3ac947e25d301", + "Q": { + "x": { + "c0": "0x6e7f1838a3c46c20bfe0eb35c2121009f54a570cca05b55821cf2154f9fa52066b1c2b0612195d7292584d83c8e9956", + "c1": "0x9b19097397731a99d65ae8d1a7b1e45de17b0bf164f4bdde944ce0e4da5b808d7fbab7023d6c2b9985ba2052bd0113a" + }, + "y": { + "c0": "0xfbc6997f872790b23aaeb0991b03bdb6984541c2e8278fd9d4c7e0da0fc1315a9b005c012b8b6cff029093476c4c1bb", + "c1": "0x425e9f6cb05a841bd3dbe614f9e932874c47bfb6969c3fdbe51f75834f3e78beb7f50253de0499a994074f09092e90a" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0x83db2ce67d535ebba778ad889a90ad9acf3ce61781adcfd75cfa75bd603217ae70b629963a7cbd6bd75799259420a40", + "c1": "0xe671fb1a47dbd92f8b6b507307d61ff09462b2bacb7b3e1d454aa2bb7ce1d35bc6714d9ed4df988e20b49f940e69e5e" + }, + "y": { + "c0": "0xdd12c6beba0d973db345ea807eacc7e9b3a82e04accfa491840a03afac6c5f2e098bfb8462625487cc4f357ed8edfcb", + "c1": "0xaa2ab8a51001be77888bdeb56bde7a864e4c24bd5a981aae8f742d4e9b7f4856ef953df82260beddf401ee5b46e04e6" + } + }, + "scalarBits": 128, + "scalar": "0xcbd7ba1cac05eb248bb175caff0dec1d", + "Q": { + "x": { + "c0": "0x1369e6d7b0e44c2b42456719121837c455a8a7ad122cdd091e00b1ef1bc4b55f6f7e984dc9a24f5c7898fca8b6f0eb89", + "c1": "0x176130e89390554cce9bbba1a94a1fc10216121c07b5c839be35fe4cf1239018d41dd5486f353ed58f8b0cd7bba14301" + }, + "y": { + "c0": "0x12841b61625dabaa0b702c6c5ac082161b36612c16081dd95802e585796c0311eb6207f9c89d8b3a50e4fc6c4749e4f2", + "c1": "0x9c0fa85487bb71c80c80796066fcf6eb76c82b6fd807aa0d582c8a285b484997a17c20e066da2517997af2373ebf9d8" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0xad5d26fde547b86abb5fa1890d9fe5af5568ebe4bd0cff12084aa3a389a78fd54bbdcd77220a72a5835e8f1fc36d4aa", + "c1": "0xee218d5e9f12be44d9eeec7225ee815f19e296ae060d28d7a6368a7049b41e410c5b8cea452787199d0f1563b9ec0cc" + }, + "y": { + "c0": "0x23550dbe324438fad6d3529fce2fd01dc86074d8f6c0be8390892218998b484f6fa225daa5167c48ebc9e2741823873", + "c1": "0x688bc9f3235dbcf64f9b2e8d1fd8ae4e366c1126e52c3af6b5e5a616f3d970b2ddc57f246864ddbffd740db5f9e8244" + } + }, + "scalarBits": 128, + "scalar": "0x2587e358a085b4cd7f02c8da3dbf7890", + "Q": { + "x": { + "c0": "0xc3aed8301e9bc4493cc079aed83afac69129a171aa8f3e9a91c4d94bcb3ecdbf979e86aa1c85e8697e782ab88011815", + "c1": "0xfe913a121d12431de7a0dca7e59745aa7b2eff0a46b60de3a81ef6b085af520369fe7b4e4c5ff9ae5a5ce33bd0caa88" + }, + "y": { + "c0": "0x70a9163437a8e35d7e417d27dcd87edc522514d5451cda3e5c365a3185e526755e123ba560a7844dd55bcab61e73c6d", + "c1": "0x36bae4b74f42f34e29a43a9d0b43eb0a532d1d01b93fd193d13acf45dc916e0c616d79fdb27e275e5723d731de185e6" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x538ea53303e83ef72a4bbe48b9416a0c26ee89a7c50b040249203349e7870f8ca83993367e65cd2c9adb0a1ed3c0606", + "c1": "0x11223ace5caa581e3d88f96fa62d9d894bd386b6b4cd7ab6bad43db738bf7d982354f5714dd5f5b4dfada11adf8228cb" + }, + "y": { + "c0": "0x157e6f0e436ce8ed49e3f85ded10ae759d717544cd943c065ed5d282a7f82a984204c2f02e6e8323cf093d8741aa6ef6", + "c1": "0x4c640c34e58860764f69c715b785bffb397b18f9c841e785455e0bd2bf0d68675ede80124ffa5be50c00ad16c95d9b5" + } + }, + "scalarBits": 128, + "scalar": "0xc380ef8952f726a578695641ac0f8713", + "Q": { + "x": { + "c0": "0x102898e35ed84155153abd70d82b8f86c8a662e1c4d4b5fd2a8fd4fe2de59780ccb38ad5d88203c1bb48dae9e458b96d", + "c1": "0x14fde2afead814eaca65778efdfb6638ee560e2ffa49ac11964762119d4a6e0b1cdd24a0a566238a2e7b971caf5c9cf2" + }, + "y": { + "c0": "0xbe991dab47241fb0d0abf479ceea7f43ff0b37cc99e7af5e7c1f204a3988a838dd71baf078f39ad91ac9b371c6fd197", + "c1": "0x12a9fac2526ef90fe32a1aba35c148ceee798b9a79925671646f0e129ee396ae26932215057c43e6faceb1f336fb2fd4" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0x4869d4279726f2afb664c23eb1ecbe008e82876807bfc083e43e35dd90b70f2c39b56fbb7adbbeb33b0759b1a252e62", + "c1": "0x154af9184b21e9224a04e4da7589500cb8f494457ad8980ec4f86798bf11041a7d98c5dc3762d6700ccc47c961eda597" + }, + "y": { + "c0": "0x1be2be5f89fc104d21721b2da5200db022f97677e3ad01435011a654344c6b7ed05910e9873d019addf294cb70b3acb", + "c1": "0x125a09be5c8e4e2cb7d3bf4b858ebdd4c6beaa701f6d3622de4a45edd84c320cf642f4ee9373f7e670d3a5f260dca11b" + } + }, + "scalarBits": 128, + "scalar": "0x34a34237dbe729488184e91c2176e46e", + "Q": { + "x": { + "c0": "0x6a88d13c399788b8fa0e9a36d4e3e755c3d2d1b50aa57ddd2142695c46b6244c263ce60dfe7a91cee778eb66f91d9c0", + "c1": "0x3c40fae11199de3a4855c5f2ae64ec2841a4cbc096518422a0cb47a703350c998a7da8cb777b3e3e3c8c7b7d9f577d5" + }, + "y": { + "c0": "0xfc00d475a95d7d53e4493bb8355389c1b42dff5c8cc52cf29f840163faa09a63bff150e02740bc9f0c6c05a04c62dfb", + "c1": "0x3287001d12b0dd7973a1d29fb3d30de4d07f3666bc68f9527cde9dcbccbdf4ad4cabf598a74af44a1ea8d4d4aa66f2f" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x108fef365f7c85a93cfa9a310383bba38b9066e1ef28885eabf29af5e30aee7362efa50533095f60a4efbdae6a23f46f", + "c1": "0xc0e2b0adfb39292090226a9f2a25d35383b1a6fa240247d67c03ae8f560a4fe45ef1932f3ad9fa6211c356e8173d6d2" + }, + "y": { + "c0": "0xd1c1d60df1940eefac2aa374d66d1c1ef0dd107724f6473c24b07eff4ff7a436c8b111f66c951bed070b81235826adb", + "c1": "0xc07cdc97cc72f91051bdd42deaa59e2a22fd5f7eeac23536fd7e18799f1a04f102a96509d4d44c7d1b80c9c7e14aacb" + } + }, + "scalarBits": 128, + "scalar": "0x894465c5970f92469c6fa61ce31ad0ad", + "Q": { + "x": { + "c0": "0x34e34bf84456aec72abb39af9bf1f4c5ab0b27d0cbbad0dc38d836f26a1409f9258041ebafa64b426ee2d28fca5b819", + "c1": "0x15253ca0fbea6f72b675f01a18327b10dd093374e97ec6768f572057cbf3fc77c6d035f1a7f02c3fded9729ccc833c48" + }, + "y": { + "c0": "0x12f935dd9d5691693ac0b4800bce870f1103710ba63bd4ed4842f3d79e8d4bbbcf9373d06afd9f39fb8ab0154d4a7dbe", + "c1": "0x277ed0145b34a0be6051adc14456f2c182f75014c32adc20f2b48ccb5ab6debde0fe45414a3a0320c348b0dec51267e" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x635ee36be353fc00bf8c211c1efaa6d09877db92d724a557a5d5b2b42c53603b450a3ced6d4a9d21930de036ceaf31a", + "c1": "0xcfd6b654a1a9257c7712d9fcf280c4ca5a939a977b239b260b1ffbdada4d0f79dddf50f5ecf552d5c6c1b928d886000" + }, + "y": { + "c0": "0x47b5845c81bde56ca43b62952b1507d76963d89f3da40a345818322d5f8bb7a77579be22a62975b78117df1461cf52e", + "c1": "0x8ffef100ab04e0af251679c42afb2c41b3c23ff7996f5d0bf26ebba8af4c29af49fdcd9d585064f28fc02f727adf35" + } + }, + "scalarBits": 128, + "scalar": "0xe2eca58afded9e3ae2b02220948c3aea", + "Q": { + "x": { + "c0": "0x8133431d88ebb8bb2f39090297f457725c70c7d3ca41aa845f570ff4126ca9ae25241384e1c915f47dbbfb12bd8c5e1", + "c1": "0x18d8c4e25d9d00d9895727634e12c30495fcb014a619900464d5b60b0d7ae52a1d22ccfc73fb1163c691ac06bd419b51" + }, + "y": { + "c0": "0xacabae8db55ba12299c75a6ac6c707fa14d73c90e9cf76f5358ff92d79c6169f98616b2891f31c915565a51318daf3", + "c1": "0x12e062d6c4b272f750892f5c6e5f8bd87af13f55ba8ac4e535d875d317f19ea6d77734c450da250c2cb68ae889131f3" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x7c638eb54afd2d3fe9a43863914e8a4045a3fa753acccd7ba283e842c0985d514188b13d5ae28266c10875692de7119", + "c1": "0x79f83cf78475dc27ef5f6548ba2e12438fda46da00b07fa78de995ff52aaa0ef7728d29493889d2e02a2756188722a0" + }, + "y": { + "c0": "0x15ef17a23f24a6b382cffe3bb2645dcf0ce3d8d8cc08b1146d3b410ba691e07f5046910924e0576903a26f166f14660b", + "c1": "0xec0f2153a2834e0a8580257d1997fae4b10711f9c6572b228cb4ec180e4fe7234c0d3912189d35391d4842f7502cf53" + } + }, + "scalarBits": 128, + "scalar": "0x8dd0024b7aed5f176709b6e42be3c35b", + "Q": { + "x": { + "c0": "0xd507da0634982c3c3239a083400f511c1635ce5ec494c9d44d4827333993368a01f97066e2e9c37f5d268e3d24b703e", + "c1": "0x5406e78055a2e79e64365e79c8d0565cb516296780db51cf11cbc40f91b4bc325b88a22b392af6ed5e45a23e21358c9" + }, + "y": { + "c0": "0x13fcac4811a44dc01da2d139f0818b1bbd2e95e9da7adf293ed793df0eb9adaee967291175f7dc449b7b982dc0cc0972", + "c1": "0x3f4e2f74734796c5f7e43d37204568c0a681e2e2532b74e452b7c5c231f1fefb8faa8ac6065cfc69d19bec696b03e16" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x1167c37b19bf57a2f8d3de951ce67111830771a92ee63a4081aaf6854418bc9c021b89af66c7b5dee97bc503cc994074", + "c1": "0x10cf408367c143e51bb6a445a6e2b06c0949812f4c2c412ba009730dbbd17f7ba64dd8111c226382484352a1109ddf7b" + }, + "y": { + "c0": "0x38fdae4bc195f4a3a0dbdd07275be5db0745d8dc638b212dcd68e0afe0db82388bc60a72d68f7aee4944aac34433cbb", + "c1": "0xc9a9abf6319c098fef898b8839968d62b56a6f140b8260195a522cbb141d06cae619512cc6973c3ae40499d6928d708" + } + }, + "scalarBits": 128, + "scalar": "0xc4722c4b47aacc1c8edbdc86f2f4cc9d", + "Q": { + "x": { + "c0": "0xb8f42385b7c0999ee96bea5240f19a3a88cf188b38978050495d299b4a0503800bfc73d19bb9edeefa045ec35c6d98e", + "c1": "0xe2fa7a7d5875540009da7b83e8a778442b762453f113cfa937aa04474b7a57ee07cc4b507121e3adaa7888f6224d34f" + }, + "y": { + "c0": "0xa1e03de66d524bfa38576ea04aae191bb940891903e160239ed56e9a721103367a75ed14ec4f91c26e0a828718258e6", + "c1": "0xcdfea6fb2b402b45a398258410fc810e514ec3285c33edf3c74f9e19eae5686ceed6e6107cac5b1c658c88ae6b2ce7b" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x72b43009bcbe20cac4c79daea2c42395c0daa9b1dc467388bd1e1c042469bd0797929c0b4e6dc1771253afe490cd436", + "c1": "0x1145a1de48065ddbfe691ec54368812849ddf21f1a35989ed186fa34ea31f76263ac4b3a726cd818b7e59e85cb3cdadd" + }, + "y": { + "c0": "0xdaa771673073cd488ea8e8401693ffb7224d4d0147119e0a0a0efbbe835c3567f5a594a9f923db66c90d29c381e0c0b", + "c1": "0x8b9091f87cc4afc473c660dcb1d84318db087e2a822a37665436074ac894dea1d2afa2dfce2d97d40afb3fdc37f236e" + } + }, + "scalarBits": 128, + "scalar": "0xcf0fb876ad18df92dce29464666b51c", + "Q": { + "x": { + "c0": "0x15b7184518ec2c1f3020d84db5a3747c52b7ff4237461c20c739cfcca95964313d3ca202bc261c6e105d369bdced4e35", + "c1": "0x785e453ba5374c6418489dacc5eaedeea5c2ea0dea3784549c852525bcf0ec52a1342244113569e67596c7accde1c8" + }, + "y": { + "c0": "0xffe61cd2df094d265fba7f71be78174b455ff7a2cd7a87a6f208a66f1d4c0dc5a3195ac6266024ab9bc496ccaf5824a", + "c1": "0x1242557d61c1877b9edd4b32d27fcbae5db773880c83fc41f67727c20e0f2f7db1c0496b48d3efad26e94fddf74d265f" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G2.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_255bit.json similarity index 97% rename from tests/math/vectors/tv_BLS12_381_scalar_mul_G2.json rename to tests/math/vectors/tv_BLS12_381_scalar_mul_G2_255bit.json index b7803b3..3ac5f4b 100644 --- a/tests/math/vectors/tv_BLS12_381_scalar_mul_G2.json +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_255bit.json @@ -28,6 +28,7 @@ "c1": "0x12564f85a81cccfdf565f3d55da3edbce5bd7a8aea7c26f1eceb36f656804642d4eb1018da9e3984fdd0c8145824b1b4" } }, + "scalarBits": 255, "scalar": "0x67af10bf777554ae7c1deff5ddb5bcbb581fc9f13728a439bcc260173b46567d", "Q": { "x": { @@ -52,6 +53,7 @@ "c1": "0xb9490dfa408a4d93838b330d6fbffdd1852bf50ad8b2898fa230e474a0124126ff4224ae14622090bd47299fd4e381f" } }, + "scalarBits": 255, "scalar": "0x5bd0ae1fa4f8f69aee37bf282d4aac82b7bd1fd47139250b9c708997a7ff8f60", "Q": { "x": { @@ -76,6 +78,7 @@ "c1": "0x8df3ec34f2f8abc711a9d7a8c7cedd2d4b4c80a51259a075334bb8433cef1c67f53d9bcf02100cacf8d7b3cf8a91048" } }, + "scalarBits": 255, "scalar": "0x8696393aee14d9e140cba05be79b5cb0441816d9e8c837015be0bfe46d979da", "Q": { "x": { @@ -100,6 +103,7 @@ "c1": "0x3d794b7a32fb59e440c06314a498c74bc4c1f9aa3bd1ce0af5c781b904d84def189f625b9586db24b26a156f6dc4ed5" } }, + "scalarBits": 255, "scalar": "0x67a0dd93e812f226efd6a05d2cf72c5f9b4255d87a93003857b7ec88b162b346", "Q": { "x": { @@ -124,6 +128,7 @@ "c1": "0xc6ef16520aed784366513ac11c75eadfae420d2e70ce86df361ac1b24639abeee4db924de14d0f33bc0802f69812559" } }, + "scalarBits": 255, "scalar": "0x6bb8fbfa6f0de8ce868ea90f92f8a220bc96baa1f841b2f0e7e26228f36c95a7", "Q": { "x": { @@ -148,6 +153,7 @@ "c1": "0x7136c511539308f08ea8fcd8e1954e6dce0c27d6df21ddfb095c6d1b116cb3e346b964a08c404687807826ba9729f42" } }, + "scalarBits": 255, "scalar": "0x4d1b14e769e71f6d5191f014663829442d5c73208af481fe8cab65e7ec0cb8f1", "Q": { "x": { @@ -172,6 +178,7 @@ "c1": "0x49c2cd8134846c3a499a3aa8565f9ade0d87c333c10154a7f19e4269c0df6bf5b4bbe6005f0d7a887675b4217d7a361" } }, + "scalarBits": 255, "scalar": "0x414257650bf812497f4af2ae88e39832ac95f809682ecb0dc7316acc536a4160", "Q": { "x": { @@ -196,6 +203,7 @@ "c1": "0x69a57a5a752f9687cb143b39cbee5783caa9b6ba7c39920235bd5cf1796108f132765afe4492a647fc11bc23d82bf66" } }, + "scalarBits": 255, "scalar": "0x501bbc748811a7774bfd4b558c5b3266c3f1b4049d2f658c34609654d5b60680", "Q": { "x": { @@ -220,6 +228,7 @@ "c1": "0xb85e3d98306130d06006f08e6ac3776d19c6891622998fcdd66b5beca101ca66a90a73982f267f1d1c6e628a403ba39" } }, + "scalarBits": 255, "scalar": "0x542e906bee5237b0a55850e3bf7812ba6627ec8b762b174d91a297cd258f5fc8", "Q": { "x": { @@ -244,6 +253,7 @@ "c1": "0xb5d8f0617c9502a87f449be88b06be34932e1e6e8436a5b0cf1ea66aaf58f173c15aaf197bcbafeb28b1985b713a656" } }, + "scalarBits": 255, "scalar": "0x166bec9ad4389bf7a8c0cea573380eac05f2ec5609c22a9cf5b40e34635a4cdc", "Q": { "x": { @@ -268,6 +278,7 @@ "c1": "0x1533e2a513f9576d9db62ae308d02f548bc2d4f169da5adefd1701037d7504549e5afa7b52b9e159970e19b3c14ba8e6" } }, + "scalarBits": 255, "scalar": "0x63a85da59b08e2d7bfe84b8781c36ba034e319ec97113b0a83cf20145c57412c", "Q": { "x": { @@ -292,6 +303,7 @@ "c1": "0x3cdceda3978b5da23269ff6814276e190242b3c8d3566199fc37d13ad7b34a4f113629d1b38e2ee69661a442d07e8d3" } }, + "scalarBits": 255, "scalar": "0x4590710e4bff754a71a1eb1da8aefb56d2a5f91d547af5d9cf0af76ef5a8a77d", "Q": { "x": { @@ -316,6 +328,7 @@ "c1": "0x154ebcadb0b24137de122e33bb0954195c8b6574f9b3b7bcc927b8b028f4fd2da4262d193be4885da512c2d615872d6d" } }, + "scalarBits": 255, "scalar": "0x6dd561488c86a665a5a7e1a2ed2daa6217247aa916e9dfc07be411e7456e5995", "Q": { "x": { @@ -340,6 +353,7 @@ "c1": "0x342d97d1ed5ca70be038c930846c7f94e5ea62bdd3ef373ae73cdf0ad2488aab60cf240ed48f8c5c523fbac23c67c39" } }, + "scalarBits": 255, "scalar": "0x438b74fa1d6412d820eceed59e954b5eca04791c602f6dfb0e9f390c01f989c8", "Q": { "x": { @@ -364,6 +378,7 @@ "c1": "0x149e61458f58c942ef864af6130cee701ee5bff060aa2113e866375f769efd68b13a5088a808def6e15c39e3b3835cfd" } }, + "scalarBits": 255, "scalar": "0x13e03982faee8d020318e2cc8456cfa2d0475c8f6417ec3439976aa1455c604f", "Q": { "x": { @@ -388,6 +403,7 @@ "c1": "0xd82868b9ee2735cdc74d5a7184a1dfad796899a1b3326d7259097692c7cf49e4bd326cf40254b9f7ae50b343ecee02c" } }, + "scalarBits": 255, "scalar": "0x2b61ad5d2a0f7d64e2f0b4870a4ca9244119765821e395273500e7bcf90fea66", "Q": { "x": { @@ -412,6 +428,7 @@ "c1": "0x3f2a867e83c53f45953e66f19795522b14fafeb15e3655fb8423800f1f886e6ee151edb5bdad28191d3d14f4b7d4747" } }, + "scalarBits": 255, "scalar": "0xb9de20027996a989025e4a853c0e09a1624c2eb9ceb2a64448a87ff032244c0", "Q": { "x": { @@ -436,6 +453,7 @@ "c1": "0x87b98d2b5c8a9bce1555b8322f9d5677115967778cf2cbd360bda2c7a354512c7045f52d88ca9cfaef6a21cc46773e2" } }, + "scalarBits": 255, "scalar": "0x840d0a5529da4cdec5a5734ee2aec6dfb06918ccffacb78dfcfab172c4b52ce", "Q": { "x": { @@ -460,6 +478,7 @@ "c1": "0x3650b70907cb688e5381ca24a5a63e0851d3a911195c74771ea6fcc10ec639aa74d4a74bd043b21bfc7013f0c6a17e" } }, + "scalarBits": 255, "scalar": "0x46191d3caeb4d810ce0ad8072d23e8a24ccf26d91d15207a38c8481dda0e8e4", "Q": { "x": { @@ -484,6 +503,7 @@ "c1": "0xdf13f9ce015b48edcbc93848e43807c8eec638cf62fc36b92fcb0896b7663e7aef0b42c3b81a784cc21a9d989557a05" } }, + "scalarBits": 255, "scalar": "0x10a52a09a569a404b84f0ccaa3a6f17899db9614cf35ecbf015dd5fc945bb412", "Q": { "x": { @@ -508,6 +528,7 @@ "c1": "0x894baa49dfb7896fcb82ee68b96a383250de24e98a583a1aca4a409378f7ab21fe8e004dfc25f2494bec2d37e2c9f84" } }, + "scalarBits": 255, "scalar": "0x251871b54ffcb02128f9b7d41593d72369430f19ad5e5ccb642fb4a6f06c883c", "Q": { "x": { @@ -532,6 +553,7 @@ "c1": "0x8a3277ad1d82d542c6f38941b2df7ac0bdc108d928d5952d87f2a69b6e1ed943454ed9f465184c48c2d2c3e70b22bc8" } }, + "scalarBits": 255, "scalar": "0x1f4328992c1e66a1458efeb28de02e0fad149769a36970de6a7991178dc3e75c", "Q": { "x": { @@ -556,6 +578,7 @@ "c1": "0xfdb8739a0e46b91175d2c582c0c317bb4566057978f23f2f56da501d65a8e567653886300d5c7609e12698c96363e62" } }, + "scalarBits": 255, "scalar": "0x57092e5c2513aeceabcc01ebb8d3716ad27d08c210fbef2571765989d2a997e7", "Q": { "x": { @@ -580,6 +603,7 @@ "c1": "0x11d88ae540975d9b1dff881652c37785f877183848aa6a6519f935eb0c80a75ceaec23011061452fffd5f28bd1f885b7" } }, + "scalarBits": 255, "scalar": "0x52a675a265dd392b602f181fb3a96c3293644da85e86dfc0c23d72ac9edd392e", "Q": { "x": { @@ -604,6 +628,7 @@ "c1": "0x46b5f0f444f1ebfd054d5c7d286434c23927e9c87f0abd507709626bd63c1bbec67d46cb072980915e3d38c12e23bd3" } }, + "scalarBits": 255, "scalar": "0x2926960fdefa115b286b93869f526a79bd6b041449777dc5813af11a991b3d5c", "Q": { "x": { @@ -628,6 +653,7 @@ "c1": "0x1e10d38faf6ce340be3164a025866a6ccee1fa4942694f3720b7a9a02259a77172c3b41e853bdb30961764ccfa6144a" } }, + "scalarBits": 255, "scalar": "0x3634328bec527e7e1f2ce632e3d9da0e05e0d94bb908d58af7778b162f478b85", "Q": { "x": { @@ -652,6 +678,7 @@ "c1": "0x12908f2a678227284e76027fe86eeba27359a6bb364119a87c4a7b503e8024bf59aaa9266982dc89ce78ac871df1c36f" } }, + "scalarBits": 255, "scalar": "0x4374bf5c5614a8e7b73074a2e2f7999143f87314732a9ee33c1735f8c92e8a35", "Q": { "x": { @@ -676,6 +703,7 @@ "c1": "0x10f16a7831a05385c3a2d09b754f5e187edcfcc5af7206aff839f6db09b5a60e8284fd76b9e0b5883f551c9eb820b2af" } }, + "scalarBits": 255, "scalar": "0x3036b1aa14474f135d4380544c19a534cc89b1286ccdab5199646eb19d31572f", "Q": { "x": { @@ -700,6 +728,7 @@ "c1": "0x17cfb0b62dca0fd8f4b9bc98cbfe068795aad7aeba636e03ba4ea8bea4c34edd8f59e44c9caa48c5ba0493b8e7824716" } }, + "scalarBits": 255, "scalar": "0x55ad209ef711ea2cca482ae48cd2f59989ffc864e0fd9aea9dec6c6d5340dbc", "Q": { "x": { @@ -724,6 +753,7 @@ "c1": "0x199c5b798c915d117e1e1eae6db7eb43f08018a90ca0311372b1683cb99c235e01ea2115f52f1f7dca60dcc4c6ddf731" } }, + "scalarBits": 255, "scalar": "0x11e8df6ac4d9ea272c526f87ad3b7459220fe39d5ede05f947a88a739d2c8f9e", "Q": { "x": { @@ -748,6 +778,7 @@ "c1": "0x1126157ca1c9f825b1f3901f01fa1c8851fad24baf4cdb1f80b9d3f2dd5ffea330019ababaf741d46eb2f3cfee8036b2" } }, + "scalarBits": 255, "scalar": "0x44032d121d4963e8c7747c7820eb5782851fa686ea3c1559cb1a61f7f81de172", "Q": { "x": { @@ -772,6 +803,7 @@ "c1": "0x5d043049a6f2c20811537a409fb1f28e093b05b8bc251d6172e2c0da3896af6bdabb80b74c67086dba2003468694b51" } }, + "scalarBits": 255, "scalar": "0x67c550e27bd33dd2eaabbc813811f1e970564b30dcd30e93775c8c711a41fddd", "Q": { "x": { @@ -796,6 +828,7 @@ "c1": "0x1157b2f2425f940d2dcac15c3994e1768d8779d24d05cb2e288ad82ac6d5e1d11accea3391d0210e7ac2e438509ae1d4" } }, + "scalarBits": 255, "scalar": "0x1be2c5d3d73a2156fa42ae121251e1705b63075fc8378a577fc348511b8869dc", "Q": { "x": { @@ -820,6 +853,7 @@ "c1": "0x19de3775d457ad64c7b7256426ee9f79a10db6b7cba56589da8c2cdc84b9df3ab677b710ebc68bc79eeb616829d6e3a4" } }, + "scalarBits": 255, "scalar": "0x5faa8aa3bedad35fad1ea6cba0cc79d0ca66dbd633a17488852b47b2c6354a73", "Q": { "x": { @@ -844,6 +878,7 @@ "c1": "0xddbcfb07a216199490c72fd4e51792d691be49e138364b51801be74fdffec26487e01c778d733b1fbf6836edd3cb9d3" } }, + "scalarBits": 255, "scalar": "0x4e827db7b4b65fc35b7a8f628df68cfd906e695dc20499dc15301be0164a6bee", "Q": { "x": { @@ -868,6 +903,7 @@ "c1": "0x3e978c0bae6f4acacfd4c3eccf61eed27e1d38bc16b6caf5ed9cdc504c06a1c1d42e30cc262ada63e16fae7a120347a" } }, + "scalarBits": 255, "scalar": "0x65ebdd0eac05eb248bb175caff0dec1d8d431bbaaf6b81520b21d69ef3e4f5f4", "Q": { "x": { @@ -892,6 +928,7 @@ "c1": "0xc5c33d4a1200f670b9c1b733a5eb3af700e62d39ce8b800627e2ebc4ff2cdc54eeddd785b0cae979e2c1472a106bed1" } }, + "scalarBits": 255, "scalar": "0x149ebd5c3525019c0d7f46a2a15f137a12534d70e63eeeb27c08092b773beda9", "Q": { "x": { @@ -916,6 +953,7 @@ "c1": "0x12e5a0e78404ad66635307cd399de1c3735c8c7e8055672ddef513245dd1a17de50271632e895ab4a944f5a648189621" } }, + "scalarBits": 255, "scalar": "0x4a104d90c4efe06782116c08946e35e8490a743510f3cc947196b66c9dd67296", "Q": { "x": { @@ -940,6 +978,7 @@ "c1": "0x15e082f350227447ca7192a11777d13acecce08252ffa4637bb885b520d3e00abc30069f56ab605d32ce214e594e2e8b" } }, + "scalarBits": 255, "scalar": "0x3384db722be3c35bcd981d687e8fe25b36c9a1ac7d5609d7577a28f3b267462d", "Q": { "x": { @@ -964,6 +1003,7 @@ "c1": "0x5e3615af7a67a32417a673640618e486f312167e6533ddc63e6631e2555f3f20e269c895bb27c84cddfe0dc3fcbfec4" } }, + "scalarBits": 255, "scalar": "0x70846eb91d40d2a8e3028962cca5a3c8dee44ce9b9a45735f6cbd825ee1b795", "Q": { "x": { diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_32bit.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_32bit.json new file mode 100644 index 0000000..020777e --- /dev/null +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_32bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BLS12_381", + "group": "G2", + "modulus": "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", + "order": "0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", + "cofactor": "0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "M_Twist", + "non_residue_fp": -1, + "G2_field": "Fp2", + "non_residue_twist": [ + 1, + 1 + ], + "a": "0x0", + "b": "0x4", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0x9ec4d4d15b8634a7a2b220486ad93735e96420b6d59596f767628f91b32b8a2a10789c0b9a7d2c919741374866166bc", + "c1": "0x12297bf829cabe2ba92e6699328a14c604ab14327748c6943ead5eb163df03578187d26f61a8aa67a9a31a690b3a8f58" + }, + "y": { + "c0": "0x1408cc29c231f4378b7221eb2422e8c1ff34b7bfeaa6751453ffef5580326c73bb40b340ac059186ee70e500675533fb", + "c1": "0x12564f85a81cccfdf565f3d55da3edbce5bd7a8aea7c26f1eceb36f656804642d4eb1018da9e3984fdd0c8145824b1b4" + } + }, + "scalarBits": 32, + "scalar": "0x3728a439", + "Q": { + "x": { + "c0": "0x75ff8097002a5f3f013d4d6bf82ab90d81fea728095268a00241000ad2a5e248121ba963ac1b0ac8172a4019b8ca94a", + "c1": "0x855f07c633d5c4eefb8cf892b34bf93afffb49a8155d72da777468cb3caeb338f1d06a19d75d78141bafd08806730c3" + }, + "y": { + "c0": "0xef0292f0c79412d5e7840756a3772be8c1d091456f6fa80f235f8e79ac85aca3bb3c233a1bd9c731779930170a8e691", + "c1": "0xd7ab196d50ca127257b65dccd109160b1bbde42d87cc11c7eb7df5416fce81b00fb55d0b8dc6301d143c01f3791c6f0" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0x17cb746b21bd81394f7eb10cce0858f5129b3adafef6c5583b9af976fbd7ce5c8831617edee40140e7674c2c1cb58ef3", + "c1": "0x181d4bd62ef1b1b093aaf632b7e1835ed5178fc78137db059db9632cd0ee00adf22d83c7e4e6051068fff79fa67646f7" + }, + "y": { + "c0": "0x6d481f9ef470d2a3a389aeb693a4307ef06a35e6d84a8dc99e912ea4aae4658c13ba931aeceed030d30e33becab12ae", + "c1": "0x17f854cbd80895b908e27049278916dedc38e8ca914ed3d7edab223b0587d8ac4f2bedd844c2a069d8627ceac7adba8c" + } + }, + "scalarBits": 32, + "scalar": "0x46d979da", + "Q": { + "x": { + "c0": "0x5fb27f38350735010d68d995ae6bcb9dc73b862aad36fa875d2aa16bb48e508ef72f3f54f5c2026710d671347bc54cf", + "c1": "0x9132d43bd3c41639d39736d66bc3c1a838636985241d3b60c4b837119e0e06844afcd0f8e8e809e43dd438effc77c7a" + }, + "y": { + "c0": "0x5886337cc03342874c344a4933ca5e40cd6d8c10f4f07f63547916ff43ab534e21f9d226a80741797c3653b8f41edaf", + "c1": "0x123ffa337890029a065818b3bfcbff7ee7b10f4936d6b0e9037ee92e195790b967c9368a02136cce4e2e1058195bc905" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x16e01eba92a65b1850a126474dfdc30b6b63c6b2740f2d3ed5dada3b5e3d5ae1411e6bcbf7aa2d56e431bec97f382649", + "c1": "0x19f96d2f528d7f8ff7bc2cfeb55a534730a95dde841c126428d1fdd1622744e526ee963d754ffca1f9485a034792fc28" + }, + "y": { + "c0": "0xe02d303765c8a15d267952e7d6980de2b5c688bedd6425dc02e5743c32543e51a6d48f2639e42ea6306be235cd646bf", + "c1": "0x1182abd1f64b2327eff0e153cfb27e9cc37e1af6b2734c318cbb9da6583d89cd6d4dac55a30c784d3e1f7d70de071041" + } + }, + "scalarBits": 32, + "scalar": "0x21f024be", + "Q": { + "x": { + "c0": "0x188ab39c4c92afa874377877370b038fc990d12f4f457fea93fd5fd4f64101349c80b0f5fca9eb9854c808e2195949d9", + "c1": "0xdcfa278262af26aeb3130c73179cdce20161f8417d624c21dbcee6e68fac5c0703a8dec85bc05d88753247996246ca1" + }, + "y": { + "c0": "0xabb3c0d0b006141f6dc263f652fbafbf848524ea2f7987039e9b52ea621c860325628eb392b523a970200fe782ee46f", + "c1": "0x196fa3cb08a54646d7b01bdb7ab5bc672b298f2825c9db3256af1bcebd51b8333f4e01c02f6093bad0ff229e14c56624" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0xa91be73dc20a5c4d88de9b1b6f6479948b2e50bd441f2234083bb35086da7995e13607661fb44630468063d4fdc7ad5", + "c1": "0x4f2e2915a38e6ff200dc66bb7f9daac5cc2c85421e637b773b8bbed97f31720d1461a4785d65694ea9ee9864c9631a" + }, + "y": { + "c0": "0x13d9ced616d160b7ec5075927f8adcecd36f8a43433077d7d43359bcafb8c81014ce871e0cdaa086cac9ba3be37d237e", + "c1": "0xbaa478445df60a8d02448ca437bf2eee39afb6c227283472fbe0bd1073287f3db7caed0b73722ce7a7ef2de273b1bb4" + } + }, + "scalarBits": 32, + "scalar": "0xa250e556", + "Q": { + "x": { + "c0": "0xff02ea47df62b38bf0241f787ac2051d412b5462d070722b95f60020dbfc44a3f195f283db9aa60e1bc9a9be7e0eabb", + "c1": "0xab5596a4a7a4d8d2d3a0a72b34b0930455733d91b51bce83e8cf1ac57ff278b11a333fc047694cc4c503b2b3465bb88" + }, + "y": { + "c0": "0x52ae1fc4be4370257e14720cbcd5b5901d6d905ebfc82a9df5de980686af449e9ea142c0d9ea78197551693334ea2d8", + "c1": "0x1641ec5dde6d88055a62360e907171350ff2ceb0e67f91a81b019d5479204383436f96ca3b45205f7fa216908af25f7b" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x7867ddd7f5a7a1f2099bbb2d72a9bd7c2817ff625b6b45e89b1ed3a3446201145cde991ac2282c6ed67176e22f07dc1", + "c1": "0x166dbe5977992458b4e2ed82a817b59e84b4f221a4109f4ce45c2fc1ea3cf363a835de8a38813ba3eee03bba372d047d" + }, + "y": { + "c0": "0xed9071c526907db92fc9c5d751f1a9a1031d51612a42e91e26868ed1d00b5f566ce838f6c54639aa761223f24fbfc45", + "c1": "0x134004d174916e0eed0f81b43018d28c47c96344e33467e8772c5126744b45b6e35afe1f346755d327b39f8ad80e5a75" + } + }, + "scalarBits": 32, + "scalar": "0xed9a691f", + "Q": { + "x": { + "c0": "0x187a9ef0737dff455ab055d3c2695e847935b120c37744b7f5e7c6067d5895cf47ad4731f469d973c523ce85fcc3ce0b", + "c1": "0xad51701ed6eeb522b455cae4d3c31d73309e8ab917d052bb7a4d3f0444f57885d19a0ac3321d44061772a77bd04c7a6" + }, + "y": { + "c0": "0x9e62b4f434a6da329010ac5961fc0f2857a06312264bb522bb37cf6ed38e0f1db0929bf905a14209de4375afa91897e", + "c1": "0x142260dc6d4d0c0f18d90ce9ed85caceb2162bcf20211477c76123da29747c8555819025546c4154dbca06a127b90500" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0x3de9608707a6cafa119c0280cd625d3ea70ec54b1206226dd110ade9197beade6f3e7fb635eee8fda560a0453778718", + "c1": "0x112e3bc71f6ba9c8574d18c05e3e1c5a3228f8541cb18dc70162b3d8d2d7051d6df74a0825148fda5ec5b692751d6677" + }, + "y": { + "c0": "0x120ddcc9a437e3daa1237b099112c17fad7827cef60b54579e6389f2a0325d03d5812a271a4795386e2f9cb15a48622b", + "c1": "0x7136c511539308f08ea8fcd8e1954e6dce0c27d6df21ddfb095c6d1b116cb3e346b964a08c404687807826ba9729f42" + } + }, + "scalarBits": 32, + "scalar": "0x8af481fe", + "Q": { + "x": { + "c0": "0x198299ec7ea1920fcb0e13cff546cceab772db89012f448f1844f0e3357dac1ca125ba2a53377dd99299d1b9bdf4f225", + "c1": "0x19baea4c4e45cefee4cf993e36e3671a1f1d805974bc7a6f29fb44a6575cd87187e879cc31ef49cc181634fa9ebfa36" + }, + "y": { + "c0": "0x951ccedad1ca2f0ac6f91671cc93271edd2ff0ab8dc951dc92cd98581a74cad609e8526bf15aa0ebbb2e101250e5f27", + "c1": "0x155c1965b7b1eb0cc3353081eef4f13033b8ecd0ce3e00aa03703b201651b3d357315685fcbcc203b0ec606809668215" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x150d26d2219fbd9a130164d90105e3e7789b51a62ae23b811290f9bd8b8fd1f00a4043fc2eaab7ed8b26bd122ab9c8c2", + "c1": "0x37e871629fb93629f9f344d9c49bc7666f61530c38a04ed346c8e43cfa298f4a5fea0fdc38351853512ce600bd7e2e2" + }, + "y": { + "c0": "0x9898fc731f4b3876435fca3b348c51b224452ffc2e22e483090f36bb6cb6835e923059ed25dc11402234154fd0e6576", + "c1": "0x12284e3dcb0090229255b9bf61bc385a58ece05ecd35ab87a6fce1a238095cfcffdaa3fa132029cf05112f60aca15cc3" + } + }, + "scalarBits": 32, + "scalar": "0xef7a08e2", + "Q": { + "x": { + "c0": "0x568de98dc8e8b2d56229eaac136a9524f1ba3f57cbae94547cac5548103d3f2534c31366d312232402a528716f0c939", + "c1": "0x1c3ba66b044d55e85d9b2334850f75e31afbfa383e39b8733078d17f95f08851e04ca778f737d103e783f2902bd3f9c" + }, + "y": { + "c0": "0x920247110d9a68ed73fb927d0f41c229c7f85372b4d39f50470a81d5d05293b407d7ebbeacd638787dc17d4d38bbbc4", + "c1": "0x49b55be5da0edbf31d2e4eb55cb9ade90b5cf7cce86c3d79cb9c4a0ae8afb69c883498d0e50f8f15438abfacd659906" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0xdc495ee3dbbc6d18049dd4ee6e2758bd0c9bd3218aafa535cbd5665ab3a072a086f09927a0efe6b4f2c5094ff7251e5", + "c1": "0x649f5fefa47406629141b789b13628d916f1534a7f228ad92ddf4289024005e05b555100245598d6be46b52feb1273d" + }, + "y": { + "c0": "0x17d5932f7184b001ba8d1a2a7b2b5100ceaf719663427fbbea8f68c5eb9cc28f55d9951c68244ad9fe1b4f30b760e80c", + "c1": "0x176dada60b76478f035b9c48afda824d8c54ed0a1c8a78aa89f63b92741b69398f84b362efd94995356327cd05c5c60f" + } + }, + "scalarBits": 32, + "scalar": "0xf8a38669", + "Q": { + "x": { + "c0": "0xd172e208879cedbb3f48312213003228b57e0c32d60eb7603c24e0d8f4fc05102556d3c2ac63d388e4a24a1d845c961", + "c1": "0x6ac10ad66ec156c2c72e3a38d0a832c76cc3ce0cef92d0a6dc80e319933bdeb14f60262fdc88b70f9b2f48389ebbc8e" + }, + "y": { + "c0": "0x13e9499426fc8a1fc5df64fae6d1131d1f4abc7c180a926336a6ab2e9cb76e041eac527d00e2d7def90030c2afe8738", + "c1": "0x90655e28b14aaaa91ed63671a7e753d18a2b036472485031565372b3d150e3c98a05c629d39d7363260d1867da203e5" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0x10b32809bc0886c622e51f0bd569f240e51bcb0fe758cf8b58c9dc96c497732db0f85a294b85376c97cdcefdf970d726", + "c1": "0x1095a558daa903331106b81cc9ac40ab196b1daeab64870beb16e3bf575879bc868424c46c591c93347558b82c2f5123" + }, + "y": { + "c0": "0x88526d00fc80ef538bfa7f7fad87a8dc006771539bc8a4b17bece08baf6af11b8ad66926d05f28b112a8be9637eeb6a", + "c1": "0x171891ad6ba963855209477bc1ca7db17ec7f1087980e24d1d7d671fa396c909c3a8bed560c1de83af5ad9fd0592ad17" + } + }, + "scalarBits": 32, + "scalar": "0x97113b0a", + "Q": { + "x": { + "c0": "0x100bb011fc37ae2d89810f1389720ab5b8a18b942a55931c4b8ff03675bd4e14e2e6ca5fc665c4609a67079327b22b8e", + "c1": "0xef3578c7477296a4108a98e76f23e89724e4df4c1ca3e23d19215cd346ce98c81de4fec1669322a7483d0608f3e92fc" + }, + "y": { + "c0": "0x1950157bcda61b47c5b49c0b91c7c161ac15c45d03566c5357a3e7b57337b7d54c4d4a9de11397aa1766235d9921ec71", + "c1": "0x2a0a6655173ab1365216770197e21850c94458b29bcff4e110b52fd459d3bfb73fbf6b8ac8c4fd8b5502c7e21041ed9" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0x127e32339a4244277c82a048399eda83d738c6d1a32899d4abd22d3735480547e6ed24ef0bc7504f412beed6bd6a20e3", + "c1": "0x144cbd205c3e8bddd5ebd861757fefc7f4ce45d0af80a1d4053adab39a8b30c721f8f204aad0d0f6d16857fbd21fbfd4" + }, + "y": { + "c0": "0x5e285a6e516efe8db41bbd04dbc51b293bd8d3607b180c92989fc233312f67b5729129c9ed995fe9619d51c2356622f", + "c1": "0x15e1ad4a2cb20e5a9ce3498d01d3a06307eb3584a1cc2f8963df485de9ec69dda74f20696fc9ac91c195508dbc1e96c4" + } + }, + "scalarBits": 32, + "scalar": "0xa7edb31f", + "Q": { + "x": { + "c0": "0x53496487aebecfe83fe9a8c6b08f3579186bd1a052d18b86e83a4ebf6675754996f313b28fe111090284f26a2b9388", + "c1": "0x987902046531a0882b61a895011b183587c303004259115af6bd018e1096668e9e1efb5684d7ec901ba4fb74c9ceaa6" + }, + "y": { + "c0": "0xc03654306d28562a4812d5727f844a7a749664259ea53818a09657bfc21daf4b4eee5669b43675c40db2369a35b7aec", + "c1": "0x123c7c29d1e50f6d0c0b67569b25f17f47db4f51cba355a196a05a4313e2972a6636caa60f5a8e7cbd006fd68f24542c" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0xb1f8a6012e69bdcfd23eac1d871ab78fe3673ce3816da4d8862951b5bd9ba9af459b409f4edc87879172b89310f39dc", + "c1": "0x16f3ac7fb7bc0d50dfbfa520dcd20528e0d09ffb623c62ae8f93fa7a3ed4f2eb1d988f46d7464e39b904a6bf7e34b7e6" + }, + "y": { + "c0": "0xe5b499597ca47ef1f28b4b0fe900489fde05b4aac701086955a789e456f01dd1d44a3deb288138ad82584d669eb628b", + "c1": "0xbda1a76efe78744f6093a8d3c01b56921f56e7e852434b6fb456d4c042f4425e7ac9b8a8d4b9268f9c93bd2b3e31025" + } + }, + "scalarBits": 32, + "scalar": "0x15325d38", + "Q": { + "x": { + "c0": "0x116fa20a04463a103edb969526fae7ff28e73f6382ca8041b28c8cea66f7a4d2e931f98beab6d1b60c1c1e0acd57ed0f", + "c1": "0x13ea1a23c4f01eba4096a103ff963d5d66044e06d5fb13427c6976bb0d65da738140ef7e7954c77c9ba2b1156003e6f8" + }, + "y": { + "c0": "0x1405f7dc16995c8810960f1b23baa348b188275c14e7f19be1fae854f3de6b1f9fab10f58e97eeae8115a65c752f2463", + "c1": "0x58d42c48afea03a5fe55507bb5f199a8b7b9018ec6eebb6572aaa1fc504270c87e7dfe4e225414583cba13c8089d7ae" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x18424bb2606ac2dce8deac093a750a3138dcb92f6946bba4c593fb522764d890653a309449ed191a5449a916ea6ff24d", + "c1": "0x93958e185ba1ad97c65b2b53ad167b87801a531f4146bf64c1d20822aabb02ad85a0e810c06a58b4253415e0e1b09a2" + }, + "y": { + "c0": "0x2917bc59ae8dacb7894cf6132bbcc26f441f3d1c01b74a1a781f0c4fcb76c3554c106784b26d9a2749afa933fa7f049", + "c1": "0x873f22fdb5be8f43a03c4f18f68c9352271a8f11eb94148b6e7627cc765deb05d7c5b11f9398fc39471e72269d4f2bc" + } + }, + "scalarBits": 32, + "scalar": "0xf17ad63d", + "Q": { + "x": { + "c0": "0xe0cf83899bd3de793c5021f3176360769cf4241c2b0ba3aca5afe44d36b1e0615861e8ac62f1d40676db63d081838fd", + "c1": "0x1860d6a92a8f5361d08cef9be2d99d5ffaaafff01c8706e81f30bd5d3a1e54ca7ebd92606667adc77885ea1a249e5764" + }, + "y": { + "c0": "0x19bf0ed6adfcad8f6d008a1697ce65508aa9de40cea618dcb0af2814e4ed0cc31f07fd29788776593a06d6d3737e481c", + "c1": "0x1b0eaa5c70315fb58770a76c68c4b433d1219a379c548ed431fd43701a2a7af186314101aff616175776f47b4e93f9a" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0x14c010096dd221ded7d119312fc8091736d0c7205e9f2345ce89d84261ebc587b1f1488e91d711d6b0c3cc1165cb347c", + "c1": "0x23e558ded82fcdfbe5dec64d2b89893723332e55243b835e6eabf9b22821cc731052f8579c9edd663a54a39090cac59" + }, + "y": { + "c0": "0xe6ffc6848fd28c032a6b30d61d0413af79901c13a4cfae7e641e8a68289ab9d8d088f0dd91a8909bbfbb383166e53e1", + "c1": "0x1745d86bd38dc29532521ae19af4fa1728f79677bac25a3ea973c0a8fe2b45f2cd41f5639be4f559d1dca2cf9ad59f60" + } + }, + "scalarBits": 32, + "scalar": "0xcafd66c6", + "Q": { + "x": { + "c0": "0xdc23562dde71db402d19a1cfffd10131f10c67a5ef37f7ada3a67a74a309de16a003052e13169c347f5e66bfb4c5d37", + "c1": "0xa1bd2cba157086cf093a925c01f002b772caaec40d6f4d1669ad73d83af24e04c151fb4c30f62aab206b0bc8248f0fa" + }, + "y": { + "c0": "0x11f3d58f551ce5c61469762b50390f2f3988dc10552a39c10fe3e4b1377d1258372d922aa234207b8996b98cc5c27228", + "c1": "0x86ba5a692989f973e15698c78a3355f7576498d10b9e3fbe0fc6c03b59adad8fea7e6213c65d228d027bd74e4798937" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0x3c6d6ce97e9809382adae38775cb30fcb3f93340cd250f0d94a2746b8c186698def62cafa942b62494539f62233e619", + "c1": "0x127db2cf9bae523e7a3277828fea5e54c4616b6c4e4bfba8ab4959878c320c74543ba416c1956cca50bba48b55932b07" + }, + "y": { + "c0": "0x5c18aac384dd739ef35d256efae204e8edde3b96c6113811e0f17f10571d6367bc02561800c26c41987e57b93460812", + "c1": "0x18f9079df4d1546027c9bbc0376dbcc886bf1dc52cda16eeb19a6ba31924c67e8fcbd9644c2c65636c5e95b4606740e5" + } + }, + "scalarBits": 32, + "scalar": "0x3e5e82f0", + "Q": { + "x": { + "c0": "0x18e31791457403729ec7983820c775de3de6b4e82d7fa1effc055527960631e0f0c403d69699ea2f4c289356089ee0b9", + "c1": "0x14926ba7b522b486e2182109659033029386a237db345f409ddf05262d2d38d0243c8ce2c3b1a0cb832245b10379b7f4" + }, + "y": { + "c0": "0x9c9f59df226a03cf518f9638473a3799a66247d72e28ba953e51decd6451e9947f9f1e739615950428f6f188f58e086", + "c1": "0x9f1bc588b45ee6894163b817308e40264385a32660f59d5e8ffe3a4a9006c683a12b8c5494c3f2c4be75dee43ade953" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0x1821b088bd8897c7e665174d6a5f723ca49421ef805e0e7712d48a9bb9166fb59a9aa88fd511f49176deb43c920ed7e2", + "c1": "0x19a6136f0f6314922de288ae417948706d7d92eece54de2e6c836beff12cfca33c18187425515c2e32d50e4337e577a7" + }, + "y": { + "c0": "0x1548f16011387f1d37ff3cc9c8be1cc38c642db946318bf4ca5dcbe0a0478efc5f2c834efb2bc5e3e42df4cad56b9607", + "c1": "0x562b0a4aa271d575b955cc0303ebe6745918b9492daf1ab7eca9b418011f8bb6d71af76094b2108d8a2c61c4c7c4dae" + } + }, + "scalarBits": 32, + "scalar": "0x455c604f", + "Q": { + "x": { + "c0": "0xc4f1a0188d889d4a358a3d434513002f20747b733cebe99b071798951582e5b2e57e73479aa4443a7505c29c6829831", + "c1": "0xf1c8f9d7a05d319e4d62bd4bc787bb1674924e687104102e930bf06168d5ef51361ef54c4b4fbf9276d2790924e53a" + }, + "y": { + "c0": "0x161bd964e8beacf3b0c2e036798062326b922e980a7675fcd6e34b436e7412dba4abd0d629893fb8b515c4c59aff2da5", + "c1": "0x62104c4aeeae33f32a85153c4733ccd6838fdda90e7b169fb1371d65422f0a0956d7b7a0b2f8146bdc44c4cd909f0e7" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x48acf163c7cebcae59c9e8f47a6b649a2b498d3f63b966097420d97e50db89a0444a36a3ffe5dd134d716ed83547065", + "c1": "0x144ceb96f86f0e092082edbc69eaf182f2edc72cd326fc831404a1e14bb274baa98e16705df410ad30a2e5bb7f68524c" + }, + "y": { + "c0": "0xb77a6996d7b85d098b0c9f2cc12a50d7322dbd5cb38454ed9058136082ed4ab0c96b12683f0b924f20866ab5111e1ba", + "c1": "0x7eb8918bd5528af19c89e11021246845e6df066af98eba630157a9d034bdc3f5ba3bf6f1eba9b4b0f59679a9e41ed3c" + } + }, + "scalarBits": 32, + "scalar": "0xbca5856f", + "Q": { + "x": { + "c0": "0x517679481e40b6a05013dd9cf73e96e4362635a6a80bcb6912d35b37d4ef124b84dd05574bc56bdad2e9a083b791247", + "c1": "0x2a02dd793174a9621b577353c35d254457e6dfae13e027d83c75e0817b303faa842cf57afcc7293a37f575ab2e3c659" + }, + "y": { + "c0": "0x1269b58c25481ff3276a6b0aa448c30472d781414de6c8e94ec1f10a58e95abcb0f447260b076df668f29341c66eaf11", + "c1": "0x19758cfdbe981e1bef807eccee01f2cd103d18126567ac7572e5c87206076fcba56641b08767376b714bf55ad0a75c7a" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0x169e5a051e306b679d7434ce1bf7b7e5212d4d3922f60ba7bfbd2e96c35574297a2f96de7ab686bc8d06b0666590f675", + "c1": "0x1263067039bbc972f1817da6ed476bdd87ea8cba5bf52489a91a4246d2c3151638a27182d4554bb380aef88e58b936f5" + }, + "y": { + "c0": "0x123255e2cb2b88cc5faab676308f0f43aa50846338c05b0a0583d41c25850edfa843bc172a86faf5ebbb8fc1e50fef6a", + "c1": "0x6589cb77ce1f8d45053ea5af60b96d03ba3d70c55eec29478a19c8dfc0e7756050bb6e9a8d06eb844bf2d64c0504d1f" + } + }, + "scalarBits": 32, + "scalar": "0x9e0de24", + "Q": { + "x": { + "c0": "0x18d2e09c5fb06379e0cfb6794d7f57fd6f9c35993c8e31628b575603a549a4052431135dd553bfc2092e1cff4e4916d7", + "c1": "0x16aa128881fcd4570be2963f15690cfa66efda3ff39f3cfe829d1c6fa5b01fc88c22f88f3813a801ee593cbd7c32e72d" + }, + "y": { + "c0": "0xc905560c4bc68f4dbdb817d116d687146a4d5d5b6651ab20e7d49bdd7e8f0ef2efe724470b9e08d40730cb471465604", + "c1": "0x916dca652696b3480e0da9b193165eb14ad94d1cbe0185f814ecf9eebca83fa9fadf45eae46781fa6f02cb1e9ac0428" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0x17c1cdc132e20120c58a4fb160273c8e679c150cb4549b93bfe84a5067aa18cb2e2eb10646ff1d98c90635951b78c3c5", + "c1": "0x17a20e23fa756b0c20eb9f02aafb7b72286ad6cd4e1bb457e65b9afa5a143539f6a23e26528ec47f3c5b7509b0368789" + }, + "y": { + "c0": "0x9b3bec3b63ddb48db911bb2814b8a51cdc133b8f0b08c95dceabb5a09ffaa98b3d9dca62d19a9db6f8637ef5f6a1628", + "c1": "0x8d6da9e3fb8c182effb8c57d4bd74d2027b05f066a790f1bee31060e0be2e008a097600a9e3c1fd483322fd9bf63154" + } + }, + "scalarBits": 32, + "scalar": "0x4894eac3", + "Q": { + "x": { + "c0": "0x1662ded5c8f03e3395a1ab29a209dc2619f0c5dff10edb2b15bb4b71fff4f8ac2a2f2f6f93cc94a952bfbf53fabfce90", + "c1": "0x15f54da4be1a269403c214cd3d1908b86bce28f306a34d7bcc7088536ff027f5f1306f8dc0b3872f7489945e48fd0f3c" + }, + "y": { + "c0": "0x15054a78bdc182b6f77295bfa7fcd8dc220670c6f6c7dffc28334333be9bce66be2bda12160e9879084449f72d9c0b3a", + "c1": "0x85a1c2e8d1a9a108c804098bf92094b274fc666b421346c58fffea4e65e33edbbe75fe6034802d2b17c4edf42e68d21" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x7e9ffd46ea75985a94be7c5415e18113fc7a9a9ee62ca8861bb33ee7ce7f1dbf1389d84824dd68f9cfa41e337b86cfc", + "c1": "0x8659c4bb3864c291cf6ce575cf58a8f30cbc6fdeea3916d426f21ceda5a94126f0857926c98d953e9205ad009dcf109" + }, + "y": { + "c0": "0x121fd5c2238fe3eeba00efef985dd7bab8b6ef7e3394a646486c8e7af4db8d59889f41e9bf4a9d0bfe7c89ee5deb8607", + "c1": "0x54c5d5e946b4f02f9ab64b6237b217a96f5e2e2796f8fe575ab55bee11218baa5bf59482b0215aa5b6571d21a4e2323" + } + }, + "scalarBits": 32, + "scalar": "0x6c8e5277", + "Q": { + "x": { + "c0": "0x176cc2087100df7a2182cbe15acf85e566e2e482c8c3b93657a5d8a2b23c695b3dd77bae9c907ef6892af645f042165", + "c1": "0xeb24e488b50bfc6b3f168d82185d9959cfb6d02a868defc5001d6517c2db4ac595714b06e19f123366426bf0f367fe3" + }, + "y": { + "c0": "0x507749b78ba6d3f85ba8cd7a94486b9bcf86be0f71f9f7155071f8c164ec4b386f34b681ff2e23c40af3d93b4bc446e", + "c1": "0x14af17e9fe3ca65096765a26b4685b4dc3da9a6f5dab6bd9a09bb67f5d752faa1cf80387fae301f555707cd7f08ff9f1" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0x3d0e928bd06ae775272f2f7fd1095df798956133d0e91c4ed83c5c8f1239437f1e4e0e02056319aa8549699b12a5479", + "c1": "0x4e11918cf1f08f7d5024312156944cdfadeaa6fb1213b70d37516973628ad6cba07669a20f8c7cb56d61969a4530e71" + }, + "y": { + "c0": "0x19b0a358e0108e5d4224525c7d5888601ed16ab04df895d7e9473203244fdbad924acd2efc4544d8adeda54217ca65cf", + "c1": "0xd36b6d0da11472c7701c79c437d9a49d2a80407ac21544e5c6e86d8e9b08fc47e735cda7ab6264e8c312d374afb6056" + } + }, + "scalarBits": 32, + "scalar": "0x32a4835c", + "Q": { + "x": { + "c0": "0x19df744cba58c4ba850c8889c912b78d89719054331652c8b06695725f39141f50bfad33a4fa88228edadfbc965f42a9", + "c1": "0x16e72273cec42bfddd2b244bac64c0eaa52e81d48a6c4e9f3355bc5ba7a863bb8659d1e4347a7ae68b4277a355aee9a6" + }, + "y": { + "c0": "0x57d9caf5c26a2b456c7e6d21a0ef2a67be20d256513740e97511c4be087f89fc70480ffbc5ef0ebb2c941982b04fbe5", + "c1": "0x185d4ed5eeabb9943024b0d8c81314b500a26cac5ca8ac5794b98843c2eb60797b4acc1e574b52bcb0820eaf9e83291b" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0x26ce050c3f40e0965cf79f27531ccbe7e91ad01480fb39936f640490c9aa74d55a4b2085786ed9894cf68f1ca2c3b1e", + "c1": "0x42c24684414fb7071641729edacaef3bb373a9afe1b4c9883b1cd64c3ba57ce6b722b4f02e2fe34fcf8d3855c54f9ee" + }, + "y": { + "c0": "0xea70b99a96af44fc59f9f13215b80e845f62ae20961146bff34c65059e44667c0198ac4813a08ca2ac5b4827977fdd0", + "c1": "0x6f022d6bf0875052813e3bf041fd37dd8f93acefda6599bd085112caf7909d166d8fc6b226052c342ca499e3f2f7c5c" + } + }, + "scalarBits": 32, + "scalar": "0x5e2297b5", + "Q": { + "x": { + "c0": "0x4f43e4ffd26d8e9c149716c7bac2cdeee0efbcf278a748e5472ea2dec0b9056ac8911e2af14ce40ec342e2cccaad319", + "c1": "0xe6a8bda1ccf14346c529e9d3c75a42d80dfd71e902380c42649d1af061fab39d57c81616a01bb6e45e74469a909d1be" + }, + "y": { + "c0": "0x7c17756a803b13aec14b6cb1aa20a7cb9c2e54967935e4144904cf66c3a1eb0f84804a681890cfcd1cafc9514eb250a", + "c1": "0x9c178a04bb2525508326f20badc3ad0d04304ea78b507923b26ca06bb1f4c101a21e9fe84512da2333bb700e88b90d4" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0x9fe5489968bca629013c2f510440747e8d3ec431d2c02033127976f52aaaa84e903238d9764d050b9468b963939c0ee", + "c1": "0xcd229dffdd2aab234e73fec73287f5b1417aff7f39c1186697f919b5fe5438187ad65d46c95a55f1aeee2938cb56715" + }, + "y": { + "c0": "0xd2cf054fd4629d3aca2d9a6c61e52d1d654cd56c2d800fb52f53804d65a446a9118ce6c0ddb20a00a951984820f0ddb", + "c1": "0x579dfcb05c6a1d1b3531e6b5ebe2811368c28150c81d34af052c188ca3b8e3b33d02379ffee71017fc31511c38af9b0" + } + }, + "scalarBits": 32, + "scalar": "0x684aeb0f", + "Q": { + "x": { + "c0": "0x12ace1a55bd7d97bae11f14fa2eff96bf27532189f14b49b20181e2cd6b935f2c84c5cbb95d7831962c28f8ffb2eb148", + "c1": "0x124e9766e33d114c749027ba70d52746c77321da458262ac83e623abba4b87c9b86a1d104db4574d24a47b6432eb622d" + }, + "y": { + "c0": "0x1584c94c229c0e47df4a79e5bddbfbe2b9ff03d012b0e2f436fcf3c45187e31da928ae8351e8be13b15d645e51727895", + "c1": "0xea1bc9db99b981c758029cf0c75ed68c6450527fea9067e2b0be5fd686b5e683fd1261c27f3c8f4b2184835274915e2" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x48269e4eedd16d405975b7d88039347b17efdd43527595a24e5bfb9991b3a2fbbe63a63f1ae6a7ae233ada5cec10a6b", + "c1": "0x80fefade4ab2c092a8ad9c78fc413ed2d3ea230240feea1a3e3dde111373b0891fab0cc7726a98b1c008bdba3cc34a1" + }, + "y": { + "c0": "0x14540c9987627aca3d1ad3ce2adfbf41c44eec2af70a4504752c3d59ffea82c30b0390d4da517c52d8351ca254a61147", + "c1": "0x832728a106deb241c79631d6d6d9c4d2b445838425268b5621f11cbbbac2c2e1e2ddf91308738537b5cc4d6768eb99f" + } + }, + "scalarBits": 32, + "scalar": "0x14474f13", + "Q": { + "x": { + "c0": "0x16bc2dfcd098ddff369c5f10793462cd8661a600a49c185009253e5e97d85b93cb07ceb6daae184098e8ee1199f47fcf", + "c1": "0x6e2693e52368e9066d5bfe7e381561cc9b354a15bc88d7c00e6b62c867e37631cb0bad8d6cd354d1b8537f444a077ff" + }, + "y": { + "c0": "0x17862c992597b355ce62dab2e130ce9b3fe59ebda0a87c4262d5c0f7866d19b34abf26f62fc98bc3a753c56c9f8eafe4", + "c1": "0x15a4366f3279d7a9886e461a69c270be1a68cc35ba147d008530d741903a244767169269a5bd37651bb7b1d48041bb7c" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0x75b382a58e05f43b52a29940b74b1ebbf2f74b5a80671bcd4b5f5ad43f7e90a4ba49d5860d57d22c7a3990160ad5680", + "c1": "0x12bd2fed30cdf6f95e7a7f0d104c8baa7bafcfa3eb9a272cf2c0123ec5a2c968134694440cf400ef8c85359dcd233d52" + }, + "y": { + "c0": "0xac4a8673bb9e791644b4518e6b4132b03e7ba596af6b7698f17dfb117093cae6c7e5c0becd32391d9ed98b788489ec4", + "c1": "0x17cfb0b62dca0fd8f4b9bc98cbfe068795aad7aeba636e03ba4ea8bea4c34edd8f59e44c9caa48c5ba0493b8e7824716" + } + }, + "scalarBits": 32, + "scalar": "0xef711ea2", + "Q": { + "x": { + "c0": "0x6fa71a273ae4e1d0e0c09976ac845189cc19c24926b6481c1b879ea12bf445f6802ca9981d85c622c855e58e1f1bd52", + "c1": "0xa1412a953146bd2aa39b164186a170de469d5006f333ba138806eb29890719fc0e6fcb129c79fdc81a4e1729915151c" + }, + "y": { + "c0": "0xa638e27c6715d16fd61a07a7e2134b979fb612f3d51b1e94eab63ae8a12c5df2cbaba7d887a3cfa96d12a67cd1b648c", + "c1": "0x6fb9dac7cb9a17b97d00cf3ee702900532ab7ebcff62f44f67bc8a3553551da38256f065ffbb9adadfc9f55ac9c71be" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0x1632f03cca35dfe6b1413ae607c9aa99f5dcd1ccc8fb1b9ec0258f6a0a651d97b30cd08eba8f55be60616fbd138cf3e3", + "c1": "0x33a16556214e4160be07c9ff1801163cf96d06db6179e18172d56c011f6896f7fa34787af7263da2f6b1e2174aab254" + }, + "y": { + "c0": "0x108109aece72e29fc71d30ef80094accb851fcb8cd698c4a19141be2bb30def7c79b0a1004ac00954d3d5ade98f948dc", + "c1": "0x199c5b798c915d117e1e1eae6db7eb43f08018a90ca0311372b1683cb99c235e01ea2115f52f1f7dca60dcc4c6ddf731" + } + }, + "scalarBits": 32, + "scalar": "0x9d2c8f9e", + "Q": { + "x": { + "c0": "0x98b7383796bb62b31e93562e697c29b90c6b85d1fe8ed76aefec8f18b3d353f5670503eb20bc44dfb189a0ad97caca4", + "c1": "0x14a005b50439af4a91d430badaba557aa05cb7f14c732c13f5eafce75e8b31102d8c3a74c1eadfe423d080130e6e8a4e" + }, + "y": { + "c0": "0x18812a611c917aa2bc0faba3c87fe98546729a7806cfe689b5d9340387d81c15f0919830f869112bd59b803eb5015fc7", + "c1": "0x16dd1546b33f84ac8d59bb02362f12779de0f130c923354f3545724659a65d61d5b88216cc612a943ff120b2f3c70c53" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0xc6a4f9181fa13a0bfe8a5b8733214ecfde9dc6ad3f9affa81e128c4043fd11e7922c34aa37593ae47f7123c18055147", + "c1": "0x94a070e800efa75052dea9b33d585ecb0277a6ed7a499efdf8ff17815a224fbba4a814d4a503017c3a7eb712e2a9c89" + }, + "y": { + "c0": "0x17c75d5d13433bb95d28cdf207067b07a0dae7080ed8a55b67820a1a90da3558d33f302f445c8702ba5fe4d28d1fd397", + "c1": "0x14e4988fe6a70a36e6ddac93afc7c8e7e9ad4e896923ccd7e1353a810d4ef10b9b12cfe136cbb0fb34af3f32f9f0c60" + } + }, + "scalarBits": 32, + "scalar": "0x18a36a32", + "Q": { + "x": { + "c0": "0x98d3b99bbc67b0406d0a95245253e55155dbc2894c338b206b6d652a7ad310e1cc7f1463b4848d6d6df45e02c06e87f", + "c1": "0x894c74537411fce5bdab265de6d6163bf2240d35209ac4ddbaf53a7ba52003c6c57c457515b74a7b7181ffc6c8c4c62" + }, + "y": { + "c0": "0x17465d99f97cba1aca9535780843aa84e9ff95a9892d1b58630184f5755c847f6065625de6a5415e151344d46612f687", + "c1": "0x90e3aec2a801b2f3a039e47e4c310244c3becd3908a7889ab50677ebab8cbf3a304d8e8157fa8f54185e0f29c62e315" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0x5f54518655396476a09a0f6f0c10054470ca1460df80ea3afc21a6027e113b194adc9f4dac936dc9b5b5ae343c1b071", + "c1": "0x84d71ea920622ccf9c4936212803fea7f9008d134b3eda64a312e69c82a3288fc512e0b920464b2df3ce10f708249d4" + }, + "y": { + "c0": "0xed49a42cd15f531812994dfb181b86107e66270f68fd3a5cb9c3e1b838d91fb0ab8010d2a69ee348f26b92861b60735", + "c1": "0x192a671b0b3eafaca322c19a9ca0898282c9dd0404ac18edc166eaf379784fce895d3bb171cd611a74a023560470830c" + } + }, + "scalarBits": 32, + "scalar": "0xe966190d", + "Q": { + "x": { + "c0": "0x14317c351316fce50b7c478fecdf792a6f59b414b967322c9e59cb564bdbf2282848609dbe95d1a4fa3b92fa966b046f", + "c1": "0xee42f064f0ea1928622634a0684f5639ef352241cedda245b1216a013dc857945ac7f1f790fe26ca9b6736c7ac71b4f" + }, + "y": { + "c0": "0x80e0e5f68300512345677e1762750688dce19969891da44f7dd6121432f3171633f098c76fdffa5bf25de1ac03aa89d", + "c1": "0x226df6f4f57a74bf31818e43121550c7c95d9e880a612b0a0a14ff6be61b1ab39519424284af7b622ecec12d070a298" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0x17773c31d618ce80a75d85725aa484dac4bbad80f032799243c12847b320be0771b4346f3861736d0dce4bb80d9593bf", + "c1": "0x7a4a051d39b5c967db23a45cb613c9b0bd2f649b25ce12f1cdd883985106a27f72b3dfac2bfd73a36f52fac469f994" + }, + "y": { + "c0": "0x12d4f88c044aa365d5d48b653007d2298c553e193200d9d6fabe3746c6b6eb3c4992e64d825d2e2ee9ae97291485c587", + "c1": "0x8dafc6d97b5ee74992817974151904f127c79394438379fe676feae1950f780eeaa6543f65cbe2b4b4c0c30117f73f9" + } + }, + "scalarBits": 32, + "scalar": "0xee569416", + "Q": { + "x": { + "c0": "0x19465bea4b1bde3385ef269df6b3eedab19130639fcf55cf5f2548c28e208282d2647eb7708f38f12ae3b1942d674dbe", + "c1": "0x12074b8511dac8a713509404667089cf27e65e7583ec85b8103eb524cff223ab10c7ae6c47d7838e4b13576317a1583d" + }, + "y": { + "c0": "0x8979b4f28695b2503dd3a147d8d451c33bc11ce9aa6df0d3a2e19346eddbfe782088151a81645061f6b1611fe9e6f08", + "c1": "0x87df0725c8165052e59b011c4feea586a4b97f38bffd52d996beaf52311f5d9fb6e1ebf88eea1585d02768ed2331a57" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x2a2b635da82823f56744480d21bcc9ca852658e93fabfec08f77e1b136657f346247326f1e93b618d9b7e3cba5310b6", + "c1": "0x228e26ff2c68580bcfeb42cfdf6b764bf998a5350e041d9ad3eff7d962c98609678747f4b6eb8bde705ba465fd4498e" + }, + "y": { + "c0": "0xd01b66571e8b06d442d949c46dfe7068d4be403152de95a57c698b7ff05cc611f8ffe0bf708253b28a0e78d7151b1cd", + "c1": "0xb16f5a351ca6e981ff00667bd0cf6a2be8b1d6dd631dddc3112af82cdd7d67aed82bb593ff9554818b897db838b606b" + } + }, + "scalarBits": 32, + "scalar": "0x76af828b", + "Q": { + "x": { + "c0": "0x15a025e367c5e1ac15095f0b4b6d72cde81fef690c0defc284775a2e32fbba32b4fa0ed5d5230654b6cd236bbc72a900", + "c1": "0x104046dc2acabf302166e3c683a143ee7cd47c1a26f2ccc6788d2bb392ef580574d110b9bdad85786f207fadaf2e4fc5" + }, + "y": { + "c0": "0xc0565d150accaa9c1c7b715268a2dbae4accee7d771fe400dbc1c373a35a11320c702a9928d5f2a12ab3e13758a3766", + "c1": "0x48293a7e9e79769bf0264179f63e81d2356cda437456eac4a8e69cae49ad90eb5e844829a0996d8a282162e1cfc62b3" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x9542a0c222f51dab731b834f5fce0d16d98900e354426f9f8429d88e20b0088a0774cf754b8f84215e8b6c37be96bb8", + "c1": "0x170b7369ec25b64e5c0a94170a1e9915331eec78075d9eb9950b41948cd6cdf45a25daea09ab1305cfe5a18fd69929b" + }, + "y": { + "c0": "0x18dcb27014f8cd1caf833e52df5d16de9711fcc6f368997065c7bbd0a1770cb550dc0ca94fa539c86839627855f169ca", + "c1": "0xabab11b8b8e0c5debc9d81518d593a92ceeed2d2b1b541253288d60239cd2f3204827e04d8e19cba87602214fae10fd" + } + }, + "scalarBits": 32, + "scalar": "0xd0b91c10", + "Q": { + "x": { + "c0": "0x1340b508554f4c90005f7d800f2ff3f86c13e7d11337ce2f02bcf7d9bf3e787a70c001899e4c316319f2bc4d32315e0", + "c1": "0x18e863b92c612ab334605d3a5835e893d2de1512b8a708b458ce232aeb234952d5a3042e605b46c10e30aefe934b38db" + }, + "y": { + "c0": "0x2f56db50c40365ae26a1c874f8a2492092b53565457ca65dcb38e85cfac7cf467ebecbfeaa6e484d45e4341c3ded6a4", + "c1": "0x60a1a660c5183b0df48319f0dfadba395f66617a4f8e7d03caea7b313357b938a5b1c9938bc47f8d8039aa5b4613b6f" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0xae38ab0b61777181e2d45b44e0809a25299e5ffc2ccd3a194b5062684102c83ff0e40e0ea338011da30338d18dfae7a", + "c1": "0x15227598a846851495d46fc024f4c7b2270f2e6bc480d8fcad6bfd0fb9365877828d535397cb750d05f034938cf3860a" + }, + "y": { + "c0": "0xc4d6662ff74df8430f36e94c45b2060a7a88d5cbb042e45e5024069c5ca9498b05033e1567b24c92dcef7b8fd2a7290", + "c1": "0x21309abcf9feffc26bf13e54677c359cd0d2f11f26c099b5b3538645f5fa3e2e903f1e04912d4acc87c587921208feb" + } + }, + "scalarBits": 32, + "scalar": "0xb61ad2a6", + "Q": { + "x": { + "c0": "0x38f98e7a36257e88684689896cf8bc3a9f12c354c743d74ad9dcd3887f138a7b3e24ee20653fe5c622058b983381fa7", + "c1": "0x1754674fcbdbbc52f4d6bcd426e3772a4ce4ab88bd01cbe64cc33f64af011eba1301b33bc7524b2adc99bb08df8f8e9" + }, + "y": { + "c0": "0x4ed05fc3217753d6f26c58478557a5f30f7bd43a477642ab8ef16bee05d69b488317dd6886bba603a3e77dbe95c6d5f", + "c1": "0x44bf737b2dab862bb4fa354b0a465b1757fdedea85011fd4ef5fc4e17cdb401759df5beeb84bb5422a0a6ca194b0981" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0x1268118abfd3e645027b72d1a4c8c236e41ddf221fef8cff3c7559a4981249eff63ff1ededb5d0a1c80b30a2c80beea1", + "c1": "0x107780e917a9afc112b5f0802ae284c44728c48fbc5fa9eb2bba2e9fd61a5045911d3d99a65b2469c90f456246ec0a48" + }, + "y": { + "c0": "0x19b0954b747daae60702ac14575d842adfd45b38cdd379143191184f1c338a31b0f077f3202d85c2a0da8bbfc1a03d28", + "c1": "0xe0ad4b0fb024aa9b85e594aed2550dc957114affc5105ca18f8325495741ace1f1011d2047931ef3458617dcc17e888" + } + }, + "scalarBits": 32, + "scalar": "0x5ce4a671", + "Q": { + "x": { + "c0": "0x5523b2116b6d71a320a7b7cbb5b35256c8a2625fed5ca637e2a4d921ab9d6903b2906111157579d683189b7d81a3ee5", + "c1": "0x100f8b6222743121835efbad18f1482b567c6face7f26d27808cf143acdeb0419187289886987401dd7507c6b75b859d" + }, + "y": { + "c0": "0xedc2f7f2cf1e635d93c4ef15e8c31489e4b9990d23016aa2f15f16d4de8abe572aed376a4b888addc729c369ed4d3d7", + "c1": "0x173a124f64395302580fdecf74808e8cd5db169337af753b75009d6cac103595c5fa8cc2f4991dda152fb07a3a4e7bdb" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0x85bb01566af85d34b0556ad774c2e4f89996509c2b91f3f65180cbbfb7c485b4a22e7ac66e4e20953232e8f779c657c", + "c1": "0xa239da990afc7b9f6e6a55f3878e487d3676c2478d05dfaa92738aa3bbd5dedcd6fa9e89cf2266d4d63f539e385802" + }, + "y": { + "c0": "0x437896671ea78729dc6c642a15dcae9e56957f185597379800fb2807d0f3b81bc01ad2f31b7320d8b619c1cc560bbba", + "c1": "0xdc621014de77b58135cb3ceada6a86e53dbfc174c6a843e42233f754e7cfa7979427a1fe5f9022509061ce746f0eac0" + } + }, + "scalarBits": 32, + "scalar": "0x116b1d74", + "Q": { + "x": { + "c0": "0x19724987c6131e364a8666b99c21ba4a22f43ca9f641c3da301f2576b079e1ee5f18b784d31ee88e43b01b07839cd4cf", + "c1": "0x177c8923ad8858f7db143d2a8bc4eab77f764e4cbcc5e5f0290bb4ec81846cee09750194d447e7522705bb765282fe23" + }, + "y": { + "c0": "0x1452e0150701e0d07a5344e4e6f50e3b444099595cb63bea61933df9f2c5f56736f36b4c4abc6b317d5a75e374d1d660", + "c1": "0x60723fcc923f835fc175f6f81031455e57d46561162e5bb066695249f0fdd1d8973bd9f5393d3d95d0eb5b17dae6b0" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x16954b883fc45208f3f4b04200540b95609620313ba1c882bd37c54a3e99f1a89ca82152a64ad7f10fab6edc05a91e45", + "c1": "0xe1fc815c246cd200d0367b5eec55a6cbeff841edf1c7354e31f2c8dd32bb7b986a72584a007def763c190c042e996c3" + }, + "y": { + "c0": "0x19cc729dbb3cb22f939c0ec63662203a3163a8cacf6bd4a0dae85635293266ba2be034bc52f17631742f3c46b3c2ba74", + "c1": "0x3f722b0d613b065acafb7526a5f7015aa5d66301ee3e5c1470b5403205ddd277ac28b43c88c7cdc87c675a88c008d53" + } + }, + "scalarBits": 32, + "scalar": "0x23ff7ccf", + "Q": { + "x": { + "c0": "0x102814259b81cb40580e0ca8a349160d246d1f4610540beabc7eca9185046061084fe4b833345546fb3833b8afe406d9", + "c1": "0x16b6587ffa6a2c381c726c42c7bc6e8b090caa9b7e7c96063e7d161f19e1f44172f3a4c7d7c658c3aa2d1df5c5025794" + }, + "y": { + "c0": "0xcac7a8b8fe175efbb637a8b80cddffda403a2f6527c56f35b1c3309c372bb300543da33416307af8a6650d6475d56a7", + "c1": "0xe79e5711ba4e00696281b5bb36e867804a7f6b5254bca85b213b88749e5b08067cff589583eb2dc934ca326045fddad" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0xc13c3536375eec4fcbbd6553c9c884c385abf1c52e3379ec6d93f3f8cdb02896dbf47aa26362f9708fa5ea938e97ce5", + "c1": "0x938a1bd16b11e3b65e2bd824916d4c7382aeab8e870e9f67f1484c250960ab8889fdf1456a39f0fdb824ee074ac39bd" + }, + "y": { + "c0": "0x502600f44a48e22b02ceeef8f2eb1de5ed0b3b02f8f6fd40106388adddfa7439b4d7c647fa1ba6ad6f9c24d36a40633", + "c1": "0xc5c33d4a1200f670b9c1b733a5eb3af700e62d39ce8b800627e2ebc4ff2cdc54eeddd785b0cae979e2c1472a106bed1" + } + }, + "scalarBits": 32, + "scalar": "0x773beda9", + "Q": { + "x": { + "c0": "0x518f1be0996878de1c8189ca0ef6fce363ed7258bbf6153e5f2d3d58cfd4b01463b593b823dbaad4e8f5d03822b514d", + "c1": "0xf98297abb1d995505f5c80baff0555dfdd5db2564230970af30ab8eac78dc2048ea321f4518d1ff35e7e38da66addd9" + }, + "y": { + "c0": "0x21a20da0094891284243ba266d44074835fcc41879124baa6407383dea4bb40b56225f76ff19e5244a8341d4c36686d", + "c1": "0xcea220d8a9d0e5858435a3db54a8ad6669e5fc6af2e61c86d95af1946c0f45e8fdec067cee049a7eb2b8a1ae869aad2" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x187a893aa6a75fee8c7dd73a7f5fd9d803f1dbfb9a643a8265737e5ca419f6426f64b191bcb3dab701459ea2bb58a73e", + "c1": "0x280ff4ce7491479365a119520756c2e83f11b0e5bce428e22880b2db30ae87e771753fc2c8665dcf026119c70545647" + }, + "y": { + "c0": "0x1ea29bf3a8d1ee4fcb6fb7fe71c6377c9530bd5f97077d21381d42a935923b390c60097e3c856b96cf85dab889bd62a", + "c1": "0x15ecc35632f82524a77b5a94320b7d1749d473c7a6facebe94b039efe965f778e76c118d3589331d6dfb94f9114cbb0d" + } + }, + "scalarBits": 32, + "scalar": "0x9dd67296", + "Q": { + "x": { + "c0": "0x63def68c967507fb8552c1f1ad1c200b198ee2fc05ef34a2cb204cd50288a6a77ba5c89e99cb019cc1e1ea6ca16fac9", + "c1": "0x4af33fec20899a04af7ca7d3818f0524f0645dd7a7bd21a457dbdf8c0468d90d3ec00e0c726f090c81cb95c50bbc" + }, + "y": { + "c0": "0x45719fd799f24d8eb33a39ac42a5e5e1da783f2de6025dca81760e5a67cfa489677d89a26a2a5efc49459ae0da7761", + "c1": "0x4d4c7799cca25c0ee212549d378fa446d062b32fe22d0e815e041a3a97da3f977f72601358d208891cad5468b895623" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x7c638eb54afd2d3fe9a43863914e8a4045a3fa753acccd7ba283e842c0985d514188b13d5ae28266c10875692de7119", + "c1": "0x79f83cf78475dc27ef5f6548ba2e12438fda46da00b07fa78de995ff52aaa0ef7728d29493889d2e02a2756188722a0" + }, + "y": { + "c0": "0x15ef17a23f24a6b382cffe3bb2645dcf0ce3d8d8cc08b1146d3b410ba691e07f5046910924e0576903a26f166f14660b", + "c1": "0xec0f2153a2834e0a8580257d1997fae4b10711f9c6572b228cb4ec180e4fe7234c0d3912189d35391d4842f7502cf53" + } + }, + "scalarBits": 32, + "scalar": "0x2be3c35b", + "Q": { + "x": { + "c0": "0x99df4124ec5cb18b7e34ee4e1167389454e650863ecb37f601f1f3691a79000df9768a280bc3405cb6b3af04333b6b7", + "c1": "0x1343d9ca4863a8bf40584fc507cac4dac8c89b870e3f8071827ea71d300c66d482cc021abc0d030dd49d62e6f0bca34f" + }, + "y": { + "c0": "0x1b6eb8fc5e442881027b98352fbefe78b528e466c39613680b03187dd277691d9c336f438468e8165bf16781dd12265", + "c1": "0x198b8880b8fd1508c748b172d32fcb0832dd00d7d88178c3bd305b2a1763d89ab8ffe94db0888d51baf9298c431af85e" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x1196d67eccf2f07ac2249ef581a1efcbc30e0987056cc4395d3e9585167a7e4ef56745319e03c5012bd7f7faa48ecdbc", + "c1": "0x3e1a4f1fd673ee93ee74a14e7276b919b586b41f3f6eec1f97ad4575618800245432c2ee8bc9856fda3b8b725393bd1" + }, + "y": { + "c0": "0x32e4f7f14444302e6cb5464a28c443616cb729a4390e5e54df7801af4089a06d8d56921c07559c752da7a321dd81ceb", + "c1": "0x141db08f41d96c6809a1408002ea1e8ef5462a1d0d31d4e3034a6f82d15b02321085637555a1837aec1f1f23c033abe7" + } + }, + "scalarBits": 32, + "scalar": "0x3551f4ff", + "Q": { + "x": { + "c0": "0x37750bed54c68bd2125813a077404f31f0806388461be46567c4d1eb785cb5f7f38f0ea67499b8895c3b1112df1b4a2", + "c1": "0x12494d4e14a5a12fe577297de3fc8d72794107e84faf8fc7a0cec5858a2aaef3c8f46a722b13d20b5971c523415b7de8" + }, + "y": { + "c0": "0x1933e75c66d5fc2fad4e49b82aaee976ceaf66a67f3c0965ab913187844dc990f0e1f3e72395fc3c8173dac43427e45f", + "c1": "0xdcedd599894d972fabb51626eae1b9d6f3b6b58e4296da712bde6ddf8518a6dfb08ade1eadf86a2bafba0b0e9293442" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x18b0b0c5502ce459044a54003f0d3ecc5e6f5df85f0d13e0740495219568c060e27ec29137df44f9384000cc6871910b", + "c1": "0x4af2fbe4292c6e46dd1f33ba7b2e1301871e8e05c77996b90ede9717726163d11dbcd6f11dcf2d04557cef46123a72f" + }, + "y": { + "c0": "0x7a90806b2425b8ad78f8287521c37ac0afbe090bc8a44beaff02498edd2071d58dcd59fb811d2991f3fc5ee6a34a4db", + "c1": "0x7b373e5d4286528ab189c62af002d072d95ca61ba92a3b2607f8ff15f7f93566ea9be19233bcaff8e5c2df3962be708" + } + }, + "scalarBits": 32, + "scalar": "0x4589651", + "Q": { + "x": { + "c0": "0xb4cdb694c392e7140057df2e56832f3480c65f35c2c5a52fa3bbbee897a09c1175ac1c2de8a00afe8fe1e07b7381eed", + "c1": "0x6d472dea1c6ff79e36ecc2928e547b3022c6672b15b23ee8c74bdf86c325117c0f7e9fdad98a82df0c93eccb4e33e3c" + }, + "y": { + "c0": "0xc71626f590c8cee438e3b85e135b463071e1c75b8e0f30971b7e69c01e0a89a2953b35f1f02cd574da7b040025be14e", + "c1": "0x13bedc3ce1f5a2332c55988a99657cb7ff1b7c08ffef72c18b046be8aa4c262f7ec12d17da9b8696e57a3469d8eac7ee" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x126e04b8253dc8e58d1ca141f4bb8bc9fb65a2c269e827efde687522e267492030c3638ab99683905d4fb2c2dc79f0ee", + "c1": "0x173fdca3232829e57bed30a76f12e8034d1cf942050ef26ede1358de66556fafd0891e680d7cedb490bb83b4736e90fd" + }, + "y": { + "c0": "0xbe10b80a83ebec17fcd679b19e793570b11107b67b1d5eaddd15601d0cdd1aa1f833f4790559a968a66b435fb5b6dbf", + "c1": "0x101abcd804b7557169ce0e46575abf4a9ce71b704b9856f43a8b8594084fac295086ea90b113fe95cb074e25e89434ce" + } + }, + "scalarBits": 32, + "scalar": "0x852f2696", + "Q": { + "x": { + "c0": "0x76f6e824508bbbd9db63aaa6bc46a3fa42d02fa87a1917f8311104062c236296f69c0f923e11348e2a57d0e009e4f6a", + "c1": "0x40204c289847272651fb08072dd2d5505bbc72a2b033753959a8eaa87b5301c29ac1079d0af453c85c050ce97bd73c9" + }, + "y": { + "c0": "0xba1a695ffd42d3cef86b8b6362805ddb4398d53d83e33b77ff9bfea8584c3d22abcade2a008958e2c87261df6191ddd", + "c1": "0x16c85632644dad3db91db5f6df4b84a991da156817dbeb8c951b3e4a5ef370a4bf4d372562634f9b3f1a87502f146041" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_64bit.json b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_64bit.json new file mode 100644 index 0000000..0f5759e --- /dev/null +++ b/tests/math/vectors/tv_BLS12_381_scalar_mul_G2_64bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BLS12_381", + "group": "G2", + "modulus": "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", + "order": "0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", + "cofactor": "0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "M_Twist", + "non_residue_fp": -1, + "G2_field": "Fp2", + "non_residue_twist": [ + 1, + 1 + ], + "a": "0x0", + "b": "0x4", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0x9ec4d4d15b8634a7a2b220486ad93735e96420b6d59596f767628f91b32b8a2a10789c0b9a7d2c919741374866166bc", + "c1": "0x12297bf829cabe2ba92e6699328a14c604ab14327748c6943ead5eb163df03578187d26f61a8aa67a9a31a690b3a8f58" + }, + "y": { + "c0": "0x1408cc29c231f4378b7221eb2422e8c1ff34b7bfeaa6751453ffef5580326c73bb40b340ac059186ee70e500675533fb", + "c1": "0x12564f85a81cccfdf565f3d55da3edbce5bd7a8aea7c26f1eceb36f656804642d4eb1018da9e3984fdd0c8145824b1b4" + } + }, + "scalarBits": 64, + "scalar": "0xbcc260173b46567d", + "Q": { + "x": { + "c0": "0x147590682eee934514dbc6f6d033a22e64411b0f870d3113926afd8cd00b94c1e91f6f2e07f5f76b499939d7dcee51c6", + "c1": "0xd3526e271be378e798eec0b8923c0772cf5177d0c7c76992561382949d2580898b16bd3bdd7f02da7d6191a8f6b0b2b" + }, + "y": { + "c0": "0x36e1e9674f8477635c200729ab270ac3769f3d12baa43fe08669e894df92caafd9cd53683d9aa61251b22ec0a3e552f", + "c1": "0x9e1868cf83c366edfeec1dccfc4bcb9754aaab8c57f9c3e2e4ddadabdc714a0a0b44667770e2cc256f115479a80905c" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0x3634639b643931444523a8f37b12437e8dc856a4386f0373356a7fb0e14479cf3f1798fbb292baf5b1dbc32deb2852f", + "c1": "0x13330a2a16e622008f60ee20bc6e829468e7649cdd86834c0bfe2d7b7e670766ff0db76c53e723c7665db0c8a8a02831" + }, + "y": { + "c0": "0x5b490938a114eb26a0504012a660d772b0c79ff08424235703fcbf725850c14b867b650512f6feb9f492df70c4d4e1", + "c1": "0x17f5c1b47a85e80ec5f9d495841f0255ee0644f4d975503e4c96f07a71ba1caeca05f872fa8923a357cb34399444d71" + } + }, + "scalarBits": 64, + "scalar": "0xa250e5562f4fdeb2", + "Q": { + "x": { + "c0": "0x6783fabcaf77e5e5b533f17beaf350ee597051a03738d4ef80a2f317493b130a4f182accda9dd223a5fb282ca4557a", + "c1": "0x16dac033350ea683bcdf6825c3397164e293829de9b11c1d701aa9efe7d9d2f856d756e81fa4fef9b2703dfc86c616c0" + }, + "y": { + "c0": "0x704ff21be34d4fb2039e0c1997314defc79ee84c6bbf3c928eb1df5727ecc838e63c3461ff03798c767c6d3a4e29db0", + "c1": "0x4a46bd38e988641cff0678bc8c8ca19edd44c313a190382c57e3d6dc7033705f1bdae03e8ef45f1c794034dd090927d" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x7867ddd7f5a7a1f2099bbb2d72a9bd7c2817ff625b6b45e89b1ed3a3446201145cde991ac2282c6ed67176e22f07dc1", + "c1": "0x166dbe5977992458b4e2ed82a817b59e84b4f221a4109f4ce45c2fc1ea3cf363a835de8a38813ba3eee03bba372d047d" + }, + "y": { + "c0": "0xed9071c526907db92fc9c5d751f1a9a1031d51612a42e91e26868ed1d00b5f566ce838f6c54639aa761223f24fbfc45", + "c1": "0x134004d174916e0eed0f81b43018d28c47c96344e33467e8772c5126744b45b6e35afe1f346755d327b39f8ad80e5a75" + } + }, + "scalarBits": 64, + "scalar": "0xed9a691fc5239cbd", + "Q": { + "x": { + "c0": "0x83365357edeab92b6cedd26b5677b87282d5033a61507a214f7cc1e825aba41f2e924ddd8a750cf7aaf82e2f3a2615a", + "c1": "0x104d2a0a3fab5874a85bbc71bbb3e632bc9c70602759d9c66da85cec352fe01e9618c7d121103112d5a140236f4baff4" + }, + "y": { + "c0": "0x286685f649e68a6a934c5104f01e545026f33c003377ad2ef85329993bb78f09efe3a5ba28062e0b059aa241860941d", + "c1": "0xd422500c3f72e134fea91ed3529089732d8a8429377101dfcc17b8d720096b5c212aa19f4c9d33183e85928f8258cdd" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x3de9608707a6cafa119c0280cd625d3ea70ec54b1206226dd110ade9197beade6f3e7fb635eee8fda560a0453778718", + "c1": "0x112e3bc71f6ba9c8574d18c05e3e1c5a3228f8541cb18dc70162b3d8d2d7051d6df74a0825148fda5ec5b692751d6677" + }, + "y": { + "c0": "0x7f33520954802bfa9f82cacb238eb57b6ff23b5fd79be67c8cd48ae567e9920492ad5d7970c6ac74bcf634ea5b74880", + "c1": "0x12eda5992446b60b423117e8b53257f0879689078592f4dfb69b0bcf459a2ae5ea4069b4a88ffb9741f77d94568d0b69" + } + }, + "scalarBits": 64, + "scalar": "0x663829442d5c7320", + "Q": { + "x": { + "c0": "0xb1ec88352baefa8a2cc7bc8021b9ae00124217f8db28da1dcf45626f1fa11138ce30cb4d1e776ab53e3baea70049063", + "c1": "0xbbf84e46023ef3f1bceb970335c2da86199007f7a92f191a6bcb2a39cf2333580037d1cd8c60596462a0d665e15ff90" + }, + "y": { + "c0": "0x10b79aa9476ea0ff3e07b85cc376862ebafc0f140af0e84964e3fabb2cad3b4d508ed3f204e3991fda3704a2e3767b29", + "c1": "0x1878cfa559020453aa9e703a70f133201d0fa8b3cf0fca3059591b744167576c2359d094299a6fb23b111876e8d502ac" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x16bf15db37755169eaf9e32d37ae6f01b0208b87503e063110387155bb6ff644761e92551b781b8d85b4249c49b22afa", + "c1": "0x120bb9d427a60456ae24b5d035b920e2c01e7ae7f7cd61594e14dd2171124a8fdd744698d3e108e3d9365a0aa0f8050e" + }, + "y": { + "c0": "0x196483b404b0ec535e29f7e45988f48b2af81b59e6bd7226270005fd660107a137b4d01b076011013fa4be63d7da06b9", + "c1": "0x180656d1d286df1f0aea2342e96060dad42b227f3b19aab604844b9d586a225d05125b679748379ed2422c69e8ed8d1b" + } + }, + "scalarBits": 64, + "scalar": "0x8bc02077ab3f7d0a", + "Q": { + "x": { + "c0": "0x6250e6404a1ad5b0db7f6de1bb201af71da30ed2f979a5f6c78c2ffe9fb4df707c0db843889ecbb7897d3f08bd3e42b", + "c1": "0x44996a0b57945429dd4e73bc50c2c346cb915a7367135cda99991bcf83e3a78d4d6ddc2a52a8a398fe7bd9b6fc05ec6" + }, + "y": { + "c0": "0x146564aa55ebb9b43ebd7b85c013d3a81a28835e53985747337ad50fc40fa7ffafff53ddd8687707e58cca5164787eb2", + "c1": "0xab95fe6412783ed03c9bd7542502a3bc98ece3b291b4d5532d37ccaf65278e4deea6bc018dfc947711247dad890a0b" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0x156c2d40bc7fc289042f63c80621c37949d1a8f0266133edf26c7ddb37276bf8f46532aade79d34be36b6e93deeb560a", + "c1": "0x1fe420edee01d3f99e4530b3955a0a2a091aee43df153e307997974810bf58c3ac55252df4f0b545d67bc4d4a03d3ad" + }, + "y": { + "c0": "0x5a682a75535286c377f36266d9cb4b9ac3844ffd885a1054b33c52bc36fe891911400948aa86fec64d267d0dbe306d8", + "c1": "0x12a62493e26dddffb7e7155e795ae83f735108bb5a5be29f2c45e4522ad0e12d9c7e4a5b7427d41d88d2d0c30f6500d8" + } + }, + "scalarBits": 64, + "scalar": "0x184744146162e9ac", + "Q": { + "x": { + "c0": "0x167c388d05d32fd1bb30f1c9ca5c0c460f45282634e7dbe1606b36ec4757af117e1f05990c16fd65df98103b7a46c7d5", + "c1": "0xf301b8f9a4f31d6b1e9680d97c322b90aa05e6dd5274547da9719a8bca9335720bb4d4337c2b70f9b6e862c458a26f7" + }, + "y": { + "c0": "0x17362c8ab4d563cb7d4950d247f71bf6b5c86c38d13114cdeb76e242441a3d2635a4b0f87036ee17c73e5aa2ee66b00c", + "c1": "0xc38579708af1b5d9aee95f9f549ecaf4e3cf96ea2e8f5d03900584aa526140addcb8eccbec2f05eaf9bddddd342b734" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x1984aec88df4335d6cd94a78522333ec16c6ea38880d1466a416a172c372bee07817a796baef31851a34966fb6ee96f2", + "c1": "0x14b693c670ef5d5831b38e0273086f45adb793a2ca6d785f36c9a9ef7c5e634ad653a896226bec2ca63f0f1a50934ea4" + }, + "y": { + "c0": "0x93b67a9dd28b3512ae20aa5d97b143cb101f57d255e242036a57e6f64794632f62a14f34c9e6f152c82df6d23370706", + "c1": "0x14e83d62ac00cfdfd9b3209d1ab11e02532fd9c14a0a8428ba98b262c6e06334245429210accfd6999564826ec8f2dfb" + } + }, + "scalarBits": 64, + "scalar": "0x1b2886507be36b85", + "Q": { + "x": { + "c0": "0x18d3d32bd2e3d932de2d2fd2dd00a15d5745763bf45e4b707bb541abef7f3ef6e559d46fae9916090c51cad76b46ae61", + "c1": "0xd7ac87b4e302b4338c84fc8602dbbd9752325de4112b85935b1f33657a4a4629d7cc4ebf129f2a078cfa19f8bcd9ca7" + }, + "y": { + "c0": "0xb7f56f9c11f51e3926a0059fecd82e9706f46e5809c8fe618cf4b36120303fd31ba2e0b4375cbb87329f5a9da29f9f", + "c1": "0x5b020cdb86d5fe3f53f0c8c10fc9bbbcfd1572b0a259a1b5e20c5c41bea8ff4933a418a5327935a86d4601b48f32a1f" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x4db025307cc9a20434c1569c5901c3ed0b16a08b6494394a9063a11e39dbd02d99419b938c2830f5cc0759bedfe1117", + "c1": "0x82cb6d00b21265f15102dd25a92c3f7209bbd81be5732939a91a678c2054d5e8a64295923d2c85c30080dee4ff788bf" + }, + "y": { + "c0": "0x1151dbbfba2d975ebed40461f384e964cea53e950d8b04def48fd02f92a7041f05cd239c19d4477a8b08a6e49a27e346", + "c1": "0x15156dc92eb910f8e7d0fef4c03d48c8d38c557d5da0356ef0a6feeddbe8f6704f58e38f03fdc46b57737a03c3b4b16" + } + }, + "scalarBits": 64, + "scalar": "0xef63899b369a1563", + "Q": { + "x": { + "c0": "0x19bb2405c824acab16d0f93f5b156623f98fa2a527b9e351d2db8efeb40653568110cf6eb4efed199178e60dd711723f", + "c1": "0x19121977f86720c0db5243dac1d43829c5edfbd9d3359375cee7e308951c152a6e7d18013582c77c40ca1a2918d77f19" + }, + "y": { + "c0": "0x46db64665c6fa53dcd7ac2a248b5c0d2a6b6a828f93ccce574efc6608879794578a16f287ccf26410ba003ea9ba63f", + "c1": "0xd33905526b2cdde290d2e9c494dedb2ab2efd9897c7919e4ca3f3e153e168bd4caaa6ec1aaa4bc5147a98c6857bfe2f" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0xf9d40961dd22282f09dd9aec61de418a05a9938475be327f75d7674e841461816083b106e1ffa38ee38762564aec2df", + "c1": "0x185b47194f50a6f6e2e690a79d1bad936f26b4cbadb57769c7b75b6caec7d1da844bfcdf7ec689dd9c6025b0645f1c7f" + }, + "y": { + "c0": "0xd00d9f9221d22a6c512f661d7b49640426d955e58d0f500565f3b46eaec042b8c6a9048c2058ca361d48f4ba4a6baef", + "c1": "0x7555576bd4c8a811a282aed8220ba7cc4294856138e5db9ac1dc601a8a0c59d8a461559001cfed3073fb1d1184d07a9" + } + }, + "scalarBits": 64, + "scalar": "0xd3b7882d08153c88", + "Q": { + "x": { + "c0": "0x144459dbc6ffa62421c00e0700cf47be2ffa17c68725e623706b15899436badb72616d25a459d46d41d86a3b9f783f80", + "c1": "0x18fae984cf78720ad4d4b7c5a8991d9d5cfdca7a026a488e1293ceb3d9a1efd1976ba4f6f9176bd2c1f7284b29646f28" + }, + "y": { + "c0": "0xce27c4591da54a484a63b22d97880fc99b401f4a61fda1c6891ae110addc45f984dba903c2a6977e3953aeed1d9ce09", + "c1": "0x116428db5c59707029a400eb616ddf0999bf1488ae8d1364057eae9047e6e1ff8528dcec9cc9130f7221f3b542cf45b8" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0xec888926857ecbeb586a83dbfb6083ed207051f1e9bdfad9ef144b1ed800cd08129023712fd940dd4886f7d97410bb2", + "c1": "0x1543b2954bedc9e92e26761851bc509357121eaeaeb142cbe26b3796621f1afbcc12d48ee03c78552613d4c77d1fc9c1" + }, + "y": { + "c0": "0x14561e4a4fce3837512ae0d61b4f52a40d9346d3fc64f3ce1ccba8d6b3b5366e8045272310bef842830a52fa1f20ee4d", + "c1": "0xcf152b7e37502bc15f9cd2856aefef5b61ebd9f3bd7f3b8b31602bc53d1b98b243fbeaba9c35df8261c6a25e41a6004" + } + }, + "scalarBits": 64, + "scalar": "0xf185f6c6cf34ebf5", + "Q": { + "x": { + "c0": "0x36cfca72e0d79ac2e5f2871f3daa454f3ab9b93c3912d7598c0a7cb09d89cc2edabd42ec7aa8870b058c21f9d2156b", + "c1": "0x163c356474fae829c80c22f054bcf0803a28e868a605908bc3ef7c314bc313d57aaee7ad018a3adac4ea69ca0dd34143" + }, + "y": { + "c0": "0x10351905bc8a58e66ecd5ef93022d9bd04c9679eb8bdad3e153c371ea0f16c3fae12a3d4d7add5d97d6b4bee4f547f66", + "c1": "0x9e8d0a9bee4108e5f06888408198e63d23fed4d4407081824e8a79a8727d78cf878f5f3718bdcc1881eaceab13178d1" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0x4d6c0dfaf64dbc104d28cf2b81c980ddfc18d10e42a02d5bf23d669c5901e4305e6d205775bdf66acedfce8f0673c57", + "c1": "0x961aa36ecc5050aa817b6a1b7d61aa6daf4ddebdf4399fc5f48b69b5ac91e6c0bbeadbf43b51e82151f9f6363f50b1d" + }, + "y": { + "c0": "0x82267a3aafa9a03cba79888d1a2906202bf0b5e4c20c742cf159c9be665c1d45da438185adbd16627f6c705129eff7a", + "c1": "0x31fca4afd2863bcf212fa9ed57aa7540151231fcaa9d3f28268144a05d05479f46255926595d2309301846aaa0c11d8" + } + }, + "scalarBits": 64, + "scalar": "0xc055e5305a44724b", + "Q": { + "x": { + "c0": "0x1066f234624a40052adf8f6719040a5007c1fd5816796393f26a5299b7875cffe53dc65f22136a97ba32963c7b802fd1", + "c1": "0x47022e8afa835c61271b44eb90b9b3bb6deab2f409cc04f39f63a4d10061012c08dad2320e7030674a2999afa46b18d" + }, + "y": { + "c0": "0xb252f0e161f83491b7e5cd24f3be9ac1b6fd845e6c97ff19fc6db682029ceaf9dc582e55b0f691c5d2fc5e9eac32f93", + "c1": "0x9fb6856b9cf3d01b4c8793ff770a5b0704778a36eced69b2ef27348ff63b2d45779e5495ca3d44a84a758251b3f262e" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x12c6ed0c1443ee980d4bb6f2b67277a014bc8092b8dca9494346f933c1de98fcc4e6c7e4344639ae8cefd67e19a3d53e", + "c1": "0xd749d957b510001048066a057eab7d975ad0a3123e3fc3ab41bc1107359b99554ae8ab2191eb8b85f8be42ee879250c" + }, + "y": { + "c0": "0x6e8789c808b8ee843b20fe063847f0edaa8e2001cfc42d83b05d2a364e9a022203642bac866466a458271780d697c3a", + "c1": "0x8f4b281a262b91ebd6526f3cdd9e1b86cdb6dafee6c106f385ffd5dbde3548b549e001ceb6290244bd3ad1212264a3" + } + }, + "scalarBits": 64, + "scalar": "0x4fec881622409af", + "Q": { + "x": { + "c0": "0xe10a187320a54096f014227571b2a0959b9ee9872e0ebb9554244c753b07c6e947136fb4cb491e7abf139e49662cb73", + "c1": "0x98e61085e477b158ff29398a9c89b74bbb454ee898e4316446b04c2149882be44b6253550580e7d525e64a8c074b051" + }, + "y": { + "c0": "0x364a78b4fe203f2387afdd03ad6eff50b924b3b4abca5005f7b812fccbe27d501c094f082f6633828000123d5f8a3b2", + "c1": "0x3bd4ae4dc11b614f30b3bda479bc0a28e85682d596e45cc3c410486e891c7974b157de2d02912fa7bb09a136cdf1da9" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0xb90843d9d33b8db01ec8c1b3973af0d1092f7728f8e7247db26102dabe20be2a6f2a1e61e069d049604671d6df60915", + "c1": "0x159d82960a846c9fe7eef49eec741f5da8c8541f973d6596873dc7fbc02861628809289b004f733f4af9074b3f68608" + }, + "y": { + "c0": "0x664c70a60e5a64f2e766a1d9e59a92851d58592fbc73663728bb1aa3b6b43d812a86fe7398d64496de5a140b8a9fd94", + "c1": "0x9c16ce9eb1d159adb52f36062d60e2d1266113f93ee4f04ea965276581aa987e09cc76a71aa23b54dd60b26e26ca3f8" + } + }, + "scalarBits": 64, + "scalar": "0x9eea6baaae66f67f", + "Q": { + "x": { + "c0": "0x95ab36de3dcb1be16103f18e3edc18aadb66a71f0fdeee976b1bcec820756b58a934ce7147a010201dd1b725f53e2df", + "c1": "0x47e7fb4cde4c1573fd9525aacd596ed1efe9f51def578d62e387c23531d27f7fa89160516d52605edf5b0a50b4ef80a" + }, + "y": { + "c0": "0xfc8548a1cbb91c10901395faeb4ca683a885ffb69b2f7a7e681657c651a22e256ea23d375eb0087c0b7afc134891c4b", + "c1": "0x23a0f14650706510adb931a478eabb19f8d639211e11cca378920eceed24d27e3403a7705ad314230dd0ae8c1bf7c51" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0x8c1d7c65d260af3b7c1a970064bad32348ee81cbc0db9fc9c4679f896f8378cd32391f701fd3b90a402173c22ce4751", + "c1": "0xb2ac404773d120ed2be21cf63df6910d0cfab6d9fc8aaaa720cd1c7347b071a3ec997119c2aef5cada9603e427f8991" + }, + "y": { + "c0": "0xdfb6a501c0c50e7dca470da271f87d608d163eb4b29b2b3e2a7f2452fa281a332453f59ead3a741c1e8428d2e508eeb", + "c1": "0xe61eb3d038e6ba188ad4c139d8350250759841d193761cce084ea6a499500140a35017c95c9b2487604332aba46e25f" + } + }, + "scalarBits": 64, + "scalar": "0x7ee0cfb18a5a34c5", + "Q": { + "x": { + "c0": "0x772e7237e5d0cc93e3983141406dd18a7148043f1aa1935bca7a6bbd80cdf74e97d1fb8def9f447c8044f91e41fe6ad", + "c1": "0x164a977d6b95f4fc318a93adc33983a8a0df1b94c1db0c6d3ce6cdef53a712f64c6b4ead9ac82999d22deb31c97cb9b1" + }, + "y": { + "c0": "0x114798126338f00408f8b91a5b77f103181a1b946f6da0f2c262555516aadda71ac9cb06c873998e68d34bda25b2ff42", + "c1": "0x1fed557f8a6e98d98e2386b6bb028a69289c0e233618c6d8d84d76a72a526d614e087ff02a66ae2c131bba701107b92" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0x112b35e7001ed3f012d085fd0f2867f9fbb18383c469d8cd9fbef4a20ca069616f380e0a4c8296cd1d266b2dbf31a656", + "c1": "0x59d47cdba51412f0989d00b2200af4d9fd7758bf381201871664cc8634c0de63553c368e56df2cbefdcaa9e6bdfcc9d" + }, + "y": { + "c0": "0x3c8b33f820d4aec6870071947433cf9ed2773ab56aed6214cebf843bfc72e5d01b8115d6f3554fc5c5a383d6f830279", + "c1": "0x52b5029862c50385a068ab691f5b5f9a444d452bb1a3010dd651bc14f8f1c2e556a4400d64a4b353e763fc9a7c917cb" + } + }, + "scalarBits": 64, + "scalar": "0x3a2ad4b62d651410", + "Q": { + "x": { + "c0": "0x148abdb46ca5b631a01422e2d87c4c6919ce200a1f327a2dabf5b68f330fbc06638d2891bd66c584e3b5a23686fa338b", + "c1": "0x6aedbf62cbd6574fd17d75e6e9fab01e3a92aa72a0c29f5f9bb12e7ad07b74e5915fd89b784f3044080c6e561fcd2c0" + }, + "y": { + "c0": "0x1522f04894f371e6fc7858e7d5914c5621014f6e47d5328c286efd552b0fe688e9fad3008f21e81ddb1c7ef7337f5193", + "c1": "0xa5887a7426625704fa12443415a7cdeb169cb8bead9c047ab33c484ebc4f77575fc6e1f2e10f13ec53715d4f5b5e883" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x19659c64d19819c7ca9fec1046813460f3b32e5eff997ce8087a4d266889ff386c63f3897dbcb7ca19729a0dec215614", + "c1": "0xa26900ee38dcaf01fce3e31c3b69286e19b22780f3382360ee21bf481e2f177f99016a708f252f43d46e9a687fdf0b7" + }, + "y": { + "c0": "0x177815a1677e1d6080f60603ca27a4e32e81e3ffbc8c137198f9283b6bd8f006dbb24b5f90564def7b1d801f76112209", + "c1": "0x68989d276d7a0d86d72fa961a5723687c9a9cd3161fe20736ecf698e3b18368ae02a5ed5e40f74e167bc3b1a78ba007" + } + }, + "scalarBits": 64, + "scalar": "0x5d87105bfa004445", + "Q": { + "x": { + "c0": "0x20af96576897e261e4da0cf0cca159a4126eac73bfba946d0c0069329418e935bfece51e341193983a6ac2cd07677d6", + "c1": "0xd98a7052398bba3b4bc5886d53f23ab656554595f60e4389954c08439104248cd8bbf3ec3876ace50cb4286bd1bb4cb" + }, + "y": { + "c0": "0x2e9d09ee20a14da29cf6c42bf7d89acaafcccb10193a48a0672ea6d94cc64e6ad084a84cec42c72f2d4e6c417ad90e1", + "c1": "0xe05a4d9459d2b0f9c80f5a448cd06e076ce60df5ca5b0899add0dfb49624213fe9d11a4b8a385fd8c96ee1ed3b8e61e" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0x9b1bd4103fa6ba9b638506ca82c70202545d74929a44f65780adaa01ed988f7e1cfceadbc325fe9155f8796c4ded9cf", + "c1": "0x528e83e0d143e678349307e7ffda74603025d60a3d6fcbdacc935e57cf69d423c0e6c6515c3cf6ab7de37aea7dfde5f" + }, + "y": { + "c0": "0x42bb404288a0e186c21900504dec73901b97f7c9d39d3fce3c92055ef8b65734e816b3e505dc95c333b654bdb0350e9", + "c1": "0x5dc662676bcc8ef145cc79eeb4c3402f4cedb619856aa509aa96fd1686f2402c4252b241c143a48b542746f6a24d0af" + } + }, + "scalarBits": 64, + "scalar": "0x91f86cecbd600b73", + "Q": { + "x": { + "c0": "0x11175103a3542acae7853fb421243c235e803901fafcf02ed5cc9d35180e14bf77907c3a512c0b286bebc451a92fe6fa", + "c1": "0xca02141a7b9516ab164986a3c46ab4420d68e6bf430fac590ddb81cf7e5d84b403aa2e7cd8b8c29184faf3836b8e9f6" + }, + "y": { + "c0": "0x19ea9e406357cf12b0020230e8aa35012e007de02af77841e17fc67cf096a9861c5324fbba0b91ea66ad631e25a1d514", + "c1": "0x1092745fc611662d2b459a9f85645fd62165c280c6e9694419d1553228312c51841f10e87e353116df3f1762f35a39d4" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0x2b40d353b64b861888d31dd83f0ef78bbb60795944ed66131d798f658fccafe2bab041df9958bc26a2200a649651ee1", + "c1": "0xaa87b3302cc2793aed8a48e8c861c4fa630d37688afe2067b5599438b1e480170be0dea570ab96f8ce42c46c7745051" + }, + "y": { + "c0": "0xe16cb40a5f02569a7cb6a4c876f6872aaeb996e75f1a39367e25fc87d1e832f15c0dd757ef901dbe55bdacd84f5d0ca", + "c1": "0x156d3d148796a4a5538d7502ddff0162c531fdffcc2d424d9065c3d32b736b3339d14c2da9064cb7a3753aa4f2950a95" + } + }, + "scalarBits": 64, + "scalar": "0x7c3c4d66c8e5277", + "Q": { + "x": { + "c0": "0x153b4162b98487ac24ad070cae15edfff735504aec0d4a4f944853f2f506e715cdfc171924ab1aab717d90bbf75eb624", + "c1": "0x431e1ad2513079160e4cb83a1bce6a609795e0f85746fa968b82ec8fb92bd025b495ee595e7319f325a0a19bd99f42e" + }, + "y": { + "c0": "0xff76da1844673a936ac007e656f695814106b31f07f8e63021962c4b2a17984d1bac42df511af60ef161e47ce1196a7", + "c1": "0xd4059cd134265e4e825ae1706f826db7ec6aa1ae439b778b741a668af59372f5734b122169744a6d5567a2d8fd36743" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x1089ea96bc3f0e1c0afdea02a1b91d03b46957ecb707c6e71744423a3638cab50b0f89afcfe4e9185f8a4133dc54c80b", + "c1": "0x2c24e8b82822620f4e758e45a6773ce57b4fac8c60a7d2b94e40e268c87fbfeb503b8569849ccb2f2bc067d412abfa5" + }, + "y": { + "c0": "0xd62b868e3366955b303c7dcf77c20655545e9cb5192ace7585f30b30903ed1720e2a58ba9619ca0706dafbb969ff224", + "c1": "0x11e0261ca031282f49d229193f2e1c8ae02bcab448b3a65486406ff466552033381b9cb17f08d2c84e17dd95407b702b" + } + }, + "scalarBits": 64, + "scalar": "0x29a6063e47186e13", + "Q": { + "x": { + "c0": "0x301d5e2fd10577c766143823ce39fb03d4c1c626f68567c94b9be2e426c6684b534b4e94a1c861c55511cdd6db33d7f", + "c1": "0x18510bd6d68178c2109b9a3614e5f476dafd6c5a61d2c35b9dd9814309a97209a9e1ecbc914e35ab85d52c69abbc5753" + }, + "y": { + "c0": "0x66231d010b84a799bcb8229e55dbc2cd2a4b5ed3dc605f4ff1a687daff8b9f44627e643f94126ea9e12e4a185e19d8b", + "c1": "0x1c27ca627ac6050c104893f6bbba98cb6da0571393e10cef40b757c3f061bec0c7632830173cec0012123789054ae9a" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0x9837118f0f9b7448dff62a78e9b49408d17c115ec2b4710fffd0de3de07fa76c1494964192ade14ac824d4eed004422", + "c1": "0x51e094893494b40e396e6aefe0ff2cd27f97f91e1242dbe07762ff10a874707d3d3640367aea5005ea64afa23bf27a6" + }, + "y": { + "c0": "0x14367a0c91674321554342a003330de17f5555e3890db7f4556e0e69165e6624b7678312e0b5733fbd6da8587a72d3c0", + "c1": "0x193a6540bbed0625504d11d78664d1f1ffaaad06c5825fc3a1711d902ba6f8a46f4cd26ee33362cc54b611be283e5f63" + } + }, + "scalarBits": 64, + "scalar": "0x449b7742eb707734", + "Q": { + "x": { + "c0": "0x176e8e8f18952f56bbce0a2b602130a152eca3f723fa5d903f0fdd8ccb6729f52ff8b9ca39fd3d800d36254b6b8eb557", + "c1": "0x7b72df0ed6facb4e768da83f5b0162744928ecf7f878693d0f9c647b9bb7bb0f132202d1cd08301e0d673b1af061aed" + }, + "y": { + "c0": "0x1859e84d97d8f738ce0124f99021ffcbef1a52e962b32cfabb08bf312ea990597ad57aa7ff71ab14e624fd8807712585", + "c1": "0x18476feaccdc993904982d8386b5ec6b67a4d6907eff6311477e31212c9558a5fd45a7c1d38f1d894333d193293934cb" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0x17af94b8a31a6ece155a6bb129b4213ada3feac38a851130ce60f5eb266a0fa2a637597f4f0ad9be41adf54f238447e1", + "c1": "0xd18f650f93e6488153cafd4d123d350c46ce7d1552d3ddf47ad17e5683b865fefc3a1e3e349570400636c92a8597e9a" + }, + "y": { + "c0": "0xd52c0556678abecb82a1ff0bed158b28a0e4a61a8aa52b371f9568fb2932d0103155eca0f9b235e8ca13d6647269583", + "c1": "0xe40f21fe8f498de3889935d306796ff0f9f780827a6b7597c8f83309acb2689725ea28e704dba94f8e285b24f680de5" + } + }, + "scalarBits": 64, + "scalar": "0xc62390a57cc8252a", + "Q": { + "x": { + "c0": "0xd5097fc311f4e15f5b554c0834998d863905710e4e72657a3fb84cf369880a61153a7d744feb5c5affe37833d43aecc", + "c1": "0xe94a7af6e8200b00cc755557642421cb061753885124f64cf059379dfb4533d7cf5526100d6a73c7cf72c26bb52f73b" + }, + "y": { + "c0": "0x171be5c083a2fc86c9f1382b65629979928224f4d6b8d9eb0d695ee51a94e3e755ed282aea62c868850c0cec73935c18", + "c1": "0x19983b4554d4f94ebdf20c6d732a2c51ec41bc7aad9494ee267a74ac198c9502bdb9bd3ad8dc55a06a2a5657d601c2c3" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0x4bf835e6924a3a8d58588f5588f55ff17336585c289f26503f93ceaabae5d8ca79c3fef2d9d5e31f0abf3548b3173d9", + "c1": "0x19d33c01247de3848b21fea22b3ca9ac7b1975860deca19ed9ed75d62639d58db80705349565410a8d0b384f2976be3f" + }, + "y": { + "c0": "0xd216f57dd2597a80b9f5e2f556d674893539258c35977947eb49b44315e52d45091d34db061063cbb451138decf8e01", + "c1": "0x8b4269d1511d6dba84b1a6b5b73645c02f851ba13a08bd1dee8a080187726ca2f8d7ddd64865d0438b9fab048882602" + } + }, + "scalarBits": 64, + "scalar": "0xd3f3885208677671", + "Q": { + "x": { + "c0": "0xa9dc55ea502172104937a9d9cb05ba991d30cb6487dbad5f1fc1f81ce6d1f5a2adca4f5f6b0e39c6d4152d73b468e63", + "c1": "0xc1cadd81678e8fb586c9df53183f6b4033c5c71c50f62d6fc8a0268f6fd05fc3c609c566cf163433640d14a75aadce5" + }, + "y": { + "c0": "0x4739f857708aed771d6e6b68d205462d560fc7a9bfbf5a06342522828157e3cb9c7fba3b2e07585ec1834cdceabf5c6", + "c1": "0xaa7552e908bd7a89f964a094ffacb094595db6300ecd983f760ca07aab972a36355d6ac7aad76f176da8cd23da7dc6" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x35127fa7eae3e6e4192e22a35ff52d8855344b17daab6ec1a7ecdd04bf7c5c031ae4e6a8b925c93dd8a6f5672b9688", + "c1": "0xdff05d2ee33d82958e2bacd13d4cde59f8a84935d16b2caef56f8fdee903d6d286e35e1e26df324ca9b4b3c1b6be4d4" + }, + "y": { + "c0": "0x806236a559817e54b61864574bfd4209b179f5f8c26d6a734d776040ae4730f5b8a90dd2ca42b1747e2263234b58a82", + "c1": "0x2f89830962cef3c35f880d76a0fb1ef4254566ead584cd065b5c5db6333ab0f7b570d782924cbb6ef69e2fea4f9d297" + } + }, + "scalarBits": 64, + "scalar": "0x86e97eb95614a8e7", + "Q": { + "x": { + "c0": "0xed9a6955144808fd3f6f0084c155e12d788c6a8067c8c38e68450f71f2899fbb3cb4fca28c8308db8570ed0f3530b88", + "c1": "0xc7f34aa2815663fe5f7cc26963b5c8463cc3a420707bdc3541ffe7ae86ef411f2c5122c3f7e8c053effb2b9efae206" + }, + "y": { + "c0": "0x1c6a72b98feaf604577938f32bffa00f9d13f264ba81d2a883b4fe561b9cfdb02f3cabf0bed02e557d46da2e40a431c", + "c1": "0xb6d513b7280c8cf2bc4022788727c511c7ac1e643a06f1423ae4c9d5d81caf5db94beb93791795bbc4f98b465e6d35a" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0x16650e5365cdf509e1890d0774490f230e0dabb971eb0fe93b1debfc1d398e0990fa890b84384ce53156b975175f2109", + "c1": "0xefd93de2f87221d5801abe9d14a1266157c6c9db44e59fbc0714fb36358b534d7583c39f855022fe3d63a065b6b95c" + }, + "y": { + "c0": "0x10672a2bbca890ff8076c340ef1ef60648b9cc984f2659b7f53c78fbeb4b493c4ade82779f9473fe29be9706ee0fed2d", + "c1": "0x101d409f9040b0acf57b30277c824a044bc56dae2bbf331583904be92a7f58c6a6230e83b87b40f6e2c24929a2929fc1" + } + }, + "scalarBits": 64, + "scalar": "0x5d4380544c19a534", + "Q": { + "x": { + "c0": "0xe6136166a3c61182c339d1543de6f3a9ac7b77e5040d1414c979c9764e476ffaee493de4caa36ecba55f314768a0e6e", + "c1": "0xfe1f366668a1662803ad7055dd8e14c9c96fe44717dfc5221c465f13ec2db8293d44f0dff127a6e5bcbb0208828c6ac" + }, + "y": { + "c0": "0xbe35b47541ffbc57589175552db5c4d68e5c9eef178c437282663c73a4174fa6aa9819466778864a97397eb858f37a8", + "c1": "0x7925050069d554fa81f22437c2339e68292796880ccd5dbb40dde69486dc4c1aaba28fbc24eb9b23ca70cf9c640bf4a" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0x11a255ba1fc345ce54ae90f5bea3f2f574a9f1abb775b1455454969b0404ed629b80a5f5b0cb18269b2e20d8b5234c8e", + "c1": "0xcc98f0a261659c05bc3c4e6e259a14d87267dee30a3e4825b32359c8b48d9848ec9d65e4f191f28a51b815a0e29574f" + }, + "y": { + "c0": "0x17f6d77df9a3816edaa2e04cdc77a2780cdba47b5c8b591d324cb0070e1acc3a3d2cf2276b6be781ddef6ad7d0db25fc", + "c1": "0x9aeecfe208387568d59737474edd91b76518d405ac09196e4928787d0acf60eedef130fd509e11543819a4a6a74229c" + } + }, + "scalarBits": 64, + "scalar": "0x13591b3a9aee38b9", + "Q": { + "x": { + "c0": "0x4c305263b849d4848658df10d7562c922634bd049ee426635dd84951bb93ef60c90d26a7af63abee8be4ba0b141a43b", + "c1": "0x5da80c2af04acbb548a4e73f916729360e89d03be847956b6ba61ff1e89a13bbf200d99350b608a8e9e9b9b3a385c0b" + }, + "y": { + "c0": "0x3235055d4aa141d17cbe85e634ea2ef4ab2f7e5d18cff39bb6e27e0d69edb1fe7c70a21829aa70585383e7aa4d3a05a", + "c1": "0x8e641dc2bac1a49b8e936e197b5e0075220f4ab76d073bf89754b3bb26da3d9de8ae3bcda840bea19dde7a9e52dd1bf" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0x85cf2703a0214103ca8c36a092733f2a64e713e097b3cb7ed9636a7d3869e44b79805dfb3b52952b483cd6325faa4eb", + "c1": "0x16ee4157d0df0ea93b40a3bf9affed63d0bd8dc186b61c10525bc96b0365d55feb6ffc5bfed6fee65fcc4b364733768e" + }, + "y": { + "c0": "0xcbc28c2842e6ef12ab98f4abe5d9e0181e7fb0208b38d87ce80d1c67f0b42fc0ef2a2647c4f450fdcfbd2702aecc788", + "c1": "0x8efcf66cf4deffb484ce9859c02900225ae4ea5c17760d2548abd39152a2018b1ca4169e27e2c0519a5b01112c1ad53" + } + }, + "scalarBits": 64, + "scalar": "0x1f44f95b8ec13e4d", + "Q": { + "x": { + "c0": "0x12b2d14cead362314235e73998870db3cf323e130e3049f9cde317e37237739a40b015929bc2531d4e535b8e04867c77", + "c1": "0x4ed5034a97fe9f0ef3e6e4dab2e570c1a04de147000edf21c1d77eb7e277a0e22d8d7ac238bad838da426339674e847" + }, + "y": { + "c0": "0x3859a68b84e5b747cfaaf512d4462a92d477b648324b6527dbb24e9fbb3b9a8036c4038c17ae796b79f79ae0dd0ce9e", + "c1": "0x114e4eb6c12360facb90b609ebeb2482cd69e115c917364cb8901aa927e14256840cb6bafc2fb5a4dde2a600f3c83dc2" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0xbf8a29a0a3ea35a7ee9c2bc56122e09c0f70582ae0f5e85ab610ca5f3ebad11a89087fae3fb6e7a2a014ce90c8e1f2a", + "c1": "0x11653c440144e9ba922b57942066876b75be7a544a780cfc32effb78718422adf01a82bc51c6119c2c0f5e54d8272301" + }, + "y": { + "c0": "0x124cd3afc6418c49f44adc83f8b33b3b9bf748d4f4ed716508b52ab803dc003258f9443463ffa3a92e9fcb53251f9f0d", + "c1": "0x1592ca55d92bd943ef95f914be8096f7b307a08700fc0c1dad43cf8d6527c8032c93af6465ccf89ee622e55683889c6e" + } + }, + "scalarBits": 64, + "scalar": "0x236652656412fbdd", + "Q": { + "x": { + "c0": "0x56c5497bf49a1dcf147f678c8b46398609562ba2e9ee3afe86946a2eba9388e0fa81e9d88af23d4a59b8a88dd3106f7", + "c1": "0xdb0e990bf12bfe9d36f01f8646498fcc95ab88e49a17c81197668874f2a7cf524e8f92059c44a2c1160525a999f8e62" + }, + "y": { + "c0": "0x1cd0a4f270bc830f0e8844235576bc423f857065b2dae96561cbe9801ade6b05f07aa050261b0ac410c14859fe22b67", + "c1": "0x374af8c4e2bbdfe27095e137a0cbd48d93669bce2df91e499ffe7d1b9d204a7a99c5932fefdfb953c28a7153e4a1349" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0xdbb4938c932be99a28cd3bf4b9526916de84f1a99a671d5aca0a9271d9a23a0aaa3861bc452b2192be965c453815441", + "c1": "0x170d047606570161a73e2646f12638f03e7e2da7bcb6f393e6bd921a6f70f2703340e77da8f2197361e48d0178c368ec" + }, + "y": { + "c0": "0x737a5dc18a71d48291c6e0d2391819290db8e65a5c338c1d7d9d9ee19c8b5ac7887d9ba342b0437bd221ca45b00ac1a", + "c1": "0x2749ea9191249223ec44a8c9fb75677347509fc220ee4095d9d354068dc3d83434267b40dd4c214392e52c23f795968" + } + }, + "scalarBits": 64, + "scalar": "0xe20fa23992669417", + "Q": { + "x": { + "c0": "0xc96a38543fe05f9703f51af099f3c27043897189a2cc3164cf41583b131c5c73e617f3005503394aad27586d724a722", + "c1": "0x167494da5605e3e58e4797052d717ef4fbf950774b7a639aa5681ee401c4f64058f4a8ec5b8979a8536216524973527a" + }, + "y": { + "c0": "0x14b7227fcd8ff727c9a96d2bcf16b31f31bb9956972716a66e923dc788b5b76d9c0e9c836835514dae91756ebc37f38e", + "c1": "0x10be323b1035f8483e6d0cae801e2b34292f2940320013106f84bea73e22496a653383967bdbe7dce3aa8f0837ab3af" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x1081888fa7427a20cb9754fa9d98a1a92117e1f89686c3f820f453c67489e8f7bbcce283b1c40ae2e716b86bc909fbe7", + "c1": "0x84db856092c61414dc1e5ee835f6659add998904faf0ae9712e1f80351cbd52d1df67414df319babe5f1e083b40e5c8" + }, + "y": { + "c0": "0x8e09a5ca99614caf47599293f7f3b0a1d10b8766f0485c2b28a02a6f57d2679ab632ef44f58910fb4d0aa4edb5b2e68", + "c1": "0xb4f2696ca0cb196223d22e4975945f5abf98e954033142644e5299f1dd05675760a07b1f419dbd2a75dbcd139bd5e18" + } + }, + "scalarBits": 64, + "scalar": "0xc8f6fc72096d1deb", + "Q": { + "x": { + "c0": "0x1a1c344e2898d3c5157af054581de1ff0d3125bce4d56de8d08e8cf3d9755534edc3276aec4cba63e0d773bb35a3bd2", + "c1": "0xed3fcd0cd8e725fa4cdadb79228e838c015ec91e52a8060c2c6cf232aa87aa344e6736dfe94479e5e597cb8d78a3516" + }, + "y": { + "c0": "0x28ae196b7ed3d31db6a123ada0ced1dba0cf817b5450d05dd6dab4c3a63eb6ef3b12592ff9b5c67c7de5391f1347bc", + "c1": "0xeebffe7d29f603990c02afe83a41393fbc0dceae7056e732aaea4f7662779c8854c9c8d561aac16ef13226e3cf88647" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x7aa2d16eb71c8586e00738e0ddea16a2a697f4c6e89ac56faa51d0fdfb6d89e7d786b7c79ed8a6484d07296aa405ee5", + "c1": "0x193872258c7109572b7415090587f767261d5287a432f6505c04f3b7b4e0e61e9b070c71fafe8957431423da2b341576" + }, + "y": { + "c0": "0x20529e51a8e415d545867ba5c8c45e13182824bc6f9ffaa174caec3a9ad6d3b26797214b4c15a54b6ee7353efddb829", + "c1": "0xc66a7e7717198d6449b4b8a6c9fe388a8ba7534c8ee4666f35faee5b0c30f009437d02302896a76d8187cb5eefcd2b9" + } + }, + "scalarBits": 64, + "scalar": "0xf925ec553579552c", + "Q": { + "x": { + "c0": "0x193d4f2d9c638a80c940371a360e7f51ba4acbd05ba234609cd5ac1c360d033e815fdc9b40e474afcaad7793315c944c", + "c1": "0x9fbf31d7a2d4e2c8af6cb61e48e2de3450890807415bf3aaa72cb6288f572897b2c73e79fa2cbd67b0da20e58e5f6b3" + }, + "y": { + "c0": "0x2bdd86d36dad32d6bfb5fe316e132049ee794b856dfddf596e49f1e9555116efb9ac5de04276e574246f8b933f0c74f", + "c1": "0x787c5522dd36a20095c62c0d7274d9347dd9fab8213374494fb009229f966a12cf40c88fd131c7f60b469eb23951f24" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0x189b3415746c96c64f185ec5880c14a2cbbcd651da36f867ba69c9a5eb6e073a12809d134dc40dbbe40a78a50cc4a2ea", + "c1": "0x1620a2a66fb02b560ae5ff8ca517e71b8e7a6fc814e2846961f638013ff116db8014f5a3710f4d5bcfb84039b1b20ce7" + }, + "y": { + "c0": "0xac5d6ac7fa4f198838baabc6fda963864eaa9006c2f24834084ea7d19a40b81a3f992f36dbcc8349e94056ce97c0c35", + "c1": "0x8fcd77658aa287066a3a56cc6de5167883704b8a50fe3b5380d5c6db756a0245e32755cd8fbe1f26047d07502fc0f29" + } + }, + "scalarBits": 64, + "scalar": "0xdced81a03564e93a", + "Q": { + "x": { + "c0": "0x7cc54ae1bcb0a42809531ea5adc640032fcb57a24361f611502f64b039e386bd07a329c32605c9509634340b0031cfc", + "c1": "0x3a841f9be56192218a112e972cd775a1c1ecf3556f60732044d474523fb2b821c3aa6691cfa0cebb7c337df3411f897" + }, + "y": { + "c0": "0xad077240cf6a6dda58be3f54f0128223ef91793eb1abca0435fc8660315827c0076bb57dd4b1acec53c31764cd3953f", + "c1": "0x2fe18ecda29af8f4f8a2eacb5206bdeb78bb4c02aea460dfa93a8a2100028a7c896f37ed4a574c0a4f183e03df3a499" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0xf3c473396d9b982719ad73066ff0e32ed737459b6124d5a2fbf5f07566a071264771321940c9fc83d3566d54adba86d", + "c1": "0xe9a808d3c0044ff2ff634c47662730d7eacd0a36d5d8d97e5cccc2ccdf41e011daeb81d147571bad962fab3c38b1a05" + }, + "y": { + "c0": "0x19e7fc0defd417c62505fe46380c49e1f91b073fe53da892d167ce020cea438084b712e10fdc06c2337535a9b7a6d091", + "c1": "0x5d043049a6f2c20811537a409fb1f28e093b05b8bc251d6172e2c0da3896af6bdabb80b74c67086dba2003468694b51" + } + }, + "scalarBits": 64, + "scalar": "0x7406967e18819df0", + "Q": { + "x": { + "c0": "0x1298ec9934855fb8dc9019c14aa43c05cf8afde15564ede3627bc2a04997b8e6bf16d4ef865fec45932829835c4eecd8", + "c1": "0xafffff45bc87db45f3b7d557c9f6f0e7e89b97492ca5c69ea503824b0affc3964517fe835eb33c4188ad89a356d9b3f" + }, + "y": { + "c0": "0x18dc5db35c9c02fba9c47fdb1f6d871817674bcbf38649ffa615cc125cedc034c0147788c4c8a602fca472b9466f91e4", + "c1": "0x29fbbfe23b9808f7bc3aedcdd59f9143b366f59e6a9310ba2d865c044c48b65d64b87f13b33366ca1bfbe4b4763a646" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0x83db2ce67d535ebba778ad889a90ad9acf3ce61781adcfd75cfa75bd603217ae70b629963a7cbd6bd75799259420a40", + "c1": "0xe671fb1a47dbd92f8b6b507307d61ff09462b2bacb7b3e1d454aa2bb7ce1d35bc6714d9ed4df988e20b49f940e69e5e" + }, + "y": { + "c0": "0xdd12c6beba0d973db345ea807eacc7e9b3a82e04accfa491840a03afac6c5f2e098bfb8462625487cc4f357ed8edfcb", + "c1": "0xaa2ab8a51001be77888bdeb56bde7a864e4c24bd5a981aae8f742d4e9b7f4856ef953df82260beddf401ee5b46e04e6" + } + }, + "scalarBits": 64, + "scalar": "0xf3e4f5f4b70d3bb7", + "Q": { + "x": { + "c0": "0x14e602faa1bf76f9ae9409f564fb4e9c8a7156d0a328a675ec708d42d9b646345d5dbd119d6eb7b0ea009ed285bd2ae3", + "c1": "0x943b1667145db0d0dd921c59c4a1953c72dad7cf66dcdd8273cba80344c4e109409c7af301055b10b28ae709ebdea48" + }, + "y": { + "c0": "0x171ba57df276753a0570f926909b65e902bd0b8cc6f5d24147aa3da8b7c616733f217f8ad8ad102ddcc6f8e96df418d1", + "c1": "0xce371472e6c899f954f837c54791d36ae6511bba6d3f99692537f43e1e88bc8d3a1285b427494683f65f118e038c887" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x58a75ac3155828bf83546d65ebe627c609e420b888bc4c290168e4c8ec21351c30948e4cfec2ecac09fbaee42b4c68c", + "c1": "0x851b79cc8d9c92ef3a54e535d8bf13607f510d5c32e23ae0b90d1f1cb737a9db8b5840c8a96a88f9719b3d911eb9e30" + }, + "y": { + "c0": "0xca52a3cc6cc60eda79157306f9b5d9418ec344b60d7fb21cd771ef0c9cd875793299ff3b82240f8e91d10a971e43a13", + "c1": "0x129fa7518bfab0c30b521a79e5051925b497eb328fd8ac6bff4e069a9bd0fa8ef607ebdcc4d9e7b58cd2cc44266fd05f" + } + }, + "scalarBits": 64, + "scalar": "0xc0993d062f18292a", + "Q": { + "x": { + "c0": "0x3080ff88255a5a7576263567dadc7c66f414a6f2b4706834d0b81eb9deb6c43117384278c0eacf397b574d57615b52c", + "c1": "0x19156ebf3ad935d6a0fb633d337177333309a5c3413578995ab31a6853a3a4ec6653e82b7fa49ab0b0e77573df01ddc3" + }, + "y": { + "c0": "0x1096fb6fe3a82a50d8763b99ba4a080d5c68bacb62ec5cacbdfaf160c12fc1a234154471e52b0ad441ded17e1350a8d4", + "c1": "0x857b613d87ef98088f915592764e7e0277353656e15bd831b5d6ed3b16f1343ecaf465f23bb96bba18d4f27df40743d" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0xd11b9271b7fedbaa26892c61665051d6567860a8b21461b44fc32978002195eb552d5c6f4b839d66dffd9ad13c19988", + "c1": "0xa925222fc88f6513fab66753a2e9f1609158d90e9d1e1b32b6a9b55d04a383c356f900c064bf573c3dc8e9c9cb63f5" + }, + "y": { + "c0": "0xbdd48bd018281448bf990b6ed0aa7d5348317a09b2f081b60f991aadf4652a8aef08cc2e38cd257d36ab3ed30371e59", + "c1": "0x19cc16b8c46258c33b26a451fa438dd47513534a54d1f7ca86b8ca573ef5690cc13ad019b7697378ed001ccbba8f9cc6" + } + }, + "scalarBits": 64, + "scalar": "0x5b58080b44ec5454", + "Q": { + "x": { + "c0": "0x7aee0c348ede41cb4770cd1ab734493cd3f3777acd36d8f7c130f46623b13a2f6ddb30eeb6d966b64c52f555027ed", + "c1": "0xbbe08b01246395ed734ab67b15f8e5c7ca0c79978bcb50dbdc5989e9185f7815e29505a1be96cdd471b573088dae622" + }, + "y": { + "c0": "0xe23b000346b573f17cd2c9712ab7d38f45c3fcad1d0bd5525da5027ac532db56088849a2ab6de2c6ca07f09b3450c6b", + "c1": "0x10866c82826aae93588a53509917b5d360f903494c1735f6bd3c9445efc04adff992656d6499e6795668041b3450e8c2" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0xfa0fc11219b58131b3cd4902fad1138d44754233ccbae5f82262691d75742c53cd3b11003bf2215477d0d693875e7a8", + "c1": "0x159937c2b46e2edd3d5a9e520949aef0e7f20327772fae8c48d8a1623917a94725a99cc08855f776b2f4c1c0561c3934" + }, + "y": { + "c0": "0x367fda2c07b691c2ae11f6313aab28d01db9cbe6397dd2f23366d97b5622a9d47cd12a720457d82ef4d8da86d6673c6", + "c1": "0x8c0f85f172639922214856befae345c539149b212e85f7144eee96b4a5e0070d6c8cc55e058c3af31f37972df1b5bf2" + } + }, + "scalarBits": 64, + "scalar": "0x314079f4cb9f7f79", + "Q": { + "x": { + "c0": "0x754241cfcdcf9e4febaefc73b70fa751fc42e1c037583c9e15da9ace663b8515e5d11bef36cda9133db95d52f5daa33", + "c1": "0xe0733ff4c7641ef9fa702e916b76f7e8aadc0670efc2a4d468da51adf18d9cdb93547472fd02640a3bafcbf5aa6e9bf" + }, + "y": { + "c0": "0x19a68b67b102af90810110ef56bf2ef8a0e1d5da168bab252b0bd09f6496d89684214b48db7b8dd50de7349f7d123a92", + "c1": "0x871f770790182bb055802c7367ca9ea402b62c40114273283d6261fbcb95f4bd999c340dafa1652dfefdb260fbbc521" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x11880ac84fa8df74fd6b5404b5b46bd1cae9b906fbda2e55d3465cf2da8d8848aa6a6f43315aeee07bd4067c7d9ce415", + "c1": "0x18bade71270029521bb785b4dddc8e22f62fd6bc41c2115ea6697697d23bbd5d86eed6a32fae7eb1d9673c28d72aaea7" + }, + "y": { + "c0": "0x1440d81bd312118102d4fe3f59aea600e4f8f71fffd2b92f57dc489a1eb259eeea6feee2e4d4b18ead4af63f6078db7", + "c1": "0xc71050ee5d17f96055a650b1aec886f5ba16f73a10a1abfdab53c3aa4f60a35f8dfa00eb758b89601710287b93e11f5" + } + }, + "scalarBits": 64, + "scalar": "0x894465c5970f9246", + "Q": { + "x": { + "c0": "0x3bf52af98ca9bbeb66f4a0e5d9b43f6944d71f651157600b5fd494c9286a8c61ad2de4d1b0b188b657187158042b1b9", + "c1": "0x68868f83a08724d466fce5b8da8c2228bf2561535abdb14cd6171614eb027aba616ac70383098dc7736d8ec32b43899" + }, + "y": { + "c0": "0x10295b84fcdf04ad049d2564fd2b5e33b7dd42aa2b09f5247da0243abc770c7ac8dd53c13a80c41e091bd96ad36a069d", + "c1": "0xf681b79f64b8b7b27dac4ff0eec7bd6ba20bb11036393209a2095de01a781fa37cd621bb969c97ac5b1fad5a4429c4e" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x635ee36be353fc00bf8c211c1efaa6d09877db92d724a557a5d5b2b42c53603b450a3ced6d4a9d21930de036ceaf31a", + "c1": "0xcfd6b654a1a9257c7712d9fcf280c4ca5a939a977b239b260b1ffbdada4d0f79dddf50f5ecf552d5c6c1b928d886000" + }, + "y": { + "c0": "0x47b5845c81bde56ca43b62952b1507d76963d89f3da40a345818322d5f8bb7a77579be22a62975b78117df1461cf52e", + "c1": "0x8ffef100ab04e0af251679c42afb2c41b3c23ff7996f5d0bf26ebba8af4c29af49fdcd9d585064f28fc02f727adf35" + } + }, + "scalarBits": 64, + "scalar": "0xeebc44ecbd8273d8", + "Q": { + "x": { + "c0": "0x123ef9533829346e76052fa4fcbfbb457dd105dcccba5ad4a8d7082083144a0f29c93618e60ac9ebb067ba4ad27cd285", + "c1": "0x15ae366dbfd5b2332da62f7319e53b6f50ac20bef4ea2766776ac8f68c3cd423e045a83813f99ea9e13571773ecd8b44" + }, + "y": { + "c0": "0x18526425c8d68654f0d031e7729ca1aaec31afe615ac438ea7ef8ec091da11a66211dde3efb6596dce023d20c837a75f", + "c1": "0xe41072be0052e26c94e18ffce45bff17df918858a0486fc63e5c088dc136718665394d52356a989665ca5343ccff02b" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x76ea7ad25cca8babfc221a8022d4f1cb23855a3f068ad771bba92fa07ac688587fa7a1cef7963f0c261ec666bac331c", + "c1": "0x19b17e922bab6dfdcd76dfd4eb3ded1f34ca8d85d0864985949b2c466940fce1ab574ed7c388f539b8fe44ebc33c37a7" + }, + "y": { + "c0": "0x19a9ff46e6056eb98b8e4fb0daa219ea99b69f2026a5d40052bf7d8baa98be03548a9e26a50681505263a341910b55e3", + "c1": "0x85a9101e73f2d2196094e6ffa68d0e1dbdb18965b14bd200c58ada8eeaa719bfb07df922ede0397e7b7993790822695" + } + }, + "scalarBits": 64, + "scalar": "0xfa23aee7312c44e5", + "Q": { + "x": { + "c0": "0x12d495eef3084c1dd12f04b21436396ed47f77020f097d77d8585de5cdf5bdf7a645c6e9c165f63c6afc3964506d9ec4", + "c1": "0xf6baf588a5fc83bfac5b76053bab28f4340b32da8f6cbb0e486816458cb625026524e7f8b070619fe6849a0b1c68a1f" + }, + "y": { + "c0": "0xea30709be84040f833ca5d4e01605dc222a7e7083ac51f67ec52bdae01056affda00f6f441f9af9576508eeace030db", + "c1": "0x18eb1b32d9eaaf534c214400b07e465b4ef3f9a402c017a15686a48b15dd90c12cab2f702d140ebfd97661e68b15254e" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x17e5693046fc891dfdf3583469c9f0216911dc31e9c843a7f1562604d8b72e531ac6baec6bec46c7076e803598d1db95", + "c1": "0x8aecf4565e5c1741488b446e3b84f52311c07ef07db731fdcd1a1ee8072d3456ff5b0ae14b90fa5b557aa4d0fa42e17" + }, + "y": { + "c0": "0x13f760d7b3c731594b1678ca62c4ff8140c89b489792393325f20b2e20c75474407550d6a8ca3a57517a26b53ef9f90a", + "c1": "0x1796506d773fb510e24f84ddb4d4bdee85e15088de5a0da547abb7f79a50d8654adebd77db2693008f6c8784731a291e" + } + }, + "scalarBits": 64, + "scalar": "0xb5f79c9426cd596b", + "Q": { + "x": { + "c0": "0x3be90faafbcc5889429447c691d13c79208d59864b3bdb87a6f0085c8635da4917d3b57ca9883cbdb79a24ef44f84ab", + "c1": "0x8033f1e66fb67d4b15361676a3061597c7d13aedf7bd92d3167c2ded4b0e28775c25861d81e4edac34aa9ddc7cdf7f" + }, + "y": { + "c0": "0x40f9436f5b71f89a74640897366c0936b29bdd85e2f2a91f1d79199ffce83312ea398165d279b77b778dbfc296f023b", + "c1": "0xbe77cc1276025ab791c8561331969d8de1812ad26d540f2cd3832743dc5a6f7f09da216c8e8a4c3d129d335ab123515" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G1.json b/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G1_254bit.json similarity index 95% rename from tests/math/vectors/tv_BN254_Nogami_scalar_mul_G1.json rename to tests/math/vectors/tv_BN254_Nogami_scalar_mul_G1_254bit.json index 17233dd..7e78e3f 100644 --- a/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G1.json +++ b/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G1_254bit.json @@ -14,6 +14,7 @@ "x": "0xe08a292f940cfb361cc82bc24ca564f51453708c9745a9cf8707b11c84bc448", "y": "0x1fc4e075b4ed6426cbec03997d19d24916de06d962498d6de12cf60e8636e047" }, + "scalarBits": 254, "scalar": "0x20025a0c74b9e838a55061e47b889f590ab06860ea8ec5bc21fe0ca80f7f29a9", "Q": { "x": "0x980b5af72bfa4a0eef02c170031cf8fc315a9cba4c9c54339b7a210e4707d1e", @@ -26,6 +27,7 @@ "x": "0x39bc19c41835082f86ca046b71875b051575072e4d6a4aeedac31eee34b07df", "y": "0x2cc399530f3a93af016d1d26e5044a083d9dc9da040252589685761ba843d30" }, + "scalarBits": 254, "scalar": "0x157a3e1ff9dabccced9746e19855a9438098be6d734f07d1c069aa1bd05b8d87", "Q": { "x": "0x1861e042361fdfef752daf293796c240f65ab237c007791e215aa1e9a5079f4c", @@ -38,6 +40,7 @@ "x": "0xdf2ff288f44313dc9ddb54de269c6424aaf7164dc5e67917066ea5dfa0d0f1e", "y": "0x5410ad2d4b58704f7e5cf88690cfbc779d3053803aea566a0f9e3a2ecf2bd52" }, + "scalarBits": 254, "scalar": "0x273bf6c679d8e880034590d16c007bbabc6c65ed870a263b5d1ce7375c18fd7", "Q": { "x": "0x47c572da2d5689e2fa67e9407cff8009aead7b29244d721eb93a78efa2941", @@ -50,6 +53,7 @@ "x": "0x1cefe2112033a045a3faee0337fb38c77f24290262dd9ba8d79eb280e2f9d32a", "y": "0x665b74188d4c06e1050cbb7aa438f6aa46cd482a445b3a91a1b1c8f08b4d662" }, + "scalarBits": 254, "scalar": "0x235e630485f974edbbd138e9079eb54d06d03a50228dbdfdbaa567b1fae19f82", "Q": { "x": "0x529bc0e057a0ef87990e6106846ffa208d23eefdece1f57b5844d63b8f1958d", @@ -62,6 +66,7 @@ "x": "0x148523f92df8d037353fd0bdc6d0febc88c9e1bc568d72c80c58438f6295dc59", "y": "0xcb0c12d9ce7a415bc1c55879a54ca7c620f80f0e6d37e3eb0180629202a39f2" }, + "scalarBits": 254, "scalar": "0x3845ad0148f76bdf14f752268eafb065c7272721784a8c6bd3a5fa736332b94", "Q": { "x": "0x50a411c760331eec7b1df6a314773af471ae8605de42a576ce56a376aa4b454", @@ -74,6 +79,7 @@ "x": "0x1323cb93cf5f33ebf21d2c0ba56e1c39fd0e75b1623d3ab160fed44a37ee1bda", "y": "0x12560d91f79f79c618ed649c877c817541fe1d2fe0ef4bfd4fcbd35c93617f5b" }, + "scalarBits": 254, "scalar": "0x252f232224ad7d89266c28d1289098f03226fa84e7905b0df4e1f6cc4e2e897", "Q": { "x": "0x157f2decb5edaebb2adff666fe4d7e5d4286b5126f4ea301ba3cb7e332ca7ced", @@ -86,6 +92,7 @@ "x": "0x3a7e0e36a933e9ad5732235e93cec84ae8db3104348bf24312ffcdf8e0e78a9", "y": "0x145e2d9789d0b912bc27bacfa11940af58861be1583031a1d0fd2fdaacd65c04" }, + "scalarBits": 254, "scalar": "0x175ed37fdee061c78e28d668a26add87007ab0d11ad699cba0cb13ae35b8215b", "Q": { "x": "0xed7ee0ade320865d11c844ad125d5c776d3d6f4424d4e95ab40258062e7b0c5", @@ -98,6 +105,7 @@ "x": "0x2337a09e7b42b83857758f3f4d0c2d0e21368a72b93f72ed172c413782db489f", "y": "0x12ee0bfb064fd1cf6b76735331156f34615b10a9b494fc96159741f3015a529b" }, + "scalarBits": 254, "scalar": "0x26e5ca7f4b418fc9eb7d7b7f44ed1c4357fa71695ad59299d4404c55a295d64", "Q": { "x": "0xd5d46a9af0cfb9d215acbdcc5289ad6fa644c11369ee711929bffa6e85a93f5", @@ -110,6 +118,7 @@ "x": "0x22bb085f0544ade1e1c95682ece911f4a6b728bd3fb902038215d1bf3ba5ef41", "y": "0x230b467476696388ebb8b46bcdd5c601b93be130723b86a20829377b9ae429b" }, + "scalarBits": 254, "scalar": "0x22e009ba34436d2a99d5cc23a9153abdb101a9bc67ab0b74e786b22b72db20a1", "Q": { "x": "0x11c015d60bc5c2dcf594ccba5ce4ab158d80a505049722c4f7804272b7f33892", @@ -122,6 +131,7 @@ "x": "0x130d23642d424ec4205cc62599b1cff4c7ceaaacc6f1df842689ac863edf4d6b", "y": "0xedcd0ab5cfe8d1cfda7cec82a5114cc223694fc9cc5aa1c3abfe34a5959dffe" }, + "scalarBits": 254, "scalar": "0xfb9835a1f2a882cc4c7915f0eea2218b0089d6a71bb41c911faf48cab4f7ac7", "Q": { "x": "0x1250bf13953224540a449cfca94bd7e7b0076a83b40d1ca6f5eed4d81966b29a", @@ -134,6 +144,7 @@ "x": "0x1cfac3eb7f51ef5c90fe33469dd55b0641eaf4597cfde95f01fe8d0c16613599", "y": "0x2323cc43bbf2627267eadd725583a94ca417316d387884f2564c303cf2cb0b0d" }, + "scalarBits": 254, "scalar": "0x24c5b2ce21615dca82231f5fb0fc8d05aa07c6df4bb5aa7c2381ac7b61a6290c", "Q": { "x": "0x1799fd6a38b1cc72e9312d0feb1ae0973b7766f40281d37b748c1981c72cedba", @@ -146,6 +157,7 @@ "x": "0x9a6b9c1392961c26657edebd560350298f9138b82fe22216cc054a39e40d4e3", "y": "0x1554d2f00a7fafeb303ee594808b37b112a2405981635b170dc9795c83ef6ab3" }, + "scalarBits": 254, "scalar": "0x23b31c35ea0317455f6d5ae6853938a8fd832b055fb8d4d0544dc4733be5873", "Q": { "x": "0xebcfb651e36efe3b4b1a1f0fed477bd6d64469e2e690452170f2b24125d5e8d", @@ -158,6 +170,7 @@ "x": "0x3550d13fb01317874bc884137be3ec9d5cc946b3bc90b1a182dd6c8b24d1637", "y": "0x246151cd26f482f1fce483401ca9a4f863549fd050870aee5f819ee71e3883a1" }, + "scalarBits": 254, "scalar": "0xb919c4af9c958d92de37902e1912f818468d2e0228f4bc48f0849e2e721cdae", "Q": { "x": "0x22abdacaa74197676743796c51b42c45024cd436f097db98042c83fa7d3ce77", @@ -170,6 +183,7 @@ "x": "0xee64b54258e687fc9887ca2362b71c50539c881d43097a0578b58c487fd26ca", "y": "0x14defc216031ea53f4ef09ffe0a57806f3237876edba1e1d10b49f75623e9380" }, + "scalarBits": 254, "scalar": "0x6223903d4bc2adea7b0a0db92822b6c2638691e4388df93f567e11edd6f23", "Q": { "x": "0x186fd5406d0594207fe742611b16b75c0a277a7986f40fb8e43efaef7b21ab1b", @@ -182,6 +196,7 @@ "x": "0x9ad64741e189a485c040d9acc6fcd32f7a1026e23e9e23f7389692541da26ea", "y": "0x1b87170490180cdd3c584e67f3b91181cc7e94a4ff2804494542ba686b9d5d11" }, + "scalarBits": 254, "scalar": "0xe461b123fb71a0d2b60b702adaba952f027845fcf3bbfdff13681c9e1daf307", "Q": { "x": "0xa1c8489ae70619a797337cc5435c347ad5054822fddae9512a45d45fcf0345", @@ -194,6 +209,7 @@ "x": "0x2db92ffd62bf2675414c5455c50dcf09e50d5e980d29ae653cdff2e9a67de43", "y": "0x17a84b5fee3757dd7d87ef0711b7470ff89d5763017204a3ac6f9012ccad9196" }, + "scalarBits": 254, "scalar": "0x189d5317bd61f0885c9bf39e9c6baeeec2ac555d3c6d1802259a4f4c15e0bd3d", "Q": { "x": "0x1ec0fce1e6fc3bc3924e587ee6b029180a7415083c10ff70d9232ace5f6db5bd", @@ -206,6 +222,7 @@ "x": "0x208cf1bde782e64bf5c86cd2c3cc34155f3b893d05fb315da08ec1b5f2eb7cf4", "y": "0x73587ce4734e7ba82979a2a9b590d8505ff757d96f2d4f17e7b16adadb9725a" }, + "scalarBits": 254, "scalar": "0x7188b949fc8499db75ae19842f14dc8274af3e92e28716b76d2adc2f4b9b9e7", "Q": { "x": "0x1c234ce42789a3ccf7f8694f3fb43cfcff62f366ef15bd2bff09ef162b20026c", @@ -218,6 +235,7 @@ "x": "0x2293c236a77512dd549f63a6a740725b161f5a2733186aef072d85c12e06f87a", "y": "0x1e0fae9741cdacbc668c1eb5e711e5f0ea6e6f8b8a21647a89756836d35f2eda" }, + "scalarBits": 254, "scalar": "0xa48591f45da5ad607639073a076ee8aeb56262bfd4f6dc6e138425eaee9c9ae", "Q": { "x": "0x9836cd9cea4a86a9bff59335e7e5d092097415e333f89aa653a95f24ca4bb52", @@ -230,6 +248,7 @@ "x": "0x5579b423d0be46585a3d75afc6649bd5eef2db0d92ab3b1f8eb4a3930d98f81", "y": "0x1d993705b27b2922f728f4f4784119f59bab6e911e20bce277e34a8aab6df2b0" }, + "scalarBits": 254, "scalar": "0x1d0ceb33722142069dd8d0f55ec1a33f93383842931692b0b8e0edd32ed3afe5", "Q": { "x": "0x51af8959280f14556a000dac49442b4c5ebfdf5ee5721712a32c899506006ac", @@ -242,6 +261,7 @@ "x": "0x1100331edc8dd561f57694f9f4a32f114e56bf756c8a2ba87df8329a10aa4b12", "y": "0x75b5028da4ca27ea0789b8aa6f03eb19b29c3b01ec905b131e4e968c1f6b0" }, + "scalarBits": 254, "scalar": "0x155331f785268585b47107252e4d978951d7200f3184d49635554f6bcf20978d", "Q": { "x": "0x11ad98c0e31d6a1b14b6a7cc17205f492f12d192cd200766d0330c51766642b1", @@ -254,6 +274,7 @@ "x": "0x24ee9f8ac0eb5826be308c8aa8d90fd635f8843f4465e067c3614e7703af9cce", "y": "0x118e385090097210adf7f7282547274e397ede50d52470e214421306655cf03c" }, + "scalarBits": 254, "scalar": "0xc6dd53ccb90cb68b280558d24a58efe56cace6363a11ad876819e86996bd9d3", "Q": { "x": "0x313b2b34532273c94635043b65c173950d153d46dbfc98b55d439fa3d534b93", @@ -266,6 +287,7 @@ "x": "0x1ef8341f82f694e040910e68a54baac4a378d52cfee4aa7335550e8d68ad1c6e", "y": "0x1bfe689f5113512d71cbf1190563986ddb2e5e30e3d877c7fa4b69dfd999f8f" }, + "scalarBits": 254, "scalar": "0x250311f0f95137a190994efc75d99f648a43448f5c7238043a71eef42e4bfdcf", "Q": { "x": "0x1f666d6a1e59f3d667fde3519eaf72acf3d4f6f0ade539b4268576b5ace954da", @@ -278,6 +300,7 @@ "x": "0xabbe56709797a29e6aa061e256705e8d1cc9656a652590fa0a42550d009adb3", "y": "0x761cf166d038a36dabf099c274994b8e90c77f26eb7e461926a4bfd5f618c89" }, + "scalarBits": 254, "scalar": "0x146aaf961442cd8e3c214282d56a2b893785cf1a4d174c63c3129362844cc400", "Q": { "x": "0x180657540e940f032486e569d7614f014469e06161de43b3e92f3bde893b3aa2", @@ -290,6 +313,7 @@ "x": "0x170c7328a9b02a49c7fa0ef3a8459baa4ff5dac0a6ed9e6bdeb58d6815c3ac23", "y": "0x1e8d94d874895815b90b70723e8f2767a52410636edb4558d26eda6b144b132d" }, + "scalarBits": 254, "scalar": "0xc367c0d6b1503eef66d7e53525577620ac8049000ba2771d604034ce96bc261", "Q": { "x": "0xc7ca08cbce5f3705ecc62b0f55371315e74c3b433c5d0dd8d1c519437cc35af", @@ -302,6 +326,7 @@ "x": "0x20a1d8f998224d7e4a414c5870264c91e94d73ffeefd88aeb7a357a91cc693bb", "y": "0x836d7be6c73edb17df019749e478abfb1e8d350c7cd020df444afa418e4e9d5" }, + "scalarBits": 254, "scalar": "0x15cc528dc3ee524b4be51b806f6ac5c22c2a99e433ab2e80c3e3947e4d79bc71", "Q": { "x": "0x23f43a650e6a19488b93e3ad9be06a878e8074aa78771febdd7dde9da166f91c", @@ -314,6 +339,7 @@ "x": "0x2131557de2580fe5626cca0178dea0c95d37c8c75c2f544dc9cd16a12d6c2bb4", "y": "0x20ad64b5a6610eabd135a9d14e5cd3ae55ea6152be44fe62bba783766ff55ed6" }, + "scalarBits": 254, "scalar": "0x179971bd22e6b2fa24084c299585c90e4a361342dc8d66f509834e0fecebc207", "Q": { "x": "0xda060f5696f36fb8fbcf9c3131ac63c2de7ca3ff1ecbce286ab5ea0fc32e49a", @@ -326,6 +352,7 @@ "x": "0xd207e98eb1a813026ed20c3aaac9a1547196f5c9075e9c9e66bd668d4a24546", "y": "0x147ed553af29e3286088545a54d787a9e5886a28dddcbe66bdb74a3b1c66d2a2" }, + "scalarBits": 254, "scalar": "0x167a229b0b49c002b74f08059a6a88b004c9a9a71d596073e5d8f1eea9e7b4fa", "Q": { "x": "0x10570ed9aa459db8ab772e66cc7474ddb9527b6dc6f95c550c9e529f80ab15d6", @@ -338,6 +365,7 @@ "x": "0x1cbe6cdc2bbb24d7428543ec9e65b94cdeeb4e73178805d68bf8a3af2864f3ba", "y": "0x7df04714a5c2ee6913a775aec1047eb206c5819f6cebf28cfe77a106293666f" }, + "scalarBits": 254, "scalar": "0xae8725cb99c880f0572a66c39f5ee0e67d82c46813f79c2cd7e2c3460041e86", "Q": { "x": "0x1a86f7f46b91e9b556746acebaf03ef67dc5b3e15473900e247f334bc5a93504", @@ -350,6 +378,7 @@ "x": "0x172d4ceb240122f31cb14dd1992829797f938efb160e01110567e752e0551e99", "y": "0x4f5154b61c12f7d24a18148e561f2539f98dae005c3578ab442ce7da578d699" }, + "scalarBits": 254, "scalar": "0x128de05b3854c5f16edaef18308e29ee1e83cbf1e03091c1f0d1a32a30b6f84e", "Q": { "x": "0x1bad0cf8579836d46c3474f31ba0c83a3ea2c5021e3094c7f6d90c971e10c07c", @@ -362,6 +391,7 @@ "x": "0x3ad8441340f6e12c4f42c30061879c49e7b8aac4624ac8f9ec5a8e597f49016", "y": "0x280148a07db0c83a065cd64430dff61ac7f484e6377b7735d0b87cb09c89a93" }, + "scalarBits": 254, "scalar": "0x6f0baa3fd694aa85e6e793ff61e58fe244e8637d15a774f25c58989c9e504c2", "Q": { "x": "0x44942e90fd2639a574409b68122a83a4f5f5dd68ba6824891dc14d5b1cb3ce5", @@ -374,6 +404,7 @@ "x": "0xce8f50d4a65a578cc4af0350a1a42a350cd4103112c9eaf976c57da8bcf166e", "y": "0x133add030c26a1289f893454d594db1bda2ffbcdcd9f8cc8fe95262c7079c7c8" }, + "scalarBits": 254, "scalar": "0x1fce54cfb9499b37cbeb1bea63009250f9859f8b4218e67973428989411fd3ff", "Q": { "x": "0x8a582000a897e33b1b92b66b2b373e1f269c13a381cab69313e0b6eaf0eadc9", @@ -386,6 +417,7 @@ "x": "0x22c32a1c3135bc582c878f2cee899fc981d64bf7208a4d2fc776479d1a985b81", "y": "0xe997cbff880b933bc9751172840be16f65b946cc3a57862eb4b17b5038ce8aa" }, + "scalarBits": 254, "scalar": "0x1d0a1ffcbfbe38a03ebb6ce043ceb2371a999f5b1a4798c0848e5dfadcbfdcf9", "Q": { "x": "0x213794bd2e7bc53a1c3af31d3d5784042b753e33c9c9ca5da528dea9b357d6e5", @@ -398,6 +430,7 @@ "x": "0x1f0e7dbf1354525fc9e8032e6c3fd14d4dcf54d2987ee42bf38c6e53cdac95d7", "y": "0x237f0099682a713b84be748f8923dacbd4f5139fc5b432f81907260b0f872c8" }, + "scalarBits": 254, "scalar": "0x83faddd35eb735c320fa0666d1c04ee6ecdda94e889c7caa328e21ac9fc1ff2", "Q": { "x": "0xc1c86e4403d47c550f47cf9bd6815e0f36714322a4330dbf52dc0114bbd1925", @@ -410,6 +443,7 @@ "x": "0x93dc0583442fcf798c027868ea60005a83e1ab73753dd6924df875e34fc64b7", "y": "0x1e1731cc4ccb1358411eaa41cf6b3dd04b4914ea9a1a0d9d479140e3c7ea1ec4" }, + "scalarBits": 254, "scalar": "0x22b8a1a5298a87d253c675d963a508bb5f5049f81e94e26f9f399ebd14eaef4a", "Q": { "x": "0x641603f7f83bd79db2dbb46840f3f515fbf00bf161678ec75afefc11b8d47ee", @@ -422,6 +456,7 @@ "x": "0xb7f5846254b0cfb2b34eefa14aa1de6f6e3c4129c0f753fb74425b8bf833667", "y": "0x1b8b0d5db08b66628ec4574adb6b483d7f35c198cd3e2a5a88c3c75c406b5e7a" }, + "scalarBits": 254, "scalar": "0xaa5095c452166f5c275aa66bb2edaf61071b2a879410f65c2b41225eae64ab1", "Q": { "x": "0x247a47363ed1535c21c79f8845625408e9b081d5e3ca655fe25d6f789536a3db", @@ -434,6 +469,7 @@ "x": "0xa2ecae63e7fdb1bf979ee636bde96267a4b0ca230c8815e2f25b9b412360e6", "y": "0x248e491606f28871d9cda1c31fc8e7d128effe633d2fee8b4990cf348e230b66" }, + "scalarBits": 254, "scalar": "0x1bea607f4655ae5b3f12536374727ad3d0aef1d5c450e4fb5ff63aa48b0860c7", "Q": { "x": "0xfcf3d60c0a0a635337c526721a83e5ffa30a1691007377190092955cb527ee5", @@ -446,6 +482,7 @@ "x": "0x1970a08752cc24a3944621abbd99d9f2f17d4008d023f99f8eec38e9554cef6b", "y": "0x1c5c9bde631ea299ad7139e07700e6d4601504c1d36e8f18ab254cd8a0add48b" }, + "scalarBits": 254, "scalar": "0xf2eb52d30ca998feaa9e78908912ed834c63acf74b68f25e3cf1b825b01b680", "Q": { "x": "0x4272b21cfed45e2e42560c5c91fe9bb7869d2fff5e7c5b2c4a011c0f186f873", @@ -458,6 +495,7 @@ "x": "0x161a4b71c96a539d25869b0434e903e460989f1123193bd9dabdf4c8f974c66a", "y": "0x12ff24fa6837aa2f0c826850d6df036679f2fd69b019b12959ebc8b0d24a44b3" }, + "scalarBits": 254, "scalar": "0x21596c79c337a32d3d93d9c66571e4bc34b0bbfe66adc0ec660083938175b462", "Q": { "x": "0xa10d31f1b2bf886ba29fab5e9dec37b1a4989b3ea845b1c31e3ad9c910067aa", @@ -470,6 +508,7 @@ "x": "0x17a4a67b01e805a50e4574af6fbc5f13245d5d4d4798c6aa93eee63483417f7b", "y": "0x1609d5959af4d6b3f9981439b291e7503894c0e2178df3ecce64620f174444c7" }, + "scalarBits": 254, "scalar": "0xb360d160e7c76ddd79f1aa27b600a6c9500f638794750401adae2dbecd5c56f", "Q": { "x": "0x1f8c1d3b5f87f8f5bb3c36bee459ae5cfbdbe81da7877fb28d1ba246413c9fa", @@ -482,6 +521,7 @@ "x": "0x2453cffd325ab2786caded069d5edc178be3bd2b2077de76667c844923289e4", "y": "0xe96284ec2c99fd3e35e6280a323e09a7bee1e281f9dbe8b6a59cd429bf41949" }, + "scalarBits": 254, "scalar": "0xaeded63570dd4581627833007d2a82a04c79cfdf1ce57a3e55f0abb14a22213", "Q": { "x": "0x8d3879c4866422fac89bf5b464bb2f26c1a9b2a1109df82897b9b3b078de73e", diff --git a/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G2.json b/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G2_254bit.json similarity index 97% rename from tests/math/vectors/tv_BN254_Nogami_scalar_mul_G2.json rename to tests/math/vectors/tv_BN254_Nogami_scalar_mul_G2_254bit.json index 53b27c4..972121e 100644 --- a/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G2.json +++ b/tests/math/vectors/tv_BN254_Nogami_scalar_mul_G2_254bit.json @@ -28,6 +28,7 @@ "c1": "0x1e4dc9a7b51716476f77d38c92163f96d4beadcc3ec08f418bdec542a7920c1c" } }, + "scalarBits": 254, "scalar": "0x765631a20b205cdde19f2fa1eaaa7b1e209c980095c08fa16639321c14c24c9", "Q": { "x": { @@ -52,6 +53,7 @@ "c1": "0xf55613e9eaa083b0c29322b47fb8f2e3b9ef8f4ab40eadc42d13bcb2f0aeb56" } }, + "scalarBits": 254, "scalar": "0x190c949c89845c2fe52669ca16a98ca422482e90993362b0fdc0f1bf13fcee2e", "Q": { "x": { @@ -76,6 +78,7 @@ "c1": "0x3fa79a9ebd1a8d316f18ffbe9ff428673a043eb273dde9926219c407cf1c2aa" } }, + "scalarBits": 254, "scalar": "0x17fe7638497a4a0b469c800682a838c10d954fa10e5c7c7360c7a2ae6bf1b8f6", "Q": { "x": { @@ -100,6 +103,7 @@ "c1": "0xcd863c4701861085dcec4988bb352ccac329d7044f064bfdaf7303a77747be9" } }, + "scalarBits": 254, "scalar": "0x220dbdd16cdb25118af2bff71ae43cea83cfda80dc82022ad7b50a0a069802bd", "Q": { "x": { @@ -124,6 +128,7 @@ "c1": "0x5dfc99b2401098e4dae7fa86c6bb74dbcdab02b216eba72bda127c84989e5cf" } }, + "scalarBits": 254, "scalar": "0x5e64299e1348fba51b06d8300ee49915fe9ff1af187cb148a7c4f8d38669532", "Q": { "x": { @@ -148,6 +153,7 @@ "c1": "0x556fdddacda76c0f369f1ebcdf58a20f5db68ccb4dbd3816aa13e79f5edfc6e" } }, + "scalarBits": 254, "scalar": "0x202ce76365f3b0d1cc6cfa43da722753efee090dd829b264ff55393854aece58", "Q": { "x": { @@ -172,6 +178,7 @@ "c1": "0x129508a9d85d56ddf9358c78867e38d848e3d9df62526b82ffb310322d0ad516" } }, + "scalarBits": 254, "scalar": "0xa5ca19f08c4e45a58ebad4472dbecd3878894f4b536aa1c55ba3121ca7f5477", "Q": { "x": { @@ -196,6 +203,7 @@ "c1": "0x3625673ed7c54ad332c3bcb8f3bef21a74c8bf225a920854305db4786df9bb7" } }, + "scalarBits": 254, "scalar": "0x1d8f33083d9b77f0d9e1fe64b74e342bc4b72a604c115bd7d828d66785bff53c", "Q": { "x": { @@ -220,6 +228,7 @@ "c1": "0x43b32cddda5a71aa4a3e936bcb382ff27f10c3661d83a59faefeef82bbcb489" } }, + "scalarBits": 254, "scalar": "0x16eb192d088c0dae9a6a70f50ff9b0b01367c1fdee76f37cebe11d120ec1e361", "Q": { "x": { @@ -244,6 +253,7 @@ "c1": "0x245015f6753f18c3dcf0ef8adb1e62e8ec16ff1877c42a928028cd084a409395" } }, + "scalarBits": 254, "scalar": "0x2466d8b753c5607fc0ed25f3abc2b8e49ba634729d17f9ba15354be968485128", "Q": { "x": { @@ -268,6 +278,7 @@ "c1": "0x22d7a6595d9e02250800adb1bdafdecd45b42802fdf54086dcecf843da2eeaf" } }, + "scalarBits": 254, "scalar": "0x1949dd8dd4cbb689f5d7a927d8ebccb408e1e834d71afb8f8eca1a1b71a58fd0", "Q": { "x": { @@ -292,6 +303,7 @@ "c1": "0xc152f64b0fa856bad6622928bf6406470575cbd7e46102b23b54b97a2212e0f" } }, + "scalarBits": 254, "scalar": "0xb90a8ca812a8cd72c3009797c2e37a2492f6de4933b1665ce0bf6c6919afeff", "Q": { "x": { @@ -316,6 +328,7 @@ "c1": "0x406348cba9af929395dbbb9d03fb39d95533d8f049c10bd7e04085e23a45516" } }, + "scalarBits": 254, "scalar": "0xed95d7f409dd060c6164c40c330d284f44d7ab2d232e90d127243de96a44c00", "Q": { "x": { @@ -340,6 +353,7 @@ "c1": "0x114ec0de4c23f91c519f4d3ef34573f219eb51338665284d5f1d04ce5c1e5453" } }, + "scalarBits": 254, "scalar": "0x179577966033c6378dc25ba322a3ab4eed87ac1c9846356ad27ba6a789409693", "Q": { "x": { @@ -364,6 +378,7 @@ "c1": "0xf93dc7c14a519e556d777d78b9fc42fa375a2f367be51f1a6afe4b0bdd977d4" } }, + "scalarBits": 254, "scalar": "0xcb6fd81d09d7f41c6090e93a46c66a8cd8248b97a2a5f3d8f0f0c8aceb4d356", "Q": { "x": { @@ -388,6 +403,7 @@ "c1": "0x195552044043e01e8c852781e5419dbf57b88c7d675f1e0c80b4d9de79fafb37" } }, + "scalarBits": 254, "scalar": "0xf70e52d7ea3062885aed72fd8b457313f401935c1c27feeaca8be5006352720", "Q": { "x": { @@ -412,6 +428,7 @@ "c1": "0x21d5002cd603fb24368c6393836dca0fc7dcfb9a65ddd31498f9f7a88278dea4" } }, + "scalarBits": 254, "scalar": "0x8577cd35098a720e484ee1f1ce9eeea4f966ff17a14eae9161bfbceab5395fe", "Q": { "x": { @@ -436,6 +453,7 @@ "c1": "0x1c464d09089855313293f71e96f645b390e7943273cae4bcd1c9d57e4afb1306" } }, + "scalarBits": 254, "scalar": "0x23fbd379d1585614788de0203c1e262c9056e34d77d595b95751e002ee9eae5f", "Q": { "x": { @@ -460,6 +478,7 @@ "c1": "0x24994960907cf272f5090f813e75eb0422be268ec451679c547075ace4d68b0a" } }, + "scalarBits": 254, "scalar": "0x19261692e6a98ee8a7de27422538bff0440e0da08b9b2447192fff186216e9f2", "Q": { "x": { @@ -484,6 +503,7 @@ "c1": "0x3a9653abf19b3a13b5805d49236065606cf47541aa92948f3e3b8ea863ed798" } }, + "scalarBits": 254, "scalar": "0x218e3e8e9644b4448bedee674a0b59c757c0a9fac535afea3b033628db390bc2", "Q": { "x": { @@ -508,6 +528,7 @@ "c1": "0x1d855d5b4a6653e537f9fd40908dbb15993f553c45008260074f4ae7334190bf" } }, + "scalarBits": 254, "scalar": "0x166a766c7661a837f6ed8ce09d64398bb8df64c3f163c3afacf9570cce764bfd", "Q": { "x": { @@ -532,6 +553,7 @@ "c1": "0x20996df17bf6b2cd4982aace810994721c79fb2a333b254005e4782bead8e268" } }, + "scalarBits": 254, "scalar": "0x1863e776b6d4c85a3e1867e32a42866ed917d041af46d43110b0e00266f858b6", "Q": { "x": { @@ -556,6 +578,7 @@ "c1": "0x22db7b286f8c7a6d8189ff2ba07cd0e0c82a03d91de6ccb3b393481f4c7dd7dc" } }, + "scalarBits": 254, "scalar": "0x110bfd023776ce65ea23466b083e0cd6af1de93fce14e0be9c664e0e9c48de7a", "Q": { "x": { @@ -580,6 +603,7 @@ "c1": "0x5c7d35d40dbd1ab24d1c5cedd5c7947bfc42949c83c2cc5d8e1c06c8188c98e" } }, + "scalarBits": 254, "scalar": "0x22265877e84a95bc98ac54f6d7099611d56560b1fda2b0a56daa7954e152184b", "Q": { "x": { @@ -604,6 +628,7 @@ "c1": "0x125859b227d6c0c306dbcef7d79d6d82f676e75db193c0fe79c73bbe438650d5" } }, + "scalarBits": 254, "scalar": "0x1339928bb8d6001e2f6c9305c4dae8ae62658f38bc37c99669eef0dd443d7e6e", "Q": { "x": { @@ -628,6 +653,7 @@ "c1": "0x223b95839a062c87ae26e75a661e51f941e28cbbb4251ae34cfe53b223c17ab4" } }, + "scalarBits": 254, "scalar": "0x3d9578f70fd8dfeef95ca722b82e313aa4cbcf0933a45e1fee3883baf6fc6de", "Q": { "x": { @@ -652,6 +678,7 @@ "c1": "0x576c62f54fc7435b2f2ead35b684158e3ab6bb4c1b96f6e98ebf279f8734633" } }, + "scalarBits": 254, "scalar": "0xee0b0c49ed468ac5486b2b4ba509aa62405b579371223c1d900e6fc5369476", "Q": { "x": { @@ -676,6 +703,7 @@ "c1": "0x1eaa2ae0b4b60bc50de301476f83dd0ab4d808c3b7bc03abbb8755d8921b5e47" } }, + "scalarBits": 254, "scalar": "0x15de6d91216f1d01d021c93a268da50921fae2d03e3ba5a08bbacbb7b6e4ae1a", "Q": { "x": { @@ -700,6 +728,7 @@ "c1": "0x181ec4720b52f082516e3789a71106f0fa0fddc71faa51a04b022ef6d52a3369" } }, + "scalarBits": 254, "scalar": "0x1d1fe4e4dc6899d22416f36523d977e7b62c31d0527e361d695447515c233ba7", "Q": { "x": { @@ -724,6 +753,7 @@ "c1": "0x1e6f242e7cecf0a998c9e20730f3dfb23ae6ec2a518a0c14e3bd87f7caef37d3" } }, + "scalarBits": 254, "scalar": "0x16b95ea9ca7f45d4d960aac56b973133b9e2d91254b46debedf709cf1590130d", "Q": { "x": { @@ -748,6 +778,7 @@ "c1": "0x937f225bc2428fb0cecd1eda09043f563a1b67d978ba14b35663d888f32f34e" } }, + "scalarBits": 254, "scalar": "0x12d4a240b105a60f0ec26eed1459a5f9957c205457fc11201955ad3d5be803f", "Q": { "x": { @@ -772,6 +803,7 @@ "c1": "0x19e0fb3e974e3c278c36b9909cc1e7fab4ee67de1a8aad3920e97d6a73da1b06" } }, + "scalarBits": 254, "scalar": "0x1137871825d3f117fe9b2497a2d11f720b3bc5a44e67f060cbb7b7b214af1426", "Q": { "x": { @@ -796,6 +828,7 @@ "c1": "0x10a00a676464107bad1fa3bbc437d177dc30d28b45574f9ca64dc19ae46ef1e7" } }, + "scalarBits": 254, "scalar": "0x58f8eb6d6d23fe376d58e6d679407798a50b1d4bee9908b9a4c9c1d59149248", "Q": { "x": { @@ -820,6 +853,7 @@ "c1": "0x36cf385b2de835568192c500ef678901711f7578cbace542959dc345818f0ae" } }, + "scalarBits": 254, "scalar": "0x1c7f423a8c359ab94c9d7d84f384ee5941137df6054593309dd932d1e56bc00a", "Q": { "x": { @@ -844,6 +878,7 @@ "c1": "0xd9c7bd9e40b9f3b5dff9b850dff61c351630c42d194edb5ea4ea230e1a0f2a8" } }, + "scalarBits": 254, "scalar": "0x18216d225d5ae949175c81e5598ce04772aafca095abcfd32566a50efc1747ba", "Q": { "x": { @@ -868,6 +903,7 @@ "c1": "0x18801599e6e9b741ce9db84857e99946ca492b9a86f58f3fb825f50620670994" } }, + "scalarBits": 254, "scalar": "0x8f6955f90da139f1f2606ff972092ce27192712a6fdc06273f2a870f85c1a11", "Q": { "x": { @@ -892,6 +928,7 @@ "c1": "0x149bbc47b2ea617fb1bc2b803212b8e1cdab36494b04009e83e4dfba84aa367a" } }, + "scalarBits": 254, "scalar": "0x13b73dea280441beede72e4bc016ed479af289f58d0377882bcc8846d2b4f3cc", "Q": { "x": { @@ -916,6 +953,7 @@ "c1": "0xd0570f7d1571e04855b7a9787a1596cbbbb81c1d65078c173f9d2067fcad6fd" } }, + "scalarBits": 254, "scalar": "0x18f54b807fbc70254b1d7ce2a968de11ad082f0c5a5c3fbf381961f7bc6c43ce", "Q": { "x": { @@ -940,6 +978,7 @@ "c1": "0x11291abdb93575e0d18c23f76cbfc3c3ea4f56e5ca365958117df94fe0556aa6" } }, + "scalarBits": 254, "scalar": "0x714a70085a541911431bd52979455f8fc7c5513868815819535432af013e305", "Q": { "x": { @@ -964,6 +1003,7 @@ "c1": "0x1997030de53af7057dd63c50270c1395241fa4af2bb6a836cb5d1c551cf7b25e" } }, + "scalarBits": 254, "scalar": "0x23d1245caa2368ddbb50dabc235deae438da0b3616c49d9390d43556147e899", "Q": { "x": { diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_128bit.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_128bit.json new file mode 100644 index 0000000..2d8621d --- /dev/null +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_128bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BN254_Snarks", + "group": "G1", + "modulus": "0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47", + "order": "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001", + "cofactor": "0x1", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x3", + "vectors": [ + { + "id": 0, + "P": { + "x": "0x22d3af0f3ee310df7fc1a2a204369ac13eb4a48d969a27fcd2861506b2dc0cd7", + "y": "0x1c994169687886ccd28dd587c29c307fb3cab55d796d73a5be0bbf9aab69912e" + }, + "scalarBits": 128, + "scalar": "0x51453708c9745a9cf8707b11c84bc448", + "Q": { + "x": "0x56a9785cc30ab97bd954c6b5aad7d479d8ead63342a4439762c9c81a46a6418", + "y": "0xce6f606d1be415036662aa7be156f97de78ffdbfe7ec544ecc37cfcfd8b8bf4" + } + }, + { + "id": 1, + "P": { + "x": "0x4c3cdd9f26d4daa75b5bb7c0f05c43257b396b1fa1e186526d762bfe82b7015", + "y": "0x25fb3c28ca2ac64cd888e8083e55f7240ff35c0f96746bbdc9bfbb6f2f4a5b63" + }, + "scalarBits": 128, + "scalar": "0xf7f29a9b4a236efba653636d03ef9a4", + "Q": { + "x": "0x29be1e63960196613e6c5a23159cc166f94b32a203ae0de76a35fa8e54358785", + "y": "0x1872743ec26bdfa369373026d134f918703736b419240ecca2236e8248d351e7" + } + }, + { + "id": 2, + "P": { + "x": "0xac21d27f2a16f6b0e6f067141835082f86ca046b71875b051575072e4d6a4ae", + "y": "0x20b70b67c611fe9f7d33d0f2a70f68e47346738a1ed2e8f68bd94f25a551a162" + }, + "scalarBits": 128, + "scalar": "0x11443699b0b8396d8ead339a3d6f3c21", + "Q": { + "x": "0x16c4945e1fd009f9d357497ef820aea15a545e44a212fb718af7a28c26dce1b9", + "y": "0x1d908442c545f6065612a4948cf48307a26447934bb9750c808fa4a0bcfbe672" + } + }, + { + "id": 3, + "P": { + "x": "0x2158e1c139ced3e6efd8cf53887e8e4426803377095708509dd156caf76af3bc", + "y": "0x2b5fa57792ded14dadec5f27aa703017e41da360e5e15aef5e296f0fd860883b" + }, + "scalarBits": 128, + "scalar": "0x9d5285f4a33a55f2a31573767e9bf53", + "Q": { + "x": "0x1cabc3dedfba865255927b69c42bafd9cb66c7cb15c7819bf274e1935a151d8e", + "y": "0x1127d1cd9a1820ed8d919ef3c99ef806427e627b2105415478c4cd97dfde4c93" + } + }, + { + "id": 4, + "P": { + "x": "0x2f4d079409cefdb0679d8e880034590d16c007bbabc6c65ed870a263b5d1ce73", + "y": "0x2b874e2567fedb008e25fc52352f777def0863bc662393bf62d790aa29b0cbd0" + }, + "scalarBits": 128, + "scalar": "0x9a5f1c68c1bfec7780a1ebd279739383", + "Q": { + "x": "0x2ef861a62366c42b845e3ba4adef1fc0c6ce7c04751cd486b219ebc95e3a420a", + "y": "0x33906c3a0f2ad21ce8c2805c035a1f66e90b1b5124484b6650a04eec8da60bd" + } + }, + { + "id": 5, + "P": { + "x": "0xd2f09ceaa2638b7ac3d7d4aa9eff7a12e93dc85db0f9676e5f19fb86d6273e9", + "y": "0x239aa3ef69785d1b31055ca0c647ec1a429dd3653228eb496e6b0de121b7a0a9" + }, + "scalarBits": 128, + "scalar": "0x7f24290262dd9ba8d79eb280e2f9d32a", + "Q": { + "x": "0x188a47e158706c86e07f5008e2dab1e9a5b9c2b420304e6e0cd3e26b67a1fd1", + "y": "0x157fb4381409905a77925db0c47917c67ed056e4c4973138848145a5c6930c0c" + } + }, + { + "id": 6, + "P": { + "x": "0x29ec81a12c2cf3ce21d79182d58b140074b7bd340e116b43148f76bdf14f7522", + "y": "0x2adbe4567415f146f7a1ca17d8efcefdc1820b9b13928920e9f6a238dec50481" + }, + "scalarBits": 128, + "scalar": "0x37ee1bda0c1d788fcaee5579e5c96f1c", + "Q": { + "x": "0x14ffa1debcbe818d0c1d7210cdc550820dc5d347eb805d04ec58920553e51680", + "y": "0x15500b6041baada44ba8a3e7ba0dd6aee47e7c7037954d081b523c2f9cf373b4" + } + }, + { + "id": 7, + "P": { + "x": "0x16b40aba93f275c60e9f838d6a933e9ad5732235e93cec84ae8db3104348bf24", + "y": "0x2b643954565430a4b7adb893ae69383580ec6136ebdd09124c44702d67b3204b" + }, + "scalarBits": 128, + "scalar": "0x33bf90d9849767bb822bef35fa424304", + "Q": { + "x": "0xb4637748547fa7bfba4f511702eb2ecb8dfea0062ca32094410965195eaf138", + "y": "0xf30ad037653862d73e55f90694b695de3f6e78ba84acd5d3e222e91cef02b57" + } + }, + { + "id": 8, + "P": { + "x": "0x1ed0ae0e57758f3f4d0c2d0e21368a72b93f72ed172c413782db489f5d7b4dfc", + "y": "0x20f3bfd4188f638fd1cb6be3929ef822b543d6109248d3efadd966068e0ac061" + }, + "scalarBits": 128, + "scalar": "0x95ad59299d4404c55a295d648cde827a", + "Q": { + "x": "0x26836aa428e6e132745ccdccc57b5a69372a5deca603225504628b2177039458", + "y": "0x2f282eb7d0cc16d005f97dc26c4371f7936f76620a80a4d9e001e0a7aa58f25d" + } + }, + { + "id": 9, + "P": { + "x": "0x2c406a6f67ab0b74e786b22b72db20a18aec217d0544ade1e1c95682ece911f4", + "y": "0x1131ef7c3b3fdb67026c8ea1db07a60a9e1f87fd7215d484b309903933750ff3" + }, + "scalarBits": 128, + "scalar": "0x8b8026e934436d2a99d5cc23a9153abd", + "Q": { + "x": "0x2fdbc298168961beac839e342c697b42d1e05cbeb267d03946b2eb4077407571", + "y": "0x2a238279fecc5a037eeb0e3c897c8898ec383b1f824809c71848b9b070a6909e" + } + }, + { + "id": 10, + "P": { + "x": "0x10c4a0a04c348d922d424ec4205cc62599b1cff4c7ceaaacc6f1df842689ac86", + "y": "0x1619c2973b3704e8d661b48c9fd78b0aaddc23bde12b8efadc3ff48ceae75163" + }, + "scalarBits": 128, + "scalar": "0x3181da0595365968fb77c7836ef3b41", + "Q": { + "x": "0x1b3ab09310cb6c3634b0724e6b13738df2c0621a960c3c6c9c1f384902e58267", + "y": "0xd0199d08433bb7ef89f73eb8935b50581baae8e676b1379db86b4bee4716a48" + } + }, + { + "id": 11, + "P": { + "x": "0x243f8cd19dd55b0641eaf4597cfde95f01fe8d0c16613599b024e0c033bc05ff", + "y": "0x1110c1523552b72d3b8bd2bf0e31d96f329e92bc0ae35c5428651240993755a4" + }, + "scalarBits": 128, + "scalar": "0x6973ba943264830273eb0fac7f51ef5c", + "Q": { + "x": "0xa4ac7773a2ebac8ebbb62771b75bc0c20bee913ebffd4d8d40cee29cacfff46", + "y": "0x9ebf0b6fabad897bc111d6fde0aaff268f0743a60c14b9346b88f261509c00d" + } + }, + { + "id": 12, + "P": { + "x": "0x12ed6a9f2381ac7b61a6290cf7b9f27a9956859ce9df713b57c3ee86aca3d842", + "y": "0x1d2d2a330e9c64acdca1cad94a93bb632e1923d47a293e3371505be617a4c6dd" + }, + "scalarBits": 128, + "scalar": "0xf339870b12f9f83eb31a791ae3333d1e", + "Q": { + "x": "0xa9a1dfd51fc66aebe7d7ee5d1a631f8563ce2c7370727bdcbc24295db0ad89d", + "y": "0x2162ca49579c3e4eab178d4be5b17a199798a3a344d5ee187a8eaa91a52dbc4d" + } + }, + { + "id": 13, + "P": { + "x": "0x263e44e282fe22216cc054a39e40d4e38e71780bdc84563c340bdaaf4562534b", + "y": "0x6e8a8277090dbc00f2a8bdd7a4d706cd2c4a76437ce77c01a07032dc45f4474" + }, + "scalarBits": 128, + "scalar": "0x269ae705392961c26657edebd5603502", + "Q": { + "x": "0x2e01b0f8a29b48a27f28a8e332acc26a1658af4fc86d4cdffc9b4a3758adea86", + "y": "0x22d2c75f7f0ab44f628d4727dc55a5371f016fe26a8b64e299d614ac5346a94" + } + }, + { + "id": 14, + "P": { + "x": "0x294decc9e70604bc0be276be8616bdd26c0674e9b79dcd781c25a299717e3f67", + "y": "0x1ad7a18330700ff8efa294cf940af787c95d692f847c51581f974fb763203bb9" + }, + "scalarBits": 128, + "scalar": "0x8fd832b055fb8d4d0544dc4733be5873", + "Q": { + "x": "0x58800496554624d424573e3a09d8286059e54e0db91277cbebf89dbff49368", + "y": "0x26027607d2d081c0e3a30e51135839ee90d403680da6053025eb56ca912b646a" + } + }, + { + "id": 15, + "P": { + "x": "0xdef8fb2d5cc946b3bc90b1a182dd6c8b24d1637b5f515f764317fb2ca9a7385", + "y": "0x769eddfa757ea9732d9e9589d44b930749ace41a2208c634448d85fcb3b3ed2" + }, + "scalarBits": 128, + "scalar": "0x9f3816f70d54344dfb01317874bc8841", + "Q": { + "x": "0x115b3694f16f4e63be5e63e87129eb76656205b54769187d09d08da9c6234906", + "y": "0x8ce9f026636ee08b9cc15908e14d533ccc6a7f9bdddc45b523f88111415b274" + } + }, + { + "id": 16, + "P": { + "x": "0x23c21278e721cdaeb416e5be421e942339b751c5edaed7e7f21c872e4034a0e1", + "y": "0x1dae6ca7837ac9623bafc9a3f2291dec5dc3b0ceb2b7bf49a18a745031ec69ff" + }, + "scalarBits": 128, + "scalar": "0x458c0c0cb27a058faf15dcbf2e467128", + "Q": { + "x": "0x1224e706741c7a405e1b4881a40f6004980cf788818d76160bebcd80644efd52", + "y": "0x16a5fef10403e2f48c827de71fc89022023a84ec9f280a07df166c2cd0654d83" + } + }, + { + "id": 17, + "P": { + "x": "0x2c05a3c4397a96aac1d8bdfc9050e40d46a3b04866d3533572ef68839aeb0bc8", + "y": "0x24ed0de89cbed171d5741da438538d4fb2b930baa3af3b91f6d7c84ec2fd9f66" + }, + "scalarBits": 128, + "scalar": "0xed33420cb1d0cfc2fa8ee308ed9d18fa", + "Q": { + "x": "0x24d247424631758c7f940f834ec1253a6e4153bbf292b0b03565b84d9a12233a", + "y": "0x2b57f6ad09c057f4898eab0a4925d444f5402b53219e8599d6f1f18a7761b032" + } + }, + { + "id": 18, + "P": { + "x": "0x1d5b8818f77710df967d28705860644fb3c03bd61b7e3ba2e05541b492626046", + "y": "0x2068fce3167eef946bc290acb713b8cc20596d9995fc2d709847a06f79ec7c5f" + }, + "scalarBits": 128, + "scalar": "0xdff604c575ef79fa244bff8728e17566", + "Q": { + "x": "0xa30f1a164d0571eaf783f266dd101b79d8dc4018250378894df281b4f3e35b6", + "y": "0x24216891d2c197c92c0292757d8ac2ef66bf75f2d812a79c9df6f717d2b4d1d3" + } + }, + { + "id": 19, + "P": { + "x": "0x6a56b861e217d6b33e560f2496b64d73590448536f1aeca0f5415012f6d6eab", + "y": "0x2d43757e3186b12662573062b83ba5f79719ecc2afa47e019f9a94883ee86ac2" + }, + "scalarBits": 128, + "scalar": "0x1ce48e22970752bd56cab93d47caa252", + "Q": { + "x": "0x300c50a7f1f6548aa9e81c37ac88655943db40ebc9567e34bd08073e4cf0c75c", + "y": "0xa2f979373634522c4d8ed5af793c3921f4aa766880e54c34c85b5a90f54a616" + } + }, + { + "id": 20, + "P": { + "x": "0x22a178cc5c0847579ae8bd3c63f5321c4beca1867c0cc48c3dd8ea5346545fff", + "y": "0x2843ebb8948427e89d963559470f30ad2c62f273b687c9f0b147d494db895d10" + }, + "scalarBits": 128, + "scalar": "0xe2a1f946d74223b151c4a5333ff35b97", + "Q": { + "x": "0x23c507f802a2c35f368fbb19288f418e85f77a4ac40414b981b4cbe9bf7b4e42", + "y": "0x298e1663e61758f6eb9b740a40f6c563df31cb1782c64b38df774a99b998007b" + } + }, + { + "id": 21, + "P": { + "x": "0x14e7220d43097a0578b58c487fd26cac1b21bbd977d6bf59726b7ba8fba7675", + "y": "0x9742c86283cba1b228b26d6ca7189db9cc887e77ea54dda96fe0941201334db" + }, + "scalarBits": 128, + "scalar": "0x3b992d52258e687fc9887ca2362b71c5", + "Q": { + "x": "0xb3f12ffe9b3542a9401e42f4324b07a2e2b20cce5355638938d1c75b6d2f31", + "y": "0x25780c72065b14b7d75a6846aabb2f0f906ecad17aac61023623d969f1fef84b" + } + }, + { + "id": 22, + "P": { + "x": "0xa751a8afd74e72e750d59b5ef93a5e59f064513511551850da61675d2540bcc", + "y": "0x7a4baea335d9471e103913a708111a0b4592844d3ec4ea612449563e29f521e" + }, + "scalarBits": 128, + "scalar": "0xd62bf2675414c5455c50dcf09e50d5e9", + "Q": { + "x": "0x3d7b149d920067635921b2b6926f42f069b93a8029cf5b1f7d038617a27c376", + "y": "0x2b2ff0705efecf5bf4de4a891723abc9fa5b62410080c7a15fc3aecc1b0a99ec" + } + }, + { + "id": 23, + "P": { + "x": "0x189d5317bd61f0885c9bf39e9c6baeeec2ac555d3c6d1802259a4f4c15e0bd3d", + "y": "0x22c22d69018e808ed3482b1deb2005ffef2c0ac671efca9febc93f05c59f4c8a" + }, + "scalarBits": 128, + "scalar": "0x549dfe43817b51a5cc6f5fdd6964a7d2", + "Q": { + "x": "0x27ed3cb9028995301a48ee997878aabfc8375a73bc93c2d3dc337a7423b8141b", + "y": "0x30bb2c146e9b3e6aac87b607a920bbea8c43aaa926582ee52e4ba4aa22c0e1d" + } + }, + { + "id": 24, + "P": { + "x": "0x1e3c82cf3e10bdba4a877e80f4f4c4627163d414b091f5d31e5bc1e6354390a0", + "y": "0x1bd132c15344a89f7304460b821b6c865db28cd38add46efff2c4c8ecb620297" + }, + "scalarBits": 128, + "scalar": "0x7c65383e42c5baac8cb4ec5f039a2cf3", + "Q": { + "x": "0x17d9699a5d1273e2436e7bbc846ebae5cf468cc9ec1abf736cee35561da6295e", + "y": "0x304a99329e94425734f1282db190aa6154be8d2f41a9ed60088f385917d4f959" + } + }, + { + "id": 25, + "P": { + "x": "0xaf79a721359981121eef7062fea71a426b43a8d0894de8263787a26c6a2afda", + "y": "0xfeab2c257924bdb83ad183e363531f245b4e18e8795af7450a0c5006c46fb1d" + }, + "scalarBits": 128, + "scalar": "0x4a06c597bc2a75e078b15d7c2df37ce4", + "Q": { + "x": "0x116d61a56614069235846e6e7ce51ef0659c939e9832b42d3385b989361b8b43", + "y": "0x2e2afeb174790519b7d7f7ced93fead69ea6b0c27d1ca22e275a2d891d97b1fb" + } + }, + { + "id": 26, + "P": { + "x": "0x2d6997e8d570635ffca925abcc52a476e602b93c43b1c2b6da1bd2e38233c6f5", + "y": "0xf9a84e29fb70efe643998b6e26c419bfa8e8b9c3babe03627a21a819facb3d7" + }, + "scalarBits": 128, + "scalar": "0x2e28716b76d2adc2f4b9b9e7a1aa7aa0", + "Q": { + "x": "0xc4ef73fe2fb8974ea2d45107caea8b9832b52a58c1b321f71d51c77ba5c6879", + "y": "0x26169759a96cee7493ba81ea7d4c2b40718daa378b1c625bc236dc70883d4b52" + } + }, + { + "id": 27, + "P": { + "x": "0x587d68933186aef072d85c12e06f87a1c622e509fc8499db75ae19842f14dc8", + "y": "0xbd549415dac63415a691184e23662726868bd0b6a5cf3051b754fb62bb5c5e6" + }, + "scalarBits": 128, + "scalar": "0x509b880c30d67d204602f670518c6f2e", + "Q": { + "x": "0x10e122a07c38d1d103e557a51a332a37cf40a2dd53a66b286dd9ae5b98066b65", + "y": "0x1a1a6b256ff9394145c0efe3f401004e91e467b92749c024f62c628c6ab8b5ab" + } + }, + { + "id": 28, + "P": { + "x": "0x1d8e41ca076ee8aeb56262bfd4f6dc6e138425eaee9c9aef7fe3f03667fa88b", + "y": "0x22e9fd907155c8b7e4da3da698053fd8e7a64348bcf3bc19cdf25f24e2d87f8b" + }, + "scalarBits": 128, + "scalar": "0xbf285d1e1290c7cf2921647f45da5ad6", + "Q": { + "x": "0xcaf9f1dacb9a6e39c5fa57a4fcaef283ce40be3e1f956ce28a51220ce7f1ef6", + "y": "0x1922b22677798f9f7b109b4925937565fc1a0f96889b2f2db55bff88527e7afd" + } + }, + { + "id": 29, + "P": { + "x": "0x24c5a4acb8e0edd32ed3afe5155e6d0b3d0be46585a3d75afc6649bd5eef2db0", + "y": "0x224b55fd1110aba0033f153d24c2941c123400a20633378a3c81af0cbd777694" + }, + "scalarBits": 128, + "scalar": "0x722142069dd8d0f55ec1a33f93383842", + "Q": { + "x": "0x1ddef6d8441059432c8914a132a2a8f766591633e2cc7a763a261accba8860d5", + "y": "0x9dd6038b033facd339b7e4f1647f0f906e74b5d65631df0cc6446b8ff0d0c52" + } + }, + { + "id": 30, + "P": { + "x": "0x90c37ba887ae51975dd3a8dc177ae15bc2aeea4fcffb633ff6f5db5622690c1", + "y": "0x1b4ae8767b6db3b805a3613b868ba8480c1274c2c73c718ded8ee0864d7dd74c" + }, + "scalarBits": 128, + "scalar": "0x66496d2ed5115a26d9adb55cefdae4e6", + "Q": { + "x": "0x10d42b301341af2a58743fa703a4681dd3a212ace498da503b9c5f7454b03f1a", + "y": "0x2db0999d38532abc042f034f7adf542333a9aaf6f36957eafdf9fa957e539ae0" + } + }, + { + "id": 31, + "P": { + "x": "0xe9e5ff86a709fe360a77cb3ce135c94e4a6f8c72128a68b53d8aec09a30e810", + "y": "0x119cff3bc0f90eea5863d19220b1ba31e9af4100b5f85a4fb411a272bb77d3ed" + }, + "scalarBits": 128, + "scalar": "0xacbed1811fb7bfc232441a4fe737dc1d", + "Q": { + "x": "0x4e8b5837e35133ea72bae5b3a8674bd974465104ec7ffc74a056a724e069d5e", + "y": "0x165be41cb4be8227b9659eaf981b6017a194295f56cee8733d4ccd0b0d7579d1" + } + }, + { + "id": 32, + "P": { + "x": "0x1c6ed0d38086f467269ec82c3e3a5387d2dcb53165431801584382b84400cc79", + "y": "0x12ffd412e8fd2b5eeec595b9e2a7c9af08e673c728decdb49b50757c6b6fc838" + }, + "scalarBits": 128, + "scalar": "0x3184d49635554f6bcf20978dfb0999ed", + "Q": { + "x": "0x97081781a6807ccc016316f2ac3521cf6b6cad37c5a1025e70c04e7aca2580d", + "y": "0x1bc91d2223c385523f6624060e5b0fa3734b4196fa422333e02005eb5f28c24b" + } + }, + { + "id": 33, + "P": { + "x": "0x24448fef84ebec990969b99e06169787554cc7dd85268585b47107252e4d9789", + "y": "0x194fb040497e1a680745fb69df6c1af7b4ccf66c3b14da11a4e579d4d7d1d50d" + }, + "scalarBits": 128, + "scalar": "0x9f6462ff7e8a2c83ab637ccfa423f005", + "Q": { + "x": "0xc50ea7807ca95ad26a3a14e7da6829929c4c0d031fd0631c23f232848714abc", + "y": "0x1bcb10b76134566535757580b603f0e19fb3c5e412b591072a9ab96a95809a74" + } + }, + { + "id": 34, + "P": { + "x": "0x18edcd982b13ca2d816c1535dc5836f0ba51bf862b70ad57b005f9c8a4a7fcfb", + "y": "0x2061df2beeb98b61fcadc01bd32f6b4a9c09cc993237b3e011c82f2c9e3b68fe" + }, + "scalarBits": 128, + "scalar": "0x9510693a4af18151888ccf75e71c60c6", + "Q": { + "x": "0x29d8b3b7260984a15c433ea4e58d544db0291981080c71d134b37ced9da5accd", + "y": "0x1193d1479d451c58023e373deee69f1c951527b89c53d6e7b42925943376fc20" + } + }, + { + "id": 35, + "P": { + "x": "0x2f8c2322a8d90fd635f8843f4465e067c3614e7703af9cce0d05eaff204bc290", + "y": "0x5ae011abf9103d2951f4eefbae76e7e347303f6da1d3330ec539aa50f3f5b21" + }, + "scalarBits": 128, + "scalar": "0x76819e86996bd9d393ba7e29c0eb5826", + "Q": { + "x": "0x53cc6edc7656e0a8ffb4b19a8cbe44b7338b4bb5921fb24318475c93faa632b", + "y": "0xde7625eb3821656128f3edb61a786fa6c8861b7f8f6187484029578bec9c450" + } + }, + { + "id": 36, + "P": { + "x": "0x1c869c8495d4e0f8fceca73331b754f0cb90cb68b280558d24a58efe56cace63", + "y": "0x47b5f60342296a221933a5d89306e4c76f3afa43746185dde26b44a2550ef00" + }, + "scalarBits": 128, + "scalar": "0xb56b61de7be0d07c82f694e040910e68", + "Q": { + "x": "0xb4cfee0626d50dd3d8a897e8ac97240486cc5c5ba0b73fd49b5f23ad3577dbb", + "y": "0x2e4e359dc1e9b57c2a64568ad38e62271228784bc802e556739e4202ef3b7613" + } + }, + { + "id": 37, + "P": { + "x": "0xe9c7bbd2e4bfdcf96238cc4d2f9358be1ff4f9676d69fbad43de58d1aac365d", + "y": "0xf18423a83b839ed16979ba30e005074b1620763a69d023fd73002529095c0c4" + }, + "scalarBits": 128, + "scalar": "0x358545c6c936c6ccd08c0a6d6b2fbfe1", + "Q": { + "x": "0x2a6a7df9dec4684f22e914bdba13e321df33d02662a9f1ccd298eaec4dc3b074", + "y": "0x2f091a9e065eaaf37bf6ea866273d2d88f3540fa815060a8274ea3ef365fdf60" + } + }, + { + "id": 38, + "P": { + "x": "0xf0850a0d56a2b893785cf1a4d174c63c3129362844cc4002aef959c09797a29", + "y": "0xba51f33ff7a9160569f0da526bd8a8c3798da22750cc73f1507c49d89813fe6" + }, + "scalarBits": 128, + "scalar": "0x653ca51ae542a60a51aabe5b1442cd8e", + "Q": { + "x": "0x3058fe7314fa0519771282329690ac6c14694bc0679b31cf0598332db7a0bc9d", + "y": "0x20d31502b8a3893420a777a8f781aa68d178b71882cf8853a756f3c3d402f4c5" + } + }, + { + "id": 39, + "P": { + "x": "0x29bb679adeb58d6815c3ac23be9f19d33d9decef59938ab82f516ea6726437d9", + "y": "0x1275922573b04c324cc88d5b2e38e9409b885faa29e7a87733e96c7b50637381" + }, + "scalarBits": 128, + "scalar": "0xa9b02a49c7fa0ef3a8459baa4ff5dac0", + "Q": { + "x": "0x298f200c2a4077987f41efd945dc5e52dbf360f0ac3fe2df88723e5433c228f3", + "y": "0x64a3fda6339446ffd689a2209265d35f6744ed6fc6c02abe29e1b44fb56edf5" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_254bit.json similarity index 95% rename from tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1.json rename to tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_254bit.json index ec93bf2..704f1c2 100644 --- a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1.json +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_254bit.json @@ -14,6 +14,7 @@ "x": "0x22d3af0f3ee310df7fc1a2a204369ac13eb4a48d969a27fcd2861506b2dc0cd7", "y": "0x1c994169687886ccd28dd587c29c307fb3cab55d796d73a5be0bbf9aab69912e" }, + "scalarBits": 254, "scalar": "0xe08a292f940cfb361cc82bc24ca564f51453708c9745a9cf8707b11c84bc448", "Q": { "x": "0x267c05cd49d681c5857124876748365313b9c285e783206f48513ce06d3df931", @@ -26,6 +27,7 @@ "x": "0x2724750abe620fce759b6f18729e40f891a514160d477811a44b222372cc4ea3", "y": "0x105cdcbe363921790a56bf2696e73642447c60b814827ca4dba86c814912c98a" }, + "scalarBits": 254, "scalar": "0x2f5c2960850eabadab1e5595ff0bf841206885653e7f2024248b281a86744790", "Q": { "x": "0x57d2dcbc665fb93fd5119bb982c29700d025423d60a42b5fe17210fd5a868fd", @@ -38,6 +40,7 @@ "x": "0x39bc19c41835082f86ca046b71875b051575072e4d6a4aeedac31eee34b07df", "y": "0x1fdbf42fc20421e1e775fd93ed1888d614f7e39067e7443f21b6a4817481c346" }, + "scalarBits": 254, "scalar": "0x29e140c33f706c0111443699b0b8396d8ead339a3d6f3c212b08749cf2a16f6b", "Q": { "x": "0x83895d1c7a2b15a5dfe9371983196591415182978e8ff0e83262e32d768c712", @@ -50,6 +53,7 @@ "x": "0x157a3e1ff9dabccced9746e19855a9438098be6d734f07d1c069aa1bd05b8d87", "y": "0x1c96bf3e48bc1a6635d93d4f1302a0eba39bd907c5d861f2a9d0c714ee60f04d" }, + "scalarBits": 254, "scalar": "0x29b05bd55963e262e0fa458c76297fb5be3ec1421fdb1354789f68fdce81dc2c", "Q": { "x": "0x196aeca74447934eeaba0f2263177fcb7eb239985814f8ef2d7bf08677108c9", @@ -62,6 +66,7 @@ "x": "0x2f260967d4cd5d15f98c0a0a9d5abaae0c70d3b8d83e1e884586cd6ece395fe7", "y": "0x2a102c7aebdfaa999d5a99984148ada142f72f5d4158c10368a2e13dded886f6" }, + "scalarBits": 254, "scalar": "0x1796de74c1edac90d102e7c33f3fad94304eaff4a67a018cae678774d377f6cd", "Q": { "x": "0x28c73e276807863ecf4ae60b1353790f10f176ca8c55b3db774e33c569ef39d5", @@ -74,6 +79,7 @@ "x": "0x1b4ccef57f4411360a02b8228e4251896c9492ff93a69ba3720da0cd46a04e83", "y": "0x1fabcb215bd7c06ead2e6b0167497efc2cdd3dbacf69bcb0244142fd63c1e405" }, + "scalarBits": 254, "scalar": "0x116741cd19dac61c5e77877fc6fef40f363b164b501dfbdbc09e17ea51d6beb0", "Q": { "x": "0x192ca2e120b0f5296baf7cc47bfebbbc74748c8847bbdbe485bcb796de2622aa", @@ -86,6 +92,7 @@ "x": "0x2807c88d6759280d6bd83a54d349a533d1a66dc32f72cab8114ab707f10e829b", "y": "0xdbf0d486aeed3d303880f324faa2605aa0219e35661bc88150470c7df1c0b61" }, + "scalarBits": 254, "scalar": "0x2a5976268563870739ced3e6efd8cf53887e8e4426803377095708509dd156ca", "Q": { "x": "0x2841f67de361436f64e582a134fe36ab7196334c758a07e732e1cf1ccb35a476", @@ -98,6 +105,7 @@ "x": "0x2754a174a33a55f2a31573767e9bf5381b47dca1cbebc8b68dd4df58b3f1cc2", "y": "0xf222f59c8893ad87c581dacb3f8b6e7c20e7a13bc5fb6e24262a3436d663b1" }, + "scalarBits": 254, "scalar": "0x25d596bf6caf4565fbfd22d81f9cef40c8f89b1e5939f20caa1b28056e0e4f58", "Q": { "x": "0x2b48dd3ace8e403c2905f00cdf13814f0dbecb0c0465e6455fe390cc9730f5a", @@ -110,6 +118,7 @@ "x": "0x273bf6c679d8e880034590d16c007bbabc6c65ed870a263b5d1ce7375c18fd7", "y": "0x2904086cb9e33657999229b082558a74c19b2b619a0499afb2e21d804d8598ee" }, + "scalarBits": 254, "scalar": "0x67a499a389129f3902ba6140660c431a56811b53de01d043e924711bd341e53", "Q": { "x": "0x1d827e4569f17f068457ffc52f1c6ed7e2ec89b8b520efae48eff41827f79128", @@ -122,6 +131,7 @@ "x": "0xec892c09a5f1c68c1bfec7780a1ebd279739383f2698eeefbba745b3e717fd5", "y": "0x23d273a1b9750fe1d4ebd4b7c25f4a8d7d94f6662c436305cca8ff2cdbd3f736" }, + "scalarBits": 254, "scalar": "0xd2f09ceaa2638b7ac3d7d4aa9eff7a12e93dc85db0f9676e5f19fb86d6273e9", "Q": { "x": "0x305d7692b141962a4a92038adfacc0d2691e5589ed097a1c661cc48c84e2b64e", @@ -134,6 +144,7 @@ "x": "0x148523f92df8d037353fd0bdc6d0febc88c9e1bc568d72c80c58438f6295dc59", "y": "0x251580663ec294fa4afb8f5ea1340ea281e5ba0faa1adb7b2e5a066f440147f6" }, + "scalarBits": 254, "scalar": "0x3845ad0148f76bdf14f752268eafb065c7272721784a8c6bd3a5fa736332b94", "Q": { "x": "0x120d0df2c066c27aa8332690053f2698c9aaea773a9116edeea2a5e6f5393f0", @@ -146,6 +157,7 @@ "x": "0x1323cb93cf5f33ebf21d2c0ba56e1c39fd0e75b1623d3ab160fed44a37ee1bda", "y": "0x118560ff4940f22e7aec1b92707b637520bf7b740cba254fe8eb1643333dce95" }, + "scalarBits": 254, "scalar": "0x252f232224ad7d89266c28d1289098f03226fa84e7905b0df4e1f6cc4e2e897", "Q": { "x": "0x10438dbb82ca277773e2769588bb8d65bcf8009d40a913604574ee652135542e", @@ -158,6 +170,7 @@ "x": "0x3a7e0e36a933e9ad5732235e93cec84ae8db3104348bf24312ffcdf8e0e78a9", "y": "0xb16292ebf8631b3a0692017ea8eb2b07bb701d3adc0b5bd96409c2dbdabb52b" }, + "scalarBits": 254, "scalar": "0x175ed37fdee061c78e28d668a26add87007ab0d11ad699cba0cb13ae35b8215b", "Q": { "x": "0x78f98145bc4295a54b801aedbfce880f16c488216b94457be42a8ec97cbe9f5", @@ -170,6 +183,7 @@ "x": "0xfb9835a1f2a882cc4c7915f0eea2218b0089d6a71bb41c911faf48cab4f7ac7", "y": "0x20557f5377910568bd2455048f2570137ef59cc3f16a8a21d76c4bfd1a0520f1" }, + "scalarBits": 254, "scalar": "0x2c09383033bc05ff693ec906cdcd2415acca073eaae81ea2e75fbe3122d91a11", "Q": { "x": "0x2d400e116b98c3a2e522c6fdf5d9f298d5284d9be2158ed867b603b3988d443c", @@ -182,6 +196,7 @@ "x": "0x1cfac3eb7f51ef5c90fe33469dd55b0641eaf4597cfde95f01fe8d0c16613599", "y": "0x2cbba5c72a787b2f881f24cd62319e39f320c54820068fc73f35afd998c184e1" }, + "scalarBits": 254, "scalar": "0x24c5b2ce21615dca82231f5fb0fc8d05aa07c6df4bb5aa7c2381ac7b61a6290c", "Q": { "x": "0x18c95d7e9f5f9bf66a4133204af08abc539d03fb73d7dc175f055d640f519a95", @@ -194,6 +209,7 @@ "x": "0x1c9d4cd1239bc59ae80557dfb0c86a1f86ec92e749c8722a713c953eafd6ca20", "y": "0x2081b76f82bc636dfb0ba24e364ca68b6343f0c1754d624decceb3b33b4c74c" }, + "scalarBits": 254, "scalar": "0x239c5e02dc84563c340bdaaf4562534b33ee935ff339870b12f9f83eb31a791a", "Q": { "x": "0xd2683e06c812e71e114a0b482c563c340017220ee2e8374138a95b658375d12", @@ -206,6 +222,7 @@ "x": "0x2bcca4d5e3ee027610989b9e2a5c2bc5dac28833bf25fc700690cc51ad518a66", "y": "0x1963e6d2f802f31268e0427897cebdf235f5fd0032df916f4d5bea79a6802349" }, + "scalarBits": 254, "scalar": "0x23b31c35ea0317455f6d5ae6853938a8fd832b055fb8d4d0544dc4733be5873", "Q": { "x": "0x27ed8e1819eff1f3f45955d048322d999200db5f370d10f897f2b8d23bfedf11", @@ -218,6 +235,7 @@ "x": "0x269da0baac87cfda91dcc696c425eee829630f3eab25975484383528e81d5a51", "y": "0x1174c07ba95ab49d7684088f744fa92e7cc79d9c1728fc1284d6835e815783ad" }, + "scalarBits": 254, "scalar": "0x14d0891e440cbd0fdc4cc55f1163deec34684839c549f63e2b67043d5c6a3b7a", "Q": { "x": "0xeffa3daca47b712d89bdf196bccf7d5b6f2936f649dc3e1b4e6a6b6f90d5f30", @@ -230,6 +248,7 @@ "x": "0x2c0dc536b58de4878fb80632a76fd8c951c7cde2000d557f0c33c1f8c8313edd", "y": "0xb47958947884ef571ed7c551d610ab2a590b174467dc271ba90753ce8565fa0" }, + "scalarBits": 254, "scalar": "0x11e6d36aa05a0b253391de46a38bb640c822a7d2deff7cfa7a2bb4ea21bff46e", "Q": { "x": "0x288e0963403093d072870aeb72663e0a8018ea3e2a468463b071bfb90b0667e1", @@ -242,6 +261,7 @@ "x": "0x2d7d457d64317fb2ca9a73853c11f0d8ea2f9e9e2059c66445be7354018206c9", "y": "0x5a5553dc4eb6ebb490ce6e71d7bab9cac50758d604177c20dc94e4b5da6ce76" }, + "scalarBits": 254, "scalar": "0x3550d13fb01317874bc884137be3ec9d5cc946b3bc90b1a182dd6c8b24d1637", "Q": { "x": "0x113a487d26baffd0d194138d1f242ae33fe7837395ea04a96810993c24d391bd", @@ -254,6 +274,7 @@ "x": "0x22a178cc5c0847579ae8bd3c63f5321c4beca1867c0cc48c3dd8ea5346545fff", "y": "0x82062ba4cad78411aba105d3a7227b06b1e781db1ea009c8ad8b781fcf3a037" }, + "scalarBits": 254, "scalar": "0x2d065d1f44795ae8f9d2739dda24ceb561d3aea6a90f003badd6ac9cf4e635b3", "Q": { "x": "0x7e0c8ddb85187d3e787f2e227dda2e8c50f8b4029d3efc895857ed4a4967a32", @@ -266,6 +287,7 @@ "x": "0xffcd6e5c952cc067aa3ae121a242b478d5ed96da30eb78ac5588964dd0f3405", "y": "0x10784735e8d8623beda487cc8204a61f8cee32625b8ac8ae99fa81da11e1bf0d" }, + "scalarBits": 254, "scalar": "0xee64b54258e687fc9887ca2362b71c50539c881d43097a0578b58c487fd26ca", "Q": { "x": "0x1242743fa09c758b96a19de815b590ca3c96e41f050a63708e328d6b8824f6cd", @@ -278,6 +300,7 @@ "x": "0x2db92ffd62bf2675414c5455c50dcf09e50d5e980d29ae653cdff2e9a67de43", "y": "0xba1cd7057b33897d1cfb0de452f07d497fa2c9b72e2fe75d2d3fd6bd842aaf0" }, + "scalarBits": 254, "scalar": "0x189d5317bd61f0885c9bf39e9c6baeeec2ac555d3c6d1802259a4f4c15e0bd3d", "Q": { "x": "0x1dcb7795df1069b2321fbd400b8dea0f618e9998ae1add0de4d2803b559e4ea4", @@ -290,6 +313,7 @@ "x": "0x2c247d741e5bc1e6354390a0f07abf7fc443fdb57746f87fbf7ef6b29b08cc28", "y": "0x884c985e9e12a61229a2408ef7d719af9a8424a83a188e37a7948c9e5824505" }, + "scalarBits": 254, "scalar": "0x10b16eab8cb4ec5f039a2cf378f20b3c3e10bdba4a877e80f4f4c4627163d414", "Q": { "x": "0xcab89c6c816208b288d7a0cef95b40b7e38b8ec2db22340f5c2d7856ed2c5cf", @@ -302,6 +326,7 @@ "x": "0x87bbdc12fea71a426b43a8d0894de8263787a26c6a2afda5bd31f967c65383e", "y": "0x43e60246efa3a16b03f952ece5e4226135b50a23c10617e7dc4df33afbd4753" }, + "scalarBits": 254, "scalar": "0xf0af4b63cb602604a06c597bc2a75e078b15d7c2df37ce42bde69ca13599811", "Q": { "x": "0x1e1d152c8165fa773e16f41f2e1c7d629a8c7584de6766788e2f99bf9b186530", @@ -314,6 +339,7 @@ "x": "0x286a9ea8b5a65fa0d570635ffca925abcc52a476e602b93c43b1c2b6da1bd2e3", "y": "0x27fe854a6b39abe73c4ffd44cd4547981e20646501196340dabeabe1beadac5b" }, + "scalarBits": 254, "scalar": "0x7188b949fc8499db75ae19842f14dc8274af3e92e28716b76d2adc2f4b9b9e7", "Q": { "x": "0x2da7c7d0fd546c27b405a89bf419280d6b819f81dd3171582462b6190f3aae8", @@ -326,6 +352,7 @@ "x": "0x2bafb56f37fc8a4e316d092c509b880c30d67d204602f670518c6f2ee3f7cd68", "y": "0x70bafbb2d34255884839dd1ba74ed3fc436bfabfff0e7cc2d867441d9d675ef" }, + "scalarBits": 254, "scalar": "0xa48591f45da5ad607639073a076ee8aeb56262bfd4f6dc6e138425eaee9c9ae", "Q": { "x": "0x1161959e5a97457d68f29ca3c9dc7a8f4004103a8029112cc941a7fc4a29b476", @@ -338,6 +365,7 @@ "x": "0x90c37ba887ae51975dd3a8dc177ae15bc2aeea4fcffb633ff6f5db5622690c1", "y": "0x1b4ae8767b6db3b805a3613b868ba8480c1274c2c73c718ded8ee0864d7dd74c" }, + "scalarBits": 254, "scalar": "0x1829df2cce135c94e4a6f8c72128a68b53d8aec09a30e810c08cad0143ca5e18", "Q": { "x": "0x2e15a14af81f9806fbb1291b288263909981660d02477da3aa05c82fe8a25497", @@ -350,6 +378,7 @@ "x": "0x29afb0bb8449ddac50717e1d25dad62984a701983697a63336e45daf7ea97c9c", "y": "0x12ad7ecdbe6b656bf44e2112d1a5a87b2bc0f4e3234750b11ed9ae76453dec06" }, + "scalarBits": 254, "scalar": "0x1100331edc8dd561f57694f9f4a32f114e56bf756c8a2ba87df8329a10aa4b12", "Q": { "x": "0x16a63a16bb7655074c9644fc24aa0f4cab61bc8911d381caf1af56da841abc40", @@ -362,6 +391,7 @@ "x": "0x27d918bf7e8a2c83ab637ccfa423f00591123fbf84ebec990969b99e06169787", "y": "0x2da54f7e40092f3a81a8ecbf9bfe354619323f27bf24b29424890b97a6a8d4a1" }, + "scalarBits": 254, "scalar": "0x1264f8b6760ae783b91cb825b46ad015e45e924b32a562e931783f6c7ec63dca", "Q": { "x": "0x29069738e5027fc8e11e33bf945fa0a297c260308aa76d671b73245f9ee20ea8", @@ -374,6 +404,7 @@ "x": "0xac4f28b816c1535dc5836f0ba51bf862b70ad57b005f9c8a4a7fcfbd451c8d3", "y": "0x6d671bd0457bc901a8be991245beb1295b88ba7029d28faa75e068b923ca224" }, + "scalarBits": 254, "scalar": "0x3417abf204bc2907b42045f9510693a4af18151888ccf75e71c60c663b73662", "Q": { "x": "0x209660c6039d04f8126d12e8c2c120b0e0d29b1be28497eb3079b392dfdad047", @@ -386,6 +417,7 @@ "x": "0x1ef8341f82f694e040910e68a54baac4a378d52cfee4aa7335550e8d68ad1c6e", "y": "0x7a314c51e78fbe5e82d1745af480d4f34d60423a284de5c85fdab64036c5f29" }, + "scalarBits": 254, "scalar": "0x2588e331d2f9358be1ff4f9676d69fbad43de58d1aac365d57f8e3afb56b61de", "Q": { "x": "0x2921003fd5ae988eb4e3abe9d2ee2627b91eb9f3ae6fab449726252f1de8b06d", @@ -398,6 +430,7 @@ "x": "0x250311f0f95137a190994efc75d99f648a43448f5c7238043a71eef42e4bfdcf", "y": "0xe49093f8626ad7dc79e939ee7304110492fc32e54fc5af21650e4c131299fc8" }, + "scalarBits": 254, "scalar": "0xd9a3b943988f2af3457fefd358545c6c936c6ccd08c0a6d6b2fbfe1ad2c5d76", "Q": { "x": "0xf3940be3578ee5217a73183bc3423258dd1aecc1319d34dcc289e919182b5c2", @@ -410,6 +443,7 @@ "x": "0xabbe56709797a29e6aa061e256705e8d1cc9656a652590fa0a42550d009adb3", "y": "0x1e07308d7c31e358c009a351f876e446c649bc1e6205c149ea7f63a9f1b1eaaa" }, + "scalarBits": 254, "scalar": "0x146aaf961442cd8e3c214282d56a2b893785cf1a4d174c63c3129362844cc400", "Q": { "x": "0x2e4194da91421e3b886094fe90da1731da8c2f12d25b9547416e8ae39f1cdc0c", @@ -422,6 +456,7 @@ "x": "0x2fa7c6743d9decef59938ab82f516ea6726437d94f9527ff653ca51ae542a60a", "y": "0x27ffcbd0152613190d20d0ccecdac848259e11f8444f2299e1206b54732287ea" }, + "scalarBits": 254, "scalar": "0x170c7328a9b02a49c7fa0ef3a8459baa4ff5dac0a6ed9e6bdeb58d6815c3ac23", "Q": { "x": "0x19b897c2f3dc81a6e37816501d79948c9589eed59039bc44ed5991170982dfc1", @@ -434,6 +469,7 @@ "x": "0xc367c0d6b1503eef66d7e53525577620ac8049000ba2771d604034ce96bc261", "y": "0x11795a4beb65c948647108a8ee08c1a58b8ad3fdf6c6b9b08d606d23a7a36a07" }, + "scalarBits": 254, "scalar": "0x20a1d8f998224d7e4a414c5870264c91e94d73ffeefd88aeb7a357a91cc693bb", "Q": { "x": "0x1c798d139649f4a497c4ccc7f05804ce44608fa8398cdef2b11110b4d72d24fc", @@ -446,6 +482,7 @@ "x": "0x15cc528dc3ee524b4be51b806f6ac5c22c2a99e433ab2e80c3e3947e4d79bc71", "y": "0x172f8322bff2a9f39c4610080f132e63015c5e1c3f64dafced095592ddd9e692" }, + "scalarBits": 254, "scalar": "0x2131557de2580fe5626cca0178dea0c95d37c8c75c2f544dc9cd16a12d6c2bb4", "Q": { "x": "0x246494ee5f7b1cd5b500551a05f879499bdef0fed91ad9d2d58c1f68744fcf6d", @@ -458,6 +495,7 @@ "x": "0x2eb90ccf155f1cd2a5cd3f8431c9dcef8219d1ffe19dd097cb876861827bca7b", "y": "0x4bd0a99b1feac1656342e540c78bbd6745daaed022d715b5b932e8394f37b84" }, + "scalarBits": 254, "scalar": "0x179971bd22e6b2fa24084c299585c90e4a361342dc8d66f509834e0fecebc207", "Q": { "x": "0x4d2df13d44060cda50ab3d8253f505c2883dc4bba4a7b6789ed6cf65704f627", @@ -470,6 +508,7 @@ "x": "0x98f659dfffb09983c2df3d4065c145e9a5c55eee35a0e8ba7e6ca10335ebd0a", "y": "0x26ca3f6a4ef7e153b2aff8eb128b66cc0fd785798dd2fb2ce9e93d3f21d5c2a0" }, + "scalarBits": 254, "scalar": "0xd207e98eb1a813026ed20c3aaac9a1547196f5c9075e9c9e66bd668d4a24546", "Q": { "x": "0x30ec5502cbd162b474bf5619ea337b6b15b95cb76db073778a43d47536b3832", @@ -482,6 +521,7 @@ "x": "0x2dd2bff238458805650bb7cbc4f87bacf2dd44fdc225cd3c7626c32bd5899cf0", "y": "0x2369f39c1a3b5b5fd20e926596513d991e7ac335dd933ab15acb08dfab1d1c64" }, + "scalarBits": 254, "scalar": "0x167a229b0b49c002b74f08059a6a88b004c9a9a71d596073e5d8f1eea9e7b4fa", "Q": { "x": "0x772a85b2c9443913c47f445275953bce7abfcb412c57cc94f61f53219108d3b", diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_32bit.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_32bit.json new file mode 100644 index 0000000..0666f61 --- /dev/null +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_32bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BN254_Snarks", + "group": "G1", + "modulus": "0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47", + "order": "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001", + "cofactor": "0x1", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x3", + "vectors": [ + { + "id": 0, + "P": { + "x": "0x22d3af0f3ee310df7fc1a2a204369ac13eb4a48d969a27fcd2861506b2dc0cd7", + "y": "0x1c994169687886ccd28dd587c29c307fb3cab55d796d73a5be0bbf9aab69912e" + }, + "scalarBits": 32, + "scalar": "0xc9745a9c", + "Q": { + "x": "0x1a6a62417d8822d2b3e1f91df94aed37b46748c4cecbb218f492a81f79255a11", + "y": "0x911b1c76257fb1b0b81197a6c534ac529b4673078c5630b4cecee05696860c" + } + }, + { + "id": 1, + "P": { + "x": "0x2ac1a18ea8ec5bc21fe0ca80f7f29a9b4a236efba653636d03ef9a4130f3764", + "y": "0x8c9930f88b00fb270f4148d47bb2aef9d246098afef80cc6b54b17b0a742d8b" + }, + "scalarBits": 32, + "scalar": "0x6a6b84f3", + "Q": { + "x": "0x1c3f21ce99adf9aab64b6aff03804fc487b1ac0fed8e0960db0c651f1760e79f", + "y": "0x186ca52e47030380523a4f299b737b0ddc721a3d855522ab6739796c4ce58dbe" + } + }, + { + "id": 2, + "P": { + "x": "0x4510da6b0b8396d8ead339a3d6f3c212b08749cf2a16f6b0e6f067141835082", + "y": "0x20553800f93d1e3c2b87a73a99612522d0f1a33175ccb0f753d5cd33da9deef8" + }, + "scalarBits": 32, + "scalar": "0xf9dabccc", + "Q": { + "x": "0x2f705566c37b478639ecd8a03599a0bae83980192f9d1e0dc4dd2871505bed35", + "y": "0x1b0594e3f798896320b4b322d0f68af5e2f84e6ba69ba93b346f761ae9d9883b" + } + }, + { + "id": 3, + "P": { + "x": "0x2f260967d4cd5d15f98c0a0a9d5abaae0c70d3b8d83e1e884586cd6ece395fe7", + "y": "0x65421f7f551f5901af5ac1e4038aabc548a3b3427190989d37daad8f9a47651" + }, + "scalarBits": 32, + "scalar": "0xa67a018c", + "Q": { + "x": "0x24889810987c7270ca52f93be9308e041132c129b7adcdf48892cefdd159814a", + "y": "0x16ced394e5006f2831a8ab5f5355a6b0504459c062eebc1dc004dfe32d1e57d1" + } + }, + { + "id": 4, + "P": { + "x": "0x1b2524bf93a69ba3720da0cd46a04e835e5b79d1c1edac90d102e7c33f3fad94", + "y": "0x2e4923efd1120df5118cfc52fd65d5d258a0319db5c0c9ff1707ba334cab8be2" + }, + "scalarBits": 32, + "scalar": "0x8e425189", + "Q": { + "x": "0xa886bc2effbaac0dd573e01f9ff872ab09c370685bf35d5d63060613facfcef", + "y": "0x2c6dadfdc0904ff1b9972823be54414efe584aa109a5d9499c5c490160471c71" + } + }, + { + "id": 5, + "P": { + "x": "0x179de1dfc6fef40f363b164b501dfbdbc09e17ea51d6beb06d333bd47f441136", + "y": "0x6abe8400971d72505a4df1ed7c404b4be54d112b23ca3a77a2daccdf45dcb7a" + }, + "scalarBits": 32, + "scalar": "0x19dac61c", + "Q": { + "x": "0x16fc46f08098cba2de380ae74b62ee7393ce82f7ea1398b47c5354b52319e697", + "y": "0x152605937ff5bd6215289c83db9919c1464baf7ccd5fb46578b5c18a7fc04ca0" + } + }, + { + "id": 6, + "P": { + "x": "0x2807c88d6759280d6bd83a54d349a533d1a66dc32f72cab8114ab707f10e829b", + "y": "0xdbf0d486aeed3d303880f324faa2605aa0219e35661bc88150470c7df1c0b61" + }, + "scalarBits": 32, + "scalar": "0xaa271c58", + "Q": { + "x": "0x1a50bf36b78159f37e2d79a4ff04834d8247c5afdd5700a62748ad8426683e93", + "y": "0x3ef263d75cebe113540c3218374c4e7692cc27f2f80a133cb9f9d4123e4a58b" + } + }, + { + "id": 7, + "P": { + "x": "0x2af1b197d870a263b5d1ce7375c18fd737cbfca18f44313dc9ddb54de269c642", + "y": "0x2453d2b2bc9c05921fedc8e86494a1c118437815e828009edb47ca4927964dff" + }, + "scalarBits": 32, + "scalar": "0x16c007bb", + "Q": { + "x": "0x25f669f0a23119c5df42c69b6d33ab57f33905667c74d2f409b665511b7e282e", + "y": "0x49687fecd5ddbbd0849f2ea9bd744a2210a148b94eb26e4d27337f3bd2c76bc" + } + }, + { + "id": 8, + "P": { + "x": "0x240ae9850660c431a56811b53de01d043e924711bd341e5309cefdb0679d8e88", + "y": "0x10b506b73c36503b32718735977e00368580d9156a4a572cc308ea5c482fb185" + }, + "scalarBits": 32, + "scalar": "0x389129f3", + "Q": { + "x": "0x17cedd6679920c434b95705a09bdbf88e5da42356c187258504c7f1e7f60bef9", + "y": "0x26b8fa4c84f9076a98738b0df682046bf0d29dc12fdc8ca34404ef3dc648a754" + } + }, + { + "id": 9, + "P": { + "x": "0xec892c09a5f1c68c1bfec7780a1ebd279739383f2698eeefbba745b3e717fd5", + "y": "0x23d273a1b9750fe1d4ebd4b7c25f4a8d7d94f6662c436305cca8ff2cdbd3f736" + }, + "scalarBits": 32, + "scalar": "0x8ae70553", + "Q": { + "x": "0xaaeb6d98342c4a3a9505cc8c30cd9efea1f8ec7dfeccccc3e0857b21bfc7ddf", + "y": "0x1522912555caa1ed591d33705044b337bba272dc450d6ffcf6b4749294c9453d" + } + }, + { + "id": 10, + "P": { + "x": "0xba4f721db0f9676e5f19fb86d6273e9ea800d6a50bfbd246fdd6a91bf1ac11d", + "y": "0x10d1bb655551bbaf9417e51ee090d625317605d4b68a2831722c51d99a5a2980" + }, + "scalarBits": 32, + "scalar": "0xaa2638b7", + "Q": { + "x": "0x97d561eb6e14fe8d39dd526e5e125afff9419ac25ad3b33c7ac113bf8f545a3", + "y": "0x1647651a9f39ae9842b9776619ed6f843400bb3c64db53acbd22c40c73730102" + } + }, + { + "id": 11, + "P": { + "x": "0x148523f92df8d037353fd0bdc6d0febc88c9e1bc568d72c80c58438f6295dc59", + "y": "0x251580663ec294fa4afb8f5ea1340ea281e5ba0faa1adb7b2e5a066f440147f6" + }, + "scalarBits": 32, + "scalar": "0x1784a8c6", + "Q": { + "x": "0x1a4844a6e50cdd0ed81a5beb0d10dd99be386f9e2715f2885631b833a2a336f", + "y": "0x20c39e36aebbfaa4fd25506f684cff7667c5a6c8c0c2ed56c1cf5735eaa2e981" + } + }, + { + "id": 12, + "P": { + "x": "0xb0b3cf321d79182d58b140074b7bd340e116b43148f76bdf14f752268eafb06", + "y": "0xb6ae7d44ca81622a00d44e55fddeca4a6c2c89f38cc0e49ebd14bd40310d101" + }, + "scalarBits": 32, + "scalar": "0xcaee5579", + "Q": { + "x": "0x1a9139a50abc81d7dab9e6ea50182930fcf6ceeaf4c008e443e7a24e3733fa40", + "y": "0x8198405c8825b15aa90606a33cb5b70852f761df4b07b2c9436244daf8c7bd1" + } + }, + { + "id": 13, + "P": { + "x": "0x1323cb93cf5f33ebf21d2c0ba56e1c39fd0e75b1623d3ab160fed44a37ee1bda", + "y": "0x118560ff4940f22e7aec1b92707b637520bf7b740cba254fe8eb1643333dce95" + }, + "scalarBits": 32, + "scalar": "0x4e7905b0", + "Q": { + "x": "0x11a83dc33d28cad784dba27f9c2707d7f798a68a5285864dad6faa891ed397f0", + "y": "0x1fdfdb667341ac631da01ffb3260d70e602257ac5d311e781a59a5701e1220b2" + } + }, + { + "id": 14, + "P": { + "x": "0x2ba36cc44348bf24312ffcdf8e0e78a9094bc8cb224ad7d89266c28d1289098f", + "y": "0x1671b78180f7d05e87c34a1941d7560da7269eb37971508f3006948e20ae58b7" + }, + "scalarBits": 32, + "scalar": "0x6a933e9a", + "Q": { + "x": "0x1d9a9d7ac7e362c8a8c03689a20054d8f7ddc719cf82d656194c6884a468d4ad", + "y": "0x2ee94025e2001697fbeeef1dff465b2c1a860204e0dc8acde80ac55310b21b3e" + } + }, + { + "id": 15, + "P": { + "x": "0x175ed37fdee061c78e28d668a26add87007ab0d11ad699cba0cb13ae35b8215b", + "y": "0x2691eb9e89b662370ae22bda9dd8091245f472f4e2ba43513799951cf0b3c9b" + }, + "scalarBits": 32, + "scalar": "0x82db489f", + "Q": { + "x": "0x74ab650e047972589f4f86004ad4b792bd9bdada76866e022ba7aa51caa78f1", + "y": "0x749485d6aee6fc79047518e2fb01d27aa9331b090677e8847a11f22d19e44eb" + } + }, + { + "id": 16, + "P": { + "x": "0x275101315a295d648cde827a7b42b83857758f3f4d0c2d0e21368a72b93f72ed", + "y": "0x266bb62874df0b5224cf52e36b0224e9f88e3f88ef68b7dd39ba14792381bccf" + }, + "scalarBits": 32, + "scalar": "0x95ad5929", + "Q": { + "x": "0x218498085d5e43bfe100cc0443ea7953d0915b62a13ab6f174154bb4413e876a", + "y": "0x19e302af3edb799338c142e433db6cc4250486b4ad2b96b1cbb24a5f4fa1126c" + } + }, + { + "id": 17, + "P": { + "x": "0x2c406a6f67ab0b74e786b22b72db20a18aec217d0544ade1e1c95682ece911f4", + "y": "0x1f325ef6a5f1c4c2b5e3b714a679b252f961e293f65bf6088916fbdda507ed54" + }, + "scalarBits": 32, + "scalar": "0x3edf4d6b", + "Q": { + "x": "0x28cad30ded13ca69a816787d387abb9f722273ce0df74a481e550aca537865c5", + "y": "0x143174a9dbc15223e2186c1ca685585c35adf8b29d8f78280dd06d4ed1093de8" + } + }, + { + "id": 18, + "P": { + "x": "0xdbbced0431282834c348d922d424ec4205cc62599b1cff4c7ceaaacc6f1df84", + "y": "0x2e517930af3f4c8acf3247fe937e11051e99ebcdfed249e25197932fc6c523db" + }, + "scalarBits": 32, + "scalar": "0x8fb77c78", + "Q": { + "x": "0x17da81c151686201ee99dbc5c308c9c16103abfbe2055dccf6e62de2f3088d35", + "y": "0x2af1159e2fa19a6ac19d0588c31cc124eb63ec61515ad09600597ad4050b46fd" + } + }, + { + "id": 19, + "P": { + "x": "0x2b3281cfaae81ea2e75fbe3122d91a113ee60d6a1f2a882cc4c7915f0eea2218", + "y": "0x2eb5ed27bbc936aca6d444a2418f9f676d671c1a3f658dcb5bcf7cdc2559a502" + }, + "scalarBits": 32, + "scalar": "0xcdcd2415", + "Q": { + "x": "0x2bea0b62b4d087353fbc91ef97d15b1ec13b5337021a462fb1e679916f6736b7", + "y": "0x28fd8921af2e698fcd680c3fa0fea327117aee0331a84c57c86d401f7c90f997" + } + }, + { + "id": 20, + "P": { + "x": "0x243f8cd19dd55b0641eaf4597cfde95f01fe8d0c16613599b024e0c033bc05ff", + "y": "0x1f538d20abdee8fc7cc472f7734f7eee64e2d7d55d8e6e3913bb79d63f45a7a3" + }, + "scalarBits": 32, + "scalar": "0x7f51ef5c", + "Q": { + "x": "0x268fc5e1781712c238247d12dbc48e68e19d363243e6e6ae39b2c97acf057044", + "y": "0x2411ac358dc291e054c97843dd1b817e69d38cc9e24d07e6a3c3c726fca65402" + } + }, + { + "id": 21, + "P": { + "x": "0x24c5b2ce21615dca82231f5fb0fc8d05aa07c6df4bb5aa7c2381ac7b61a6290c", + "y": "0x23608f84f3340bb790efbcd2e04c3a09fcf92cb11fcac0634fa93a90e469a97e" + }, + "scalarBits": 32, + "scalar": "0xafd6ca20", + "Q": { + "x": "0x1d0025277e903afada13d6fb137e00a29e7d14b3d7a81d260ec1d690c9195283", + "y": "0x2d1f663271ae9ad6331332d288182099fd8106487478c0e7f28ee8db42f73b5a" + } + }, + { + "id": 22, + "P": { + "x": "0x249d33d9b24b0b9d72753345239bc59ae80557dfb0c86a1f86ec92e749c8722a", + "y": "0xb8120200759e489f99d6b0e934d0ceb0091048b220d6056a17aec7f63fe45cd" + }, + "scalarBits": 32, + "scalar": "0xb31a791a", + "Q": { + "x": "0x11f79cbe0dbb2238df73898cf94cf8f411fb4ba16fca55c56453811d0a772e34", + "y": "0x28febf0ec31fb96c2733c2ed34877f504e375a7d8d2a477c9c6ecc19dbf4e066" + } + }, + { + "id": 23, + "P": { + "x": "0x1b3015289e40d4e38e71780bdc84563c340bdaaf4562534b33ee935ff339870b", + "y": "0x676a581ed81adc8da2ed1118036af893b6a29d0971fd4dfd306b59e51765bb2" + }, + "scalarBits": 32, + "scalar": "0xd5603502", + "Q": { + "x": "0x19f0e7eebe38ecb4e73d3d0a7def6327b7638dd61a51e45e2d65420990dd8a98", + "y": "0xcdce3e5dd50719fd9754507fd5a0467cf22526c5cf94320fc148074f1cdc4cf" + } + }, + { + "id": 24, + "P": { + "x": "0x2185af746c0674e9b79dcd781c25a299717e3f6779292dd1269ae705392961c2", + "y": "0x7d476334ac8c31c9d5af37e8f4b594b4c136b223371f78374ce3a4f9ec9d88" + }, + "scalarBits": 32, + "scalar": "0xa537b326", + "Q": { + "x": "0x2022fa2867836f913ec47df6e47eb6c787502e8400d144565a2c1da28a9c7bf7", + "y": "0x1c654d9b6bb5c7deda91d3d6e88be4f64e65aade8b003224a0dde9b9bd35ab92" + } + }, + { + "id": 25, + "P": { + "x": "0x1a43314ad518a66e2cca67cc1f9052aa2ea225d8eb16a2d47fca680f68a65f7", + "y": "0xd28fdc4eaa95eefead63eae41cec51d2f2c68ba684bef43e3657d9ff9543fab" + }, + "scalarBits": 32, + "scalar": "0x2a5c2bc5", + "Q": { + "x": "0xc4b96cb6d740138c7be5c707deb848328982b2d08101212f8ca10f089e0fdc5", + "y": "0x2c4b603513a7945bc98aeccf7dea082ab71adb86c8e0851220c062e0703c3dcd" + } + }, + { + "id": 26, + "P": { + "x": "0x157db56b6853938a8fd832b055fb8d4d0544dc4733be5873af329355e3ee0276", + "y": "0x227d234740e2daaac186cb25385e50aad3e9c47bf9aa93b324df7f51fb10ca38" + }, + "scalarBits": 32, + "scalar": "0x5ea03174", + "Q": { + "x": "0x168cbd88a5c8957f40da58e74f0cdc3c2db5eede7a6150b6dd016e278f80e14f", + "y": "0x2d18f5197d5cacca7cd05fed71797df9891c649d4b49d739985c112a54f9cc0c" + } + }, + { + "id": 27, + "P": { + "x": "0x269da0baac87cfda91dcc696c425eee829630f3eab25975484383528e81d5a51", + "y": "0x1eef8df737d6eb8c41cc3d270d31af2f1ab9ccf55148ce7ab74a08b85725799a" + }, + "scalarBits": 32, + "scalar": "0x5c6a3b7a", + "Q": { + "x": "0x137583466d578bb7c23a9cce0ddc47bd16ec1d86f7cd7c60cccf5a70a7e958c", + "y": "0x127d6c34def4fbb7729cde6679cecfea3c3bdf8ffae6e5a2cb2f5ed0b10ea8a1" + } + }, + { + "id": 28, + "P": { + "x": "0x30cf07ec8313edd53422479440cbd0fdc4cc55f1163deec34684839c549f63e", + "y": "0x17c52967e18b8e2de8aeea3e352ee47cee9a24a7ea2bc7f4a9167c009a73e868" + }, + "scalarBits": 32, + "scalar": "0xd557f", + "Q": { + "x": "0xff1a883dfa7aada97f0e48c69898faf35dc1d0ca3db292277a430f2ad3b1dea", + "y": "0x1662778a41d3a6a5e3c8aaa1920f52e603ed851e2ec2926b006510f686ff0966" + } + }, + { + "id": 29, + "P": { + "x": "0x211a34b8228f4bc48f0849e2e721cdaeb416e5be421e942339b751c5edaed7e7", + "y": "0x1e500b6cbe48d82976327671d7d325fa88e7e730a7ff48fad83d75632a5b084f" + }, + "scalarBits": 32, + "scalar": "0xe1912f81", + "Q": { + "x": "0x62084ba85ae2b64f26ff1b2dfcd5a361443408ff1c4f4057bace46cea71bb1a", + "y": "0x16479c29b60d58e6ca5b7c6db6faf31d3c4bafa0c656d84a5dcf06bd56d6afbb" + } + }, + { + "id": 30, + "P": { + "x": "0x1cbbda209aeb0bc801044c54458c0c0cb27a058faf15dcbf2e467128f9c958d9", + "y": "0x29930e4120c3e2a4b15f756ab7d19755f854a800f1158caf50dc9842da5d6ae3" + }, + "scalarBits": 32, + "scalar": "0x66d35335", + "Q": { + "x": "0x3b3339cc5648eef03e19d44b3d2fa82213bc5506834d21a9a8be69cffb29bbb", + "y": "0x15fbe0b5b0c1f5814a33e691ad054476bb1619c4796c0082cf4b3ccf0f16ccb3" + } + }, + { + "id": 31, + "P": { + "x": "0x22a178cc5c0847579ae8bd3c63f5321c4beca1867c0cc48c3dd8ea5346545fff", + "y": "0x82062ba4cad78411aba105d3a7227b06b1e781db1ea009c8ad8b781fcf3a037" + }, + "scalarBits": 32, + "scalar": "0xa90f003b", + "Q": { + "x": "0x11a77ca3637b326f4819de3edff87d204cfbb934a78fce8d9da480fe5c374e49", + "y": "0x13822f509627228117e721a3b584187f378b6f975949c949576cb36ace3a2b47" + } + }, + { + "id": 32, + "P": { + "x": "0x2357b65ba30eb78ac5588964dd0f3405b419747d44795ae8f9d2739dda24ceb5", + "y": "0x2331a9b7ad9a6278d2be08e03b69e5854d28e159ac9a4fa451b0b05bcbca88d9" + }, + "scalarBits": 32, + "scalar": "0x1a242b47", + "Q": { + "x": "0x2774f05e532b89952afdf1ad3b4a2e45b7562d1e87a547b5bb074d0d00237058", + "y": "0x2705938b897c06e0568bd657cfc65b7638738589e4eb56b7138dba7bdb6a8b63" + } + }, + { + "id": 33, + "P": { + "x": "0x25c9adee8fba76752f1e8fc9e2a1f946d74223b151c4a5333ff35b97c952cc06", + "y": "0x13bfbce44e7c1d68ce83d635fbe7ce94f4aba3b082964acb634b3bc32a47c591" + }, + "scalarBits": 32, + "scalar": "0x87fd26ca", + "Q": { + "x": "0x1223150360605ac920ca323898d88eca5f953d1b2304b09776fa950b52812acb", + "y": "0x64321e01551eadf29a3fb1d32246f969da9a8e1a7b2002e44663073e11ec0a5" + } + }, + { + "id": 34, + "P": { + "x": "0x24fd59f81edd6f233b992d52258e687fc9887ca2362b71c50539c881d43097a0", + "y": "0x142ce527587004d911fad01090db8aeb81d5b92148b8b9701cf5cce8e5e1e62e" + }, + "scalarBits": 32, + "scalar": "0x1e4388df", + "Q": { + "x": "0xba934b1d66d2b00cc94c1b2e44bd0fa94e8299bffe3fd46cf798a5d9e05c49e", + "y": "0x1c3b346b4279be6ca2652d32559faa180afeb284f6aa527d11441b82102c2d5a" + } + }, + { + "id": 35, + "P": { + "x": "0xf842f6e4a877e80f4f4c4627163d414b091f5d31e5bc1e6354390a0f07abf7f", + "y": "0x1c11e20a584a0e9cac0340e8d5b295fac1ad86b3c155e922a89ece33ed1c3d63" + }, + "scalarBits": 32, + "scalar": "0x78f20b3c", + "Q": { + "x": "0x223c6d2375491d7e3c01970bc088cb7026f23b9e28afdb6e688cde4ed25555f1", + "y": "0x239a74b735f8c2b71cb2984b935338d18f8c36531236cf1b3623d983722490a8" + } + }, + { + "id": 36, + "P": { + "x": "0xc5b424b509b880c30d67d204602f670518c6f2ee3f7cd688a4f08d9a77512dd", + "y": "0x3c75107681d6aaf03207ed6fd66e06da32da8a58016c10a4698f695c28fe94d" + }, + "scalarBits": 32, + "scalar": "0xa076ee8a", + "Q": { + "x": "0xacd5f968e348c2490510d53d3c400ca3c35bb0a876551e1ed8e70bd128c0e6d", + "y": "0x14b898e19656c2030f6fb9602e7a601126daea18b27f975229be0d120a3f55af" + } + }, + { + "id": 37, + "P": { + "x": "0x441f5513ac5275b0d2335c8121f557dbf285d1e1290c7cf2921647f45da5ad6", + "y": "0x209e1ae54a6ad1819a7fee0c9b923aa9017999e9e7652ac0e9b2f67cc6cc0efd" + }, + "scalarBits": 32, + "scalar": "0xd92ab3b1", + "Q": { + "x": "0x1b5142a6c23c030cef6b4fcc2fc1f5762ffba52e36fab4c64f183096f202de07", + "y": "0x113492e36dfdd96765eb3777451acd57d55867a7d960ad8a5fd0875180a4f406" + } + }, + { + "id": 38, + "P": { + "x": "0x24ce0e10931692b0b8e0edd32ed3afe5155e6d0b3d0be46585a3d75afc6649bd", + "y": "0x1f8ad289dbbab3723fae3308d8e87310a7bf749415c1b8b428d7f6543f74c631" + }, + "scalarBits": 32, + "scalar": "0x72214206", + "Q": { + "x": "0x25736f7fdf34cbeffc93a8e000ef08384b7425c9947ab638caf1d2f18bbbbb14", + "y": "0x1e5faa677943beb9f4d78886ecbf2d799d796182430caa14f051f663086752af" + } + }, + { + "id": 39, + "P": { + "x": "0x90c37ba887ae51975dd3a8dc177ae15bc2aeea4fcffb633ff6f5db5622690c1", + "y": "0x151965fc65c3ec71b2ace47afaf5b0158b6ef5cea13558ff4e91ab908aff25fb" + }, + "scalarBits": 32, + "scalar": "0x3d83d27a", + "Q": { + "x": "0x2b2ef2c7f4dfacd607d56ffed9c1b32bffecfde89433b5837780e537856a0076", + "y": "0x59b9b39af006bb73dcc009cb7d3d0f2deb014f1b9435a1b0db35586676071b5" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_64bit.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_64bit.json new file mode 100644 index 0000000..3ab915d --- /dev/null +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G1_64bit.json @@ -0,0 +1,532 @@ +{ + "curve": "BN254_Snarks", + "group": "G1", + "modulus": "0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47", + "order": "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001", + "cofactor": "0x1", + "form": "short_weierstrass", + "a": "0x0", + "b": "0x3", + "vectors": [ + { + "id": 0, + "P": { + "x": "0x22d3af0f3ee310df7fc1a2a204369ac13eb4a48d969a27fcd2861506b2dc0cd7", + "y": "0x1c994169687886ccd28dd587c29c307fb3cab55d796d73a5be0bbf9aab69912e" + }, + "scalarBits": 64, + "scalar": "0x24ca564f51453708", + "Q": { + "x": "0x240794d8d903e132f2bf995d16c131b43be286632688594d0ec6a30bd5e2ddf2", + "y": "0x14e96e7449b2e12a351fe3e03742d935906f8ee92d3341ebabb5ac79cac3d19b" + } + }, + { + "id": 1, + "P": { + "x": "0x1d66dbc6729e40f891a514160d477811a44b222372cc4ea338228a4bf940cfb3", + "y": "0x2c3455f244035c1744ae59ecbd616033bec67a761aa31efebf86be90d67d5ed0" + }, + "scalarBits": 64, + "scalar": "0x3e7f2024248b281a", + "Q": { + "x": "0x22ecc82eb8ff5b23ad3261d83bb425706cea5593196ca310b26dfc743fbf0f0e", + "y": "0x2451efa866594bce4fb10213cd146ccde61206787cb4e665f03e53f0d834df26" + } + }, + { + "id": 2, + "P": { + "x": "0x2ac1a18ea8ec5bc21fe0ca80f7f29a9b4a236efba653636d03ef9a4130f3764", + "y": "0x279abb6358819077475c312939c62d6dfa5d09f8b88249c0d0cbda9bce08cfbc" + }, + "scalarBits": 64, + "scalar": "0xa55061e47b889f59", + "Q": { + "x": "0x16b6f8132e2cf7b940707e1cfac3cd7e88aa2fefc5b5d2225d1850233307cfef", + "y": "0x206e1f6b120a5d0340509c49de9f2b3f34ff8f4e1cb1d56201173be37db361e2" + } + }, + { + "id": 3, + "P": { + "x": "0x1060d420f86ca046b71875b051575072e4d6a4aeedac31eee34b07dfd87968a1", + "y": "0x54562d49c1ee66d42bc13bfa8fd706236c99af1af18dbd79a76d8861fa5d5d8" + }, + "scalarBits": 64, + "scalar": "0xf2a16f6b0e6f0671", + "Q": { + "x": "0x56d5247ce9e95e09c7e47464d51d2d8880d60d8a29b1fb1af80ee04d79b48ee", + "y": "0x75e947381ce2a25fa31a4292158b7abf1468dbdcb4062efdd13ca84446d747f" + } + }, + { + "id": 4, + "P": { + "x": "0x1e27da3fce81dc2c55e8f87ff9dabccced9746e19855a9438098be6d734f07d1", + "y": "0x43b2562f762dcac0572b0f8df177daff4b3d9f5373534be09107d4059206a24" + }, + "scalarBits": 64, + "scalar": "0xbe3ec1421fdb1354", + "Q": { + "x": "0x1bf8780526bbc1587b4e4c6a73163ebcfe4f112a99bbb20a6174e89b87e36731", + "y": "0x2f4f0fe9a3f267225c7463574460a24845ce4ec8490052571d3cafba0c938777" + } + }, + { + "id": 5, + "P": { + "x": "0x2756aeab0c70d3b8d83e1e884586cd6ece395fe7a6c16f565963e262e0fa458c", + "y": "0x255fe111cea8ea60efa6f41b779ceeaa2bc308b14435b7764df12a19a70f6b69" + }, + "scalarBits": 64, + "scalar": "0x5e5b79d1c1edac90", + "Q": { + "x": "0x2d9c72ca82fe6e3e5a40564023f30012595cde1375bc125e8acc741728eae6c", + "y": "0xbb12a03992bcbc3cf0860d1fe67f9c3066aa058d574ebadaf228fcf1d44a6fa" + } + }, + { + "id": 6, + "P": { + "x": "0x22bbc36ca01f22366759280d6bd83a54d349a533d1a66dc32f72cab8114ab707", + "y": "0x2957da010f522aa39d43ec3285bc4fee7b65cc64a0676fbead5fb77a43fbf263" + }, + "scalarBits": 64, + "scalar": "0xaa271c58933ecf94", + "Q": { + "x": "0x12b24f0fa405ed42d7b54721f20df5d87d27428865c9c0ef74781900577f0d1a", + "y": "0x71820048dbb0e8386fac4c9ef3ce51533d9005c77e207bb7d90b0d31a83b4cf" + } + }, + { + "id": 7, + "P": { + "x": "0x2af1b197d870a263b5d1ce7375c18fd737cbfca18f44313dc9ddb54de269c642", + "y": "0x2453d2b2bc9c05921fedc8e86494a1c118437815e828009edb47ca4927964dff" + }, + "scalarBits": 64, + "scalar": "0x34590d16c007bb", + "Q": { + "x": "0x15357e254bdbf62e9ce96ccda71438b6fbce824283720b384f5d6ede02dd8a9d", + "y": "0x1b6ec5daf3dc8bd3c9b5f176f9a583da47f6c9f89e8936311b0bcafa76f7d549" + } + }, + { + "id": 8, + "P": { + "x": "0xe244a7c902ba6140660c431a56811b53de01d043e924711bd341e5309cefdb0", + "y": "0x2d8ee46b7fc569f66c3a52af122d183cdb8a446610ec5ed2588fdfc4b933e2e1" + }, + "scalarBits": 64, + "scalar": "0x9a5f1c68c1bfec77", + "Q": { + "x": "0x2e784c7c268a4b23f80d9aa888c4a9d3ee941ce4dc5c6ab414cdb491f3fd60c1", + "y": "0x2eae5f66d56f30001be0262e4635239999a58c3cc5069a0e968b06c0c87a6b0d" + } + }, + { + "id": 9, + "P": { + "x": "0xd2f09ceaa2638b7ac3d7d4aa9eff7a12e93dc85db0f9676e5f19fb86d6273e9", + "y": "0x239aa3ef69785d1b31055ca0c647ec1a429dd3653228eb496e6b0de121b7a0a9" + }, + "scalarBits": 64, + "scalar": "0xd79eb280e2f9d32a", + "Q": { + "x": "0xca5fd5113cf6eeb17aad43e9264ada6c01e251d7fdd822fcebd53332013ef33", + "y": "0x1c5e48ee75393316a6fde8cc122619dbcc4cb4407b961a42abff23bfc72eab58" + } + }, + { + "id": 10, + "P": { + "x": "0x8a36f7fbaa567b1fae19f829a8126f41a71fb40d1266aaf8c7842ed44223ed5", + "y": "0x301c871c4da0879693f1f65c28c42be08edd19963452b8bb95f833c2426c2f91" + }, + "scalarBits": 64, + "scalar": "0x8d798c1285f974ed", + "Q": { + "x": "0x18f52d92650797c7bc768a213f7d0fae3ec262f1f3c9383bc03324db93dfcc40", + "y": "0x2951d5049402e1377572cbf8a328b7edab46be6438870daa280696b495d37681" + } + }, + { + "id": 11, + "P": { + "x": "0xdfb86f60c1d788fcaee5579e5c96f1ca7b206862c2cf3ce21d79182d58b1400", + "y": "0xa8da4ffe0e48c2d076f7b2f83f091ad43e1b85433d249dad57ebcf2ed7458a" + }, + "scalarBits": 64, + "scalar": "0x3226fa84e7905b0", + "Q": { + "x": "0xf7ba8d3f352f9b3b92e323aa6387206af06c96ee6655ebd1927af12b14dfd24", + "y": "0x261efc3045aade49d0507a9d66a0d1b36a550bc4c8b8fd0413ff09ce1e9b85f" + } + }, + { + "id": 12, + "P": { + "x": "0x2125d9ee822bef35fa4243045ad02aea93f275c60e9f838d6a933e9ad5732235", + "y": "0xf0491c4f529f6542b17484722a8f46efb1d9f9494a87ee543f3db0f0ac7a206" + }, + "scalarBits": 64, + "scalar": "0xa0cb13ae35b8215b", + "Q": { + "x": "0x244b0aa3a509b508d3e6db6ab2609ac1c605f6930717dc04db1ae83af3147534", + "y": "0x100ad727a600b90f0bdd80b1b50a746314cc3cf01dc35b2cd81b751728ef2f70" + } + }, + { + "id": 13, + "P": { + "x": "0x2e4fdcbb172c413782db489f5d7b4dfcdee061c78e28d668a26add87007ab0d1", + "y": "0xcc0bcc48e4acee5f5146365bc3cb3a286a47a6ad46ea2ea05dde1829e722f7" + }, + "scalarBits": 64, + "scalar": "0x4d0c2d0e21368a72", + "Q": { + "x": "0x465ab2d4e47ccbdec07dd2b1afdfb26ca489dde0078589c6d1682ed032ee71f", + "y": "0x1366b2e1ca8ae480ee0e0c05238b303b17aff52140597848e774c5fd661fe073" + } + }, + { + "id": 14, + "P": { + "x": "0x27adf5edf44ed1c4357fa71695ad59299d4404c55a295d648cde827a7b42b838", + "y": "0x27682da5524a605d04ea7f14b821670c1e0cf595bf961325c49322f8324bfa86" + }, + "scalarBits": 64, + "scalar": "0x50a2cc84b8bc13dd", + "Q": { + "x": "0x2675714f6c0d7585b63b8802467995b96211f171bc13aae7c9f184214b8f194c", + "y": "0x1b6dfe4dff2c3d8cbd1f07ff8c0508e2ea88429da6100f6a7d86f88ea53e8376" + } + }, + { + "id": 15, + "P": { + "x": "0x2c406a6f67ab0b74e786b22b72db20a18aec217d0544ade1e1c95682ece911f4", + "y": "0x1f325ef6a5f1c4c2b5e3b714a679b252f961e293f65bf6088916fbdda507ed54" + }, + "scalarBits": 64, + "scalar": "0x99d5cc23a9153abd", + "Q": { + "x": "0x226e256e44c8683f9bfa076bb418b042b0cf9c4b63a51f54fc224b70caecaaf0", + "y": "0xf263e0b39d42561372204701f856d2465f3ea17fe847a5d5a9bba3247b3903d" + } + }, + { + "id": 16, + "P": { + "x": "0xb5093b1205cc62599b1cff4c7ceaaacc6f1df842689ac863edf4d6b8b8026e9", + "y": "0x2e630c7ab33cc7456a8547ec0979d2984acfffc25d64a90df4959c01f6a48c9c" + }, + "scalarBits": 64, + "scalar": "0x431282834c348d92", + "Q": { + "x": "0x255c784f373f1266a7dc1ae86efc148dbaea6dc318326468f0e361cc3cf25256", + "y": "0x11cd3512f96c911416cf124a01fbe8346355351e09f803e830cf9943097fc923" + } + }, + { + "id": 17, + "P": { + "x": "0x7fa34316613599b024e0c033bc05ff693ec906cdcd2415acca073eaae81ea2", + "y": "0x1cc15f05a347496256b31d95076769b06fa9f6fd2f141341606ba0b10dc1246c" + }, + "scalarBits": 64, + "scalar": "0x7f51ef5c90fe3346", + "Q": { + "x": "0x17a21052ad6acad19b4f0ffe24d4e3edaa4a34e5072e195f214334c9d784ba9c", + "y": "0x22266886e90473815f1fcefbe0fee6b6be7bb1253e8daedde643245263137b9f" + } + }, + { + "id": 18, + "P": { + "x": "0x24c5b2ce21615dca82231f5fb0fc8d05aa07c6df4bb5aa7c2381ac7b61a6290c", + "y": "0x23608f84f3340bb790efbcd2e04c3a09fcf92cb11fcac0634fa93a90e469a97e" + }, + "scalarBits": 64, + "scalar": "0x713c953eafd6ca20", + "Q": { + "x": "0x24fee1d0f6f6eb7c24bbbf2f704d9725f49cbc55cfb8ee10e43ea8bfa5b7b0e", + "y": "0x3047e72bf49c7c3356bffa2332d2327cba9c37143eced0b60db55804454d340a" + } + }, + { + "id": 19, + "P": { + "x": "0x70968a6717e3f6779292dd1269ae705392961c26657edebd560350298f9138b", + "y": "0x244db8d8b08606616a5185bd1269983fd969104a963d53c11903a81dc9414c00" + }, + "scalarBits": 64, + "scalar": "0xf68a65f70e34724f", + "Q": { + "x": "0x100c096e3346aec1561cf2aa146c831114f41856ce2b78f433ff6222082e961", + "y": "0x2991b3b6c7ed5f130149e2d429a5f62f6d468553f9b6dc36b9477de049618ffc" + } + }, + { + "id": 20, + "P": { + "x": "0x1471f378000d557f0c33c1f8c8313edd53422479440cbd0fdc4cc55f1163deec", + "y": "0x872330f81b91ab92b8391d32586df7986474d6c32c928c56f78ff4d8237926e" + }, + "scalarBits": 64, + "scalar": "0x21bff46eb03714d9", + "Q": { + "x": "0x198667da25285ce05a19ad9efb2e832f08bae556f2195f9e639220eb3016f112", + "y": "0x204a8efd35140c31f9a847c4aa028bb492275daa0e962ba9ac43cbf529fd8ee1" + } + }, + { + "id": 21, + "P": { + "x": "0x9085a7634b5a25f479b4daaa05a0b253391de46a38bb640c822a7d2deff7cfa", + "y": "0x1d0ddadec7b50770ec142809b43dcfda7c1f8c7f3845584b495067c0da1ce32f" + }, + "scalarBits": 64, + "scalar": "0xdf0699b6b6531f32", + "Q": { + "x": "0x1c5221f2af7136678ecec5e4396be1c249c2ba6f397f56e10501dec5a6f37ed7", + "y": "0xa35b5a7e2a2676c79616429a80d9d6810ced9528f5114765fba0d8fe59ad837" + } + }, + { + "id": 22, + "P": { + "x": "0xdef8fb2d5cc946b3bc90b1a182dd6c8b24d1637b5f515f764317fb2ca9a7385", + "y": "0x769eddfa757ea9732d9e9589d44b930749ace41a2208c634448d85fcb3b3ed2" + }, + "scalarBits": 64, + "scalar": "0xfb01317874bc8841", + "Q": { + "x": "0xe00503ce0993b07d8a376ab4372b991e3b8ca49ccaf6e5f58d46a1b874c45b3", + "y": "0x20572bcbdedd6deda7623aeb59a6f94407ec8a6f9f65cb4984238787a9caf582" + } + }, + { + "id": 23, + "P": { + "x": "0x22a178cc5c0847579ae8bd3c63f5321c4beca1867c0cc48c3dd8ea5346545fff", + "y": "0x82062ba4cad78411aba105d3a7227b06b1e781db1ea009c8ad8b781fcf3a037" + }, + "scalarBits": 64, + "scalar": "0x3b992d52258e687f", + "Q": { + "x": "0x26cf598325ebaaeb44b4018a803f5a70b5458fdff1c8a2292c83e04d134d0f62", + "y": "0x2aeade160d2f21f43d71e57aee6404749ac582bee474db0c05ba164466640475" + } + }, + { + "id": 24, + "P": { + "x": "0xa751a8afd74e72e750d59b5ef93a5e59f064513511551850da61675d2540bcc", + "y": "0x28bf9388add40bb7d74cb47c110046bce328424c94857be729dbf6b2f5ddab29" + }, + "scalarBits": 64, + "scalar": "0x93e7ed71b30a063b", + "Q": { + "x": "0x238f8f03db3c719fe1cb3e3a55a2b8fb942ceafda7f5419ee5215e6d2897b735", + "y": "0x17b73ac3ce11ecee90182c098948fafe0ecfb8e39e1060f824ead06ccdcc8f0a" + } + }, + { + "id": 25, + "P": { + "x": "0xf842f6e4a877e80f4f4c4627163d414b091f5d31e5bc1e6354390a0f07abf7f", + "y": "0x1c11e20a584a0e9cac0340e8d5b295fac1ad86b3c155e922a89ece33ed1c3d63" + }, + "scalarBits": 64, + "scalar": "0x7c65383e42c5baac", + "Q": { + "x": "0x192a8c449baeffd05dae8683baa6644fa322d09912eab7ab137951b81d9cf537", + "y": "0x1b29d6344f60ff05e6ab1f2137ba77356dc0fb928fb5ebd4f7db6c51c4c8bec3" + } + }, + { + "id": 26, + "P": { + "x": "0xaf79a721359981121eef7062fea71a426b43a8d0894de8263787a26c6a2afda", + "y": "0x20799bb0899f544e34a32d784b4c266b51cc8902e0dc1b18eb7fc7166c36022a" + }, + "scalarBits": 64, + "scalar": "0x3cb602604a06c597", + "Q": { + "x": "0x2345f359095342e8e436270eba350a31b61ae0f5b497864edf7d9f72f37f3b21", + "y": "0x2e88f36cfb2f60edea77c871394d8189f60ebdb241ef3c7ede22f00e2f91dc55" + } + }, + { + "id": 27, + "P": { + "x": "0x286a9ea8b5a65fa0d570635ffca925abcc52a476e602b93c43b1c2b6da1bd2e3", + "y": "0x865c92875f7f4427c004871b43c10c57961062c6758674c6161e03519cf50ec" + }, + "scalarBits": 64, + "scalar": "0x76d2adc2f4b9b9e7", + "Q": { + "x": "0x4aff10126bcba38d92b1eb9341cbe4129d26d27ee0dd53c3eafdb56e937e327", + "y": "0x9f1504ed149e10518db2ae6a0ff52e9283690e81760ba3dd6be9f1b38045f19" + } + }, + { + "id": 28, + "P": { + "x": "0xcc61abb072d85c12e06f87a1c622e509fc8499db75ae19842f14dc8274af3e9", + "y": "0x11a114ff612261feabcfe04701499657fafa0d56adac0881635ac0706d9b65f7" + }, + "scalarBits": 64, + "scalar": "0xa740725b161f5a27", + "Q": { + "x": "0x953b64afdc7b9223a5104cc7ff9688510bc951ac902d7faa236e890ecb40a0c", + "y": "0x5d2504ee83227f5302e2c735b2543375c1cc238ab8532753c5e6dfcb20eb5b9" + } + }, + { + "id": 29, + "P": { + "x": "0xc5b424b509b880c30d67d204602f670518c6f2ee3f7cd688a4f08d9a77512dd", + "y": "0x3c75107681d6aaf03207ed6fd66e06da32da8a58016c10a4698f695c28fe94d" + }, + "scalarBits": 64, + "scalar": "0xebc67326fa772017", + "Q": { + "x": "0xf4db4c2bf5663a0bcafd0b5c1a9df468871211f8eb19b6e2123e5f9065ac126", + "y": "0x59a0131678964ff8db1956cef40d7a193c8d20cb8f7e36197358f0c1b915e6c" + } + }, + { + "id": 30, + "P": { + "x": "0x2d4966231107d5473ac5275b0d2335c8121f557dbf285d1e1290c7cf2921647f", + "y": "0xdf11168f5671e956af1a0f094246eeda1db4be50fe7a01b9ca36912b3d92fa" + }, + "scalarBits": 64, + "scalar": "0x3d0be46585a3d75a", + "Q": { + "x": "0x45f1a172b36b547b4abca18911aa35fee88b2882545eec1ae8888d075217500", + "y": "0x105376d25ae12ebbbe9f422712bcba9c55d8086c17c8fb76deac0cdfb6160c61" + } + }, + { + "id": 31, + "P": { + "x": "0x90c37ba887ae51975dd3a8dc177ae15bc2aeea4fcffb633ff6f5db5622690c1", + "y": "0x1b4ae8767b6db3b805a3613b868ba8480c1274c2c73c718ded8ee0864d7dd74c" + }, + "scalarBits": 64, + "scalar": "0xd5115a26d9adb55c", + "Q": { + "x": "0x136fd198ca8ba76f541c7d8af7cdabc4deb2c82ce394b34a37c9b163f6c5e911", + "y": "0x26cb30a96bcb0e5c1e98c566a1f91d2494f494369a4f524dbf5c8b41004c4b07" + } + }, + { + "id": 32, + "P": { + "x": "0x1faa5f27c86a6db61b89044aacbed1811fb7bfc232441a4fe737dc1d3a797fe3", + "y": "0x31763183a76ad8ba9dcf03985486440f490f64c65bc5abc98b96f55d40d7eec" + }, + "scalarBits": 64, + "scalar": "0x7df8329a10aa4b12", + "Q": { + "x": "0x198c558f7549f39dd05d28280618d161aafb9fdf4f96596852a1bae44ba189be", + "y": "0x602d3d2292e33dc80b7114b232af4471bb693cff8f2e2077e1b3e3c428a40f0" + } + }, + { + "id": 33, + "P": { + "x": "0xc61352535554f6bcf20978dfb0999ed71bb434f8086f467269ec82c3e3a5387", + "y": "0x127cf6ba97e2383d7a2376faa6d9a43a0ff2bbf687f4966a0d7eb1292fa87db4" + }, + "scalarBits": 64, + "scalar": "0x554cc7dd85268585", + "Q": { + "x": "0x27e037f5995e1ad0202439d2b7ca96d513fcbacedbdafe8ead2ec3c6ca72e8cd", + "y": "0x5b6dae29096088a4ac8d2e4bdca41527cbf9df3a4d193553409c6a17f2bc908" + } + }, + { + "id": 34, + "P": { + "x": "0x1fb18f729f6462ff7e8a2c83ab637ccfa423f00591123fbf84ebec990969b99e", + "y": "0x295ec58e89bf0faf7e2862ce46064faff22843eadfb2ac9141df23ad491c2a4f" + }, + "scalarBits": 64, + "scalar": "0xb91cb825b46ad015", + "Q": { + "x": "0x1b425b453400fac0f3b4a34277f1b2c645e71cfc62831cf402366d146ace0bfa", + "y": "0x2555dc5031c002a38fd1912f056252bc359134a39e40af24ea3a1d6a46ac61f0" + } + }, + { + "id": 35, + "P": { + "x": "0x205b054ddc5836f0ba51bf862b70ad57b005f9c8a4a7fcfbd451c8d34993e2da", + "y": "0x29092ff35c71182d7de9b308e6a28c2d47688173da4ef715db9cdf6ba9fc4a09" + }, + "scalarBits": 64, + "scalar": "0x204bc2907b42045f", + "Q": { + "x": "0xcd9f88cf94b1c04f0a781a7ccb7d8158b64c9aa656f077340771be7a1a3e761", + "y": "0x2c0d04c7418968c0d32996be33ccf515e879bd7f0af9a476b4f59eb3798ebea1" + } + }, + { + "id": 36, + "P": { + "x": "0x1ef8341f82f694e040910e68a54baac4a378d52cfee4aa7335550e8d68ad1c6e", + "y": "0x7a314c51e78fbe5e82d1745af480d4f34d60423a284de5c85fdab64036c5f29" + }, + "scalarBits": 64, + "scalar": "0x57f8e3afb56b61de", + "Q": { + "x": "0x12b7f5d85f5921c92b7a26e5977f326ee76d8d2e52f0ad2d080b184cec1030dc", + "y": "0x1cfa641459bc4ca54f4cd05e6ad1fcdc03ff56ed2515e5e2a263584b907b50f0" + } + }, + { + "id": 37, + "P": { + "x": "0x26a39d37941f65940d4911a8940c47c1f95137a190994efc75d99f648a43448f", + "y": "0x2229169a2a06c22ccf2e11bf981fc596f3b566d0c9f08cfd081da4b8420cca26" + }, + "scalarBits": 64, + "scalar": "0xb8c782b99f34db55", + "Q": { + "x": "0x1640616462c70264b59795192c273712354da36d7005ab0a596e8907d0db6189", + "y": "0x5abdb8e5da4e9ea22bec2372f566821057a665cd775f9a1c6d9bad7f162264f" + } + }, + { + "id": 38, + "P": { + "x": "0xd15ffbf358545c6c936c6ccd08c0a6d6b2fbfe1ad2c5d76ef633376cd4a0989", + "y": "0x14ea99d359e35a3c149f626d53d8c57d5c35dbd0739e023c7f5f33e4eecae6a7" + }, + "scalarBits": 64, + "scalar": "0xe6aa061e256705e8", + "Q": { + "x": "0x21f4b30456e8828bd2ef9f5fe7e13e249ffe180908a3c40204698525db3fa700", + "y": "0x10f43d61e8338041081f0950cfda35bb5c95ad4e256a0da0bd85e2e8c3372771" + } + }, + { + "id": 39, + "P": { + "x": "0x1ac540fbf66d7e53525577620ac8049000ba2771d604034ce96bc2615c31cca1", + "y": "0x2c28e5a6826cff2aea43d41ca85ea6e827dfb947232b15214618584e95fa969a" + }, + "scalarBits": 64, + "scalar": "0x8aae833390a5bfee", + "Q": { + "x": "0x2baffe56efcbc120ca450238763eccad5f4f731f422c6c8944e23ae235fe841", + "y": "0x281d381882ba6d13e95b16e59fe4880eb45062f2d0011f902f8fe3899ba130d2" + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_128bit.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_128bit.json new file mode 100644 index 0000000..36d5541 --- /dev/null +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_128bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BN254_Snarks", + "group": "G2", + "modulus": "0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47", + "order": "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001", + "cofactor": "0x30644e72e131a029b85045b68181585e06ceecda572a2489345f2299c0f9fa8d", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "D_Twist", + "non_residue_fp": -1, + "G2_field": "Fp2", + "non_residue_twist": [ + 9, + 1 + ], + "a": "0x0", + "b": "0x3", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0x1625bf258f7f7be15ee438ab65c97393391fb36133cbb17c44c98efad3b04f06", + "c1": "0x25e9e71cbbb71cc1720d0102a7015f1224469a5e45c80017f4c212f34134294a" + }, + "y": { + "c0": "0x7cfda5f906b107ff2477779f0d03d4795049df8125d8131316ab2bbe12acf87", + "c1": "0x11f787a6cfa5113a8071d6e502b0644a8884b353d6a93b843e21b6d6803d42e0" + } + }, + "scalarBits": 128, + "scalar": "0x8957d6fb7a7a2c609e20d65d455251e", + "Q": { + "x": { + "c0": "0x276c7773e00ee5e77a5197f139587046cb300791abbb087d2a93983c626ccb89", + "c1": "0x8909b20cd59f121520e321711b43845ce8a3b88bb8ac5bbf63f349db932c41e" + }, + "y": { + "c0": "0x71037c5f3b0dc1d2308a8f0699f6af47fb2b91a31d4fcbc685de9aed8919529", + "c1": "0x17d0ccd9560e7ec5dc17a4569c0aeaf260be8181eedd83e41391361eba1ae16e" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0x1c562a466724b6771102e05ffedf27a62f3006eb2fa54bea6b9166f0df016e61", + "c1": "0x2fc7a19ac7a9e824ce08d3583c109ef9d4042bc7e6a67b55e86d9a6c4d5f7c33" + }, + "y": { + "c0": "0x28aa296f946c2afcc54ef55965f3e3ab9999bba15941779f6e8b427ee9b28f16", + "c1": "0x9702297d08c5b033895c3e052917373b00f51cc0d43809aa6254d0e4b39b08" + } + }, + "scalarBits": 128, + "scalar": "0x91f091d089fadf8346fd0698c759173a", + "Q": { + "x": { + "c0": "0xe0b9d879dc7c8b3de42cb2c5ce262d7af76ae264b6879822ee5806784954b8e", + "c1": "0xd30daa0ccbbb0ec31ebe5715b52c36bad8a29f50555f892ff13235cc2c47584" + }, + "y": { + "c0": "0x15a215ddcc9ec9e8caf93a3d8ae0e33c9ac4d6a7c38c4d9cabcbf36b8f38490c", + "c1": "0x232bd787edb76a16ad9dd9c9a3947dda3e0b5b081116c3613ac1d8049317ddf7" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x3df5cd766f60f7e4ebaae1abf21e6df622473a2dc50d6632765266512597d8", + "c1": "0x1b985067020d0ffc6daf11587d84d2b5c94fd0d9b90c3f87c357e0d2da8625a3" + }, + "y": { + "c0": "0x95da468e0d49d24a9c5d25fe545fdcae4661a0084da3ab7677b5f8a0a18ef88", + "c1": "0x1aefd4ce6017d776ca3d5a5d826fadf7186a1292776ff0ec74c72e5e23555431" + } + }, + "scalarBits": 128, + "scalar": "0x1ba67b6d984298c6da6c6d52a47c357d", + "Q": { + "x": { + "c0": "0x1411bc72dcdad40183f514675620f1ac6b6645f452e3db49437a6a01eacbcb11", + "c1": "0x10e938ca621866580ce40c2721308988c1b68721be80b37249a7fb24b7ccb734" + }, + "y": { + "c0": "0x2b1c92591a9eb3677c858c0fd34216d043678877b7d7871a64bccc9590f1d1df", + "c1": "0x3fd80e0ef94ce6ac0fb4e5de630fb83acea5e5acb9d86ec8f9198b171d12717" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x260c0d9324a9b7acd99eec1ca956e30a9c866b07061cc040d472a79513192589", + "c1": "0x4a7a02243910911b2b0168cafa80c9ffbd1433c19946b1c3e5ce47af12addf6" + }, + "y": { + "c0": "0x23328ce91af56a02c252ac25a90278b81275b2010027a47bed2d0ea2049df59a", + "c1": "0xb87640ec62d70ea0409c1b4ddced221ef8c54a02598783027670cdd85b02cdc" + } + }, + "scalarBits": 128, + "scalar": "0x234a599fdc7c99f1ea4c774702986add", + "Q": { + "x": { + "c0": "0x598ece3b2057239f7a0dfeeb344b90c1e720f74766e65223ffd46fded5a0d41", + "c1": "0x30add2f162e761e9850c3c5c422db275ecfc79470d72d853cf589dbff1f51ad" + }, + "y": { + "c0": "0x11a351fcf68524726b9c0b94a1e7d8baa31bd5472424f5f33cd44e7cdd40559f", + "c1": "0xc875f3b89e562bc561ff898516f084e5294fb8397785cc46b1384e7d56b0264" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x1c5327f3efb5881ada131c1f15458c96383def135df0bb5218d56c740f1e5d8b", + "c1": "0x2c529b3c9fb133eef8291aec8860a1800c8f9a9d4edb1c54f0b204e010a165c6" + }, + "y": { + "c0": "0x2148b109f9634ee9e2e733e394870db42294810f121116180006d428e845d4be", + "c1": "0xd4aaa1f9ac5d232a42fb19fb93208f6db48650aaf9be7e9fbc3b97cf6e2d9c7" + } + }, + "scalarBits": 128, + "scalar": "0xac06cc9604a1aa59cfbcad4c4c6a196", + "Q": { + "x": { + "c0": "0x1b74d598a6d27098dd92755b707794444bb76e679cd7ec519ea431fad890ae35", + "c1": "0x193c55f9adb6874b5d248b6df66f03a8fd55c9d1f9973a840440585450b2e709" + }, + "y": { + "c0": "0x29aafd5217045df94a7ee742a8150d2c8c0b5e822246b2d17b9b3901eccf35fc", + "c1": "0x38086f2e50f0b3eb9f0b2448715b9c1015a699be82b9d8714b5a7ded07057dd" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0x3419bb812ba4173bdfbb2c5af70eee5b2cc6cf5311fd31843b1f9f7d479e891", + "c1": "0x22352661ee2082d61ea24a0a0a912ce554ec88deb6dea6181d121f3f0f7f709e" + }, + "y": { + "c0": "0x1d6d21485dddf8cfe03384690513a272913062ea460652c2373fdb6a4827a428", + "c1": "0x22bc03cf16562d578b0032986ee225d931bed5fb75b3b84f3c70e15d91b13e0" + } + }, + "scalarBits": 128, + "scalar": "0x497a4a0b469c800682a838c10d954fa1", + "Q": { + "x": { + "c0": "0x19508d5e49191621e0320324f0d47acef7409705431b19ef970ff2d488428be5", + "c1": "0x266146b4995792ca22a80cbd3040748f95dc9c8ec4444ad0fa36758a02f5da76" + }, + "y": { + "c0": "0x28e18363e34a5ae910af6454df7c071a44405799193173ded09a0f762aca75e2", + "c1": "0x2f7c4cc7875d086ab4630de3b0021da373dedaaefbb1db4a1904f8b6e80626bd" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x21148bf49f36d6a0b688e8e182e23618de5dba4da3a33b46234d335398c0fa26", + "c1": "0x16efcc88d5c35644d24ca75f4d1387e17a2539cdded78c7c04b04ceddf58084c" + }, + "y": { + "c0": "0x172edfbe1b3cbb5e44ee25d2c50df3f68e2d75ecfb33d1aabf85bd9cfe672f58", + "c1": "0x6a194272a11a79057c9f27a29aa91d28e8aa88766878a79b9ec30ccfb5450fb" + } + }, + "scalarBits": 128, + "scalar": "0x138853591429046fbe00b5c8dedd665e", + "Q": { + "x": { + "c0": "0xcfde85e2e20b72c41e748ae677b561c1f2151f023cc75e63c908daadebf155e", + "c1": "0x48ef578a734707a7c6741e915a9e582e9b6d2d1675ee80ac4647785cd6f439" + }, + "y": { + "c0": "0x8e941ff9522ae7aa1c038011f7e028e284566187998af02f939c6614cb066bf", + "c1": "0xd60381ee4dd65c8e205ff8534dc1fc3d4f9b89c61d7f742127bf6323f3e9a3e" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x209301042d16c71355873072a5a0dc26b60456e0ae54cd7d1c109661b9adca28", + "c1": "0x118a21c816db871e0b5b566da61a02ca375dc201024f30dac2c2288826d623c6" + }, + "y": { + "c0": "0xcbe693ff8e8811dafd8ebbc96cbb102b42bdd9f6501720f981fc9595ce066c9", + "c1": "0xc3fe9d44af252e57bf552d0347f5851a8f4b4f38031162c852811ef2e0df3b" + } + }, + "scalarBits": 128, + "scalar": "0xf2e6de84a571734ed221a012070ec2e0", + "Q": { + "x": { + "c0": "0xd816cc288b1041907939dbf7633af0431ead26dce09a41dfa28fd7d7e6da37e", + "c1": "0x67f7da44a2fa20cf37da50aba2154ebaa451af588ef2b8b735e2b7796565a7" + }, + "y": { + "c0": "0x1b04f849f48c97150ee4c2c4a11984ebb53214b724c525a4b3ad371bc7974fdf", + "c1": "0xae688b4e2829dc7ed3cea83a1d89b69d8448195bd77af28b7cbebf8a5bff742" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0x1a43386b3cf6ab6892e6a544deebed91c81745a3935396cb94468d6f3edd95ce", + "c1": "0x3047ba2238108454266cd98d1793de1d6cbecee29f668e649d4ea3cf7de0722d" + }, + "y": { + "c0": "0x23f8b0e79e19b06d1fc6afdd8c6d1c8ebbbf6735d2f1754686c9118f9879028a", + "c1": "0x5f898a68baa8661961cfb69984154d1d64ed156226508081fe41befcc61073b" + } + }, + "scalarBits": 128, + "scalar": "0x22f94dfbc29a1046d41108cb10e42e88", + "Q": { + "x": { + "c0": "0x82bce081bf9c5831d8a8ed9e04dcb604181576b327fb3d15aadeda61bfa0bb5", + "c1": "0x24d193a2b68f6f864e5fbaf60d1548a771eda03b2e1a8ffa96dfd0ad79348888" + }, + "y": { + "c0": "0x93a547d701e4e86198aac6b11bd66aeb48264f75e0391e7f32556764ecdf3c6", + "c1": "0x3758b9821c1a1fa9adc581aafeba9c6defd9a2ae027d9c363f7a5407bad8e80" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0x19417ec57e3c87a9b80feff36c9ad4fe948e5fbd31b81e8779275973bc7b15fa", + "c1": "0x18f8d68f4aff9d440542b310d603b9e8248eb41caf8e505b2107550c82fcbe66" + }, + "y": { + "c0": "0x2c0d0421b94c0fcce92791d20c4e957749f94f3b58d7866ee4427849a61ed3b5", + "c1": "0x210dc53b78d2b06ffa981a3c2db13291decac19f05d6350c605cda4edeb8665f" + } + }, + "scalarBits": 128, + "scalar": "0x8c4e45a58ebad4472dbecd3878894f4", + "Q": { + "x": { + "c0": "0x2deaae0a586f68ee4e5983145e65b51e15ccd4a7c539bf11cd8b4de25e113cc4", + "c1": "0x1db49a5342198d9cb49cc6c40857f6301ac585a979d74ab569f7ebb283467168" + }, + "y": { + "c0": "0x261e27c58ecb04966a8a1d3d374eda8e094141cb92ec65212071d829c5ee7172", + "c1": "0x1cd4b43c2e6cbb06243319a93142a66027f10fe4181a437ad71e6a552b5bcafc" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0x27805b89f1ba34c395e7e3729748cb627ae2e77ff4b44389eadf55b3e9e8262d", + "c1": "0x1a4573cc30e210c837ae2793299cea99c621fd71e07f6401b114f280ded97135" + }, + "y": { + "c0": "0x2999a458d1569fd2b2d8f9363ab92fa57c1a90319b37de3eb5feeccbb16aad74", + "c1": "0x2932e9583f86826b905cf3a9ef916ff200bafa012f2cca2d60b63f03e14eee66" + } + }, + "scalarBits": 128, + "scalar": "0x393974556a30d52d9c189b839ea9a434", + "Q": { + "x": { + "c0": "0x4219861e2060513c58d50b258ff1cd73243f216c6f631c962eda1db9295e029", + "c1": "0x242bb738b99545be3f588d6535f9f2329258d585ccea8ab8b57708c94b221bc1" + }, + "y": { + "c0": "0x26d410e7e790bd08ebdb6f3e6778ed3fe775ac08d73a1dcef7ba2d690150d06e", + "c1": "0x1b54459ebcc238084bc3a11391b3d96ad29fd2c3b7aeac72af971d57b58365d9" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0xdd12e7fcd0c1e155b365799de489d34fbdf9552c20ab6b3f2600b45aa5d63d9", + "c1": "0x1812c0a5506ad7af5b08bcfa0405e8cd01b58c6138becbb05ce0bf5fb2bec3f4" + }, + "y": { + "c0": "0x23dd60166c7c0682cb9e5ea5b36c89f2fbab2965c7367e4b5b23803cc443edf9", + "c1": "0xeccf60fcdb9ba983afd1f5c898401cb2e9a8e8fa71beeb7e3028f20ffa534c3" + } + }, + "scalarBits": 128, + "scalar": "0xb002f42a5293a234ca9dd9b27afa5b7e", + "Q": { + "x": { + "c0": "0xe3bbc13abb36b402b01f700e2585b9a472197733c9ba222143900a912dfccd", + "c1": "0x18682fe6408a667cfda4a01acfd9471c7dbbebeb2419f3610581ea7f0e85b2a5" + }, + "y": { + "c0": "0x1ed60a91b75222eb25b25740979af8f3c5df57a8aeea864d9aea02815b933af", + "c1": "0x1dd4c24fd9a6d14b3e1cb562cd3f4b67f38bb437a97ca2ef6c3d68a415f06ad6" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0x123a9e5f7f1b4560ebfaea9ff80a52ad85537b8d2236d93a99b83988973582c4", + "c1": "0x294effe8aaaed89d7bdbb941d5fd2724f032498f53c0892fafc59b724e73156b" + }, + "y": { + "c0": "0x11bc1f2fe428dc8fee92713a9695e69af892c6c6f076e454f645301be21304a9", + "c1": "0x204a8d32d9ebb50ea7bf563638598c0b278aecb252e13fb4fd430af03ea0556b" + } + }, + "scalarBits": 128, + "scalar": "0x851c6af6e675312046952fa551571dea", + "Q": { + "x": { + "c0": "0x765b2f123f9f10f60e6935cad49e44d20931f4be5e2c353821769a81aa1a3d1", + "c1": "0x187c8304c4a01d8ebb460df1358cd81deffd5e1640a6614c8986b5fa23f430d7" + }, + "y": { + "c0": "0x22789d6debaf578236d67fbeb254bde2576f53e20a3a62d889b9499df35c7dd8", + "c1": "0xb427d561fee05dce4d4086c249db013c1ec618f6686e1ffd3f40a3d0d3414d5" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0x2a61b5d45e7f2f414c7167d059da5b4ef99c0aa04edbcf85b4e0bafee1bb5e5f", + "c1": "0x4a0bbef9f0cbf64b5001906eb5ae03dcf314782a188b5e157de0b0858d054a0" + }, + "y": { + "c0": "0x1a951e4bcae3e134e8b4fc4a22f310d0eb7e569d143f9297c909bf2be81479f1", + "c1": "0x1875a7dc6a5edd596924a1895613d7422af2b88f6171ab23064925da8c5c948" + } + }, + "scalarBits": 128, + "scalar": "0x2b1f55459de0ee6bfd888db5d02e7b23", + "Q": { + "x": { + "c0": "0x2ec0bc2621b78d0e118a42fcd4b198e068fa1aa86cac99d39c76bfcf49ed3b1", + "c1": "0x1e2f306a0d6a50b15d768005a1f9c04ad969faf37eb6c6464c349d245976f9a1" + }, + "y": { + "c0": "0x958c0866996d0a721dc1013416eb7e4d20c1d4f0ded37c6f36e7fb338fbf1a2", + "c1": "0x1df9147d808c1ea3912aed47844bfb9f85af2c0b5b986b37f6651eb930f748da" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0x12adcb3a6f9935bd7c0e1a839dcbc20f80fdd2a326cc33811e7f5554d170cc28", + "c1": "0x229afa1c35acf4f66b9e33dc7ad178db68af4d4b56022111ae759cb6689c2f92" + }, + "y": { + "c0": "0xbcf5f114aed8dfd5a0160dd65da0934f52dbb8127450a84a05562bc37c7288f", + "c1": "0x1b86fd913aa9e627f67240611e25337141e3ce7a8798d55eb76bbb3bb4a3494d" + } + }, + "scalarBits": 128, + "scalar": "0x1a43c56e4b5c88ce9c0e2dc5f4ed3002", + "Q": { + "x": { + "c0": "0x2cd944da989c9f4ccf3bdbf59df571ce74607783e0e5fcaa3dc64341103e690c", + "c1": "0x65fe0ca9d0d62d61a29c287e4b334b6ffcb290175d19b08775dc3def09cd988" + }, + "y": { + "c0": "0x26e80f91b7489b8b7fe5d222e0d7ffc1eb233106606dc0f2d2e7e078d5b75667", + "c1": "0x1af58b27e563f81417abe42e9b7dbcb65889f9a2816c1474e0f179acd7ba6d5a" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x6cd6b1bdf678ee7252a9094ded5496ab491093bb0dcde2267129eeb2620bfee", + "c1": "0x1617ac4b7298e441a35b8a9b22bb3ed939fc3773c202dfe0e60c4b282df052ee" + }, + "y": { + "c0": "0x2e0b4a569525b5d3b69297ff1394f47f54cfb6719226acc5e708baf97de9c5e7", + "c1": "0x14067291b5a76016459f357af4db233f06dcd6c4ed58827e25522841a1636b7f" + } + }, + "scalarBits": 128, + "scalar": "0x36ac0682c4cad02d95b222d7a09bd633", + "Q": { + "x": { + "c0": "0x71bb98e3849ffe43ab3c05f7df4e13c11a111ec1cca855c63001f2b176d422e", + "c1": "0x28cb3425dbce345a5165ca132a85485f00b1be0a10ce3c3d6e883c7626179e64" + }, + "y": { + "c0": "0x1300442335f5f7cab9bb139f43e3f8991a4d5baf173dcc47451026c4607582e3", + "c1": "0x204935aaa16de6cc9c8e1de60b1795bc35ab2be9b8216e94c3b5a740aa39133c" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0x1b9d2a6314d692a6cc5f21df16c4a72b096fe5525fd9c34ffe317c2c74d86c5c", + "c1": "0xb635f2301496f9aed472cd88c3559b5ffd65383644f772249e5ef429ae5c3d3" + }, + "y": { + "c0": "0x2c5707b14f2533b35c4a2a04e510bebebbca41767679bfa7e76021ad8d10fd7c", + "c1": "0xc8af38d9621d9c80fe90c1c5eb423f8c36afe4304643f8c8c8fe9b02b52846a" + } + }, + "scalarBits": 128, + "scalar": "0xf5b1e65a411bf88dfe92114a69f55821", + "Q": { + "x": { + "c0": "0xaa4a11909dcf15c3c8ab650abc0f8332a95905f14abb69475b516506efaef6b", + "c1": "0x1037f3f12b2808a92d3ba3cfb07bbcbbe57522561d152ae775b2f08694e54687" + }, + "y": { + "c0": "0x2c85f677648bf09d384ef9f789a524da2ba6747801df3c10930b181304c792d2", + "c1": "0x1b413136465845f54f04d26424f455a90ba58ae0fe9621ae116304c67932d8b4" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0x136badb9b6aed6ff43e4864ae2a20837bf458f019e50e241d78b913606b13e54", + "c1": "0x25abec824c3b97b64a74d92b3d2894ef7d95d7bfb54b2d94deb063b0ed2eae97" + }, + "y": { + "c0": "0x1b1987547a9207bd3a944e47b9d420aa274afa7a3606a0ef41b5c797a2cabe27", + "c1": "0x152f4e7ac79036d882b732b8e34fca6da8844f30e0f33df4ae636a31b5a2ae75" + } + }, + "scalarBits": 128, + "scalar": "0x9120ef18579200b38e7c86bfaf238c48", + "Q": { + "x": { + "c0": "0x2304bcb4b5c865b1ccb4a9f325ad4e8ad23e2c9daa01a1b665e3b4892e159f74", + "c1": "0x14e6bffb272bcc4a41f6f3e2c89ac6a7e268793cb553a40f9e2c0f641a60eb40" + }, + "y": { + "c0": "0x2210b019f63214a8c41b43a919cc0d33c52b9c0c1a88568c487ae8a26936a42", + "c1": "0xec33888da4308bafac27c7e833f78614c8337491c2c46894929b7617c6f3dfb" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x2e7b5b91d10962460f7eb4626f9304807ca560aadbb98c469c93c109a95d234d", + "c1": "0x22d11159c7d6bf307393deac36867c5cabd1e5f273016620f391afb8c21b12cb" + }, + "y": { + "c0": "0x24cb3f6b02cb97d3e0689b2589112f51d3485c66ef38debf04f36dce2d08c10f", + "c1": "0x10a9430f89f817bcb2567026c00b1e61714dc2168aeb0c2d9901e30d114de8f4" + } + }, + "scalarBits": 128, + "scalar": "0x90616623d60b41ce7debb349a0a1ffc2", + "Q": { + "x": { + "c0": "0x260749b59cce3729f648bc1422fb08f770fdc7721881d98711e1218be276ebe0", + "c1": "0xc108681cc8164de7f72c78deb5716eb514cc79441b9ab8a649cbab7f39a6564" + }, + "y": { + "c0": "0x2753cd3591e71c195c0febae964d371ae0b2e098f4a5ae14344d45fad1be0213", + "c1": "0x3b38ef5d17d0b1c8450b9b84f48418c44056edd57c50cdc2f121eaa1373c024" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0x2394a4404783377dab6954dd22404770499effd1b6b3b47e0ef7a35aa6306ddc", + "c1": "0x23c46225cb4d0f1d9c1303ca812a86309b28a071ed20b62b3fec90705a16de25" + }, + "y": { + "c0": "0xe7a426eff8911fbb2e3afbf350029edfe165be7616844f1299ecc5732f1c3fc", + "c1": "0x1f38277fb1a62cdcd411010f90fd4f67f70680696db380cf40fb3a94a3cee937" + } + }, + "scalarBits": 128, + "scalar": "0x9c4802506158aabcf43251cdc53aec66", + "Q": { + "x": { + "c0": "0x19921dfb63cc896e4a4a746b56a2127807bbd5456ea34c4a23aae622b182d87e", + "c1": "0x2fb589ad6e0f006af410f97ed28fc2975b100befef0522dc790778cd408d156" + }, + "y": { + "c0": "0x1587400ba181670ce75c2b547e34f3be6d688d14c065b4f27abc58657fc221e8", + "c1": "0x5fe990426bf4b5a31242a83d214a54b07243c67e5273236d5e04289e0c90d18" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0x1ff704a5f1fd313e6b786cb09d3069638d1e1fdbf43c8b84b16d0fdb0d010e80", + "c1": "0x1a0fb63ac3ef3501d77ff97c593d81462ff35801a05e2c0a4669939b655ffc64" + }, + "y": { + "c0": "0x1d5e49ade9b1650e3ec96cab6d792771b9a13a5a97228a43853c6ef3007c1cb6", + "c1": "0x2df40d752f93e90e0459111e4067e5823adfc81d691d8b9eb2fcd8bf79822420" + } + }, + "scalarBits": 128, + "scalar": "0x49f017e2c8cd5ea57136a1a8f88ac3c2", + "Q": { + "x": { + "c0": "0xad2eacf181a5186470391459ef985931e3c3beedf6c743aa344df7d560b2d7c", + "c1": "0x291bd74fe6b0dbfd10e64f94d020da5395114cf0cda2ad08d8a3bb4935369dc8" + }, + "y": { + "c0": "0x29dbdda303c9b9ae656b38b2a33f9e3b2f701971afe3112ed06131afa4b1b7b3", + "c1": "0x219d743634e0ffff6a9ec4173c3929de42b3f3bf229407e3479fdbedc81f188f" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0x24ec44b22c75f23262dd86079b263bc188110cb7ee592c316de0001811633c82", + "c1": "0xceec5c3c3acff697beca88bd3ea634371e0b884f85516e9471acd72b0c81431" + }, + "y": { + "c0": "0x15d53b57021b70b3574aa9ccf6ea1bb8ebc650d74bd1e2aeda7120ce55fc7e43", + "c1": "0x2914da1f9b36de9715ed568121ea46a5bed6f8bfa59fc761f98b814441497613" + } + }, + "scalarBits": 128, + "scalar": "0x6cf2aa72301a14d4cde0530dcb2e7110", + "Q": { + "x": { + "c0": "0x2c66a3162abf080f556404e85506b781e7f6f01e3d155071651e890da430d58d", + "c1": "0x2773d65951452eefde9f574718c87fd2681c4b7e115351bea8ca50946c428fb1" + }, + "y": { + "c0": "0x177fcbdc1cd83509ee320b05ecc2c93caed95e6b3e44de08ae286f18c8453373", + "c1": "0x1a29ebafc84932d4a2fed43df07240187f85a3b0b3eb5e7308547e928172f8c2" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x1ba1bc6a0b32bb8eb4e87e38295dce9fb0c2f825d727c302be09af7ecca12b2a", + "c1": "0x2b1ab51ea784b8a6a4a276ef5a1afa8cce122fcb44fa687a51b230477a41e9c4" + }, + "y": { + "c0": "0xc07de50f26aaadc7db7cd2771ee1be8447b09912f88cc480fa117ad5390c80a", + "c1": "0x2de33c18768b58b3e71fff1fb22a537323b6bf77feff8ae7e39151c7c4cd5c70" + } + }, + "scalarBits": 128, + "scalar": "0x30fd0c5cd13bc87db9564a350edcabc9", + "Q": { + "x": { + "c0": "0x1c33519205c79e52713af5bbddc331bc309161b756702fe1d7e5a56cb4f553a3", + "c1": "0x82fdd5a21e6d1b32f73262daa04fbdebb179f5b93242512504173c2ae0c5ae3" + }, + "y": { + "c0": "0xc123b36ed041e974417231d80ce6175a19a46f0de72f4c2caedffbaf1cd0da", + "c1": "0x13302e707383d11e4f9a9735dcb3f6bdd0a57df5d44197a0881c11de2dc0eee2" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0xeae0cd20085dce50caf54672072b02ecd54f0307f7ba745c22f79f5f5f00392", + "c1": "0xd6d54ccb19a889c373a36286e1f14cba3c3ae61d34dda09a612bbdf4cb47e2e" + }, + "y": { + "c0": "0x1734ad17e4f912782dae2ee940377d2867f4d4f12b6c41d6ed7cf474637abb5c", + "c1": "0x1c480ef3e68837ad7c479e2edde021779d8a65c36ad0f908cc8f1103856d6352" + } + }, + "scalarBits": 128, + "scalar": "0xd09d7f41c6090e93a46c66a8cd8248b9", + "Q": { + "x": { + "c0": "0x1cc1f5d37f0337ad5ec3bfc301e5e1171d39624dd549af3472b31490bc64fabd", + "c1": "0x81bf492583999f30ff5621e84808eced175166b62882f38a455458acf1f840d" + }, + "y": { + "c0": "0x123ce70ae8cda740f3eb653231ec0ab069ec2d3d8dd7bbbfd8d8ff54148d5b54", + "c1": "0x2103feb2b91ea1e1745ec82d3d7655b99b0d0afeb5c22feb435f7cfd757085ad" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0xed121f410e970ee41fe2927eb1cf3f9a55aa004ae3cd3e630509da4532e49bf", + "c1": "0x3bced2117f94147d162193366f039baceb403394c43ef5cee56c61f1d9dc013" + }, + "y": { + "c0": "0xec18ee9e2b279e8d619f803a86496fcb06115a95a19bc657494706b940547a", + "c1": "0x1f866430e44265ae28ec415c97e245a8aad8b3063d1593d395944125db365fa" + } + }, + "scalarBits": 128, + "scalar": "0x6bb0d0c90ca633ccc55f7d9fe650b710", + "Q": { + "x": { + "c0": "0x15a5fc35d20f208eebfba2fc06e3d717256376a578d2e0d43b585b351b7f1fcc", + "c1": "0x2aa83b088c3559577c15b21b330460ec1ebd62fdb63f909c44ecaddb8f673498" + }, + "y": { + "c0": "0x1f82557b5eedc8e0aab84bb7d36ab7e8f896b89e31ca002427d911bf891e471c", + "c1": "0x1d9ed21c3129e4cceab7363f83c61e53abb054d761f75ab9c6d01d746b665a9b" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0xe316227863cca05a5e9375417577c83ed0fe3e42b0d1e6d4f064a652b6c8ae2", + "c1": "0x100dfdcab8d1b6d1bb9a4894aab103cdad85069f95addd20ecded06033ef5660" + }, + "y": { + "c0": "0xcee0824935e0467515f7f4a196a062ddbc49b4005b3f35697804eee83312373", + "c1": "0x22a2cc487e81981938f3f4a26f8368ce27b896928f500fb3c1a3c09383d52e55" + } + }, + "scalarBits": 128, + "scalar": "0x161bfbceab5395fee4c2ee36d22956c7", + "Q": { + "x": { + "c0": "0x1a16ba3f95903374438753268b48d758568ed0bc713b99402deae230f86b9ced", + "c1": "0x2589521a3569eeb3c4160fcb46d6cfc1fe7a5d4770864ca350daebad0c340e9d" + }, + "y": { + "c0": "0x141791cccde7ec4b55d38f19cfa788afc2bbca0868ffd6e5747d8616a3fccdfc", + "c1": "0x14f6096ae37af4d9a5bec63e8a14c6ab4b5c628f0a42781438920a45250430a2" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0x29298b2506ab0aa50d74700e776f565fac32168e1c5ac249d482403f9bc9eb43", + "c1": "0x145f9ad844147153236c99f329a14181746bee55cc4a98fa42958efcaecd7c04" + }, + "y": { + "c0": "0x206774e22f002589552fd16d59a4a562e350b7ae791d326f1c86a679caa9f485", + "c1": "0x2d1a8ad7cdee9c2b0439cae01378a40bc679af43145977c4dce00fea6248e70d" + } + }, + "scalarBits": 128, + "scalar": "0xcaac554bd79ee5710d3a566afe0bdb55", + "Q": { + "x": { + "c0": "0x1fda0e0f640e91d4fbe582f2418e9e045a4a5fc7554cbbd141eb6999c199b03b", + "c1": "0x173dc5730804f3d0ef04d13490bb968449cf78a104e908b325b25881caa5d5e2" + }, + "y": { + "c0": "0x23afb91fdc646a2aff7dfc00746303cbd390e1caf6775c74f125d490a8b4e4c3", + "c1": "0x14346eec541728238e9dfaac31bed8250cad3cc12583e1a671eebdf116caa14" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0xf38a006886f11b037e14d71b1df549862c52fea7a9cad62395a863de02dbf2e", + "c1": "0x3335bdbb2159020973adf7939980205cc905508f3801790fb67dee880d6b9e5" + }, + "y": { + "c0": "0x21a25fe2968e2e5ef23a1612e35fec5744b8d7cf97f8066b3ce6b9612be21062", + "c1": "0x2dc1f0e7541139261691c28b73d312f4849bae59f20e95cd99aeedeb4827e615" + } + }, + "scalarBits": 128, + "scalar": "0x9b532f89464eeff7d19afa4da68ca99b", + "Q": { + "x": { + "c0": "0x191af506a2fbbb1a1fc429f5cbfec8bc8ac09b15755b9ab6a536b52558170a35", + "c1": "0xeffeeb9dd6cad298432a5b3e4bcb774f3d8f318ae8b41078b60e91aa2bd6282" + }, + "y": { + "c0": "0x1a5fe98f3732237edc37f88f82d34aa68d1504d84528f9da967f25ca5fffa573", + "c1": "0x8455853a6ca715c9b96b665a866c19ca44584b226484364c143b7c3ec6f4b79" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x2e6a872c01802947ff7e2d661cd1c1a93e92c9b36a696f27d77733a82313e827", + "c1": "0x1fa7db5c5fae7092032418bb5435069f22560375c70e277af04926b0fc26257b" + }, + "y": { + "c0": "0x71d3b0eeceb9714bb61e0111b9d04dc8b37d51b9e5b7147b692a2af4eb7a349", + "c1": "0x1cb0d354829ab2d81870a0d42b09520b509f8ccdd9ec24fc49efa6b83836edcf" + } + }, + "scalarBits": 128, + "scalar": "0xe3a0426a3691ec7c47c837c90b640e7f", + "Q": { + "x": { + "c0": "0x2c5cae59f7bc53fa9ebce4bc2ef019a447881bd5210771342cbc1bc096669bd1", + "c1": "0x13cac2675f1fa0447ae2f9fe19a3316fdf9875032ff5db22e3af706e6834dabb" + }, + "y": { + "c0": "0xa652608ebad74e6ed27a135f574ae623d23736550823060312e11135c046b77", + "c1": "0x2f3acf1297af59fdc0c2497475cfbe386d1f41559de742ccad800da64fa104ca" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x2ec5365c4405ceaf5b865de2287e47e6b95536d976e148f0ebcd2335d5aa3e26", + "c1": "0x27601e07b95f449356a787fd8d9a431ac91195a994019afdb95a57460575b238" + }, + "y": { + "c0": "0x119574d666861a2f1e51a0f5d3e50dcab04eea289872ea8eba591d9463cd211d", + "c1": "0x2bec41aaa5b4c4059efbffd68d8dc7f0954bbb7e7294f9dd13eda0243e5e4b35" + } + }, + "scalarBits": 128, + "scalar": "0x6216e9f25a22b34918e7ad81b9558a02", + "Q": { + "x": { + "c0": "0x22545c5b269e30d0455f0099dcfeef158352bbd6cacff883d9605db5282734b3", + "c1": "0x2374d6a8b73745b999a286b2daf18caab152fa6fc0c2ecc47cd87e3ff43d9501" + }, + "y": { + "c0": "0x14b861249169a32b4871a0c3a09085927b4c8c241dc6277113adf792925025b9", + "c1": "0x22aa361253c7cb60a203c673e9e38730bd52ce6cf5674f9df37129f85103d8ec" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0x1673fd6c872e03dcea6469ec5257da6e4f10037fd39b330b6769c750bfa06198", + "c1": "0x1478755e516f0b7489d4b31561695bb83e3575863a6caccd65b28cc67a5841dc" + }, + "y": { + "c0": "0x287595985ef78a6f24ac480fb200c3bb03a54f492e68ee45eb81126e19a3ad3e", + "c1": "0x1a7467640439926bc4e361d5e3209397c1ad02984bd9a5355e132b783db9d78f" + } + }, + "scalarBits": 128, + "scalar": "0x9c24deae18e166b38ba1af24d0af6403", + "Q": { + "x": { + "c0": "0x60d1deb9ef2156554d949df6b7e23847cb3116ef937a41cad236a085165a113", + "c1": "0x78045cdf09cefb6ed63185bc91c1488055a41f46a2b0b599960b7db3422f7b0" + }, + "y": { + "c0": "0x15c5045e5ad03c1c431064fb78a58b25f1742d606380e9770fa9bce68993376a", + "c1": "0x1919c7eece35d4b0d618729bc5aed801ecdf640f65076895ec7ab9152b834864" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0x22c337dedbd70d1bdb19eeeda0bc850dbb2aa302871b7a9f50d21414fc638a63", + "c1": "0x1dd18102d3bb0ff82b3e4207d3ab0899636c968bb710d8ff99a554c6fa0f46d7" + }, + "y": { + "c0": "0x13784cbe5ccbd0f72c52a8e4f7c3933ffb99a8143923743d425f3b23fd500df0", + "c1": "0x23d456454bf0501e020581d5283708c65aae02ddef5d2875fbc89b31a680c948" + } + }, + "scalarBits": 128, + "scalar": "0x3feac05fff563262d3c38526644be154", + "Q": { + "x": { + "c0": "0x7802bc6cf924fac05bafa670de59d42bee84cd780c052643654e61ea0291bc1", + "c1": "0x1c2740c85631a9b574397fdd78b14ef8aa6739f381f4565dc25ddfce1df393e" + }, + "y": { + "c0": "0x57ca29e5c277ce7443cf858a00e02287df257030072dbbfd4ddcbe22c8e37b5", + "c1": "0x1e6bb8ee95292d86e88d5773154c13849d1d1b30ef9cf5b18ba01d7aafd0d70a" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0x1d1dd753c3baae64b85c7ea295cf6ecf7f4cdc85d2b55b04150c0144cb57c182", + "c1": "0x129e7a446a83864ccfa8e1c14ec74ae2b91624c67d0f384a8dacf651776f823c" + }, + "y": { + "c0": "0x21841aa8402c1302ac6322ee601911a66ece24f7049d79e4246b0a2c15e8a71e", + "c1": "0xbd58f781ae5b34c318fd87dcb61d79318b815a87f162fa212e201bc02d4ced2" + } + }, + "scalarBits": 128, + "scalar": "0xaf1066504c811c74a50ac512a3af552", + "Q": { + "x": { + "c0": "0x1af70af13bfa6caca011efad8ac940b85905de2e92f15e656723127e18bcdb73", + "c1": "0x2667a37f62602a7c78b8048f771d0fd9d90615fee5f74a39d2adc83f477435d4" + }, + "y": { + "c0": "0x2d557da207400cd461727ae08e7a7dd4a8973e13218e0957a9e3fbf8d7d89a7a", + "c1": "0xe59bc7b16f7230a10db445535919fc8e15380ec6ceb391e83fef846b359c5f3" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x237426e4e3166510890aec15cdeab6a507f99e8e1ffabd812ba6fafc3528cc95", + "c1": "0x6df4ec8c96c5017005b3bb1ef88ee32567eff792278d3582bdd12a332100c15" + }, + "y": { + "c0": "0x1e90b3db77451699caff7e0e738e73a9b2d8af7326de7ee9a88d28b56ff70876", + "c1": "0x2546468b1c31361871f0b58b124e99bb9f76cddbfe3031586f1368561460c30f" + } + }, + "scalarBits": 128, + "scalar": "0xb6d4c85a3e1867e32a42866ed917d041", + "Q": { + "x": { + "c0": "0x11479264459ac68f98fbb558e6d68161e4b7bdd7b3cdf401b42bc0c2af6b8e9b", + "c1": "0x16ba848372b0407693efc8428f0ff1361b03530c3c0dd1e8a87fc3812fe1f108" + }, + "y": { + "c0": "0x70d0bc71d38cfe1211628a70b8859314bd8329dfcb25823a3a2c38322a7b16b", + "c1": "0x2e28a26c6c59b451164139ac01af5a7fb1976ba6ab35a0c32b1b6a3b5a850c82" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0x226e9ec4a630aa5f5905930cff5a56cb585ff1636f039593c12f50a63f402737", + "c1": "0x2778e50df948903f7e0bbf3070dd720145d3f0738ca6645f5a2cd8b845243190" + }, + "y": { + "c0": "0x2e697a2998ba3abff1f904d73dac35b922ff2a576689626204acacb06b40e313", + "c1": "0x1907cd06b3f007ee9867617c16780cb46d646540e6b6e7c9165a23f4ada282d3" + } + }, + "scalarBits": 128, + "scalar": "0x36951757a6dadda52216b906083cb361", + "Q": { + "x": { + "c0": "0x1894b3f4a7089dc29bfb77994ff7275c89794f9be1a838b642ed2c6fd7ae854a", + "c1": "0x20220f4ab8142f58b35fa758282989fd0ad3cb4735ee51e2636f046923defc00" + }, + "y": { + "c0": "0x126af995f5ee9e65742fd29384800839aa70f051924ff6cec51622ab10ef802d", + "c1": "0x9b006e5d9597e73ad32c3ddb248dae31698ad3a54586dc69213129def6fa7fd" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x1e5e7f097f4f0f4dab32fa5847383d62cac7231c298a965828206c4409b899d0", + "c1": "0x13950d672f23dcf1f758995d0dedb7c6a2a34aecbec3d67acbfc6a6c947ed719" + }, + "y": { + "c0": "0x250252fd349c362bc5e920f3f2a586ecca9dc7ec73548593788b494756a40d7f", + "c1": "0xb8000becce63aee4e0a79a0b5c29396bebd94ee6348226f26586150b107481b" + } + }, + "scalarBits": 128, + "scalar": "0x9e6875936de395b341581750db91c481", + "Q": { + "x": { + "c0": "0x3027f3536fb2882c8ef903d3d1ba8770b948e48e26dc27ed3903324c8f38008", + "c1": "0x2ff14613985f3433f61513d2ccecea3bd7fb09e773a8f7732b1cb1ecf862be8c" + }, + "y": { + "c0": "0x29d14b6ab74c69a13f188030203022e2f681597e67fb7dad643bf47bbd41d7b0", + "c1": "0x2d1262934f0908925cc4333bdb91c744316294006710b39adc1a6f12b3a0c28c" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x2cc76860431f6d309c4bdbe686f47d71bc2acd5a3c4d64ac2273df22e668cf7", + "c1": "0x1239f707e73670bc02ff51087c8b1e363f8a8e740a2743734aef63efec028ae4" + }, + "y": { + "c0": "0x25d8bbfb6f16fa08ef0f5c1107d0fb90482c3fbbb6bcef083f53290e54d4b61b", + "c1": "0x68e70b64ed5c585f0155b1f42416e4f2801e7469b2b3a03299e181a14df2593" + } + }, + "scalarBits": 128, + "scalar": "0x14d5b8df86d7f0438ae971c57cf104e2", + "Q": { + "x": { + "c0": "0x23ff0c42efc8b0c5aa24652053d466421e17aa81fce45346b45b2e04746f7a19", + "c1": "0xf6739684105e416e6875f88a11714cd8d7a20e9ac3ea80e59d3ae5fa5d45dbd" + }, + "y": { + "c0": "0x1ca2e9065b62834ca6e8760ad89e0fe7669eb1cbb008ff5f073c264d966c2184", + "c1": "0x1872f1c9f7192e82ff370730b626604fc7b6b86268034b346e57f3fbb0d11d1c" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x28bb812c83adab3d96b4908f8e1c9628bb12ac8b8d81bd609fcc4b4492b46006", + "c1": "0x15a7d2635de3331ff647d6533e339eca5053e693c7bceea6049719f845d1163f" + }, + "y": { + "c0": "0x14ff10636bb6506e092d46a749ab5bcbdb6cee630eca7d019247cb4155e5beb1", + "c1": "0xcd78d63105e7096328a51134698747fd4abb3e1472a96643511cf3f602779a3" + } + }, + "scalarBits": 128, + "scalar": "0xf429b690b20a15a9880ea939a628ec51", + "Q": { + "x": { + "c0": "0x28bbb0db8e31ab5ab6ec1c783bea88224254d6fe1d84b0567761379a314253c6", + "c1": "0x300a7e85728b76197ccfb84e5fca48ee988f5ee67aceaf48c91988cc31105760" + }, + "y": { + "c0": "0x231ceb57fc1371e5ea340751f28b9fe9de4236805a2232658fdde663a30da9f8", + "c1": "0x28f83f10620f3aa4d4ec95d78b454de938f00d6a02f2306e3f1c60d7d392dfbd" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0xdc3299cd0f0992aa4ffbab9f83fda6aad84150431bfbf297dd959109e9acdfd", + "c1": "0x1f126a0969c1f8088875ae89fc8c864ac5386f4e3305b517388858cc83fc50f0" + }, + "y": { + "c0": "0x2ab24d1208e7c78e73ab37523dba8cba3396c05f5b36f711d0da6759d2eef0ea", + "c1": "0x29acbca913d4fe9225c534ee2680690825dab4f9a915f1387e77d08d28ec318f" + } + }, + "scalarBits": 128, + "scalar": "0xd242dba4c5bc96bb2af14333b0043578", + "Q": { + "x": { + "c0": "0x606cb9906ce9ecb0f8231d7f468677cd905c08543c6cf6f0c018b9de3421726", + "c1": "0x6efd1c77448b17354db6802a7e515b88b5218669f6ed414efcf8510af8ee607" + }, + "y": { + "c0": "0x297fe005565808f8ffe8808028b03bee152236b5dfdacfec418cfa5b4b7c5b0", + "c1": "0x2c400cdf6ba65023ec519bf2ba2bdf41f997cd50d9ae7d615203618d90fb5d68" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x1d64375692c39d645cbc94df0c3687c2f19d7d3715968d25f02c84a0a9fa3c1b", + "c1": "0x2e8442329ad1f608e72590ba976927f0709f90a46ccb4cd70e5a6b1a8817bd1b" + }, + "y": { + "c0": "0x278d5820109e682f77833321d2699c6fe878bb2b955a1b27488d60060924e4b0", + "c1": "0x1d617eb1d40338a444ea79b2d2e41dc23c7376746d739c400a2b9c54b563c939" + } + }, + "scalarBits": 128, + "scalar": "0xd903ea413b80d80961fb8f4024b2f6a7", + "Q": { + "x": { + "c0": "0x311b9ddab4c5ce377a7b0a20764d3cc44db08bdd9d24845e09bb219b2aa8569", + "c1": "0x16526a1cf9bb86ab8ea8277106aaf0b256aa61b3277ca01b2211d541f82dce8c" + }, + "y": { + "c0": "0x22a0c8eac5772a64f8e4292ae85fbe13926ff690bd18cb559e490099923b79e1", + "c1": "0xf6542578ba59e4085038676f37ca80f556dce8cfc7d559138b395100fbabdc5" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_254bit.json similarity index 97% rename from tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2.json rename to tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_254bit.json index 8ddc605..91a0ad8 100644 --- a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2.json +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_254bit.json @@ -28,6 +28,7 @@ "c1": "0x11f787a6cfa5113a8071d6e502b0644a8884b353d6a93b843e21b6d6803d42e0" } }, + "scalarBits": 254, "scalar": "0xf4a990ccca0053b6aeec01ed669ae5134323e4a9bce7e9d4e5ecd1baac01965", "Q": { "x": { @@ -52,6 +53,7 @@ "c1": "0x26cefb017e2533b8bd31d5eec61f4b18500ac3a6b0bdae97b7f6c43b1f060e1e" } }, + "scalarBits": 254, "scalar": "0x237a00cd09f8ab026971e5e8458cc54091f091d089fadf8346fd0698c759173a", "Q": { "x": { @@ -76,6 +78,7 @@ "c1": "0x822b0814347b4b26c14394e74d815cb895f8400a3ce850a08b0cb86dfa6b63e" } }, + "scalarBits": 254, "scalar": "0x6ed213f37703ff64c3d7379de22249ccf0881037948beec3cdef64dd024ffd4", "Q": { "x": { @@ -100,6 +103,7 @@ "c1": "0x53a8aabaed6875827f147852922b8ac6c5d2951e190bd46f814450f68c4c14a" } }, + "scalarBits": 254, "scalar": "0x62bd5288cf20a6e36f17d948a80e2158ce1f82403053e46dcc7ad5abc661ade", "Q": { "x": { @@ -124,6 +128,7 @@ "c1": "0x1128ed5d7a58ee5cb2754d4307d6465832a64a1f70675cf3e0581f3d2e0b9a29" } }, + "scalarBits": 254, "scalar": "0x97f69fbd95814f6029b0b25c25d3cd15ff9d8e3497a4a0b469c800682a838c1", "Q": { "x": { @@ -148,6 +153,7 @@ "c1": "0x275e014c9ada99807e67fdc03fc99ac91eaf4bc7d0a9ff849fd92fa967739dec" } }, + "scalarBits": 254, "scalar": "0x294ea5041de649a34abbbe380b335da0bb773accedb844ff6a930891162bb69d", "Q": { "x": { @@ -172,6 +178,7 @@ "c1": "0x29c2ba4bb71ff8996086533c57d6c68b08f6c20a01ea401382345b49dd28ac4c" } }, + "scalarBits": 254, "scalar": "0x50a411bbe00b5c8dedd665e8c340cf4ebcf069bf923007ee79c152bb3a9f6b9", "Q": { "x": { @@ -196,6 +203,7 @@ "c1": "0x12b7f3ee937b92194a854d050e6cf3cab7fcaf030810ecba6fa865f58440090c" } }, + "scalarBits": 254, "scalar": "0xa62755eeb96c240521f3962964b172b10aa81ca1bde0568f2ff2233c5951432", "Q": { "x": { @@ -220,6 +228,7 @@ "c1": "0xe784617111a3f0997184f9f267ce0b7c918434a1a69be753ba9487cce2d4dec" } }, + "scalarBits": 254, "scalar": "0x2b7c3ab242b02a049035f52d290668e6e2b9b6c7494a05db7fc4ddfed3c5b698", "Q": { "x": { @@ -244,6 +253,7 @@ "c1": "0x152d036d9b123dfc285fec76dd270a5bba0c808ad07a77fe3379214b1b07d12b" } }, + "scalarBits": 254, "scalar": "0x16e34632d04259cd28729c6aa8f882d2a6b12f6a8ba0783c40d8bb05fd8a10cc", "Q": { "x": { @@ -268,6 +278,7 @@ "c1": "0x13fa9fd4cc0edee469766b634870cde0f58a03d0efe003fc24bc03c426d5f8da" } }, + "scalarBits": 254, "scalar": "0x1a01c730b207403d5762c950573926e60ba1be22d9335c1cf5d1829133028678", "Q": { "x": { @@ -292,6 +303,7 @@ "c1": "0x21e23558302df29d7ff50ce65e01bc9bd4be585828aedc335f87f602e36907d1" } }, + "scalarBits": 254, "scalar": "0x7956c3f46bf864013a6094c834e0fa4ef376155f8b82e34fe46e1f69b999566", "Q": { "x": { @@ -316,6 +328,7 @@ "c1": "0x16e77962a9c01c5dec89157a499583748619523d068c05e278cfc8ac7ac2b7d8" } }, + "scalarBits": 254, "scalar": "0x4d9f07fee76f37cebe11d120ec1e3613118c582c1dac76b61bb69d23d72ff7f", "Q": { "x": { @@ -340,6 +353,7 @@ "c1": "0xb95a470ff3f05f70927d9f7765e6990a111a3a94881eea2030ab319b878335" } }, + "scalarBits": 254, "scalar": "0x2466d8b753c5607fc0ed25f3abc2b8e49ba634729d17f9ba15354be968485128", "Q": { "x": { @@ -364,6 +378,7 @@ "c1": "0xcc02ff98d9fb7f55b86cd87f36230f72aaf2f33dbf6c68c3d39f0650e373543" } }, + "scalarBits": 254, "scalar": "0x1949dd8dd4cbb689f5d7a927d8ebccb408e1e834d71afb8f8eca1a1b71a58fd0", "Q": { "x": { @@ -388,6 +403,7 @@ "c1": "0x18cc98c778e550eca0dc91f7b17286aaa2b644fd1254a0f9f4a5c802d4280167" } }, + "scalarBits": 254, "scalar": "0x27f0f46b6590a026f9cfc665f9e94aeba10fa6ba994e91e4aa0b8aefd44541cb", "Q": { "x": { @@ -412,6 +428,7 @@ "c1": "0xc5a9eb14dd8e417783130df881004eababc90013337bc892e0875db91872c2b" } }, + "scalarBits": 254, "scalar": "0x2dd20fad04b440639afba585fa9fc769bea04e212767b61c85e7f59084ea7c39", "Q": { "x": { @@ -436,6 +453,7 @@ "c1": "0x128172f6033034541003d3fe5d6f7e7e8d2fe2c8b35ca5225371673c43a78959" } }, + "scalarBits": 254, "scalar": "0x2500d86fee9f6801643bd47690616623d60b41ce7debb349a0a1ffc2995735f5", "Q": { "x": { @@ -460,6 +478,7 @@ "c1": "0x2d74b82585f9021c9ec9b54f3f63c8689017d4cae96ea97d94ffc83b0c02abe3" } }, + "scalarBits": 254, "scalar": "0x2ba6bc9761268479c5bb78f71937ca3d906fd55a9715a2e19880f24da75b2c1f", "Q": { "x": { @@ -484,6 +503,7 @@ "c1": "0x142c259c0853ea1883435ce062b69eeb36d353b279c47e550f80ad030d29a299" } }, + "scalarBits": 254, "scalar": "0x179577966033c6378dc25ba322a3ab4eed87ac1c9846356ad27ba6a789409693", "Q": { "x": { @@ -508,6 +528,7 @@ "c1": "0x10a438eab3483a12c88772d57ec1a922f646ae7cde7b5fec07b3c32bfdbde60" } }, + "scalarBits": 254, "scalar": "0x18d9b30b25dad3a84a63bc3497173c7e3a81db93f245eefada200b467e8c5287", "Q": { "x": { @@ -532,6 +553,7 @@ "c1": "0x23a886311223de7f4316b59005c48eb431bfff717e135f6cb78c5c12aac8f642" } }, + "scalarBits": 254, "scalar": "0xcb6fd81d09d7f41c6090e93a46c66a8cd8248b97a2a5f3d8f0f0c8aceb4d356", "Q": { "x": { @@ -556,6 +578,7 @@ "c1": "0x2e6be82fd2ed79ced5c181a0b80334030cd3df6104a0715002c748047ac9974d" } }, + "scalarBits": 254, "scalar": "0x3298cf3c55f7d9fe650b7108fd6d5eedcea3b0d5955c0ce1d5283e1514f66b6", "Q": { "x": { @@ -580,6 +603,7 @@ "c1": "0x1955c0c257f5ab4d16b3101c72f4d575d614b060e053f5c8be222f0fb450de4c" } }, + "scalarBits": 254, "scalar": "0x1d452534873553997ae4682a447edde2eb8ab54f3e35af07320ee306871ea160", "Q": { "x": { @@ -604,6 +628,7 @@ "c1": "0xc1fd043b06296fd548a17381e966b5880a98d3a0936d77bbec6e4e9855fa2fb" } }, + "scalarBits": 254, "scalar": "0x16b64c33ed81dc9bb39bbf535fbfd43ced3e7deacf2e3fcd99991a68700c7f67", "Q": { "x": { @@ -628,6 +653,7 @@ "c1": "0xc01ab56241a8c27fd1ce429104ddf4d4faac77084d091baed8197037f37c74e" } }, + "scalarBits": 254, "scalar": "0x20087e3937f77fa131cf5ef5ee753ace441b4ae4d9bae6987b97a8d506ae88c5", "Q": { "x": { @@ -652,6 +678,7 @@ "c1": "0xc323b87d7b1201bdb44eed3217ff4c68ca0757ae648572ce32616fd03425355" } }, + "scalarBits": 254, "scalar": "0x1ddab66e2fecfcc4ef565745ceb882edb2160a2bd34a4b4ae7a1ce22b2b70810", "Q": { "x": { @@ -676,6 +703,7 @@ "c1": "0x821daba762dc909fefdd724a220a4c90ee272408ebbe0ce247b038c0d486632" } }, + "scalarBits": 254, "scalar": "0x17171602bee6f1e6199835e7504c26a538d6e74561759417e5637dba9ad48bf3", "Q": { "x": { @@ -700,6 +728,7 @@ "c1": "0x188df415536ce3780b7c36adb6b3933ef6650bbc7080c1b86ad1082fbb69f00" } }, + "scalarBits": 254, "scalar": "0x218e3e8e9644b4448bedee674a0b59c757c0a9fac535afea3b033628db390bc2", "Q": { "x": { @@ -724,6 +753,7 @@ "c1": "0x2a2984650a76475ad042d93b057aebe1a4c1d5a179e9b813286c59e23640f0ba" } }, + "scalarBits": 254, "scalar": "0x2bc419904c811c74a50ac512a3af552b5462f7f76141ab495b9cd9ed055a22a", "Q": { "x": { @@ -748,6 +778,7 @@ "c1": "0xbe474bb6471e2f9a7143c1ac179374bc6928e55675e840ceceef5862406e836" } }, + "scalarBits": 254, "scalar": "0xcfe5029fa05727d4f5c00694a3ff19d244f7514b6eccf418d3d8ce28b974ce0", "Q": { "x": { @@ -772,6 +803,7 @@ "c1": "0x20436ac231e6a2950d4fdbc2027c462c0c145fd0211c25a0c151b59658b5e61b" } }, + "scalarBits": 254, "scalar": "0x16282791727bc8c77fd1b539ebb27c40bcf7d01b0eaa4f2d1049ebb57cc0e254", "Q": { "x": { @@ -796,6 +828,7 @@ "c1": "0x5a82731ca1ea02c56b90d92b4ab778d048bcc2fbb337a2d7608fc7382fae9b1" } }, + "scalarBits": 254, "scalar": "0x17252dc9538b9c44670e59e3508eb7d83bc1ff6ecc411991bf6b8800935b56e8", "Q": { "x": { @@ -820,6 +853,7 @@ "c1": "0x76a09a2a3dbeca23bebb043dac34d2e9089a95ead74bb1018081cd89007daf7" } }, + "scalarBits": 254, "scalar": "0x22265877e84a95bc98ac54f6d7099611d56560b1fda2b0a56daa7954e152184b", "Q": { "x": { @@ -844,6 +878,7 @@ "c1": "0x2ab7d6dbc9aa1327a06fa5e2cab77657d196e66a116c8a9442a2beadcbb81534" } }, + "scalarBits": 254, "scalar": "0x29ebe627896f3089cfc548c24fd614790f891560f09a2c0b00d9b1c0746dbee9", "Q": { "x": { @@ -868,6 +903,7 @@ "c1": "0x2bbdaf1b557ce800ac567b9748a7fa18f401f1b2e6ab1dd33cf26b3ebde77379" } }, + "scalarBits": 254, "scalar": "0x420d38e89dea2daa792b23b8daf2af449ac02691bb79623d44543650851848", "Q": { "x": { @@ -892,6 +928,7 @@ "c1": "0x6f0d64a6d31249301417b65f71608042f2303157630a4871a6732e46075f4f2" } }, + "scalarBits": 254, "scalar": "0xee0b0c49ed468ac5486b2b4ba509aa62405b579371223c1d900e6fc5369476", "Q": { "x": { @@ -916,6 +953,7 @@ "c1": "0xb7ed1621f487b8f176b41e73a7e4c9e6dd730c4df4ee63770cb55ec65c77763" } }, + "scalarBits": 254, "scalar": "0x1019c6fd4411a79e4067200d6bc08a6cd31aba0b4bf0122012a7c090debb4911", "Q": { "x": { @@ -940,6 +978,7 @@ "c1": "0x2e889b65d20214deee20b2426fa5dbfec1fecf82689f1d79bbee2ba8d37912f1" } }, + "scalarBits": 254, "scalar": "0x5fecf0f77d5893688482fa8f53c6d27959b1d35ad28e40384464d72cff32022", "Q": { "x": { @@ -964,6 +1003,7 @@ "c1": "0x26159129fcea1dbaad972a459db9d546ea7163a09139939cb6c91741c79345a8" } }, + "scalarBits": 254, "scalar": "0x286799045208066279c27dd97ed6f300796c72f06c304694759b500b38904c73", "Q": { "x": { diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_32bit.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_32bit.json new file mode 100644 index 0000000..810f903 --- /dev/null +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_32bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BN254_Snarks", + "group": "G2", + "modulus": "0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47", + "order": "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001", + "cofactor": "0x30644e72e131a029b85045b68181585e06ceecda572a2489345f2299c0f9fa8d", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "D_Twist", + "non_residue_fp": -1, + "G2_field": "Fp2", + "non_residue_twist": [ + 9, + 1 + ], + "a": "0x0", + "b": "0x3", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0x1625bf258f7f7be15ee438ab65c97393391fb36133cbb17c44c98efad3b04f06", + "c1": "0x25e9e71cbbb71cc1720d0102a7015f1224469a5e45c80017f4c212f34134294a" + }, + "y": { + "c0": "0x7cfda5f906b107ff2477779f0d03d4795049df8125d8131316ab2bbe12acf87", + "c1": "0x11f787a6cfa5113a8071d6e502b0644a8884b353d6a93b843e21b6d6803d42e0" + } + }, + "scalarBits": 32, + "scalar": "0xaac01965", + "Q": { + "x": { + "c0": "0x285648594f1ddf11f569487155e19ed8f39e5983eb93bea782dea975a515b13", + "c1": "0x2fbea9337029139ef7684684c5761c74562ed0fa6f77309b5b7b0c3df2c41274" + }, + "y": { + "c0": "0xc9d9bba5423af71041dd5e05bb02bd17c8b5979e3de418f2f01112ccb00e678", + "c1": "0xefae59210cdfa0cbf5a9bbefc449e2278d0cca6a1716059d8ae83d20b4e535f" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0xa113ad36406b65fb2bbf3b3b82d4dfd4ce85c792c63036b16a21bbee11b2f", + "c1": "0x2c42a868e6588d5867a5f52ac577907c25fb6fe6887988f83504c09c8fdc13a" + }, + "y": { + "c0": "0x2d87add757d2833e5b3f86812bef72df002e1f16ce5db4075fd9ef0c30bec066", + "c1": "0x3aff471724542a0d56f0a98ce97f281c8bf727d89808771c9568b1f5184988a" + } + }, + "scalarBits": 32, + "scalar": "0x7a84ec42", + "Q": { + "x": { + "c0": "0x1f46d5ff490a26909c7d8b2ffd2aadd27ca70781bf8dea4a34ec1e29e8dfe6a2", + "c1": "0x2ed64a9e9dded63889a5a19e4eabe1be47af1f11e2eb32f43ed37caab2e265fa" + }, + "y": { + "c0": "0x1be69c65d8340b66e8df4edd2eeb91ce765bc3f0f1cb596fa58ac81445beb60", + "c1": "0x170b7897543d4ea69e2044332a3e918b4b814218dd486de2b3745bb96dad6f0a" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x9c49fe95b91564db59c6c9ffcf2d14dff5fde35a4e77dd95fcf94dfd74804f7", + "c1": "0x1e30e63fa399758261217bb25523ff84681686bfba360e56fb3d7431d39f98e1" + }, + "y": { + "c0": "0x62b430ed4971abaefffecc337c3ddc73bb8715d7a3d2353cf6e4b76ae8b6234", + "c1": "0x10f484d5311045b0af3e552e8acde2f3a116eb6005fd36376fae9f0ea1d00246" + } + }, + "scalarBits": 32, + "scalar": "0x93ea6ef4", + "Q": { + "x": { + "c0": "0xabca1e2bb231dda61c2a595499a71b52fb9b406df71cfdec0e5e0b5505f303f", + "c1": "0xef5e163e98c67a5cca79b45054f2cf19875a2e82af75c2fdfcf5e86025678fe" + }, + "y": { + "c0": "0x22ee3d2f87b8c7855cb3a3ae63d59488a27650d42b65611931f99845f1ee7025", + "c1": "0x8c2eff5afbc938d86c09632cb06f8a7a64c147fd140c3186f25cac6b91a7b92" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x5023a33dce4e7c1a8c9147fca46ef81a48b64dba28f45d2f091e2d7e832aee6", + "c1": "0x1e65acb03313289b497e7b8ab293fe91a1d75db273e47d107306b27c76d698d9" + }, + "y": { + "c0": "0x1d990eed46ded209ba68592be8d57768968c0f21ad99c56b7d90700eee38043e", + "c1": "0x2c224bb99580d84d0ffcfed76c54346f24d8ab9ad909f2b9ffa89953922e0e76" + } + }, + "scalarBits": 32, + "scalar": "0x56831806", + "Q": { + "x": { + "c0": "0x10e8999dcfb17172cebbe446258f0fc85f15a544d353bc93d03938632d331a74", + "c1": "0x2aa2606e47dc67f1a43503228f581b2ca7eb884568bada950c62ba65f3fbbbc4" + }, + "y": { + "c0": "0xd1133c3ec7d5a7a666bb9fbc08cf7ca3a77530c358251f59321d6795c6ab869", + "c1": "0x1144b669f2839cda6c8019814c7eb28f65f99fc59ac92b535f52be8a922eba9a" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x97f9aa747dd4476c61672f16b1b2aafeb86e6b3c98794fe1fe2aa4ae978d710", + "c1": "0x862adb28f52b193f4c5bd3d9d2ea280062105ae80e3d3c5187fcaca6a7cb818" + }, + "y": { + "c0": "0x2bcd4f6108a07cfa5e7a698c3613725be033ffb22fc63bdba8be90f9e7ae539b", + "c1": "0x123accfca55bfc86657f907bb58bdd53a54a5cd0437607f65f8d26d75a5896fe" + } + }, + "scalarBits": 32, + "scalar": "0x9002d3cf", + "Q": { + "x": { + "c0": "0x1e5a53289ac40edebd0549c86b3756af9733f88127209af36c73f6afd2cfe21f", + "c1": "0x293c0586013e197ecba18eeef7eb0a9435977dff1e5b08f494bc60c833db8235" + }, + "y": { + "c0": "0x2b977d95fe831bb939bba4e47642f81fc87d176a07fadd0bb747f666bde2a22b", + "c1": "0x1c43fe7867bcca7566d6f51c50f3f7160b1a502b2e345391c5c18ae48d1927de" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0x10ffeec00d4a65a816b00b13b5236811f8006dd48a6ceec8af4fc3accd9f3ea7", + "c1": "0x2b7cbd07d2f96b713951b5b983d0fa042ced28fa93c207464e0078d64c52643f" + }, + "y": { + "c0": "0x64ffde833819583be310697659895a48b51708ed99db6dd9dcd323554402b22", + "c1": "0x29d999e8fab065e1f391ce4a88a977d3bab43268533d758e23a838377e1c2365" + } + }, + "scalarBits": 32, + "scalar": "0x6254d9e0", + "Q": { + "x": { + "c0": "0x844f987a92320c8e9c9cc1d1ffe8f635ebb64322bbd6d00fcf8d3456256c243", + "c1": "0xfd9d6cee754e13de7d59a066f94e9b606525148fb0d14f3822f8d9d8a554ddf" + }, + "y": { + "c0": "0x2ec4e5c44a6a74b707992c0f74db6cfad146bc58d0b0fdca9e9feae5be527754", + "c1": "0x1442c2987bf1c71a5a1b59a0b506f978b920b5e8a87b71efb1588ea5922f41dd" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x23564c0191c7c6abd3194f357ce83ca3a8fd08827877f1f5bb0d406f0ed083d", + "c1": "0x5e39d7bdea1ff7c795238e7efd1822f0ae71bd399e209c6bf52697f8691573d" + }, + "y": { + "c0": "0x3a9039a328db0dcc2e83c128c346102c8ae83c566c9abf3ac1eed35a0798c79", + "c1": "0x275e014c9ada99807e67fdc03fc99ac91eaf4bc7d0a9ff849fd92fa967739dec" + } + }, + "scalarBits": 32, + "scalar": "0x162bb69d", + "Q": { + "x": { + "c0": "0x2ea820f0cdfda75f90f0d03ec6769250b0f7aa8c11aef7fc613fb2f5b88999fb", + "c1": "0x17624d05aab131494fc6443e0a7670c3c3c0a33d60e586789bfb1ecf0d1ae40b" + }, + "y": { + "c0": "0x241cc2ba1ff792e399b2eed624e631f6ee98d708d8bd4ee07fb5d0e5caf04234", + "c1": "0x22b1c6553d9e8f10fa757ecb4245c29f330f2a9d506fd5dfce895965d7753bbc" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x29b67c02a3f45f0921d849503819553fe816e1def0edceecb3901ba7824ffcaa", + "c1": "0xf142356c12b359dbc393219ec57cd3d39cd5c6c115d8515a512197c89178bd1" + }, + "y": { + "c0": "0x2ee66adfb50bc1e6e5a123509ba3a49272fe8143350cc510262d0ee0e4fc71bd", + "c1": "0x24f8127be013b57a92b7906709e3d1d3b2b32fcdc61cd7a7d6c6fc12e9bdb7ef" + } + }, + "scalarBits": 32, + "scalar": "0xe1348fba", + "Q": { + "x": { + "c0": "0xe45ae9874dd689528a9c7b409b628203206af8aa378f8fa8afccea0bcc1d2f5", + "c1": "0x18f2788bad195262647d5bc9d80301cc1f37dae975c60ef73755f6b16ae50bab" + }, + "y": { + "c0": "0xf4342a539c01816afbd7681b8a8bf7e85e076039667475972f466c0a0b95802", + "c1": "0x210c7bfc4abc3669513f8c203d39c0f3c46c7f49802300a08fd89199c10d698a" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0x215795e1a7ce8cb9660ea16fc927704ca88789abced61405e938835aa83ae77b", + "c1": "0xbe481411dd9d494bbc71a2317f32b4be8c6dff7db22e58264ecd3de3cdb162e" + }, + "y": { + "c0": "0x2fd35311045dc501a8e5c8d9c41e44b04b6e388f5587bca2a0d171b3f497c1c4", + "c1": "0x23faefa623cdbd3dc490eb956ca4041788f3544ffdf18bfc0d06174171a63899" + } + }, + "scalarBits": 32, + "scalar": "0x7fbd2a9a", + "Q": { + "x": { + "c0": "0x1dddda23895ca2727c614bd92ce6baeb02c7cd015ad86616c56e63af243a11e3", + "c1": "0xd3604b1be3eb9975263ed6885747f749edf54ac6b656ab6629e1464d1acd7a2" + }, + "y": { + "c0": "0x461c7e825c160f41127c14718c1d200573b959f6f95463277716641ee88af4d", + "c1": "0x1d1bb0121b489a25b903dcc02dd95e527098c235ef9ccbd77592e6ab8ea5bcd5" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0xad98f391964e65f3eed99e8c96c5731ddb297a656688d790f2fa87d2022ce2e", + "c1": "0x25e99d0c796ef7e215c49408d03e2425425f48ceceb41a4544aa6c60d714fcf1" + }, + "y": { + "c0": "0x8e4c4e02a343b8f72a0d9bc9c4de0cb4f19a27cd0b9498715261f18232a293b", + "c1": "0x27b285d1d89db6012614c09015eece526ab8ecb3a78fd3fef0a9b56db7aac07e" + } + }, + "scalarBits": 32, + "scalar": "0x1221b0d3", + "Q": { + "x": { + "c0": "0x15f0c86953e6b34ac44e4c06b317af338854c0224f2fbfee2911c8830c981d33", + "c1": "0xfedc2c300d4ecd49144156ec5921f0ecd142f466e2108cf4901cd0c7ef82cc0" + }, + "y": { + "c0": "0x786300091a3723b73690e162842cc348d1f4bd865fb9900d45708e3db63e259", + "c1": "0x2da2f6a865693da4e3f5c3cc0c5fecd71377b20bb27aa176341695a4c2f29207" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0x6143d1ec05058494e82cf3201d962868da4f0381f6286ff14cd5d7938f4e6e5", + "c1": "0x182a7786886f72834aadb71d8199d9e3cb12be0d387338dca2edcae1800ab7c1" + }, + "y": { + "c0": "0xcbd7b0f880fa9e4ebb743689e20ac8f8d9589316a4c524a5f14f2a360bf9dab", + "c1": "0x14c086ef6ef8f4c81614f87e2c6ca52f6709685e89e2364453a76e7fc1c8211d" + } + }, + "scalarBits": 32, + "scalar": "0xdaaf384", + "Q": { + "x": { + "c0": "0x15d69b6ed6c0d02f76ace8e95d419e38572de6fd0f48225eebf23e581581cb67", + "c1": "0x2bef726f3a335b4c2e5eca0aae60c3a7cca16e3ec2a62309cc1a2728625c6754" + }, + "y": { + "c0": "0x271dd2078878a7f828668535fc692f8ff88c083a90fec251d616788397d2a909", + "c1": "0x24559e6307097cc2da0c52990cd7ec106642d3f74360a3c1447ae815d4559621" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x1c063e653893a4e0b05a748c9f2a36072923bb601a6b90543343141358d2ff61", + "c1": "0x2b6a7b2ce78f9abad39df831f0b2e6c0bfb128945fe8366f7db7edfe1ba10ebd" + }, + "y": { + "c0": "0x14201accd59e9584f9997766b467e5acbe0ba5d47e5cbe49cc81f3e543b42285", + "c1": "0x7d11399e2bbb5b1354a00fbc39928310c36b4d9365b535509664e469e7af594" + } + }, + "scalarBits": 32, + "scalar": "0xd04259cd", + "Q": { + "x": { + "c0": "0x158285972f809ecbacf22dd3a249f9ef769fb91582650579c05bc67e7ece792e", + "c1": "0x88fb62bf4f329057a68efc0c4d483b51132e5138b513e7d43858fed43468237" + }, + "y": { + "c0": "0x28f24c37e11d2e54c90dd7ba39fcc046bcffedd5f279225979bc769d5ee4b7d4", + "c1": "0xf0291f2a011b0d0c1c28a272c6f23835c61c02dff7acff5f2cf6f83157d7530" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0x2bf7345bc5929ff5c5bb62713a31d4a3f4dd0e860bb6f4cb122c6a353b85cd19", + "c1": "0x1ff9a1bfb398237db64a0bb525c9a9aa7082991e605081b92b4c89db03e3cc03" + }, + "y": { + "c0": "0x6fcb9e09b1c66ff84ae29b4fc285b82dbc0381f930e10988fc5af68abfca345", + "c1": "0x13fa9fd4cc0edee469766b634870cde0f58a03d0efe003fc24bc03c426d5f8da" + } + }, + "scalarBits": 32, + "scalar": "0xd9335c1c", + "Q": { + "x": { + "c0": "0x30537c84a55445986902e87ecf96728a09cd60ebac7173d28e8bee3912a11bb", + "c1": "0x51158d3d203c42a602010a024a3eb86bd94e1e6dcdcab2ee09b2cdff560dac" + }, + "y": { + "c0": "0x199edea6b47e8b057d6dfc0e90f54aebda95334d5597868e95da5d586d5e6c9c", + "c1": "0xf20243d28b3085a8a34e4657c5eff687b3a82cbef73ea1c80a3bbd70cf277ac" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0x178c5af80bd181c998610df626e7d4c5f30e68691ab8ced787230ac6c46833be", + "c1": "0x269029220f9c5c17693b987a8ab1a76ab2253a1bf26ce9c50ec1f64793c7e9fd" + }, + "y": { + "c0": "0x895372aeba5724aef38eb16f4e7e892de858db991aec0f4a85be1961a3596db", + "c1": "0x1a2333ac7dbfec6c214267c4c8b4ad66aefbc926df9c005abf035bd4a10ea18c" + } + }, + "scalarBits": 32, + "scalar": "0xf5bdd745", + "Q": { + "x": { + "c0": "0x5bb857dd59c5f3a8b4ca8d915e850e22b73499f98862f6604544fda804ba4f7", + "c1": "0x2f49bea67d5953879594b01af0454c7f6f379498f9ee43ee69931892b0ac1f69" + }, + "y": { + "c0": "0x13b28c2e626d620008402116ee874a01def3b592fc6cae07c94b3536324fa887", + "c1": "0x5046081ec955736b3ee5879c459857c6d2fd88695dab3509fe3d4be30fa75d3" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0x1c1808490a78f971108b54be6564922210e6c380e9bb0a4305324fc9683d4089", + "c1": "0x27dc57e9df49de5ed352197efa9c227ec0dfb831496365a1f9cfe362b4509ece" + }, + "y": { + "c0": "0x183c7d61419c47a2c5399308cf32be15423c482e858d0b714a592b0162a5dbf0", + "c1": "0xfd91da1672a22b74ee0e6c08439ad082af1b8434ed4875c71fb5f7655a6de0b" + } + }, + "scalarBits": 32, + "scalar": "0x384da267", + "Q": { + "x": { + "c0": "0x23ab4a287613efaf124399570232839e60a2ad4340dc5134c127727bb2d7079f", + "c1": "0x13f4833afa23fb9b4b2d7c02de46204564bd5d4587e3cbcc8dda41b3cb96491f" + }, + "y": { + "c0": "0x270f84726973a7b933c369509d0e10849bf4c1b7bfb45192de5e0f81c17398c8", + "c1": "0x29f259858b3d22290068b3c4219160ae0643a513fc163491854c0032ada633bb" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x4e67947572d778862370e1948e27df1fd1089df34f5fdc4fc3892ac40589f9d", + "c1": "0x295c3bb5cf46984b361628dc4d0851dc81044bbb286a60e68b3e5167bb2703b2" + }, + "y": { + "c0": "0x2f0941d81e1db53004d497901b42eb3607a21d3f64574faaffdf4af9414ecdcf", + "c1": "0x3041acdf7b3f829b1da6d1d242b6298ab075203286af7b7a188f115147a2c339" + } + }, + "scalarBits": 32, + "scalar": "0x69b90331", + "Q": { + "x": { + "c0": "0x30076d58fe547285fc2e275f2ffb18150900d9ccbe1d20e5406edb0448131cd8", + "c1": "0x2f83032b02956342bd717ece136fae99e3d958e1ac0817ed8030e0051f7e78b8" + }, + "y": { + "c0": "0x62c0b4348c7ea1481af7b743e689d618df1c3505c9f2384d7ff198346a41459", + "c1": "0x19b5df9b117cbf5f82825637f937fb679d84574c874be3eed89a3ac4d0da4ee6" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0xdfa564e04e7f9567156c98a2e0d86fc5f8d134142f367e196a92a68fad8006f", + "c1": "0x86b52ab193e029a15f4ba080de69ad7c81ae1106f42a669b3c5bf237d62a735" + }, + "y": { + "c0": "0x2ce2754f89e05562a8e6bd354cf7dfe48e0d66114a3e8054299216506224ac66", + "c1": "0x95b363d5294d91fa30abedc79894238d7e4650647aa6052915eaa1842a3613f" + } + }, + "scalarBits": 32, + "scalar": "0x46bf8640", + "Q": { + "x": { + "c0": "0x1b514d3c56cf5601862b69be004a16726dd9f671d8455cadff7e1a8ee32a3662", + "c1": "0x1f3e9cf462226fbe455f8914f863def27f55c8a5ea29ac621cae86581be8725c" + }, + "y": { + "c0": "0x1936c8e63d85e836ad117510ebfb732906000e42851f4a654093c56013f301e6", + "c1": "0xef174aa8a723f3e63bbb2bc9b1948decd94d4a0d0a0b82fb8d7541c1715bd7a" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0x1908e3869a722ff619a8f7a1ca88c05e8601a6ced375202caeb1bddcbba21474", + "c1": "0x1897b1be2b561d304a535d81baa41f958e74cdb7d5669e497206a7902e15dfe0" + }, + "y": { + "c0": "0xecbbc55a8216d5b0cca24dd596043223f30ebd8f327e2bc9c1fa5184eca3202", + "c1": "0x16e77962a9c01c5dec89157a499583748619523d068c05e278cfc8ac7ac2b7d8" + } + }, + "scalarBits": 32, + "scalar": "0x3d72ff7f", + "Q": { + "x": { + "c0": "0x288cf8b889c60df9359ae0a96d433eff6d75a6c268d105611416f346a7a71b20", + "c1": "0x7eb6ab9cb170df0388e4a926279d852600a62e1b11c939c3f473c3513801dd5" + }, + "y": { + "c0": "0x10645c9e435c26ecc89d206ad1b3dd4565603c52fa1213fbd29e071c11550728", + "c1": "0xafa8d1c25965349b6fa3bac477a740fbb271d8e1b128c468413372cf349f4de" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0x2c458a75161da182acaeb9e5609f182b557c271b77127c9e9f517e633a31ba47", + "c1": "0x1e4b0eee531c197aa22b82af46a9ecd9b93d165cd4462e8de3906c1b53e9ddfc" + }, + "y": { + "c0": "0xf88a87cebf1f4b4789d1ce7592f2656d0932bc7553b4f6fb10d3d67af4447e9", + "c1": "0xfb07466a01a394c98678be25edcd1147c4b7ae3efb303d06f76f9472cdc7c03" + } + }, + "scalarBits": 32, + "scalar": "0xe39a8134", + "Q": { + "x": { + "c0": "0x41b8548f43f05842fe1a0eb5477a709aed036bb599c95a08fc4d385d307dff7", + "c1": "0x46eaa679efb1e07b9ab0b747e3d7ce98a313707579cbaa65b8571ef282677a8" + }, + "y": { + "c0": "0x48a7208ed48f8ea1e6323851f58eb58abf985d6d3ff01e4ebc87681337e8df9", + "c1": "0x2d58a917cd1d258405227907ac6f74df3b5ae01fdd1116e145951a567d6ebfca" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0x18bb780ea6c8645cf075cbaf795f9a8d416753b06d379f24b20d442c79b47de3", + "c1": "0x292185bec02a33685af4964d7a340a5e32b26a65ee14d7a4a0a934c5be680d1e" + }, + "y": { + "c0": "0x5effc675b73e313e692318045e2533ebf83e0db6e394ad19a8d6dea35809057", + "c1": "0x128172f6033034541003d3fe5d6f7e7e8d2fe2c8b35ca5225371673c43a78959" + } + }, + "scalarBits": 32, + "scalar": "0x90616623", + "Q": { + "x": { + "c0": "0xc3b259ce3c09fe428360e9549d8bf219b571ab0d39366ab051e28d7dd8e1150", + "c1": "0x2a40af2d15033a6bd4828a60eb0a006f0f4b314d9158a4d12dc15a601c7703c0" + }, + "y": { + "c0": "0x296820032263022b1dde52f00796b845dd1a3374d0d0b4cc107fa7bd8a1472bb", + "c1": "0x1e20d6fa622f9260186071d2e7afbae22c3b6dc0c89135b923fff1c3352d54ee" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0x2394a4404783377dab6954dd22404770499effd1b6b3b47e0ef7a35aa6306ddc", + "c1": "0x23c46225cb4d0f1d9c1303ca812a86309b28a071ed20b62b3fec90705a16de25" + }, + "y": { + "c0": "0xe7a426eff8911fbb2e3afbf350029edfe165be7616844f1299ecc5732f1c3fc", + "c1": "0x1f38277fb1a62cdcd411010f90fd4f67f70680696db380cf40fb3a94a3cee937" + } + }, + "scalarBits": 32, + "scalar": "0x87ddef1f", + "Q": { + "x": { + "c0": "0x4dcb5bae80fda6f0ff9a36ec7b0b31b0862687e05e39b98eb18aa2185e22929", + "c1": "0x110483eaa8f2b096f7e9c5a107f25fef22b3bf47ccb77b9ff10b193814f674c" + }, + "y": { + "c0": "0x2b0d1f67c1256f4b8a332779c4796c46d2ddb525fef66c76fccde1b8c205ac51", + "c1": "0x67b98834f9bf758fb835e77804c593e733587be10f2698a091d73dffe0b7c71" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0x137d443538ad72ee7a622506ff54f85787d8d970499a91d15c28ce487353f6a5", + "c1": "0x250fa4f5987768469107a001f2e41d5293cbdd196ec946f9bb5594d03add4d90" + }, + "y": { + "c0": "0xa716d4152888074c70439a907f21797d17092d2c7eeb204e5a9d7331042a43", + "c1": "0x2870b4b20d3bab379704fa0b2a0c76f9bdadcb67ccef70cf4aaae44c358aa3b2" + } + }, + "scalarBits": 32, + "scalar": "0x5e0544b7", + "Q": { + "x": { + "c0": "0x1feee6e265fa592d4e5287cfca83ce25223d1bdf3bfd93a45c73bc1bda4cefa6", + "c1": "0x1cae74f125b5f0030fa33be4d4c3702dc212379a171b5bd51b71a989b12222da" + }, + "y": { + "c0": "0x164a37ba6e8d29859f1443855411287da9d5ec6849cff243ba1f5c70234636f4", + "c1": "0x2551de5997c5435b46ee1d4ff7f3c3e34d548f2a821de7d2c5bd933d0daf547d" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x4a5f8846d3d83d9400fe0df8a742f92fc4d855549e80a59494eb6330a901809", + "c1": "0x6734e58547c4847414c9169b24aa4635e36a29e2e276d7f43fdfef719f1e6b1" + }, + "y": { + "c0": "0x1e1991bfea4e910eef1c43691ef764be5ebb1c91c08d53117a48403233ca318b", + "c1": "0x1c3828d6d8ddb611350ce8d61ecab97260ae16deeead4c382c9fdf13cb535aae" + } + }, + "scalarBits": 32, + "scalar": "0x6033c637", + "Q": { + "x": { + "c0": "0xb69f4ef6be24b8f7816d52197b7a2c85c9020743f637c2f57707ac3be7bda0f", + "c1": "0x26d45be56f9d0c540eb508b12d61b323f334f1f93b97bd0264600387cfe4b96b" + }, + "y": { + "c0": "0x2ac1706cbcb6b163acf56c0c88215948f9c9ec9d23f047ecc1d43b16d18adc29", + "c1": "0x2eb9686215faaec58fa43fe6a1c037ca83395bd4474daed84b92250e88122489" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0xbf5be6c3fd3d32381ea85323569316e96e5ea246b0f8e965f5a1af753633d89", + "c1": "0x1489a4ef0d17b19bda82416c70c4aa664c8c01ac6d068925147f825b0ae283d5" + }, + "y": { + "c0": "0x197a969987ad91be0e9bd2cc0acf469382eeabda4e083f7014de9e32652b9009", + "c1": "0x10a438eab3483a12c88772d57ec1a922f646ae7cde7b5fec07b3c32bfdbde60" + } + }, + "scalarBits": 32, + "scalar": "0xf245eefa", + "Q": { + "x": { + "c0": "0x126febe3ca4a19a4ecf782d2642e0b55e104b9ba63d47d0321263917e81c4efd", + "c1": "0x1ea77a8fe1987db85bcff689d6980798c42ee4cd16434e53b35d9c25e92d276" + }, + "y": { + "c0": "0xc2506ab48771a221cea0784510c20928df474851586a97fd3a0cbecb5cf4362", + "c1": "0x218a4183635b3b1592d6e1be65ebe3c77d670231bc5aebf3c9cf7b76202c7a09" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0xfcc5b8ea32b2548aa90f2ce04ea12c9b814860b06c19f6b3596bdb20314a3c8", + "c1": "0x2c11891beae4aabc89fabcc789abb53af7a17b345a82b3e44aae525ea52eb902" + }, + "y": { + "c0": "0x218e0e8697365c016af33908cee95bc008892bd2ff0bb664afc158d8bad3794b", + "c1": "0x154d8975f096c874f28ab4ff02a29fb8bc83da9e77d856dff9283bac14e010a1" + } + }, + "scalarBits": 32, + "scalar": "0x76683419", + "Q": { + "x": { + "c0": "0x1ddaeee08fd2bdc72b66d5c5c88047ff1cb3693835aac7ee4a2457d46cbddbe", + "c1": "0x2602f2b386107f1f59c7b0743e123a0d7253cc7432e6e3fbb796588d6eb0575f" + }, + "y": { + "c0": "0x24fc7b929f9f8f715b8a6268638ac7342fae786ddef4f1b2111402a97ab6509f", + "c1": "0x18d24fc464437d87f17683d38acf719b17bf50265d6860984c42461b665000fa" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0x2fc5f715253677e7af6a2292c6cbf574782223874150628446613a302f6abea0", + "c1": "0xb27c5a3089ac4b269a32ae5a3194c85b62ce21cda9c701730e8ce33b4b3c8bf" + }, + "y": { + "c0": "0x2eecbe41039d99c37e6217269aa1cb8a6adf02ae82ea2713e9cc204ea7ab9f60", + "c1": "0xcb6e30daa32b985a2ab8faa3fa865d86342c3b6110f54fe37761e1922c82bc6" + } + }, + "scalarBits": 32, + "scalar": "0x87355399", + "Q": { + "x": { + "c0": "0x18a5ef88f2823db3b687e654c5d14ecb47f6458e7b1ceb0c60a8a5b632ca4749", + "c1": "0x75f9994a9b14c1ea7d29f5ce5e44c1785c8ab1bf3124ae2ab87fab32f6f3c83" + }, + "y": { + "c0": "0x2fe41bfb48b4f90974a7394c3cddfca098e4cad47884e045472a480c26b255e0", + "c1": "0x23d5a028549541043189497bac766907b90a6ff0b5ffefed8f174c27dd76550c" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0xbfe53b46fe2f96f53061d8a1bf826e63fa175da43e0eafc078767c92753483a", + "c1": "0x78926b1571687613ec4e40287c4ce9b8554f96f58576b8f3ee3f53ba5799474" + }, + "y": { + "c0": "0xe59a1f874cf818d4f22d5d6eeeb9bddfe5bb89bd00c675be8b15f0e13c80ffc", + "c1": "0xc1fd043b06296fd548a17381e966b5880a98d3a0936d77bbec6e4e9855fa2fb" + } + }, + "scalarBits": 32, + "scalar": "0xed81dc9b", + "Q": { + "x": { + "c0": "0x19f5b16aaaa8836697c484466f768b3030054810fd6ca1deaa77f8a2c4a5a46d", + "c1": "0x1943a77ad8c98ad63f5c14d5f1686633a6fc5cdcecb0e347fde5e28111038731" + }, + "y": { + "c0": "0x2ab86cff594742064cd34025d0e7a8bfdf917928400a21bb54eca32cb5293306", + "c1": "0x159350d80217fc25ea851f3ec56965e136cd79d1634384964b3f725e25986cde" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0x25a4285665cc2545de67bccff505431a7f2d9ae699659fce1e6e5b9484d96cb", + "c1": "0x278ba0ce6daf9b5ae6fd63ffeb98709722133f5cae60f08afa784adf13b51b8c" + }, + "y": { + "c0": "0x27649f50664434cac5ff32faa57c2afac827a337b17ff2ff54e7a4a8e5ca0c60", + "c1": "0xc01ab56241a8c27fd1ce429104ddf4d4faac77084d091baed8197037f37c74e" + } + }, + "scalarBits": 32, + "scalar": "0x6ae88c5", + "Q": { + "x": { + "c0": "0x1431fb66ae78c906478c704e3e8ba9a0b3ab8390fe5e5ea01cd764ac12ce785c", + "c1": "0x1b586762d99d487ae9af0a577342aa141481fa8deac52bdac03485c769ef084b" + }, + "y": { + "c0": "0x228965a1bd7a97d6f0d696593b208a5ac7b437520a0a180d622c551f75ccaaed", + "c1": "0xa81970313fde6c3d6a67a1477f32f99d3210ca7e67e725856e67b428e89f72f" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0x63625ba09ca8bf574be9349e5564a43242ce4b4e6c4f3527d3601f6e41a3b4f", + "c1": "0x86dbf1e72dd09ab8fa6417eda5b64dac85033f35e49ae13517bf5e41b90562d" + }, + "y": { + "c0": "0x23f1cf5b316fadbb7be8a88b090df169ecd41a343a220d6bd3bc77a6c9ce7de6", + "c1": "0x1226cb9fb0e5999018933599c68b7b4aa2dfe1ed5e0c089059d9f2b584a81044" + } + }, + "scalarBits": 32, + "scalar": "0x9b532f89", + "Q": { + "x": { + "c0": "0x1b865ea8f0bf5403c0cf2ae0a71698f2a1a8175d1644cf23f25de03b62974e2b", + "c1": "0x19ed1589e132611b8d47f0ec2d9330ebf13a9ecd987998a146b11b70d2438a8b" + }, + "y": { + "c0": "0x1e91acecf4a5c7c8cba486c79a9ca9d3c5a61be2c2e58af24835756d409865a4", + "c1": "0x1b6829faed5d8083c7838cafe43721dc8536173422169820ef6d8de949e82de" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x2e6a872c01802947ff7e2d661cd1c1a93e92c9b36a696f27d77733a82313e827", + "c1": "0x1fa7db5c5fae7092032418bb5435069f22560375c70e277af04926b0fc26257b" + }, + "y": { + "c0": "0x29471363f4460914fcee65a565e453810c499575ca165945858de96789c559fe", + "c1": "0x13b37b1e5e96ed519fdfa4e25678065246e1ddc38e85a590f230e55ea0460f78" + } + }, + "scalarBits": 32, + "scalar": "0xb640e7f", + "Q": { + "x": { + "c0": "0x874d6c74ec601805f62d7682edf1580b5a395e7f10d8b8515eaca94bc942e52", + "c1": "0x2d9b657dcae9a481a564d0b90bf4be5aee17ef97cd633f097db1267abc7ec3ff" + }, + "y": { + "c0": "0x1351558affb8f9b48bf15ac81c1b93978261d8b4060c8307291d3cc063b361d5", + "c1": "0x2f7f8ebc3e05bb17416aa114008bdd12ccd4f7a4d5d6fe0b0633be6ae5dcd015" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0xaf86712940d0f552e739a2cbccab8e857cfd615867045f0f18ca2d22250abc8", + "c1": "0x28f1b2c0e95dde8abb21e7dbf27c93cbb079a511a00c37d1b42e2bbaeab35690" + }, + "y": { + "c0": "0x19548fc4eb5984567e10e33f5287f717cc5a392993b6b4f91824118b88c7a5a2", + "c1": "0x223fd719cc9dfdbbacd8a41acf025ffe151a98438ad94ac4ec8836bc3bde80aa" + } + }, + "scalarBits": 32, + "scalar": "0xdb390bc2", + "Q": { + "x": { + "c0": "0x135477268047380cd63350f50b50067a822da9f376887091f616bf47f7a0b436", + "c1": "0x1594cea0644f16a0a3a737d874847eeef02db4b5629ccfafa699c5b449cf30bc" + }, + "y": { + "c0": "0x1ef8e412e8b8b6348fc735ea498a0cc170762a6c8820292191dcdd513aa00c15", + "c1": "0x281a2d3ff6433023ffb71c61c2a86d8481bc0e0fe2403cec7455a5fcbc2b04ae" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0x61a04f4cfa0d68f073b05189a2efea4e1637cebe550952cb1df822ad5588312", + "c1": "0x12121259ebe487293902a6b5d58d3c05e47573844b35a90b67c37e7220c32ab9" + }, + "y": { + "c0": "0x2d8c4717fde79e14a68a6f4b0906722b8a6738594345007064030d93cd5fcc7b", + "c1": "0x28e903990c13cf7638d6566027131113b4c7847c46ee90c8a45d58f6708a0d48" + } + }, + "scalarBits": 32, + "scalar": "0x114e61a4", + "Q": { + "x": { + "c0": "0x1eca8bc65d7a63dd595c41c35f31a6b4eb7c9263cc36b74129a17d8856e55caa", + "c1": "0xfcba2fe8dc6437d64d1ba2f34ed2437d1129a8ff4eb7d7560bc6547b86f64f8" + }, + "y": { + "c0": "0x9863a4177188c5163bc89c4ffb9f65cd3bdec305ee787a8cfed66a63734f75e", + "c1": "0xb679f18a66f1e539f282ee27222eb1b26c776426f771da7e79825d064b80ac4" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0xa761424b49b1ec6e0cb5782fa9112342f02a9fccc36dedb9dbfcb0e09543053", + "c1": "0x2e15ae9937167f082156388d1576d53fc243124f431cf8f2ca7cbf7c0d6b6efa" + }, + "y": { + "c0": "0x286e1c2cfd3adbfdcc217083122295b85a36ba9738da11c8f0e417c1b8b6b045", + "c1": "0x247fd9b77cbfbd30113c099bc0082111d0eedc3c011346804f319690b4761511" + } + }, + "scalarBits": 32, + "scalar": "0xb6eccf41", + "Q": { + "x": { + "c0": "0xdb24777c44bb7ecb9c194aab8db8b75e465a3ee91b0cda2fcaa516ca9460654", + "c1": "0x2170716c54f9adcc8fa388b83269541be280dddca98eca34e5c77e3e3c0d1b9f" + }, + "y": { + "c0": "0x6454c3e0c93d98912ebd95b5da1bf4cd513662b01b8254a5f1d4173c0fd16d2", + "c1": "0x5130a3af9ee41cfe9e9ce2c434a5f9a810790d28d0769bd1f3730876433118f" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x17fb7d1649d1f0e7010cbd28c32d25d189a665955339e30b56f69352e5e95131", + "c1": "0x4ee8ea8db7b8fef55c763d1f593fef4dad52cda809c28fd3a0856742c42c9fc" + }, + "y": { + "c0": "0x2f9cdfe4f8946ddc94cb36361312c7365434365729965b45f68297720bce31ba", + "c1": "0x5a82731ca1ea02c56b90d92b4ab778d048bcc2fbb337a2d7608fc7382fae9b1" + } + }, + "scalarBits": 32, + "scalar": "0x19ea5852", + "Q": { + "x": { + "c0": "0x13efd94c0f57fc8453b4291ed37c74e2253fcfdff24b099c04ccb553a7408db6", + "c1": "0x12be8c1ed147b5cd4fc53c8c81688cf7b7970aac7ef4a3b44857573baa082ef1" + }, + "y": { + "c0": "0x15f56f2c4c3a4ce93937e6c29586e6944584a3628a9ab510b56e20ed13df4fa3", + "c1": "0x1836eb99dddc27814c072378c14906b8f17fc223ab9457a6c25133189ae1f960" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0xbdcf293dafebf79d57cb94c48174a98b77278f6c1c70977a84663cf0d780b95", + "c1": "0xd0b02788a20012b81cefd522fd68c3bcfb9718647d3358bf6553fbf5a7d3364" + }, + "y": { + "c0": "0x1df64238f2b82edb4ffec0716ef5a51c9725778dad0368661f22f217264c2f9a", + "c1": "0x25245868d44d6c95b1c61b9e5ab0cdf433ad38f2b3035631f1e7ca4e6c847f2a" + } + }, + "scalarBits": 32, + "scalar": "0xf55541af", + "Q": { + "x": { + "c0": "0x15747b304f725d77787ef9ea59ba938c5e7cc37291c297d1c6c67f4a018e2c9", + "c1": "0x13947621777a7338172cfdd392eb7e9391dea0779531b69c61192d16b3075c63" + }, + "y": { + "c0": "0x1a40bab9bfe2595bb47e1dd855e2bee36805ed8c7fb46ab69b3b372a590ab65e", + "c1": "0x2a769c173eb34528feb30a9f85b7688353980944802e1b9eb6f8cda31ba00f63" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x2cc76860431f6d309c4bdbe686f47d71bc2acd5a3c4d64ac2273df22e668cf7", + "c1": "0x1239f707e73670bc02ff51087c8b1e363f8a8e740a2743734aef63efec028ae4" + }, + "y": { + "c0": "0xa8b9277721aa620c940e9a579b05ccd4f552ad5b1b4db84fccd630883a8472c", + "c1": "0x29d5ddbc925bdaa3c83aea973f3fea0e6f7f834acd46908a128273fcc39dd7b4" + } + }, + "scalarBits": 32, + "scalar": "0xdf9e86f9", + "Q": { + "x": { + "c0": "0x213339869685e009471681d8f7ff4aa15a88a55b895fc233e39345a8e97961d7", + "c1": "0x278a10eabbfd5ee96f3481f14bc858b83fb854d29e4746775273fdf8b73df99e" + }, + "y": { + "c0": "0x176078ccf9ec1f4183aa837f752219b930742ef732d3d8db6628f66e5183e2c4", + "c1": "0x5aa6f9f81f47c3aac4391620b7192e795d7000f112a3dd7a09ae02c12e4fb1b" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x8b41718b1419b495a57d515e24ceca17805a2768a5548edd9950d88b0b59de1", + "c1": "0x2efeaf9a18d54a06679b988b6616bc61806e6bc64b23c1ecc642663d903c0861" + }, + "y": { + "c0": "0x1641cf7ba72c56fbab8c9fc62421540b91f5c1bfb3d75941b3c5d22c95057e30", + "c1": "0x2ad77d870d98b05125ec0eff52c1292c11542848fd4ef46893cba24c25594d23" + } + }, + "scalarBits": 32, + "scalar": "0x70fd8dfe", + "Q": { + "x": { + "c0": "0x1d487fa8f4e8f1930ff3655b1911a5496282a9418036c4cc61173536329cd514", + "c1": "0x2b34d0d5ce165f616dc8f1c9e45f74e64e50d631d0a6806241e7ef35130139a3" + }, + "y": { + "c0": "0x233c4f454b7c6dacca4893a6a17e100dcf07dd584aa127e9d00e9e43552c5b9a", + "c1": "0x493f9af6334d424cd225405478d8b8f83ee5696407d7a48225ed3ef3cca28fa" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x18ed416390eed89db0ebeb36317b7c7509141a3f2f06922a491d68fe9f08401b", + "c1": "0x91e6c11db4b845f03205f1142d5f1f5e0caf5fb98fc9697c16d4cf11f651874" + }, + "y": { + "c0": "0x1ba88562888c425a1dc52fcb96fc1e7f7d93c319b43541a6126e32c7228a31e", + "c1": "0x6f0d64a6d31249301417b65f71608042f2303157630a4871a6732e46075f4f2" + } + }, + "scalarBits": 32, + "scalar": "0x1a5b64db", + "Q": { + "x": { + "c0": "0x272c6d648ced8976fa91b262524878bffde5130df150a6ad9eca0e38e8b49712", + "c1": "0x2d3e4a28d7650997f8b502d169b99ae6c5d67964aa829b6816faa382d3ada65b" + }, + "y": { + "c0": "0x2d90a900f1646ee31507f2f5c99d2c665e83a44fa050a472c16c81eb9bdb58d8", + "c1": "0x2e11d0ee422f478c359a468f0097a4aa3e3bec19df84ee5952b7120704daf3ec" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x2b8ff291848d377017b26c5ef9cb955d3ecfe9f21bc68b74e003255775be7d3a", + "c1": "0x26d3aeaf6749624b21333906bebbf5ee871b4d7c949b94c83844c56ab39ee3b3" + }, + "y": { + "c0": "0x11cb41355eb253fb811d01c5c02f15ccc25d8dfaec734cff875a28b050c41cee", + "c1": "0x12e4a6842b02116abcbf6f6b97deff1129d21c7b5ff2548da459296fa818794" + } + }, + "scalarBits": 32, + "scalar": "0x547c210", + "Q": { + "x": { + "c0": "0x1427b52cb84f5bb8265d4fc3aa857aacf24699bb5b0aaa82f3362e77a4f8b64e", + "c1": "0x19a14dd7cc80f70f67659f52238442f1ff74f5be4aeef60243889b6901a750b0" + }, + "y": { + "c0": "0x151d14ef5d26fd0dc6407d36b6ac901c13c74a96bc8455eb023ce708e0634fb8", + "c1": "0xe9df2b881ffc9e6950f3b66c407ba9141d28cb11d46b04e0709a2adbbf11dee" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x2c916f06f8231872b95939a7241e8a0f726e9e971fd75a184dc6620c32995d65", + "c1": "0x2b9050eda5925757e0b1b3c3795b99671dad16b1d046e1d870aabe49fb1a1b71" + }, + "y": { + "c0": "0x15bbaf27fa285a14f25d97f3f210375b37bbe81ab423e83152d8a96a4dd4c607", + "c1": "0x2e889b65d20214deee20b2426fa5dbfec1fecf82689f1d79bbee2ba8d37912f1" + } + }, + "scalarBits": 32, + "scalar": "0x77d58936", + "Q": { + "x": { + "c0": "0x2b024eb57cc581b3d8529c44dc2d4ad3969d531caf20682c9dee7e2bae7f62c", + "c1": "0xebce27ab20adaa77a7be6a175ff8a5383e1377ee00448b9f588e00abfe4c364" + }, + "y": { + "c0": "0x1d375176d50883f63d55b317be510c6bb5ad89f5ee1ed9bd051eb31af9aa6cff", + "c1": "0x7378f0095b649f40783c86d21fda606256db859f4828b3ecebae57faa5f762f" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_64bit.json b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_64bit.json new file mode 100644 index 0000000..10ea070 --- /dev/null +++ b/tests/math/vectors/tv_BN254_Snarks_scalar_mul_G2_64bit.json @@ -0,0 +1,1020 @@ +{ + "curve": "BN254_Snarks", + "group": "G2", + "modulus": "0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47", + "order": "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001", + "cofactor": "0x30644e72e131a029b85045b68181585e06ceecda572a2489345f2299c0f9fa8d", + "form": "short_weierstrass", + "twist_degree": 6, + "twist": "D_Twist", + "non_residue_fp": -1, + "G2_field": "Fp2", + "non_residue_twist": [ + 9, + 1 + ], + "a": "0x0", + "b": "0x3", + "vectors": [ + { + "id": 0, + "P": { + "x": { + "c0": "0x1625bf258f7f7be15ee438ab65c97393391fb36133cbb17c44c98efad3b04f06", + "c1": "0x25e9e71cbbb71cc1720d0102a7015f1224469a5e45c80017f4c212f34134294a" + }, + "y": { + "c0": "0x7cfda5f906b107ff2477779f0d03d4795049df8125d8131316ab2bbe12acf87", + "c1": "0x11f787a6cfa5113a8071d6e502b0644a8884b353d6a93b843e21b6d6803d42e0" + } + }, + "scalarBits": 64, + "scalar": "0xd669ae5134323e4a", + "Q": { + "x": { + "c0": "0x1af31e5ea5c199c5a63be03b495d8b753c0b7ba801d746976409aaebee2098b6", + "c1": "0x14d84247a981d53fa8cdf33696b5e309a0f9277714c9d33c2179e7c1c1559e5e" + }, + "y": { + "c0": "0x11ac4f18ef5cab40b22448a94fb916df3f8031f3df7d1ca0fc9d7e3819763e6f", + "c1": "0x1ed74ba43797e386433d208735e128c42c3a1fc85bfcd27741caff398a5f3581" + } + } + }, + { + "id": 1, + "P": { + "x": { + "c0": "0xf9d0aa4a77df87eac2790aba49bcc0d9a3dfe7f7de1c678574b1d0729dc6e67", + "c1": "0x1d0e37471f09b44ab8069d17518251ef71ec136e74301ba7b3dd2c51bb33837a" + }, + "y": { + "c0": "0x2df7af9e46ff7c16f2427e20e2d0d708766176ab1bbbe4bae8941e7cee504672", + "c1": "0x1b16dc319eece455a14d7621ae6bca4818371734be4adea5712d548b095b7642" + } + }, + "scalarBits": 64, + "scalar": "0x95d4eccd6f28e58c", + "Q": { + "x": { + "c0": "0x241a7d91e282785a93ddaa9196a17c7d51fc6064846f36b5aa787a790ee30903", + "c1": "0x2e12dd9d2058e8c1ae4d98e990fe5f497f1828b4a2943531c263b80cb57081af" + }, + "y": { + "c0": "0x1a9d7545307836e589c6aefdeb9e8834cf6e0338c09566fa913b2f2517dfd0f1", + "c1": "0xcd7b1245c8e93a7192dc58de22cd1639d867426088727267eeda2f53f2e6eb2" + } + } + }, + { + "id": 2, + "P": { + "x": { + "c0": "0x9c49fe95b91564db59c6c9ffcf2d14dff5fde35a4e77dd95fcf94dfd74804f7", + "c1": "0x1e30e63fa399758261217bb25523ff84681686bfba360e56fb3d7431d39f98e1" + }, + "y": { + "c0": "0x62b430ed4971abaefffecc337c3ddc73bb8715d7a3d2353cf6e4b76ae8b6234", + "c1": "0x10f484d5311045b0af3e552e8acde2f3a116eb6005fd36376fae9f0ea1d00246" + } + }, + "scalarBits": 64, + "scalar": "0x22482e90993362b0", + "Q": { + "x": { + "c0": "0xd427fab1e417751ef849ef6a5e069ae841eed131cd13d25cf76ea4a50307fde", + "c1": "0x1456a957b0b54d1caa2142168367e32c4a207b6f852dc3fd982d556aaf170f8c" + }, + "y": { + "c0": "0x21a2d7dedbdb363f2986c023ec75e39c892472c6d75411c72c0da425c78aec8c", + "c1": "0x2f7d977760e7da01a3d371f94fd5f528c8605fdb9f6da989fc1bd838aa140185" + } + } + }, + { + "id": 3, + "P": { + "x": { + "c0": "0x827a47e301573ab79c33f826460d2c8cb9f0c910594b9aef8b5db1a56769a37", + "c1": "0x18364d233480f88a408d0175da8a307b2d4bdf56660920407440aaad91fb8be9" + }, + "y": { + "c0": "0x1c94709ee4522ad87493312afedde3d6977b3a08aaf8d6a771ec13231e441045", + "c1": "0x1fbe6be07c1c564cb9a3d63f7b19c8fb25503bd74aca911fbda53bfd1c4212c5" + } + }, + "scalarBits": 64, + "scalar": "0x3194a616c7051cc8", + "Q": { + "x": { + "c0": "0xe9134b19354930a033129cd91818b3f23772ff002b4a1ea6360e52ca5f43b88", + "c1": "0x441da963449cfc8cc303283ac43b0e356d74039e1cdc6f45d2702575d08e499" + }, + "y": { + "c0": "0x11e52b90a2014dd3a6a17863d264e2f1f950c740b397a6c3e3ef6914d2041e5a", + "c1": "0x118d095430c86b871ac8da5c83922175c34bfe4d295c598726bf3180b24546e7" + } + } + }, + { + "id": 4, + "P": { + "x": { + "c0": "0x4b6ad5b6cb0fabc25f5a66a3979858b8fea4eebfd1a4470e4b3a6924b006112", + "c1": "0x27d3e3b73ffda5ec398157a3ff6dd2380ee6b2d02faf28bc2baaf23713e45dc" + }, + "y": { + "c0": "0x290902771c94305e47b0ad9305f6502ee38b9687791accfc1b94e8b1f4d74810", + "c1": "0x1128ed5d7a58ee5cb2754d4307d6465832a64a1f70675cf3e0581f3d2e0b9a29" + } + }, + "scalarBits": 64, + "scalar": "0x469c800682a838c1", + "Q": { + "x": { + "c0": "0x27a7f7e04159a7564d4d663e20debe6f4a65a23c54d485bb5e9a430cdaaad80b", + "c1": "0x5cc84b31a97a7b4f928dfd8612686129e76ae179cf7f75dcfdf091275241e20" + }, + "y": { + "c0": "0xd7907c7b3bcad81376fb340849f2f555c236788ffee046bda3e876dbc8291fa", + "c1": "0x9a9fff86f8679103f17230b2a6bfbbc592c3356421ef3fe37c57bc15094a1b9" + } + } + }, + { + "id": 5, + "P": { + "x": { + "c0": "0x1dba67b62cd3a7f5e6156ce0ca888274f9120c568fab4d16fd7cbf5d16bb2bc0", + "c1": "0x1babab90061ccbf7c35e625d18ceac5cf06ec1c4ff79dfd982c1b6e350451275" + }, + "y": { + "c0": "0x21de1c319bb61c57cd0beb90ab8cd09dc3eaa1cc7c48fdb4b54ca01c86d64cc5", + "c1": "0x7bd0f8a4a307e463705c0b329390dd736746cca845a78b402c185d6ee5be22d" + } + }, + "scalarBits": 64, + "scalar": "0xa902fada720e2aa4", + "Q": { + "x": { + "c0": "0x1a6b7aaefbd17d6010da3fac6ee959b5541fb3cf977ed3a1847064c7be999643", + "c1": "0x7dd9cf88031a97342dbd11ed163623b161ff2982c06fc5387740a36aa9b134c" + }, + "y": { + "c0": "0x1b9bf40b8791d7cc7a770795ea8947a11b3e21c29b65222f0459c4c19a4b5bdd", + "c1": "0x202626642f9f3f9f91e841bf97f70d28022b1c1c5086bd68f0db89871197ad86" + } + } + }, + { + "id": 6, + "P": { + "x": { + "c0": "0x29cbfc4a62d6524a3e64870cd73557122c113bbe05b44dbb1746a138ac3d5c8e", + "c1": "0x2e8ce32a231a120be1bc3e014223f540494f51774ce301be29bde165d3e17282" + }, + "y": { + "c0": "0x28a42efa345e1d659d067b097ad4222636486b3a2e47c7f3e142ab31aea4594f", + "c1": "0x423fe09024d357c50b52a9260cd91d3f648235fbc9f4759bb89d03f181619ae" + } + }, + "scalarBits": 64, + "scalar": "0x2a52bdc0195918fe", + "Q": { + "x": { + "c0": "0x463a65f6f8b0ce567d483db087042eb263fcc810b41be9de613a341c6fb485e", + "c1": "0x179d28fce2eedc031285dd69d2e919c00637dbd9e62997ce794f47d817132b7f" + }, + "y": { + "c0": "0xe27547758509534f3e4b88b1a1aa04a3b5aa7d71e112cdfff910767940d4862", + "c1": "0x206d9f36f94128a19aba15cd11ae588103af05a989f618f0add74aee0cbdb8ed" + } + } + }, + { + "id": 7, + "P": { + "x": { + "c0": "0x10ea1a9649aadd9e41cbd47a1ee93d4f94d755033ff0526197f6a7c8e7cf08a", + "c1": "0x1a1ff1b5ac169dfd1accdb70cf5e03af2d9832c5877f03d59238fce7a28646b6" + }, + "y": { + "c0": "0x1a86b2ce6b28f0bdab07cd56ace1c6a9cba8c692b7f5cfbfe3333320413469d3", + "c1": "0x1a0f347076646f54aaae88e01d76e51986971b428f9f136454c9dbb5b2ad7d" + } + }, + "scalarBits": 64, + "scalar": "0xa55de71ba38bd4b", + "Q": { + "x": { + "c0": "0x15f3aec4c8882536734c6e5cbb3e52babd33bfcfb5aaa069195739c6861b6b9a", + "c1": "0xd6503a64cb16952fed049fbae91b102113a0e1a60c3275273ae0f8501242928" + }, + "y": { + "c0": "0x23206525669f9fe0e4709c85c8952c3b70457bb1d4c2d1a72b8883d12ce73777", + "c1": "0x25412d4ca1e1e0449a6f4a343044bef0f41784aa1df83e77a887f5e3c1d56b7e" + } + } + }, + { + "id": 8, + "P": { + "x": { + "c0": "0x1359666352283e4da607aeb3aaffa26b759cc7a35a31256ea059028ca3608f75", + "c1": "0xc492dd0cf87c56b7e01ea32effa0fd0cad81ac3e6b270e3b8e7293205659e6a" + }, + "y": { + "c0": "0x2b7a46b7b0d62baa3a019aa5fde274fd15f57bd64aa94f7bbd45af05aefa24a4", + "c1": "0x2582c239921cb5b8915e62ea3743ec5c2ef741a327d2f931f1393086ec75e89" + } + }, + "scalarBits": 64, + "scalar": "0x56465cc249af9ee7", + "Q": { + "x": { + "c0": "0x17a85d870893f95e1f486bd97a13d8f0e141b9e0ca3697125a2a8c6ca7bd31f0", + "c1": "0x2b05cc23ed3a3e19d2363c94f06a30d00dfd81e01028ad04e19c6b1286341fb1" + }, + "y": { + "c0": "0x186514e05ac994639410a39c41f9b81ecf24bab1ea581be276e0166bdaeb462c", + "c1": "0x262ce67170a0cee62fbd1fafe75faccc7843f5cb0721911165ec7ab7a3a982e2" + } + } + }, + { + "id": 9, + "P": { + "x": { + "c0": "0x1e3fc2746b05f0e371f605246fa59a01d108c278b2087c4aef0fea2db6a7038f", + "c1": "0x1804a39fe3640a128c1ec83b27bf76fbf5c9894b8744024061b4d8e1715abb26" + }, + "y": { + "c0": "0x1929fca1ea228adf39e87f2eb60e06c9e5c5252a230ff2c8bddfdeade3725022", + "c1": "0x1906a319121d30571d6cee089fcd9d6ad34658d5ed81676fd6c9244883bdcdea" + } + }, + "scalarBits": 64, + "scalar": "0x73c1a7ba4bf929a0", + "Q": { + "x": { + "c0": "0x17de7f9c1bbb90ddae319673221427220579c1d6dd694a7ea114c0efc2873fe4", + "c1": "0x28bbb1ee4d282544c056bdf78fccd291075bc7362260d74e448c66cab3df2b6c" + }, + "y": { + "c0": "0x26bf85378b3277c85bea214bc7fdec5d971651a3c3a32a94b9ad34144d90496a", + "c1": "0x79cc6bbeec5d78914f84b216d9fac02cfe12644be6090d8fccbdb6231c45149" + } + } + }, + { + "id": 10, + "P": { + "x": { + "c0": "0xc6d5de82337cd5891e35a426e1c573f8f12b0162982cbbb3453717060652d71", + "c1": "0x2829706f1ae0713d09585a4ce6cd7d53c2e947b2f075b3974a5d3a1748a49b0c" + }, + "y": { + "c0": "0x16c6d7896fd209952fd2809a3973672e0e132cb6fd7e77fe3b9a9f8788731fb7", + "c1": "0x4184e9f304b9a05ce374abfa77043e2303f89b619924d1b0715e0a26e83040a" + } + }, + "scalarBits": 64, + "scalar": "0x3ef3c292c686ba48", + "Q": { + "x": { + "c0": "0x93a531843a3b6b96f5bbdd4ae87bb5236480546aeea79dc2c918b2c2e6046ff", + "c1": "0x1327d5c4362e58154d995087221382f30e1d4d8cb43f1b0e89a57d60e5b7e45b" + }, + "y": { + "c0": "0x202ef68652c50a84b936329d1f8c058934167c5fdb850df0cdba91018a314f3f", + "c1": "0x1689e27dbbc4fbe7e0a48ab8ec5ab5fd04d9e143c64b820182572462e4a8e26e" + } + } + }, + { + "id": 11, + "P": { + "x": { + "c0": "0x2a804184a7068f6bfb5046179bdfa3ce5d0b725be86b776b57bb12b7206e961f", + "c1": "0x2f2a4d34aa4a12a8893123d8a3982dc26a59a2753c229a7e5cb8efd21374d858" + }, + "y": { + "c0": "0x85134a477d376ee0e55ee83e642d311d098f163186d499a78f456fffa678ffb", + "c1": "0x29852025001dbf2b3c6f3663a2975d95ecce85edde3719d336eab7616b782f85" + } + }, + "scalarBits": 64, + "scalar": "0x1951ed9f1c5a2a3", + "Q": { + "x": { + "c0": "0x2070a6e850d27f7cb4a65a42adc9a5290ea5f4bc90a3e5681c04e040f3c7fbcf", + "c1": "0x2572902c3ae1e71d163b2ad6a32a29a56d17a8a5f6fd9e572f05b9c1535595e4" + }, + "y": { + "c0": "0xe317542e57e60add0a372b43e7c24d9254845d6f28dda5344ac6e2dcc133c7b", + "c1": "0x9c5d288a1141b6d8ff9b9a7df46dedc20ded0b5ab5b3c715d775d466773f70b" + } + } + }, + { + "id": 12, + "P": { + "x": { + "c0": "0x238020890daae77bb08adf3ad47c8a18d1122bef8bd6f657e2cbe0ead9598d30", + "c1": "0x5aaad8aa21b0f269c97747257582f790e4939e6861c636a8b4aac740b3734d8" + }, + "y": { + "c0": "0x16962f2503e8de78f02a8ad4cee70e1700af03560d93f1c2a1f025e6799b8011", + "c1": "0x19594e391bb41f1cc568e15fe96ad246aaef93e62b7e79813e089e07230da23d" + } + }, + "scalarBits": 64, + "scalar": "0x71be933d0adda21", + "Q": { + "x": { + "c0": "0x9b41bb15f383dcd815bf9be4bd0313708b6b5d08c53242988b35970ee255ddf", + "c1": "0x1ea6a46651b0b1ba14e6b1d6e00eaaf7ccbcdcf41d9be754c53b0be18d5e05" + }, + "y": { + "c0": "0x1697c824437395753aa60dd3f247a203f4becd9be78fbd453a353e838458bf3b", + "c1": "0x2fd72b18985d1a0a651bd6e04935a01f4c461ce9f9b46f53dddb6b4544cc75f5" + } + } + }, + { + "id": 13, + "P": { + "x": { + "c0": "0x136badb9b6aed6ff43e4864ae2a20837bf458f019e50e241d78b913606b13e54", + "c1": "0x25abec824c3b97b64a74d92b3d2894ef7d95d7bfb54b2d94deb063b0ed2eae97" + }, + "y": { + "c0": "0x1b1987547a9207bd3a944e47b9d420aa274afa7a3606a0ef41b5c797a2cabe27", + "c1": "0x152f4e7ac79036d882b732b8e34fca6da8844f30e0f33df4ae636a31b5a2ae75" + } + }, + "scalarBits": 64, + "scalar": "0x8e7c86bfaf238c48", + "Q": { + "x": { + "c0": "0x22f82c38023902bc6821a00e96868c7508501eb5fd948fdbf46246b186a880f8", + "c1": "0x1a48255f8cb352d087e5f9e24344d1048b8b5be0b4b49a459143e5795dab0c9a" + }, + "y": { + "c0": "0x4534ff171b587790f362012c8a10fe7caf253e8e9f56c0c92d56b81c8b8f1ae", + "c1": "0x8d9657f3350f3d3e693c453dc819c5f9dbe3a00f81bc2fa8490685c685e55b6" + } + } + }, + { + "id": 14, + "P": { + "x": { + "c0": "0xccfd587c25cb67bed9378ee964430d0c4c16d28db3c79bbde8697d9fc202b14", + "c1": "0x1d05f6ed316c1b804650e13729e8007f71218938a2d33e82ce05236ef28ba3dd" + }, + "y": { + "c0": "0x1da246b2575302e93db081114f5f128802ae6ff27be27d3558aa9daa06139ac4", + "c1": "0x2174bc5135e1acf22a2e90d13ccc4537512b5d5aa33a67ccb19f7cd1f49eaf6b" + } + }, + "scalarBits": 64, + "scalar": "0x7c2e37a2492f6de4", + "Q": { + "x": { + "c0": "0xaa2747606ac2b5f79ab937d6b1d6338a5b454f7850123d325a1879d9bc031b", + "c1": "0x1a073da1fd176d18972c3808c2d25a9ede53513530f67738a68d9a1ab599b7ec" + }, + "y": { + "c0": "0x15dfac0e313fdede7632d82382f498d848dd74b21e5010f1792e8e35d7ea6ee4", + "c1": "0x15765987da147a0c911e1fb24d1faae670801940d6786834ebf530cd9b3f6e8c" + } + } + }, + { + "id": 15, + "P": { + "x": { + "c0": "0x1cb9f51eea8f49f4344bf88a6b7e53040362a5034a1b61b88a67dad1c1426700", + "c1": "0x29a228650728e41997696ff35e9e327a77b6b598218fd8890248acb9aeb97db6" + }, + "y": { + "c0": "0x9703248c27c36b4606f38a11f4fc7db82bd8c116e7eec2120f6811884b9cda3", + "c1": "0x184c272e5722e51a7e06edb469fd0f8f3c6c9a1b0b3835611792fdb13dd1a5ed" + } + }, + "scalarBits": 64, + "scalar": "0x96a44c000459c423", + "Q": { + "x": { + "c0": "0x972ba8c644a128382a92f6a7745cb578ac821e1d5e37056c1f44b4c298bf80a", + "c1": "0x206d9adf91eaed7349d541ecf3d8de46cf9dc74045d2a6042c49b9243583c71c" + }, + "y": { + "c0": "0x165a2d366b0dc8cc1b7e84e67746ed81c0953b08fab8359e6fc5a2c9ab3895a9", + "c1": "0x196cc332c6a0ea4488f105ea417ed7365fdb542d0829f0d1667db47879b40f5f" + } + } + }, + { + "id": 16, + "P": { + "x": { + "c0": "0x2394a4404783377dab6954dd22404770499effd1b6b3b47e0ef7a35aa6306ddc", + "c1": "0x23c46225cb4d0f1d9c1303ca812a86309b28a071ed20b62b3fec90705a16de25" + }, + "y": { + "c0": "0x21ea0c03e1a88e2e056c95f74c812e6f996b0eaa0709859c1281bfbfa58b394b", + "c1": "0x112c26f32f8b734ce43f44a6f08408f5a07aea27fabe49bdfb25518234ae1410" + } + }, + "scalarBits": 64, + "scalar": "0xc5bb78f71937ca3d", + "Q": { + "x": { + "c0": "0x2663b5495d921542273cdee55fb8f3c030e2331ebd628cdbde672580f72fb6cd", + "c1": "0x1426e42296968f70bd0c5f5c21783c10ed7f02258bae35f7fd84076f7208cb0c" + }, + "y": { + "c0": "0x1eaa4e51c7c9fbbe3025559bb35c2400ac03de0390bacfb4f5709d358f309716", + "c1": "0x22a10653313841e5eb72811529de890138d17acf69b13dcbcb521af97b54c962" + } + } + }, + { + "id": 17, + "P": { + "x": { + "c0": "0xb6436aec478290c43523a04b36dcb0baf52f7f55e87e6d7b4eba066116f9841", + "c1": "0x1401ed16829ea340ec28d3ab57f5208a5200370a10614f96ea873b6295b12b75" + }, + "y": { + "c0": "0x28475c208c440e153aa5aefca5e211ffa82cf9d27ed31f2b39dbe6bc50f30db", + "c1": "0x16a56f75c253a8696e125aec6f723a41271dc00fca8621ef89639e2f25c3e499" + } + }, + "scalarBits": 64, + "scalar": "0x30fd0c5cd13bc87d", + "Q": { + "x": { + "c0": "0x23525bb502ae104a7c2d707b513574b258ce5b158d7b007d933751c08bb64987", + "c1": "0x27e49e263fde7305c015441e6639b410434f05c39c4aabe8e44e9b65813394b1" + }, + "y": { + "c0": "0x352a653894311845dc654c43e2e85dfe8120c56c4692fe080de3b166f312a35", + "c1": "0x425cb28a0e6acb76d77c72b81d3b4914d8bbe84e4382c4e08b68fc3f321a732" + } + } + }, + { + "id": 18, + "P": { + "x": { + "c0": "0xeae0cd20085dce50caf54672072b02ecd54f0307f7ba745c22f79f5f5f00392", + "c1": "0xd6d54ccb19a889c373a36286e1f14cba3c3ae61d34dda09a612bbdf4cb47e2e" + }, + "y": { + "c0": "0x192fa15afc388db18aa216cd4149db352f8c95a03d0588b64ea397a2750241eb", + "c1": "0x141c3f7efaa9687c3c08a787a3a136e5f9f704cdfda0d1846f917b13530f99f5" + } + }, + "scalarBits": 64, + "scalar": "0x32dbf604d09d7f41", + "Q": { + "x": { + "c0": "0x2b966b9948bd761ef83ba39e5dfa1993af0766cc78e599d82e9152e396d7c9b8", + "c1": "0x7b2b4016a6a676e2aac0d1af563a1045f3429521d4868c98b8932f449a8c1f2" + }, + "y": { + "c0": "0x263175f6d447bba887b3aa240a21aa946fe0fc2865800f2371b918f0ef8cb800", + "c1": "0xa93eadba7c69d638004670dff58f84fa0bca88963f5c0f72f5eca5d7ed20aee" + } + } + }, + { + "id": 19, + "P": { + "x": { + "c0": "0x1f95b524aa5f9bb09121dfd6eb0dfdcd21fa6faad5b5f89dbfe744ddc106a8e1", + "c1": "0x223fa3536998da41bd048989a524f87da502ef13e4b7364056e85037274ba68" + }, + "y": { + "c0": "0x4ac3f8896d056a37f85f1b5ff6b5349cce39eb60baf521c6837be3cc9a46f6d", + "c1": "0xcc536179a58b7f404eb2ae6031aac9fc9962ba453e984277c93de8d22c09ed7" + } + }, + "scalarBits": 64, + "scalar": "0xc1c27feeaca8be50", + "Q": { + "x": { + "c0": "0x6876cd116910d43c572ef448ea7c82498aee57c7a393329f50a054c24b45212", + "c1": "0x1e4ed62a29985e11ac4d44fb99cacf5e0d6c46ce05afc62491b60c8c167fc23b" + }, + "y": { + "c0": "0x1bd3cda12915fae7a9819977996876dd5cec5ff108f57803dc71f51c00b1d7ae", + "c1": "0x2c710321042fa5aaf67d41d0c102783d747f874a9c3ca8ba3b72c0c01ed5f8f9" + } + } + }, + { + "id": 20, + "P": { + "x": { + "c0": "0xfcc5b8ea32b2548aa90f2ce04ea12c9b814860b06c19f6b3596bdb20314a3c8", + "c1": "0x2c11891beae4aabc89fabcc789abb53af7a17b345a82b3e44aae525ea52eb902" + }, + "y": { + "c0": "0xed63fec49fb44284d5d0cadb297fc9d8ef83ebe696614288c5f333e1da983fc", + "c1": "0x1b16c4fcf09ad7b4c5c590b77edeb8a4dafd8ff2f09973ad42f8506ac39ceca6" + } + }, + "scalarBits": 64, + "scalar": "0x62fe0e276683419", + "Q": { + "x": { + "c0": "0x27feedfed02eab3bb3e23f24abd1e6d6268914f8d63999a6eebf82810a2cbf9e", + "c1": "0x2b1471a174637f285a07c530dfff91ec3462b87db65a177dafd80715b5796975" + }, + "y": { + "c0": "0xb2479bce9b6d4053d3470cf1151bf2af01c05aba64a0f871f80d00ad1da1692", + "c1": "0x21db0cc65b492c8590960688cb33968065d5d5a4a11fdee0d38a80f73efbe5eb" + } + } + }, + { + "id": 21, + "P": { + "x": { + "c0": "0x119fb5b9725054e5967c1e842d4f55c27fc532c9eeef3f51fdd6378fbbf91fac", + "c1": "0x1e3c18fb4b37d93a759d04dfeed548f96309f4e4d8c288166c0dc55177baa699" + }, + "y": { + "c0": "0x24bbd98a118206f4badef060a6076f8bbf818a49ecbed28ed9b9bcbdaae43b89", + "c1": "0x18241e3c0dec8b0aec9848afb98c92052b5a127f9d1ed9e00eda099542b61ff5" + } + }, + "scalarBits": 64, + "scalar": "0x215df34c5098a720", + "Q": { + "x": { + "c0": "0x12a0f9f4797a6bd9a34061577f7c3f6500db8e63da2a5f0cdb016801fb8faac3", + "c1": "0x73a1624a342807370ce7106ccbe865d3a72130216c00ba64b7808eaf2b31de4" + }, + "y": { + "c0": "0x3af17ea949e357f837fa94b75e0b7d54444d85ff640c76c461619850806254c", + "c1": "0x2d6c4948ce17a9bc57533cf786178e6cf4be3723e4be41fdd17adb319fc0eec6" + } + } + }, + { + "id": 22, + "P": { + "x": { + "c0": "0x19a18a3050a1bf17c2b05de281afd643a19ce9b89065d7041cfa79383c9bb2b", + "c1": "0x2df87ceec0b00228cbeb7808ab99480ccda712e0308158e3b0647f6528990a2" + }, + "y": { + "c0": "0x2e7883e6e671ee87c6209532171ee6f8772da4f0c59198bc35ee3f94c786a201", + "c1": "0x2feb0a5fa9642f4f70924cd95a0379689f77f90f72be236fcc616fc81f59b7dd" + } + }, + "scalarBits": 64, + "scalar": "0x4bc85d8c5ad930cf", + "Q": { + "x": { + "c0": "0x1c251be0e41d57f88a361babef4c7234bf51c770ea3bff822a3213a6210def61", + "c1": "0x27d9dd9f2a31c42b835a589c396782e188157a9ddd9ec34c45f1cbe503d086ed" + }, + "y": { + "c0": "0x1815cf4382152b873ade287a4e5bfcc84e5d04cd34bb3749523e3613733a1f43", + "c1": "0x10a8a587a549051cdf8579b5e7818935ece0061cfb867b188fc708f178ad67a4" + } + } + }, + { + "id": 23, + "P": { + "x": { + "c0": "0x63625ba09ca8bf574be9349e5564a43242ce4b4e6c4f3527d3601f6e41a3b4f", + "c1": "0x86dbf1e72dd09ab8fa6417eda5b64dac85033f35e49ae13517bf5e41b90562d" + }, + "y": { + "c0": "0xc727f17afc1f26e3c679d2b787366f3aaad505d2e4fbd21686414700eae7f61", + "c1": "0x1e3d82d3304c06999fbd101cbaf5dd12f4a188a40a65c1fce246996153d4ed03" + } + }, + "scalarBits": 64, + "scalar": "0x7be54caa9b532f89", + "Q": { + "x": { + "c0": "0x2b55856a1a78adf603c172175a01de538e8cb80e75db5f19954688f14a26d937", + "c1": "0x337c8ad66a87a6bfc3e8106ac54aa555ca07e762dbafb807ef6891ca8bf3bc5" + }, + "y": { + "c0": "0xf74a6fbcfd256d3c72b5ea14071c23d3f98140ff6212de968260d06df8ac8a9", + "c1": "0x23d8cfb28e2e631468f43dbef5998bc2c430320a2d8c7784d654edf6f662ce2" + } + } + }, + { + "id": 24, + "P": { + "x": { + "c0": "0x1cce1f708793837ab37c55cb023a9c0584972eb339bbd58dec637b8801ce727a", + "c1": "0x25d8ff66e6c24a8e20b643d1eddbaf46a41aa09f6ce1e66bcad3df22899b4a77" + }, + "y": { + "c0": "0x2945df1bc7aa6af90cce1004b89e5d8dd38d77a6c3036fb13aad0da0b988d75c", + "c1": "0x2653c4f6ff15c1702883d590b89bb07ede19b07f03509f782ace00a8b461f1e9" + } + }, + "scalarBits": 64, + "scalar": "0x8db4f1740722411e", + "Q": { + "x": { + "c0": "0x1fa980d34e4bf931041ecf1453c2784d511fe3b7f4fe40d2e442145fbb25449", + "c1": "0x2e51d4f3a3ba1bcb2e4b1a1a38619455923178d0d424c328ac1094d8d0e40ddd" + }, + "y": { + "c0": "0xd5de62ce97da64972daf23937ae652d35d3bc587bcef526202e80efe7e95705", + "c1": "0xbda7129c4e6de4dcf1b0032105833a16cfae8d1dcf332e675d2fad1d6d8a6c" + } + } + }, + { + "id": 25, + "P": { + "x": { + "c0": "0x12e76dafed7b603bffbe5c4de5acf4ab9cb1c0057152e3e17c11f59fa71b0281", + "c1": "0x126dc8f585eedbc8d0eb959280d0d5138deec7ede5d4e6e4a254baec7455311c" + }, + "y": { + "c0": "0x24c03c5bc8af02d980d798fa66a9449d39773ca1241a471a94a129b4c490665b", + "c1": "0x12b57838cbeb7707bb2f7768530f677f5ba67c449198d806c6a5941026be53eb" + } + }, + "scalarBits": 64, + "scalar": "0x95aa9721e071baf4", + "Q": { + "x": { + "c0": "0x2e49820e2ef22f289f9dd654b35e2629c83735a510b27f6e41d38f3ec472c6a", + "c1": "0x12f22fc68015617357e29b3402426fc2144d08bf01a17009f02d27188bde4772" + }, + "y": { + "c0": "0x623fe52625baaae96c25968bd8e4accfc3f58b8db9b5daa128902c411679cf", + "c1": "0xdb590422ed029f1c68f6394ce63541724a08bee00f4685e0c062c652f05a899" + } + } + }, + { + "id": 26, + "P": { + "x": { + "c0": "0x1d58c9ceaa90ba5eee1aa59f9419966542cb1cace8768cb17c661147669d0545", + "c1": "0x1bce5e33163ec58489e3d1323de1aee811463f80a90861238a921b26627e82f6" + }, + "y": { + "c0": "0x2da771ecbf8db8782d7fc584f7b29aae6ef12f01412929baec00f64907173180", + "c1": "0x19809866d651b45298a086fc7149a3b05340a071ae698a5aebccb74147f79339" + } + }, + "scalarBits": 64, + "scalar": "0x9419b3ace0298cfe", + "Q": { + "x": { + "c0": "0x2cd17ec5bb4a969f4cf89376f1a9921e367b4158d15836947499f7fff6c5dd59", + "c1": "0x6938255cd3d809f4e0b40f7c1f526ed624570f8f3b026c1db0452aeb19ab40d" + }, + "y": { + "c0": "0x126f2dea2ccbe615fa679ae8e5974b573f62785ceda9a193727b5baf1767acdc", + "c1": "0x2d5875f974e2396839b0a5001ccf9123314a14dc9d25b0fdb8056fa913dd22be" + } + } + }, + { + "id": 27, + "P": { + "x": { + "c0": "0x1dd053c5d9aa9bc16a75c203c63b4299d14647539446900cfea8d8d003f043e", + "c1": "0x119b22f30e1b82ea97e07955a4f87ccf56d2acd5962c0f081d6ad2fd0aedc87e" + }, + "y": { + "c0": "0x273235b769098b8fc4b616e957da5baae7c4a27d0a9b438ba1af75b49349831a", + "c1": "0x1cc216247c8ec111b6dba1bc18b891e9ee082006b5c1f20c084eb9f6fae3629f" + } + }, + "scalarBits": 64, + "scalar": "0x1ae48495952ac78c", + "Q": { + "x": { + "c0": "0x2c6eaf35ef96ce410082c4878af0d889e4912ffe0aa6be2e95c86e4dda72d87f", + "c1": "0xe7184cc1a515ab1d288b87fe2bf20677230b8a16b6cdc070de01dc067e8fcf7" + }, + "y": { + "c0": "0x55a39d6985743ffd485a56da56618652e6df2c55f4ec6531e4c55165c5d3f0e", + "c1": "0x1da68ea8725facd404697c1d02c2b52dafc8bb895c12cc2bd5f73cf91203b1bf" + } + } + }, + { + "id": 28, + "P": { + "x": { + "c0": "0xa761424b49b1ec6e0cb5782fa9112342f02a9fccc36dedb9dbfcb0e09543053", + "c1": "0x2e15ae9937167f082156388d1576d53fc243124f431cf8f2ca7cbf7c0d6b6efa" + }, + "y": { + "c0": "0x7f63245e3f6c42bec2ed5336f5ec2a53d4aaffa2f97b8c44b3c74551fc64d02", + "c1": "0xbe474bb6471e2f9a7143c1ac179374bc6928e55675e840ceceef5862406e836" + } + }, + "scalarBits": 64, + "scalar": "0x4a3ff19d244f7514", + "Q": { + "x": { + "c0": "0x26fd0219ac83b67288875e8aece45c09f4cdf7aaee82e37d580ab8ae6ffc3610", + "c1": "0x1cc1a9414156db13cd7b88e9d2c980462640c433fda5dd557f793302bbf63642" + }, + "y": { + "c0": "0x2f09d5947fa557da3582671f8c732bbe3b25bf7c48d651f344ffb1e1b11044a9", + "c1": "0x2627e0e25544689ade601c423886df0e8d121061963b0c60275a6e5b09dcbbaf" + } + } + }, + { + "id": 29, + "P": { + "x": { + "c0": "0x1f9dd6bb9a399ef181d7c21f493d2fb7b014f8d461c504ebb5027c9dcff80788", + "c1": "0x7dad4422fb87d1bedfb3b076549af0f0f1f3aa8a68323fc72726af4679e7b73" + }, + "y": { + "c0": "0x1a677404b4adb615896f1a98234e46cb216f667590a9c15708b6c4322318c980", + "c1": "0x26cf0b490b1c2eb28f34e9f5a1b51a5ef2405bff88ff3f8c8a0235dd4e346f5e" + } + }, + "scalarBits": 64, + "scalar": "0xea23466b083e0cd6", + "Q": { + "x": { + "c0": "0x4023d070e1ec40bf39e99900beab59547685216d7e3afc2096594782020e6a9", + "c1": "0x17cd21135181a6d8c5d877fa006c6766a29cf03ec6f44c657c8f5f7c80ab4783" + }, + "y": { + "c0": "0x27a87b9a27df765971df5c2718fdcd21c9f6cc178f1dcb69b2c682d466de45f1", + "c1": "0x1b681ad5a87ca93bdc71ff111b83102a89a8ce90bd1627b5a852a62d0689be77" + } + } + }, + { + "id": 30, + "P": { + "x": { + "c0": "0x1f779415edf5ada5722e56f6431f93c73c0146d8e85f7c8abb466bd0200c4c83", + "c1": "0xa407e1883b6102310e888ae121def75808ec529b7f0520a26cb90c504ac7a37" + }, + "y": { + "c0": "0x1b86bb127d3e2e9e3d45d52e2bc4eb8dc12cd2074a74d7990f1609449304a64f", + "c1": "0x11cff23e109153ca745211e11a51dfbad5d5afc4efc082a7012af73f8030bac2" + } + }, + "scalarBits": 64, + "scalar": "0x5f7aea44c7530fe0", + "Q": { + "x": { + "c0": "0x1b074c6202293949d5ceb129954cf054204829aacac7b93da093bf0c7a108c95", + "c1": "0x6ab856bf5f7fe7a4cada81c866ca1422e9163c82ad32448b3586058550196b4" + }, + "y": { + "c0": "0xac2a860886c2188158643c68643d649bd3447ba95d0550713159228d8578e6f", + "c1": "0x2a68fa37a7b10071e71ee72995aa5b4446433107ecc82daa87c7d969a8e309f1" + } + } + }, + { + "id": 31, + "P": { + "x": { + "c0": "0x18abdf171097cd8410e39165193f15fd5a5c0b2dd8a6951f20a87a87e7fef862", + "c1": "0x2c0fad70857b8a49da6aee7d98f68c05aed236132d699a28c48d73d9b2fc91fa" + }, + "y": { + "c0": "0x25e991318856cc4d98ab8df695e382433770d3f071545535f33a62172857f49a", + "c1": "0x168eb8a0b0c07562d377517b0274cca3b3101cef9894aef12154bf7e7c0c619a" + } + }, + "scalarBits": 64, + "scalar": "0x92d444c845dac2ae", + "Q": { + "x": { + "c0": "0xa7ab45c19cf0029bb1a33ea0a2594951c01d7a10d9fed3076cd1a71ed402bfd", + "c1": "0x52adfb45344cf4baabf51091d7930a39002a14b1b0a4b0f56f80792cf0e70bc" + }, + "y": { + "c0": "0x1faa7d6ab43c540b2a0bc50e20b301f4a1c1aa51ef31adfe176dbac44786ff0a", + "c1": "0x19f45e88ee60cdef84e271814896ae21a18c44de44b9e7005fb3bfe90d4a6fe" + } + } + }, + { + "id": 32, + "P": { + "x": { + "c0": "0x18c917a5fcc9c716b5014bb71450fee6ddf8ef31573cd7e5e4692d8ca02f6c40", + "c1": "0x1ba0aa9fa0bdbd5a4d6b2d9f4549a97b99ec6aeee5fbca6af9ea0dc8e86751f8" + }, + "y": { + "c0": "0x2d7a66508d8f69de716bf81d9d0c4cffb43f2d062309a36ab369594753f35f82", + "c1": "0x37e1ea3da1eaa5d05a5db0631dfef9e5ce0cfbea311a06f0d7b4604c7600957" + } + }, + "scalarBits": 64, + "scalar": "0x1a5b64db9431b4b9", + "Q": { + "x": { + "c0": "0x22fe21484a121ef51b2ce19b657bc5c9160ba8e6336963deecb8209efca5500c", + "c1": "0x28650e899aba0398ba6ea371bed702241430e245a1952bd11f53dadc35d0f1f9" + }, + "y": { + "c0": "0x28dca6b96c46488a347ba53c9c0d5aa3eca7caa3e6f9df3786631ba9d28d1731", + "c1": "0x296645a1239bebc638dab6bd0a8a28a3e18dd980944cb115c93bb031e35899b" + } + } + }, + { + "id": 33, + "P": { + "x": { + "c0": "0x2b8ff291848d377017b26c5ef9cb955d3ecfe9f21bc68b74e003255775be7d3a", + "c1": "0x26d3aeaf6749624b21333906bebbf5ee871b4d7c949b94c83844c56ab39ee3b3" + }, + "y": { + "c0": "0x11cb41355eb253fb811d01c5c02f15ccc25d8dfaec734cff875a28b050c41cee", + "c1": "0x12e4a6842b02116abcbf6f6b97deff1129d21c7b5ff2548da459296fa818794" + } + }, + "scalarBits": 64, + "scalar": "0x4915c325a9b0798a", + "Q": { + "x": { + "c0": "0x125a94664453a9a224f4effb2b31bea99c5790c3ce8c225c58e2df7dc7ad6f99", + "c1": "0x2b571d77dd74ad758e6b728322d714a978a21fe1c69ec3b9728c9ed8ef84c7a3" + }, + "y": { + "c0": "0x21be1d1922d1b25211b83cf1ceeb052e43be892da127f77d01f13f9e70300a79", + "c1": "0x2493f3de65fb9f9a3b0fb334dda4b3988824e145187651b70b43434e34c1c655" + } + } + }, + { + "id": 34, + "P": { + "x": { + "c0": "0x2acc0b27747319da65bcba74949b22c69352d2a05ac9751742270c2de134c267", + "c1": "0x1950b7851512665938e84e745eca715dd6bbbbba20340791c644cd5d4bbf97a5" + }, + "y": { + "c0": "0x13d5ebf4a514967c052221268be8a9a08e2b1e786e96ca7a9bb73898e174a472", + "c1": "0x1defee2667083146bad8f7646266270d4db76af58d93c9eca24c1383d02ee71f" + } + }, + "scalarBits": 64, + "scalar": "0x341efacf4168c43", + "Q": { + "x": { + "c0": "0x27c0ee50191c9b4c6890efe91237e43acedbe1ae549c5a4f297cd39ee441ffdf", + "c1": "0x1fd9a4b62f3d564a98d672e94cbff2b89bb2214c29adf951661fcd077bc921ce" + }, + "y": { + "c0": "0x1169aa1d14ece702567979a77aa7a4e248b8875ad2c0a950f6d9fe6aea85b20d", + "c1": "0x15b6fb3ff075158969ed58947815ce992f192cd9b92c0ebecf97942aa6a96f51" + } + } + }, + { + "id": 35, + "P": { + "x": { + "c0": "0x189546b0adc7b5b7e2fa120d3e38ff14aa07a71cab40a6f79c150a1107665fbb", + "c1": "0x13068f5122ba58be73821ac7766e8237371762cc5ed25564de239ca87761805d" + }, + "y": { + "c0": "0x1d04bc0611100d1ff613912db1ff52f20b4005765170f2db6e5176823b57aab3", + "c1": "0x196abaa45d01a158564b9a06fa2a676e1730ab866a1f07b88ded2a1cf0e747f1" + } + }, + "scalarBits": 64, + "scalar": "0x7325451f1bcc1b31", + "Q": { + "x": { + "c0": "0x2f4d9c488b88a31d48666951879a3aec7ac081602e40de7199c7b4209f2a1f75", + "c1": "0x2e61daa693cc799183ddf5960b71a8988d651dee5230f12b6bbebeb4087f2eba" + }, + "y": { + "c0": "0x185636e1cc70d9fbd0afb25b491423c9e69e71ff5978c9aac3e82be0c4f8a6d", + "c1": "0x156cbabc8bf293d467372529d61595c796f803103118403e2ba9b1180165e25a" + } + } + }, + { + "id": 36, + "P": { + "x": { + "c0": "0x25838aae816a5460fe4ff0d878f0306a8882bc5788a3815847d9e86de84541c8", + "c1": "0x277db2efcdab1fa0bb48123a61a43ab45be07b1308ee55b2e70253076e8353d" + }, + "y": { + "c0": "0xb117c03ee0132857b22123c9d0d472b55fef430a45ac2a18183bd4a6b2e1b0b", + "c1": "0x16974bc71b0798d104d5b7f2285d98dab2d11986cf7d80036af28109ff455837" + } + }, + "scalarBits": 64, + "scalar": "0xd410f3cc8086bdc0", + "Q": { + "x": { + "c0": "0x8139b7b56f6b8fba3c1136b15d9b4657bbc6667aa2c6bfbd35e62d1cd8f1968", + "c1": "0x2e25096db216675565abf7dc91fc20374430b509eba59a4d27f700660b57b516" + }, + "y": { + "c0": "0x249f110f2024cef97da5472293e666f8a710a29ba176837116164a5de2ad07b2", + "c1": "0x1f427e6646211ad36928036e8bc49765d239026e36893998940873bb8c449800" + } + } + }, + { + "id": 37, + "P": { + "x": { + "c0": "0x275a5d3f69ddf0ecf0c0f3d12064692ac1d37fa03474db0e0edd99a7cabf8f30", + "c1": "0x28478e8b5a43d1d1d5424ef30dc707b0e836f8437ea9176cebcfc30a1cfec981" + }, + "y": { + "c0": "0x180796ad1c4fc79f317e813467199e14107b6aa2708fcad00f274b1086fbb7ef", + "c1": "0x1414057e48280736f2b505565fafd06adab6b9278fbac7971ddaa3e616fca14a" + } + }, + "scalarBits": 64, + "scalar": "0xdc6899d22416f365", + "Q": { + "x": { + "c0": "0x1d529ef8efcff60e101e74261605625e7f2a1762b123c005fafa1af8f92d3b10", + "c1": "0x1f21dc73dc8781714a3618ef63598a19f8feeedf87352f2ef3d29a3e1a75ef0c" + }, + "y": { + "c0": "0xd04c40d2051835b445e79238625232cf7a750e8bbc727bb3fd3124a599d5891", + "c1": "0x6985f3f5545e054eedea5dde4977b4f540d8b2482968ff44fa8dac0ffa6c70e" + } + } + }, + { + "id": 38, + "P": { + "x": { + "c0": "0x1353ebf097bedaf94e75fc221a19713c50f1f7425ee885baf394b928ae042cea", + "c1": "0x11cc639aa2bc2301ab022a81e65bab9e2244fb49de2eab67abcf83b27d73f055" + }, + "y": { + "c0": "0x687dc0fd3c701f2f9bc5e64cd36ad1e1091ce12e36d2410eb5a67eb23dfcd2f", + "c1": "0x19109e211c36baaf537091ae8878e2e89573bd7fae89b7e90f5754c7fb81c452" + } + }, + "scalarBits": 64, + "scalar": "0xedf709cf1590130d", + "Q": { + "x": { + "c0": "0x4adbdff7e54104b6c4b77fc89aec30a6c93daaf40c313ca0bc783be5585ff0e", + "c1": "0x1a987ccbe54c4d9ef0d9ff05c62522940c265b328e9ed3e47bd4596429b1df61" + }, + "y": { + "c0": "0x1a4b57e45b7022c754c97a98dc5a19e5241a8930ad1c8eb8fa565fa5da5fa28a", + "c1": "0x1d1c7a68f2e72e55a044911c7c0522f758772e453f582ef2752950c2df83a37a" + } + } + }, + { + "id": 39, + "P": { + "x": { + "c0": "0x26f7a18b0eaeb4f75531da2b08345095f9b9d18416cb0dd18120e7e52080aa33", + "c1": "0x1d5071c566a543a6e948a26b0ff82dbd8a850f87371921bf5c21c4d2d2497102" + }, + "y": { + "c0": "0x4470d32cfd54d11e7be6e5704f38d43114c0de868fd95986f666408f636f25a", + "c1": "0xdef949960f3b3c1e81903faa6ec94ab72d2317821e144f5edb1d7f372de496d" + } + }, + "scalarBits": 64, + "scalar": "0x6643d40f7576fd98", + "Q": { + "x": { + "c0": "0x20fb39d505930fe1382fada0248e4a8324cddb6d2f6259b8ed41e5fc348b4cbe", + "c1": "0x16aa89302b7757f99c8682ac96c681b9e694313b693de8e996b1994fed42aaef" + }, + "y": { + "c0": "0x1891c1510965d0371de5bff3404fcc5c7e04682088cdf3636ca2d58876a9f6c4", + "c1": "0x245557c7d7a480ee3db48b5a636b5e8de9da251167a7f0be9bee96ca2516ca1f" + } + } + } + ] +} \ No newline at end of file diff --git a/tests/math/vectors/tv_BW6_761_scalar_mul_G1.json b/tests/math/vectors/tv_BW6_761_scalar_mul_G1_377bit.json similarity index 97% rename from tests/math/vectors/tv_BW6_761_scalar_mul_G1.json rename to tests/math/vectors/tv_BW6_761_scalar_mul_G1_377bit.json index 75b220b..09d011b 100644 --- a/tests/math/vectors/tv_BW6_761_scalar_mul_G1.json +++ b/tests/math/vectors/tv_BW6_761_scalar_mul_G1_377bit.json @@ -14,6 +14,7 @@ "x": "0x5545f882f8e079c50c17588c42111420a6ac7a9a44528480efa364358de0fdbd1f6af42ed542e285c70c7ea7f30154d4ac74c100e91e834159849cd44668c564a2f70a8770edc74f4fcd226598a02d4aaf2846c6fed2ed74656b9a2e6bd628", "y": "0x3f114b0d3c383561977824d49b0fa01c915025bee25758db6922e55616e7329f7c21478c6c5183b306ef22c779bfb5011193a81cf2e47011127344d628b2f1c7397fe6182dce2070b4ba5fdb0b9987d5a23328a4cc8dd6ca8847f6ec11e814" }, + "scalarBits": 377, "scalar": "0x16f42b8a4f8f69aee37bf282d4aac82b7bd1fd47139250b9c708997a7ff8f603e48f0471c2cfe03e77fec558ef287c9", "Q": { "x": "0x299c105c1d3fe580706b83811bf4aae65bca7bf4778aae0cf35f75fe62b68335b82ec3786a4f25d459331aa9b369316518a6f8acf07fd494b42a72521919eaa720bd67ad01714df0e7e0c78e9d0e59c63823563742111a405000090603f7cc", @@ -26,6 +27,7 @@ "x": "0xbc521723a760d04132b9bc4e8b5ba8ba87c6856c9a254fe169b7d7c0c269bafa81ebb9f70dd5d49a328996605433d92d132d76c1e19ff9514e83531cd5c53ed40980ecf3cdd66394a37421070bc697fdf2ac057a5d3622ebab925531267703", "y": "0xa04a6eeafbf50d540e29231ff57b4b0ca52b1c1873228c9fe4fd0b09d67ed67f9ae7376ce1572a8ec063e92ab6ae1dc94b4cba5079c92da32ecfed47214c0520ebc410c8ba53ce933a8e450d93e305e59c947b739c3de9550cf85ffffc0cd6" }, + "scalarBits": 377, "scalar": "0x373cefa5f6ac9d1085a890088c51eac4edfebf978946e523021c72bc7db6b54def07e6b2da232a8507ac66a7c7422d", "Q": { "x": "0xebb58d673f89191cedf4c3ebb59877703d36172e5888d6bfa96298f02b7ac98c208a4a896c3ffb8c9b708b0d0c0f7509dc740f4b3e9567fc7144cc278c73531d2e964fe146f314a4ab00d0777dbdd2589e0cea78d7d4ecd6781e506fccc9fa", @@ -38,6 +40,7 @@ "x": "0xde30e20472ef1876a39b7914e6dce371524825cb36061eafcfdda891ee2af8f57379eccc33397d8af62015b8c6dd479d546cd4a5a6b6fe9e7228b79b0e0b698e6a624a8908b9cff01be1e26162e6908da2767b030927e5f99ec01294e47274", "y": "0x155676883b538dc85db423946ab25ec36f8789adf71a891ad71a50c9b330c4c728bd08fdd7d411a3f938c512cb3e7676de67d191ba84dcf8424c2cdebfa1824816a3787d9f10ba3fb9abb35b0d3ecaeb9ac86112f0b0578fec724c48184dc8" }, + "scalarBits": 377, "scalar": "0x25dbb5bdba82fde2fbe2947d0b49131d8c5116e57423d7543cd4525af2f97abd462e08b0bc81c48f645759bb5d0512", "Q": { "x": "0xfd70f9eb071c5a45507ccf6c21129c2f0afdcae1d5a2950aee7979bc63a6145bb82ce4a10e727d1981be7d8299d44cd32dd6b10b63d3486b02b0608ffde5e56e54c8ca45e8e5776a5036459fe8824d44c01a043432dcf767d3551babc2d93e", @@ -50,6 +53,7 @@ "x": "0x87fac29ea121e5888c9aaaf2ff931cb37b7f6c70012b147711a0236077abedb871f6dda3a1c0d79d7cc3d38c0b785721cfc28a3720532dadd147d14301c55ef9485a1459bedbdc4f897eea390b40fbf77225a9e81bb9a310f7c8438f960250", "y": "0xefba3f41a1b415cc88293cd0b09b6e4cbbf7df5bbed1aad46656826481277f3e288211f81dc67ea9b8a0a773851e1af9ea28080049579e3c88f29269ba39cb74abeac52275d16b75a2ee685d20f03d0359eaf33475cb283716f1698ea90e13" }, + "scalarBits": 377, "scalar": "0x1a5f4af45fd88b7345433d8eb1b55be02dd782f825f901078267cd2c5a702877f0161ed2339c026fb9841a73c44eba9", "Q": { "x": "0x52473f405d568dd6018d309a1b677f9ce5ecaf37a41f2857363a9b3e4ce1973c11637d6eb74b1b507ed8984504cc11c5f3528bb625b117249f0f5b823cf12f1c0545d227bf71d56528b02ece7a60dab3fdba92a11f8b3e91366f511a5ed1a0", @@ -62,6 +66,7 @@ "x": "0x1e4967374ce67cd73d0a9c88e6b6a4535a4dc3125855806b3435d8e0b0b14af8f46f5e8d61d5e74d713ec57ba303c0ce51e7fdfa9c77a894ecc6f9608f79ab8d50233ef4a05ae2ad42c8c62dc4169fb50ee484c2e51b96b54ea68943411b57", "y": "0x46538c65b371d8cf43f051b222155ce8c0d4d444749272770e5007625b59a5206daa13957eae8b24629e49116a2d5f2df76593212306ec0b19023002caf7de4a3309b2cc9e040c45878a29767cd2b914df3ceb7070a3787c2b303d1aecbb22" }, + "scalarBits": 377, "scalar": "0x1656931ba49c3036bf5e127d7a7a609b093f5fca57a6d8f2dd64b0bc11bb33d8f60ca1af2b149e991f1e8035fc86ae1", "Q": { "x": "0xe6a74aecda6866bcc332e59bb183320789be7a9fc26206da10c661a1a7215f777bdac451e9c543c9470b059fefecc3a3e0f56ceff3c37b40d74abbf31b09506aeeab97a74d8bedf5343b1eeea1caf4e40e376d17c2093065b423b1c1e65489", @@ -74,6 +79,7 @@ "x": "0x469635bb906ebf2524e4dd42939f9835009d72040b371f9bd0b5f02872cd7bc378cbba4e349ee6004fe3cb979c9cd13714ec130ec42eea98ae771b28cb7adcd4cde1007a011e8dbc9944d217dfdfb93cf24b9a05e04f1a6945841c51faf786", "y": "0x43c135a716eb43309899293af6f367bad79fb2a87071e8fdcd0a64b40d59d6d09b03ddcdd23b1371c56aa697f6a9628f12405e3036dd22ed21ff1975333a66cd761fb2dad9a6368dff94a170109bb1c1725fca912d43c3fb9f1f0cfb4f1e12" }, + "scalarBits": 377, "scalar": "0x1568c3511475177a15f32f53fdee1358bbc3456140aa92b4565ea0847c0fb2e1e513cc6cd67499b5fb3d2408ab7e447", "Q": { "x": "0xf9d4e8bc31485f711c8ecb9c14a4bb0c8c503c71b12d8e3e09726068794eb033ad7742728d2189048b8fbb60947f3d8518a04d75fd0b88e4416d67674ed5dfd20e9e6b74cacfc91584158c203fdf1a52901f794cb166059fd119a7bbfe45e", @@ -86,6 +92,7 @@ "x": "0x69621d65f6712778c4e8b774b1b811e4eba1c3659aee7d7d5c13b2cbb050d73f282fcae8179c62a0936a69ae0d8c33fc2e935d221b1d881d34f18eaad986f2b42f9da0bf132e73368f95addc66a1f8dd567ba0b2e64a0bb50e8684d1dba527", "y": "0x8b3db64d3a25b11f0b60c58c2d810f8f29c17278d983b25391b9404a6b7e5fcc117eff9e718083d538ab872cfb9ff96dd380665520c8114c3cab62ac331e430a241fb216b9ce96729229803f505dc2b7d3f0370751037db29c7b77d6984f93" }, + "scalarBits": 377, "scalar": "0x377eb12184799f184744146162e9acd6ad59a60e1a7a6ab4c6437148569d5d30a0a30ea926046ab6790c3dbf0b397b", "Q": { "x": "0x1e9bf1fbb3e68629925f240b8f4e013d88d539038d872ee0fe8fddd69dd77c2b937d7ead319dcd1895e095f2613787b2d7e905bb86c283301797c9339333d974e3785eedd913c9cb90a048810ae5fd357a50d0c438a6da35cb7da51f5703fa", @@ -98,6 +105,7 @@ "x": "0x880e24712c86f8e6d0951e510a889c656f39b9e5d3008ce1df691d5bd5464cf7673e6f15aa34467ab12edc0e899e24ed4ae1b6d19b23cc172cc80f681e8978098d256475a199361b8537e430b9b1e476abf8daacea5fd5ae0585a0c6ed5923", "y": "0x2d0b591b1f4957c7e7f4b424b25c89f58b54c3b82113c4883ca4eda5b7964c616837166e78ffe1f492311a8268215c5e5b1727722e6df4bc374e578f37e30fe9324b1d161a3ebe7db9f0ce1e56261a333f21a3a86c1de8337cece77dc663a4" }, + "scalarBits": 377, "scalar": "0x1a54bf2547af5d9cf0af76ef5a8a77d1ee843b60d4036c6b2e0382c0942cb1a93c45ba61ef313e31abea00b8643a39a", "Q": { "x": "0xd37a301b2d7e9558fe72fc981ca584ca51380fd8c5fb8ca42807cc7b2472db2ec82d142423949e8f8bedcd050bd1793aa6f71e4d2062b9c725db264323d42bed74dbb1c1a2fdcc149eb104bbdb4879516bb631530413e3487886fa9f950feb", @@ -110,6 +118,7 @@ "x": "0xd6e05afa1604cb7a083054dc0cc3d511c0354e4074a0a2e852f81209d6077a3339fa734aa97273ec8bbeed9a1cf80df88e9b849deed6a8d6e1eeead7bffb7c55cd401abe3773fac5e71d588b67c136dff46c3a87c1281d27e81dd30b375f89", "y": "0x2654cf67fec9cba1e4ef3a7f6defda140b9392b0cf960e0fa674846a0b85f6d691c40b8fd86f080da55555cc8e8b49ea008d66132f3f7924ab939436a26b37300d0b1e5f0e4a9fad6c47efb06557af7960f24821d9b44877ca3c7697fee530" }, + "scalarBits": 377, "scalar": "0xf83110568923c9515755e6c030b5dab546348eeb3e5f90a769dad3decfd7b3d43dc95624a2caab32626a00f3c92f6a", "Q": { "x": "0xdfc0db9923bf3bf5fd043d1860402770ec47f680a2ca8ecf31a1407fc4e765d05d8fb8d7e66a338049748946e2a85feeabbb0631dbe3f7a33248a9b5ee8a5d768a0deb4d7e113754d1ca9758c8f0c391a9bc3c89865082345442eb27cd8441", @@ -122,6 +131,7 @@ "x": "0x12169c4c3e8e254a4c89c1793cbe1b1c34d2123de56b2ad1dc991f8388810774a660f637ec94d7401d5b96d2007a6d68c8a435ca71928d4c222fa6a0710e062bd5b35454e098178cd4a6161930f7ec64b6a0580ec14815b937dd3eac7c7e977", "y": "0x90c69ca2f7ec3f4b5b915b8f325dd4dd5a1ec26a31d1bae8f10f611eace0f94bdec8c515ecf45a2d39dbe29c8703c3d0564b8e331172bff08b3be5c48506e7c30f0548ad543302df171cf561e8b3b9348597cd4bde41d66d14aec7e578c52e" }, + "scalarBits": 377, "scalar": "0x115b6bdff18cb8de3f71fe01590f070f1e108a299b60bcf8163534c45d2eb401b2886507be36b85852cda082f4741d5", "Q": { "x": "0x28ef28c54e08b29e4c25d141272795df1919d28f8c5dba50057090f089cf8b2433e2e83013ebc4d271fa84c71a88d5b0ffe7be95d921384d873a77dccca409f48069d8ef5459077baa4e6416332047396f186d14505e066622adb71ed972bd", @@ -134,6 +144,7 @@ "x": "0x15f1eab3d6f9ea528647e74ed1974cede345d7d17a6a89a230933877dab9c798a1a4f9699b69316560208e02bbb61fc2de6f6360132d986b1c738959b86754cc29c28ecab6dc36e5630766673c8b029e73ab3994e88d9ac0bf613099c917c1", "y": "0x90748552b18cb01d9ec84967daf03f6b8e8e1c2daafe2c19d80cd3eab20763bb293a2cb3ddfc4ffff172bdeb633bd0ae061b621bee176d8914fd125cdbaf61cd28bc67b1a5f49a0a404f5f6a01dcce130dd25651d9753be0cd0cbb7095e123" }, + "scalarBits": 377, "scalar": "0x10cd8e83c7142db6b415301882e5afd9c5960ea4855bb76eee2f1fe6250630fdbaac2918c86a665a5a7e1a2ed2daa62", "Q": { "x": "0x3db6f683f04025665c23e3897cb93232161104d320fd03cfd3a068bc05941873c46a21a98305679b2f15b200580c505ff11dd7f473ab006c64198ca2f214224ab5580e593d5607c93279d23c781a2557e0adfa5dc6ee6e85b91a118661f882", @@ -146,6 +157,7 @@ "x": "0x697f5f580ede11feea2e9b9e74f5b82c1cf17233b853e6e685e98397726d12be4b96d867a98e5a565ceadaa23999a0a6ae9588f56da323032fb41760d0dd8907a79d3eb09c0d683d47cc1542e011c7d7ced2fa3ae1a22ffcb4c31c3df7d346", "y": "0xb213c11e57b9d92abec187cdd6dca14afe82142dc76b3d97bbc7dd3d5d6367e0133c00c557e54d808f623d7eb1b4077f0b4126dad0896eeb19d8533e369a4027110fb476fe95acc7485a54cc87301654a30abd8d3e620f25930412c9486db4" }, + "scalarBits": 377, "scalar": "0x111b62aafa254fb7b237323f185f6c6cf34ebf5cc5e2728a5d7c3cc18c65b2b52ba8da3e12c8cf06ad4566e9811ce13", "Q": { "x": "0x3586b34e285f71b881c9db444fa289c32be5a90d92a674e529a959c46e5ffd0f10ef2c6759f37503da6f2bdb35496d67ea27e77785e98c0ed018f09875084591e9cd0ead04caea9139b613d1955639873aaa5be951783a4d9e79d4886635c0", @@ -158,6 +170,7 @@ "x": "0x58e44444653b857c32777f0d4c6bd24bff430cd4b5d5e2c1057a15b8dedae757ff17c7037962212a9df8f5127e9e2e002e3ac58fbc24d178a399e30c57ed010335f5ef1625994eae17436dd8d4aa4b6c3ae6a235c0b69692ba564a9272d453", "y": "0x639fbfb13eb9394a48ad293df061d96a49ae75a89e0ef997d06c92c5113a16f86a8ad537a0cd8f197eb81508d156744ae2ee802c8806932531bf686f14fca68e6928a75c270885278c9d879e305725bd385b7f189ca8d4f3d253ea04775af8" }, + "scalarBits": 377, "scalar": "0x10b14c3e5e82f05c146bb456bdb53ea6c80e9e09f42ba9f0dbccf1e68f814a06563249c586925461804ce4aa14fa21", "Q": { "x": "0x7260ca99313ad686f58af25f49ec6d4fe0ba3b9d95ebe8fb35bff9f07e1e071c0c7923135949d083c1f20fc21b602964282eb59cf2708a8cd403e992cb30593a816eeded398b8a4809e8956560ae77f4ddae4e5a6282343af2edde7ca8c8e4", @@ -170,6 +183,7 @@ "x": "0x2b03d7c265b827693ac07e27e8b367e3041fd5497f3670975d37b405a4b364ed458079c402af6d5556a1c5e5dd76da504a2d443268798ed5df04067d9e8fea839dc044fce12952822e639ac715a76330192f4b01e15af4a704c372241c61d2", "y": "0xa03dc31b5189609bde8b309ad2b688a9aae1f9c7ef475bff1429227fa2c5b92589b6b0ea5be9b8fdc5785009d2efb9a6261e1cf5925fcb22cfc0de7846f626f1fd54f04eb503c5a8cf847ee8853769d2d7759323ec08ed60f0843394ec1bc4" }, + "scalarBits": 377, "scalar": "0x8232ec21e395273500e7bcf90fea66aeef49687e7f855567d0d4d42f4d60aea8eccf7bd6fe09e7fdc83d038d1c6bcb", "Q": { "x": "0x276105138b4531e049b3b60648937ea826345744fae675746b4f311ea675bacbad6a3b47650a62b41448c4d5829bf3d25e1525799756427fd831a3dfce6c9db9827710052c8a305bebf3d6c226951a4aa683b4622bb61f7c4b07517c85f282", @@ -182,6 +196,7 @@ "x": "0xf8933a5f3a54ea1f86cb35818cb92244f5a20f617086130d8a6d7e875e94a6eaad11c280a7a73db4ab4a556b22409774a56139f7d774b9bd78ed13454f0498feabb17164136da08b1b1b18667964d804824ee83813cd62d2de38ea8e126790", "y": "0xc87a5d7b8837c513a63f6dcb17653d930e4932200abdb323c2da8e3db3ddc4b09a12c098a4522c33e5b64c564fbc92a34d7c9b0bcbeade9e790a51a652c3a27c0fd3d848ae8591623e334ab69c8216d6489db05af084ebc6a5bc4523d45471" }, + "scalarBits": 377, "scalar": "0x11b1832364c17939ccf4ee4cb9eefc2293ea255080154c4c9507505f1016d16ad182a00d52673d6abdc59406f1c7274", "Q": { "x": "0x6c1caba8b68187111dfc351fb1b76656d27e49df8b0bac6dd0d038b104452a27d649fc7311966d671d55c8f72f1d493bf4ab976e79ae56fc7f894b35a6459b6e9e24fafeed3421eeea871fee9b770c284bf566710f0a01fbf071978e68143e", @@ -194,6 +209,7 @@ "x": "0xbb399b9046149d8a675b1324a2859bf3a6770581f9cd0c520e3d0e8eae2c6c67901377dd0404ab16c89a2d4719266bd05597dcc94089eeb03227a94db259173f00bc69ca9f5bf184226e11af635cfaf601b44a15b45c3dda4f8a88ee0ac70", "y": "0xd6f07a312a30052f67b738ce24efa08ee46fac38c7e97eb5800523002aaf7e0fec725dc3e7ffdcdb3549b6031b839900c02199114963ad155f56fb2aa40c0fe64be27d3d9e4fdc7736dc9b084332e199f030de5bb1c7c282e531f89daeb6f0" }, + "scalarBits": 377, "scalar": "0x33c0f4ab242f0e6d1cb2e44894eac39d847396d3cb5d8c2c90bb1a180b7a4cdac2c15c549746025b5a17e0d028efdd", "Q": { "x": "0xfe5f33aff9a2c2d92bd90c5d162f9bd0f4dc03eb0f9967b3224260e11069ca9cb537fd2fdf5aba5cb663b22d300e9f5b0602cd9017c2e2d4619451054bbaf3a412901daeef028c0fd98c4565c18263e23501f9e391e3f5788e3184fefc32d7", @@ -206,6 +222,7 @@ "x": "0x1107904da7203f1e7239bdd297105bc4987c9b9d5bea8b5a0a1c6092e2a3ca5a524aa4264c3042ae2687e4eb8955bf5657930fcf7b9f258ae943ada0ec13e4fbbb8c0f283b73008337695b8bdc3032c51c9923783c4e331de655c4f8029b085", "y": "0xccda560322a4a531a6f983d9e9c40018e7f0427dc6619e229d98d729f99a5fd2953edd42cfa7ca9e1f65efbb7beb78b9e4eb1ce4871ace2ac17e16c6e74a8948151a0cb746fb29a3dbc322643fc8cbfc2ab2445ffee64f29c1bb52d1403201" }, + "scalarBits": 377, "scalar": "0x13852988844cfd5e7901051e9934e8704a4bdc7d815a29950a2f1a9fe95ddcf831e7f9fbbde5495c052b3a31791a88e", "Q": { "x": "0x5632f1c886f483ec6137dd19936a7a2bcb0614becf8958a81cb9ac11a070e057435ec17550debddaefa4b210a2c543ddf67223886449414b61502a0162c7eac10ce07c9b3f8bdd507a620a6d2350e1d68df7b1dfc7201f6f3e5c3ead922862", @@ -218,6 +235,7 @@ "x": "0x4552ddafa5505e6a4997360bd34716cd65cbf863982c0565a925b881f9a61972fa4e01d93258a5901f784708df5091c693c7521d8664b3cee234f75009a3ec52a0a34cd2b3508d3a017c406b98e72393520057d926b4046e48a9e3008b31bc", "y": "0x339c0c75980440d5c8210bd6bdc34a5e8948ab4a15dce47bc8d0db818d024935b312dc07990c00427bfa942843bd81d94fe19c3165d7dafa5f55b79713a3599d35c39949e9746fc24b2a7ec8ccab2b8466241fa07b0e62646d1dcb69243745" }, + "scalarBits": 377, "scalar": "0x9461c64ffcb02128f9b7d41593d72369430f19ad5e5ccb642fb4a6f06c883cb15c22076ac55e54e72844fd1db1cc3c", "Q": { "x": "0xdf81546f9a71617e02df5994fb4ce66637937a145bd10224a8bf2dab4b37337fc98e91cbaf38c230a055bd55d2885ff7f55bc1dde2d8934faed68eff47c3fac0e980d06e93eb534b2ba8cf3e2d5c34bdd01d410fff80440bbb0fe81443ae54", @@ -230,6 +248,7 @@ "x": "0xf8e2c84f8c568ea6b657b15ecd77640c8cd5b5e3d36e13bd17274d587b5543fded2051ec7d77cbe27c07046fbfb2d4c512300fdfd4173e74b86333a002951eab78675d196c390d01951ec501c2377b2edef01d084b2c3419bff0af38e96034", "y": "0xcb7cb10f806298ee53f1c7701c9935368a5565e5ad3336c18d61b6c5af98b7061dd5a7425b8874dd848412d85068d382ef7dca076e356f17f1754b813dcdc1eca4ee7bdca17989fce8221001654da5b22b78ddce75a335edc5725e7331104d" }, + "scalarBits": 377, "scalar": "0x15c24b92513aeceabcc01ebb8d3716ad27d08c210fbef2571765989d2a997e72a76264bc1a06d71617d593a661c7400", "Q": { "x": "0x17a3a7716d0d783eb94dd119e314128c4ef5e6ea030d3fd5d9dd40bf0e7f4151e075c67464a60dd5fad80e7ca5cdbe1a99487f2c2878a4437cc3bbae619ec55ec15a2c6158104cddc008c8f087d3cc8a30355f803566a2cc396c900d7d16a2", @@ -242,6 +261,7 @@ "x": "0x8a265b90a54146d6988fb48cd40fc5ed498f9fedd2c91159e6b2ba0f050f067b7b4eb46df5159695437f61d61dc234a5b23d3507d86ab68710dc3592539d8541416b72ea58304d596b0055e758fcb2b9182fddb9e390d8e0fd870b10d01877", "y": "0x30f39b82bb542ff5315295fefc6d865b0efa2c541139da721bfb8281e670682fac600ba53117536175813997ffb8028f54f82d1f4b54c3abe0a1931405de875822f7dc4d6d22083858f0b8e9fca68926784f18e240d2dd245f6db93742a8f5" }, + "scalarBits": 377, "scalar": "0x18bfa7e290a9a4c302b7593953faea9aa53c6cf92302618423777d35e2297b5d155ee2e2838653ab8724efcd460b962", "Q": { "x": "0xf794363167f6605bd7c7c500814440f0a622e18be55b201599ef7406af39a9a68528fa9c7e2a39c5fe4e0945b547f5956773550595b4158aed82a23602f798b92b2aef7a3a4d51a461c3a4c1360c608abfc8d20e38f738882134dcb069af57", @@ -254,6 +274,7 @@ "x": "0xbaf7f0847742ce33ddc1d08434c05d8b9c7dc13aacd8ce37c6a68da0f3c47b8ae97d345d288c36131d61271b0ed1b298a48bf52a9cd7c9ea472520f0a6d9653b21a0ccdad7c13337677f1c43b707f4a80c83635947ff7ea4f69d5c91ec9f18", "y": "0x3bb82c091b0e62347965472a0120b31e48753b40d154ab3d3d8c87aca7afef4ecc139c24e0cb738da2fec537e092df0c5ea2b58c4596f01276490845dcf21ec32a01abc953c44d0e0e281044e548581680a2a15aa50f7d01877746a814220a" }, + "scalarBits": 377, "scalar": "0x1a815db7201a19e2e11c6d8396c27108e3e545df171b408de52318a7d5949126c686516ec527e7e1f2ce632e3d9da0e", "Q": { "x": "0xe3f5dddaf4a5bf49f3fbb3f39e8241873e17c1b7b962ee7508bb286dfe0380a6a011afce6f9db376ff77e7c6ce9d0c6a587a81382b51140d91c978de40352dbb4d15fa2cad801e20ac5805b773a7253fe736f8f7d25e75e58bf74ec30319c5", @@ -266,6 +287,7 @@ "x": "0xe6f9604a4798679cd7a7eb9f80b31ba1b5a42d71d8392f81fa1a9723c48872b61c719a53e0812d90940aaf1d7e8bae4fe1674fd94daa1f4e3ebc3c3353fe7722cf270f145d6aae74b37e461ed6355d0891a443d68275b718b1190179c23c4d", "y": "0x1c9fb235352adbe204773b7a5f6dde732124d2cc2909b5ca81cbbcdc2c5a04ecb53c9847b943a8fda37928ff89c82240f8c133445123a5e87ec4a02c367ad0d4ac4dd31b9c0d71c060ee510bf3e59320703ed8049b807163abc3f98e4a8220" }, + "scalarBits": 377, "scalar": "0x19913626ccdab5199646eb19d31572fa7da86c87ed1daa34ba07768257226882d3d921105e4aa129b4c0d34493fc369", "Q": { "x": "0xbb702633a93f020f625cfcb9e5dbcfebc2cb014ab4b0bf32b27bfb653c9a42e61ca63b08e5e8035da0869d34b86333d556078ecfaf6f6afeff9952463e8795b523ae299930f799c3fc97a42dc2b0d4f6d2b28e716b8c8c9b0d39305bea24ed", @@ -278,6 +300,7 @@ "x": "0x6b42390c0c49c324aa729606a7661ada8a3d7805df981127cd582efad5da2a3698939608648ba3c6327efe70e45ae783a12c1f0f9e7bdf1cd1cbad02045e8c7cdad8bd9b65aa6474c90a5ae827bfd1e27baac25598ffe5d12ca487376b51ac", "y": "0x7d41340e51c82c0c821af137510f2cc35884e52d20a6bc7ac9dd9de0faacffefd5caa04ea9e00826605013fce3f83b7da20d29d794ec44f1af19cf852c0ee125d18ff03cd43b86ee79988376f33ddfc785fce99cf7c30e0c3e7175c3929964" }, + "scalarBits": 377, "scalar": "0x88d990fbc5bc4fe8a1eb96e0a09c4e8dcb965ca78deb4c55bc4a3845a87e918f79ed022d75c8c556c46e60c16a46ab", "Q": { "x": "0x1057d2575967a3d6bd6a06e3a678fc45e5cb7ac96fba491b8be9db4e99d9de3aa4b000befb83d66c2ef81b499745ec9be21a8e78f14c4d46e3b00fd1140eacb7d45b19932d8f91f919cd2d7910c03b8f71164dca83e7752c1b6b20b6866c256", @@ -290,6 +313,7 @@ "x": "0xf594afc8e1844b3c5b2d1cbdd933bf90f093653bb4d2a7b7d5d7f8e2e439052f4baa72822f7602ca074a888e0ad78bcc9aa184d29d8dc7a6fc936034ade7358bceb6e683496a2bf4b2dfeca61ecb78b7cb2f9a602c7aad5a185ce37eb15b26", "y": "0xfb6e538e5ee5ff6cb09889e6dc85c34100d8c58b10f9e1cb7ceb5510595a2080c14c7aaa709521b1baaef701f13fc32964e43246088230b7f1efdc629d5733e7fc5ba46227a8650fa9ed72ec3a19edf9e3bf52d27dfe24a73e357691bd7679" }, + "scalarBits": 377, "scalar": "0x19b3946436f9cc0df394180bf4d3597741f27971ddf23757cb80835cffcad70604e962cbdd8d391b6bf5af7537ad990", "Q": { "x": "0x10e2a7a13acf873672477c29dd3311f468aadfbbd0ace0d2f8378bd9b423287f93071007c3102e546b84eea50193b635cd58e8a53e29112f85860d539a147b4c6ccc52f85928454fa50cc6116bf2323e87914787118249f18f32c0fe2bca78e", @@ -302,6 +326,7 @@ "x": "0xcbff8ab17ab9013f53815f6d485f1eb217d7537a84c57ef03f644187e0ebf61858c3dfc71cef3fba78c653b12cf122a00d23936baead152776269f0ea9b00a12757cd54ae9f1210ef3f915c4b31667ff17c5fd5af7ac9849bc9ffaeffb6654", "y": "0x7ecfe9fae750c0297918e392e0ada5dbddca49e63b80efb67cbdde413b700c6cd950eb44672d6a8d131aed642051d5fa97484a316186455ce328ef78005d548615631443139d0a3f9547185a5d954bc6917e2cd7c46e845679811d8aa7c567" }, + "scalarBits": 377, "scalar": "0x51f3a4cceb1c28cd0444b7b6500e35fcf6e67af5bf13db2e5b8ecbf925ec553579552c805504415ca62b217d354f05", "Q": { "x": "0x83bbacf669930e5758b6db1797f88dc1754c993ccf902e4af1cd1ac7136710eba44c229327ea4790f988d2527ef4e5f8332370b2e38b4d3a80c52de81db34352dd1c5590a5c0b0590ff555bc288d04be8172a90a13f6fdd387ec07bda35e1d", @@ -314,6 +339,7 @@ "x": "0x41667c709fbeb82ed0fdd10a61930f959acf556859daea3f5a705f649163c25912e0959e7f691b786aa7467aefc464746f5b24867475e20bfc3df49e3b701ff65d6ea20096d0b5e4b7fb12f4c0aaa21e860730617b79e84f3f7b7f4ac06f42", "y": "0x167c81045e5049bc5f5ae5d3b198df184ae476fe9c37f45445968922abae7fddd0cd4b6ef4d0f0ca8db37b7bea4d71ce992dac1755edc36207390211b477c0cbd112c9c5bb3bf8824b0a1b4600b66c291a090b0dec34a616865bbe461f87e5" }, + "scalarBits": 377, "scalar": "0x341986fabc76e3946dd702c57b0ec9584b1ea2d6c9a9efe102deaea772b8cce89933d8c1f06d8c1438845b76af828b", "Q": { "x": "0x308e5fae8b2374f3e5f4013f21a95194338289a11c685febcdf238517a816f6f27af836f5cf4ecb04c1f2652db7a66c041cd954ba1ff847e613a8cf4d7e6be4f6014878dd7a5555605758368742a9880b94d5abb49e516b98105e81d1ea1e4", @@ -326,6 +352,7 @@ "x": "0x3e70e04c34db72274d5d770fcfa211ce20aaf7b83c436a8457d83c19550dd148e789cf6e1aa3d07720f9e74c692203b65b67620337eb19fd44e4fa2ce0bf539ae670dc5540955a0a0e42be39f4dc4f57d6db8eafdc868fed2344cf2d34910a", "y": "0xc7af52b2b56670460496dc261b232806c02d3067a5aa35df11d3d414e39cc268d2c07ac8e1a0abd5bed8e36c7de76c81a2528a0948268172331611a4afb3bf04695a56fab333c8cdbdd8c3fbd43f7464683981d8cbf904af211199282f23ff" }, + "scalarBits": 377, "scalar": "0xfb69db02927653829d59afb5cc83cd35b38e16d80a23a5cce014206a4f4ac625cfff81dced81a03564e93ae2ee36df", "Q": { "x": "0x45ad4fa1a0ae18b65e999161c3b4283732affde935d1475bbc4faf93e4b94fecc1b107f12db4d8a1b7464a0f63e092bbd421570e6e674a01249e86deebb4bb2c66fd1ca8c59981a92856f631863154d92f74fa541220bca235c66875a80ec3", @@ -338,6 +365,7 @@ "x": "0x17092c53168999936bd269c1a97d37d1de74b56fca434cec9c3fea2e2d599b2547523a52c537adb459633aba009e58d29a796995da9f6c7788e57cdebd17e307eb334874272d50f25d20fa7e5eba3a782f8390b8b8db2379e58a90419c3d8c", "y": "0x107b9ccecf4701eda2fb425c5f3887bdfe356a3c1b4c8c9b86a7048890d1aaa0c4b2b4eb1631400ae2f6284e459cb8f080d520eee21ed8cc22e42a0d88f8917c7948e3df7517679627408d7d133a1bdf793757cba0eabe131c3bbbd8a39ab98" }, + "scalarBits": 377, "scalar": "0x6ed467c90dff687fac8c7637d5feebcf8aa1c47bd33dd2eaabbc813811f1e970564b30dcd30e93775c8c711a41fddd", "Q": { "x": "0x79a732c8ac52dce3ce4a863c319ab34e789129b067852a070ed725e27187dc34c9e29372166f2d88154e0d96cae999a3be35d5f15240500fb6c8378731419c21e05457e7b3b0bced57086721a16b710223d2642d26a8bb208b315176994b0e", @@ -350,6 +378,7 @@ "x": "0x975ef56fe1fcd06122f5a4d793231dd7dd45d3618ccb96448d46329f952d50c3c8ff864e7ffee5b20d047f0244e2d8ab84d0a57ee4b94d3f777cecd16cb71f9c7dfe1a6567fac13fde114a977fca04496a6411dc9a59ce9a596b47ce2f84f5", "y": "0x5b6038e0f3437d294329311da4a63738c57055ffd8dd115413fbb3af04ce40c8326197c48187f025414e35ff19735994ea66b690c98bcd4025e5fedf068a1fca2a6a578dffd905b0134749c07f2accf804691bad855d6634cfdec165553c2e" }, + "scalarBits": 377, "scalar": "0x1a6584f789827b2b5560bd7f88fa106e62777af37d48ecf774b2cc7040609b19d04fb6eb4b65fc35b7a8f628df68cfd", "Q": { "x": "0x571339354899bf520c2e67ab81f69ee6f9bfba8cbb4337ff3b910c6cc1c540e8710bcb93f34879ffed4b5e7104be3d17851acfd7623606cf1855b4d21075b561ac21b9a80c347ef7965350ed4c926688dcfe39d37b32d3a2cfc53f9ae7d065", @@ -362,6 +391,7 @@ "x": "0xa78906f0ffe45e76ff9491356b12039765cc7bfb7c255a5300845cf53520de75bd72a349475ff10186b73f6281c8c65f9f210699eee271a0b83db1288bda058d5dfb7e16f25ee1459dc0011f4eb6d47c5464403e3022cb135cda58ce3e03a1", "y": "0x5a65c7dd2110e22da5f6c0bfad43b127d8d98b87a1ef3aa0d8ec6c7ce01ff0d2d41e1430a13cd7f89c1af888bae84855b4f5ada873b2f08913980b6e9234543b82cae867ff3ef7bba577fe1b7517e9d6bb794592848ca4624cd26ed3fb1658" }, + "scalarBits": 377, "scalar": "0x906443b3910f87a67ef765d5333e2e307a6776d9c2780d7752b316d4da125afafe37554881b31e2587e358a085b4cd", "Q": { "x": "0xfb257fdb7a8ef4e2b49718399164100d1500c6ce98fe287f49941add36ab0b93211ad6d8ffdce9ae75967d624695e62621a59b1dd0f6d26f50c9d6e6ceb2588d854d486a27d5ebf523c67f6ee763c0c03b3524472a0eb3204e1c22fd641173", @@ -374,6 +404,7 @@ "x": "0x11970a3ed27ff663fc7773ca56454f037fd702423ad97bab60f06ec6dc2874ffb9816345d65698f55b00b852a0b38209797c89992e238db1ec9344ef50adfe354b153bf9fd61397ce795c3fc83ef3d0b1134e48a9433d1882861732a45d4682", "y": "0xd147cc98bd0cde43a1337c6e43b42362e66b86c5c793210117b06557cd5a93d2e0d4c4027ad74ef84914f74fb29e6bd546e3504b94baf853af97dd4ab3e5ca4bc87da94b94e423d168de6f3246262629933aa0ae9d5afe9b974c6d8e19cda1" }, + "scalarBits": 377, "scalar": "0xaf6559a961f4be436ddbedfaaeb0965663e91e7c6ce03993870869530e404f314079f4cb9f7f79bf2a6d315c34bb36", "Q": { "x": "0xb9e0b889979dc3d1d2c7a9665463d71807930f96364e565e6a420f9609792fff7a1c18a8b9b7823f3aa84f64cbef9038a338bcc134dfa91b8c473e6b43edc6fdfeb229338c32b5e5f992fceb3b7421af0c40036e1a2b1e91b8ca609d4eaaec", @@ -386,6 +417,7 @@ "x": "0xc02aa02419c7d3f30baeb4cf69b12ff986b77ecb54ed5dcd201d5dd0efc786cc706fafb53d41fdac72f5b0412608256b206a38d44ba3a933e8fa9cc040275e18b396607b2d9ea35c9a5be3aa3ba2a85d989abc4b4619b4e0352968bc8d7395", "y": "0xaed8d4db008bb6690ecdeb558ae6fc9f4c987ee733490a6ebee21d3f48b62b14556a934334fdca9d1473733d4ee5a881f69c4f2ee514689b6cb534410ee166f44d449c12577fdcc936c43774617abdb51593871c7f71ff1710ed931787e34e" }, + "scalarBits": 377, "scalar": "0x1ac3bfb85a57fe343d841d603e95c5bab1896c1dc55a60702accc79c11d567cfec9b05f07ff4690e7fb007f51d85106", "Q": { "x": "0xa3b92a6d6813b8fce0284ef6e0247ac4fbeb33d4248a17eefe9b1e6b51c6bd57a19c1afee2a77b7b5e5e8cbd7e51f2fcf914b80f272d92c7ed5ebfa9dd6e04aa5bfded747e757230ec73c33f1579764b933d575b5335f92b98a9dd20e0aae9", @@ -398,6 +430,7 @@ "x": "0x9dbd698fd38d194b3221cfb357eeecd7db6b7321440894994e2bb0ce3891a31b2ad1f80e144ee69a02c41443616ea453f8061cd8a7a8944401b6073c6a4b9297d8ca99370c86ce43cbcbc103adf3aba388af611ee644d28fead236e718d80b", "y": "0xd9eee4ca51af82bb0a696fcda7cbad26bdf1f5c9d534ff26ea886ab3872284c3728edddc24a2f5c1244351f57db10ea10835e353263dc120fe27a99406354b80fde2b05e9d0e69c4c3d08b30673af273c98ab4c3281def393a020dedcc95c5" }, + "scalarBits": 377, "scalar": "0xf7965a0831fd4a659c9cfecb8eea5df564691df0379b925afe128548c90ad43f65af42b4a2a7135eb0b607db96fb71", "Q": { "x": "0x9067f23aa20942462889b9f1ace2390516a8fa6106bbc10159f404fcc442caa7d573222b70e5b6b6c8e2f1ac08b769696c3cb487ee41423633b58c46abf997a0e22ffe965156e30376d0dc57a93254c2cf3c9f3c85947549e4cb42754f2e34", @@ -410,6 +443,7 @@ "x": "0x51b2018081f71ac073cc99fa172acef1cd63a7f9bb6a3c05c2095e5a17532371f6a573c65106cc91c527e1d3638aa0ad57629d9aaa07f06a1bc23065d1408bb75c604baf64c45768e34626dbca2c1612193d43691f3bb2e608857e693c6bd9", "y": "0xfe2cdc1bc8f001fde9e27bae322f408f9f6c3456e7257d7c065cf6efd8a61cdf9d27d2d75c55ca2d007561c5d35cecc6b8a041f60f88f70bee7f8e92fccd65c1468b44a2ceb4ec75e63f53016328325048d48383d7e046e00dac9e13111cbd" }, + "scalarBits": 377, "scalar": "0xca051cfa28ea3d1ab6942d60a2007a466da68b3c21bc24e6ace5de641532f65502263b3781cc115a6b3991ed84027", "Q": { "x": "0x7af096b8ee3d2985653e82a50549ff51d5fc197f68333c6eb2355de523398e0d21179c9dc8306b59c5a946e07fc981e955af1027c7ba522eb16f5c40a3b13424c6c30bc2ad0a6b01db1cf7f8b0e44312909f7e06b23fa506cd92f7be91c43d", @@ -422,6 +456,7 @@ "x": "0xcdcc60726e3413c8a4c17cf7a29df3095c5630c24b53b30409ef9aa417c663a4d192666a6d3155038285c7a94f7a4794ada511a2acc4da3b6cc67f095185103ec1f7c537c411b7fe8bff2d2ed9c81b72c8d83894f2a3fb102a1006afa25666", "y": "0x11a70417f4bf0684ea623f531163dfe69ce20d7ea5c22a031339eec62b0ae82ecdf034291f980b9ac8b950015988c777a5870989f23a2f8dba466312cbd1fdafbef5df24ec9ee74ae32301f417ca8c41ef20f0eac8c75089fb7ac011a744b0e" }, + "scalarBits": 377, "scalar": "0xbbe30f2733979d9e0460ef722b4e388973ccea3f34cfca5ccdf0f666804e5181ee65bcdfd854cf57e91c8f79d029c5", "Q": { "x": "0x56f852808f242b646b4471df8e46242dea98e8f27351a0ceb491bb6db91423e79e90910ebd428eb7ffd967a9d50ae2d858ff872f3e9a880840c4d6b8c7fa3012917f4e746c7baa2ecf8342e445c899a7fc4c6cc37549556140f82161302a40", @@ -434,6 +469,7 @@ "x": "0x945958e41e42d485a13f5f4c0d0b4c66c3228f1f65ea9aab509522ccc2338c93800961d52c60900ace778219efe1b7c2c2929866dc31b36c7cf8506c850ae15ca5e1fe1002d7286d1e7fd61f0a2dfe06937173e02de5ef66e23e9e05a2a1b7", "y": "0xb6dcc5e85b9bf006979f652193954209661d06d93db56da783f4e8679532233842bbf63226fb3f5b790c4edeaf4854a6fa306e124dd782d8c9e2bee0dcbfaeb98b75c72c0d7d1a7dc6dee1f62b2929cffb7ad082d33447f9325b9ebbc70f2e" }, + "scalarBits": 377, "scalar": "0x641a351325cdb90e024588ead0db65faed19fa218f49a16c45aa786a59210429d3a3ce6bc354576af81185f3d4ac01", "Q": { "x": "0xf91010a4e4f3bb7d53774751b96423d3ba8ca10d0e07b8a89916c6e344f2d8fd73346ea246f98799017c9edac2f7f5ef13c3396094a6aa8b1ba55a3b4cd91823ee7fa4d4fa8fc5d8ac120d50990c1ba27067bc41e6b9e5a38dde4d99160f5b", @@ -446,6 +482,7 @@ "x": "0xb1f8d7f441bebb7707b652cc23459e9f2adc9cb24a9818efe923988898e3b6d83c0292502ce7a5ff48dc6b658f42bbb865c38b84530ec757063a1e4fdf822742b3f5c2deedc0d13cb129616b42e981714a4b59ce647c2476639a10500d4d24", "y": "0xbac10c6aada96073ab68875771192dfdf74b3260e4e431f318e4098d597760b134f51752157ca8f4fd4535747ea450bde08ca8e9f6486a74273ee870f9de03913dfd907f84ea652bd94980e2082fc6d23ae928fb4fdedddb21a2048a7c42c9" }, + "scalarBits": 377, "scalar": "0x14e5e12c7591f27289c71d2a174ad3eddb5970fd58e21a5f07874dd75fbfff4f7133476346cdd1bd6b14fbe3cb2e86", "Q": { "x": "0x620542fec79ddae8f63c20a27bd8725d95b61f2b56391bd1ebd643ea75e126382775598698c4147d3072a4275755bab09d4c37ae9148fe94c2c3158bc8976929706a1216bc453af5c4ad76721fb6afd9d2bd3cc1cd1d2df9487d2f2d22e0fc", @@ -458,6 +495,7 @@ "x": "0x11a022a70fe8ceaaf62caa6ae6143f22ce71347b5b17508b2371f0ecc356cc54437f46156cf66a663ec78c6ab6c186a3537391bea668e7937c503e94e2d7897581b67e48816e5964ae465e478872e3381d306485f920d0b4910013a4978e088", "y": "0x5f96897a6d2fddb66507b73c0849c4bab6a9d5d72662754f4390cb4a327e650b38e354cd67b50d82467cf6451dbdd67303e79c247059d6361594ab2e6443864bcce00a495a6641a0a90eddb83d5472658e03ee8d6b12f0d6180177badfb009" }, + "scalarBits": 377, "scalar": "0x13f74c09216b0ee9b528bbc8cee1f5fbc9ac93668e0a1c3dfc56766660224cc1a9e70cd43460c1d03868b1b0cfeed80", "Q": { "x": "0xb1e156c00043feac278f52e7ad53cc57b7114ceb8f32591ef684e080fe34feadd5bfe8d6d195d79d7c8eac6b492ff0df47ba244a07446b0df53c8a6fdd735a8c1851cb749b637fa29b6689feb8eedaab71cae980a9a460de898fb4a4cf936f", @@ -470,6 +508,7 @@ "x": "0xd82a8f756e8df249891faf0f4d6b9502cfa30404e4a578bc72612591e5b3d71f9026060b9c9da0efaedf95213a9b7e705a6b0911c0e8c524ee20d43c914e1739aa0fb77d1102eff55fd46910ebd800bda95fe4f2a5ab821b406c23adcc52a0", "y": "0xa3dc5383a86ba82461221a838a620afe6c4abcdaec704b0059a860a9c82e905274902183d263e346e872005d7c28f29b5b33bd82327fb72f76110cc4b629136959ac3b281754c504115e07981d48d62ce64ba41878af2533c9853c3fa92729" }, + "scalarBits": 377, "scalar": "0xb70e53dec30fa362ffbd21cfaf1255f1ac3b6dd1dd017e4d797716167e2f0ed7293389c7b584c36c968641f6e5b7e2", "Q": { "x": "0x4009a71eebfb58e4b462d409e6e7469a30d00555a24fba30bdbea409b2bcc7ae49e47a17b75b6862770aee09c218ecf45f72dbd317cf43568fb5015bc837a7b39fb5a2d9dd39228e9ddefc58928a980cd831fef110cd41fea9dd30f4e43fc3", @@ -482,6 +521,7 @@ "x": "0xe5c6a1bf81815f93b1ed316067959e48c319d849555a806e2463d04635570938aefa7c6e20df4625d84d73f6c77ba8132cb7f69ff983b4de4d79be02506a545dd873cc2398e6f33c0e70430dbff3a82147ecf8f36bd5f74a5f367a5612ac9d", "y": "0xf0dc8c03c1bf8dd294e7182c73f2f73a83ecea22fac90e28aecd3a3d3c2a91f4c254777ba6bd83c30ef21d44f634b9daf520ede24d4ccb1fcdd1965404929607b90c45e08dded0fc1692bac1c34368ac7260584a6f011e2bba63fcf2e5e583" }, + "scalarBits": 377, "scalar": "0x1a9a1969951675393e2a5bdf0ebe1e7ff35d6b67a636417481ef06a5c872eb1b0f911062b250d49c80ecdcebe467da1", "Q": { "x": "0x6672746bf5e23f004cd05466c36306f701bcab585b08a4c987d9a8855836fd2e0e4b351a5068d7cded0c898cc40a2dba62770cd5d597d03487013c0713a02d1ab92e63bfb4f48b311cad3047ccc4499c9b8a3179307cf1c9ced039c3a98d24", diff --git a/tests/math/vectors/tv_BW6_761_scalar_mul_G2.json b/tests/math/vectors/tv_BW6_761_scalar_mul_G2_377bit.json similarity index 97% rename from tests/math/vectors/tv_BW6_761_scalar_mul_G2.json rename to tests/math/vectors/tv_BW6_761_scalar_mul_G2_377bit.json index d85de41..3eb82c6 100644 --- a/tests/math/vectors/tv_BW6_761_scalar_mul_G2.json +++ b/tests/math/vectors/tv_BW6_761_scalar_mul_G2_377bit.json @@ -19,6 +19,7 @@ "x": "0x390f5ca70bc0a36f30b0f8db9b844d682358490a23fd65f052a11566f082f31b6813462b7d65e82cff45490e77741a547222bfaabb41a490dd641aae6c5da17604e550301a1b45a1d25e375139168a7a491eb354dfa149ca82229857aa45e6", "y": "0xeb29b1fbd522f4d96f61e60dab2800ad7218934414ed8efcfb6371e2b00e9e11c683fbc9a808c694eaf19e3342145d1a2a09eb182996040260fe5527dd3aa7619d444f1217d90b78f367f29f2850b60e6422ccfda316c98d68f024d0991783" }, + "scalarBits": 377, "scalar": "0x100a331b6c086bd660eb2d2bca8f276e283a891b5c0615064d7886af625cf2e7f0b7ade0149796fb2286a707ecc699", "Q": { "x": "0x4620c3fdf54b9d33f6d625c651fd11642b53802491d1874b2956ebcfde0c46ac261ffb17ebdb0d9538c709b11e0d05deb6a9de2150c8b2392a0ac631c0ebfe3542d93ca5b71d2f2e4218a5dc3c8277fea45ee618970a6232b434d07fbb4847", @@ -31,6 +32,7 @@ "x": "0xf1e120a34cec6dc230a399ca31d4e5371c9cd0f06caa830637f6a5d0447f488c9a61ce21c923409cb46acb699e1182e8c7ea7d5ae15acb9337a5856d37fed314c240dce05c22c031b197215e8d5c282d0421b828668e58028d0e9b1a3931", "y": "0x11ead6a04bdc6726cb379cf0ba3d36696bb3c030f39e87c25b4e28fb255e515a8c19d0b7852d1b132fafe8320f2291ddd8604bd82b7fd1a9ff21637b681e4539978ac2a0e6de77da7ccec9f8caa0b38269987da963130cb1fdf8024302ed812" }, + "scalarBits": 377, "scalar": "0x1810decd62e1f9904c3c1497243455c578a963e81b389f04e95ceafc4f47dc777579cdc82eca79bc50d2323ceb694b6", "Q": { "x": "0x8ce5b923cef4d4f1ec0e5808f4c7b2e02b3614a7fe79839038dabbddf0d26d13a84f6cff2da892d84afe657658470e90675b6fe32a6e380a4f66478d1d13d277cd74481a91511f352f2ba8522db59b913b649301ac1b07dbaf28947d0314b9", @@ -43,6 +45,7 @@ "x": "0x2561b56dd064993454c0d658d2c3afba18e07c520f733f32c2f5c3f8b2cbc0fc6dc4919465c62378194d1749d8e512fc006a6bc0903c6a2de2b0009e0d2e6b24b266a1bf5ce4291740bb2a1b1229f960dc6c7928d745bbab0f3e46dee73d46", "y": "0x79573c425c2e1f91eaa818229828489542eeaba8a132f8808fbf7bcdd0bf65fd4a2c6ef98352d64318edc2b85d457b96eb112ca420998b8552cdab7deccfeb4d5cdbacc409c651dfbf8a9ada3a9000ec9e9337515d88b9ac3602c5839bdcad" }, + "scalarBits": 377, "scalar": "0x2254aebe904792d43dfec443d86beb27bd5f377ac462bb25c04b7824026208d2f9dcd4bada63c40825e57c5c5c90d", "Q": { "x": "0x5961709e6f3779a26801095f3161c554b6382b6518c9edf7f2c6a8df1848fae014e6b6bc98338195b8b15f1c6849165b7c978c1d0e48c2d76b1d36751d986410fff36e4d68440450993c97eae762e1be0224f59f8ea828b88b4f47bc1ceedf", @@ -55,6 +58,7 @@ "x": "0xfc714d4638a339575d8597da9c04a896e3a8a1891267dd9e4817acba920c6b966339ddd566264a1640f4e5eaac078b2fb587bdf6bc3250764ba0d08088681934bf2266d8b59f60f9629066d7dba5ab9fc185b24a48762177bbfdfe2feacdbb", "y": "0x4b48f2cc28d8778113ed87a4089776ffdedd735f1d1ae9a0fe870b1ed5bf8ac449d944b8b6781fe43dc7a8d960e1807506f98cd64771f7b4cda9003d744f88d54fca26fb80c592f17c9a04d08de4d32b028a1f63c491e0483e39990997ec06" }, + "scalarBits": 377, "scalar": "0x557cf069b1239bd35a22c905315b8a074e1fe776f14c5543cb1cbab5973cc0605f5bb1b045deac6f5820cf045842ed", "Q": { "x": "0x10d9b485e39d7e54b9ed629218f02f6d5a650787e122ee8a388dabcd462940c84cd2fadd8321088fb027cb4d0b745bb4318bdc20cc21d6665d91af467c71298320df2a33ccd21c45fed4dbf6cb5e55bd0ab52566bb387352a24d0ab28b50463", @@ -67,6 +71,7 @@ "x": "0xfc3f9c827d83a18f06a2445137b8ad01ae61f9f1797a3d038f9cfb710900c0487f6ee2fa9c9c3345eb0a79bc29513b539955312c62dab7c7ec6b904adfcebc63e06cd4f545c14a1f0a08848e7f06d0b6ff27f05a80ae2a39e40197dc72966a", "y": "0x71709bb7418a25576973f9d778b621a38d25e63b1103104eab605d9e132925d5de3b301b49f2ecb25bd0e732a11691de59ab036d2232746dff9008b3c9645152cd81534d4b2c7e861afc0b53e98735d5ef470558b47c5310f92fcdaf12c202" }, + "scalarBits": 377, "scalar": "0x1656931ba49c3036bf5e127d7a7a609b093f5fca57a6d8f2dd64b0bc11bb33d8f60ca1af2b149e991f1e8035fc86ae1", "Q": { "x": "0xf486e4593cdde160b9a6beff8d9167eda70d228079197037266dea37c93d3a88023eb67bf1a234620a626ffbf2fefcd6d42abac14eff80da3607d1e38426e58eafd164a0b30b5b1fc0f0cbccbd0aaf818e33a395254704dd6a755473bc63c0", @@ -79,6 +84,7 @@ "x": "0x79970240516bc00793f147acb795ef46207e15f4c296c205c0a69854b83744e03de512d8089a90719a39f3ed33d1ad7059ce9961e0e21fbe8989e018e104b48bbd3438af07af6f3c27e13cd374f26b46f8d462637316224405a3e5e7e2eeee", "y": "0x301535bc0dd7719bfe93adb3bae92fb886d1db3e981e46aeee520996855e1c6be293439dea472985af3d9eb666688b137f027e479e93649c49aff96ceead1c1887a5fe91b172c4995a3f1c5b4e3ee0f0cab273d7517c9557dbb28bc3618151" }, + "scalarBits": 377, "scalar": "0x59afb2d4389bf7a8c0cea573380eac05f2ec5609c22a9cf5b40e34635a4cdc57c217ff73b58602eb7bc4ffe71446ac", "Q": { "x": "0x9307a46c9a69976de4757814badae0982d07ea52fa04d63ab0bf4e9416998a7fb5e517df7dcd4ddf351fab18681d0671e01d85d88ebf9a8207bac5921d8f32be532d13d3978fd52fa8ab3cb3d86eb302574a62be0c565ea60e8a4b5d8b7f8", @@ -91,6 +97,7 @@ "x": "0x2daebe748cf4e0e9253bf350a952fcf71b7186beb26dba322ef57b6c12026eb51ec882ca70f04fad99c3b854487cb0f85d03d59289a28d7f7d06c6634b80a0646196b1781dc151956fc02f26b60370682583af0521d7e1ec7035c0d7c65fe1", "y": "0x11448b98be2c67e0f51c456ce24f91e374df08842ea6ac6d66374eb67a8d8d64f2598f79986c8bd346fcfe9344703120c2fa4a6f837803e3ad0efa6743197ce3f8f1211d7ed64d4399e7e81d4fb9438124994bfa3d3d3c7aa81dc67875cb24" }, + "scalarBits": 377, "scalar": "0x12a45d924853f6cd3b7882d08153c88a7cd979e911b7ff5e8ba474a72ce4394ec3706dd1b0eb4012f99db511cb3d002", "Q": { "x": "0x8f6d6737c4a04848ce286bb87a1a2735416084896f330f3d69593a38e1a53462a5d294b01b6324a74c3a385c32219ef9f11f1193418e95f3ec477842446b10c11f219b7a6cada1785ac1e607c7f5b862956391a29f60dfd7f2bb85917c8e1d", @@ -103,6 +110,7 @@ "x": "0x31d108961c9944426a53671ab4fe71dd18e05fcd2105317365a5264d9f4e7e340b79cbc004740873a081c354ec058981e2843f67dd858c43db973be276c4acbbeba257cae2af16f83130ca4813bdd01b3e21f5e9a12ec15bcf77b2ebf6956b", "y": "0x8949b06441977876e3f7b0bdfea0aeb8efa6a8c363a222bf3787602b1ca8534fac20182cd9c89359ef460a0e0f5e7c29b7d07001ccc50958bb33d8c7b8f726dd8ced91976ab7417a408789216570435fb8b5f71629fe406a5e5046060705f0" }, + "scalarBits": 377, "scalar": "0xb185643d2b1b856373ac0d7077306885d4689575b48dcb9d3d53fb90454558f76233c46bd3381e6217ede0462d45a", "Q": { "x": "0xdeea8733c42fee969797fa4d0d5fd638ceae4e31379dc200149d506e467c3d18039c5c6529abadb85b235c24bca35518da74544f0ff8b225e158f69a93bb74b3fdd478716118c2bac133f0148a2a147bfd89cfa0d677a87213b4fd7b82126f", @@ -115,6 +123,7 @@ "x": "0xeb982190130ad87bd1ecd572728b6946d246123dbf00421ce35afd922771478da319827b4ebd0895da6b46e27ae41eb82027b7cefc8aa7d8449194a5e0ab1367177781120ea71c06ba38e758fb84555a8ecdb43a247db3ad33786062d70ebc", "y": "0xecf73535b511e47cc2d79c32013e70be6434341e2a5e2d6a5cdb325d82e7cba82e12f003557876d2f2ec3ee0940999dc85be1368951a7be2154ed3df7c7bd614fc4700c78429cc5ed9cfb33388b82254f3bc6cb2fe3fa523964729607955af" }, + "scalarBits": 377, "scalar": "0x975eee0db6a5dca707a0bd313b1f0b1b20d5b776f9ec6a285b66cacafd66c6cc21b8fc69f89f57b2202d83248c16cc", "Q": { "x": "0xaaab758d17e370110dbb04c93f09a83656d00f03e7fbb814bab68183955396fbaa1be04bd60f58eeaad94859424910ebad63ece6ed467a0c3b41db4a5a7b4fa87286ddec03d5a0b387cc5265fbf3d0c745115a1c2339a7ed509b65f83de5e4", @@ -127,6 +136,7 @@ "x": "0x2afee4ee63c14152642f4eb0a8ee9fa085390175e868538094d31cb8c384b083b88d5636272bbb750e661b9eeaa04dc0baa1252308ce08c66ca12d37487a41d1929d679a62b139fded0b7a758be1aa70ed96a872302b372eb021976a75dfe3", "y": "0x10ef5621cec841b4dc795e76219a6f24fa1d08227b8a2c608f2c48ae3b44fb14942e26aba54b6a79df78bbdb31699409c2cf7b0bf6ed45c442a703808f37675778309f935f2357b8fbb6bc0599f4b585b1cd2f58469b1dc9a0817e31b713f97" }, + "scalarBits": 377, "scalar": "0x11cf9d9827d2f48b081e9fc69ad98cc665a657a00a8006d7699836444c0f7fe43a9c147c692af5040ab1092e6846b26", "Q": { "x": "0x6e2d0d2f89d2a34065b5b79d67bd0d8dcef4e56481d6ce3b2d5465667224bc6fab600441ac5e3fb108ff5edd3ed5263f6d63647f9ff6e19acd31afb7464d9eb1f852e48e9a45e3ba2932a295d51d4efd85b1143ecd26369371fa17a2cfd83d", @@ -139,6 +149,7 @@ "x": "0xb6028faa2e1f5be2659512ccd6fcc0e716cce7bdc50b7dee9b4ce06ba3b010af976de58a51179200b3f856e09aba51a8681f918fde43a478fd268c7644bb5a475ab7e79c4fd7a92a8ca48357735304861c4aef88c74703a93c3f46ff40f21f", "y": "0xd487695a509decacf9b345520ec560d225fe74c1a3a8013b9bfd4e15f9e485bf8f738566655d0c8f80af2aee654a60184da3c41ebd3157a2f0c6c2c47ead60a87d0a6cf1ee77d26dbe9155d24e3462b7ea41bbb97c8d23b22e76c64594519f" }, + "scalarBits": 377, "scalar": "0x15ebbb124d78bccbba5e9c01544f17ea95e67721dcdde9b48b6cb5c75f148c056c35aba2a0f7d64e2f0b4870a4ca924", "Q": { "x": "0xda1df45a4354e55f7560b3e28ddfeb06300b2d272f000742aff2292806257bcb9ee45ed7914dc1d25da202f34a4e6ba8380412f8c85d804720827d4b0ab40d3e27108bd86e232b29970c4b01041674cdb10ec6e8f75e67f1d7c6a54c400ca1", @@ -151,6 +162,7 @@ "x": "0x112cfafd6c4ac185ccd683498956af6c2ee20329a0e2dbf3b94c12f5bc749dc8feb8d8b44f2d3552e4814e575df9c87cac3cc375d68a47a94e0e044fc20334d9ef5e5db4a58d17c606f7aced7717c4e46bae609d03e1578ec7308963eafcb7e", "y": "0x7522cb62c176b06e4a2ca359106e2e26363a0cc275cb8eacda79987d7673bf859e546a9150d1faf355262602ddc81c2c4ce7365a2495c40f3d5a58f871e618ceb82c64436d40eceaa3114588db46fe0ecb42b4c9357efa06a7fe5309d51ed2" }, + "scalarBits": 377, "scalar": "0x33c0f4ab242f0e6d1cb2e44894eac39d847396d3cb5d8c2c90bb1a180b7a4cdac2c15c549746025b5a17e0d028efdd", "Q": { "x": "0x81e375c02b429105ea7813d17cf06bec0c809d19e8efad10253c2c4839065072e356c2c50e153c8363f2aec56bfc89107e37af96095150e66f69eaf7f3a66e3f89b4fa419de3eab06d7ec67fc4b488d81273570b4e89dd33a36426e8a613ad", @@ -163,6 +175,7 @@ "x": "0x4485268717a7a311819777b7f5cc096fd7a04250b68fd4cfcd1fb55148e80dc2cdcd2ecb9a735f491672a4f265b4db01efae22adb5be3c3056c54566d162e57a17376873674907d3925d61f59709c12d34acb1af0ce756480bea44cc4a0ef9", "y": "0x9dfe31f14a8a32c10d34af428718bf680dc6e6ea9a2799e9a1e3e7992394f9096c878e1872870d9adb173576e8fbc8281d773b3e8b2610de771596ec99d4a38a8b6562782922b27b05c42c95e0ca7ed345a55030b0d90fbaa41a7a6d65c1e4" }, + "scalarBits": 377, "scalar": "0x118647caeb4d810ce0ad8072d23e8a24ccf26d91d15207a38c8481dda0e8e4b26ae60ee93558056535732379831d5a", "Q": { "x": "0x318f0634c137e3c0328d8ee2fc679767f12a75f6d3e51a4e8fe9cc5759e4d8572b137f891391441e22180525b81e74f31da8f6a8f98bdd2a9542142963bb5e1174fd3b9a05f171c9da3ad249c30939502050053092992eea76b2c7df63ac93", @@ -175,6 +188,7 @@ "x": "0x7742d1c3e01d9f4b9e35bfd27ba2316afe46356b00bb40de023b751e5c917b0914ba48e0e413db0a0f577bf23dba80dd3a813cbe4d046c5fb9954f90c1e58481e3f758126efebc15115946009783bea24452ac7c9085123360c96deea41cf", "y": "0x6ec827631c0d173efef84873368cefdd681c2acf383667a81c56ad8f33b18fc571eaac594220fc721fcb51750cdd32aed54ca6d168ec018f32dd0bc825570366b5788fe80f84d294f331c95c30b93e4634a1a1e64ba244b794edf4ac78ad1e" }, + "scalarBits": 377, "scalar": "0x9461c64ffcb02128f9b7d41593d72369430f19ad5e5ccb642fb4a6f06c883cb15c22076ac55e54e72844fd1db1cc3c", "Q": { "x": "0x62fc12205205938033c3693b4b17e3ada8902a97c149a31ee4f5d47703c74f010b0eb69cfde693f0686df3bf4c8835d4c707b71f5a11896040006776c4091bf6a5d2cf3d7ab19ecb7e79b8a38b7a25dbf4afca644e543ebd431dd7c03242cc", @@ -187,6 +201,7 @@ "x": "0x87f699f7bbc52e536c1b16d1ab1c0395ffb81a0aa42e3cdd08a068f0b3bb3d65ee6f0a6ed4fcfb2db10acf37911158979707ff183a34e0f3c6955c45055964baa353ed7e24be775740dcc3d31fbd24737156fc19acb858e2cc1836f637b925", "y": "0xff54cc166ad89bbf53c1156fda8f7c6762b01cdd5e11d1c12133865efe04dfdfe16ba7f8392be13d57fc642109389326fade1575ddcb3175cf41f82e71728299b953fda9c6a008a5bf3e8fdcbe6568ee9e016eb0d6dfdf48a3b9cde327cf22" }, + "scalarBits": 377, "scalar": "0x10f54f0229c23b67b5784be267a56f33e69c8f62408f318e5e22e57ba2bb77771551001bc9d694f4ae3866129a6063e", "Q": { "x": "0x2620f3c2bada54c85cd33f165ec2a8f638f43468b24af7a21ce504d02565add32734c93a6910170e03ccc792d5598029c726a79d54c539c64742268e3c560fb3680fc75c044e1f9152755ac343caa7506430631b521ed663b5e68824f8ede1", @@ -199,6 +214,7 @@ "x": "0x1a621b075f8348381eb6a259ed5b3eb1e19dedeeb5f497aa24c20f9df33af1177eb3501c2db984737355709c9da6c76732eb8e5ef8777b6fbd429d935dd70b23d5413f9922d7b5f121f6a1fd6c39702133d601b9d0754d8a6c74df14922fcd", "y": "0x99e1ac01fa36be6340e2a133238c25dd7aed328d5e98cf98c29f19756262e2e031570679dcfffffcb0ae21eacade092bc67ef2a5a59e5dfd36872c593dc0328c0d3b0062e29e66f8486031b17ce88e62afe00e732ac0de3fc2032dac659f15" }, + "scalarBits": 377, "scalar": "0x18bfa7e290a9a4c302b7593953faea9aa53c6cf92302618423777d35e2297b5d155ee2e2838653ab8724efcd460b962", "Q": { "x": "0xf3a77b9b231769b599a69f56ac7644b81ceddbdffe93fffbd8bbd6edd2a4a10f371e4eafeadebcfd1bae1b142f11861ff799b514b43ea6522bd6f35c1083a72d9464a8014e125bbf8601c0ead399c63098778efa5a851c00661425fb422a6f", @@ -211,6 +227,7 @@ "x": "0x1b34033bc2f102216b5f253fe8a80f89901f1ac4e157a4cfbe723a8b06832b3ed425cf6f8a7a78e69a253bfd9286242a08c609251ad4c150bcb8d553cb79f0c37c8e3b2560873032af381cee9f050aa8dc62eefcb31c11c7193ea236e8fdf", "y": "0x11a9b1df116ffee7f90274ee60e5303c8f40ec640f79c7442b8d54951ea786d9edb99649b9bdd25cb45ff2ebb8e4cefa445c8d993283887882b3d95cf40df91b8e841431e5add8c16cfcbf573bb62ea14749a88af1b2b49d3c2a664f6026430" }, + "scalarBits": 377, "scalar": "0x1a815db7201a19e2e11c6d8396c27108e3e545df171b408de52318a7d5949126c686516ec527e7e1f2ce632e3d9da0e", "Q": { "x": "0x7296e008492ea8792568cda95db37843831c1e5d683d0358770b1159f0103586ed5f53f42842d19739ca3561a513b62b1f5270f6f80c7feed0fd84b7250e463afeedce18efb8e751e25307685f602ec72b9e18da43b06efa223340b5235504", @@ -223,6 +240,7 @@ "x": "0x325af61a4448ebed6401c4161005fcde5f700b0b06a8390a7191eee7e5969dc918b12c5fb6f31470058f437721110a899fc58f9c8f7f7b27e849c6de954fe828d05077ea4b0e2b924401172527b84155ff00c768f21e037aa77b972b4ca18a", "y": "0xda1655f2810c00eb66e4c6f5cc33f52686232c224ff6f8ced3d686c178cd1d354b84ffbb0d4c0946be113c32baa901f406d6a40e09073a8242a92a2426d42a00597d1699911140c546112a17b367980a813a6d1d6973bf6db8a694a7228c1d" }, + "scalarBits": 377, "scalar": "0x87f0e6732a9ee33c1735f8c92e8a356c1c377edf4c372d2fe7e37eb37b8b1f9bc5a12dca538f23e7216aa90be015f3", "Q": { "x": "0xdd1648265e917af93afe35f4dbd9553d7c2698b03b725c922efc25c2b87ed0fe58798394d5565c12a28419c2ef3cd015baafff9660bdf3c93ba604537b9206493485722b63f4dda3d750ed998bfb2f2ea5459d3eb71a5bb83d78f508a78750", @@ -235,6 +253,7 @@ "x": "0xcfc2fbf349e49b575c988fb08a436db7394d02bad94ac8ecff6ceb2a01a9dd00db634636a43e52827a2d39ab085195a71d0b00183d9195ded1fd1cb6d461bef50ab461bf141a9c3a65a7844bdf98ff590bda8e364358cf34381d60ec93b899", "y": "0x10e5f0685feef04e49128f4983eff16fda79f9f61ae8ebfa980f59ea51f46c3c9e54088523bb0363d0ba3b97f2bf260c4beb9598dd35021254929d7bce010fd048f374a66723192a8a530b2a087720b4df28927f2c9cc0a0b67a1f4dc7953fe" }, + "scalarBits": 377, "scalar": "0x98f59db3a463084258ca815f09b097fc43f7df414ee1a2529c495e967162c47726092286fca39c3a7023dfee552b37", "Q": { "x": "0x1003664ae19a140e8d5571405c0f3db41f7f0c1256bd72df8f80aa6d5e27b2bc24e95b4c4cc168e8be4a8967346cff065433c41872b6fd3429019e1972d9873966ce0c61a939f3c43f6c96d38d316ceda26dab205be31be528c09c60356ffd7", @@ -247,6 +266,7 @@ "x": "0x82aa7bad3d8f7399295ee41a66a4a568e8abba46238ce7caac96a5fc99d8e4db41af0d967837b7cc288684c89267d4d0fae0008596e8e6dbffa2191816b403e6e21e4939d24bfe46ca8c69b2fa6231f786212ee76fee72fddc7374c4c6232f", "y": "0xa15684b2a33d3fa25655c18c7b72b83b7212cd47f4c8f3d9b49a028324126ace885f67365b7c56f1572275f29dd3e13866344a33b82dc15266a59d88a131ddbed3744d9a3682f761971b75293c522aa468d451b7fe3fe6a1b19d42d8af0e98" }, + "scalarBits": 377, "scalar": "0xa55a5328457b26c0177c97aa827cf439be416b0d453cbb3d2b765870d0d58ccb3040313c10716cfbc28e8b0f0da617", "Q": { "x": "0xddceadbbcb52a6bc2aae010ee0f31ee1eb880034ad457645fe23dec4dabbcb581322880a31c0f1d1093df0b9f3716ccf35a4430f9d317c387875e5993bab8d44e1b2a34ec7676b645ab99ca239ebc39dacbd0ff096275711013f4461ad1b33", @@ -259,6 +279,7 @@ "x": "0xeb6aa969dd6687db499a1f2d07cb87ee0632e64d3b8a6d3e563b7005351a7e1182145611d5c85918e8fa3cdc57ac7796697fd4f533ebecc1c102917c58c17eae978ca727b85172b7d171604a00a9d64fbd936f76b6d8f9500465eafdf1fcde", "y": "0xe64bb21e0241fd63961900476152816f4749a4f3d1bb98bc5f43de36d8724e3b477ee7089868e7f73ff66318c5fd0894e409195af6965b5696d1d1d5c2052d5ec650afc71c87e3e43ddd6fcd67cfde996c5f604a971dfdf6f6fa35c8764c85" }, + "scalarBits": 377, "scalar": "0xf35ee1965c92b03144c958da29ee67550da5d8ee8c4289d9917b5957b9b189ac23166f8c124320b7594bb813e20120", "Q": { "x": "0xa791b6c179d884e6ee9b311e4c81ebcaec28de4e4c8434246c64b4a6a24117641db794f038bd011090555e07a750f44059cb2c050b527da4d4fac915c5ec88e8c7b1059f01d57363b38c440a7f60d3e44e0908e7142ca43d46776e15570d86", @@ -271,6 +292,7 @@ "x": "0xf002c90119bd2b351855ac7310692c3f5565d76fa44360797cfbbc56a7bbe625d483269f1385c9f1d1e1a904668a5858d9f460f7fb9185bbc8669cb346ebdf4ddc8cc413369d04cd3b248361b3cd5450255ef45a09cba0a11e59cbf67e8c34", "y": "0x25bb32b037a51322a5790939cdf064ca27feff8c53dbc9a9ec9800abbd420f4231570d76f50b09d9fc173334e175982032c594b6f9ab5633f61efc8ec7abb899761576a68c9e649a339f39ab26846a8e9844838a0ad821728643864cd354f3" }, + "scalarBits": 377, "scalar": "0x1a30ae1a088b1a4ff413926abeba594e9c6194b4abecaaa9be786b2e9b1a487de6aba81d47818a8facf1a716d463173", "Q": { "x": "0x420f4484d6f509b54c1767a20acbb481bab1f78a82011a4e113b40823114bbae4c5938c6f1f5ebd807e01735d549d5710057dcc7e2037baed17b62b5af742fa51c98a379becd1b0a0d84550531401a32d8fc57d9a0c40b88be4732626a3395", @@ -283,6 +305,7 @@ "x": "0x5a6f12252b61763f042b8a806901a59daf430b11753cb6d8580393877c26fa63110587da5345336d7cedbb7538d27247a1070fcc8e9fe1b95f12d9a0f471a400dda3ef7bea499f6ef42fd4ba35f7b39be7d66e103c64205069d3e8e6163894", "y": "0x8719216b9c1132e320ca3df24f21d59b80a4e7254883c4383657725db0bc6d3c63e82f32f45a3b8b0c917c354203bd93e2bb64bf41c7c42d3393d224bd6c0dde019c9abad8fd47bc4048e03ce652551053d67bf32d15f83be3e2bd1d5fb5eb" }, + "scalarBits": 377, "scalar": "0x4d52f9709fae42736d304cad0791cb6af665fe4bd777eedfa49eef0b1a314e58871de882a93d7a00e6c6c57f66535a", "Q": { "x": "0xd118a3b5bda5477449809e96b31838b956a30438895d22c4d41e1ca4c1d658a4d5c2a25dc80b01ab8844f930e9b28b724f31e9fa7999c200dc9a6b0483211e4ea3f1cd2d222163aac57eba46d8d9dd2dd20f88b63a53ccde74cde7627845b2", @@ -295,6 +318,7 @@ "x": "0x1092a20751b0364520204bea0c469003360e1e8df67106325028ee937e3b5c299e035482042680f0921363d4200322960413b3a719c6982e08e423d44a70863e80ff0fa3d885eabae7f5c194cb6ec52187364382f89b894a41bf58e367bf559", "y": "0x9e95d52a786bebe38c2cfbb490aa5bbf6caa12c06cdb77a9e151bf7af2202a5d3a8ca9e5f95013235f6e430fcc6aac01dc933f19403c540ff0ce22526532b608c68b1672fb0789ccf72dea585d7244762e9b03e987e26154d3000ae2624bf5" }, + "scalarBits": 377, "scalar": "0x1800ea2940e1feb9f93155326cd135e8a1802e2df9d1b37bc0bb53fdf5ce0228463be0bddbb6884e25f3c97d66fc7e5", "Q": { "x": "0xce9fd299d5dbc321be86f520fe1fdcf91e08e32d0988ef5be8f9c282dc3602e71291c80cf1fb43f9ea0493980c0cf98a801961a80d087479330c44de53c58f36d085d15e28c6fe149331d277b1811b03f345030d5746d57425d3d5469f862", @@ -307,6 +331,7 @@ "x": "0x853648f7910267d2f65a6973d9349fe0ac64d2cf6e060288458bd5743f8c9469025ef7b67012c99f80b1117be087f24fc630481f45ab7f9fb8b565fa719a9f86daa801a5ab813f5a605892cc9cc01dabf81e33447ab4851b985c5ac754dbff", "y": "0x11d0d0a3a7827413488f6e22f012b6dfacd15d6fa76973e9cef3fb28a3fddb2d67c11d4b3f9426e7a515a345ba57d77e5bdfa64856bccfc41c77308fd0e39633449225bd876f1de286ccf2ab38364174ef5c76c0b436e55bf705e979c3514b6" }, + "scalarBits": 377, "scalar": "0x96278b116b1d748d799bd67e1ff8bf6604ebe96d4e7a68ab55cd9db254ea77310ec9ee5779b355bd32e3c381cfd371", "Q": { "x": "0x9cfed0f6f3481d39ef07d7ff1eb3b9ac14953c7d82ecb327eb98a1d1e7ce6fbd55edc45e1d3630bc5793568b4a05aa3508f78700da3859912d64cbd49190dbda1891f6afc5d5333a85a8f94ac13d98b79eb968761dc3cbeb15702f80e2ea37", @@ -319,6 +344,7 @@ "x": "0x2bc097ff5fbcd10d1a247b5ed4ff7b47645721d3cba06c92975802eb465c26ce151c0ac947db29d4848ae6ccd8dbccd3188ce6f62293bd3b10db72ab29016a7005e88c214a712f162e7ecda6ad78b451b30d2b5bd3382f0f2b289759963900", "y": "0xc878cf1cfac097bbc84aa5445c083febb4da4365073c98b30a67f0c89c2187168849cbd61de920d61f6c6717cb454fba79d8576f77eb3dba2b871048919ccdb4b7c5263fbd755b87a2b9fa4df51be554ba27e38fc2675ec9e5fbcb425204bb" }, + "scalarBits": 377, "scalar": "0x172a23bc1dede10a35d922930fcc492c0b334f5f738bafb18be34dd34a34237dbe729488184e91c2176e46e8ef3d592", "Q": { "x": "0x2b8c4fa14ff82ebe9b00c0314c3f2db2fd76ff0b6c61bd6d70e687a4efeaf73ed554546ae08a7f36175efef76065263aadc4a2678546d0384ffbf5fe8665be43237ad865c8c9db9ebe656e726231d89619365510ffac79be02b783964e68c", @@ -331,6 +357,7 @@ "x": "0xfe8426e2cb385e86078c6eb3b426c82d5adb3d76d8a2b4364326e9c7b25f8dc28f0dd92d3689296fdacbcdffecc19420982c9d9cb7e16697c9915bbf33cce664647e556169268a56b815a9a22d9c08a221a645cc1c2259586d3de40e28d161", "y": "0xbc64ce948d87b11faa0b810932c0aeb11c9b93f16e5f462cadc5bac36be8ab1018baf4eb35d70b93f20ed991b1b11a861a4f81f839f55f0228baa0cb5bcfa2e2c79a96f7bfe6cf2825a70f07004c0242fe75f18210d237bf3c3a2b9456c49d" }, + "scalarBits": 377, "scalar": "0xeefd4cc0f631b5070f6a104e01532d00ff7abacae3b7bf06ac47147e018be511a2d9da23050000359647641926fd54", "Q": { "x": "0x28d4ef5fd4fdf609073ec91d48c3df0567c4e96f7447a624df5d1d66bc0d0492c4a30dd80965a5494026988989e3856f754877864cf4476f86de4c0a53918064f68023cb2d4c949c01845d0840215717dad08959c77bb3b5ab236799da06a", @@ -343,6 +370,7 @@ "x": "0x264c12bb54c2b26f57df64cf5a802f0cb1fb273742606f6914ddb244415194fc07723486041b3d786a8c0cfec8fdb232adfe671f8102379fb279aacc1995f910506205dd983e8fd1a9ee26fb84c745a23399ff546460cb62ad73c8c243e0fa", "y": "0x1020c32905905c7edc3c66e0eecbddbeb59fd07a35419fccb2e90d0067f0cf25093badf35d497ce7889df26ec8a801b1ef46417a1c8c49826d786180d068e092e82b0739ddfe3fa5328761ac0291a9fdcf921af98a63d86ed953e3ea364c05a" }, + "scalarBits": 377, "scalar": "0x10eb3c0a4ec174f5bcd734139b16bc0eebc44ecbd8273d892b9ce9ee7f648a53a97c57a60582a44b2aaf28432c9577a", "Q": { "x": "0x7c018a6be1fe305753496c0041489517fdb3381690c6c786855965958534d5ded5230fb6c79aa28b80004aadd81925e8f1f7c3eaea32ec8c0bf6814fa515048b8a02349ca518b54e4af6a8ed91ec56ecc6a703b146eecd1d58410c6da87bff", @@ -355,6 +383,7 @@ "x": "0xaeae0af1a62b42386d949eb0530d0905bee22548c8fdcb46ea2e3defded5e0dc8c07a3ad0423bf2820860b6e7dd9497f0764767d994c338a2f2002d69c56d5a3fb26dd3cead70b6ffd0fdfd1aca6a09e26ee1d26fec266220bf8ca963f0e31", "y": "0xa3e274b4e774a15b70bf8ab2385dbafb6dccb177971fe45172123ede44fc678e66f94726ed3c426a5217dafce095c252ee97d70d6b26160d8f138bff39c60dd6a8d7c2f2f21c610e221b2229ca5247d6d2069a838560c5627dfd5693abc0a6" }, + "scalarBits": 377, "scalar": "0x537ddfa23aee7312c44e5505cea7c2716ec9cd58a783019c26cef869a34698b57d707ad8eb2866581b710518e4c2e", "Q": { "x": "0x8906bc4c3f3859bde45bcf2874b25a24782d23669caf44c0296d5977c0862fc553f45ee542fc123d9769d7806ed9b6a1275108ce4a3f5d1d0f84d373de2ef97d09d4362cdfe1852abffcf93cec0bb84740dee52291fcf5d5687cb4a65afd02", @@ -367,6 +396,7 @@ "x": "0x8e19bff4c15516e3e70600dd731b431362a3d79b3fb1ccee6e6816901b70854e70435442d6587fbc231e9db188fc74ab29b09d9b0c8e1f747e1309c43d971ea9b776b654deb47a9c333f0afb0449f9985a46549fa9ad5e24c258e1de605a31", "y": "0xd8d43c0af4a7a1324a0d774ca4a17d9b4cfc95c62e9ee474ec40fa04185fd2817e392eda8366eedf9618b282f9e2b52ec168b659d526e8e643f35f6d759269eabbefc919e45da42c9a101d40b5d1952727af0f69ca3c2e1947dab7d8b586c0" }, + "scalarBits": 377, "scalar": "0x86e1cd852f2696195634c18c60fc483dcdadeec4eb9a7264b5abbea75b0bc310806ef765e856e9b167c6f4972e7150", "Q": { "x": "0x3c9e6031acf32ea11ecd0df9f7289e2a65e4df32c0e2a2386edeb8f3eadf1c6d2d19672a3d13ff2815d458024f4c1db6bfda656eee512aac1d7c2e94c0089a1e8a82fe0d5dcbae09e3a1c590cf38cf7c22a3ef85dfe5be1cea01da46c1737f", @@ -379,6 +409,7 @@ "x": "0xcde547fa0f2e91895e46d4b0d2e68901f9d510eea91a1211bf3095da6d582333cbaa9fcbc638a1e1d11e7bf61a2e7b8fd29bec05ada7c0cd0bfbcaa9572686ccc3ec2b23f71e89137a3910222823d24d3046c2cc741125743b8390b3bb4c4e", "y": "0x497c939f755f3526b20e75abb4958aa666f268e879cb7eba3066f9b26c8be822437d2d75caec11ae06e00b4c7c2ba2b9cca8c4db5c320f4bb5e1a8b39004cd304e1dff0ee2a0d690299d5f026e2226f9e8bc7948c041835d853caef732f02d" }, + "scalarBits": 377, "scalar": "0x1902f583a7a8174ebd1bd0060d32c572f167bd0507ff3b13e7d6f6bebcc768e5f401310c951f8d451d6bc755573ff39", "Q": { "x": "0x2183beff6110322b9873c09150cefeca0dc2479d95fc42061b1593de5f6fd3cfa34359a64f4428420573533b3b1538d635f82177816d06c292d5dd70b096ba8c462aeef6db18487c35b7807cbbf06364316840b5030d13aec63079a6a6f126", @@ -391,6 +422,7 @@ "x": "0x1e0384f6cb173344f0c6766a1c7ea55eaf713e1dfa5b80c940b98c0fcd5259d6760ef03f05086958564b66c4381a1b5fd095ecf9a33ef96c82b11056b2cf7ebdbd36244983ce15271055a1caee2ccad3bcc29be1ee661c92d1108c1c4182f6", "y": "0xe44d5719e6f91c2d581695aea92ee86249f9c895129ff2d84833a29f571357df451f40b75b7b7ed5e4920f9dac1a1ce3b29ba05bfdc24a82b433502e9bcedf88ebee95a3add1f9768150177b8d121678a0c270cfa25b9fe17da601fc5c5e49" }, + "scalarBits": 377, "scalar": "0xbbe30f2733979d9e0460ef722b4e388973ccea3f34cfca5ccdf0f666804e5181ee65bcdfd854cf57e91c8f79d029c5", "Q": { "x": "0x45c48ac10e518546a948039b8dd7307adc50d4f9e254204f543c3078195ea291fb9079737590eba7f622701fff1d2f7d17d3ce758c413e741b2c5c4dd5ab4815aa7f251e1a21646f7833c487972227bf8bc00ec125850175f4a4ba5b5d10ad", @@ -403,6 +435,7 @@ "x": "0x520f96c358920d1ff21b29261a02f0069956778975d490038f66f3f11a5c83df13277beacaadb5b8e56e3bca38715d1e8fe328076e78032c24a6450839ba30e60207e8b8d7d89921a45f513eda61253587ff273fdc7b558e79511a222e2c96", "y": "0xc40ce36547c31844d916c68f7d08c88d6fa97af17cb2e0722f02a554a25b8818d5afcabd34c7956ef9ea7e097080952e0fd82ecf9a7a8dd1613b2b08fc1337a7b251aa50a53e80885c2c64c73775eaccc1effb684eddad841567128a54a8de" }, + "scalarBits": 377, "scalar": "0xfea339aa381b1b64af440ada010031f2171ea60cfc33b8bc80c210e464bd9668f3c620f14889dec8e26c3d561f5129", "Q": { "x": "0xbd3276413f5fcfa6d517def13017c5c662a4a81dd2d9acede174c4b25121292347a5dd6c6206d4606548594f85a68641863236768476030c143d2a578b562ad52837b0df3d1100eef08a815efbc5be35628855498e275e3a85d3f7c4075479", @@ -415,6 +448,7 @@ "x": "0x47784e91851f3a90679f213084daad6f7175216db2c78cd4bfc42277c3382d9d48838639241a84d30309ff24ecd09e9fde7453cc0560f5cbe2b9fc1cfa17eb28c3000ed49bfb9106d2c8f53ca56d7a54d174731bfe8174f0b2c198319180f2", "y": "0x4561e9f3f956334b6f1bf2bb8a2ab951d60d1961646e144b8a29916bdf9b9e1d0c07a1f58f544776f06cfbfada04e084dad968cbd647432d10e94e35ada3ab738eb2991db145d236bb4a7247374a04fb5e6ee7bdd543d2f057c3e8bc773360" }, + "scalarBits": 377, "scalar": "0xd530c10fd9449913c19a52956c5002489acd09ece67cd2f1cde7bf3fa0ddcc9d03b1388e7a2a89e5393c468be2877e", "Q": { "x": "0x11eb0350fd391ad89c27478218403f10b6d5c96bd6dc474b6f5e3676f998b61df9e00842e8390496d6d3303140cf3c0b8d5dde99a50fe7b328669af3bad05d13a9c664cddef5185128d47d49b3e0188c5dc202dd95bdc29c3c4203b12d77cbb", @@ -427,6 +461,7 @@ "x": "0x809943c8d93c6db72538927b2a7c1cc427835b4ea952ff994ecc8aa9c4fd4b3b3708ee828c3112d8704a3dce72dd96a1181a624afdedb7a6e33ad7e48e2e6404d33375b42674a9eec1a7c90931a1cb9a973e59fac85a56e20a30c37032b449", "y": "0x12245f2022de09660f609a4caf20a1c7818f46752d317b7f995c1770a56c3172e6d4923dcada28c0bbea0087acc2b8e2a839e985a669d579206dc19ba9afe1745456b2e6232642ab8b6e29e8420426e333362fb818c36ba3d20498f505d15f4" }, + "scalarBits": 377, "scalar": "0x1a66bcfa5a6c9ba9bd74ee4f50f7c1dfb8ab477ad9e45826c9f3d70043ab990069b282a76b20492a382af89d492f935", "Q": { "x": "0xec5ad71fdd54108204c80230c29dac7d5b0becd26223ea4c130c6e0207f31200e657737cc3a3bd6bcd8dced7a693b5242a8c7e09c8bff8836d8c1feb1eb86cf6ff2624b8711ffd0655bfc759062c1b9d765f167b779e122fe6ebbf8857a188", @@ -439,6 +474,7 @@ "x": "0xb6cdae305129bdb24e248231c12eeedb244182ed49f847a307af869b61b633481c6713ecd9819a6f6a2726c768e92d848833ab54e14dd00adb93f9646a17ae8df67a213324f519401ae44a4f30c9d8bff543b9ed1f59dcae3c03fc36ed2b98", "y": "0xdc2b9886b4b43756c3a6064b38433919314146dd2fae73cc34bf76576994459420b55725ce51668771020827517292a0274b2736b6cb99beed841f1f075be579efa5a4faced18587a68c82bcbf7dd8f4c70dd625873b1e8c5d0da727a2d0a9" }, + "scalarBits": 377, "scalar": "0xb70e53dec30fa362ffbd21cfaf1255f1ac3b6dd1dd017e4d797716167e2f0ed7293389c7b584c36c968641f6e5b7e2", "Q": { "x": "0x8ede2e7e6d167f554e14377bae219cc58ccb26e346ef347b636ddd013bdbf27d9d0120b45a442b103dd9a8d330890aeb3545c086919e6adbb106eb36232411386e12af3ebe665faa3e2dd579b53a327421c09ae61e1829ff3d8da9d80f243e", @@ -451,6 +487,7 @@ "x": "0x69a1e973c7eaab0ef3381d4c99eaaa4b6dfbd2fa103f01f0418d8d8ed878c2dbd4a2d840f6e600dc0bdfb419597f4a731d21859d530e58c8f2e3dc96731ddd2bc44c244cade09fdddccc936b1655b1f84b7d0dbc5bc129693d85ab17e50727", "y": "0x3074120782010de499cd11c88d4721cd8e4af55531546065d4a8cce042ebcf5f06ba2ce378e088e798ceb616bc9bdaee7ad508edbe4e29b063647c164951aeca6cf16d6725ecc6ce13e7d6e4d49a05a030ca1ced500aed2c2cd46b6a3a59a" }, + "scalarBits": 377, "scalar": "0x1887572daf2f7334820384013f053c899f17be8aa297e130523e8de5a10a70389efaddd2beae128b4daa2f201553bb9", "Q": { "x": "0x11bf0a6f66ae924feab4e7cc7d545b5e7d1959db756aa93dacde7174fbd813653cc092caaec90b0fa3e683efab64454079d3c4b24d8484a400faf67778445bc808c27eea96691211c35e289adf606fbc4982fb1468be9bba15d015c5d37616a", @@ -463,6 +500,7 @@ "x": "0x6ee26a654c1583032b2695a745d350491b3fa1dfd4d96f56e8bb7fd46e91c9dba40bdab76fa370e118238472459eb651caf3c4a6fe4b484853276dc843e73653e8b95049824f49b2ed60bada770c0fe516890248c852dbf33eb519bac17fdd", "y": "0x4b7a3c45af1e754945165027120eba1099624705f15db1c5dcfb7354ba26fc6cb7661bc4a50a1392edc5332453abf131341e7492f21a77a03134d33c63a7de2c93b865b4a851df667493518af30dff9f6a1e8eddb491d7877e3a15b7e5adda" }, + "scalarBits": 377, "scalar": "0x1206176ca811d9c2ecd9e34bf8a1acb212960ab20daef573113d404b7a4f8cc2fb2cdf97ab07a356256ff38848b6faf", "Q": { "x": "0x5a6a163fe464eae57c819e74abb083abb4c6d6b0ff3edee63f6a121d5b9cfbf7d82e50fc17f2dd9a3951a27ffd636a3850497735697be8f7cc5a4ac87b4d09c06094f8adc25511b50cade67cedf359869344e17598a17d041274d682723624", @@ -475,6 +513,7 @@ "x": "0x12b7e9c103da8136143aee7ecb7947b52e8fad1ce35f061953727d11509cd6f80deb487ec5e31595616d1b8892c676ee0f2d280ea674ead2a1254ace5808559076a7530e8b960a6c69bcf24d36254b02133d1edd38d421c3d9e7ffabc34068", "y": "0x1a03a1f6b82f669524eff54cbef0ac9d08dd6652bd4971097604ceb8213dd1b078e77fe6160321d10e33b6979c5b113656004ae40f97f2a1c51b9d46870086385e1d935e9e7d385413b50dd39fb9a8b1b96cffd736b319c338b7de6356b698" }, + "scalarBits": 377, "scalar": "0x12544b86d259ee660584d11f8c143e0edb5b17e001d63a45dcf1ddede122e91f21a1a42d2334d8c97e1c19e00109d34", "Q": { "x": "0xf208afc0527e9c777113a63c8a7fd437e30366a48fd98061d633b62fb36bfb2c4deac5ac20cd1c43f8a2bdd84be37b234b4029dbe5857ddbf064d0543de1636dd53204e1c3345a18537698740277515a5b606e43d62a52fba8314872b1a314", @@ -487,6 +526,7 @@ "x": "0x10f3313a585a0de35b9993ab1172d041feceef3ee87747be872af04035d6038f9fbe1a6c184fcae3b9baa40af96e3007464aa62d44b477720c7cec7e6642f83a1ca4f8a9f676992da423770851663aef03effafbfbaf3ed0351bf79572bfb5b", "y": "0xa2bb47a7dd0fe83557b8448f078dde0e756c0bb12421ad3b7326f3d39dd07f113cbf45dcdb4492458f43f054f14ae95e7f20024863a04d223ab5b8f6e02c3efd6c50dbbd4fc4b180558f1a13fcff8c708ebd6e8167fb8585c5565c483f8e18" }, + "scalarBits": 377, "scalar": "0x39d2b243507d8a840674119541c34a72a217bc74b669db31aa8f9f67949f1635b41b2d11e4704199b5ea2fbfd2c1e2", "Q": { "x": "0x4eca58459b8b74bef8c254c2e0780968f7804f3b67a744cf0b4a3605bb41335cf83232835468ab970a52511c3d8468e7baf2552d8d1f4ed02d1f0bad2d9da0ef2b13069d5113f3b8bda757bb0a5f5a11973fb2004e8e3f6ea474fcd7b56f0d", diff --git a/tests/math/vectors/tv_Pallas_scalar_mul_G1.json b/tests/math/vectors/tv_Pallas_scalar_mul_G1_255bit.json similarity index 95% rename from tests/math/vectors/tv_Pallas_scalar_mul_G1.json rename to tests/math/vectors/tv_Pallas_scalar_mul_G1_255bit.json index b465d06..f4f07f7 100644 --- a/tests/math/vectors/tv_Pallas_scalar_mul_G1.json +++ b/tests/math/vectors/tv_Pallas_scalar_mul_G1_255bit.json @@ -14,6 +14,7 @@ "x": "0x2af47c3ff9dabccced9746e19855a9438098be6d734f07d1c069aa1bd05b8d87", "y": "0xd4d00c2bece9774e429677e1d4e8d7cb72317a9d426eb03acc93d4e0b1be032" }, + "scalarBits": 255, "scalar": "0x2f2dbce8c1edac90d102e7c33f3fad94304eaff4a67a018cae678774d377f6cd", "Q": { "x": "0x63e38e922ada06c14cf4f0ef18a695fef169ea6d9e6cb69596e7e2dcb9e45c6", @@ -26,6 +27,7 @@ "x": "0x36999dea7f4411360a02b8228e4251896c9492ff93a69ba3720da0cd46a04e83", "y": "0x3611e94b3a435ed32398ffd862868d785310bd3b0feaee78951b0b455f761970" }, + "scalarBits": 255, "scalar": "0x22ce839b19dac61c5e77877fc6fef40f363b164b501dfbdbc09e17ea51d6beb0", "Q": { "x": "0x2eed553a9d1c97cac65db6ec5e2c3de9c1edd02b3c313a850167262cd124be80", @@ -38,6 +40,7 @@ "x": "0x4e77ed8679d8e880034590d16c007bbabc6c65ed870a263b5d1ce7375c18fd7", "y": "0x31df558c0b8758337d92a5ced71e476ba1b5eb0e52e64a68970a57f9ed7de0e3" }, + "scalarBits": 255, "scalar": "0xcf49334389129f3902ba6140660c431a56811b53de01d043e924711bd341e53", "Q": { "x": "0x6d722ca19aecc6f35cdd038f92f856f1701941a6529f3a87caab21cddeb46e7", @@ -50,6 +53,7 @@ "x": "0x1d9125819a5f1c68c1bfec7780a1ebd279739383f2698eeefbba745b3e717fd5", "y": "0x1c65e80e9e0289e770292e241369e4f8d6940ab73a77b09c59b6da631663e176" }, + "scalarBits": 255, "scalar": "0x1a5e139daa2638b7ac3d7d4aa9eff7a12e93dc85db0f9676e5f19fb86d6273e9", "Q": { "x": "0x161bf981167f99bf9fd423f111d65ed23f01cffb16337bfee220dbf0080b1d15", @@ -62,6 +66,7 @@ "x": "0x290a47f32df8d037353fd0bdc6d0febc88c9e1bc568d72c80c58438f6295dc59", "y": "0x1ad890756e24c22f3c1aa590a473efa5e262f3b305b80b73b3fabaaf0c179a9a" }, + "scalarBits": 255, "scalar": "0x708b5a1148f76bdf14f752268eafb065c7272721784a8c6bd3a5fa736332b94", "Q": { "x": "0x1010d4485dc96189b886c4d0a6e5cb3af3d4c0b41c8d8df661a71f64959a6cc4", @@ -74,6 +79,7 @@ "x": "0x60ebc47caee5579e5c96f1ca7b206862c2cf3ce21d79182d58b140074b7bd34", "y": "0x10574ac428a17f07cfbf58d362fb989024dd4b8baf5d6dc4e1a4fecd8c5b0d69" }, + "scalarBits": 255, "scalar": "0x26479726cf5f33ebf21d2c0ba56e1c39fd0e75b1623d3ab160fed44a37ee1bda", "Q": { "x": "0x5b4f916198f9cb3528f9e21c9e01b6253c74c844464b01a271fc1a84b6aa1ea", @@ -86,6 +92,7 @@ "x": "0x4a5e465224ad7d89266c28d1289098f03226fa84e7905b0df4e1f6cc4e2e897", "y": "0x38842bffc633a75cff2ab4fe9ef5395d00555926146a4c7d2ebb67377cd4ee7a" }, + "scalarBits": 255, "scalar": "0x74fc1c66a933e9ad5732235e93cec84ae8db3104348bf24312ffcdf8e0e78a9", "Q": { "x": "0x1ee9b4d272769c3c8fab1d747d9fe3ea1a19f8ecf256ae70c54d0d0eedcf944", @@ -98,6 +105,7 @@ "x": "0x4dcb94ef4b418fc9eb7d7b7f44ed1c4357fa71695ad59299d4404c55a295d64", "y": "0x1fdd76d370c37a9b73dbfd34c616a647434013f1fa48324e589f2fa181ee3df0" }, + "scalarBits": 255, "scalar": "0x1652a6af65163b5d5f2d01c8fcde010d11f3f0f250a2cc84b8bc13dd9083356c", "Q": { "x": "0xe5ff9baa77851908cdc436d0d05680d38e74797cffda32323e89fff9b3acfbb", @@ -110,6 +118,7 @@ "x": "0x261a46c92d424ec4205cc62599b1cff4c7ceaaacc6f1df842689ac863edf4d6b", "y": "0x21c4a02ab5fcf8bd5c3b7ac5b2f67a2ad46c73e32b08098b559c595f84ed1076" }, + "scalarBits": 255, "scalar": "0x1f7306b51f2a882cc4c7915f0eea2218b0089d6a71bb41c911faf48cab4f7ac7", "Q": { "x": "0x2fd22f01b7f6a1ea6a08fcf1a90aefca476bbfca0a656b39e7aa6bac87078e98", @@ -122,6 +131,7 @@ "x": "0x47663865ea0317455f6d5ae6853938a8fd832b055fb8d4d0544dc4733be5873", "y": "0x1d02d331353678fa4258ebc14270ad05d25aa2adebe96a87eca89fc263b0fc0d" }, + "scalarBits": 255, "scalar": "0x29a1123c440cbd0fdc4cc55f1163deec34684839c549f63e2b67043d5c6a3b7a", "Q": { "x": "0x252b34c871d5ed7bac3d9cdadf69a669d583643939aee1bfea4d4a5cb11d66de", @@ -134,6 +144,7 @@ "x": "0x6aa1a26fb01317874bc884137be3ec9d5cc946b3bc90b1a182dd6c8b24d1637", "y": "0x2febb7751b653797b6255c8c6db30fe9212090d3ea52b0b6a80d262d32e7d41a" }, + "scalarBits": 255, "scalar": "0x17233894f9c958d92de37902e1912f818468d2e0228f4bc48f0849e2e721cdae", "Q": { "x": "0x3794dc29819819fcd271dbbbf388dd35a76c1a2ab12d440af61b823149a51300", @@ -146,6 +157,7 @@ "x": "0x1dcc96a9258e687fc9887ca2362b71c50539c881d43097a0578b58c487fd26ca", "y": "0xbaa9ba0c8306073327f8889c50cbb1af27e771ff20ce9484255e4763c1e5ffb" }, + "scalarBits": 255, "scalar": "0xc447303d4bc2adea7b0a0db92822b6c2638691e4388df93f567e11edd6f23", "Q": { "x": "0x199bf85a7955865d07634326b3c0e7bf291e01639f256d81b044148129263c32", @@ -158,6 +170,7 @@ "x": "0x1bffe656e3723d9be238d0610c7236d5549dfe43817b51a5cc6f5fdd6964a7d2", "y": "0x2a879909024c7a6618f9d540d71a683557319fd30baaabbb7f64944ae6c802b" }, + "scalarBits": 255, "scalar": "0x2162dd568cb4ec5f039a2cf378f20b3c3e10bdba4a877e80f4f4c4627163d414", "Q": { "x": "0x18d196b23a0dc2289dc71f31f2322ed6c6fe788a861d109ec3634452d6a12f4", @@ -170,6 +183,7 @@ "x": "0x1e15e96d3cb602604a06c597bc2a75e078b15d7c2df37ce42bde69ca13599811", "y": "0x7a674cd317090dc05f848a75a795657d5757ec82028a788a5c1f4c1f30ec62a" }, + "scalarBits": 255, "scalar": "0xe3117289fc8499db75ae19842f14dc8274af3e92e28716b76d2adc2f4b9b9e7", "Q": { "x": "0x25aa05297627d0e3b983c98eb9f9a75ae40823e5e0a1643c42755aca1e91ec01", @@ -182,6 +196,7 @@ "x": "0x1490b23f45da5ad607639073a076ee8aeb56262bfd4f6dc6e138425eaee9c9ae", "y": "0xd4edea175e89789da3e2f261383c1fb506ce47cf3472fe07b85f01f121b7de8" }, + "scalarBits": 255, "scalar": "0xaaf36853d0be46585a3d75afc6649bd5eef2db0d92ab3b1f8eb4a3930d98f81", "Q": { "x": "0x3acf6a6af3aa4554343a72d2c6ebeb9ec3958f19e38c145853435b94de81c770", @@ -194,6 +209,7 @@ "x": "0x3a19d667722142069dd8d0f55ec1a33f93383842931692b0b8e0edd32ed3afe5", "y": "0x22fdef87984ffa7130dedb72b95394b1a6d21e9a586c4fec57e02b929bb94add" }, + "scalarBits": 255, "scalar": "0x12186f74887ae51975dd3a8dc177ae15bc2aeea4fcffb633ff6f5db5622690c1", "Q": { "x": "0x258560681b64d86ed475fef5b5cb171b03d697003ad84e78acc1ebf6a88e0b63", @@ -206,6 +222,7 @@ "x": "0x2200663cdc8dd561f57694f9f4a32f114e56bf756c8a2ba87df8329a10aa4b12", "y": "0x456b179884d0a1bd7ae211fc18098eecf00b821c8ba0524c3dffc42a403a7bc" }, + "scalarBits": 255, "scalar": "0x2aa663ee85268585b47107252e4d978951d7200f3184d49635554f6bcf20978d", "Q": { "x": "0x2bd36e55f897cdbe8094d2f9ca406408afd992679d89379cd141178a49db8cbd", @@ -218,6 +235,7 @@ "x": "0x24c9f16d760ae783b91cb825b46ad015e45e924b32a562e931783f6c7ec63dca", "y": "0x3661c531c4bc7a7a1e96d71de81f44a59e9cb1e8d09b153eabce96abea932881" }, + "scalarBits": 255, "scalar": "0x1589e516816c1535dc5836f0ba51bf862b70ad57b005f9c8a4a7fcfbd451c8d3", "Q": { "x": "0x2e123272172cbf5701444efaefaf609420fd2ade1001b97725ecb7d56a0cdc6c", @@ -230,6 +248,7 @@ "x": "0x3df0683e82f694e040910e68a54baac4a378d52cfee4aa7335550e8d68ad1c6e", "y": "0x370646bde9e00e05a74b8a483f460550a2720a4f0a9f7beb92ce5491f693a25c" }, + "scalarBits": 255, "scalar": "0x1b3477283988f2af3457fefd358545c6c936c6ccd08c0a6d6b2fbfe1ad2c5d76", "Q": { "x": "0x1c02b13390d6897c802df68954b6514584888cca039a4bf283e7cd9ab13df96", @@ -242,6 +261,7 @@ "x": "0x1577cace09797a29e6aa061e256705e8d1cc9656a652590fa0a42550d009adb3", "y": "0x35172db9be3ad8669395577371c0de7f7faaf795e936a46a152154bfe8941663" }, + "scalarBits": 255, "scalar": "0x28d55f2d1442cd8e3c214282d56a2b893785cf1a4d174c63c3129362844cc400", "Q": { "x": "0x907f51f0945081738beda8d053e543928a6cb770893dd3ade09bbb66d9737bb", @@ -254,6 +274,7 @@ "x": "0x186cf81a6b1503eef66d7e53525577620ac8049000ba2771d604034ce96bc261", "y": "0x155cacf753c137e3515976dd23e6552a5f26ab4bfe79b0b60acd9a75fdc8d221" }, + "scalarBits": 255, "scalar": "0x2b98a51bc3ee524b4be51b806f6ac5c22c2a99e433ab2e80c3e3947e4d79bc71", "Q": { "x": "0x3138443221e88f2e5fe801d7b2f3a12b5c1abdc42ef480d0382ddfa7f621f725", @@ -266,6 +287,7 @@ "x": "0x1a40fd31eb1a813026ed20c3aaac9a1547196f5c9075e9c9e66bd668d4a24546", "y": "0x19ebbbcd62f5df086049cb5cf14b50d246118f0f6b98a377e527358eacfce9df" }, + "scalarBits": 255, "scalar": "0x2cf445370b49c002b74f08059a6a88b004c9a9a71d596073e5d8f1eea9e7b4fa", "Q": { "x": "0x154b10311277f0c22cda903c62bb00cc64cb62568dc4cb2cb7650309474a821f", @@ -278,6 +300,7 @@ "x": "0x397cd9b92bbb24d7428543ec9e65b94cdeeb4e73178805d68bf8a3af2864f3ba", "y": "0x2469453fff56403da13dab62c3fba4bfde51a7cedf35d518d6c8f8caa47b99e0" }, + "scalarBits": 255, "scalar": "0x15d0e4b9b99c880f0572a66c39f5ee0e67d82c46813f79c2cd7e2c3460041e86", "Q": { "x": "0x33c55b1dcd0b909e6f407e357326ea4d85177a6677f081a689053ddcf943762f", @@ -290,6 +313,7 @@ "x": "0x2e5a99d7240122f31cb14dd1992829797f938efb160e01110567e752e0551e99", "y": "0x11943af2229d48e75e48ce151e20305bbd23a85f429357bbde58619af0c3839f" }, + "scalarBits": 255, "scalar": "0x251bc0b63854c5f16edaef18308e29ee1e83cbf1e03091c1f0d1a32a30b6f84e", "Q": { "x": "0x15e2fa7f36db56bf7b875b581f8289ebdb99f7e4feb036c2bc545c42ef83eda6", @@ -302,6 +326,7 @@ "x": "0x68b98202a3eb8afb4b5accb359743a00a96e4e3dddfd5a0dd6a1ac15f163db4", "y": "0x2f2181044e1142bbbcbbbe859d57a699bd6cb5847723b4afd4923f47a8753e30" }, + "scalarBits": 255, "scalar": "0x350bd7ea5026ef342c59323e636fda3a29f8317365975cbd3dd49b9efaddbdc0", "Q": { "x": "0x164e7e2e6e0e8c8f121c0c4da44c91b5d05f00dcdb8dfc3737b7859c20791941", @@ -314,6 +339,7 @@ "x": "0x6ac37c299c47db983bafc9706a79af8ada2e55c35ce4a9a85a8fd066651d5d1", "y": "0x218702da40124c73e7a6bf7bc3e9ed3456366ca6a47f386a3f74746d7b4f7acf" }, + "scalarBits": 255, "scalar": "0x75b0882340f6e12c4f42c30061879c49e7b8aac4624ac8f9ec5a8e597f49016", "Q": { "x": "0x3523a3975ac48cab53a8a389244dc74672bdce72214729aeacf6fca30ee8a8cf", @@ -326,6 +352,7 @@ "x": "0x87f2513d7746fe7975b2c2239bec5fddf94c7aab24f4ef408fced40edba551f", "y": "0x384ca15309b55753d82e75b62350ae1c20a0c04ae051132aaecee2d710b7be8a" }, + "scalarBits": 255, "scalar": "0x5a7fffbdb16d74245e3fecbea1da2d32ad3673d26c942ef8acc773c271d6779", "Q": { "x": "0x24b3a6833013960f196af3c45397a00dc512523f31244744835743f872c000ee", @@ -338,6 +365,7 @@ "x": "0x192b763dd3d423fe9c543b396c469f49b3dba4db0964213207901f39d4c458f6", "y": "0xb41032769e3a81200d14401311457e1f7185edd6cbe9f9c309716a3db45af0a" }, + "scalarBits": 255, "scalar": "0xfca9bb91281b91307d1db8874ad2f2f0f108bd619cfb9f93a034834c6f878", "Q": { "x": "0x7f7c76541d6e1a84f042941c0af27807de70e825d73059c966060ad85d4954d", @@ -350,6 +378,7 @@ "x": "0x19d1ea1b4a65a578cc4af0350a1a42a350cd4103112c9eaf976c57da8bcf166e", "y": "0xaeebf1f86156788a62aeba79af614fb8bc97ccbb7e8df1be9906f7247b9fdc9" }, + "scalarBits": 255, "scalar": "0x3f9ca99fb9499b37cbeb1bea63009250f9859f8b4218e67973428989411fd3ff", "Q": { "x": "0x36d84afb48f2843c48514987f7b2a1e0c46e65ef55a986ffc9002a879bf55215", @@ -362,6 +391,7 @@ "x": "0x3a143ff9bfbe38a03ebb6ce043ceb2371a999f5b1a4798c0848e5dfadcbfdcf9", "y": "0x33e4a3a2657df140989a0c5730719d340040087a98c6100f0bd38d37990f3a64" }, + "scalarBits": 255, "scalar": "0x3e7f18a78ad98fd7240345518a73b5bce00b64020e47f2905258ce8523173271", "Q": { "x": "0x180d4185dd4b79226169c5536d97143302f91cbb062c587db05131c1e9fb248e", @@ -374,6 +404,7 @@ "x": "0x107f5bbb35eb735c320fa0666d1c04ee6ecdda94e889c7caa328e21ac9fc1ff2", "y": "0x2faa567eb241186ac9bef699d00653c851c04f44b56f190eae696b109d10b162" }, + "scalarBits": 255, "scalar": "0x22cba76072845f8d5d45aa4ce2efa998fc66ee686c61a8f4538552a9e6f2b794", "Q": { "x": "0x1c671cd70eecc9dc03bf0f516f8afb7893ca0c69b35feeff492a9e4ba21ad245", @@ -386,6 +417,7 @@ "x": "0x127b80b03442fcf798c027868ea60005a83e1ab73753dd6924df875e34fc64b7", "y": "0x1301db1b1ed61ad3bffc49397fe625521c728b45c1134148484b783ad4b8e461" }, + "scalarBits": 255, "scalar": "0x16feb08c254b0cfb2b34eefa14aa1de6f6e3c4129c0f753fb74425b8bf833667", "Q": { "x": "0x1d2c6bd03b6a18e8c3f0fbd61dd5123225e1156676279419de2a3cf652400a50", @@ -398,6 +430,7 @@ "x": "0x145d95d63e7fdb1bf979ee636bde96267a4b0ca230c8815e2f25b9b412360e6", "y": "0x1c190d719720cac0d68ac6d7587f0bdabd1c7b1b25cdf65aec05bdb410f9d11b" }, + "scalarBits": 255, "scalar": "0x37d4c0fe4655ae5b3f12536374727ad3d0aef1d5c450e4fb5ff63aa48b0860c7", "Q": { "x": "0x1f8437284ca13c3ef39d602d93f062234b3572161837508f971c4049b8203ff9", @@ -410,6 +443,7 @@ "x": "0x1232f94004be88e7a778496195885d8f3d5fac8eb9a996b011b8138b826783ea", "y": "0x2044b0488c79772be3c6009d1c6451ce4802c7245022031f1e6e64ead2d670a8" }, + "scalarBits": 255, "scalar": "0x2c3496e3c96a539d25869b0434e903e460989f1123193bd9dabdf4c8f974c66a", "Q": { "x": "0x971748d2b6f15ab8482e8bf1d9358678890873d88ebd9866ddb24a202d3038", @@ -422,6 +456,7 @@ "x": "0x6d675b937f933adecd599cefab5369350d26b5d5a12222449feaea114aad041", "y": "0x14047374650b0511df7c8b6caf0afd8fec8918fd714825f79fe8a0739bce3359" }, + "scalarBits": 255, "scalar": "0x2f494cf701e805a50e4574af6fbc5f13245d5d4d4798c6aa93eee63483417f7b", "Q": { "x": "0x27f1b1cc290203baaab63e7f7309ed1408a37c1f42643e07d73e36693c2a633c", @@ -434,6 +469,7 @@ "x": "0x48a79ffd325ab2786caded069d5edc178be3bd2b2077de76667c844923289e4", "y": "0x16517799bc897f658f9bee4603a88fddfef2c3f9cd6dafa5e31f0f08a3d999a7" }, + "scalarBits": 255, "scalar": "0x15dbdac7570dd4581627833007d2a82a04c79cfdf1ce57a3e55f0abb14a22213", "Q": { "x": "0x2d80072eae7d7439998d725e44c2575c04cd7dfa8b920abc6f35047b993cc894", @@ -446,6 +482,7 @@ "x": "0x17ec08e51a51b66cc4d730c642d171eb090d6e9a8073957a6736e0af0e262bb6", "y": "0x35821a60f2e3d163d146f6a21618922e10f99626311af4af9925a2006326c2ef" }, + "scalarBits": 255, "scalar": "0x36e749e92df47d6454f700df731d407ce9aec35886cb9f927e0215c657ce95c1", "Q": { "x": "0x20744abca2f12abe87d84a998cd2466c8d85d38817020883d51c6092e33207cd", @@ -458,6 +495,7 @@ "x": "0xa73814ab55d7bc23befa4c97523689d0635e55e526480a62c8a5663522b07dd", "y": "0x17871097c68980fb588a681b8ee2b576d3e6515101f95147a95e8bcfe63f7bca" }, + "scalarBits": 255, "scalar": "0x1ae7d92d79f854b526d9be1cc57b96bbf939432a03af688747e23a910d4db803", "Q": { "x": "0x2277fa3b77b7147e06999e4769bfb783a139bb1e520254a27159edba1773f02d", @@ -470,6 +508,7 @@ "x": "0x31f99fa4af6be5bfa996f34a3243faf641eeb4a441613cee54e9cb6161038bd9", "y": "0x2d2c77e401cac314108db3d8f83a101327089320818460319e930d930fe4fa5c" }, + "scalarBits": 255, "scalar": "0x327880e8329bf792b555787a7285859a0f58d9a409e9efb5f0ff68528217ec4c", "Q": { "x": "0x5eaa66da6a86a7efcef38a8d9a935a637e6c4cc77c578e6da28e5f51713e55a", @@ -482,6 +521,7 @@ "x": "0x4725b1fe2201df726e20a3eb0643653015a790f677d2ee13d0b97e55761fc13", "y": "0x2fa9eca778858b463de6ca52b27d353672b6a825e6cc6645e8212a8377ae5c3a" }, + "scalarBits": 255, "scalar": "0xac5049f5882453952031bb8ab471aae495c8cc4553dcc5c4fd27c9d6ddd7414", "Q": { "x": "0x2283e89eba5b9809be6dc95ace04d4b2befca682eb7012d64344967f86d61ffd", diff --git a/tests/math/vectors/tv_Vesta_scalar_mul_G1.json b/tests/math/vectors/tv_Vesta_scalar_mul_G1_255bit.json similarity index 95% rename from tests/math/vectors/tv_Vesta_scalar_mul_G1.json rename to tests/math/vectors/tv_Vesta_scalar_mul_G1_255bit.json index 68973e1..f563702 100644 --- a/tests/math/vectors/tv_Vesta_scalar_mul_G1.json +++ b/tests/math/vectors/tv_Vesta_scalar_mul_G1_255bit.json @@ -14,6 +14,7 @@ "x": "0x737833841835082f86ca046b71875b051575072e4d6a4aeedac31eee34b07df", "y": "0x227510143dc2cfa6316530f7207b6e9acf2d5f0c7fe5958d9ba7d60673fe530a" }, + "scalarBits": 255, "scalar": "0x2af47c3ff9dabccced9746e19855a9438098be6d734f07d1c069aa1bd05b8d87", "Q": { "x": "0xdf55c23f4b27f5eb96500187226c88bacf19a5ce3532f8ff0188c2f70f87f99", @@ -26,6 +27,7 @@ "x": "0x2f2dbce8c1edac90d102e7c33f3fad94304eaff4a67a018cae678774d377f6cd", "y": "0x2ef7e48e41750e6316b32fd39bcf5862e0b63cc2da5ae909a6cc53754e1ea3a5" }, + "scalarBits": 255, "scalar": "0x36999dea7f4411360a02b8228e4251896c9492ff93a69ba3720da0cd46a04e83", "Q": { "x": "0xac16fbb452fb40102e6fbe10174450d037358473b36df3f1a2e14adb4276b7b", @@ -38,6 +40,7 @@ "x": "0x1be5fe508f44313dc9ddb54de269c6424aaf7164dc5e67917066ea5dfa0d0f1e", "y": "0x30e97acfd8ba342840822e66c371c9edbe1c89707c580fe5c63bdbec175a8990" }, + "scalarBits": 255, "scalar": "0x4e77ed8679d8e880034590d16c007bbabc6c65ed870a263b5d1ce7375c18fd7", "Q": { "x": "0x1df9cd87b46679771f7a374c83f781bd7d23f10f965089e29f1e6529b957a5e4", @@ -50,6 +53,7 @@ "x": "0x1d9125819a5f1c68c1bfec7780a1ebd279739383f2698eeefbba745b3e717fd5", "y": "0x31e6b40691229fa8e43071e044e2fd862f25f8d8611d27173599d1c4cd16a23c" }, + "scalarBits": 255, "scalar": "0x1a5e139daa2638b7ac3d7d4aa9eff7a12e93dc85db0f9676e5f19fb86d6273e9", "Q": { "x": "0x3ad4bcdcad50eca077353d18122dc417afdbd4b20d8d11d5c1330457b307e4dc", @@ -62,6 +66,7 @@ "x": "0x2ebda6fedee061c78e28d668a26add87007ab0d11ad699cba0cb13ae35b8215b", "y": "0x1fa8a58acfcc5fc0e05bd0365ec5b07c675b8c75a250eb0c8d05d3178a96692c" }, + "scalarBits": 255, "scalar": "0x4dcb94ef4b418fc9eb7d7b7f44ed1c4357fa71695ad59299d4404c55a295d64", "Q": { "x": "0x205e486f4fcf3d3c059df6066ec2187e2bbbe086e6c0c6f82a6f42ccfeb042be", @@ -74,6 +79,7 @@ "x": "0x1f7306b51f2a882cc4c7915f0eea2218b0089d6a71bb41c911faf48cab4f7ac7", "y": "0x177cef21af08d4ee2c74cd2afd61e25e4796be5d658ac292014503b48d61b76c" }, + "scalarBits": 255, "scalar": "0x39f587d67f51ef5c90fe33469dd55b0641eaf4597cfde95f01fe8d0c16613599", "Q": { "x": "0x3b2759aa564e9814bfcc51bb731bab0223a689af24353a9a3ca8e41e95e97b2e", @@ -86,6 +92,7 @@ "x": "0x393a99a2239bc59ae80557dfb0c86a1f86ec92e749c8722a713c953eafd6ca20", "y": "0x41c6c8fddabbb9b8de114a9114a25fd8dfe4989313115c37bb02444abb72781" }, + "scalarBits": 255, "scalar": "0x134d7382392961c26657edebd560350298f9138b82fe22216cc054a39e40d4e3", "Q": { "x": "0x3d5f4d81c3f1c25f870e8d697460534ea9e71e5d3088148c1551bac186464190", @@ -98,6 +105,7 @@ "x": "0x47663865ea0317455f6d5ae6853938a8fd832b055fb8d4d0544dc4733be5873", "y": "0xed8406ae04029e2f601375fee4d7c4bffe1bcd5de31b807064c7f0af7d10ddc" }, + "scalarBits": 255, "scalar": "0x29a1123c440cbd0fdc4cc55f1163deec34684839c549f63e2b67043d5c6a3b7a", "Q": { "x": "0x2981ec7ab15d8cb4a98182e9ec6432eb99346a1d1f7df4492d3bfbcf5414d056", @@ -110,6 +118,7 @@ "x": "0x6aa1a26fb01317874bc884137be3ec9d5cc946b3bc90b1a182dd6c8b24d1637", "y": "0x3a58a425a3cf3854a523b9a762d1f6bcd3290a2cb280a1d42c92082250313d05" }, + "scalarBits": 255, "scalar": "0x17233894f9c958d92de37902e1912f818468d2e0228f4bc48f0849e2e721cdae", "Q": { "x": "0x26874bacfffec689e3f56b24798912605e68c5516b06f22bf816c87ba560a722", @@ -122,6 +131,7 @@ "x": "0x2351d82466d3533572ef68839aeb0bc801044c54458c0c0cb27a058faf15dcbf", "y": "0x119d6f7a24a1263068c6d7dcab6d97b13aa1506d3ea0ca019e6cf58b7c3f0002" }, + "scalarBits": 255, "scalar": "0x7aa0a802f6d6eab342473ed2b07313c5b02e2c63f2218e5773df0aa839ce9ba", "Q": { "x": "0x1c3858d9ab2bf6e1a9e04968630df4df688cfa7a5b898a4ebc59fecd18e39b80", @@ -134,6 +144,7 @@ "x": "0x223cdeed1ce48e22970752bd56cab93d47caa252d52948367b21163591f7b7b1", "y": "0x267e42f9f12355e2ea41ed9401e853fc8c4019cb793d8f4370e2f68bfe2c60f0" }, + "scalarBits": 255, "scalar": "0x1ff9adcbc952cc067aa3ae121a242b478d5ed96da30eb78ac5588964dd0f3405", "Q": { "x": "0x1c71f9f5e8cfa9a54b1f4c0081edb98a8cc175c90bff86a633c4929a4f946c15", @@ -146,6 +157,7 @@ "x": "0xc447303d4bc2adea7b0a0db92822b6c2638691e4388df93f567e11edd6f23", "y": "0x1814c2a8a32f7a008ac8ef9abbffbbe0e086a652873d104700956eacd96836fb" }, + "scalarBits": 255, "scalar": "0x135ac8e91e189a485c040d9acc6fcd32f7a1026e23e9e23f7389692541da26ea", "Q": { "x": "0x91abcc90ac367639d282d5a1e45eed84562341d53dfb188df6ddb0e33778c6a", @@ -158,6 +170,7 @@ "x": "0x5b725fed62bf2675414c5455c50dcf09e50d5e980d29ae653cdff2e9a67de43", "y": "0xd2d4de1f2fafae36f7aa71d01337993e2fbdba8a5c89ae4e74703bcb01274fc" }, + "scalarBits": 255, "scalar": "0x313aa62ebd61f0885c9bf39e9c6baeeec2ac555d3c6d1802259a4f4c15e0bd3d", "Q": { "x": "0x20b3afc27ca0655f6abd2d4d33432f737409e48ac88098202ecb9e7ad07f543f", @@ -170,6 +183,7 @@ "x": "0x2162dd568cb4ec5f039a2cf378f20b3c3e10bdba4a877e80f4f4c4627163d414", "y": "0x23736f6a4de96ad619a3843142546582197be0ee783ff012624d3c9c1d728729" }, + "scalarBits": 255, "scalar": "0x10f77b832fea71a426b43a8d0894de8263787a26c6a2afda5bd31f967c65383e", "Q": { "x": "0x1b059eafdf29567b27609b6746c1e894bb30b460503636fd340e687560a8ab65", @@ -182,6 +196,7 @@ "x": "0x1e15e96d3cb602604a06c597bc2a75e078b15d7c2df37ce42bde69ca13599811", "y": "0x247e1539463c5314aaf87be6728f7ebdd01a2abcc9d54f93c283bc4479984989" }, + "scalarBits": 255, "scalar": "0xe3117289fc8499db75ae19842f14dc8274af3e92e28716b76d2adc2f4b9b9e7", "Q": { "x": "0x236f9f208e54cd2e3422e5a1c2f2c2e7aeb6afcadc41f3607bcbdcc036f39f1e", @@ -194,6 +209,7 @@ "x": "0x1490b23f45da5ad607639073a076ee8aeb56262bfd4f6dc6e138425eaee9c9ae", "y": "0x2946df2734be7cf1746c99c6188faa354ea78e938f3ab6b22119c47d061ea797" }, + "scalarBits": 255, "scalar": "0xaaf36853d0be46585a3d75afc6649bd5eef2db0d92ab3b1f8eb4a3930d98f81", "Q": { "x": "0xbde22cb7d1b912509b19f0a8189312596c6b8ce3332371f6813a100a1136327", @@ -206,6 +222,7 @@ "x": "0x12186f74887ae51975dd3a8dc177ae15bc2aeea4fcffb633ff6f5db5622690c1", "y": "0x9e29b5dd5f84701e3d9ee5ae3502fd14d13ccb71379790695c56865443024f" }, + "scalarBits": 255, "scalar": "0x3053be59ce135c94e4a6f8c72128a68b53d8aec09a30e810c08cad0143ca5e18", "Q": { "x": "0x26e5022fe545395f7c772c48304c15a23204006ecc977bfd145fdc581a53ea52", @@ -218,6 +235,7 @@ "x": "0x2200663cdc8dd561f57694f9f4a32f114e56bf756c8a2ba87df8329a10aa4b12", "y": "0x1482239cd5bc225c0924d5e0258da343a987062582d25d8f685e1c6959993230" }, + "scalarBits": 255, "scalar": "0x2aa663ee85268585b47107252e4d978951d7200f3184d49635554f6bcf20978d", "Q": { "x": "0x3d2a0a5e0f06343b5d9b96061072dc65894e04a9d82a63b12e454724448a159f", @@ -230,6 +248,7 @@ "x": "0x24c9f16d760ae783b91cb825b46ad015e45e924b32a562e931783f6c7ec63dca", "y": "0x68c966f8d614fd57a9d7c052bef1d44a4f054c9bfe4d59fd1fd9b8fc641548c" }, + "scalarBits": 255, "scalar": "0x1589e516816c1535dc5836f0ba51bf862b70ad57b005f9c8a4a7fcfbd451c8d3", "Q": { "x": "0x13e6397e50b9561ea2ee029f15e16b6ad5b3bd2817bea925e2ab6a531a7fe686", @@ -242,6 +261,7 @@ "x": "0x682f57f204bc2907b42045f9510693a4af18151888ccf75e71c60c663b73662", "y": "0x16805df45e4cd8ad0808830666366f0c2a36ba11c32d1bf6d11f3498f1030daa" }, + "scalarBits": 255, "scalar": "0x18dbaa78cb90cb68b280558d24a58efe56cace6363a11ad876819e86996bd9d3", "Q": { "x": "0x25d6d198668e744fa299fc35052cb6e49896b6750b6aa17b51d187107e3fec98", @@ -254,6 +274,7 @@ "x": "0x1b3477283988f2af3457fefd358545c6c936c6ccd08c0a6d6b2fbfe1ad2c5d76", "y": "0x2163bb923c8076d64be0e92ba02a79a2e0d6056d94b5c1d0e873be33c499eb9d" }, + "scalarBits": 255, "scalar": "0x1577cace09797a29e6aa061e256705e8d1cc9656a652590fa0a42550d009adb3", "Q": { "x": "0x173787dc097ba37db1cd9beb3b12dbeafcecc7f143d99bb712487d451679e60", @@ -266,6 +287,7 @@ "x": "0x2b98a51bc3ee524b4be51b806f6ac5c22c2a99e433ab2e80c3e3947e4d79bc71", "y": "0x1d8b9fd4e70e009792cbdbc7975cdfcac891bebd00611abe2a9a13a768728556" }, + "scalarBits": 255, "scalar": "0x2f32e37b22e6b2fa24084c299585c90e4a361342dc8d66f509834e0fecebc207", "Q": { "x": "0x1b70aec4b1dcaccef7f58b562382d9f6ba4a5081293fd268cd09cb72ba17c331", @@ -278,6 +300,7 @@ "x": "0x131ecb3afffb09983c2df3d4065c145e9a5c55eee35a0e8ba7e6ca10335ebd0a", "y": "0x2da4291f726cb6524ddd9e723f78f1703a4b048e7e1bb4f511bbae44e87ddb18" }, + "scalarBits": 255, "scalar": "0x1a40fd31eb1a813026ed20c3aaac9a1547196f5c9075e9c9e66bd668d4a24546", "Q": { "x": "0x3f868749eec0e49fb9067fb2c00b9182f6f825cfd8c579a2e2e285d6743598ce", @@ -290,6 +313,7 @@ "x": "0x397cd9b92bbb24d7428543ec9e65b94cdeeb4e73178805d68bf8a3af2864f3ba", "y": "0x3dd55afa178c5a4b20ce2c4eeb89d4bbccdfbb988bf3cc3a83b69c3c4485595e" }, + "scalarBits": 255, "scalar": "0x15d0e4b9b99c880f0572a66c39f5ee0e67d82c46813f79c2cd7e2c3460041e86", "Q": { "x": "0x12ac1f9d2f31e3a236de75720dbceaf50f807aca11c8fbea7bc170676b01d702", @@ -302,6 +326,7 @@ "x": "0x251bc0b63854c5f16edaef18308e29ee1e83cbf1e03091c1f0d1a32a30b6f84e", "y": "0x16f443ac292bca3b759cac9177885cee9cf1443a8bc1f0ef66cd7f2ac7aad9ee" }, + "scalarBits": 255, "scalar": "0x68b98202a3eb8afb4b5accb359743a00a96e4e3dddfd5a0dd6a1ac15f163db4", "Q": { "x": "0xaa75f538ac1c15046e554f7af87956868f35162f54191406c5101c66434229c", @@ -314,6 +339,7 @@ "x": "0x350bd7ea5026ef342c59323e636fda3a29f8317365975cbd3dd49b9efaddbdc0", "y": "0xe075caac88f5e43a5416222b4a3c9e406dae15603eee40a5c93fd32ff9e59dd" }, + "scalarBits": 255, "scalar": "0x6ac37c299c47db983bafc9706a79af8ada2e55c35ce4a9a85a8fd066651d5d1", "Q": { "x": "0x22a065bfd5f3dc77157def7a5edd6eedd8c4d1b088c07e6926a8e8d2c3a8a35f", @@ -326,6 +352,7 @@ "x": "0x75b0882340f6e12c4f42c30061879c49e7b8aac4624ac8f9ec5a8e597f49016", "y": "0xca66a912d664b0c9d5db9eb0cdad75e16220af0f2ed971226c0e6c4e3a125c8" }, + "scalarBits": 255, "scalar": "0xde17547fd694aa85e6e793ff61e58fe244e8637d15a774f25c58989c9e504c2", "Q": { "x": "0x51e1a5f1a59c9e88eb165f762936167bafcd36e4d7b20c703d3775c6d9f7f71", @@ -338,6 +365,7 @@ "x": "0x87f2513d7746fe7975b2c2239bec5fddf94c7aab24f4ef408fced40edba551f", "y": "0x2e0302f618a03f0e73b32ce1d438a3ebc930762a0607dd1eb777b363768be338" }, + "scalarBits": 255, "scalar": "0x5a7fffbdb16d74245e3fecbea1da2d32ad3673d26c942ef8acc773c271d6779", "Q": { "x": "0x4126547e270371f6acef12bcaa15ed4c7759a2cdf7f40805d3e31e772032049", @@ -350,6 +378,7 @@ "x": "0xfca9bb91281b91307d1db8874ad2f2f0f108bd619cfb9f93a034834c6f878", "y": "0xa5b7f9ab5f0ebeb511d060d9f8b6056a6d0024b156eecf30bd2c0c909bdc83e" }, + "scalarBits": 255, "scalar": "0x19d1ea1b4a65a578cc4af0350a1a42a350cd4103112c9eaf976c57da8bcf166e", "Q": { "x": "0x34979fc99ce149d9f586d0b63de8147f1af90c3c149dd5d5a3c97697da0ac103", @@ -362,6 +391,7 @@ "x": "0x3f9ca99fb9499b37cbeb1bea63009250f9859f8b4218e67973428989411fd3ff", "y": "0xd152226b266c18324d354827ba692ddd2da6b2ba7659f5f062e35367e46ce13" }, + "scalarBits": 255, "scalar": "0x3a143ff9bfbe38a03ebb6ce043ceb2371a999f5b1a4798c0848e5dfadcbfdcf9", "Q": { "x": "0x35686b1f039662fd63c399cc63f7638454f87a641dd4af877f6da5d6d6bfbe35", @@ -374,6 +404,7 @@ "x": "0x3e7f18a78ad98fd7240345518a73b5bce00b64020e47f2905258ce8523173271", "y": "0x3142b404ccb490f7d5c0b4994067f6b14eacd51e9217f2eb699cf9aa5906eb36" }, + "scalarBits": 255, "scalar": "0x3e1cfb7f1354525fc9e8032e6c3fd14d4dcf54d2987ee42bf38c6e53cdac95d7", "Q": { "x": "0x15924258d0b2f5ba6bb24eb345ebb24052b5f8b0f3d7a02b04eb1b97c8409032", @@ -386,6 +417,7 @@ "x": "0x107f5bbb35eb735c320fa0666d1c04ee6ecdda94e889c7caa328e21ac9fc1ff2", "y": "0x325a4b8aba70d089a9bea376eb30007583b0acd8a434ea5c8316a034f89d91c2" }, + "scalarBits": 255, "scalar": "0x22cba76072845f8d5d45aa4ce2efa998fc66ee686c61a8f4538552a9e6f2b794", "Q": { "x": "0x1d455daf6b036e5aca4420ff5cc0450c2bf3dec4746149acff00009cbadbfa1e", @@ -398,6 +430,7 @@ "x": "0x16feb08c254b0cfb2b34eefa14aa1de6f6e3c4129c0f753fb74425b8bf833667", "y": "0x387aadc388415cf5dbc446edd8210453e3a4a800cc26a6c08aeaba1e230b5794" }, + "scalarBits": 255, "scalar": "0x154a12b9452166f5c275aa66bb2edaf61071b2a879410f65c2b41225eae64ab1", "Q": { "x": "0x3b364d6c48326ca2bae59aa9c515ec91db30770813ba1d80c6e0632204fe0ff7", @@ -410,6 +443,7 @@ "x": "0x1c3426e28c87c46ebb166e4031cae447f362bff11c0ecd6fa4dbdd1d8c635347", "y": "0x2490ef967538c9ca67e58842e8ea015b165da38d71151aadee204979b600ef72" }, + "scalarBits": 255, "scalar": "0x32e1410e52cc24a3944621abbd99d9f2f17d4008d023f99f8eec38e9554cef6b", "Q": { "x": "0x37821758dbcbe941e80627ee85feaa1957dc8a3b56e62774f460eae694132e9e", @@ -422,6 +456,7 @@ "x": "0x1232f94004be88e7a778496195885d8f3d5fac8eb9a996b011b8138b826783ea", "y": "0x7a58be0727a4e77b178783519da5ea8a327f9d2e7f1f3faa9eb796bbea47f64" }, + "scalarBits": 255, "scalar": "0x2c3496e3c96a539d25869b0434e903e460989f1123193bd9dabdf4c8f974c66a", "Q": { "x": "0x3cee52bf9f24ec17188fd26bf228079c7831e5b48a8cfec5fa059cb3a643054d", @@ -434,6 +469,7 @@ "x": "0x2f494cf701e805a50e4574af6fbc5f13245d5d4d4798c6aa93eee63483417f7b", "y": "0x1bd2d9692cc0c1fc5514b11203eb1843c2be65183db275c22f36fb737d13ee2b" }, + "scalarBits": 255, "scalar": "0x166c1a2d0e7c76ddd79f1aa27b600a6c9500f638794750401adae2dbecd5c56f", "Q": { "x": "0x1f74b61677333885e53c25578c7a5263ee3de2035b0b2ce0d4f422541cc04ccd", @@ -446,6 +482,7 @@ "x": "0x1ae7d92d79f854b526d9be1cc57b96bbf939432a03af688747e23a910d4db803", "y": "0x9969b2d0c5226a0386bea689873529f4e448f61816b617db65c63681c4e50f5" }, + "scalarBits": 255, "scalar": "0x31f99fa4af6be5bfa996f34a3243faf641eeb4a441613cee54e9cb6161038bd9", "Q": { "x": "0x333a735f6e589501871154d40564abeea4cd04bae148cab18c2b31d718bae9be", @@ -458,6 +495,7 @@ "x": "0x327880e8329bf792b555787a7285859a0f58d9a409e9efb5f0ff68528217ec4c", "y": "0x1b1d55cfc64e977c55a91c0b3862e090e2f0a1f0696ad38025b06ddd36ace60" }, + "scalarBits": 255, "scalar": "0x4725b1fe2201df726e20a3eb0643653015a790f677d2ee13d0b97e55761fc13", "Q": { "x": "0x12f5cc7eb733c6df53b911ebd875b0b7fec8692a55a537c4be703ee63164a740", @@ -470,6 +508,7 @@ "x": "0xac5049f5882453952031bb8ab471aae495c8cc4553dcc5c4fd27c9d6ddd7414", "y": "0x338954a1ddc5b91391b4881b48d6b686b5e6a776f32faa8cb6e3e2490695ec54" }, + "scalarBits": 255, "scalar": "0x3a704c1be5ac08ff43834e9190c8dcdd8c5368bb690f8a5c5795d836a68e589d", "Q": { "x": "0x3523c461c262ef4acaa30e85937351a0b0d3a86527791bde0243fbe7f9f4e0bf", @@ -482,6 +521,7 @@ "x": "0x236467bf9a78e8c6e113f7beae859a100190bc8ff62ee797b0aac1aeb6420072", "y": "0x1e74eaeea7c4d0b9411f54c7fe32ab3e94b71af281cbdc69931baf46e1747761" }, + "scalarBits": 255, "scalar": "0x1a755936aeffcd6a67252928971c524c21a3bc4d64c1011a5900f99c40bd379", "Q": { "x": "0x77aabf7ff0fcdc2abdbce25ec9bfcc682ebe601f4b9485acbfb07af0ebcc127", diff --git a/tests/parallel/t_ec_template_parallel.nim b/tests/parallel/t_ec_template_parallel.nim index 4f5ad7f..515ba33 100644 --- a/tests/parallel/t_ec_template_parallel.nim +++ b/tests/parallel/t_ec_template_parallel.nim @@ -78,12 +78,12 @@ proc run_EC_batch_add_parallel_impl*[N: static int]( else: const G1_or_G2 = "G2" - const testSuiteDesc = "Elliptic curve parallel batch addition for Short Weierstrass form" + const testSuiteDesc = "Elliptic curve parallel sum reduction for Short Weierstrass form" suite testSuiteDesc & " - " & $ec & " - [" & $WordBitWidth & "-bit mode]": for n in numPoints: - test $ec & " batch addition (N=" & $n & ")": + test $ec & " sum reduction (N=" & $n & ")": proc test(EC: typedesc, gen: RandomGen) = var tp = Threadpool.new() defer: tp.shutdown() @@ -99,7 +99,7 @@ proc run_EC_batch_add_parallel_impl*[N: static int]( for i in 0 ..< n: r_ref += points[i] - tp.sum_batch_vartime_parallel(r_batch, points) + tp.sum_reduce_vartime_parallel(r_batch, points) check: bool(r_batch == r_ref) @@ -108,7 +108,7 @@ proc run_EC_batch_add_parallel_impl*[N: static int]( test(ec, gen = HighHammingWeight) test(ec, gen = Long01Sequence) - test "EC " & G1_or_G2 & " batch addition (N=" & $n & ") - special cases": + test "EC " & G1_or_G2 & " sum reduction (N=" & $n & ") - special cases": proc test(EC: typedesc, gen: RandomGen) = var tp = Threadpool.new() defer: tp.shutdown() @@ -137,7 +137,7 @@ proc run_EC_batch_add_parallel_impl*[N: static int]( for i in 0 ..< n: r_ref += points[i] - tp.sum_batch_vartime_parallel(r_batch, points) + tp.sum_reduce_vartime_parallel(r_batch, points) check: bool(r_batch == r_ref) diff --git a/tests/t_hash_to_curve.nim b/tests/t_hash_to_curve.nim index 0ef790d..83e26ef 100644 --- a/tests/t_hash_to_curve.nim +++ b/tests/t_hash_to_curve.nim @@ -115,7 +115,7 @@ proc run_hash_to_curve_test( let testSuiteDesc = "Hash to Curve " & $EC.F.C & " " & G1_or_G2 & " - official specs " & spec_version & " test vectors" - suite testSuiteDesc & " [" & $WordBitWidth & "-bit mode]": + suite testSuiteDesc & " [" & $WordBitWidth & "-bit words]": doAssert vec.hash == "sha256" doAssert vec.k == "0x80" # 128 @@ -150,7 +150,7 @@ proc run_hash_to_curve_svdw_test( let testSuiteDesc = "Hash to Curve " & $EC.F.C & " " & G1_or_G2 & " - official specs " & spec_version & " test vectors" - suite testSuiteDesc & " [" & $WordBitWidth & "-bit mode]": + suite testSuiteDesc & " [" & $WordBitWidth & "-bit words]": doAssert vec.hash == "sha256" doAssert vec.k == "0x80" # 128