adding more tests

.env

@@ -0,0 +1,8 @@
+MNEMONIC="vintage reflect pass input polar enlist giggle judge render position also document"
+PIN="696969"
+PRIVATE_KEY_EVM="0x7a9633b8103fec11c9e855a6b6c8c072e9af311a69b92ab0ad8186b1fb57371f"
+PRIVATE_KEY_BTC= "KzQfcdjDRUwpVmKKev6k2aAeJFJ359Ht9Umxdg77MTzf2E3bzGsC"
+EVM_ADDRESS_1='0x6bbc122fa843f3ed30d23f8cdd9a430d1f898d07'
+EVM_ADDRESS_2="0xbae949ddb4d8ac763c12f206db842b9b2d49a464"
+BITCOIN_ADDRESS_1="bc1qugw5q5yrzw86wnw3lgldm8en0c736k4hvceuzl"
+BITCOIN_ADDRESS_2="bc1qta5f6q32cphxt5rck3kuspukac7keqvxyuk4cl"

package.json

@@ -57,7 +57,7 @@
     "@getsafle/vault-bitcoin-controller": "^2.0.7",
     "@getsafle/vault-bsc-controller": "^1.2.4",
     "@getsafle/vault-eth-controller": "^1.4.6",
-    "@getsafle/vault-evm-controller": "^1.0.0",
+    "@getsafle/vault-evm-controller": "^1.0.1",
     "@getsafle/vault-mantle-controller": "^1.0.1",
     "@getsafle/vault-optimism-controller": "^1.0.8",
     "@getsafle/vault-polygon-controller": "^1.2.8",
@@ -69,6 +69,7 @@
     "bip39": "^3.0.4",
     "crypto": "^1.0.1",
     "crypto-js": "^4.1.1",
+    "dotenv": "^16.4.5",
     "eth-sig-util": "^3.0.1",
     "ethers": "^5.5.3",
     "jest": "^29.4.3",

src/lib/keyring.js

@@ -623,70 +623,99 @@ class Keyring {
     }
 
     const { privateKey, isImported } = response;
-
     if (isImported) {
-      const web3 = new Web3(new Web3.providers.HttpProvider(rpcUrl));
-
-      if (this.chain === "ethereum") {
-        const signedMessage = await this.keyringInstance.sign(
-          data,
-          privateKey,
-          web3
+      if (
+        Chains.evmChains.hasOwnProperty(this.chain) ||
+        this.chain === "ethereum"
+      ) {
+        const signedMsg = await this.keyringInstance.customSignTypedMessage(
+          "0x" + privateKey,
+          data
         );
 
-        return { response: signedMessage.message };
+        return { response: signedMsg };
       }
+      return { error: ERROR_MESSAGE.UNSUPPORTED_NON_EVM_FUNCTIONALITY };
+    }
 
-      if (Chains.evmChains.hasOwnProperty(this.chain)) {
-        const keyringInstance = await helper.getCoinInstance(this.chain);
+    const accounts = await this.getAccounts();
 
-        const signedMessage = await keyringInstance.sign(
-          data,
-          privateKey,
-          web3
-        );
+    if (accounts.response.filter((e) => e.address === address).length < 1) {
+      return { error: ERROR_MESSAGE.NONEXISTENT_KEYRING_ACCOUNT };
+    }
 
-        return { response: signedMessage.message };
-      }
+    if (
+      Chains.evmChains.hasOwnProperty(this.chain) ||
+      this.chain === "ethereum"
+    ) {
+      const msgParams = { from: address, data: data };
 
-      if (Chains?.[this.chain]) {
-        const { signedMessage } = await this[this.chain].signTypedMessage(
-          data,
-          address,
-          privateKey
-        );
-        return { response: signedMessage };
-      }
+      const signedMsg = await this.keyringInstance.signTypedMessage(msgParams);
 
-      return { error: ERROR_MESSAGE.UNSUPPORTED_NON_EVM_FUNCTIONALITY };
-    } else {
-      const accounts = await this.getAccounts();
+      return { response: signedMsg };
+    }
 
-      if (accounts.response.filter((e) => e.address === address).length < 1) {
-        return { error: ERROR_MESSAGE.NONEXISTENT_KEYRING_ACCOUNT };
-      }
+    const { signedMessage } = await this[this.chain].signTypedMessage(
+      data,
+      address
+    );
 
-      if (
-        Chains.evmChains.hasOwnProperty(this.chain) ||
-        this.chain === "ethereum"
-      ) {
-        const msgParams = { from: address, data: data };
+    return { response: signedMessage };
+  }
+  async personalSign(address, data, pin, encryptionKey, rpcUrl = "") {
+    if (
+      typeof pin != "string" ||
+      pin.match(/^[0-9]+$/) === null ||
+      pin < 0 ||
+      pin.length != 6
+    ) {
+      return { error: ERROR_MESSAGE.INCORRECT_PIN_TYPE };
+    }
 
-        const signedMsg = await this.keyringInstance.signTypedMessage(
-          msgParams
-        );
+    const res = await this.validatePin(pin);
 
-        return { response: signedMsg };
-      }
+    if (res.response == false || res.error) {
+      return { error: ERROR_MESSAGE.INCORRECT_PIN };
+    }
 
-      const { signedMessage } = await this[this.chain].signTypedMessage(
-        data,
-        address
+    const err = helper.validateEncryptionKey(
+      this.vault,
+      JSON.stringify(encryptionKey)
+    );
+
+    if (err.error) {
+      return { error: err.error };
+    }
+
+    const { error, response } = await this.exportPrivateKey(address, pin);
+
+    if (error) {
+      return { error };
+    }
+
+    const { privateKey, isImported } = response;
+
+    const accounts = await this.getAccounts();
+
+    if (accounts.response.filter((e) => e.address === address).length < 1) {
+      return { error: ERROR_MESSAGE.NONEXISTENT_KEYRING_ACCOUNT };
+    }
+
+    if (
+      Chains.evmChains.hasOwnProperty(this.chain) ||
+      this.chain === "ethereum"
+    ) {
+      const signedMsg = await this.keyringInstance.customPersonalSign(
+        "0x" + privateKey,
+        data
       );
 
-      return { response: signedMessage };
+      return { response: signedMsg };
+    } else {
+      return { error: ERROR_MESSAGE.UNSUPPORTED_NON_EVM_FUNCTIONALITY };
     }
   }
+
   async signTransaction(rawTx, pin, rpcUrl) {
     if (
       typeof pin != "string" ||
@@ -716,14 +745,13 @@ class Keyring {
       if (isImported) {
         const signedTransaction = await this.keyringInstance.signTransaction(
           rawTx,
-          web3,
           privateKey
         );
         return { response: signedTransaction };
       } else {
         const signedTx = await this.keyringInstance.signTransaction(
           rawTx,
-          web3
+          privateKey
         );
         return { response: signedTx };
       }
@@ -1178,7 +1206,42 @@ class Keyring {
         });
 
         if (isDuplicateAddress) {
-          return { error: ERROR_MESSAGE.ADDRESS_ALREADY_PRESENT };
+          try {
+            Object.keys(this.decryptedVault)
+              .slice(0, -1)
+              .forEach((chain) => {
+                this.decryptedVault[chain]?.public?.forEach(
+                  (account, index) => {
+                    if (account.address === address && account.isDeleted) {
+                      this.decryptedVault[chain].public[
+                        index
+                      ].isDeleted = false;
+                    }
+                  }
+                );
+              });
+
+            const vault = await helper.cryptography(
+              JSON.stringify(this.decryptedVault),
+              JSON.stringify(encryptionKey),
+              "encryption"
+            );
+
+            this.vault = vault;
+
+            this.logs.getState().logs.push({
+              timestamp: Date.now(),
+              action: "import-wallet",
+              vault: this.vault,
+              chain: this.chain,
+              address,
+            });
+
+            return { response: { vault, address } };
+          } catch (error) {
+            console.error("Error processing duplicate address:", error);
+            throw error; // or handle it as appropriate for your application
+          }
         }
       }