sign typed message and updating public rpcs

.gitignore

@@ -41,7 +41,7 @@ Thumbs.db
 *.app
 *.exe
 *.war
-
+.env
 # Large media files
 *.mp4
 *.tiff

CHANGELOG.md

@@ -670,7 +670,9 @@
 - Update BEVM controller version
 - Fixed validatePin function for tests
 
-### 2.9.1 (2024-09-23)
+### 2.9.2 (2024-09-23)
 
 -Integrated vault-evm-controller
 -Resolved issue for unarchival of a wallet
+-Adding test for bitcoin
+-Adding sensitive info in env github pipeline

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getsafle/safle-vault",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "Safle Vault is a non-custodial, flexible and highly available crypto wallet which can be used to access dapps, send/receive crypto and store identity. Vault SDK is used to manage the vault and provide methods to generate vault, add new accounts, update the state and also enable the user to perform several vault related operations.",
   "main": "src/index.js",
   "scripts": {
@@ -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",
@@ -67,7 +67,10 @@
     "@getsafle/vault-stacks-controller": "^1.0.5",
     "@getsafle/vault-velas-controller": "^1.3.1",
     "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",
     "limiter": "^2.1.0",

src/lib/keyring.js

@@ -591,6 +591,130 @@ class Keyring {
       return { response: signedMessage };
     }
   }
+  async signTypedMessage(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 res = await this.validatePin(pin);
+
+    if (res.response == false || res.error) {
+      return { error: ERROR_MESSAGE.INCORRECT_PIN };
+    }
+
+    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;
+    if (isImported) {
+      if (
+        Chains.evmChains.hasOwnProperty(this.chain) ||
+        this.chain === "ethereum"
+      ) {
+        const signedMsg = await this.keyringInstance.customSignTypedMessage(
+          "0x" + privateKey,
+          data
+        );
+
+        return { response: signedMsg };
+      }
+      return { error: ERROR_MESSAGE.UNSUPPORTED_NON_EVM_FUNCTIONALITY };
+    }
+
+    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 msgParams = { from: address, data: data };
+
+      const signedMsg = await this.keyringInstance.signTypedMessage(msgParams);
+
+      return { response: signedMsg };
+    }
+
+    const { signedMessage } = await this[this.chain].signTypedMessage(
+      data,
+      address
+    );
+
+    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 res = await this.validatePin(pin);
+
+    if (res.response == false || res.error) {
+      return { error: ERROR_MESSAGE.INCORRECT_PIN };
+    }
+
+    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: signedMsg };
+    } else {
+      return { error: ERROR_MESSAGE.UNSUPPORTED_NON_EVM_FUNCTIONALITY };
+    }
+  }
 
   async signTransaction(rawTx, pin, rpcUrl) {
     if (
@@ -621,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 };
       }
@@ -1083,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
+          }
         }
       }