diff --git a/demo/redirect-flow-example/package-lock.json b/demo/redirect-flow-example/package-lock.json
index ed42060..817aa92 100644
--- a/demo/redirect-flow-example/package-lock.json
+++ b/demo/redirect-flow-example/package-lock.json
@@ -8,7 +8,7 @@
       "name": "redirect-flow-example",
       "version": "0.1.0",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
+        "@tkey/common-types": "^15.2.1-alpha.0",
         "@toruslabs/torus.js": "15.2.0-alpha.0",
         "@toruslabs/tss-dkls-lib": "^5.0.0-alpha.0",
         "@toruslabs/tss-frost-lib": "^2.0.0-alpha.0",
@@ -21,7 +21,7 @@
         "@web3auth/base": "^9.0.2",
         "@web3auth/ethereum-mpc-provider": "^9.3.0",
         "@web3auth/mpc-core-kit": "file:../..",
-        "@web3auth/mpc-passkey-plugin": "0.1.15-alpha.0",
+        "@web3auth/mpc-passkey-plugin": "~0.1.15-alpha.0",
         "browserify-zlib": "^0.2.0",
         "copy-webpack-plugin": "^11.0.0",
         "html-webpack-plugin": "^5.5.3",
@@ -57,14 +57,14 @@
     },
     "../..": {
       "name": "@web3auth/mpc-core-kit",
-      "version": "4.1.6-alpha.0",
+      "version": "4.1.7-alpha.0",
       "license": "ISC",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
-        "@tkey/core": "^15.1.0",
+        "@tkey/common-types": "file:../tkey/packages/common-types",
+        "@tkey/core": "file:../tkey/packages/core/tkey-core-15.2.1-alpha.0.tgz",
         "@tkey/share-serialization": "^15.1.0",
-        "@tkey/storage-layer-torus": "^15.1.0",
-        "@tkey/tss": "^15.1.0",
+        "@tkey/storage-layer-torus": "file:../tkey/packages/storage-layer-torus/tkey-storage-layer-torus-15.2.1-alpha.0.tgz",
+        "@tkey/tss": "file:../tkey/packages/tss/tkey-tss-15.2.1-alpha.0.tgz",
         "@toruslabs/constants": "^14.2.0",
         "@toruslabs/customauth": "^20.3.0",
         "@toruslabs/elliptic-wrapper": "^0.1.1",
@@ -73,7 +73,7 @@
         "@toruslabs/metadata-helpers": "^6.0.0",
         "@toruslabs/openlogin-utils": "^8.2.1",
         "@toruslabs/session-manager": "^3.1.0",
-        "@toruslabs/torus.js": "15.2.0-alpha.0",
+        "@toruslabs/torus.js": "file:../torus.js/toruslabs-torus.js-15.1.1.tgz",
         "@toruslabs/tss-client": "^3.3.0-alpha.0",
         "@toruslabs/tss-frost-client": "^1.0.1-alpha.0",
         "@toruslabs/tss-frost-common": "^1.0.2-alpha.0",
@@ -976,9 +976,9 @@
       "license": "MIT"
     },
     "node_modules/@tkey/common-types": {
-      "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/common-types/-/common-types-15.1.0.tgz",
-      "integrity": "sha512-oA5gLoyhNNMgCKcjvwLyU31TVS5KMT+lotRrjjoBdDvS0keZwzSLrtHWbXj8jZDlSZaqbd3VlPbCoHcqpk1irA==",
+      "version": "15.2.1-alpha.0",
+      "resolved": "https://registry.npmjs.org/@tkey/common-types/-/common-types-15.2.1-alpha.0.tgz",
+      "integrity": "sha512-0BXtkB2PHNtV+fCmTVhWRqz/0tc975/z2onqCDQyCn0Lk36uhAPbEwCPRJ4vrccICxVizuYagZ+CazaEjk/ICA==",
       "license": "MIT",
       "dependencies": {
         "@toruslabs/customauth": "^20.3.0",
diff --git a/demo/redirect-flow-example/package.json b/demo/redirect-flow-example/package.json
index 098bf77..b8133db 100644
--- a/demo/redirect-flow-example/package.json
+++ b/demo/redirect-flow-example/package.json
@@ -3,7 +3,7 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
-    "@tkey/common-types": "^15.1.0",
+    "@tkey/common-types": "^15.2.1-alpha.0",
     "@toruslabs/torus.js": "15.2.0-alpha.0",
     "@toruslabs/tss-dkls-lib": "^5.0.0-alpha.0",
     "@toruslabs/tss-frost-lib": "^2.0.0-alpha.0",
@@ -16,7 +16,7 @@
     "@web3auth/base": "^9.0.2",
     "@web3auth/ethereum-mpc-provider": "^9.3.0",
     "@web3auth/mpc-core-kit": "file:../..",
-    "@web3auth/mpc-passkey-plugin": "0.1.15-alpha.0",
+    "@web3auth/mpc-passkey-plugin": "~0.1.15-alpha.0",
     "browserify-zlib": "^0.2.0",
     "copy-webpack-plugin": "^11.0.0",
     "html-webpack-plugin": "^5.5.3",
diff --git a/demo/redirect-flow-example/src/App.tsx b/demo/redirect-flow-example/src/App.tsx
index e6a6fb1..e3d5747 100644
--- a/demo/redirect-flow-example/src/App.tsx
+++ b/demo/redirect-flow-example/src/App.tsx
@@ -104,7 +104,7 @@ function App() {
         uxMode: "redirect",
         manualSync: true,
         storage: window.localStorage,
-        tssLib: selectedTssLib,
+        supportedKeyTypes: [KeyType.secp256k1, KeyType.ed25519],
         useDKG: false,
       })
   );
@@ -118,7 +118,7 @@ function App() {
     // )
   )
   async function setupProvider(chainConfig?: CustomChainConfig) {
-    if (coreKitInstance.current.keyType !== KeyType.secp256k1) {
+    if (!coreKitInstance.current.getSupportedCurveKeyTypes().includes(KeyType.ed25519)) {
       console.warn(`Ethereum requires keytype ${KeyType.secp256k1}, skipping provider setup`);
       return;
     }
@@ -175,7 +175,7 @@ function App() {
       uxMode: "redirect",
       manualSync: false,
       storage: window.localStorage,
-      tssLib: selectedTssLib,
+      supportedKeyTypes: [KeyType.ed25519, KeyType.secp256k1],
       useDKG: false,
     })
  
@@ -205,14 +205,11 @@ function App() {
     if (!coreKitInstance) {
       throw new Error("coreKitInstance not found");
     }
-    const factorPubs = coreKitInstance.current.tKey.metadata.factorPubs;
-    if (!factorPubs) {
+    const factorPubs = coreKitInstance.current.getTssFactorPub();
+    if (!factorPubs || factorPubs.length === 0) {
       throw new Error("factorPubs not found");
     }
-    const pubsHex = factorPubs[coreKitInstance.current.tKey.tssTag].map(pub => {
-      return pub.toSEC1(factorKeyCurve, true).toString("hex");
-    });
-    uiConsole(pubsHex);
+    uiConsole(factorPubs);
   };
 
   const loginWithMock = async () => {
@@ -406,64 +403,85 @@ function App() {
     return balance;
   };
 
-  const signMessage = async (): Promise<any> => {
-    if (coreKitInstance.current.sigType === SIG_TYPE.ECDSA_SECP256K1) {
-      if (!web3) {
-        uiConsole("web3 not initialized yet");
-        return;
-      }
-      const fromAddress = (await web3.eth.getAccounts())[0];
-      const message = "hello";
-      const signedMessage = await web3.eth.personal.sign(message, fromAddress, "");
-      
 
-      uiConsole(signedMessage);
-    } else if (coreKitInstance.current.sigType === SIG_TYPE.ED25519 || coreKitInstance.current.sigType === SIG_TYPE.BIP340) {
-      const msg = Buffer.from("hello signer!");
-      const sig = await coreKitInstance.current.sign(msg);
-      uiConsole(sig.toString("hex"));
+  const signMessageEd25519 = async (): Promise<any> => {
+   
+    if (!coreKitInstance.current.getSupportedSigTypes().includes(SIG_TYPE.ED25519)) {
+      coreKitInstance.current.addTssLibs([tssLibFrost]);
+    } 
+    const msg = Buffer.from("hello signer!");
+    const sig = await coreKitInstance.current.signED25519(msg);
+    uiConsole(sig.toString("hex"));
+  }
+
+  const signMessage = async (): Promise<any> => {
+    if (!web3) {
+      uiConsole("web3 not initialized yet");
+      return;
     }
+    if (!coreKitInstance.current.getSupportedSigTypes().includes(SIG_TYPE.ECDSA_SECP256K1)) {
+      coreKitInstance.current.addTssLibs([tssLibDkls]);
+    }
+    const fromAddress = (await web3.eth.getAccounts())[0];
+    const message = "hello";
+    const signedMessage = await web3.eth.personal.sign(message, fromAddress, "");
+    uiConsole(signedMessage);
   };
 
   const signWithKeyTweak = async (): Promise<any> => {
-    if (coreKitInstance.current.sigType === SIG_TYPE.ECDSA_SECP256K1) {
-      throw new Error("Not supported for this signature type");
-    } else if (coreKitInstance.current.sigType === SIG_TYPE.ED25519 || coreKitInstance.current.sigType === SIG_TYPE.BIP340) {
-      const msg = Buffer.from("hello signer!");
-      const keyTweak = (() => {
-        const ec = new EC(coreKitInstance.current.keyType);
-        return ec.genKeyPair().getPrivate();
-      })();
-      const sig = await coreKitInstance.current.sign(msg, { keyTweak });
-      uiConsole(sig.toString("hex"));
+    if (!coreKitInstance.current.getSupportedCurveKeyTypes().includes(KeyType.secp256k1) ) {
+      throw new Error("Not supported for this curve type");
     }
+    
+    if (!coreKitInstance.current.getSupportedSigTypes().includes(SIG_TYPE.BIP340)) {
+      coreKitInstance.current.addTssLibs([tssLibFrostBip340])
+    }
+    
+    const msg = Buffer.from("hello signer!");
+    const keyTweak = (() => {
+      const ec = new EC(KeyType.secp256k1);
+      return ec.genKeyPair().getPrivate();
+    })();
+    const sig = await coreKitInstance.current.signBIP340(msg );
+    uiConsole(sig.toString("hex"));
   };
 
   const signMessageWithPrecomputedTss = async (): Promise<any> => {
-    if (coreKitInstance.current.keyType === "secp256k1") {
-      const precomputedTssClient = await coreKitInstance.current.precompute_secp256k1();
-      const msg = Buffer.from("hello signer!");
-      const sig = await coreKitInstance.current.sign(msg, { secp256k1Precompute: precomputedTssClient });
-      uiConsole(sig.toString("hex"));
-    } else {
-      throw new Error("Not supported for this key type");
+
+    if (!coreKitInstance.current.getSupportedCurveKeyTypes().includes(KeyType.secp256k1) ) {
+      throw new Error("Not supported for this curve type");
     }
+    if (!coreKitInstance.current.getSupportedSigTypes().includes(SIG_TYPE.ECDSA_SECP256K1)) {
+      coreKitInstance.current.addTssLibs([tssLibDkls])
+    }
+
+    const precomputedTssClient = await coreKitInstance.current.precompute_secp256k1();
+    const msg = Buffer.from("hello signer!");
+    const sig = await coreKitInstance.current.sign_ECDSA_secp256k1(msg, { secp256k1Precompute: precomputedTssClient });
+    uiConsole(sig.toString("hex"));
   };
 
   const signMultipleMessagesWithPrecomputedTss = async (): Promise<any> => {
-    if (coreKitInstance.current.keyType === "secp256k1") {
-      const [precomputedTssClient, precomputedTssClient2] = await Promise.all([coreKitInstance.current.precompute_secp256k1(), coreKitInstance.current.precompute_secp256k1()]);
 
-      const msg = Buffer.from("hello signer!");
-      const sig = await coreKitInstance.current.sign(msg, { secp256k1Precompute: precomputedTssClient });
-      const msg2 = Buffer.from("hello signer2!");
-
-      const sig2 = await coreKitInstance.current.sign(msg2, { secp256k1Precompute: precomputedTssClient2 });
-      uiConsole("Sig1: ", sig.toString("hex"), "Sig2: ", sig2.toString("hex"));
-    } else {
-      throw new Error("Not supported for this key type");
+    if (!coreKitInstance.current.getSupportedCurveKeyTypes().includes(KeyType.secp256k1) ) {
+      throw new Error("Not supported for this curve type");
+    }
+    if (!coreKitInstance.current.getSupportedSigTypes().includes(SIG_TYPE.ECDSA_SECP256K1)) {
+      coreKitInstance.current.addTssLibs([tssLibDkls])
     }
+
+    const [precomputedTssClient, precomputedTssClient2] = await Promise.all([coreKitInstance.current.precompute_secp256k1(), coreKitInstance.current.precompute_secp256k1()]);
+
+    const msg = Buffer.from("hello signer!");
+    const sig = await coreKitInstance.current.sign_ECDSA_secp256k1(msg, { secp256k1Precompute: precomputedTssClient });
+    const msg2 = Buffer.from("hello signer2!");
+
+    const sig2 = await coreKitInstance.current.sign_ECDSA_secp256k1(msg2, { secp256k1Precompute: precomputedTssClient2 });
+    uiConsole("Sig1: ", sig.toString("hex"), "Sig2: ", sig2.toString("hex"));
+
   };
+
+
   const switchChainSepolia = async () => {
     if (!provider) {
       uiConsole("provider not initialized yet");
@@ -705,32 +723,6 @@ function App() {
     await coreKitInstance.current.commitChanges();
   };
 
-  const tssLibSelector = (
-    <div className="flex-container">
-      <label>TSS Library:</label>
-      <select 
-        value={selectedTssLib === tssLibDkls ? "dkls" : selectedTssLib === tssLibFrost ? "frost" : "frostBip340"} 
-        onChange={(e) => {
-          switch(e.target.value) {
-            case "dkls":
-              setSelectedTssLib(tssLibDkls);
-              break;
-            case "frost":
-              setSelectedTssLib(tssLibFrost);
-              break;
-            case "frostBip340":
-              setSelectedTssLib(tssLibFrostBip340);
-              break;
-          }
-        }}
-      >
-        <option value="dkls">DKLS</option>
-        <option value="frost">FROST</option>
-        <option value="frostBip340">FROST BIP340</option>
-      </select>
-    </div>
-  );
-
   const loggedInView = (
     <>
       <h2 className="subtitle">Account Details</h2>
@@ -739,8 +731,12 @@ function App() {
           Get User Info
         </button>
 
-        <button onClick={async () => uiConsole(await coreKitInstance.current.getPubKey())} className="card">
-          Get Public Key
+        <button onClick={async () => uiConsole(await coreKitInstance.current.getPubKey(KeyType.secp256k1))} className="card">
+          Get Public Key Secp256k1
+        </button>
+
+        <button onClick={async () => uiConsole(await coreKitInstance.current.getPubKey(KeyType.ed25519))} className="card">
+          Get Public Key Ed25519
         </button>
 
         <button onClick={keyDetails} className="card">
@@ -760,10 +756,18 @@ function App() {
           [CRITICAL] Reset Account
         </button>
 
-        <button onClick={async () => uiConsole(await coreKitInstance.current._UNSAFE_exportTssKey())} className="card">
-          [CAUTION] Export TSS Private Key
+        <button onClick={async () => uiConsole(await coreKitInstance.current._UNSAFE_exportTssKey(KeyType.secp256k1))} className="card">
+          [CAUTION] Export TSS Private Key Secp256k1
+        </button>
+
+        <button onClick={async () => uiConsole(await coreKitInstance.current._UNSAFE_exportTssKey(KeyType.ed25519))} className="card">
+          [CAUTION] Export TSS Private Key Ed25519
         </button>
 
+        <button onClick={async () => uiConsole(await coreKitInstance.current._UNSAFE_exportTssEd25519Seed())} className="card">
+          [CAUTION] Export Ed25519 seed 
+        </button> 
+
         <button onClick={logout} className="card">
           Log Out
         </button>
@@ -872,6 +876,10 @@ function App() {
           Get Balance
         </button>
 
+        <button onClick={signMessageEd25519} className="card">
+          Sign Message Ed25519
+        </button>
+
         <button onClick={signMessage} className="card">
           Sign Message
         </button>
@@ -909,7 +917,6 @@ function App() {
 
   const unloggedInView = (
     <>
-      {tssLibSelector}
       <input value={mockEmail} onChange={(e) => setMockEmail(e.target.value)}></input>
       <button onClick={() => loginWithMock()} className="card">
         MockLogin
diff --git a/package-lock.json b/package-lock.json
index d2fa201..0c683be 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,11 +9,11 @@
       "version": "4.1.7-alpha.0",
       "license": "ISC",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
-        "@tkey/core": "^15.1.0",
+        "@tkey/common-types": "file:../tkey/packages/common-types",
+        "@tkey/core": "file:../tkey/packages/core/tkey-core-15.2.1-alpha.0.tgz",
         "@tkey/share-serialization": "^15.1.0",
-        "@tkey/storage-layer-torus": "^15.1.0",
-        "@tkey/tss": "^15.1.0",
+        "@tkey/storage-layer-torus": "file:../tkey/packages/storage-layer-torus/tkey-storage-layer-torus-15.2.1-alpha.0.tgz",
+        "@tkey/tss": "file:../tkey/packages/tss/tkey-tss-15.2.1-alpha.0.tgz",
         "@toruslabs/constants": "^14.2.0",
         "@toruslabs/customauth": "^20.3.0",
         "@toruslabs/elliptic-wrapper": "^0.1.1",
@@ -22,7 +22,7 @@
         "@toruslabs/metadata-helpers": "^6.0.0",
         "@toruslabs/openlogin-utils": "^8.2.1",
         "@toruslabs/session-manager": "^3.1.0",
-        "@toruslabs/torus.js": "15.2.0-alpha.0",
+        "@toruslabs/torus.js": "file:../torus.js/toruslabs-torus.js-15.1.1.tgz",
         "@toruslabs/tss-client": "^3.3.0-alpha.0",
         "@toruslabs/tss-frost-client": "^1.0.1-alpha.0",
         "@toruslabs/tss-frost-common": "^1.0.2-alpha.0",
@@ -84,6 +84,30 @@
         }
       }
     },
+    "../tkey/packages/common-types": {
+      "name": "@tkey/common-types",
+      "version": "15.2.1-alpha.0",
+      "license": "MIT",
+      "dependencies": {
+        "@toruslabs/customauth": "^20.3.0",
+        "@toruslabs/eccrypto": "^5.0.4",
+        "@toruslabs/torus.js": "^15.1.0",
+        "bn.js": "^5.2.1",
+        "elliptic": "^6.5.5",
+        "ts-custom-error": "^3.3.1"
+      },
+      "devDependencies": {
+        "@types/bn.js": "^5.1.5",
+        "@types/elliptic": "^6.4.18"
+      },
+      "engines": {
+        "node": ">=18.x",
+        "npm": ">=9.x"
+      },
+      "peerDependencies": {
+        "@babel/runtime": "7.x"
+      }
+    },
     "node_modules/@ampproject/remapping": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
@@ -3754,57 +3778,16 @@
       }
     },
     "node_modules/@tkey/common-types": {
-      "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/common-types/-/common-types-15.1.0.tgz",
-      "integrity": "sha512-oA5gLoyhNNMgCKcjvwLyU31TVS5KMT+lotRrjjoBdDvS0keZwzSLrtHWbXj8jZDlSZaqbd3VlPbCoHcqpk1irA==",
-      "license": "MIT",
-      "dependencies": {
-        "@toruslabs/customauth": "^20.3.0",
-        "@toruslabs/eccrypto": "^5.0.4",
-        "@toruslabs/torus.js": "^15.1.0",
-        "bn.js": "^5.2.1",
-        "elliptic": "^6.5.5",
-        "ts-custom-error": "^3.3.1"
-      },
-      "engines": {
-        "node": ">=18.x",
-        "npm": ">=9.x"
-      },
-      "peerDependencies": {
-        "@babel/runtime": "7.x"
-      }
-    },
-    "node_modules/@tkey/common-types/node_modules/@toruslabs/torus.js": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@toruslabs/torus.js/-/torus.js-15.1.1.tgz",
-      "integrity": "sha512-sLaXA1/R8KTTjU4t+teL3PPaJr2+j01QLYn5IY/t5uTD+1G2nzzfVWpkMDYrk9EfQYw0u4aKJ1lT7j9uKafMlg==",
-      "license": "MIT",
-      "dependencies": {
-        "@toruslabs/bs58": "^1.0.0",
-        "@toruslabs/constants": "^14.0.0",
-        "@toruslabs/eccrypto": "^5.0.4",
-        "@toruslabs/http-helpers": "^7.0.0",
-        "bn.js": "^5.2.1",
-        "elliptic": "^6.5.7",
-        "ethereum-cryptography": "^2.2.1",
-        "json-stable-stringify": "^1.1.1",
-        "loglevel": "^1.9.2"
-      },
-      "engines": {
-        "node": ">=18.x",
-        "npm": ">=9.x"
-      },
-      "peerDependencies": {
-        "@babel/runtime": "7.x"
-      }
+      "resolved": "../tkey/packages/common-types",
+      "link": true
     },
     "node_modules/@tkey/core": {
-      "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/core/-/core-15.1.0.tgz",
-      "integrity": "sha512-JaFprczHR8fBEw1LrwKs87ASgpZagxQ9VZ6lAfAAI8jEh1yhz8djh9l2wzJbaFuLEOQskh7GoxpKfgB+YtBSmw==",
+      "version": "15.2.1-alpha.0",
+      "resolved": "file:../tkey/packages/core/tkey-core-15.2.1-alpha.0.tgz",
+      "integrity": "sha512-/tgonNX4/fCQXB3vlqrOOQQdVIFZ02RWRpbd2NkJB0Vjc3kuoZsuz90ZTIfCJU9mszUUDVUxhUD5GHIZdLclnw==",
       "license": "MIT",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
+        "@tkey/common-types": "^15.2.1-alpha.0",
         "@toruslabs/eccrypto": "^5.0.4",
         "@toruslabs/http-helpers": "^7.0.0",
         "@toruslabs/torus.js": "^15.1.0",
@@ -3821,37 +3804,13 @@
         "@babel/runtime": "7.x"
       }
     },
-    "node_modules/@tkey/core/node_modules/@toruslabs/torus.js": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@toruslabs/torus.js/-/torus.js-15.1.1.tgz",
-      "integrity": "sha512-sLaXA1/R8KTTjU4t+teL3PPaJr2+j01QLYn5IY/t5uTD+1G2nzzfVWpkMDYrk9EfQYw0u4aKJ1lT7j9uKafMlg==",
-      "license": "MIT",
-      "dependencies": {
-        "@toruslabs/bs58": "^1.0.0",
-        "@toruslabs/constants": "^14.0.0",
-        "@toruslabs/eccrypto": "^5.0.4",
-        "@toruslabs/http-helpers": "^7.0.0",
-        "bn.js": "^5.2.1",
-        "elliptic": "^6.5.7",
-        "ethereum-cryptography": "^2.2.1",
-        "json-stable-stringify": "^1.1.1",
-        "loglevel": "^1.9.2"
-      },
-      "engines": {
-        "node": ">=18.x",
-        "npm": ">=9.x"
-      },
-      "peerDependencies": {
-        "@babel/runtime": "7.x"
-      }
-    },
     "node_modules/@tkey/service-provider-base": {
-      "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/service-provider-base/-/service-provider-base-15.1.0.tgz",
-      "integrity": "sha512-MruUxiWwyRczZ8KlhhGJ2TQ/p+VFPMOQZ089B5SIi7UsTOBMlzRqJWP3lM2fBSyQsfJCzpzXkj9a29ecpRZe0g==",
+      "version": "15.2.1-alpha.0",
+      "resolved": "https://registry.npmjs.org/@tkey/service-provider-base/-/service-provider-base-15.2.1-alpha.0.tgz",
+      "integrity": "sha512-8CTHuAoglCfDhxk3U0VkWJTl6XcL5UXIQAjtRTo/fbFClsHZ1lfQREXe24m+185XwBsZySrgE+UpL/Qvrq9vow==",
       "license": "MIT",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
+        "@tkey/common-types": "^15.2.1-alpha.0",
         "bn.js": "^5.2.1",
         "elliptic": "^6.5.5"
       },
@@ -3864,13 +3823,13 @@
       }
     },
     "node_modules/@tkey/service-provider-torus": {
-      "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/service-provider-torus/-/service-provider-torus-15.1.0.tgz",
-      "integrity": "sha512-7tA/1ALPo4ToXvwTwMj9OF0wh97S3p1sCeilwRcfyxBMJGpaDW8MSbiAbPqaSkK/DT3AFxlkHwAXWYYZ4+ZueQ==",
+      "version": "15.2.1-alpha.0",
+      "resolved": "https://registry.npmjs.org/@tkey/service-provider-torus/-/service-provider-torus-15.2.1-alpha.0.tgz",
+      "integrity": "sha512-ZkVaZvf0S+wrjN7nVAwq87+X02XJSCal2aCEYoRtoYQAcqp0wgTMPzBB6r4Jo1VyWIYbXS9zl6fZ90h1I86YVQ==",
       "license": "MIT",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
-        "@tkey/service-provider-base": "^15.1.0",
+        "@tkey/common-types": "^15.2.1-alpha.0",
+        "@tkey/service-provider-base": "^15.2.1-alpha.0",
         "@toruslabs/customauth": "^20.3.0",
         "@toruslabs/torus.js": "^15.1.0",
         "bn.js": "^5.2.1",
@@ -3884,21 +3843,15 @@
         "@babel/runtime": "7.x"
       }
     },
-    "node_modules/@tkey/service-provider-torus/node_modules/@toruslabs/torus.js": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@toruslabs/torus.js/-/torus.js-15.1.1.tgz",
-      "integrity": "sha512-sLaXA1/R8KTTjU4t+teL3PPaJr2+j01QLYn5IY/t5uTD+1G2nzzfVWpkMDYrk9EfQYw0u4aKJ1lT7j9uKafMlg==",
+    "node_modules/@tkey/share-serialization": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/@tkey/share-serialization/-/share-serialization-15.1.0.tgz",
+      "integrity": "sha512-n8jf6WDAWcWKFUr/nSnBURxX8vlXCQjJOfQUchiqvvUFlExeDqXqJq8I5icn2hjxKqANNcXVf1vKSvOCxPCAng==",
       "license": "MIT",
       "dependencies": {
-        "@toruslabs/bs58": "^1.0.0",
-        "@toruslabs/constants": "^14.0.0",
-        "@toruslabs/eccrypto": "^5.0.4",
-        "@toruslabs/http-helpers": "^7.0.0",
+        "@tkey/common-types": "^15.1.0",
         "bn.js": "^5.2.1",
-        "elliptic": "^6.5.7",
-        "ethereum-cryptography": "^2.2.1",
-        "json-stable-stringify": "^1.1.1",
-        "loglevel": "^1.9.2"
+        "ethereum-cryptography": "^2.2.1"
       },
       "engines": {
         "node": ">=18.x",
@@ -3908,15 +3861,18 @@
         "@babel/runtime": "7.x"
       }
     },
-    "node_modules/@tkey/share-serialization": {
+    "node_modules/@tkey/share-serialization/node_modules/@tkey/common-types": {
       "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/share-serialization/-/share-serialization-15.1.0.tgz",
-      "integrity": "sha512-n8jf6WDAWcWKFUr/nSnBURxX8vlXCQjJOfQUchiqvvUFlExeDqXqJq8I5icn2hjxKqANNcXVf1vKSvOCxPCAng==",
+      "resolved": "https://registry.npmjs.org/@tkey/common-types/-/common-types-15.1.0.tgz",
+      "integrity": "sha512-oA5gLoyhNNMgCKcjvwLyU31TVS5KMT+lotRrjjoBdDvS0keZwzSLrtHWbXj8jZDlSZaqbd3VlPbCoHcqpk1irA==",
       "license": "MIT",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
+        "@toruslabs/customauth": "^20.3.0",
+        "@toruslabs/eccrypto": "^5.0.4",
+        "@toruslabs/torus.js": "^15.1.0",
         "bn.js": "^5.2.1",
-        "ethereum-cryptography": "^2.2.1"
+        "elliptic": "^6.5.5",
+        "ts-custom-error": "^3.3.1"
       },
       "engines": {
         "node": ">=18.x",
@@ -3927,12 +3883,12 @@
       }
     },
     "node_modules/@tkey/storage-layer-torus": {
-      "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/storage-layer-torus/-/storage-layer-torus-15.1.0.tgz",
-      "integrity": "sha512-ZRk1FclOEomd7KAE3evKc/4Nk9I//RW20Bq2UrSPyKGf5YeTbDTaglAK0GrcG5CPtCpVLqh348Bw6hvGzjArag==",
+      "version": "15.2.1-alpha.0",
+      "resolved": "file:../tkey/packages/storage-layer-torus/tkey-storage-layer-torus-15.2.1-alpha.0.tgz",
+      "integrity": "sha512-5f3N6JoAFAqEGoEm/Qpuc5+ncxnXsuZMCCAjV4yokBJHVEbFLcYnW5LPWqbnWULavGMDHjnfpy49bBR/5UG3Uw==",
       "license": "MIT",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
+        "@tkey/common-types": "^15.2.1-alpha.0",
         "@toruslabs/http-helpers": "^7.0.0",
         "base64url": "3.0.1",
         "bn.js": "^5.2.1",
@@ -3948,47 +3904,24 @@
       }
     },
     "node_modules/@tkey/tss": {
-      "version": "15.1.0",
-      "resolved": "https://registry.npmjs.org/@tkey/tss/-/tss-15.1.0.tgz",
-      "integrity": "sha512-UcbJbWscIL83Zh1/i6M+X/xhN4EOimGV8JoWZ3D23Ji2pHPo8BgveUZA9i1DK4Y3YqqZ9aS8PvhSHt+KVnNluw==",
+      "version": "15.2.1-alpha.0",
+      "resolved": "file:../tkey/packages/tss/tkey-tss-15.2.1-alpha.0.tgz",
+      "integrity": "sha512-b2Egx54MuXt6+xZDc10HpoQ5TV60SYhUB5PuYWE2H6MlVy+TpmyCJ2WDf/DDzUex/ZwLSNY4Q0FwfG36SQehFQ==",
       "license": "ISC",
       "dependencies": {
-        "@tkey/common-types": "^15.1.0",
-        "@tkey/core": "^15.1.0",
-        "@tkey/service-provider-torus": "^15.1.0",
+        "@tkey/common-types": "^15.2.1-alpha.0",
+        "@tkey/core": "^15.2.1-alpha.0",
+        "@tkey/service-provider-torus": "^15.2.1-alpha.0",
         "@toruslabs/customauth": "^20.3.0",
+        "@toruslabs/http-helpers": "^7.0.0",
         "@toruslabs/rss-client": "^2.0.1",
-        "@toruslabs/torus.js": "^15.1.0",
+        "@toruslabs/torus.js": "file:../../../torus.js/toruslabs-torus.js-15.1.1.tgz",
         "@types/bn.js": "^5.1.5",
         "bn.js": "^5.2.1",
         "elliptic": "^6.5.5",
         "ethereum-cryptography": "^2.1.3"
       }
     },
-    "node_modules/@tkey/tss/node_modules/@toruslabs/torus.js": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@toruslabs/torus.js/-/torus.js-15.1.1.tgz",
-      "integrity": "sha512-sLaXA1/R8KTTjU4t+teL3PPaJr2+j01QLYn5IY/t5uTD+1G2nzzfVWpkMDYrk9EfQYw0u4aKJ1lT7j9uKafMlg==",
-      "license": "MIT",
-      "dependencies": {
-        "@toruslabs/bs58": "^1.0.0",
-        "@toruslabs/constants": "^14.0.0",
-        "@toruslabs/eccrypto": "^5.0.4",
-        "@toruslabs/http-helpers": "^7.0.0",
-        "bn.js": "^5.2.1",
-        "elliptic": "^6.5.7",
-        "ethereum-cryptography": "^2.2.1",
-        "json-stable-stringify": "^1.1.1",
-        "loglevel": "^1.9.2"
-      },
-      "engines": {
-        "node": ">=18.x",
-        "npm": ">=9.x"
-      },
-      "peerDependencies": {
-        "@babel/runtime": "7.x"
-      }
-    },
     "node_modules/@tootallnate/quickjs-emscripten": {
       "version": "0.23.0",
       "resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
@@ -4089,30 +4022,6 @@
         }
       }
     },
-    "node_modules/@toruslabs/customauth/node_modules/@toruslabs/torus.js": {
-      "version": "15.1.1",
-      "resolved": "https://registry.npmjs.org/@toruslabs/torus.js/-/torus.js-15.1.1.tgz",
-      "integrity": "sha512-sLaXA1/R8KTTjU4t+teL3PPaJr2+j01QLYn5IY/t5uTD+1G2nzzfVWpkMDYrk9EfQYw0u4aKJ1lT7j9uKafMlg==",
-      "license": "MIT",
-      "dependencies": {
-        "@toruslabs/bs58": "^1.0.0",
-        "@toruslabs/constants": "^14.0.0",
-        "@toruslabs/eccrypto": "^5.0.4",
-        "@toruslabs/http-helpers": "^7.0.0",
-        "bn.js": "^5.2.1",
-        "elliptic": "^6.5.7",
-        "ethereum-cryptography": "^2.2.1",
-        "json-stable-stringify": "^1.1.1",
-        "loglevel": "^1.9.2"
-      },
-      "engines": {
-        "node": ">=18.x",
-        "npm": ">=9.x"
-      },
-      "peerDependencies": {
-        "@babel/runtime": "7.x"
-      }
-    },
     "node_modules/@toruslabs/eccrypto": {
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/@toruslabs/eccrypto/-/eccrypto-5.0.4.tgz",
@@ -4515,16 +4424,15 @@
       }
     },
     "node_modules/@toruslabs/rss-client": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/@toruslabs/rss-client/-/rss-client-2.0.1.tgz",
-      "integrity": "sha512-EBqAX7LK8ZBy4fiGTGQhI3wVvLvfUyfwREbNkfAxP/iwevgCA2EKLXGWtVsvJj/wXF8HkfjqOcorVeHwP2vvWw==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/@toruslabs/rss-client/-/rss-client-2.0.2.tgz",
+      "integrity": "sha512-kmtl7KaxTOdrftxtv/hTzz6k2RJbVFq6oPs5Vg4u4iybdQYdRzyP1HqQ3wMu9ADhiItbZAg80VP4gOCCmjao4w==",
       "license": "MIT",
       "dependencies": {
         "@toruslabs/eccrypto": "^5.0.4",
         "@toruslabs/http-helpers": "^7.0.0",
         "bn.js": "^5.2.1",
         "elliptic": "^6.5.7",
-        "fetch": "^1.1.0",
         "loglevel": "^1.9.2"
       },
       "engines": {
@@ -4673,9 +4581,9 @@
       }
     },
     "node_modules/@toruslabs/torus.js": {
-      "version": "15.2.0-alpha.0",
-      "resolved": "https://registry.npmjs.org/@toruslabs/torus.js/-/torus.js-15.2.0-alpha.0.tgz",
-      "integrity": "sha512-W0HXmffYTbA9pFC3gdj6ON+FsmzJlSksT6hW5mDkRLZp1qSprYppjHnnnelq5n46yOs+290En8LP5s/U5viluw==",
+      "version": "15.1.1",
+      "resolved": "file:../torus.js/toruslabs-torus.js-15.1.1.tgz",
+      "integrity": "sha512-kkLuZ9vpmWZTklva+RQFKozDMCR2ydhR5WBn9bbgJBZqVP75FSzLZL0LQYrFqBPMgKgV22uOQ8quXW6T+Kko/g==",
       "license": "MIT",
       "dependencies": {
         "@toruslabs/bs58": "^1.0.0",
@@ -6236,18 +6144,6 @@
         "@noble/hashes": "^1.2.0"
       }
     },
-    "node_modules/biskviit": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/biskviit/-/biskviit-1.0.1.tgz",
-      "integrity": "sha512-VGCXdHbdbpEkFgtjkeoBN8vRlbj1ZRX2/mxhE8asCCRalUx2nBzOomLJv8Aw/nRt5+ccDb+tPKidg4XxcfGW4w==",
-      "license": "MIT",
-      "dependencies": {
-        "psl": "^1.1.7"
-      },
-      "engines": {
-        "node": ">=1.0.0"
-      }
-    },
     "node_modules/bl": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
@@ -7858,15 +7754,6 @@
         "typedarray-to-buffer": "3.1.5"
       }
     },
-    "node_modules/encoding": {
-      "version": "0.1.12",
-      "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz",
-      "integrity": "sha512-bl1LAgiQc4ZWr++pNYUdRe/alecaHFeHxIJ/pNciqGdKXghaTCOwKkbKp6ye7pKZGu/GcaSXFk8PBVhgs+dJdA==",
-      "license": "MIT",
-      "dependencies": {
-        "iconv-lite": "~0.4.13"
-      }
-    },
     "node_modules/end-of-stream": {
       "version": "1.4.4",
       "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
@@ -9138,16 +9025,6 @@
         "reusify": "^1.0.4"
       }
     },
-    "node_modules/fetch": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/fetch/-/fetch-1.1.0.tgz",
-      "integrity": "sha512-5O8TwrGzoNblBG/jtK4NFuZwNCkZX6s5GfRNOaGtm+QGJEuNakSC/i2RW0R93KX6E0jVjNXm6O3CRN4Ql3K+yA==",
-      "license": "MIT",
-      "dependencies": {
-        "biskviit": "1.0.1",
-        "encoding": "0.1.12"
-      }
-    },
     "node_modules/fetch-blob": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
@@ -10185,6 +10062,7 @@
       "version": "0.4.24",
       "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
       "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "safer-buffer": ">= 2.1.2 < 3"
@@ -13717,12 +13595,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/psl": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz",
-      "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==",
-      "license": "MIT"
-    },
     "node_modules/public-encrypt": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz",
@@ -14818,6 +14690,7 @@
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/schema-utils": {
diff --git a/package.json b/package.json
index 15a15e1..76b760b 100644
--- a/package.json
+++ b/package.json
@@ -47,11 +47,11 @@
     }
   },
   "dependencies": {
-    "@tkey/common-types": "^15.1.0",
-    "@tkey/core": "^15.1.0",
+    "@tkey/common-types": "file:../tkey/packages/common-types",
+    "@tkey/core": "file:../tkey/packages/core/tkey-core-15.2.1-alpha.0.tgz",
     "@tkey/share-serialization": "^15.1.0",
-    "@tkey/storage-layer-torus": "^15.1.0",
-    "@tkey/tss": "^15.1.0",
+    "@tkey/storage-layer-torus": "file:../tkey/packages/storage-layer-torus/tkey-storage-layer-torus-15.2.1-alpha.0.tgz",
+    "@tkey/tss": "file:../tkey/packages/tss/tkey-tss-15.2.1-alpha.0.tgz",
     "@toruslabs/constants": "^14.2.0",
     "@toruslabs/customauth": "^20.3.0",
     "@toruslabs/elliptic-wrapper": "^0.1.1",
@@ -59,8 +59,8 @@
     "@toruslabs/fnd-base": "^14.2.0",
     "@toruslabs/metadata-helpers": "^6.0.0",
     "@toruslabs/openlogin-utils": "^8.2.1",
-    "@toruslabs/torus.js": "15.2.0-alpha.0",
     "@toruslabs/session-manager": "^3.1.0",
+    "@toruslabs/torus.js": "file:../torus.js/toruslabs-torus.js-15.1.1.tgz",
     "@toruslabs/tss-client": "^3.3.0-alpha.0",
     "@toruslabs/tss-frost-client": "^1.0.1-alpha.0",
     "@toruslabs/tss-frost-common": "^1.0.2-alpha.0",
diff --git a/src/interfaces.ts b/src/interfaces.ts
index ccfb484..2b1173b 100644
--- a/src/interfaces.ts
+++ b/src/interfaces.ts
@@ -87,15 +87,16 @@ export type MPCKeyDetails = {
   requiredFactors: number;
   totalFactors: number;
   shareDescriptions: ShareDescriptionMap;
-  keyType: KeyType;
-  tssPubKey?: TkeyPoint;
+  supportedKeyType: KeyType[];
 };
 
 export type OAuthLoginParams = (SubVerifierDetailsParams | AggregateVerifierLoginParams) & {
   /**
    * Key to import key into Tss during first time login.
    */
-  importTssKey?: string;
+  importTssKey?: {
+    [K in KeyType]: string;
+  };
 
   /**
    * For new users, use SFA key if user was registered with SFA before.
@@ -161,7 +162,9 @@ export interface JWTLoginParams {
   /**
    * Key to import key into Tss during first time login.
    */
-  importTssKey?: string;
+  importTssKey?: {
+    [K in KeyType]?: string;
+  };
 
   /**
    * For new users, use SFA key if user was registered with SFA before.
@@ -183,7 +186,6 @@ export interface Web3AuthState {
   postboxKeyNodeIndexes?: number[];
   userInfo?: UserInfo;
   tssShareIndex?: number;
-  tssPubKey?: Buffer;
   accountIndex: number;
   factorKey?: BN;
 }
@@ -199,9 +201,9 @@ export interface Web3AuthOptions {
   web3AuthClientId: string;
 
   /**
-   * The threshold signing library to use.
+   * The supported curve key type.
    */
-  tssLib: TssLibType;
+  supportedKeyTypes: KeyType[];
 
   /**
    * @defaultValue `false`
@@ -333,6 +335,15 @@ export interface Web3AuthOptions {
    * only scalar will be exported, scalar can be used for signing outside of this sdk but not for importing the key in other wallets.
    */
   useClientGeneratedTSSKey?: boolean;
+
+  /**
+   * @defaultValue `false`
+   * Set this flag to true to use the legacy flag for signing
+   * legacy flag do not support multicurve mode
+   * legacy ed25519 customAuth is only supported in legacy mode
+   * Note: This option is set to false by default.
+   */
+  legacyFlag?: boolean;
 }
 export type Web3AuthOptionsWithDefaults = Required<Web3AuthOptions>;
 
@@ -345,7 +356,7 @@ export interface IMPCContext {
   updateState: (newState: Partial<Web3AuthState>) => void;
   getUserInfo: () => UserInfo;
   setupTkey: (params?: {
-    providedImportKey?: string;
+    providedImportKey?: { [key in KeyType]?: string };
     sfaLoginResponse?: TorusKey | TorusLoginResponse | TorusAggregateLoginResponse;
     userInfo?: UserInfo;
     importingSFAKey?: boolean;
@@ -467,22 +478,45 @@ export interface ICoreKit {
   commitChanges(): Promise<void>;
 
   /**
-   * Create a signature for the given data.
+   * Create a SECP256K1 ECDSA signature for the given data.
+   * will throw if secp256k1 is not configured as supported keyType
+   * will thrwo if dkls lib is not added prior signing
    *
    * Options:
    * - 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.
-   * - keyTweak: Provide a bip340 key tweak. Only works for bip340.
    */
-  sign(
+  sign_ECDSA_secp256k1(
     data: Buffer,
     opts?: {
       hashed?: boolean;
       secp256k1Precompute?: Secp256k1PrecomputedClient;
+    }
+  ): Promise<Buffer>;
+
+  /**
+   * Create a BIP340 signature for the given data.
+   * will throw if secp256k1 is not configured as supported keyType
+   * will thrwo if bip340 frost lib is not added prior signing
+   *
+   * Options:
+   * - keyTweak: Provide a bip340 key tweak. Only works for bip340.
+   */
+  signBIP340(
+    data: Buffer,
+    opts?: {
       keyTweak?: BN;
     }
   ): Promise<Buffer>;
 
+  /**
+   * Create a ED25519 signature for the given data.
+   * will throw if ed25519 is not configured as supported keyType
+   * will thrwo if ed25519 frost lib is not added prior signing
+   *
+   */
+  signED25519(data: Buffer): Promise<Buffer>;
+
   /**
    * WARNING: Use with caution. This will export the private signing key.
    *
@@ -490,7 +524,7 @@ export interface ICoreKit {
    *
    * For keytype ed25519, consider using _UNSAFE_exportTssEd25519Seed.
    */
-  _UNSAFE_exportTssKey(): Promise<string>;
+  _UNSAFE_exportTssKey(keyType: KeyType): Promise<string>;
 
   /**
    * WARNING: Use with caution. This will export the private signing key.
@@ -510,7 +544,6 @@ export interface SessionData {
   postboxKeyNodeIndexes?: number[];
   factorKey: string;
   tssShareIndex: number;
-  tssPubKey: string;
   signatures: string[];
   userInfo: UserInfo;
 }
@@ -539,6 +572,16 @@ export interface EthereumSigner {
   getPublic: () => Promise<Buffer>;
 }
 
+export interface Bip340Signer {
+  sign: (msgHash: Buffer) => Promise<Buffer>;
+  getPublic: () => Promise<Buffer>;
+}
+
+export interface Ed25519Signer {
+  sign: (msgHash: Buffer) => Promise<Buffer>;
+  getPublic: () => Promise<Buffer>;
+}
+
 export type StateEmitterEvents = {
   LOGOUT: () => void;
 };
diff --git a/src/mpcCoreKit.ts b/src/mpcCoreKit.ts
index 44b7fc1..18fa7cc 100644
--- a/src/mpcCoreKit.ts
+++ b/src/mpcCoreKit.ts
@@ -2,24 +2,23 @@ import { BNString, KeyType, ONE_KEY_DELETE_NONCE, Point, secp256k1, SHARE_DELETE
 import { CoreError } from "@tkey/core";
 import { ShareSerializationModule } from "@tkey/share-serialization";
 import { TorusStorageLayer } from "@tkey/storage-layer-torus";
-import { factorKeyCurve, getPubKeyPoint, lagrangeInterpolation, TKeyTSS, TSSTorusServiceProvider } from "@tkey/tss";
-import { SIGNER_MAP } from "@toruslabs/constants";
+import { factorKeyCurve, getPubKeyPoint, lagrangeInterpolation, TKeyTSS, TSS_TAG_DEFAULT, TSSTorusServiceProvider } from "@tkey/tss";
+import { SIG_TYPE, SIGNER_MAP, WEB3AUTH_SIG_TYPE } from "@toruslabs/constants";
 import { AGGREGATE_VERIFIER, TORUS_METHOD, TorusAggregateLoginResponse, TorusLoginResponse, UX_MODE } from "@toruslabs/customauth";
 import type { UX_MODE_TYPE } from "@toruslabs/customauth/dist/types/utils/enums";
 import { Ed25519Curve, Secp256k1Curve } from "@toruslabs/elliptic-wrapper";
 import { fetchLocalConfig } from "@toruslabs/fnd-base";
 import { keccak256 } from "@toruslabs/metadata-helpers";
 import { SessionManager } from "@toruslabs/session-manager";
-import { Torus as TorusUtils, TorusKey } from "@toruslabs/torus.js";
+import { getKeyCurve, Torus as TorusUtils, TorusKey } from "@toruslabs/torus.js";
 import { Client, getDKLSCoeff, setupSockets } from "@toruslabs/tss-client";
-import type { WasmLib as DKLSWasmLib } from "@toruslabs/tss-dkls-lib";
+import { type WasmLib as DKLSWasmLib } from "@toruslabs/tss-dkls-lib";
 import { sign as signFrost } from "@toruslabs/tss-frost-client";
 import type { WasmLib as FrostWasmLibEd25519 } from "@toruslabs/tss-frost-lib";
 import type { WasmLib as FrostWasmLibBip340 } from "@toruslabs/tss-frost-lib-bip340";
 import { SafeEventEmitter } from "@web3auth/auth";
 import BN from "bn.js";
 import bowser from "bowser";
-import { ec as EC } from "elliptic";
 
 import {
   ERRORS,
@@ -98,26 +97,37 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
 
   private ready = false;
 
-  private _tssLib: TssLibType;
+  private _tssLibs: TssLibType[] = [];
 
-  private wasmLib: DKLSWasmLib | FrostWasmLibEd25519 | FrostWasmLibBip340;
-
-  private _keyType: KeyType;
-
-  private _sigType: SigType;
+  private wasmLib: {
+    [SIG_TYPE.ECDSA_SECP256K1]?: DKLSWasmLib;
+    [SIG_TYPE.ED25519]?: FrostWasmLibEd25519;
+    [SIG_TYPE.BIP340]?: FrostWasmLibBip340;
+  } = {};
 
   private atomicCallStackCounter: number = 0;
 
   private sessionSigGenerator: ISessionSigGenerator;
 
+  private supportedCurveKeyTypes: Set<KeyType> = new Set();
+
+  private supportedSigTypes: Set<SigType> = new Set();
+
   constructor(options: Web3AuthOptions) {
     if (!options.web3AuthClientId) {
       throw CoreKitError.clientIdInvalid();
     }
 
-    this._tssLib = options.tssLib;
-    this._keyType = options.tssLib.keyType as KeyType;
-    this._sigType = options.tssLib.sigType as SigType;
+    if (options.supportedKeyTypes.length === 0) {
+      throw CoreKitError.invalidConfig("No supported key types provided");
+    }
+    this.supportedCurveKeyTypes = new Set(options.supportedKeyTypes);
+
+    if (!options.legacyFlag) {
+      options.legacyFlag = false;
+    } else if (this.supportedCurveKeyTypes.size > 1) {
+      throw CoreKitError.invalidConfig("Legacy flag is not supported for multiple curves");
+    }
 
     const isNodejsOrRN = this.isNodejsOrRN(options.uxMode);
 
@@ -136,6 +146,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     if (!options.disableHashedFactorKey) options.disableHashedFactorKey = false;
     if (!options.hashedFactorNonce) options.hashedFactorNonce = options.web3AuthClientId;
     if (options.disableSessionManager === undefined) options.disableSessionManager = false;
+
     this.sessionSigGenerator = new DefaultSessionSigGeneratorPlugin(this);
     this.options = options as Web3AuthOptionsWithDefaults;
 
@@ -157,14 +168,6 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     return this.tkey;
   }
 
-  get keyType(): KeyType {
-    return this._keyType;
-  }
-
-  get sigType(): SigType {
-    return this._sigType;
-  }
-
   get config(): Web3AuthOptionsWithDefaults {
     return this.options;
   }
@@ -190,10 +193,6 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     return this.sessionManager?.sessionId;
   }
 
-  get supportsAccountIndex(): boolean {
-    return this._sigType !== "ed25519";
-  }
-
   private get verifier(): string {
     if (this.state.userInfo?.aggregateVerifier) {
       return this.state.userInfo.aggregateVerifier;
@@ -209,8 +208,36 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     return this.options.uxMode === UX_MODE.REDIRECT;
   }
 
-  private get useClientGeneratedTSSKey(): boolean {
-    return this._sigType === "ed25519" && this.options.useClientGeneratedTSSKey === undefined ? true : !!this.options.useClientGeneratedTSSKey;
+  public getSupportedSigTypes(): Array<SigType> {
+    return Array.from(this.supportedSigTypes);
+  }
+
+  public getSupportedCurveKeyTypes(): Array<KeyType> {
+    return Array.from(this.supportedCurveKeyTypes);
+  }
+
+  /**
+   * The threshold signing library to use.
+   */
+  public addTssLibs(tssLibs: TssLibType[], force = false) {
+    for (const tssLib of tssLibs) {
+      if (!this.supportedCurveKeyTypes.has(tssLib.keyType as KeyType)) {
+        throw CoreKitError.invalidConfig(
+          `Tsslib key type: ${tssLib.keyType} is not supported, please reconfigure corekit with supported curves keytype`
+        );
+      }
+      if (this.supportedSigTypes.has(tssLib.sigType as WEB3AUTH_SIG_TYPE)) {
+        if (force) {
+          this._tssLibs = this._tssLibs.filter((t) => t.sigType !== tssLib.sigType);
+          this._tssLibs.push(tssLib);
+        } else {
+          log.warn(`Tsslib sig type: ${tssLib.sigType} is already exists, library is not appended`);
+        }
+        continue;
+      }
+      this.supportedSigTypes.add(tssLib.sigType as WEB3AUTH_SIG_TYPE);
+      this._tssLibs.push(tssLib);
+    }
   }
 
   public setCustomSessionSigGenerator(sessionSigGenerator: ISessionSigGenerator) {
@@ -221,10 +248,30 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     return this.sessionSigGenerator.getSessionSigs();
   }
 
+  public getTssShare(args: { keyType: KeyType; factorkey: BN; accountIndex?: number }) {
+    const { keyType, factorkey, accountIndex } = args;
+    return this.tkey.getTSSShare(factorkey, {
+      keyType,
+      accountIndex: accountIndex === undefined ? this.state.accountIndex : accountIndex,
+    });
+  }
+
+  public getTssData(keyType: KeyType) {
+    const result = this.getTssDataNotThrow(keyType);
+    if (!result) {
+      throw CoreKitError.default("Legacy mode only support single curve, please congfiure with correct keyType");
+    }
+    return result;
+  }
+
+  public getTssDataNotThrow(keyType: KeyType) {
+    return this.tkey.metadata.getTssData(keyType, TSS_TAG_DEFAULT);
+  }
+
   // RecoverTssKey only valid for user that enable MFA where user has 2 type shares :
   // TssShareType.DEVICE and TssShareType.RECOVERY
   // if the factors key provided is the same type recovery will not works
-  public async _UNSAFE_recoverTssKey(factorKey: string[]) {
+  public async _UNSAFE_recoverTssKey(factorKey: string[], keyType: KeyType) {
     this.checkReady();
     const factorKeyBN = new BN(factorKey[0], "hex");
     const shareStore0 = await this.getFactorKeyMetadata(factorKeyBN);
@@ -234,7 +281,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     const tssIndexesBN: BN[] = [];
     for (let i = 0; i < factorKey.length; i++) {
       const factorKeyBNInput = new BN(factorKey[i], "hex");
-      const { tssIndex, tssShare } = await this.tKey.getTSSShare(factorKeyBNInput);
+      const { tssIndex, tssShare } = await this.getTssShare({ keyType, factorkey: factorKeyBNInput });
       if (tssIndexes.includes(tssIndex)) {
         // reset instance before throw error
         await this.init();
@@ -245,21 +292,36 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       tssShares.push(tssShare);
     }
 
-    const finalKey = lagrangeInterpolation(this.tkey.tssCurve, tssShares, tssIndexesBN);
+    const tssCurve = getKeyCurve(keyType);
+    const finalKey = lagrangeInterpolation(tssCurve, tssShares, tssIndexesBN);
     // reset instance after recovery completed
     await this.init();
     return finalKey.toString("hex", 64);
   }
 
+  public getServiceProviderKeyType() {
+    // multicurve only support for secp256k1 torus/ sss
+    let keyType = KeyType.secp256k1;
+
+    // incase of legacy flag, it will depends on the tsslib used
+    if (this.options.legacyFlag) {
+      if (this.supportedCurveKeyTypes.size > 1) {
+        throw CoreKitError.invalidConfig("Legacy flag is not supported for multiple curves");
+      }
+      // return the only supported curve
+      keyType = this.supportedCurveKeyTypes.keys().next().value;
+    }
+    return keyType;
+  }
+
   public async init(params: InitParams = { handleRedirectResult: true }): Promise<void> {
     this.resetState();
     if (params.rehydrate === undefined) params.rehydrate = true;
 
-    const nodeDetails = fetchLocalConfig(this.options.web3AuthNetwork, this.keyType);
+    // multicurve only support for secp256k1 torus/ sss
+    const spKeyType = this.getServiceProviderKeyType();
 
-    if (this._sigType === "ed25519" && this.options.useDKG) {
-      throw CoreKitError.invalidConfig("DKG is not supported for ed25519 signature type");
-    }
+    const nodeDetails = fetchLocalConfig(this.options.web3AuthNetwork, spKeyType);
 
     this.torusSp = new TSSTorusServiceProvider({
       customAuthArgs: {
@@ -270,7 +332,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
         redirectPathName: this.options.redirectPathName,
         locationReplaceOnRedirect: true,
         serverTimeOffset: this.options.serverTimeOffset,
-        keyType: this.keyType,
+        keyType: spKeyType,
         useDkg: this.options.useDKG,
       },
     });
@@ -290,7 +352,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       modules: {
         shareSerialization: shareSerializationModule,
       },
-      tssKeyType: this.keyType,
+      legacyMetadataFlag: this.options.legacyFlag,
     });
 
     if (this.isRedirectMode) {
@@ -379,7 +441,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
         }
         const existingSFAKey = loginResponse.finalKeyData.privKey.padStart(64, "0");
         await this.setupTkey({
-          providedImportKey: existingSFAKey,
+          providedImportKey: { secp256k1: existingSFAKey },
           sfaLoginResponse: loginResponse,
           userInfo,
           importingSFAKey: true,
@@ -416,15 +478,16 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     this.torusSp.verifierName = verifier;
     this.torusSp.verifierId = verifierId;
 
-    if (registerExistingSFAKey && importTssKey) {
+    if (registerExistingSFAKey && importTssKey && (importTssKey.secp256k1 || this.options.legacyFlag)) {
       throw CoreKitError.invalidConfig("Cannot import TSS key and register SFA key at the same time.");
     }
 
+    const firstKeyType = this.getSupportedCurveKeyTypes()[0];
     try {
       // prefetch tss pub keys.
       const prefetchTssPubs = [];
       for (let i = 0; i < prefetchTssPublicKeys; i++) {
-        prefetchTssPubs.push(this.torusSp.getTSSPubKey(this.tkey.tssTag, i));
+        prefetchTssPubs.push(this.torusSp.getTSSPubKey(this.tkey.tssTag, i, firstKeyType));
       }
 
       // get postbox key.
@@ -449,9 +512,14 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
         if (loginResponse.metadata.typeOfUser === "v1") {
           throw CoreKitError.invalidConfig("Cannot register existing SFA key for v1 users, please contact web3auth support.");
         }
+        const spKeyType = this.getServiceProviderKeyType();
+        if (!this.supportedCurveKeyTypes.has(spKeyType)) {
+          throw CoreKitError.invalidConfig("Cannot register existing SFA key for secp256k1 users to ed25519, please contact web3auth support.");
+        }
         const existingSFAKey = loginResponse.finalKeyData.privKey.padStart(64, "0");
+
         await this.setupTkey({
-          providedImportKey: existingSFAKey,
+          providedImportKey: { [firstKeyType]: existingSFAKey },
           importingSFAKey: true,
           sfaLoginResponse: loginResponse,
           userInfo: { ...parseToken(idToken), verifier, verifierId },
@@ -523,6 +591,14 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
 
   public async inputFactorKey(factorKey: BN): Promise<void> {
     this.checkReady();
+
+    if (this.options.legacyFlag) {
+      const spKeyType = this.getServiceProviderKeyType();
+      // Check for existing curve in tssData for legacy mode
+      const tssData = this.getTssDataNotThrow(spKeyType);
+      if (!tssData) throw CoreKitError.default("Legacy mode only support single curve, please congfiure with correct keyType");
+    }
+
     try {
       // input tkey device share when required share > 0 ( or not reconstructed )
       // assumption tkey shares will not changed
@@ -546,7 +622,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
   }
 
   public setTssWalletIndex(accountIndex: number) {
-    this.updateState({ tssPubKey: this.tKey.getTSSPub(accountIndex).toSEC1(this.tkey.tssCurve, false), accountIndex });
+    this.updateState({ accountIndex });
   }
 
   public getCurrentFactorKey(): IFactorKey {
@@ -628,7 +704,9 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     if (!this.state.factorKey) {
       throw CoreKitError.factorKeyNotPresent("factorKey not present in state when getting tss factor public key.");
     }
-    const factorPubsList = this.tKey.metadata.factorPubs[this.tKey.tssTag];
+    const firstKeyType = this.getSupportedCurveKeyTypes()[0];
+    const tssData = this.getTssData(firstKeyType);
+    const factorPubsList = tssData.factorPubs;
     return factorPubsList.map((factorPub) => factorPub.toSEC1(factorKeyCurve, true).toString("hex"));
   };
 
@@ -675,17 +753,18 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
   /**
    * Get public key point in SEC1 format.
    */
-  public getPubKey(): Buffer {
-    const { tssPubKey } = this.state;
-    return Buffer.from(tssPubKey);
+  public getPubKey(keyType: KeyType, compressed: boolean = true, accountIndex?: number): Buffer {
+    const tssPubKey = this.getPubKeyPoint(keyType, accountIndex);
+    const tssCurve = getKeyCurve(keyType);
+    return tssPubKey.toSEC1(tssCurve, compressed);
   }
 
   /**
    * Get public key point.
    */
-  public getPubKeyPoint(): Point {
-    const { tssPubKey } = this.state;
-    return Point.fromSEC1(this.tkey.tssCurve, tssPubKey.toString("hex"));
+  public getPubKeyPoint(keyType: KeyType, accountIndex?: number): Point {
+    const tssPubKey = this.tkey.getTSSPub(keyType, accountIndex === undefined ? this.state.accountIndex : accountIndex);
+    return tssPubKey;
   }
 
   /**
@@ -694,11 +773,13 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
    * Throws an error if signature type is not ed25519.
    */
   public getPubKeyEd25519(): Buffer {
-    if (this._sigType !== "ed25519") {
-      throw CoreKitError.default(`getPubKeyEd25519 not supported for signature type ${this.sigType}`);
+    if (!this.supportedSigTypes.has(KeyType.ed25519)) {
+      throw CoreKitError.default(`ed25519 is not supported, please configure tssLib with ed25519 signature type `);
     }
 
-    const p = this.tkey.tssCurve.keyFromPublic(this.getPubKey()).getPublic();
+    const tssCurve = getKeyCurve(KeyType.ed25519);
+    if (this.state.accountIndex !== 0) throw CoreKitError.default("Ed25519 only support account index 0");
+    const p = this.getPubKeyPoint(KeyType.ed25519, 0).toEllipticPoint(tssCurve);
     return ed25519().keyFromPublic(p).getPublic();
   }
 
@@ -708,11 +789,12 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
    * Throws an error if signature type is not bip340.
    */
   public getPubKeyBip340(): Buffer {
-    if (this._sigType !== "bip340") {
-      throw CoreKitError.default(`getPubKeyBip340 not supported for signature type ${this.sigType}`);
+    if (!this.supportedSigTypes.has("bip340")) {
+      throw CoreKitError.default(`getPubKeyBip340 not supported , please configure tssLib with bip340 signature type `);
     }
 
-    const p = this.tkey.tssCurve.keyFromPublic(this.getPubKey()).getPublic();
+    const tssCurve = getKeyCurve(KeyType.secp256k1);
+    const p = this.getPubKeyPoint(KeyType.secp256k1).toEllipticPoint(tssCurve);
     return p.getX().toBuffer("be", 32);
   }
 
@@ -722,20 +804,24 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     signatures: string[];
   }> {
     const { sessionSignatures } = params || {};
-    this.wasmLib = await this.loadTssWasm();
+
+    const keyType = KeyType.secp256k1;
+    const sigType = SIG_TYPE.ECDSA_SECP256K1;
+
+    await this.loadTssWasm(sigType);
+    const dklsWasm = this.wasmLib[sigType];
+
     // PreSetup
     const { tssShareIndex } = this.state;
-    const tssPubKey = this.getPubKeyPoint();
+    const tssPubKey = this.getPubKeyPoint(keyType);
 
-    const { torusNodeTSSEndpoints } = fetchLocalConfig(this.options.web3AuthNetwork, this.keyType);
+    const { torusNodeTSSEndpoints } = fetchLocalConfig(this.options.web3AuthNetwork, keyType);
 
     if (!this.state.factorKey) {
       throw CoreKitError.factorKeyNotPresent("factorKey not present in state when signing.");
     }
-    const { tssShare } = await this.tKey.getTSSShare(this.state.factorKey, {
-      accountIndex: 0,
-    });
-    const tssNonce = this.getTssNonce();
+    const { tssShare } = await this.getTssShare({ keyType, factorkey: this.state.factorKey, accountIndex: 0 });
+    const tssNonce = this.getTssNonce(keyType);
 
     if (!tssPubKey || !torusNodeTSSEndpoints) {
       throw CoreKitError.tssPublicKeyOrEndpointsMissing();
@@ -749,7 +835,8 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     const clientIndex = parties - 1;
     // 1. setup
     // generate endpoints for servers
-    const { nodeIndexes } = await this.torusSp.getTSSPubKey(this.tKey.tssTag, this.tKey.metadata.tssNonces[this.tKey.tssTag]);
+    const tssData = this.getTssData(keyType);
+    const { nodeIndexes } = await this.torusSp.getTSSPubKey(this.tKey.tssTag, tssData.tssNonce, keyType);
     const {
       endpoints,
       tssWSEndpoints,
@@ -778,23 +865,12 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     // Client lib expects pub key in XY-format, base64-encoded.
     const tssPubKeyBase64 = Buffer.from(tssPubKey.toSEC1(secp256k1).subarray(1)).toString("base64");
 
-    const client = new Client(
-      currentSession,
-      clientIndex,
-      partyIndexes,
-      endpoints,
-      sockets,
-      share,
-      tssPubKeyBase64,
-      true,
-      this.wasmLib as DKLSWasmLib
-    );
+    const client = new Client(currentSession, clientIndex, partyIndexes, endpoints, sockets, share, tssPubKeyBase64, true, dklsWasm);
 
     // Suppress client logs if logging is disabled.
     client.log = (msg: string) => {
       if (!this.enableLogging) return;
-      // eslint-disable-next-line no-console
-      console.log(msg);
+      log.debug(msg);
     };
 
     const serverCoeffs: Record<number, string> = {};
@@ -814,31 +890,58 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     };
   }
 
-  public async sign(
-    data: Buffer,
-    opts?: {
-      hashed?: boolean;
-      secp256k1Precompute?: Secp256k1PrecomputedClient;
-      keyTweak?: BN;
+  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 `);
     }
-  ): Promise<Buffer> {
-    this.wasmLib = await this.loadTssWasm();
-    if (this._sigType === "ecdsa-secp256k1") {
-      if (opts?.keyTweak) {
-        throw CoreKitError.default("key tweaking not supported for ecdsa-secp256k1");
-      }
-      const sig = await this.sign_ECDSA_secp256k1(data, opts?.hashed, opts?.secp256k1Precompute);
-      return Buffer.concat([sig.r, sig.s, Buffer.from([sig.v])]);
-    } else if (this._sigType === "ed25519" || this._sigType === "bip340") {
-      if (opts?.hashed) {
-        throw CoreKitError.default(`hashed data not supported for bip340`);
-      } else if (opts?.keyTweak && this._sigType !== "bip340") {
-        throw CoreKitError.default("key tweaking not supported for ed25519");
-      }
+    if (!this.supportedSigTypes.has(SIG_TYPE.ECDSA_SECP256K1)) {
+      throw CoreKitError.default(`ECDSA_SECP256K1 is not supported, please configure tssLib with ECDSA_SECP256K1 signature type `);
+    }
+    const { hashed = false, secp256k1Precompute } = opts || {};
 
-      return this.sign_frost(data, opts?.keyTweak);
+    const sig = await this._sign_ECDSA_secp256k1(Buffer.from(data), hashed, secp256k1Precompute);
+    return Buffer.concat([sig.r, sig.s, Buffer.from([sig.v])]);
+  }
+
+  public async signBIP340(data: Uint8Array, opts?: { hashed?: boolean; keyTweak?: BN }) {
+    if (!this.supportedCurveKeyTypes.has(KeyType.secp256k1)) {
+      throw CoreKitError.default(`secp256k1 KeyTYpe is not supported, please configure secp256k1 curve key type `);
+    }
+    if (!this.supportedSigTypes.has(SIG_TYPE.BIP340)) {
+      throw CoreKitError.default(`BIP340 is not supported, please configure tssLib with BIP340 signature type `);
     }
-    throw CoreKitError.default(`sign not supported for key type ${this.keyType}`);
+
+    if (opts?.hashed) {
+      throw CoreKitError.default(`hashed data not supported for bip340`);
+    }
+    await this.loadTssWasm(SIG_TYPE.BIP340);
+    const frostlib = this.wasmLib[SIG_TYPE.BIP340];
+    if (!frostlib) {
+      throw CoreKitError.default(`frostlib not loaded for ed25519`);
+    }
+    if (frostlib.keyType !== KeyType.secp256k1) {
+      throw CoreKitError.default("frostlib keyType not matched");
+    }
+    return this.sign_frost({ data: Buffer.from(data), frostlib, keyTweak: opts?.keyTweak });
+  }
+
+  public async signED25519(data: Uint8Array) {
+    if (!this.supportedCurveKeyTypes.has(KeyType.ed25519)) {
+      throw CoreKitError.default(`ed25519 KeyTYpe is not supported, please configure ed25519 curve key type `);
+    }
+    if (!this.supportedSigTypes.has(SIG_TYPE.ED25519)) {
+      throw CoreKitError.default(`ed25519 is not supported, please configure tssLib with ed25519 signature type `);
+    }
+
+    await this.loadTssWasm(SIG_TYPE.ED25519);
+    const frostlib = this.wasmLib[SIG_TYPE.ED25519];
+    if (!frostlib) {
+      throw CoreKitError.default(`frostlib not loaded for ed25519`);
+    }
+    if (frostlib.keyType !== KeyType.ed25519) {
+      throw CoreKitError.default(`frostlib keyType not matched - forstlib keyType ${frostlib.keyType}`);
+    }
+    return this.sign_frost({ data: Buffer.from(data), frostlib });
   }
 
   // mutation function
@@ -846,12 +949,14 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     if (!this.state.factorKey) {
       throw CoreKitError.factorKeyNotPresent("factorKey not present in state when deleting a factor.");
     }
-    if (!this.tKey.metadata.factorPubs) {
+    const firstKeyType = this.getSupportedCurveKeyTypes()[0];
+    const tssData = this.getTssData(firstKeyType);
+    if (!tssData.factorPubs) {
       throw CoreKitError.factorPubsMissing();
     }
 
     await this.atomicSync(async () => {
-      const remainingFactors = this.tKey.metadata.factorPubs[this.tKey.tssTag].length || 0;
+      const remainingFactors = tssData.factorPubs.length || 0;
       if (remainingFactors <= 1) {
         throw CoreKitError.cannotDeleteLastFactor("Cannot delete last factor");
       }
@@ -864,7 +969,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       const authSignatures = await this.getSessionSignatures();
       await this.tKey.deleteFactorPub({ factorKey: this.state.factorKey, deleteFactorPub: factorPub, authSignatures });
       const factorPubHex = fpp.toSEC1(factorKeyCurve, true).toString("hex");
-      const allDesc = this.tKey.metadata.getShareDescription();
+      const allDesc = this.tkey.metadata.getShareDescription();
       const keyDesc = allDesc[factorPubHex];
       if (keyDesc) {
         await Promise.all(keyDesc.map(async (desc) => this.tKey?.metadata.deleteShareDescription(factorPubHex, desc)));
@@ -904,9 +1009,8 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
   public getKeyDetails(): MPCKeyDetails {
     this.checkReady();
     const tkeyDetails = this.tKey.getKeyDetails();
-    const tssPubKey = this.state.tssPubKey ? Point.fromSEC1(this.tkey.tssCurve, this.state.tssPubKey.toString("hex")) : undefined;
 
-    const factors = this.tKey.metadata.factorPubs ? this.tKey.metadata.factorPubs[this.tKey.tssTag] : [];
+    const factors = this.getTssFactorPub();
     const keyDetails: MPCKeyDetails = {
       // use tkey's for now
       requiredFactors: tkeyDetails.requiredShares,
@@ -914,8 +1018,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       totalFactors: factors.length + 1,
       shareDescriptions: this.tKey.getMetadata().getShareDescription(),
       metadataPubKey: tkeyDetails.pubKey,
-      tssPubKey,
-      keyType: this.keyType,
+      supportedKeyType: Array.from(this.supportedCurveKeyTypes),
     };
     return keyDetails;
   }
@@ -979,9 +1082,11 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
    *
    * Exports the private key scalar for the current account index.
    *
+   * @param keyType - export final tsskey of designated keyType
+   *
    * For signature type ed25519, consider using _UNSAFE_exportTssEd25519Seed.
    */
-  public async _UNSAFE_exportTssKey(): Promise<string> {
+  public async _UNSAFE_exportTssKey(keyType: KeyType): Promise<string> {
     if (!this.state.factorKey) {
       throw CoreKitError.factorKeyNotPresent("factorKey not present in state when exporting tss key.");
     }
@@ -989,15 +1094,19 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       throw CoreKitError.signaturesNotPresent("Signatures not present in state when exporting tss key.");
     }
 
-    const exportTssKey0 = await this.tKey._UNSAFE_exportTssKey({
-      factorKey: this.state.factorKey,
-      authSignatures: this.state.signatures,
-    });
+    return this.atomicSync(async () => {
+      const exportTssKey0 = await this.tKey._UNSAFE_exportTssKey({
+        factorKey: this.state.factorKey,
+        authSignatures: this.state.signatures,
+        keyType,
+      });
 
-    const accountNonce = this.getAccountNonce();
-    const tssKey = exportTssKey0.add(accountNonce).umod(this.tKey.tssCurve.n);
+      const accountNonce = this.getAccountNonce();
+      const tssCurve = getKeyCurve(keyType);
+      const tssKey = exportTssKey0.add(accountNonce).umod(tssCurve.n);
 
-    return tssKey.toString("hex", FIELD_ELEMENT_HEX_LEN);
+      return tssKey.toString("hex", FIELD_ELEMENT_HEX_LEN);
+    });
   }
 
   /**
@@ -1007,19 +1116,22 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
    * flow has been used.
    */
   public async _UNSAFE_exportTssEd25519Seed(): Promise<Buffer> {
-    if (this._sigType !== "ed25519") {
+    if (!this.supportedCurveKeyTypes.has(KeyType.ed25519)) {
       throw CoreKitError.default("Wrong signature type. Method can only be used when signature type is ed25519.");
     }
     if (!this.state.factorKey) throw CoreKitError.factorKeyNotPresent("factorKey not present in state when exporting tss ed25519 seed.");
     if (!this.state.signatures) throw CoreKitError.signaturesNotPresent("Signatures not present in state when exporting tss ed25519 seed.");
 
     try {
-      const exportEd25519Seed = await this.tKey._UNSAFE_exportTssEd25519Seed({
-        factorKey: this.state.factorKey,
-        authSignatures: this.state.signatures,
-      });
+      const result = await this.atomicSync(async () => {
+        const exportEd25519Seed = await this.tKey._UNSAFE_exportTssEd25519Seed({
+          factorKey: this.state.factorKey,
+          authSignatures: this.state.signatures,
+        });
 
-      return exportEd25519Seed;
+        return exportEd25519Seed;
+      });
+      return result;
     } catch (error: unknown) {
       throw CoreKitError.default(`Error exporting ed25519 seed: ${error}`);
     }
@@ -1030,7 +1142,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
   }
 
   public async setupTkey(params?: {
-    providedImportKey?: string;
+    providedImportKey?: { [k in KeyType]?: string };
     sfaLoginResponse?: TorusKey | TorusLoginResponse | TorusAggregateLoginResponse;
     userInfo?: UserInfo;
     importingSFAKey?: boolean;
@@ -1060,17 +1172,22 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     }
 
     const existingUser = await this.isMetadataPresent(this.state.postBoxKey);
-    let importKey = providedImportKey;
+    const importKey = providedImportKey ?? {};
     if (!existingUser) {
-      if (!importKey && this.useClientGeneratedTSSKey) {
-        if (this.keyType === KeyType.ed25519) {
-          const k = generateEd25519Seed();
-          importKey = k.toString("hex");
-        } else if (this.keyType === KeyType.secp256k1) {
-          const k = secp256k1.genKeyPair().getPrivate();
-          importKey = scalarBNToBufferSEC1(k).toString("hex");
-        } else {
-          throw CoreKitError.default(`Unsupported key type and sig type combination: ${this.keyType}, ${this._sigType}`);
+      const keyTypes = this.getSupportedCurveKeyTypes();
+      for (const keyType of keyTypes) {
+        if (!importKey[keyType]) {
+          if (keyType === KeyType.ed25519) {
+            const k = generateEd25519Seed();
+            importKey.ed25519 = 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 `);
+          }
         }
       }
       if (importingSFAKey && sfaLoginResponse && sfaLoginResponse.metadata.upgraded) {
@@ -1078,7 +1195,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       }
       await this.handleNewUser(importKey, importingSFAKey);
     } else {
-      if (importKey) {
+      if (importKey && Object.keys(importKey).length > 0) {
         throw CoreKitError.tssKeyImportNotAllowed();
       }
       await this.handleExistingUser();
@@ -1107,27 +1224,17 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     }
   }
 
-  private async importTssKey(tssKey: string, factorPub: Point, newTSSIndex: TssShareType = TssShareType.DEVICE): Promise<void> {
-    if (!this.state.signatures) {
-      throw CoreKitError.signaturesNotPresent("Signatures not present in state when importing tss key.");
-    }
-
-    await this.tKey.importTssKey(
-      { tag: this.tKey.tssTag, importKey: Buffer.from(tssKey, "hex"), factorPub, newTSSIndex },
-      { authSignatures: this.state.signatures }
-    );
-  }
-
-  private getTssNonce(): number {
-    if (!this.tKey.metadata.tssNonces || this.tKey.metadata.tssNonces[this.tKey.tssTag] === undefined) {
+  private getTssNonce(keyType: KeyType): number {
+    const tssData = this.getTssData(keyType);
+    if (tssData.tssNonce === undefined) {
       throw CoreKitError.tssNoncesMissing(`tssNonce not present for tag ${this.tKey.tssTag}`);
     }
-    const tssNonce = this.tKey.metadata.tssNonces[this.tKey.tssTag];
+    const { tssNonce } = tssData;
     return tssNonce;
   }
 
   // mutation function
-  private async handleNewUser(importTssKey?: string, isSfaKey?: boolean) {
+  private async handleNewUser(importTssKey?: { [k in KeyType]?: string }, isSfaKey?: boolean) {
     await this.atomicSync(async () => {
       // Generate or use hash factor and initialize tkey with it.
       let factorKey: BN;
@@ -1141,14 +1248,52 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       }
       const deviceTSSIndex = TssShareType.DEVICE;
       const factorPub = getPubKeyPoint(factorKey, factorKeyCurve);
-      if (!importTssKey) {
-        const ec = new EC(this.keyType);
-        const deviceTSSShare = ec.genKeyPair().getPrivate();
-        await this.tKey.initialize({ factorPub, deviceTSSShare, deviceTSSIndex });
+
+      await this.tKey.initialize();
+
+      // only consider 2 types of curve, will change the logic in the future if there are more key types curves
+      // if both keyType library is avaiable, initialize secp256k1 first as secp256k1 is initialize offline
+      if (this.supportedCurveKeyTypes.has(KeyType.secp256k1)) {
+        const importTssBuf = importTssKey.secp256k1 ? Buffer.from(importTssKey.secp256k1, "hex") : undefined;
+        // check if key is in the tsslib and keytype exists
+        await this.tKey.initializeTss({
+          importKey: importTssBuf,
+          factorPub,
+          deviceTSSIndex,
+          tssKeyType: KeyType.secp256k1,
+          serverOpts: {
+            // selectedServers: [],
+            authSignatures: this.state.signatures,
+          },
+        });
+
+        if (this.supportedCurveKeyTypes.has(KeyType.ed25519)) {
+          const importTssBufEd25519 = importTssKey.ed25519 ? Buffer.from(importTssKey.ed25519, "hex") : undefined;
+          // factorPub and tssIndex are not allowed as tkey tss will get from tss data of existing curve
+          await this.tKey.initializeTss({
+            importKey: importTssBufEd25519,
+            tssKeyType: KeyType.ed25519,
+            serverOpts: {
+              // selectedServers: [],
+              authSignatures: this.state.signatures,
+            },
+          });
+        }
+      } else if (this.supportedCurveKeyTypes.has(KeyType.ed25519)) {
+        // for case where only ed25519 is configured, factorPub, and index is required
+        const importTssBuf = importTssKey.ed25519 ? Buffer.from(importTssKey.ed25519, "hex") : undefined;
+        await this.tKey.initializeTss({
+          importKey: importTssBuf,
+          factorPub,
+          deviceTSSIndex,
+          tssKeyType: KeyType.ed25519,
+          serverOpts: {
+            // selectedServers: [],
+            authSignatures: this.state.signatures,
+          },
+        });
       } else {
-        await this.tKey.initialize({ skipTssInit: true });
-        await this.tKey.reconstructKey();
-        await this.importTssKey(importTssKey, factorPub, deviceTSSIndex);
+        throw CoreKitError.default("Invalid or unsupported type");
       }
 
       // Finalize initialization.
@@ -1181,6 +1326,14 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
 
   private async handleExistingUser() {
     await this.tKey.initialize({ neverInitializeNewKey: true });
+
+    if (this.options.legacyFlag) {
+      const spKeyType = this.getServiceProviderKeyType();
+      // Check for existing curve in tssData for legacy mode
+      // the function below will throw if tss data is not available
+      this.getTssData(spKeyType);
+    }
+
     if (this.options.disableHashedFactorKey) {
       return;
     }
@@ -1211,11 +1364,36 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       log.warn("AccountIndex should be 0");
       this.state.accountIndex = 0;
     }
-    // Read tss meta data.
-    const { tssIndex: tssShareIndex } = await this.tKey.getTSSShare(factorKey);
-    const tssPubKey = this.tKey.getTSSPub().toSEC1(this.tkey.tssCurve, false);
 
-    this.updateState({ tssShareIndex, tssPubKey, factorKey });
+    let newCurveKeyType = false;
+    for (const keyType of this.supportedCurveKeyTypes) {
+      const tssData = this.getTssDataNotThrow(keyType);
+      if (!tssData) {
+        newCurveKeyType = true;
+      }
+    }
+
+    if (newCurveKeyType) {
+      this.atomicSync(async () => {
+        // check for missing curve and initialize it
+        for (const keyType of this.supportedCurveKeyTypes) {
+          const tssData = this.getTssDataNotThrow(keyType);
+          if (!tssData) {
+            await this.tKey.initializeTss({
+              tssKeyType: keyType,
+              serverOpts: {
+                authSignatures: this.state.signatures,
+              },
+            });
+          }
+        }
+      });
+    }
+
+    const firstKeyType = this.getSupportedCurveKeyTypes()[0];
+    // Read tss meta data.
+    const { tssIndex: tssShareIndex } = await this.getTssShare({ keyType: firstKeyType, factorkey: factorKey });
+    this.updateState({ tssShareIndex, factorKey });
 
     await this.createSession();
   }
@@ -1251,7 +1429,6 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
         postBoxKey,
         postboxKeyNodeIndexes: result.postboxKeyNodeIndexes || [],
         tssShareIndex: result.tssShareIndex,
-        tssPubKey: this.tkey.getTSSPub().toSEC1(this.tKey.tssCurve, false),
         signatures: result.signatures,
         userInfo: result.userInfo,
       });
@@ -1271,14 +1448,13 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     try {
       const sessionId = SessionManager.generateRandomSessionKey();
       this.sessionManager.sessionId = sessionId;
-      const { postBoxKey, factorKey, userInfo, tssShareIndex, tssPubKey, postboxKeyNodeIndexes } = this.state;
+      const { postBoxKey, factorKey, userInfo, tssShareIndex, postboxKeyNodeIndexes } = this.state;
       if (!this.state.factorKey) {
         throw CoreKitError.factorKeyNotPresent("factorKey not present in state when creating session.");
       }
-      const { tssShare } = await this.tKey.getTSSShare(this.state.factorKey, {
-        accountIndex: this.state.accountIndex,
-      });
-      if (!postBoxKey || !factorKey || !tssShare || !tssPubKey || !userInfo) {
+      const firstKeyType = this.getSupportedCurveKeyTypes()[0];
+      const { tssShare } = await this.getTssShare({ keyType: firstKeyType, factorkey: this.state.factorKey });
+      if (!postBoxKey || !factorKey || !tssShare || !userInfo) {
         throw CoreKitError.userNotLoggedIn();
       }
       const sessionSigs = this.state.signatures;
@@ -1287,7 +1463,6 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
         postboxKeyNodeIndexes: postboxKeyNodeIndexes || [],
         factorKey: factorKey?.toString("hex"),
         tssShareIndex: tssShareIndex as number,
-        tssPubKey: Buffer.from(tssPubKey).toString("hex"),
         signatures: sessionSigs,
         userInfo,
       };
@@ -1334,10 +1509,12 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
    */
   private async copyOrCreateShare(newFactorTSSIndex: number, newFactorPub: Point) {
     this.checkReady();
-    if (!this.tKey.metadata.factorPubs || !Array.isArray(this.tKey.metadata.factorPubs[this.tKey.tssTag])) {
+    const firstKeyType = this.getSupportedCurveKeyTypes()[0];
+    const tssData = this.getTssData(firstKeyType);
+    if (!tssData.factorPubs || !Array.isArray(tssData.factorPubs)) {
       throw CoreKitError.factorPubsMissing("'factorPubs' is missing in the metadata. Failed to copy factor public key.");
     }
-    if (!this.tKey.metadata.factorEncs || typeof this.tKey.metadata.factorEncs[this.tKey.tssTag] !== "object") {
+    if (!tssData.factorEncs || typeof tssData.factorEncs !== "object") {
       throw CoreKitError.factorEncsMissing("'factorEncs' is missing in the metadata. Failed to copy factor public key.");
     }
     if (!this.state.factorKey) {
@@ -1346,7 +1523,7 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     if (VALID_SHARE_INDICES.indexOf(newFactorTSSIndex) === -1) {
       throw CoreKitError.newShareIndexInvalid(`Invalid share type provided (${newFactorTSSIndex}). Valid share types are ${VALID_SHARE_INDICES}.`);
     }
-    if (this.tKey.metadata.factorPubs[this.tKey.tssTag].length >= MAX_FACTORS) {
+    if (tssData.factorPubs.length >= MAX_FACTORS) {
       throw CoreKitError.maximumFactorsReached(`The maximum number of allowable factors (${MAX_FACTORS}) has been reached.`);
     }
     const authSignatures = await this.getSessionSignatures();
@@ -1410,7 +1587,8 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
       additionalMetadata = {};
     }
 
-    const { tssIndex } = await this.tKey.getTSSShare(factorKey);
+    const firstKeyType = this.getSupportedCurveKeyTypes()[0];
+    const { tssIndex } = await this.getTssShare({ keyType: firstKeyType, factorkey: factorKey });
     const factorPoint = getPubKeyPoint(factorKey, factorKeyCurve);
     const factorPub = factorPoint.toSEC1(factorKeyCurve, true).toString("hex");
 
@@ -1475,7 +1653,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,
@@ -1509,8 +1687,13 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     }
   }
 
-  private async sign_frost(data: Buffer, keyTweak?: BN): Promise<Buffer> {
-    const nodeDetails = fetchLocalConfig(this.options.web3AuthNetwork, this.keyType, this._sigType);
+  private async sign_frost(args: { data: Buffer; keyTweak?: BN; frostlib: FrostWasmLibEd25519 | FrostWasmLibBip340 }): Promise<Buffer> {
+    const { data, keyTweak, frostlib } = args;
+
+    const keyType = frostlib.keyType as KeyType;
+    const sigType = frostlib.sigType as WEB3AUTH_SIG_TYPE;
+
+    const nodeDetails = fetchLocalConfig(this.options.web3AuthNetwork, keyType, sigType);
     if (!nodeDetails.torusNodeTSSEndpoints) {
       throw CoreKitError.default("could not fetch tss node endpoints");
     }
@@ -1527,29 +1710,28 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
 
     // Derive share coefficients for flat hierarchy.
     const ec = (() => {
-      if (this.keyType === KeyType.secp256k1) {
+      if (keyType === KeyType.secp256k1) {
         return new Secp256k1Curve();
-      } else if (this.keyType === KeyType.ed25519) {
+      } else if (keyType === KeyType.ed25519) {
         return new Ed25519Curve();
       }
-      throw CoreKitError.default(`key type ${this.keyType} not supported with FROST signing`);
+      throw CoreKitError.default(`key type ${keyType} not supported with FROST signing`);
     })();
     const { serverCoefficients, clientCoefficient } = deriveShareCoefficients(ec, serverXCoords, clientXCoord, this.state.tssShareIndex);
 
     // Get pub key.
-    const tssPubKey = this.getPubKey();
-    const tssPubKeyPoint = ec.keyFromPublic(tssPubKey).getPublic();
+    const tssPubKeyPoint = this.getPubKeyPoint(keyType).toEllipticPoint(ec);
 
     // Get client key share and adjust by coefficient.
-    if (this._sigType === "ed25519" && this.state.accountIndex !== 0) {
+    if (sigType === "ed25519" && this.state.accountIndex !== 0) {
       throw CoreKitError.default("Account index not supported for ed25519");
     }
-    const { tssShare } = await this.tKey.getTSSShare(this.state.factorKey);
+    const { tssShare } = await this.getTssShare({ keyType, factorkey: this.state.factorKey });
     const clientShareAdjusted = tssShare.mul(clientCoefficient).umod(ec.n);
     const clientShareAdjustedHex = ec.scalarToBuffer(clientShareAdjusted, Buffer).toString("hex");
 
     // Generate session identifier.
-    const tssNonce = this.getTssNonce();
+    const tssNonce = this.getTssNonce(keyType);
     const sessionNonce = generateSessionNonce();
     const session = getSessionId(this.verifier, this.verifierId, this.tKey.tssTag, tssNonce, sessionNonce);
 
@@ -1558,8 +1740,9 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     const pubKeyHex = ec.pointToBuffer(tssPubKeyPoint, Buffer).toString("hex");
     const serverCoefficientsHex = serverCoefficients.map((c) => ec.scalarToBuffer(c, Buffer).toString("hex"));
     const authSignatures = await this.getSessionSignatures();
+
     const signature = await signFrost(
-      this.wasmLib as FrostWasmLibEd25519 | FrostWasmLibBip340,
+      frostlib,
       session,
       authSignatures,
       serverXCoords,
@@ -1576,8 +1759,18 @@ export class Web3AuthMPCCoreKit implements ICoreKit, IMPCContext {
     return Buffer.from(signature, "hex");
   }
 
-  private async loadTssWasm() {
-    if (this.wasmLib) return this.wasmLib;
-    return this._tssLib.load();
+  private async loadTssWasm(sigType: WEB3AUTH_SIG_TYPE) {
+    if (this.wasmLib[sigType]) {
+      return this.wasmLib[sigType];
+    }
+
+    if (this.supportedSigTypes.has(sigType)) {
+      const matchLibs = this._tssLibs.find((x) => x.sigType === sigType);
+      if (sigType === SIG_TYPE.ECDSA_SECP256K1) {
+        this.wasmLib[sigType] = (await matchLibs?.load()) as DKLSWasmLib;
+      }
+      if (sigType === SIG_TYPE.ED25519 || sigType === SIG_TYPE.BIP340) this.wasmLib[sigType] = (await matchLibs?.load()) as FrostWasmLibEd25519;
+    }
+    return this.wasmLib[sigType];
   }
 }
diff --git a/src/utils.ts b/src/utils.ts
index 43179a3..ef1fbc5 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -9,7 +9,8 @@ import { eddsa as EDDSA } from "elliptic";
 import loglevel from "loglevel";
 
 import { DELIMITERS, SCALAR_LEN } from "./constants";
-import { CoreKitSigner, EthereumSigner, IAsyncStorage, IStorage } from "./interfaces";
+import { Bip340Signer, Ed25519Signer, EthereumSigner, IAsyncStorage, IStorage } from "./interfaces";
+import { Web3AuthMPCCoreKit } from "./mpcCoreKit";
 
 export const ed25519 = () => {
   return new EDDSA("ed25519");
@@ -195,21 +196,51 @@ export function sigToRSV(sig: Buffer) {
   return { r: sig.subarray(0, 32), s: sig.subarray(32, 64), v: sig[64] };
 }
 
-export function makeEthereumSigner(kit: CoreKitSigner): EthereumSigner {
-  if (kit.keyType !== KeyType.secp256k1) {
-    throw new Error(`Invalid key type: expected secp256k1, got ${kit.keyType}`);
+export function makeEthereumSigner(kit: Web3AuthMPCCoreKit): EthereumSigner {
+  if (!kit.getSupportedCurveKeyTypes().includes(KeyType.secp256k1)) {
+    throw new Error(`Invalid key type: secp256k1 is not configured`);
   }
   return {
     sign: async (msgHash: Buffer) => {
-      const sig = await kit.sign(msgHash, { hashed: true });
+      const sig = await kit.sign_ECDSA_secp256k1(msgHash, { hashed: true });
       return sigToRSV(sig);
     },
     getPublic: async () => {
-      const pk = Point.fromSEC1(secp256k1, kit.getPubKey().toString("hex"));
+      const pk = Point.fromSEC1(secp256k1, kit.getPubKey(KeyType.secp256k1).toString("hex"));
       return pk.toSEC1(secp256k1).subarray(1);
     },
   };
 }
 
+export function makeBip340Signer(kit: Web3AuthMPCCoreKit): Bip340Signer {
+  if (!kit.getSupportedCurveKeyTypes().includes(KeyType.secp256k1)) {
+    throw new Error(`Invalid key type: secp256k1 is not configured`);
+  }
+
+  return {
+    sign: async (msgHash: Buffer) => {
+      return kit.signBIP340(msgHash, { hashed: false });
+    },
+    getPublic: async () => {
+      const pk = Point.fromSEC1(secp256k1, kit.getPubKey(KeyType.secp256k1).toString("hex"));
+      return pk.toSEC1(secp256k1).subarray(1);
+    },
+  };
+}
+
+export function makeEd25519Signer(kit: Web3AuthMPCCoreKit): Ed25519Signer {
+  if (!kit.getSupportedCurveKeyTypes().includes(KeyType.ed25519)) {
+    throw new Error(`Invalid key type: ed25519 is not configured`);
+  }
+  return {
+    sign: async (msgHash: Buffer) => {
+      return kit.signED25519(msgHash);
+    },
+    getPublic: async () => {
+      return kit.getPubKeyEd25519();
+    },
+  };
+}
+
 export const log = loglevel.getLogger("mpc-core-kit");
 log.disableAll();
diff --git a/tests/backwardCompatible.spec.ts b/tests/backwardCompatible.spec.ts
index 5c244c6..d044395 100644
--- a/tests/backwardCompatible.spec.ts
+++ b/tests/backwardCompatible.spec.ts
@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import test from "node:test";
 
-import { EllipticPoint } from "@tkey/common-types";
+import { EllipticPoint, KeyType } from "@tkey/common-types";
 import { UX_MODE_TYPE } from "@toruslabs/customauth";
 import { keccak256 } from "@toruslabs/metadata-helpers";
 import { tssLib } from "@toruslabs/tss-dkls-lib";
@@ -33,23 +33,29 @@ const checkLogin = async (coreKitInstance: Web3AuthMPCCoreKit) => {
   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"));
+  const keyType = coreKitInstance.getSupportedCurveKeyTypes()[0];
+  await coreKitInstance.getTssShare({keyType, factorkey: new BN(factorkey.factorKey, "hex")});
 };
 
 variable.forEach((testVariable) => {
   const { web3AuthNetwork, uxMode, manualSync, email } = testVariable;
+  const keyType = tssLib.keyType as KeyType;
 
   const storageInstance = new MemoryStorage();
-  const newCoreKitInstance = () =>
-    new Web3AuthMPCCoreKit({
+  const newCoreKitInstance = () => {
+    const instance = new Web3AuthMPCCoreKit({
       web3AuthClientId: "torus-key-test",
       web3AuthNetwork,
       baseUrl: "http://localhost:3000",
       uxMode,
-      tssLib,
+      supportedKeyTypes: [keyType],
       storage: storageInstance,
       manualSync,
+      legacyFlag: true,
     });
+    instance.addTssLibs([tssLib])
+    return instance;
+  }
 
   const coreKitInstance = newCoreKitInstance();
 
@@ -72,14 +78,11 @@ variable.forEach((testVariable) => {
       // get key details
       await checkLogin(coreKitInstance);
 
-      const tssPublicPoint = bufferToElliptic(coreKitInstance.getPubKey());
-      const { metadataPubKey, tssPubKey } = coreKitInstance.getKeyDetails();
+      const tssPublicPoint = bufferToElliptic(coreKitInstance.getPubKey(keyType));
+      const { metadataPubKey } = coreKitInstance.getKeyDetails();
       assert.strictEqual(tssPublicPoint.getX().toString("hex"), "d2869f27c3e226d90b275b008f7dc67b8f4b208900a7b98ecc4e5266807d382c");
       assert.strictEqual(tssPublicPoint.getY().toString("hex"), "15860fd569413eb7f177e655c4bf855f37920b800235de344fdd518196becfe0");
 
-      assert.strictEqual(tssPubKey.x.toString("hex"), "d2869f27c3e226d90b275b008f7dc67b8f4b208900a7b98ecc4e5266807d382c");
-      assert.strictEqual(tssPubKey.y.toString("hex"), "15860fd569413eb7f177e655c4bf855f37920b800235de344fdd518196becfe0");
-
       assert.strictEqual(metadataPubKey.x.toString("hex"), "b3951a441f87ecea4672edc82894ac023316723cf164a93adec72b58a27a1f06");
       assert.strictEqual(metadataPubKey.y.toString("hex"), "3be6c118d94242a650e8aebbefcd37ebeceeb927d0ed51f3d2ba723b8fd2740b");
     });
@@ -119,11 +122,11 @@ variable.forEach((testVariable) => {
       const msg = "hello world";
       const msgBuffer = Buffer.from(msg);
       const msgHash = keccak256(msgBuffer);
-      const signature = sigToRSV(await coreKitInstance.sign(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;
-      const publicKeyPoint = bufferToElliptic(coreKitInstance.getPubKey());
+      const publicKeyPoint = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       assert(pubkey.eq(publicKeyPoint));
     });
   });
diff --git a/tests/bip340.spec.ts b/tests/bip340.spec.ts
index 298d100..3ee0601 100644
--- a/tests/bip340.spec.ts
+++ b/tests/bip340.spec.ts
@@ -1,14 +1,15 @@
 import assert from "node:assert";
 import test from "node:test";
 
-import { EllipticPoint } from "@tkey/common-types";
+import { EllipticPoint, KeyType } 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";
+import {  criticalResetAccount, mockLogin, mockLogin2 } from "./setup";
+import { getKeyCurve } from "@toruslabs/torus.js";
 
 type TestVariable = {
   web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
@@ -31,25 +32,31 @@ const checkLogin = async (coreKitInstance: Web3AuthMPCCoreKit, accountIndex = 0)
   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 keyType = coreKitInstance.getSupportedCurveKeyTypes()[0]
+  await coreKitInstance.getTssShare({ keyType, factorkey: 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,
-    });
+
+  const keyType = tssLib.keyType as KeyType;
+  
+  const newCoreKitInstance = () => {
+    const instance =
+      new Web3AuthMPCCoreKit({
+        web3AuthClientId: "torus-key-test",
+        web3AuthNetwork,
+        baseUrl: "http://localhost:3000",
+        uxMode,
+        supportedKeyTypes: [keyType],
+        storage: storageInstance,
+        manualSync,
+      });
+    instance.addTssLibs([tssLib])
+    return instance;
+  };
 
   async function resetAccount() {
     const resetInstance = newCoreKitInstance();
@@ -85,11 +92,10 @@ variable.forEach((testVariable) => {
       // get key details
       await checkLogin(coreKitInstance);
 
-      checkPubKey = bufferToElliptic(coreKitInstance.getPubKey(), coreKitInstance.tKey.tssCurve);
+      const tssCurve = getKeyCurve(keyType)
+      checkPubKey = coreKitInstance.getPubKeyPoint(keyType).toEllipticPoint(tssCurve);
       const factorkey = coreKitInstance.getCurrentFactorKey();
-      const { tssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"), {
-        threshold: 0,
-      });
+      const { tssShare } = await coreKitInstance.getTssShare( { keyType, factorkey: new BN(factorkey.factorKey, "hex")});
       checkTssShare = tssShare;
 
       if (manualSync) {
@@ -125,9 +131,10 @@ variable.forEach((testVariable) => {
 
       // get key details
       await checkLogin(coreKitInstance);
-      const newPubKey = bufferToElliptic(coreKitInstance.getPubKey(), coreKitInstance.tKey.tssCurve);
+      const tssCurve = getKeyCurve(keyType)
+      const newPubKey = coreKitInstance.getPubKeyPoint(keyType).toEllipticPoint(tssCurve);
       const factorkey = coreKitInstance.getCurrentFactorKey();
-      const { tssShare: newTssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"));
+      const { tssShare: newTssShare } = await coreKitInstance.getTssShare({ keyType, factorkey: new BN(factorkey.factorKey, "hex") });
       assert(checkPubKey.eq(newPubKey));
       assert(checkTssShare.eq(newTssShare));
     });
@@ -144,7 +151,7 @@ variable.forEach((testVariable) => {
       const msg = "hello world";
       const msgBuffer = Buffer.from(msg);
 
-      const signature = await coreKitInstance.sign(msgBuffer);
+      const signature = await coreKitInstance.signBIP340(msgBuffer);
       const pk = coreKitInstance.getPubKeyBip340();
       const valid = bip340.verify(signature, msgBuffer, pk);
       assert(valid);
diff --git a/tests/ed25519.spec.ts b/tests/ed25519.spec.ts
index 208beb5..227abb1 100644
--- a/tests/ed25519.spec.ts
+++ b/tests/ed25519.spec.ts
@@ -1,13 +1,14 @@
 import assert from "node:assert";
 import test from "node:test";
 
-import { EllipticPoint } from "@tkey/common-types";
+import { EllipticPoint, KeyType } from "@tkey/common-types";
 import { UX_MODE_TYPE } from "@toruslabs/customauth";
 import { tssLib } from "@toruslabs/tss-frost-lib";
 import BN from "bn.js";
 
 import { AsyncStorage, COREKIT_STATUS, ed25519, MemoryStorage, WEB3AUTH_NETWORK, WEB3AUTH_NETWORK_TYPE, Web3AuthMPCCoreKit } from "../src";
 import { bufferToElliptic, criticalResetAccount, mockLogin, mockLogin2 } from "./setup";
+import { getKeyCurve } from "@toruslabs/torus.js";
 
 type TestVariable = {
   web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
@@ -30,24 +31,25 @@ const checkLogin = async (coreKitInstance: Web3AuthMPCCoreKit, accountIndex = 0)
   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 keyType = coreKitInstance.getSupportedCurveKeyTypes()[0];
+  await coreKitInstance.getTssShare({ keyType, factorkey: new BN(factorkey.factorKey, "hex"), accountIndex });
 };
 
 const storageInstance = new MemoryStorage();
 
 variable.forEach((testVariable) => {
   const { web3AuthNetwork, uxMode, manualSync, email } = testVariable;
+  const keyType = tssLib.keyType as KeyType;
   const newCoreKitInstance = () =>
     new Web3AuthMPCCoreKit({
       web3AuthClientId: "torus-key-test",
       web3AuthNetwork,
       baseUrl: "http://localhost:3000",
       uxMode,
-      tssLib,
+      supportedKeyTypes: [keyType],
       storage: storageInstance,
       manualSync,
+      legacyFlag: true,
     });
 
   async function resetAccount() {
@@ -84,11 +86,10 @@ variable.forEach((testVariable) => {
       // get key details
       await checkLogin(coreKitInstance);
 
-      checkPubKey = bufferToElliptic(coreKitInstance.getPubKey(), coreKitInstance.tKey.tssCurve);
+      const tssCurve = getKeyCurve(keyType)
+      checkPubKey = bufferToElliptic(coreKitInstance.getPubKey(keyType), tssCurve);
       const factorkey = coreKitInstance.getCurrentFactorKey();
-      const { tssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"), {
-        threshold: 0,
-      });
+      const { tssShare } = await coreKitInstance.getTssShare({keyType, factorkey: new BN(factorkey.factorKey, "hex")});
       checkTssShare = tssShare;
 
       if (manualSync) {
@@ -124,15 +125,19 @@ variable.forEach((testVariable) => {
 
       // get key details
       await checkLogin(coreKitInstance);
-      const newPubKey = bufferToElliptic(coreKitInstance.getPubKey(), coreKitInstance.tKey.tssCurve);
+      const tssCurve = getKeyCurve(keyType)
+      const newPubKey = bufferToElliptic(coreKitInstance.getPubKey(keyType), tssCurve);
       const factorkey = coreKitInstance.getCurrentFactorKey();
-      const { tssShare: newTssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"));
+      const { tssShare: newTssShare } = await coreKitInstance.getTssShare({ keyType, factorkey: new BN(factorkey.factorKey, "hex") });
       assert(checkPubKey.eq(newPubKey));
       assert(checkTssShare.eq(newTssShare));
     });
 
     await t.test("#able to sign", async function () {
       const coreKitInstance = newCoreKitInstance();
+      // add signing lib
+      coreKitInstance.addTssLibs([tssLib]);
+
       await coreKitInstance.init({ handleRedirectResult: false, rehydrate: false });
       const localToken = await mockLogin2(email);
       await coreKitInstance.loginWithJWT({
@@ -143,7 +148,7 @@ variable.forEach((testVariable) => {
       const msg = "hello world";
       const msgBuffer = Buffer.from(msg);
 
-      const signature = ed25519().makeSignature((await coreKitInstance.sign(msgBuffer)).toString("hex"));
+      const signature = ed25519().makeSignature((await coreKitInstance.signED25519(msgBuffer)).toString("hex"));
       const valid = ed25519().verify(msgBuffer, signature, coreKitInstance.getPubKeyEd25519());
       assert(valid);
     });
diff --git a/tests/factors.spec.ts b/tests/factors.spec.ts
index e3a7506..4c0ffe2 100644
--- a/tests/factors.spec.ts
+++ b/tests/factors.spec.ts
@@ -1,42 +1,49 @@
 import assert from "node:assert";
 import test from "node:test";
 
-import { EllipticPoint, Point } from "@tkey/common-types";
+import { EllipticPoint, KeyType, Point } from "@tkey/common-types";
 import { factorKeyCurve } from "@tkey/tss";
 import { tssLib as tssLibDKLS } from "@toruslabs/tss-dkls-lib";
 import { tssLib as tssLibFROST } from "@toruslabs/tss-frost-lib";
 import BN from "bn.js";
 
 import { COREKIT_STATUS, IAsyncStorage, IStorage, MemoryStorage, TssLibType, TssShareType, WEB3AUTH_NETWORK, Web3AuthMPCCoreKit } from "../src";
-import { AsyncMemoryStorage, bufferToElliptic, criticalResetAccount, mockLogin } from "./setup";
+import { AsyncMemoryStorage, criticalResetAccount, mockLogin } from "./setup";
+import { getKeyCurve } from "@toruslabs/torus.js";
+import { randomId } from "@toruslabs/customauth";
+import log  from "loglevel";
 
 type FactorTestVariable = {
   manualSync?: boolean;
   storage?: IAsyncStorage | IStorage;
   email: string;
   tssLib?: TssLibType;
+  resetAccount? : false
 };
 
 function getPubKeys(kit: Web3AuthMPCCoreKit, indices: number[]): EllipticPoint[] {
-  if (!kit.supportsAccountIndex) {
+  const keyType = kit.getSupportedCurveKeyTypes()[0];
+  if (keyType !== KeyType.ed25519) {
     indices = indices.filter((i) => i === 0);
   }
+  const tssCurve = getKeyCurve(keyType)
   const pubKeys = indices.map((i) => {
-    kit.setTssWalletIndex(i);
-    return bufferToElliptic(kit.getPubKey());
+    return kit.getPubKeyPoint(keyType,  i).toEllipticPoint(tssCurve);
   });
   return pubKeys;
 }
 
 export const FactorManipulationTest = async (testVariable: FactorTestVariable) => {
   const { email, tssLib } = testVariable;
+  const localTssLib = tssLib ?? tssLibDKLS;
+  const keyType = localTssLib.keyType as KeyType;
   const newInstance = async () => {
     const instance = new Web3AuthMPCCoreKit({
       web3AuthClientId: "torus-key-test",
       web3AuthNetwork: WEB3AUTH_NETWORK.DEVNET,
       baseUrl: "http://localhost:3000",
       uxMode: "nodejs",
-      tssLib: tssLib || tssLibDKLS,
+      supportedKeyTypes: [keyType],
       storage: testVariable.storage,
       manualSync: testVariable.manualSync,
     });
@@ -52,7 +59,12 @@ export const FactorManipulationTest = async (testVariable: FactorTestVariable) =
   };
 
   async function beforeTest() {
+    if (testVariable.resetAccount === false) {
+      log.debug("skipping reset account");
+      return ;
+    }
     const resetInstance = await newInstance();
+
     await criticalResetAccount(resetInstance);
     await resetInstance.logout();
   }
@@ -64,7 +76,7 @@ export const FactorManipulationTest = async (testVariable: FactorTestVariable) =
       const coreKitInstance = await newInstance();
       assert.equal(coreKitInstance.status, COREKIT_STATUS.LOGGED_IN);
 
-      if (coreKitInstance.supportsAccountIndex) {
+      if (keyType !== KeyType.ed25519) {
         coreKitInstance.setTssWalletIndex(1);
       }
       const tssPubKeys = getPubKeys(coreKitInstance, [0, 1, 99]);
@@ -81,7 +93,7 @@ export const FactorManipulationTest = async (testVariable: FactorTestVariable) =
         shareType: TssShareType.DEVICE,
       });
 
-      if (coreKitInstance.supportsAccountIndex) {
+      if (keyType!== KeyType.ed25519) {
         coreKitInstance.setTssWalletIndex(2);
       }
       const factorKey2 = await coreKitInstance.createFactor({
@@ -105,14 +117,14 @@ export const FactorManipulationTest = async (testVariable: FactorTestVariable) =
       // try inputFactor ( set as active factor )
 
       // delete factor
-      if (coreKitInstance.supportsAccountIndex) {
+      if (keyType!== KeyType.ed25519) {
         instance2.setTssWalletIndex(0);
       }
       const pt = Point.fromScalar(new BN(factorKey1, "hex"), factorKeyCurve);
       await instance2.deleteFactor(pt);
 
       // delete factor
-      if (coreKitInstance.supportsAccountIndex) {
+      if (keyType!== KeyType.ed25519) {
         instance2.setTssWalletIndex(1);
       }
       const pt2 = Point.fromScalar(new BN(factorKey2, "hex"), factorKeyCurve);
@@ -140,7 +152,7 @@ export const FactorManipulationTest = async (testVariable: FactorTestVariable) =
       const instance = await newInstance();
       assert.strictEqual(instance.status, COREKIT_STATUS.LOGGED_IN);
 
-      if (instance.supportsAccountIndex) {
+      if (keyType!== KeyType.ed25519) {
         instance.setTssWalletIndex(1);
       }
       const recoverFactor = await instance.enableMFA({});
@@ -181,6 +193,7 @@ const variable: FactorTestVariable[] = [
   { manualSync: false, storage: new AsyncMemoryStorage(), email: "testmail1015" },
 
   { manualSync: true, storage: new MemoryStorage(), email: "testmail1012ed25519", tssLib: tssLibFROST },
+  { manualSync: true, storage: new MemoryStorage(), email: randomId() , tssLib: tssLibFROST , resetAccount: false},
 ];
 
 variable.forEach(async (testVariable) => {
diff --git a/tests/gating.spec.ts b/tests/gating.spec.ts
index 1cb6868..a9a3491 100644
--- a/tests/gating.spec.ts
+++ b/tests/gating.spec.ts
@@ -6,6 +6,7 @@ import assert from "assert";
 
 import { COREKIT_STATUS, MemoryStorage, WEB3AUTH_NETWORK, WEB3AUTH_NETWORK_TYPE, Web3AuthMPCCoreKit } from "../src";
 import { criticalResetAccount, mockLogin } from "./setup";
+import { KeyType } from "@tkey/common-types";
 
 type TestVariable = {
   description: string;
@@ -47,12 +48,13 @@ const variable: TestVariable[] = [
 
 variable.forEach((testVariable) => {
   const { web3AuthNetwork, uxMode, manualSync, email, web3ClientID: web3AuthClientId, expectedErrorThrown } = testVariable;
+  const keyType = tssLib.keyType as KeyType;
   const coreKitInstance = new Web3AuthMPCCoreKit({
     web3AuthClientId,
     web3AuthNetwork,
     baseUrl: "http://localhost:3000",
     uxMode,
-    tssLib,
+    supportedKeyTypes: [keyType],
     storage: new MemoryStorage(),
     manualSync,
   });
diff --git a/tests/importRecovery.spec.ts b/tests/importRecovery.spec.ts
index 8d3bbc8..d78e012 100644
--- a/tests/importRecovery.spec.ts
+++ b/tests/importRecovery.spec.ts
@@ -1,21 +1,28 @@
 import assert from "node:assert";
-import test from "node:test";
+import test, { describe, it } from "node:test";
 
 import { tssLib as tssLibDKLS } from "@toruslabs/tss-dkls-lib";
 import { tssLib as tssLibFROST } from "@toruslabs/tss-frost-lib";
 
 import { AsyncStorage, MemoryStorage, TssLibType, TssShareType, WEB3AUTH_NETWORK } from "../src";
 import { bufferToElliptic, criticalResetAccount, newCoreKitLogInInstance } from "./setup";
+import { getKeyCurve } from "@toruslabs/torus.js";
+import { KeyType, Point } from "@tkey/common-types";
+import { MockStorageLayer } from "@tkey/storage-layer-torus";
 
 type ImportKeyTestVariable = {
   manualSync?: boolean;
   email: string;
   importKeyEmail: string;
   tssLib: TssLibType;
+  legacyFlag?: boolean;
 };
 
 const storageInstance = new MemoryStorage();
+
+// use mockStorageLayer, hence resetAccount is not required.
 export const ImportTest = async (testVariable: ImportKeyTestVariable) => {
+  const mockStorageLayer = new MockStorageLayer();
   async function newCoreKitInstance(email: string, importTssKey?: string) {
     return newCoreKitLogInInstance({
       network: WEB3AUTH_NETWORK.DEVNET,
@@ -24,27 +31,16 @@ export const ImportTest = async (testVariable: ImportKeyTestVariable) => {
       storageInstance,
       tssLib: testVariable.tssLib,
       importTssKey,
+      legacyFlag: testVariable.legacyFlag,
+      mockStorageLayer,
     });
   }
 
-  async function resetAccount(email: string) {
-    const kit = await newCoreKitInstance(email);
-    await criticalResetAccount(kit);
-    await kit.logout();
-    await new AsyncStorage(kit._storageKey, storageInstance).resetStore();
-  }
-
-  test(`import recover tss key : ${testVariable.manualSync}`, async function (t) {
-    const beforeTest = async () => {
-      await resetAccount(testVariable.email);
-      await resetAccount(testVariable.importKeyEmail);
-    };
-
-    await beforeTest();
-
-    await t.test("#recover Tss key using 2 factors key, import tss key to new oauth login", async function () {
+  describe(`import recover tss key manual sync: ${testVariable.manualSync}, testVariable: ${JSON.stringify(testVariable)}`, async function (t) {
+    it("#recover Tss key using 2 factors key, import tss key to new oauth login", async function () {
       const coreKitInstance = await newCoreKitInstance(testVariable.email);
 
+      const keyType = coreKitInstance.getSupportedCurveKeyTypes()[0];
       // Create 2 factors which will be used to recover tss key.
       const factorKeyDevice = await coreKitInstance.createFactor({
         shareType: TssShareType.DEVICE,
@@ -59,55 +55,56 @@ export const ImportTest = async (testVariable: ImportKeyTestVariable) => {
       }
 
       // Export key and logout.
-      const exportedTssKey1 = await coreKitInstance._UNSAFE_exportTssKey();
+      const exportedTssKey1 = await coreKitInstance._UNSAFE_exportTssKey(keyType);
+
+      const ed25519ImportSeed = (keyType === KeyType.ed25519)?  (await coreKitInstance._UNSAFE_exportTssEd25519Seed()).toString("hex") : undefined ;
       await coreKitInstance.logout();
 
+      // logout re-init storagelayer, reassign to mock is required
+      coreKitInstance.tKey.storageLayer = mockStorageLayer;
+
       // Recover key from any two factors.
-      const recoveredTssKey = await coreKitInstance._UNSAFE_recoverTssKey([factorKeyDevice, factorKeyRecovery]);
+      const recoveredTssKey = await coreKitInstance._UNSAFE_recoverTssKey([factorKeyDevice, factorKeyRecovery], keyType);
       assert.strictEqual(recoveredTssKey, exportedTssKey1);
 
+      // import for ed25519 need to be seed.
+      const importKey = ed25519ImportSeed ?? recoveredTssKey ;
+
       // Initialize new instance and import existing key.
-      const coreKitInstance2 = await newCoreKitInstance(testVariable.importKeyEmail, recoveredTssKey);
+      const coreKitInstance2 = await newCoreKitInstance(testVariable.importKeyEmail, importKey);
       if (testVariable.manualSync) {
         await coreKitInstance2.commitChanges();
       }
 
       // Export key.
-      const exportedTssKey = await coreKitInstance2._UNSAFE_exportTssKey();
+      const exportedTssKey = await coreKitInstance2._UNSAFE_exportTssKey(keyType);
       assert.strictEqual(exportedTssKey, recoveredTssKey);
 
       // Check exported key corresponds to pub key.
       const coreKitInstance3 = await newCoreKitInstance(testVariable.importKeyEmail);
-      const tssPubkey = bufferToElliptic(coreKitInstance3.getPubKey());
+      const tssPubkey = coreKitInstance3.getPubKeyPoint(keyType).toEllipticPoint(getKeyCurve(keyType));
 
-      const exportedTssKey3 = await coreKitInstance3._UNSAFE_exportTssKey();
-      const tssCurve = coreKitInstance3.tKey.tssCurve;
+      const exportedTssKey3 = await coreKitInstance3._UNSAFE_exportTssKey(keyType);
+      const tssCurve = getKeyCurve(keyType);
       const exportedPub = tssCurve.keyFromPrivate(exportedTssKey3).getPublic();
       assert(tssPubkey.eq(exportedPub));
 
       // Check exported key corresponds to pub key for account index > 0.
-      if (coreKitInstance3.supportsAccountIndex) {
+      if (keyType !== KeyType.ed25519) {
         coreKitInstance3.setTssWalletIndex(1);
-        const exportedTssKeyIndex1 = await coreKitInstance3._UNSAFE_exportTssKey();
+        const exportedTssKeyIndex1 = await coreKitInstance3._UNSAFE_exportTssKey(keyType);
         const exportedPubIndex1 = tssCurve.keyFromPrivate(exportedTssKeyIndex1).getPublic();
-        const tssPubKeyIndex1 = bufferToElliptic(coreKitInstance3.getPubKey());
+        const tssPubKeyIndex1 = bufferToElliptic(coreKitInstance3.getPubKey(keyType));
         assert(exportedPubIndex1.eq(tssPubKeyIndex1));
       }
     });
-
-    t.afterEach(function () {
-      return console.info("finished running recovery test");
-    });
-    t.after(function () {
-      return console.info("finished running recovery tests");
-    });
   });
 };
 
 const variable: ImportKeyTestVariable[] = [
   { manualSync: false, email: "emailexport", importKeyEmail: "emailimport", tssLib: tssLibDKLS },
   { manualSync: true, email: "emailexport", importKeyEmail: "emailimport", tssLib: tssLibDKLS },
-  { manualSync: false, email: "emailexport_ed25519", importKeyEmail: "emailimport_ed25519", tssLib: tssLibFROST },
+  // { manualSync: false, email: "emailexport_ed25519--1", importKeyEmail: "emailimport_ed25519--1", tssLib: tssLibFROST },
 ];
 
 variable.forEach(async (testVariable) => {
diff --git a/tests/login.spec.ts b/tests/login.spec.ts
index 33a45ef..69378cb 100644
--- a/tests/login.spec.ts
+++ b/tests/login.spec.ts
@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import test from "node:test";
 
-import { EllipticPoint } from "@tkey/common-types";
+import { EllipticPoint, KeyType } from "@tkey/common-types";
 import { UX_MODE_TYPE } from "@toruslabs/customauth";
 import { keccak256 } from "@toruslabs/metadata-helpers";
 import { tssLib } from "@toruslabs/tss-dkls-lib";
@@ -33,22 +33,22 @@ const checkLogin = async (coreKitInstance: Web3AuthMPCCoreKit, accountIndex = 0)
   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 keyType = coreKitInstance.getSupportedCurveKeyTypes()[0];
+  await coreKitInstance.getTssShare({ keyType, factorkey: new BN(factorkey.factorKey, "hex"), accountIndex });
 };
 
 const storageInstance = new MemoryStorage();
 
 variable.forEach((testVariable) => {
   const { web3AuthNetwork, uxMode, manualSync, email } = testVariable;
+  const keyType = tssLib.keyType as KeyType;
   const newCoreKitInstance = () =>
     new Web3AuthMPCCoreKit({
       web3AuthClientId: "torus-key-test",
       web3AuthNetwork,
       baseUrl: "http://localhost:3000",
       uxMode,
-      tssLib,
+      supportedKeyTypes: [keyType],
       storage: storageInstance,
       manualSync,
     });
@@ -65,7 +65,7 @@ variable.forEach((testVariable) => {
         web3AuthNetwork,
         baseUrl: "http://localhost:3000",
         uxMode,
-        tssLib,
+        supportedKeyTypes: [keyType],
         storage: storageInstance,
         manualSync,
       });
@@ -95,11 +95,9 @@ variable.forEach((testVariable) => {
       // get key details
       await checkLogin(coreKitInstance);
 
-      checkPubKey = bufferToElliptic(coreKitInstance.getPubKey());
+      checkPubKey = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       const factorkey = coreKitInstance.getCurrentFactorKey();
-      const { tssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"), {
-        threshold: 0,
-      });
+      const { tssShare } = await coreKitInstance.getTssShare({ keyType, factorkey: new BN(factorkey.factorKey, "hex") });
       checkTssShare = tssShare;
 
       if (manualSync) {
@@ -135,15 +133,16 @@ variable.forEach((testVariable) => {
 
       // get key details
       await checkLogin(coreKitInstance);
-      const newPubKey = bufferToElliptic(coreKitInstance.getPubKey());
+      const newPubKey = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       const factorkey = coreKitInstance.getCurrentFactorKey();
-      const { tssShare: newTssShare } = await coreKitInstance.tKey.getTSSShare(new BN(factorkey.factorKey, "hex"));
+      const { tssShare: newTssShare } = await coreKitInstance.getTssShare({ keyType, factorkey: new BN(factorkey.factorKey, "hex") });
       assert(checkPubKey.eq(newPubKey));
       assert(checkTssShare.eq(newTssShare));
     });
 
     await t.test("#able to sign", async function () {
       const coreKitInstance = newCoreKitInstance();
+      coreKitInstance.addTssLibs([tssLib])
       await coreKitInstance.init({ handleRedirectResult: false, rehydrate: false });
       const localToken = await mockLogin2(email);
       await coreKitInstance.loginWithJWT({
@@ -157,13 +156,13 @@ variable.forEach((testVariable) => {
       const secp256k1 = new EC("secp256k1");
 
       // Sign hash.
-      const signature = sigToRSV(await coreKitInstance.sign(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());
+      const publicKeyPoint = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       assert(pubkey.eq(publicKeyPoint));
 
       // Sign full message.
-      const signature2 = sigToRSV(await coreKitInstance.sign(msgBuffer));
+      const signature2 = sigToRSV(await coreKitInstance.sign_ECDSA_secp256k1(msgBuffer));
       const pubkey2 = secp256k1.recoverPubKey(msgHash, signature2, signature2.v) as EllipticPoint;
       assert(pubkey2.eq(publicKeyPoint));
     });
@@ -183,13 +182,14 @@ variable.forEach((testVariable) => {
       const secp256k1 = new EC("secp256k1");
       await coreKitInstance.setTssWalletIndex(0);
 
+      coreKitInstance.addTssLibs([tssLib])
       const msg = "hello world 1";
       const msgBuffer = Buffer.from(msg);
       const msgHash = keccak256(msgBuffer);
-      const signature1 = sigToRSV(await coreKitInstance.sign(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());
+      const publicKeyPoint0 = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       assert(pubkeyIndex0.eq(publicKeyPoint0));
 
       await coreKitInstance.setTssWalletIndex(1);
@@ -198,10 +198,10 @@ variable.forEach((testVariable) => {
       const msgBuffer1 = Buffer.from(msg1);
       const msgHash1 = keccak256(msgBuffer1);
 
-      const signature2 = sigToRSV(await coreKitInstance.sign(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());
+      const publicKeyPoint1 = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       assert(pubkeyIndex1.eq(publicKeyPoint1));
 
       await checkLogin(coreKitInstance, 1);
@@ -211,10 +211,10 @@ variable.forEach((testVariable) => {
       const msg2 = "hello world 3";
       const msgBuffer2 = Buffer.from(msg2);
       const msgHash2 = keccak256(msgBuffer2);
-      const signature3 = sigToRSV(await coreKitInstance.sign(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());
+      const publicKeyPoint2 = bufferToElliptic(coreKitInstance.getPubKey(keyType));
       assert(pubkeyIndex2.eq(publicKeyPoint2));
 
       await checkLogin(coreKitInstance, 2);
@@ -237,11 +237,11 @@ variable.forEach((testVariable) => {
       });
 
       coreKitInstance.setTssWalletIndex(0);
-      const pubkey3index0 = bufferToElliptic(coreKitInstance3.getPubKey());
+      const pubkey3index0 = bufferToElliptic(coreKitInstance3.getPubKey(keyType));
       coreKitInstance3.setTssWalletIndex(1);
-      const pubkey3index1 = bufferToElliptic(coreKitInstance3.getPubKey());
+      const pubkey3index1 = bufferToElliptic(coreKitInstance3.getPubKey(keyType));
       coreKitInstance3.setTssWalletIndex(2);
-      const pubkey3index2 = bufferToElliptic(coreKitInstance3.getPubKey());
+      const pubkey3index2 = bufferToElliptic(coreKitInstance3.getPubKey(keyType));
 
       assert(pubkeyIndex0.eq(pubkey3index0));
       assert(pubkeyIndex1.eq(pubkey3index1));
diff --git a/tests/multiCurveTest.spec.ts b/tests/multiCurveTest.spec.ts
new file mode 100644
index 0000000..a987382
--- /dev/null
+++ b/tests/multiCurveTest.spec.ts
@@ -0,0 +1,143 @@
+import { COREKIT_STATUS } from '../src/interfaces';
+import dklslib from "@toruslabs/tss-dkls-lib";
+import frostLib from "@toruslabs/tss-frost-lib";
+import frostBip340lib from "@toruslabs/tss-frost-lib-bip340";
+
+import { expect } from "chai";
+import { describe, it } from "node:test";
+import { makeBip340Signer, makeEd25519Signer, makeEthereumSigner, MemoryStorage, sigToRSV, WEB3AUTH_NETWORK, Web3AuthMPCCoreKit } from "src";
+import {  mockLogin2 } from "./setup";
+import { KeyType } from '@tkey/common-types';
+import { BN } from 'bn.js';
+import { MockStorageLayer  } from '@tkey/storage-layer-torus';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { ed25519 } from '@noble/curves/ed25519';
+import { bytesToHex, utf8ToBytes, bytesToNumberBE } from '@noble/curves/abstract/utils';
+import { keccak_256 } from '@noble/hashes/sha3';
+
+import { schnorr as bip340 } from '@noble/curves/secp256k1';
+
+
+const web3AuthNetwork = WEB3AUTH_NETWORK.DEVNET;
+const manualSync = false;
+const verifierId = "multicurvetest"
+
+const mockSL = new MockStorageLayer({
+    dataMap: {},
+    lockMap: {},
+});
+
+describe("multiCurveTest", () => {
+    const newCoreKitInstance = () =>
+        new Web3AuthMPCCoreKit({
+          web3AuthClientId: "torus-key-test",
+          web3AuthNetwork,
+          baseUrl: "http://localhost:3000",
+          uxMode: "nodejs",
+          supportedKeyTypes: [KeyType.secp256k1, KeyType.ed25519],
+          storage: new MemoryStorage(),
+          manualSync,
+        });
+    
+    
+    const testAllSigning = async (instance: Web3AuthMPCCoreKit) => {
+        const message = "message to sign";
+
+        const hash = keccak_256(message);
+        instance.addTssLibs([dklslib]);
+        const result = await instance.sign_ECDSA_secp256k1(Buffer.from(hash), {hashed: true})
+        const {r, s } = sigToRSV(result);
+
+        const validsecp256k1 = secp256k1.verify({
+            r: bytesToNumberBE(r),
+            s: bytesToNumberBE(s),
+        }, bytesToHex(hash), bytesToHex(instance.getPubKey(KeyType.secp256k1,  false)))
+        expect(validsecp256k1).eq(true);
+
+        instance.addTssLibs([frostBip340lib]);
+        const result2 = await instance.signBIP340( Buffer.from(utf8ToBytes(message)), {hashed: false})
+        
+        const validb340 = bip340.verify(bytesToHex(result2), bytesToHex(utf8ToBytes(message)), bytesToHex(instance.getPubKeyBip340()));
+        expect(validb340).eq(true);
+
+
+        instance.addTssLibs([frostLib]);
+        const result3 = await instance.signED25519(Buffer.from(message))
+        const valided25519 = ed25519.verify(bytesToHex(result3), bytesToHex(Buffer.from(message)), bytesToHex( new Uint8Array(instance.getPubKeyEd25519()) ) )
+        expect(valided25519).eq(true);
+
+
+        const ethSigner = makeEthereumSigner(instance)
+        const ethSignerPubKey = await ethSigner.getPublic();
+        const ethSignerResult = await ethSigner.sign(Buffer.from(hash)) 
+        const validsethSignerResult = secp256k1.verify({
+            r: bytesToNumberBE(ethSignerResult.r),
+            s: bytesToNumberBE(ethSignerResult.s),
+        }, bytesToHex(hash), "04"+bytesToHex(ethSignerPubKey));
+        expect(validsethSignerResult).eq(true);  
+
+
+        const bip340Signer = makeBip340Signer(instance)
+        const bip340SignerResult = await bip340Signer.sign(Buffer.from(utf8ToBytes(message)));
+
+
+        const validBip340SignerResult = bip340.verify(bip340SignerResult, bytesToHex(utf8ToBytes(message)), bytesToHex(instance.getPubKeyBip340()));
+        expect(validBip340SignerResult).eq(true);
+              
+        const ed25519Signer = makeEd25519Signer(instance)
+        const ed25519SignerResult = await ed25519Signer.sign(Buffer.from(utf8ToBytes(message)))
+        const validEd25519SignerResult = ed25519.verify(ed25519SignerResult, bytesToHex(Buffer.from(message)), bytesToHex( new Uint8Array(instance.getPubKeyEd25519()) ) )
+        expect(validEd25519SignerResult).eq(true);  
+
+    }
+
+    it("should able to initialize with multiple curve/ tsslib", async () => {
+        const instance = newCoreKitInstance();
+        await instance.init({ handleRedirectResult: false, rehydrate: false });
+        
+        // mock storage layer
+        instance.tKey.storageLayer = mockSL;
+
+
+        const { idToken, parsedToken } = await mockLogin2(verifierId);
+        
+        await instance.loginWithJWT({
+            verifier: "torus-test-health",
+            verifierId: parsedToken.email,
+            idToken,
+        });
+
+        expect(instance.status).eq("LOGGED_IN");
+
+        
+        await testAllSigning(instance);
+
+
+        const recoverFactor = await instance.enableMFA({})
+
+        await testAllSigning(instance);
+        
+
+        const instance2 = newCoreKitInstance();
+        await instance2.init({ handleRedirectResult: false, rehydrate: false });
+
+        // mock storage layer
+        instance2.tKey.storageLayer = mockSL;
+        
+        const { idToken: idToken2, parsedToken: parsedToken2 } = await mockLogin2(verifierId);
+        await instance2.loginWithJWT({
+            verifier: "torus-test-health",
+            verifierId: parsedToken2.email,
+            idToken: idToken2,
+        });
+
+        expect(instance2.status).eq(COREKIT_STATUS.REQUIRED_SHARE);
+
+        await instance2.inputFactorKey(new BN(recoverFactor, "hex"));
+        expect(instance2.status).eq(COREKIT_STATUS.LOGGED_IN);
+
+        await testAllSigning(instance2);
+
+    })
+
+});
\ No newline at end of file
diff --git a/tests/securityQuestion.spec.ts b/tests/securityQuestion.spec.ts
index 3f1d788..a926f91 100644
--- a/tests/securityQuestion.spec.ts
+++ b/tests/securityQuestion.spec.ts
@@ -16,6 +16,7 @@ import {
   Web3AuthMPCCoreKit,
 } from "../src";
 import { criticalResetAccount, mockLogin } from "./setup";
+import { KeyType } from "@tkey/common-types";
 
 type TestVariable = {
   web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
@@ -26,6 +27,8 @@ type TestVariable = {
 
 const storageInstance = new MemoryStorage();
 export const TssSecurityQuestionsTest = async (newInstance: () => Promise<Web3AuthMPCCoreKit>, testVariable: TestVariable) => {
+
+  const keyType = tssLib.keyType as KeyType;
   test(`#Tss Security Question - ${testVariable.manualSync} `, async function (t) {
     async function beforeTest() {
       const coreKitInstance = await newInstance();
@@ -63,7 +66,7 @@ export const TssSecurityQuestionsTest = async (newInstance: () => Promise<Web3Au
       // recover factor
       const factor = await securityQuestion.recoverFactor(instance, answer);
       // check factor
-      await instance.tKey.getTSSShare(new BN(factor, "hex"));
+      await instance.getTssShare({ keyType, factorkey: new BN(factor, "hex") });
       // check wrong answer
       await assert.rejects(() => securityQuestion.recoverFactor(instance, "wrong answer"));
 
@@ -77,26 +80,26 @@ export const TssSecurityQuestionsTest = async (newInstance: () => Promise<Web3Au
       // recover factor
       // check factor
       const newFactor = await securityQuestion.recoverFactor(instance, newAnswer);
-      await instance.tKey.getTSSShare(new BN(newFactor, "hex"));
-
+      await instance.getTssShare({ keyType, factorkey: new BN(newFactor, "hex") });
+ 
       instance.setTssWalletIndex(0);
 
       // recover factor
       // check factor
       const newFactor2 = await securityQuestion.recoverFactor(instance, newAnswer);
-      await instance.tKey.getTSSShare(new BN(newFactor, "hex"));
+      await instance.getTssShare({ keyType, factorkey: new BN(newFactor, "hex") });
 
       instance.setTssWalletIndex(2);
 
       // recover factor
       // check factor
       const newFactor3 = await securityQuestion.recoverFactor(instance, newAnswer);
-      await instance.tKey.getTSSShare(new BN(newFactor, "hex"));
+      await instance.getTssShare({ keyType, factorkey: new BN(newFactor, "hex") });
 
       assert.strictEqual(newFactor, newFactor2);
       assert.strictEqual(newFactor, newFactor3);
 
-      await assert.rejects(() => instance.tKey.getTSSShare(new BN(factor, "hex")));
+      await assert.rejects(() => instance.getTssShare({ keyType, factorkey: new BN(factor, "hex") }));
 
       // recover factor
       // check wrong answer
@@ -126,13 +129,14 @@ const variable: TestVariable[] = [
 const email = "testmail99";
 
 variable.forEach(async (testVariable) => {
+  const keyType = tssLib.keyType as KeyType;
   const newCoreKitLogInInstance = async () => {
     const instance = new Web3AuthMPCCoreKit({
       web3AuthClientId: "torus-key-test",
       web3AuthNetwork: WEB3AUTH_NETWORK.DEVNET,
       baseUrl: "http://localhost:3000",
       uxMode: "nodejs",
-      tssLib,
+      supportedKeyTypes: [keyType],
       storage: storageInstance,
       manualSync: testVariable.manualSync,
     });
diff --git a/tests/sessionTime.spec.ts b/tests/sessionTime.spec.ts
index f649fbd..a68fa57 100644
--- a/tests/sessionTime.spec.ts
+++ b/tests/sessionTime.spec.ts
@@ -6,6 +6,7 @@ import { tssLib } from "@toruslabs/tss-dkls-lib";
 
 import { COREKIT_STATUS, MemoryStorage, WEB3AUTH_NETWORK, WEB3AUTH_NETWORK_TYPE, Web3AuthMPCCoreKit } from "../src";
 import { criticalResetAccount, mockLogin } from "./setup";
+import { KeyType } from "@tkey/common-types";
 
 type TestVariable = {
   web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
@@ -70,11 +71,12 @@ variable.forEach(async (testVariable) => {
         web3AuthNetwork,
         baseUrl: "http://localhost:3000",
         uxMode,
-        tssLib,
+        supportedKeyTypes: [tssLib.keyType as KeyType],
         storage: new MemoryStorage(),
         manualSync,
         sessionTime,
         disableSessionManager,
+        legacyFlag: false,
       });
       if (coreKitInstance.status === COREKIT_STATUS.INITIALIZED) await criticalResetAccount(coreKitInstance);
     }
diff --git a/tests/setup.ts b/tests/setup.ts
index 8b6adc5..f6e6866 100644
--- a/tests/setup.ts
+++ b/tests/setup.ts
@@ -1,11 +1,11 @@
-import { EllipticPoint, secp256k1 } from "@tkey/common-types";
-import { tssLib } from "@toruslabs/tss-dkls-lib";
+import { EllipticPoint, KeyType, secp256k1 } from "@tkey/common-types";
 import BN from "bn.js";
 import jwt, { Algorithm } from "jsonwebtoken";
 import { tssLib as tssLibDKLS } from "@toruslabs/tss-dkls-lib";
 import { TorusKey } from "@toruslabs/torus.js";
 
 import { IAsyncStorage, IStorage, parseToken, TssLibType, WEB3AUTH_NETWORK_TYPE, Web3AuthMPCCoreKit } from "../src";
+import { MockStorageLayer } from "@tkey/storage-layer-torus";
 
 export const mockLogin2 = async (email: string) => {
   const req = new Request("https://li6lnimoyrwgn2iuqtgdwlrwvq0upwtr.lambda-url.eu-west-1.on.aws/", {
@@ -31,14 +31,10 @@ export const criticalResetAccount = async (coreKitInstance: Web3AuthMPCCoreKit):
     throw new Error("coreKitInstance is not set");
   }
 
-  if (coreKitInstance.tKey.secp256k1Key) {
-    await coreKitInstance.tKey.CRITICAL_deleteTkey();
-  } else {
-    await coreKitInstance.tKey.storageLayer.setMetadata({
-      privKey: new BN(coreKitInstance.state.postBoxKey!, "hex"),
-      input: { message: "KEY_NOT_FOUND" },
-    });
-  }
+  await coreKitInstance.tKey.storageLayer.setMetadata({
+    privKey: new BN(coreKitInstance.state.postBoxKey!, "hex"),
+    input: { message: "KEY_NOT_FOUND" },
+  });
 };
 
 const privateKey = "MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCCD7oLrcKae+jVZPGx52Cb/lKhdKxpXjl9eGNa1MlY57A==";
@@ -94,6 +90,9 @@ export const newCoreKitLogInInstance = async ({
   importTssKey,
   registerExistingSFAKey,
   login,
+  mockStorageLayer,
+  tssLib,
+  legacyFlag,
 }: {
   network: WEB3AUTH_NETWORK_TYPE;
   manualSync: boolean;
@@ -103,24 +102,36 @@ export const newCoreKitLogInInstance = async ({
   importTssKey?: string;
   registerExistingSFAKey?: boolean;
   login?: LoginFunc;
-}) => {
+  mockStorageLayer?: MockStorageLayer;
+  legacyFlag?: boolean;
+  }) => {
+  const localTsslib = tssLib ?? tssLibDKLS;
+  
   const instance = new Web3AuthMPCCoreKit({
     web3AuthClientId: "torus-key-test",
     web3AuthNetwork: network,
     baseUrl: "http://localhost:3000",
     uxMode: "nodejs",
-    tssLib: tssLib || tssLibDKLS,
+    supportedKeyTypes: [localTsslib.keyType as KeyType],
     storage: storageInstance,
     manualSync,
+    legacyFlag,
   });
+  instance.addTssLibs([localTsslib])
 
   const { idToken, parsedToken } = login ? await login(email) : await mockLogin(email);
   await instance.init();
+
+  if (mockStorageLayer) {
+    instance.tKey.storageLayer = mockStorageLayer
+  }
+
+  const finalImportKey = importTssKey ? { [localTsslib.keyType]: importTssKey } : undefined;
   await instance.loginWithJWT({
     verifier: "torus-test-health",
     verifierId: parsedToken.email,
     idToken,
-    importTssKey,
+    importTssKey: finalImportKey,
     registerExistingSFAKey
   });
 
@@ -133,6 +144,9 @@ export const loginWithSFA = async ({
   email,
   storageInstance,
   login,
+  tssLib,
+  legacyFlag,
+  mockStorageLayer,
 }: {
   network: WEB3AUTH_NETWORK_TYPE;
   manualSync: boolean;
@@ -140,19 +154,31 @@ export const loginWithSFA = async ({
   storageInstance: IStorage | IAsyncStorage;
   tssLib?: TssLibType;
   login?: LoginFunc;
-}): Promise<TorusKey> => {
+  legacyFlag?: boolean;
+  mockStorageLayer?: MockStorageLayer;
+  }): Promise<TorusKey> => {
+  
+  const localTssLib = tssLib ?? tssLibDKLS
+  
   const instance = new Web3AuthMPCCoreKit({
     web3AuthClientId: "torus-key-test",
     web3AuthNetwork: network,
     baseUrl: "http://localhost:3000",
     uxMode: "nodejs",
-    tssLib: tssLib || tssLibDKLS,
+    supportedKeyTypes: [localTssLib.keyType as KeyType],
     storage: storageInstance,
     manualSync,
+    legacyFlag,
   });
 
   const { idToken, parsedToken } = login ? await login(email) : await mockLogin(email);
   await instance.init();
+
+  // mock storate layer
+  if (mockStorageLayer) {
+    instance.tKey.storageLayer = mockStorageLayer
+  }
+
   const nodeDetails = await instance.torusSp.customAuthInstance.nodeDetailManager.getNodeDetails({
     verifier: "torus-test-health",
     verifierId: parsedToken.email,
@@ -188,7 +214,7 @@ export function bufferToElliptic(p: Buffer, ec = secp256k1): EllipticPoint {
 
 
 export function generateRandomEmail(): string {
-  const username = stringGen(10); 
+  const username = stringGen(100); 
   const domain = stringGen(5); 
   const tld = stringGen(3);     
   return `${username}@${domain}.${tld}`;
diff --git a/tests/sfaImport.spec.ts b/tests/sfaImport.spec.ts
index bfd2ec9..d37ec97 100644
--- a/tests/sfaImport.spec.ts
+++ b/tests/sfaImport.spec.ts
@@ -1,31 +1,35 @@
 import assert from "node:assert";
-import test from "node:test";
+import test, { after, before, describe, it } from "node:test";
 
 import { tssLib as tssLibDKLS } from "@toruslabs/tss-dkls-lib";
 import { tssLib as tssLibFROST } from "@toruslabs/tss-frost-lib";
 
 import { AsyncStorage, MemoryStorage, TssLibType, TssShareType, WEB3AUTH_NETWORK } from "../src";
 import { criticalResetAccount, generateRandomEmail, loginWithSFA, newCoreKitLogInInstance } from "./setup";
+import { KeyType } from "@tkey/common-types";
 
 type ImportKeyTestVariable = {
   manualSync?: boolean;
   email: string;
   tssLib: TssLibType;
+  legacyFlag: boolean;
 };
 
 const storageInstance = new MemoryStorage();
 export const ImportSFATest = async (testVariable: ImportKeyTestVariable) => {
   async function newCoreKitInstance(email: string) {
-    return newCoreKitLogInInstance({
+    const instance = await newCoreKitLogInInstance({
       network: WEB3AUTH_NETWORK.DEVNET,
       manualSync: testVariable.manualSync,
       email: email,
       storageInstance,
       tssLib: testVariable.tssLib,
       registerExistingSFAKey: true,
+      legacyFlag: testVariable.legacyFlag,
     });
+    return instance;
   }
-
+  
   async function resetAccount(email: string) {
     const kit = await newCoreKitInstance(email);
     await criticalResetAccount(kit);
@@ -33,17 +37,24 @@ export const ImportSFATest = async (testVariable: ImportKeyTestVariable) => {
     await new AsyncStorage(kit._storageKey, storageInstance).resetStore();
   }
 
-  test(`import sfa key and recover tss key : ${testVariable.manualSync}`, async function (t) {
-    const afterTest = async () => {
-        await resetAccount(testVariable.email);
-      };
-    await t.test("#recover Tss key using 2 factors key, import tss key to new oauth login", async function () {
+  describe(`import sfa key and recover tss key manualSync: ${testVariable.manualSync} siging lib ${testVariable.tssLib.sigType}`, async function (t) {
+    const keyType = testVariable.tssLib.keyType as KeyType;
+
+    after(async () => {
+      await resetAccount(testVariable.email);
+    });
+
+    it("#recover Tss key using 2 factors key, import tss key to new oauth login", async function () {
       const sfaResult = await loginWithSFA({
         network: WEB3AUTH_NETWORK.DEVNET,
         manualSync: testVariable.manualSync,
         email: testVariable.email,
+        legacyFlag: testVariable.legacyFlag,
         storageInstance,
+        tssLib: testVariable.tssLib,
+        
       });
+
       const coreKitInstance = await newCoreKitInstance(testVariable.email);
 
       // Create 2 factors which will be used to recover tss key.
@@ -60,45 +71,48 @@ export const ImportSFATest = async (testVariable: ImportKeyTestVariable) => {
       }
 
       // Export key and logout.
-      const exportedTssKey1 = await coreKitInstance._UNSAFE_exportTssKey();
-      await coreKitInstance.logout();
+      const exportedTssKey1 = await coreKitInstance._UNSAFE_exportTssKey(keyType);
+      let exportEd25519Seed : string | undefined = undefined
+      if (keyType === KeyType.ed25519) { 
+        const edResult = await coreKitInstance._UNSAFE_exportTssEd25519Seed()
+        exportEd25519Seed = edResult.toString("hex")
+      }
 
       // Recover key from any two factors.
-      const recoveredTssKey = await coreKitInstance._UNSAFE_recoverTssKey([factorKeyDevice, factorKeyRecovery]);
+      const recoveredTssKey = await coreKitInstance._UNSAFE_recoverTssKey([factorKeyDevice, factorKeyRecovery], keyType);
       assert.strictEqual(recoveredTssKey, exportedTssKey1);
-      assert.strictEqual(sfaResult.finalKeyData.privKey,recoveredTssKey);
-    // sfa key should be empty after import to mpc
-    const sfaResult2 = await loginWithSFA({
-      network: WEB3AUTH_NETWORK.DEVNET,
-      manualSync: testVariable.manualSync,
-      email: testVariable.email,
-      storageInstance,
-    });
-    assert.strictEqual(sfaResult2.finalKeyData.privKey, "");
-        
-    const coreKitInstance2 = await newCoreKitInstance(testVariable.email);
-    const tssKey2 = await coreKitInstance2._UNSAFE_exportTssKey();
-    // core kit should have same sfa key which was imported before
-    assert.strictEqual(tssKey2, exportedTssKey1);
-    assert.strictEqual(sfaResult.finalKeyData.privKey, tssKey2);
-
-
-    });
-
-    await afterTest();
-    t.afterEach(function () {
-      return console.info("finished running recovery test");
-    });
-    t.after(function () {
-      return console.info("finished running recovery tests");
+      assert.strictEqual(sfaResult.finalKeyData.privKey, exportEd25519Seed ?? exportedTssKey1);
+      // sfa key should be empty after import to mpc
+      const sfaResult2 = await loginWithSFA({
+        network: WEB3AUTH_NETWORK.DEVNET,
+        manualSync: testVariable.manualSync,
+        email: testVariable.email,
+        storageInstance,
+        tssLib: testVariable.tssLib,
+        legacyFlag: testVariable.legacyFlag,
+      });
+      assert.strictEqual(sfaResult2.finalKeyData.privKey, "");
+          
+      const coreKitInstance2 = await newCoreKitInstance(testVariable.email);
+
+      const tssKey2 = await coreKitInstance2._UNSAFE_exportTssKey(keyType);
+      
+      exportEd25519Seed = undefined
+      if (keyType === KeyType.ed25519) { 
+        const edResult = await coreKitInstance2._UNSAFE_exportTssEd25519Seed()
+        exportEd25519Seed = edResult.toString("hex")
+      } 
+      // core kit should have same sfa key which was imported before
+      assert.strictEqual(tssKey2, exportedTssKey1);
+      assert.strictEqual(sfaResult.finalKeyData.privKey, exportEd25519Seed ?? tssKey2);
     });
   });
 };
 
 const variable: ImportKeyTestVariable[] = [
-  { manualSync: false, email: generateRandomEmail(), tssLib: tssLibDKLS },
-  { manualSync: true, email: generateRandomEmail(), tssLib: tssLibDKLS },
-  { manualSync: false, email: generateRandomEmail(), tssLib: tssLibFROST },
+  { manualSync: false, email: generateRandomEmail(), tssLib: tssLibDKLS, legacyFlag: false },
+  { manualSync: true, email: generateRandomEmail(), tssLib: tssLibDKLS , legacyFlag: false},
+  { manualSync: false, email: generateRandomEmail(), tssLib: tssLibFROST, legacyFlag: true },
 ];
 
 variable.forEach(async (testVariable) => {