fix: rename signECDSA function name

fix multicurve test to use new storage instance
fix useClientGeneratedTSSKey bug

Author: ieow

src/interfaces.ts

@@ -486,7 +486,7 @@ export interface ICoreKit {
    * - hashed: The data is already hashed. Do not hash again. Only works for ecdsa-secp256k1.
    * - secp256k1Precompute: Provide a precomputed client for faster signing. Only works for ecdsa-secp256k1.
    */
-  signECDSA(
+  sign_ECDSA_secp256k1(
     data: Buffer,
     opts?: {
       hashed?: boolean;

src/mpcCoreKit.ts

@@ -890,7 +890,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     };
   }
 
-  public async signECDSA(data: Uint8Array, opts?: { hashed?: boolean; secp256k1Precompute?: Secp256k1PrecomputedClient }) {
+  public async sign_ECDSA_secp256k1(data: Uint8Array, opts?: { hashed?: boolean; secp256k1Precompute?: Secp256k1PrecomputedClient }) {
     if (!this.supportedCurveKeyTypes.has(KeyType.secp256k1)) {
       throw CoreKitError.default(`secp256k1 KeyTYpe is not supported, please configure secp256k1 curve key type `);
     }
@@ -899,8 +899,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     }
     const { hashed = false, secp256k1Precompute } = opts || {};
 
-    // TODO: replace buffer to uint8array
-    const sig = await this.sign_ECDSA_secp256k1(Buffer.from(data), hashed, secp256k1Precompute);
+    const sig = await this._sign_ECDSA_secp256k1(Buffer.from(data), hashed, secp256k1Precompute);
     return Buffer.concat([sig.r, sig.s, Buffer.from([sig.v])]);
   }
 
@@ -946,7 +945,6 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
   }
 
   // mutation function
-
   async deleteFactor(factorPub: Point, factorKey?: BNString): Promise<void> {
     if (!this.state.factorKey) {
       throw CoreKitError.factorKeyNotPresent("factorKey not present in state when deleting a factor.");
@@ -1177,9 +1175,11 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
           if (keyType === KeyType.ed25519) {
             const k = generateEd25519Seed();
             importKey.ed25519 = k.toString("hex");
-          } else if (keyType === KeyType.secp256k1 && !!this.options.useClientGeneratedTSSKey) {
-            const k = secp256k1.genKeyPair().getPrivate();
-            importKey.secp256k1 = scalarBNToBufferSEC1(k).toString("hex");
+          } else if (keyType === KeyType.secp256k1) {
+            if (this.options.useClientGeneratedTSSKey) {
+              const k = secp256k1.genKeyPair().getPrivate();
+              importKey.secp256k1 = scalarBNToBufferSEC1(k).toString("hex");
+            }
           } else {
             throw CoreKitError.default(`Unsupported key type and sig type combination `);
           }
@@ -1648,7 +1648,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     return this.tkey.computeAccountNonce(this.state.accountIndex);
   }
 
-  private async sign_ECDSA_secp256k1(data: Buffer, hashed: boolean = false, precomputedTssClient?: Secp256k1PrecomputedClient) {
+  private async _sign_ECDSA_secp256k1(data: Buffer, hashed: boolean = false, precomputedTssClient?: Secp256k1PrecomputedClient) {
     const executeSign = async (client: Client, serverCoeffs: Record<string, string>, hashedData: Buffer, signatures: string[]) => {
       const { r, s, recoveryParam } = await client.sign(hashedData.toString("base64"), true, "", "keccak256", {
         signatures,

src/utils.ts

@@ -202,7 +202,7 @@ export function makeEthereumSigner(kit: Web3AuthMPCCoreKit): EthereumSigner {
   }
   return {
     sign: async (msgHash: Buffer) => {
-      const sig = await kit.signECDSA(msgHash, { hashed: true });
+      const sig = await kit.sign_ECDSA_secp256k1(msgHash, { hashed: true });
       return sigToRSV(sig);
     },
     getPublic: async () => {

tests/backwardCompatible.spec.ts

@@ -122,7 +122,7 @@ variable.forEach((testVariable) => {
       const msg = "hello world";
       const msgBuffer = Buffer.from(msg);
       const msgHash = keccak256(msgBuffer);
-      const signature = sigToRSV(await coreKitInstance.signECDSA(msgHash, { hashed: true } ));
+      const signature = sigToRSV(await coreKitInstance.sign_ECDSA_secp256k1(msgHash, { hashed: true } ));
 
       const secp256k1 = new EC("secp256k1");
       const pubkey = secp256k1.recoverPubKey(msgHash, signature, signature.v) as EllipticPoint;

tests/login.spec.ts

@@ -156,13 +156,13 @@ variable.forEach((testVariable) => {
       const secp256k1 = new EC("secp256k1");
 
       // Sign hash.
-      const signature = sigToRSV(await coreKitInstance.signECDSA(msgHash, { hashed: true }));
+      const signature = sigToRSV(await coreKitInstance.sign_ECDSA_secp256k1(msgHash, { hashed: true }));
       const pubkey = secp256k1.recoverPubKey(msgHash, signature, signature.v) as EllipticPoint;
       const publicKeyPoint = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       assert(pubkey.eq(publicKeyPoint));
 
       // Sign full message.
-      const signature2 = sigToRSV(await coreKitInstance.signECDSA(msgBuffer));
+      const signature2 = sigToRSV(await coreKitInstance.sign_ECDSA_secp256k1(msgBuffer));
       const pubkey2 = secp256k1.recoverPubKey(msgHash, signature2, signature2.v) as EllipticPoint;
       assert(pubkey2.eq(publicKeyPoint));
     });
@@ -186,7 +186,7 @@ variable.forEach((testVariable) => {
       const msg = "hello world 1";
       const msgBuffer = Buffer.from(msg);
       const msgHash = keccak256(msgBuffer);
-      const signature1 = sigToRSV(await coreKitInstance.signECDSA(msgHash, { hashed: true }));
+      const signature1 = sigToRSV(await coreKitInstance.sign_ECDSA_secp256k1(msgHash, { hashed: true }));
 
       const pubkeyIndex0 = secp256k1.recoverPubKey(msgHash, signature1, signature1.v);
       const publicKeyPoint0 = bufferToElliptic(coreKitInstance.getPubKey(keyType));
@@ -198,7 +198,7 @@ variable.forEach((testVariable) => {
       const msgBuffer1 = Buffer.from(msg1);
       const msgHash1 = keccak256(msgBuffer1);
 
-      const signature2 = sigToRSV(await coreKitInstance.signECDSA(msgHash1, { hashed: true }));
+      const signature2 = sigToRSV(await coreKitInstance.sign_ECDSA_secp256k1(msgHash1, { hashed: true }));
 
       const pubkeyIndex1 = secp256k1.recoverPubKey(msgHash1, signature2, signature2.v) as EllipticPoint;
       const publicKeyPoint1 = bufferToElliptic(coreKitInstance.getPubKey(keyType));
@@ -211,7 +211,7 @@ variable.forEach((testVariable) => {
       const msg2 = "hello world 3";
       const msgBuffer2 = Buffer.from(msg2);
       const msgHash2 = keccak256(msgBuffer2);
-      const signature3 = sigToRSV(await coreKitInstance.signECDSA(msgHash2, { hashed: true }));
+      const signature3 = sigToRSV(await coreKitInstance.sign_ECDSA_secp256k1(msgHash2, { hashed: true }));
 
       const pubkeyIndex2 = secp256k1.recoverPubKey(msgHash2, signature3, signature3.v) as EllipticPoint;
       const publicKeyPoint2 = bufferToElliptic(coreKitInstance.getPubKey(keyType));

tests/multiCurveTest.spec.ts

@@ -20,7 +20,6 @@ import { schnorr as bip340 } from '@noble/curves/secp256k1';
 
 const web3AuthNetwork = WEB3AUTH_NETWORK.DEVNET;
 const manualSync = false;
-const storageInstance = new MemoryStorage();
 const verifierId = "multicurvetest"
 
 const mockSL = new MockStorageLayer({
@@ -36,7 +35,7 @@ describe("multiCurveTest", () => {
           baseUrl: "http://localhost:3000",
           uxMode: "nodejs",
           supportedKeyTypes: [KeyType.secp256k1, KeyType.ed25519],
-          storage: storageInstance,
+          storage: new MemoryStorage(),
           manualSync,
         });
 
@@ -46,7 +45,7 @@ describe("multiCurveTest", () => {
 
         const hash = keccak_256(message);
         instance.addTssLibs([dklslib]);
-        const result = await instance.signECDSA(Buffer.from(hash), {hashed: true})
+        const result = await instance.sign_ECDSA_secp256k1(Buffer.from(hash), {hashed: true})
         const {r, s } = sigToRSV(result);
 
         const validsecp256k1 = secp256k1.verify({