@dorafactory/maci-sdk 0.1.3-pre.23 → 0.1.3-pre.25

package/dist/index.js

@@ -1212,59 +1212,168 @@ async function genKeypairFromSign({
 }
 
 // src/libs/crypto/curve.ts
-var import_ffjavascript = require("ffjavascript");
-var bls12381r = import_ffjavascript.Scalar.e("73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", 16);
-var bn128r = import_ffjavascript.Scalar.e(
+var import_bn254 = require("@noble/curves/bn254");
+var import_bls12_381 = require("@noble/curves/bls12-381");
+var import_utils = require("@noble/curves/abstract/utils");
+var bls12381r = BigInt("0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001");
+var bn128r = BigInt(
   "21888242871839275222246405745257275088548364400416034343698204186575808495617"
 );
-var bls12381q = import_ffjavascript.Scalar.e(
-  "1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab",
-  16
+var bls12381q = BigInt(
+  "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab"
 );
-var bn128q = import_ffjavascript.Scalar.e(
+var bn128q = BigInt(
   "21888242871839275222246405745257275088696311157297823662689037894645226208583"
 );
+function createBn254Curve() {
+  return {
+    name: "bn254",
+    r: bn128r,
+    q: bn128q,
+    G1: {
+      fromObject: (obj) => obj,
+      toUncompressed: (point) => {
+        const x = BigInt(point[0]);
+        const y = BigInt(point[1]);
+        const p = new import_bn254.bn254.G1.ProjectivePoint(x, y, 1n);
+        p.assertValidity();
+        const affine = p.toAffine();
+        const xBytes = (0, import_utils.numberToBytesBE)(affine.x, 32);
+        const yBytes = (0, import_utils.numberToBytesBE)(affine.y, 32);
+        const bytes = new Uint8Array(64);
+        bytes.set(xBytes, 0);
+        bytes.set(yBytes, 32);
+        return bytes;
+      }
+    },
+    G2: {
+      fromObject: (obj) => obj,
+      toUncompressed: (point) => {
+        const Fp2 = import_bn254.bn254.fields.Fp2;
+        const x = Fp2.create({ c0: BigInt(point[0][0]), c1: BigInt(point[0][1]) });
+        const y = Fp2.create({ c0: BigInt(point[1][0]), c1: BigInt(point[1][1]) });
+        const p = new import_bn254.bn254.G2.ProjectivePoint(x, y, Fp2.ONE);
+        p.assertValidity();
+        const affine = p.toAffine();
+        const x0Bytes = (0, import_utils.numberToBytesBE)(affine.x.c0, 32);
+        const x1Bytes = (0, import_utils.numberToBytesBE)(affine.x.c1, 32);
+        const y0Bytes = (0, import_utils.numberToBytesBE)(affine.y.c0, 32);
+        const y1Bytes = (0, import_utils.numberToBytesBE)(affine.y.c1, 32);
+        const bytes = new Uint8Array(128);
+        bytes.set(x1Bytes, 0);
+        bytes.set(x0Bytes, 32);
+        bytes.set(y1Bytes, 64);
+        bytes.set(y0Bytes, 96);
+        return bytes;
+      }
+    }
+  };
+}
+function createBls12381Curve() {
+  return {
+    name: "bls12_381",
+    r: bls12381r,
+    q: bls12381q,
+    G1: {
+      fromObject: (obj) => obj,
+      toUncompressed: (point) => {
+        const x = BigInt(point[0]);
+        const y = BigInt(point[1]);
+        const p = new import_bls12_381.bls12_381.G1.ProjectivePoint(x, y, 1n);
+        p.assertValidity();
+        const affine = p.toAffine();
+        const xBytes = (0, import_utils.numberToBytesBE)(affine.x, 48);
+        const yBytes = (0, import_utils.numberToBytesBE)(affine.y, 48);
+        const bytes = new Uint8Array(96);
+        bytes.set(xBytes, 0);
+        bytes.set(yBytes, 48);
+        return bytes;
+      }
+    },
+    G2: {
+      fromObject: (obj) => obj,
+      toUncompressed: (point) => {
+        const Fp2 = import_bls12_381.bls12_381.fields.Fp2;
+        const x = Fp2.create({ c0: BigInt(point[0][0]), c1: BigInt(point[0][1]) });
+        const y = Fp2.create({ c0: BigInt(point[1][0]), c1: BigInt(point[1][1]) });
+        const p = new import_bls12_381.bls12_381.G2.ProjectivePoint(x, y, Fp2.ONE);
+        p.assertValidity();
+        const affine = p.toAffine();
+        const x0Bytes = (0, import_utils.numberToBytesBE)(affine.x.c0, 48);
+        const x1Bytes = (0, import_utils.numberToBytesBE)(affine.x.c1, 48);
+        const y0Bytes = (0, import_utils.numberToBytesBE)(affine.y.c0, 48);
+        const y1Bytes = (0, import_utils.numberToBytesBE)(affine.y.c1, 48);
+        const bytes = new Uint8Array(192);
+        bytes.set(x1Bytes, 0);
+        bytes.set(x0Bytes, 48);
+        bytes.set(y1Bytes, 96);
+        bytes.set(y0Bytes, 144);
+        return bytes;
+      }
+    }
+  };
+}
 async function getCurveFromR(r2) {
-  let curve;
-  if (import_ffjavascript.Scalar.eq(r2, bn128r)) {
-    curve = await (0, import_ffjavascript.buildBn128)();
-  } else if (import_ffjavascript.Scalar.eq(r2, bls12381r)) {
-    curve = await (0, import_ffjavascript.buildBls12381)();
+  if (r2 === bn128r) {
+    return createBn254Curve();
+  } else if (r2 === bls12381r) {
+    return createBls12381Curve();
   } else {
-    throw new Error(`Curve not supported: ${import_ffjavascript.Scalar.toString(r2)}`);
+    throw new Error(`Curve not supported: ${r2.toString()}`);
   }
-  return curve;
 }
 async function getCurveFromQ(q) {
-  let curve;
-  if (import_ffjavascript.Scalar.eq(q, bn128q)) {
-    curve = await (0, import_ffjavascript.buildBn128)();
-  } else if (import_ffjavascript.Scalar.eq(q, bls12381q)) {
-    curve = await (0, import_ffjavascript.buildBls12381)();
+  if (q === bn128q) {
+    return createBn254Curve();
+  } else if (q === bls12381q) {
+    return createBls12381Curve();
   } else {
-    throw new Error(`Curve not supported: ${import_ffjavascript.Scalar.toString(q)}`);
+    throw new Error(`Curve not supported: ${q.toString()}`);
   }
-  return curve;
 }
 async function getCurveFromName(name) {
-  let curve;
   const normName = normalizeName(name);
   if (["BN128", "BN254", "ALTBN128"].indexOf(normName) >= 0) {
-    curve = await (0, import_ffjavascript.buildBn128)();
+    return createBn254Curve();
   } else if (["BLS12381"].indexOf(normName) >= 0) {
-    curve = await (0, import_ffjavascript.buildBls12381)();
+    return createBls12381Curve();
   } else {
     throw new Error(`Curve not supported: ${name}`);
   }
-  return curve;
   function normalizeName(n) {
     return (n.toUpperCase().match(/[A-Za-z0-9]+/g) || []).join("");
   }
 }
 
 // src/libs/crypto/adapter.ts
-var import_ffjavascript2 = require("ffjavascript");
-var { unstringifyBigInts } = import_ffjavascript2.utils;
+var unstringifyBigInts = (obj) => {
+  if (typeof obj === "string") {
+    if (obj.startsWith("0x")) {
+      try {
+        return BigInt(obj);
+      } catch {
+        return obj;
+      }
+    }
+    if (/^-?\d+$/.test(obj)) {
+      return BigInt(obj);
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(unstringifyBigInts);
+  }
+  if (typeof obj === "object" && obj !== null) {
+    const result = {};
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        result[key] = unstringifyBigInts(obj[key]);
+      }
+    }
+    return result;
+  }
+  return obj;
+};
 var Bytes2Str = (arr) => {
   let str = "";
   for (let i = 0; i < arr.length; i++) {
@@ -9651,7 +9760,7 @@ var import_snarkjs = require("snarkjs");
 
 // src/libs/keypairs/eddsa-poseidon/keypair.ts
 var import_blake2b = require("@noble/hashes/blake2b");
-var import_utils9 = require("@noble/hashes/utils");
+var import_utils10 = require("@noble/hashes/utils");
 var import_bip32 = require("@scure/bip32");
 var import_sha2563 = require("@noble/hashes/sha256");
 var import_eddsa_poseidon4 = require("@zk-kit/eddsa-poseidon");
@@ -9857,7 +9966,7 @@ var EdDSAPoseidonKeypair = class _EdDSAPoseidonKeypair extends Keypair3 {
   static fromSecretKey(secretKey, options) {
     if (typeof secretKey === "string") {
       const cleanSecretKey = secretKey.startsWith("0x") ? secretKey.slice(2) : secretKey;
-      const decoded = buffer2Bigint((0, import_utils9.hexToBytes)(cleanSecretKey));
+      const decoded = buffer2Bigint((0, import_utils10.hexToBytes)(cleanSecretKey));
       return this.fromSecretKey(decoded, options);
     }
     const unPackedPublicKey = genPubKey(secretKey);
@@ -9865,7 +9974,7 @@ var EdDSAPoseidonKeypair = class _EdDSAPoseidonKeypair extends Keypair3 {
     if (!options || !options.skipValidation) {
       const encoder = new TextEncoder();
       const signData = encoder.encode("dora validation");
-      const msgHash = (0, import_utils9.bytesToHex)((0, import_blake2b.blake2b)(signData, { dkLen: 16 }));
+      const msgHash = (0, import_utils10.bytesToHex)((0, import_blake2b.blake2b)(signData, { dkLen: 16 }));
       const signature = (0, import_eddsa_poseidon4.signMessage)(bigInt2Buffer(secretKey), msgHash);
       if (!(0, import_eddsa_poseidon4.verifySignature)(msgHash, signature, unPackedPublicKey)) {
         throw new Error("Provided secretKey is invalid");
@@ -9895,7 +10004,7 @@ var EdDSAPoseidonKeypair = class _EdDSAPoseidonKeypair extends Keypair3 {
    * @returns The secret key encoded as a hexadecimal string
    */
   getSecretKey() {
-    return (0, import_utils9.bytesToHex)(bigInt2Buffer(this.keypair.secretKey));
+    return (0, import_utils10.bytesToHex)(bigInt2Buffer(this.keypair.secretKey));
   }
   getFormatedPrivKey() {
     return this.keypair.formatedPrivKey;