add bip340 test

Author: matthiasgeihs

package-lock.json

@@ -55,8 +55,8 @@
     "@toruslabs/fetch-node-details": "^14.0.1",
     "@toruslabs/fnd-base": "^14.0.0",
     "@toruslabs/metadata-helpers": "^6.0.0",
-    "@toruslabs/session-manager": "^3.1.0",
     "@toruslabs/openlogin-utils": "^8.2.1",
+    "@toruslabs/session-manager": "^3.1.0",
     "@toruslabs/torus.js": "^15.1.0",
     "@toruslabs/tss-client": "^3.3.0-alpha.0",
     "@toruslabs/tss-frost-client": "^1.0.0-alpha.0",
@@ -68,6 +68,7 @@
   },
   "devDependencies": {
     "@babel/register": "^7.25.7",
+    "@noble/curves": "^1.6.0",
     "@toruslabs/config": "^2.2.0",
     "@toruslabs/eslint-config-typescript": "^3.3.3",
     "@toruslabs/torus-scripts": "^6.1.2",

package.json

@@ -672,13 +672,31 @@ export class Web3AuthMPCCoreKit implements ICoreKit {
   /**
    * Get public key in ed25519 format.
    *
-   * Throws an error if keytype is not compatible with ed25519.
+   * Throws an error if signature type is not ed25519.
    */
   public getPubKeyEd25519(): Buffer {
+    if (this._sigType !== SigType.ed25519) {
+      throw CoreKitError.default(`getPubKeyEd25519 not supported for signature type ${this.sigType}`);
+    }
+
     const p = this.tkey.tssCurve.keyFromPublic(this.getPubKey()).getPublic();
     return ed25519().keyFromPublic(p).getPublic();
   }
 
+  /**
+   * Get public key in bip340 format.
+   *
+   * Throws an error if signature type is not bip340.
+   */
+  public getPubKeyBip340(): Buffer {
+    if (this._sigType !== SigType.bip340) {
+      throw CoreKitError.default(`getPubKeyBip340 not supported for signature type ${this.sigType}`);
+    }
+
+    const p = this.tkey.tssCurve.keyFromPublic(this.getPubKey()).getPublic();
+    return p.getX().toBuffer("be", 32);
+  }
+
   public async precompute_secp256k1(): Promise<{
     client: Client;
     serverCoeffs: Record<string, string>;

src/mpcCoreKit.ts

@@ -0,0 +1,153 @@
+import assert from "node:assert";
+import test from "node:test";
+
+import { EllipticPoint } from "@tkey/common-types";
+import { UX_MODE_TYPE } from "@toruslabs/customauth";
+import { tssLib } from "@toruslabs/tss-frost-lib-bip340";
+import BN from "bn.js";
+import { schnorr as bip340 } from '@noble/curves/secp256k1';
+
+import { AsyncStorage, COREKIT_STATUS, MemoryStorage, WEB3AUTH_NETWORK, WEB3AUTH_NETWORK_TYPE, Web3AuthMPCCoreKit } from "../src";
+import { bufferToElliptic, criticalResetAccount, mockLogin, mockLogin2 } from "./setup";
+
+type TestVariable = {
+  web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
+  uxMode: UX_MODE_TYPE | "nodejs";
+  manualSync?: boolean;
+  email: string;
+};
+
+const defaultTestEmail = "testEmailForLoginBip340";
+const variable: TestVariable[] = [
+  { web3AuthNetwork: WEB3AUTH_NETWORK.DEVNET, uxMode: "nodejs", email: defaultTestEmail },
+  // { web3AuthNetwork: WEB3AUTH_NETWORK.MAINNET, uxMode: UX_MODE.REDIRECT, email: defaultTestEmail },
+
+  { web3AuthNetwork: WEB3AUTH_NETWORK.DEVNET, uxMode: "nodejs", manualSync: true, email: defaultTestEmail },
+  // { web3AuthNetwork: WEB3AUTH_NETWORK.MAINNET, uxMode: UX_MODE.REDIRECT, manualSync: true, email: defaultTestEmail },
+];
+
+const checkLogin = async (coreKitInstance: Web3AuthMPCCoreKit, accountIndex = 0) => {
+  const keyDetails = coreKitInstance.getKeyDetails();
+  assert.strictEqual(coreKitInstance.status, COREKIT_STATUS.LOGGED_IN);
+  assert.strictEqual(keyDetails.requiredFactors, 0);
+  const factorkey = coreKitInstance.getCurrentFactorKey();
+  await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"), {
+    accountIndex,
+  });
+};
+
+const storageInstance = new MemoryStorage();
+
+variable.forEach((testVariable) => {
+  const { web3AuthNetwork, uxMode, manualSync, email } = testVariable;
+  const newCoreKitInstance = () =>
+    new Web3AuthMPCCoreKit({
+      web3AuthClientId: "torus-key-test",
+      web3AuthNetwork,
+      baseUrl: "http://localhost:3000",
+      uxMode,
+      tssLib,
+      storage: storageInstance,
+      manualSync,
+    });
+
+  async function resetAccount() {
+    const resetInstance = newCoreKitInstance();
+    const { idToken, parsedToken } = await mockLogin(email);
+    await resetInstance.init({ handleRedirectResult: false, rehydrate: false });
+    await resetInstance.loginWithJWT({
+      verifier: "torus-test-health",
+      verifierId: parsedToken.email,
+      idToken,
+    });
+    await criticalResetAccount(resetInstance);
+    await new AsyncStorage(resetInstance._storageKey, storageInstance).resetStore();
+  }
+
+  const testNameSuffix = JSON.stringify(testVariable);
+
+  let checkPubKey: EllipticPoint;
+  let checkTssShare: BN;
+
+  test(`#Login Test with JWT + logout:  ${testNameSuffix}`, async (t) => {
+    await resetAccount();
+    await t.test("#Login", async function () {
+      const coreKitInstance = newCoreKitInstance();
+
+      // mocklogin
+      const { idToken, parsedToken } = await mockLogin(email);
+      await coreKitInstance.init({ handleRedirectResult: false });
+      await coreKitInstance.loginWithJWT({
+        verifier: "torus-test-health",
+        verifierId: parsedToken.email,
+        idToken,
+      });
+      // get key details
+      await checkLogin(coreKitInstance);
+
+      checkPubKey = bufferToElliptic(coreKitInstance.getPubKey(), coreKitInstance.tKey.tssCurve);
+      const factorkey = coreKitInstance.getCurrentFactorKey();
+      const { tssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"), {
+        threshold: 0,
+      });
+      checkTssShare = tssShare;
+
+      if (manualSync) {
+        await coreKitInstance.commitChanges();
+      }
+      // check whether the public key and tss share is same as old sdks
+    });
+
+    await t.test("#relogin ", async function () {
+      const coreKitInstance = newCoreKitInstance();
+      // rehydrate
+      await coreKitInstance.init({ handleRedirectResult: false });
+      await checkLogin(coreKitInstance);
+
+      // logout
+      await coreKitInstance.logout();
+
+      // rehydrate should fail
+      await coreKitInstance.init({
+        rehydrate: false,
+        handleRedirectResult: false,
+      });
+      assert.strictEqual(coreKitInstance.status, COREKIT_STATUS.INITIALIZED);
+      assert.throws(() => coreKitInstance.getCurrentFactorKey());
+
+      // relogin
+      const { idToken, parsedToken } = await mockLogin(email);
+      await coreKitInstance.loginWithJWT({
+        verifier: "torus-test-health",
+        verifierId: parsedToken.email,
+        idToken,
+      });
+
+      // get key details
+      await checkLogin(coreKitInstance);
+      const newPubKey = bufferToElliptic(coreKitInstance.getPubKey(), coreKitInstance.tKey.tssCurve);
+      const factorkey = coreKitInstance.getCurrentFactorKey();
+      const { tssShare: newTssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"));
+      assert(checkPubKey.eq(newPubKey));
+      assert(checkTssShare.eq(newTssShare));
+    });
+
+    await t.test("#able to sign", async function () {
+      const coreKitInstance = newCoreKitInstance();
+      await coreKitInstance.init({ handleRedirectResult: false, rehydrate: false });
+      const localToken = await mockLogin2(email);
+      await coreKitInstance.loginWithJWT({
+        verifier: "torus-test-health",
+        verifierId: email,
+        idToken: localToken.idToken,
+      });
+      const msg = "hello world";
+      const msgBuffer = Buffer.from(msg);
+
+      const signature = await coreKitInstance.sign(msgBuffer);
+      const pk = coreKitInstance.getPubKeyBip340();
+      const valid = bip340.verify(signature, msgBuffer, pk);
+      assert(valid);
+    });
+  });
+});

tests/bip340.spec.ts

@@ -4,14 +4,14 @@ import test from "node:test";
 import { tssLib as tssLibDKLS } from "@toruslabs/tss-dkls-lib";
 import { tssLib as tssLibFROST } from "@toruslabs/tss-frost-lib";
 
-import { AsyncStorage, MemoryStorage, TssLib, TssShareType, WEB3AUTH_NETWORK } from "../src";
+import { AsyncStorage, MemoryStorage, TssLibType, TssShareType, WEB3AUTH_NETWORK } from "../src";
 import { bufferToElliptic, criticalResetAccount, newCoreKitLogInInstance } from "./setup";
 
 type ImportKeyTestVariable = {
   manualSync?: boolean;
   email: string;
   importKeyEmail: string;
-  tssLib: TssLib;
+  tssLib: TssLibType;
 };
 
 const storageInstance = new MemoryStorage();

tests/importRecovery.spec.ts

@@ -4,7 +4,7 @@ import BN from "bn.js";
 import jwt, { Algorithm } from "jsonwebtoken";
 import { tssLib as tssLibDKLS } from "@toruslabs/tss-dkls-lib";
 
-import { IAsyncStorage, IStorage, parseToken, TssLib, WEB3AUTH_NETWORK_TYPE, Web3AuthMPCCoreKit } from "../src";
+import { IAsyncStorage, IStorage, parseToken, TssLibType, WEB3AUTH_NETWORK_TYPE, Web3AuthMPCCoreKit } from "../src";
 
 export const mockLogin2 = async (email: string) => {
   const req = new Request("https://li6lnimoyrwgn2iuqtgdwlrwvq0upwtr.lambda-url.eu-west-1.on.aws/", {
@@ -97,7 +97,7 @@ export const newCoreKitLogInInstance = async ({
   manualSync: boolean;
   email: string;
   storageInstance: IStorage | IAsyncStorage;
-  tssLib?: TssLib;
+  tssLib?: TssLibType;
   importTssKey?: string;
   login?: LoginFunc;
 }) => {