@metamask/eth-hd-keyring 4.0.2 → 5.0.1

package/test/index.js

@@ -5,8 +5,24 @@ const {
   recoverTypedSignature,
   signTypedData,
   SignTypedDataVersion,
+  encrypt,
 } = require('@metamask/eth-sig-util');
-const ethUtil = require('ethereumjs-util');
+const { wordlist } = require('@metamask/scure-bip39/dist/wordlists/english');
+const oldMMForkBIP39 = require('@metamask/bip39');
+const {
+  isValidAddress,
+  bufferToHex,
+  toBuffer,
+  ecrecover,
+  pubToAddress,
+} = require('@ethereumjs/util');
+const {
+  TransactionFactory,
+  Transaction: EthereumTx,
+} = require('@ethereumjs/tx');
+
+const OldHdKeyring = require('@metamask/eth-hd-keyring');
+const { keccak256 } = require('ethereum-cryptography/keccak');
 const HdKeyring = require('..');
 
 // Sample account:
@@ -18,12 +34,40 @@ const sampleMnemonic =
 const firstAcct = '0x1c96099350f13d558464ec79b9be4445aa0ef579';
 const secondAcct = '0x1b00aed43a693f3a957f9feb5cc08afa031e37a0';
 
+const notKeyringAddress = '0xbD20F6F5F1616947a39E11926E78ec94817B3931';
+
 describe('hd-keyring', () => {
   let keyring;
   beforeEach(() => {
     keyring = new HdKeyring();
   });
 
+  describe('compare old bip39 implementation with new', () => {
+    it('should derive the same accounts from the same mnemonics', async () => {
+      const mnemonics = [];
+      for (let i = 0; i < 99; i++) {
+        mnemonics.push(oldMMForkBIP39.generateMnemonic());
+      }
+
+      await Promise.all(
+        mnemonics.map(async (mnemonic) => {
+          const newHDKeyring = new HdKeyring({ mnemonic, numberOfAccounts: 3 });
+          const oldHDKeyring = new OldHdKeyring({
+            mnemonic,
+            numberOfAccounts: 3,
+          });
+          const newAccounts = await newHDKeyring.getAccounts();
+          const oldAccounts = await oldHDKeyring.getAccounts();
+          await expect(newAccounts[0]).toStrictEqual(oldAccounts[0]);
+
+          await expect(newAccounts[1]).toStrictEqual(oldAccounts[1]);
+
+          await expect(newAccounts[2]).toStrictEqual(oldAccounts[2]);
+        }),
+      );
+    });
+  });
+
   describe('constructor', () => {
     it('constructs with a typeof string mnemonic', async () => {
       keyring = new HdKeyring({
@@ -36,9 +80,9 @@ describe('hd-keyring', () => {
       expect(accounts[1]).toStrictEqual(secondAcct);
     });
 
-    it('constructs with a typeof array mnemonic', async () => {
+    it('constructs with a typeof buffer mnemonic', async () => {
       keyring = new HdKeyring({
-        mnemonic: Array.from(Buffer.from(sampleMnemonic, 'utf8').values()),
+        mnemonic: Buffer.from(sampleMnemonic, 'utf8'),
         numberOfAccounts: 2,
       });
 
@@ -47,9 +91,15 @@ describe('hd-keyring', () => {
       expect(accounts[1]).toStrictEqual(secondAcct);
     });
 
-    it('constructs with a typeof buffer mnemonic', async () => {
+    it('constructs with a typeof Uint8Array mnemonic', async () => {
+      const indices = sampleMnemonic
+        .split(' ')
+        .map((word) => wordlist.indexOf(word));
+      const uInt8ArrayOfMnemonic = new Uint8Array(
+        new Uint16Array(indices).buffer,
+      );
       keyring = new HdKeyring({
-        mnemonic: Buffer.from(sampleMnemonic, 'utf8'),
+        mnemonic: uInt8ArrayOfMnemonic,
         numberOfAccounts: 2,
       });
 
@@ -132,18 +182,34 @@ describe('hd-keyring', () => {
   });
 
   describe('#serialize mnemonic.', () => {
-    it('serializes mnemonic stored as a buffer in a class variable into a buffer array and does not add accounts', async () => {
-      keyring.generateRandomMnemonic();
+    it('serializes mnemonic stored as a buffer to a Uint8Array', async () => {
+      keyring.mnemonic = oldMMForkBIP39.generateMnemonic();
+      const mnemonicAsUint8Array = keyring._stringToUint8Array(
+        keyring.mnemonic.toString(),
+      );
       const output = await keyring.serialize();
       expect(output.numberOfAccounts).toBe(0);
-      expect(Array.isArray(output.mnemonic)).toBe(true);
+      expect(output.mnemonic).toStrictEqual(mnemonicAsUint8Array);
+    });
+
+    it('serializes keyring data with mnemonic stored as a Uint8Array', async () => {
+      keyring.generateRandomMnemonic();
+      const { mnemonic } = keyring;
+      const hdpath = keyring.hdPath;
+      keyring.addAccounts(1);
+      const output = await keyring.serialize();
+      expect(output.numberOfAccounts).toBe(1);
+      expect(output.hdPath).toStrictEqual(hdpath);
+      expect(output.mnemonic).toStrictEqual(mnemonic);
     });
 
-    it('serializes mnemonic stored as a string in a class variable into a buffer array and does not add accounts', async () => {
+    it('serializes mnemonic stored as a string', async () => {
       keyring.mnemonic = sampleMnemonic;
       const output = await keyring.serialize();
       expect(output.numberOfAccounts).toBe(0);
-      expect(Array.isArray(output.mnemonic)).toBe(true);
+      expect(output.mnemonic).toStrictEqual(
+        keyring._stringToUint8Array(sampleMnemonic),
+      );
     });
   });
 
@@ -153,14 +219,16 @@ describe('hd-keyring', () => {
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
-      expect(keyring.wallets).toHaveLength(1);
+      const accountsFirstCheck = await keyring.getAccounts();
+
+      expect(accountsFirstCheck).toHaveLength(1);
       await keyring.addAccounts(1);
-      const accounts = await keyring.getAccounts();
-      expect(accounts[0]).toStrictEqual(firstAcct);
-      expect(accounts[1]).toStrictEqual(secondAcct);
-      expect(accounts).toHaveLength(2);
+      const accountsSecondCheck = await keyring.getAccounts();
+      expect(accountsSecondCheck[0]).toStrictEqual(firstAcct);
+      expect(accountsSecondCheck[1]).toStrictEqual(secondAcct);
+      expect(accountsSecondCheck).toHaveLength(2);
       const serialized = await keyring.serialize();
-      expect(Buffer.from(serialized.mnemonic).toString()).toStrictEqual(
+      expect(keyring._uint8ArrayToString(serialized.mnemonic)).toStrictEqual(
         sampleMnemonic,
       );
     });
@@ -171,7 +239,8 @@ describe('hd-keyring', () => {
       it('creates a single wallet', async () => {
         keyring.generateRandomMnemonic();
         await keyring.addAccounts();
-        expect(keyring.wallets).toHaveLength(1);
+        const accounts = await keyring.getAccounts();
+        expect(accounts).toHaveLength(1);
       });
 
       it('throws an error when no SRP has been generated yet', async () => {
@@ -185,28 +254,9 @@ describe('hd-keyring', () => {
       it('creates that number of wallets', async () => {
         keyring.generateRandomMnemonic();
         await keyring.addAccounts(3);
-        expect(keyring.wallets).toHaveLength(3);
-      });
-    });
-  });
-
-  describe('#getAccounts', () => {
-    it('calls getAddress on each wallet', async () => {
-      // Push a mock wallet
-      const desiredOutput = 'foo';
-      keyring.wallets.push({
-        getAddress() {
-          return {
-            toString() {
-              return desiredOutput;
-            },
-          };
-        },
+        const accounts = await keyring.getAccounts();
+        expect(accounts).toHaveLength(3);
       });
-
-      const output = await keyring.getAccounts();
-      expect(output[0]).toBe(`0x${desiredOutput}`);
-      expect(output).toHaveLength(1);
     });
   });
 
@@ -270,7 +320,9 @@ describe('hd-keyring', () => {
       await keyring.addAccounts(1);
       const addresses = await keyring.getAccounts();
       const address = addresses[0];
-      const signature = await keyring.signTypedData_v1(address, typedData);
+      const signature = await keyring.signTypedData(address, typedData, {
+        version: SignTypedDataVersion.V1,
+      });
       const restored = recoverTypedSignature({
         data: typedData,
         signature,
@@ -297,7 +349,9 @@ describe('hd-keyring', () => {
       });
       const addresses = await keyring.getAccounts();
       const address = addresses[0];
-      const signature = await keyring.signTypedData_v3(address, typedData);
+      const signature = await keyring.signTypedData(address, typedData, {
+        version: SignTypedDataVersion.V3,
+      });
       const restored = recoverTypedSignature({
         data: typedData,
         signature,
@@ -351,7 +405,9 @@ describe('hd-keyring', () => {
       await keyring.addAccounts(1);
       const addresses = await keyring.getAccounts();
       const address = addresses[0];
-      const signature = await keyring.signTypedData_v3(address, typedData);
+      const signature = await keyring.signTypedData(address, typedData, {
+        version: SignTypedDataVersion.V3,
+      });
       const restored = recoverTypedSignature({
         data: typedData,
         signature,
@@ -423,129 +479,453 @@ describe('hd-keyring', () => {
   })
   */
 
-  describe('getAppKeyAddress', () => {
-    it('should return a public address custom to the provided app key origin', async () => {
+  describe('signing methods withAppKeyOrigin option', () => {
+    it('should signPersonalMessage with the expected key when passed a withAppKeyOrigin', async () => {
       const address = firstAcct;
+      const message = '0x68656c6c6f20776f726c64';
 
-      keyring = new HdKeyring({
+      const privateKey = Buffer.from(
+        '8e82d2d74c50e5c8460f771d38a560ebe1151a9134c65a7e92b28ad0cfae7151',
+        'hex',
+      );
+      const expectedSig = personalSign({ privateKey, data: message });
+
+      await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
-      const appKeyAddress = await keyring.getAppKeyAddress(
-        address,
-        'someapp.origin.io',
+      const sig = await keyring.signPersonalMessage(address, message, {
+        withAppKeyOrigin: 'someapp.origin.io',
+      });
+
+      expect(sig).toStrictEqual(expectedSig);
+    });
+
+    it('should signTypedData with the expected key when passed a withAppKeyOrigin', async () => {
+      const address = firstAcct;
+      const typedData = {
+        types: {
+          EIP712Domain: [],
+        },
+        domain: {},
+        primaryType: 'EIP712Domain',
+        message: {},
+      };
+
+      const privateKey = Buffer.from(
+        '8e82d2d74c50e5c8460f771d38a560ebe1151a9134c65a7e92b28ad0cfae7151',
+        'hex',
       );
+      const expectedSig = signTypedData({
+        privateKey,
+        data: typedData,
+        version: SignTypedDataVersion.V3,
+      });
 
-      expect(address).not.toBe(appKeyAddress);
-      expect(ethUtil.isValidAddress(appKeyAddress)).toBe(true);
+      await keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
 
-      const accounts = await keyring.getAccounts();
-      expect(accounts[0]).toStrictEqual(firstAcct);
+      const sig = await keyring.signTypedData(address, typedData, {
+        withAppKeyOrigin: 'someapp.origin.io',
+        version: SignTypedDataVersion.V3,
+      });
+      expect(sig).toStrictEqual(expectedSig);
     });
+  });
 
-    it('should return different addresses when provided different app key origins', async () => {
-      keyring = new HdKeyring({
+  // /
+  /* TESTS FOR BASE-KEYRING METHODS */
+  // /
+
+  describe('#signMessage', function () {
+    const message =
+      '0x879a053d4800c6354e76c7985a865d2922c82fb5b3f4577b2fe08b998954f2e0';
+    const expectedResult =
+      '0xb21867b2221db0172e970b7370825b71c57823ff8714168ce9748f32f450e2c43d0fe396eb5b5f59284b7fd108c8cf61a6180a6756bdd3d4b7b9ccc4ac6d51611b';
+
+    it('passes the dennis test', async function () {
+      await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
+      const result = await keyring.signMessage(firstAcct, message);
+      expect(result).toBe(expectedResult);
+    });
 
-      const address = firstAcct;
+    it('reliably can decode messages it signs', async function () {
+      await keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
+      const localMessage = 'hello there!';
+      const msgHashHex = bufferToHex(keccak256(Buffer.from(localMessage)));
+      await keyring.addAccounts(9);
+      const addresses = await keyring.getAccounts();
+      const signatures = await Promise.all(
+        addresses.map(async (accountAddress) => {
+          return await keyring.signMessage(accountAddress, msgHashHex);
+        }),
+      );
+      signatures.forEach((sgn, index) => {
+        const accountAddress = addresses[index];
 
-      const appKeyAddress1 = await keyring.getAppKeyAddress(
-        address,
-        'someapp.origin.io',
+        const r = toBuffer(sgn.slice(0, 66));
+        const s = toBuffer(`0x${sgn.slice(66, 130)}`);
+        const v = BigInt(`0x${sgn.slice(130, 132)}`);
+        const m = toBuffer(msgHashHex);
+        const pub = ecrecover(m, v, r, s);
+        const adr = `0x${pubToAddress(pub).toString('hex')}`;
+
+        expect(adr).toBe(accountAddress);
+      });
+    });
+
+    it('throw error for invalid message', async function () {
+      await keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
+
+      await expect(keyring.signMessage(firstAcct, '')).rejects.toThrow(
+        'Cannot convert 0x to a BigInt',
       );
+    });
 
-      expect(ethUtil.isValidAddress(appKeyAddress1)).toBe(true);
+    it('throw error if empty address is passed', async function () {
+      await keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
 
-      const appKeyAddress2 = await keyring.getAppKeyAddress(
-        address,
-        'anotherapp.origin.io',
+      await expect(keyring.signMessage('', message)).rejects.toThrow(
+        'Must specify address.',
       );
+    });
 
-      expect(ethUtil.isValidAddress(appKeyAddress2)).toBe(true);
+    it('throw error if address not associated with the current keyring is passed', async function () {
+      await keyring.deserialize({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
 
-      expect(appKeyAddress1).not.toBe(appKeyAddress2);
+      await expect(
+        keyring.signMessage(notKeyringAddress, message),
+      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
     });
+  });
 
-    it('should return the same address when called multiple times with the same params', async () => {
+  describe('#removeAccount', function () {
+    beforeEach(() => {
       keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
+    });
 
-      const address = firstAcct;
+    describe('if the account exists', function () {
+      it('should remove that account', async function () {
+        const addresses = await keyring.getAccounts();
+        expect(addresses).toHaveLength(1);
+        keyring.removeAccount(addresses[0]);
+        const addressesAfterRemoval = await keyring.getAccounts();
+        expect(addressesAfterRemoval).toHaveLength(0);
+      });
+    });
+
+    describe('if the account does not exist', function () {
+      it('should throw an error', function () {
+        const unexistingAccount = '0x0000000000000000000000000000000000000000';
+        expect(() => keyring.removeAccount(unexistingAccount)).toThrow(
+          `Address ${unexistingAccount} not found in this keyring`,
+        );
+      });
+    });
+  });
 
+  describe('getAppKeyAddress', function () {
+    beforeEach(() => {
+      keyring = new HdKeyring({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
+    });
+
+    it('should return a public address custom to the provided app key origin', async function () {
+      const appKeyAddress = await keyring.getAppKeyAddress(
+        firstAcct,
+        'someapp.origin.io',
+      );
+
+      expect(firstAcct).not.toBe(appKeyAddress);
+      expect(isValidAddress(appKeyAddress)).toBe(true);
+    });
+
+    it('should return different addresses when provided different app key origins', async function () {
       const appKeyAddress1 = await keyring.getAppKeyAddress(
-        address,
+        firstAcct,
         'someapp.origin.io',
       );
 
-      expect(ethUtil.isValidAddress(appKeyAddress1)).toBe(true);
+      expect(isValidAddress(appKeyAddress1)).toBe(true);
 
       const appKeyAddress2 = await keyring.getAppKeyAddress(
-        address,
+        firstAcct,
+        'anotherapp.origin.io',
+      );
+
+      expect(isValidAddress(appKeyAddress2)).toBe(true);
+      expect(appKeyAddress1).not.toBe(appKeyAddress2);
+    });
+
+    it('should return the same address when called multiple times with the same params', async function () {
+      const appKeyAddress1 = await keyring.getAppKeyAddress(
+        firstAcct,
         'someapp.origin.io',
       );
 
-      expect(ethUtil.isValidAddress(appKeyAddress2)).toBe(true);
+      expect(isValidAddress(appKeyAddress1)).toBe(true);
 
-      expect(appKeyAddress1).toStrictEqual(appKeyAddress2);
+      const appKeyAddress2 = await keyring.getAppKeyAddress(
+        firstAcct,
+        'someapp.origin.io',
+      );
+
+      expect(isValidAddress(appKeyAddress2)).toBe(true);
+      expect(appKeyAddress1).toBe(appKeyAddress2);
     });
-  });
 
-  describe('signing methods withAppKeyOrigin option', () => {
-    it('should signPersonalMessage with the expected key when passed a withAppKeyOrigin', async () => {
-      const address = firstAcct;
-      const message = '0x68656c6c6f20776f726c64';
+    it('should throw error if the provided origin is not a string', async function () {
+      await expect(keyring.getAppKeyAddress(firstAcct, [])).rejects.toThrow(
+        `'origin' must be a non-empty string`,
+      );
+    });
 
-      const privateKey = Buffer.from(
-        '8e82d2d74c50e5c8460f771d38a560ebe1151a9134c65a7e92b28ad0cfae7151',
-        'hex',
+    it('should throw error if the provided origin is an empty string', async function () {
+      await expect(keyring.getAppKeyAddress(firstAcct, '')).rejects.toThrow(
+        `'origin' must be a non-empty string`,
       );
-      const expectedSig = personalSign({ privateKey, data: message });
+    });
+  });
 
-      await keyring.deserialize({
+  describe('exportAccount', function () {
+    beforeEach(() => {
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
-      const sig = await keyring.signPersonalMessage(address, message, {
-        withAppKeyOrigin: 'someapp.origin.io',
+    });
+
+    it('should return a hex-encoded private key', async function () {
+      const expectedPrivateKeyResult =
+        '0xd3cc16948a02a91b9fcf83735653bf3dfd82c86543fdd1e9a828bd25e8a7b68d';
+      const privKeyHexValue = await keyring.exportAccount(firstAcct);
+
+      expect(expectedPrivateKeyResult).toBe(`0x${privKeyHexValue}`);
+    });
+
+    it('throw error if account is not present', async function () {
+      await expect(keyring.exportAccount(notKeyringAddress)).rejects.toThrow(
+        'HD Keyring - Unable to find matching address.',
+      );
+    });
+  });
+
+  describe('#encryptionPublicKey', function () {
+    const publicKey = 'LV7lWhd0mUDcvxkMU2o6uKXftu25zq4bMYdmMqppXic=';
+    beforeEach(() => {
+      keyring = new HdKeyring({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
       });
+    });
 
-      expect(sig).toStrictEqual(expectedSig);
+    it('returns the expected value', async function () {
+      const encryptionPublicKey = await keyring.getEncryptionPublicKey(
+        firstAcct,
+      );
+      expect(publicKey).toBe(encryptionPublicKey);
     });
 
-    it('should signTypedData with the expected key when passed a withAppKeyOrigin', async () => {
-      const address = firstAcct;
+    it('throw error if address is blank', async function () {
+      await expect(keyring.getEncryptionPublicKey('')).rejects.toThrow(
+        'Must specify address.',
+      );
+    });
+
+    it('throw error if address is not present in the keyring', async function () {
+      await expect(
+        keyring.getEncryptionPublicKey(notKeyringAddress),
+      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
+    });
+  });
+
+  describe('#signTypedData V4 signature verification', function () {
+    beforeEach(() => {
+      keyring = new HdKeyring({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
+    });
+
+    const expectedSignature =
+      '0x220917664ef676d592bd709a5bffedaf69c5f6c72f13c6c4547a41d211f0923c3180893b1dec023433f11b664fabda22b74b57d21094f7798fc85b7650f8edbb1b';
+
+    it('returns the expected value', async function () {
       const typedData = {
         types: {
-          EIP712Domain: [],
+          EIP712Domain: [
+            { name: 'name', type: 'string' },
+            { name: 'version', type: 'string' },
+            { name: 'chainId', type: 'uint256' },
+            { name: 'verifyingContract', type: 'address' },
+          ],
+          Person: [
+            { name: 'name', type: 'string' },
+            { name: 'wallets', type: 'address[]' },
+          ],
+          Mail: [
+            { name: 'from', type: 'Person' },
+            { name: 'to', type: 'Person[]' },
+            { name: 'contents', type: 'string' },
+          ],
+          Group: [
+            { name: 'name', type: 'string' },
+            { name: 'members', type: 'Person[]' },
+          ],
+        },
+        domain: {
+          name: 'Ether Mail',
+          version: '1',
+          chainId: 1,
+          verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+        },
+        primaryType: 'Mail',
+        message: {
+          from: {
+            name: 'Cow',
+            wallets: [
+              '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+              '0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF',
+            ],
+          },
+          to: [
+            {
+              name: 'Bob',
+              wallets: [
+                '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+                '0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57',
+                '0xB0B0b0b0b0b0B000000000000000000000000000',
+              ],
+            },
+          ],
+          contents: 'Hello, Bob!',
         },
-        domain: {},
-        primaryType: 'EIP712Domain',
-        message: {},
       };
 
-      const privateKey = Buffer.from(
-        '8e82d2d74c50e5c8460f771d38a560ebe1151a9134c65a7e92b28ad0cfae7151',
-        'hex',
-      );
-      const expectedSig = signTypedData({
-        privateKey,
+      const addresses = await keyring.getAccounts();
+      const [address] = addresses;
+
+      const signature = await keyring.signTypedData(address, typedData, {
+        version: 'V4',
+      });
+      expect(signature).toBe(expectedSignature);
+      const restored = recoverTypedSignature({
         data: typedData,
-        version: SignTypedDataVersion.V3,
+        signature,
+        version: SignTypedDataVersion.V4,
       });
+      expect(restored).toBe(address);
+    });
+  });
 
-      await keyring.deserialize({
+  describe('#decryptMessage', function () {
+    const message = 'Hello world!';
+    let encryptedMessage;
+
+    beforeEach(async () => {
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
 
-      const sig = await keyring.signTypedData_v3(address, typedData, {
-        withAppKeyOrigin: 'someapp.origin.io',
+      const encryptionPublicKey = await keyring.getEncryptionPublicKey(
+        firstAcct,
+      );
+      encryptedMessage = encrypt({
+        publicKey: encryptionPublicKey,
+        data: message,
+        version: 'x25519-xsalsa20-poly1305',
       });
-      expect(sig).toStrictEqual(expectedSig);
+    });
+
+    it('returns the expected value', async function () {
+      const decryptedMessage = await keyring.decryptMessage(
+        firstAcct,
+        encryptedMessage,
+      );
+      expect(message).toBe(decryptedMessage);
+    });
+
+    it('throw error if address passed is not present in the keyring', async function () {
+      await expect(
+        keyring.decryptMessage(notKeyringAddress, encryptedMessage),
+      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
+    });
+
+    it('throw error if wrong encrypted data object is passed', async function () {
+      await expect(keyring.decryptMessage(firstAcct, {})).rejects.toThrow(
+        'Encryption type/version not supported.',
+      );
+    });
+  });
+
+  describe('#signTransaction', function () {
+    beforeEach(() => {
+      keyring = new HdKeyring({
+        mnemonic: sampleMnemonic,
+        numberOfAccounts: 1,
+      });
+    });
+
+    const txParams = {
+      from: firstAcct,
+      nonce: '0x00',
+      gasPrice: '0x09184e72a000',
+      gasLimit: '0x2710',
+      to: firstAcct,
+      value: '0x1000',
+    };
+
+    it('returns a signed legacy tx object', async function () {
+      const tx = new EthereumTx(txParams);
+      expect(tx.isSigned()).toBe(false);
+
+      const signed = await keyring.signTransaction(firstAcct, tx);
+      expect(signed.isSigned()).toBe(true);
+    });
+
+    it('returns a signed tx object', async function () {
+      const tx = TransactionFactory.fromTxData(txParams);
+      expect(tx.isSigned()).toBe(false);
+
+      const signed = await keyring.signTransaction(firstAcct, tx);
+      expect(signed.isSigned()).toBe(true);
+    });
+
+    it('returns rejected promise if empty address is passed', async function () {
+      const tx = TransactionFactory.fromTxData(txParams);
+      await expect(keyring.signTransaction('', tx)).rejects.toThrow(
+        'Must specify address.',
+      );
+    });
+
+    it('throw error if wrong address is passed', async function () {
+      const tx = TransactionFactory.fromTxData(txParams);
+      await expect(
+        keyring.signTransaction(notKeyringAddress, tx),
+      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
     });
   });
 });