@metamask/eth-hd-keyring 6.0.0 → 7.0.0

package/{test/index.js → src/HDKeyring.test.ts}

@@ -1,4 +1,4 @@
-const {
+import {
   normalize,
   personalSign,
   recoverPersonalSignature,
@@ -6,24 +6,27 @@ const {
   signTypedData,
   SignTypedDataVersion,
   encrypt,
-} = require('@metamask/eth-sig-util');
-const { wordlist } = require('@metamask/scure-bip39/dist/wordlists/english');
-const oldMMForkBIP39 = require('@metamask/bip39');
-const {
+  EthEncryptedData,
+} from '@metamask/eth-sig-util';
+import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';
+import { generateMnemonic as oldMMForkBIP39GenerateMnemonic } from '@metamask/bip39';
+import {
   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('..');
+} from '@ethereumjs/util';
+import { TransactionFactory, Transaction as EthereumTx } from '@ethereumjs/tx';
+import { keccak256 } from 'ethereum-cryptography/keccak';
+import { Eip1024EncryptedData, Hex, add0x, assert } from '@metamask/utils';
+
+// we do not want to add this to dependency
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - TS7016: Could not find a declaration file for module
+// eslint-disable-next-line node/no-unpublished-import
+import OldHDKeyring from '@metamask/eth-hd-keyring';
+import { HDKeyring } from './HDKeyring';
 
 // Sample account:
 const privKeyHex =
@@ -39,25 +42,23 @@ const notKeyringAddress = '0xbD20F6F5F1616947a39E11926E78ec94817B3931';
 describe('hd-keyring', () => {
   describe('compare old bip39 implementation with new', () => {
     it('should derive the same accounts from the same mnemonics', async () => {
-      const mnemonics = [];
+      const mnemonics: Buffer[] = [];
       for (let i = 0; i < 99; i++) {
-        mnemonics.push(oldMMForkBIP39.generateMnemonic());
+        mnemonics.push(oldMMForkBIP39GenerateMnemonic());
       }
 
       await Promise.all(
         mnemonics.map(async (mnemonic) => {
-          const newHDKeyring = new HdKeyring({ mnemonic, numberOfAccounts: 3 });
-          const oldHDKeyring = new OldHdKeyring({
+          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]);
+          expect(newAccounts[0]).toStrictEqual(oldAccounts[0]);
+          expect(newAccounts[1]).toStrictEqual(oldAccounts[1]);
+          expect(newAccounts[2]).toStrictEqual(oldAccounts[2]);
         }),
       );
     });
@@ -65,7 +66,7 @@ describe('hd-keyring', () => {
 
   describe('constructor', () => {
     it('constructs with a typeof string mnemonic', async () => {
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 2,
       });
@@ -76,7 +77,7 @@ describe('hd-keyring', () => {
     });
 
     it('constructs with a typeof buffer mnemonic', async () => {
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: Buffer.from(sampleMnemonic, 'utf8'),
         numberOfAccounts: 2,
       });
@@ -93,7 +94,7 @@ describe('hd-keyring', () => {
       const uInt8ArrayOfMnemonic = new Uint8Array(
         new Uint16Array(indices).buffer,
       );
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: uInt8ArrayOfMnemonic,
         numberOfAccounts: 2,
       });
@@ -103,23 +104,35 @@ describe('hd-keyring', () => {
       expect(accounts[1]).toStrictEqual(secondAcct);
     });
 
+    it('constructs with jscasted buffer', async () => {
+      const jscastedBuffer = Buffer.from(sampleMnemonic).toJSON();
+      const keyring = new HDKeyring({
+        mnemonic: jscastedBuffer,
+        numberOfAccounts: 2,
+      });
+
+      const accounts = await keyring.getAccounts();
+      expect(accounts[0]).toStrictEqual(firstAcct);
+      expect(accounts[1]).toStrictEqual(secondAcct);
+    });
+
     it('throws on invalid mnemonic', () => {
       expect(
         () =>
-          new HdKeyring({
+          new HDKeyring({
             mnemonic: 'abc xyz',
             numberOfAccounts: 2,
           }),
       ).toThrow('Eth-Hd-Keyring: Invalid secret recovery phrase provided');
     });
 
-    it('throws when numberOfAccounts is passed with no mnemonic', () => {
-      expect(
-        () =>
-          new HdKeyring({
-            numberOfAccounts: 2,
-          }),
-      ).toThrow(
+    it('throws when numberOfAccounts is passed with no mnemonic', async () => {
+      expect(() => {
+        // eslint-disable-next-line no-new
+        new HDKeyring({
+          numberOfAccounts: 1,
+        });
+      }).toThrow(
         'Eth-Hd-Keyring: Deserialize method cannot be called with an opts value for numberOfAccounts and no menmonic',
       );
     });
@@ -129,7 +142,7 @@ describe('hd-keyring', () => {
     const alreadyProvidedError =
       'Eth-Hd-Keyring: Secret recovery phrase already provided';
     it('double generateRandomMnemonic', () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       keyring.generateRandomMnemonic();
       expect(() => {
         keyring.generateRandomMnemonic();
@@ -137,7 +150,7 @@ describe('hd-keyring', () => {
     });
 
     it('constructor + generateRandomMnemonic', () => {
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 2,
       });
@@ -148,12 +161,13 @@ describe('hd-keyring', () => {
     });
 
     it('constructor + deserialize', () => {
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 2,
       });
 
       expect(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         keyring.deserialize({
           mnemonic: sampleMnemonic,
           numberOfAccounts: 1,
@@ -164,28 +178,28 @@ describe('hd-keyring', () => {
 
   describe('Keyring.type', () => {
     it('is a class property that returns the type string.', () => {
-      const { type } = HdKeyring;
+      const { type } = HDKeyring;
       expect(typeof type).toBe('string');
     });
   });
 
   describe('#type', () => {
     it('returns the correct value', () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
 
       const { type } = keyring;
-      const correct = HdKeyring.type;
+      const correct = HDKeyring.type;
       expect(type).toStrictEqual(correct);
     });
   });
 
   describe('#serialize mnemonic.', () => {
     it('serializes the mnemonic in the same format as previous version (an array of utf8 encoded bytes)', async () => {
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
       });
       // uses previous version of eth-hd-keyring to ensure backwards compatibility
-      const oldHDKeyring = new OldHdKeyring({ mnemonic: sampleMnemonic });
+      const oldHDKeyring = new OldHDKeyring({ mnemonic: sampleMnemonic });
       const { mnemonic: oldKeyringSerializedMnemonic } =
         await oldHDKeyring.serialize();
 
@@ -194,7 +208,7 @@ describe('hd-keyring', () => {
     });
 
     it('serializes mnemonic passed in as a string to an array of utf8 encoded bytes', async () => {
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
       });
       const output = await keyring.serialize();
@@ -204,9 +218,9 @@ describe('hd-keyring', () => {
     });
 
     it('serializes mnemonic passed in as a an array of utf8 encoded bytes in the same format', async () => {
-      const uint8Array = new TextEncoder('utf-8').encode(sampleMnemonic);
+      const uint8Array = new TextEncoder().encode(sampleMnemonic);
       const mnemonicAsArrayOfUtf8EncodedBytes = Array.from(uint8Array);
-      const keyring = new HdKeyring({
+      const keyring = new HDKeyring({
         mnemonic: mnemonicAsArrayOfUtf8EncodedBytes,
       });
 
@@ -215,11 +229,18 @@ describe('hd-keyring', () => {
       const mnemonicAsString = Buffer.from(output.mnemonic).toString();
       expect(mnemonicAsString).toStrictEqual(sampleMnemonic);
     });
+
+    it('throws if mnemnoic is not set', async () => {
+      const keyring = new HDKeyring({});
+      await expect(keyring.serialize()).rejects.toThrow(
+        'Eth-Hd-Keyring: Missing mnemonic when serializing',
+      );
+    });
   });
 
   describe('#deserialize a private key', () => {
     it('serializes what it deserializes', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
@@ -242,7 +263,7 @@ describe('hd-keyring', () => {
   describe('#addAccounts', () => {
     describe('with no arguments', () => {
       it('creates a single wallet', async () => {
-        const keyring = new HdKeyring();
+        const keyring = new HDKeyring();
         keyring.generateRandomMnemonic();
         await keyring.addAccounts();
         const accounts = await keyring.getAccounts();
@@ -250,8 +271,8 @@ describe('hd-keyring', () => {
       });
 
       it('throws an error when no SRP has been generated yet', async () => {
-        const keyring = new HdKeyring();
-        expect(() => keyring.addAccounts()).toThrow(
+        const keyring = new HDKeyring();
+        await expect(keyring.addAccounts()).rejects.toThrow(
           'Eth-Hd-Keyring: No secret recovery phrase provided',
         );
       });
@@ -259,7 +280,7 @@ describe('hd-keyring', () => {
 
     describe('with a numeric argument', () => {
       it('creates that number of wallets', async () => {
-        const keyring = new HdKeyring();
+        const keyring = new HDKeyring();
         keyring.generateRandomMnemonic();
         await keyring.addAccounts(3);
         const accounts = await keyring.getAccounts();
@@ -270,7 +291,7 @@ describe('hd-keyring', () => {
 
   describe('#signPersonalMessage', () => {
     it('returns the expected value', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
 
       const address = firstAcct;
       const message = '0x68656c6c6f20776f726c64';
@@ -293,7 +314,7 @@ describe('hd-keyring', () => {
 
   describe('#signTypedData', () => {
     it('can recover a basic signature', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       Buffer.from(privKeyHex, 'hex');
       const typedData = [
         {
@@ -304,8 +325,9 @@ describe('hd-keyring', () => {
       ];
       keyring.generateRandomMnemonic();
       await keyring.addAccounts(1);
-      const addresses = await keyring.getAccounts();
-      const address = addresses[0];
+      const [rawAddress] = await keyring.getAccounts();
+      assert(rawAddress, 'addresses is empty');
+      const address = add0x(rawAddress);
       const signature = await keyring.signTypedData(address, typedData);
       const restored = recoverTypedSignature({
         data: typedData,
@@ -326,11 +348,12 @@ describe('hd-keyring', () => {
     ];
 
     it('signs in a compliant and recoverable way', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       keyring.generateRandomMnemonic();
       await keyring.addAccounts(1);
-      const addresses = await keyring.getAccounts();
-      const address = addresses[0];
+      const [rawAddress] = await keyring.getAccounts();
+      assert(rawAddress, 'addresses is empty');
+      const address = add0x(rawAddress);
       const signature = await keyring.signTypedData(address, typedData, {
         version: SignTypedDataVersion.V1,
       });
@@ -345,13 +368,13 @@ describe('hd-keyring', () => {
 
   describe('#signTypedData_v3', () => {
     it('signs in a compliant and recoverable way', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       const typedData = {
         types: {
           EIP712Domain: [],
         },
         domain: {},
-        primaryType: 'EIP712Domain',
+        primaryType: 'EIP712Domain' as const,
         message: {},
       };
 
@@ -359,8 +382,9 @@ describe('hd-keyring', () => {
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
-      const addresses = await keyring.getAccounts();
-      const address = addresses[0];
+      const [rawAddress] = await keyring.getAccounts();
+      assert(rawAddress, 'addresses is empty');
+      const address = add0x(rawAddress);
       const signature = await keyring.signTypedData(address, typedData, {
         version: SignTypedDataVersion.V3,
       });
@@ -375,7 +399,7 @@ describe('hd-keyring', () => {
 
   describe('#signTypedData_v3 signature verification', () => {
     it('signs in a recoverable way.', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       const typedData = {
         types: {
           EIP712Domain: [
@@ -394,7 +418,7 @@ describe('hd-keyring', () => {
             { name: 'contents', type: 'string' },
           ],
         },
-        primaryType: 'Mail',
+        primaryType: 'Mail' as const,
         domain: {
           name: 'Ether Mail',
           version: '1',
@@ -416,8 +440,9 @@ describe('hd-keyring', () => {
 
       keyring.generateRandomMnemonic();
       await keyring.addAccounts(1);
-      const addresses = await keyring.getAccounts();
-      const address = addresses[0];
+      const [rawAddress] = await keyring.getAccounts();
+      assert(rawAddress, 'addresses is empty');
+      const address = add0x(rawAddress);
       const signature = await keyring.signTypedData(address, typedData, {
         version: SignTypedDataVersion.V3,
       });
@@ -432,9 +457,9 @@ describe('hd-keyring', () => {
 
   describe('custom hd paths', () => {
     it('can deserialize with an hdPath param and generate the same accounts.', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       const hdPathString = `m/44'/60'/0'/0`;
-      keyring.deserialize({
+      await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
         hdPath: hdPathString,
@@ -446,9 +471,9 @@ describe('hd-keyring', () => {
     });
 
     it('can deserialize with an hdPath param and generate different accounts.', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       const hdPathString = `m/44'/60'/0'/1`;
-      keyring.deserialize({
+      await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
         hdPath: hdPathString,
@@ -468,14 +493,14 @@ describe('hd-keyring', () => {
 
       for (let i = 0; i < 1e3; i++) {
 
-        const keyring = new HdKeyring({
+        const keyring = new HDKeyring({
           numberOfAccounts: 1,
         })
         const originalAccounts = await keyring.getAccounts()
         const serialized = await keyring.serialize()
         const mnemonic = serialized.mnemonic
 
-        const keyring = new HdKeyring({
+        const keyring = new HDKeyring({
           numberOfAccounts: 1,
           mnemonic,
         })
@@ -495,7 +520,7 @@ describe('hd-keyring', () => {
 
   describe('signing methods withAppKeyOrigin option', () => {
     it('should signPersonalMessage with the expected key when passed a withAppKeyOrigin', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       const address = firstAcct;
       const message = '0x68656c6c6f20776f726c64';
 
@@ -517,14 +542,14 @@ describe('hd-keyring', () => {
     });
 
     it('should signTypedData with the expected key when passed a withAppKeyOrigin', async () => {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       const address = firstAcct;
       const typedData = {
         types: {
           EIP712Domain: [],
         },
         domain: {},
-        primaryType: 'EIP712Domain',
+        primaryType: 'EIP712Domain' as const,
         message: {},
       };
 
@@ -562,7 +587,7 @@ describe('hd-keyring', () => {
       '0xb21867b2221db0172e970b7370825b71c57823ff8714168ce9748f32f450e2c43d0fe396eb5b5f59284b7fd108c8cf61a6180a6756bdd3d4b7b9ccc4ac6d51611b';
 
     it('passes the dennis test', async function () {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
@@ -572,17 +597,19 @@ describe('hd-keyring', () => {
     });
 
     it('reliably can decode messages it signs', async function () {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
       const localMessage = 'hello there!';
-      const msgHashHex = bufferToHex(keccak256(Buffer.from(localMessage)));
+      const msgHashHex = bufferToHex(
+        Buffer.from(keccak256(Buffer.from(localMessage))),
+      ) as Hex;
       await keyring.addAccounts(9);
       const addresses = await keyring.getAccounts();
       const signatures = await Promise.all(
-        addresses.map(async (accountAddress) => {
+        addresses.map(async (accountAddress: Hex) => {
           return await keyring.signMessage(accountAddress, msgHashHex);
         }),
       );
@@ -601,31 +628,32 @@ describe('hd-keyring', () => {
     });
 
     it('throw error for invalid message', async function () {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
 
       await expect(keyring.signMessage(firstAcct, '')).rejects.toThrow(
-        'Cannot convert 0x to a BigInt',
+        'Value must be a hexadecimal string',
       );
     });
 
     it('throw error if empty address is passed', async function () {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
 
+      // @ts-expect-error we inputting an invalid address
       await expect(keyring.signMessage('', message)).rejects.toThrow(
         'Must specify address.',
       );
     });
 
     it('throw error if address not associated with the current keyring is passed', async function () {
-      const keyring = new HdKeyring();
+      const keyring = new HDKeyring();
       await keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
@@ -633,14 +661,14 @@ describe('hd-keyring', () => {
 
       await expect(
         keyring.signMessage(notKeyringAddress, message),
-      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
+      ).rejects.toThrow('Eth-Hd-Keyring: Unable to find matching address.');
     });
   });
 
   describe('#removeAccount', function () {
-    let keyring;
+    let keyring: HDKeyring;
     beforeEach(() => {
-      keyring = new HdKeyring({
+      keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -648,9 +676,12 @@ describe('hd-keyring', () => {
 
     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 rawAddresses = await keyring.getAccounts();
+        const [rawAddress] = rawAddresses;
+        expect(rawAddresses).toHaveLength(1);
+        assert(rawAddress, 'rawAddress should be empty');
+        const address = add0x(rawAddress);
+        keyring.removeAccount(address);
         const addressesAfterRemoval = await keyring.getAccounts();
         expect(addressesAfterRemoval).toHaveLength(0);
       });
@@ -667,9 +698,9 @@ describe('hd-keyring', () => {
   });
 
   describe('getAppKeyAddress', function () {
-    let keyring;
+    let keyring: HDKeyring;
     beforeEach(() => {
-      keyring = new HdKeyring({
+      keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -720,6 +751,7 @@ describe('hd-keyring', () => {
     });
 
     it('should throw error if the provided origin is not a string', async function () {
+      // @ts-expect-error we are providing an incorrect origin key
       await expect(keyring.getAppKeyAddress(firstAcct, [])).rejects.toThrow(
         `'origin' must be a non-empty string`,
       );
@@ -733,9 +765,9 @@ describe('hd-keyring', () => {
   });
 
   describe('exportAccount', function () {
-    let keyring;
+    let keyring: HDKeyring;
     beforeEach(() => {
-      keyring = new HdKeyring({
+      keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -751,16 +783,16 @@ describe('hd-keyring', () => {
 
     it('throw error if account is not present', async function () {
       await expect(keyring.exportAccount(notKeyringAddress)).rejects.toThrow(
-        'HD Keyring - Unable to find matching address.',
+        'Eth-Hd-Keyring: Unable to find matching address.',
       );
     });
   });
 
   describe('#encryptionPublicKey', function () {
     const publicKey = 'LV7lWhd0mUDcvxkMU2o6uKXftu25zq4bMYdmMqppXic=';
-    let keyring;
+    let keyring: HDKeyring;
     beforeEach(() => {
-      keyring = new HdKeyring({
+      keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -774,6 +806,7 @@ describe('hd-keyring', () => {
     });
 
     it('throw error if address is blank', async function () {
+      // @ts-expect-error provide an invalid key
       await expect(keyring.getEncryptionPublicKey('')).rejects.toThrow(
         'Must specify address.',
       );
@@ -782,14 +815,14 @@ describe('hd-keyring', () => {
     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.');
+      ).rejects.toThrow('Eth-Hd-Keyring: Unable to find matching address.');
     });
   });
 
   describe('#signTypedData V4 signature verification', function () {
-    let keyring;
+    let keyring: HDKeyring;
     beforeEach(() => {
-      keyring = new HdKeyring({
+      keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -827,7 +860,7 @@ describe('hd-keyring', () => {
           chainId: 1,
           verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
         },
-        primaryType: 'Mail',
+        primaryType: 'Mail' as const,
         message: {
           from: {
             name: 'Cow',
@@ -853,8 +886,8 @@ describe('hd-keyring', () => {
       const addresses = await keyring.getAccounts();
       const [address] = addresses;
 
-      const signature = await keyring.signTypedData(address, typedData, {
-        version: 'V4',
+      const signature = await keyring.signTypedData(address as Hex, typedData, {
+        version: SignTypedDataVersion.V4,
       });
       expect(signature).toBe(expectedSignature);
       const restored = recoverTypedSignature({
@@ -868,10 +901,10 @@ describe('hd-keyring', () => {
 
   describe('#decryptMessage', function () {
     const message = 'Hello world!';
-    let encryptedMessage, keyring;
+    let encryptedMessage: EthEncryptedData, keyring: HDKeyring;
 
     beforeEach(async () => {
-      keyring = new HdKeyring({
+      keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -897,20 +930,20 @@ describe('hd-keyring', () => {
     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.');
+      ).rejects.toThrow('Eth-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.',
-      );
+      await expect(
+        keyring.decryptMessage(firstAcct, {} as Eip1024EncryptedData),
+      ).rejects.toThrow('Encryption type/version not supported.');
     });
   });
 
   describe('#signTransaction', function () {
-    let keyring;
+    let keyring: HDKeyring;
     beforeEach(() => {
-      keyring = new HdKeyring({
+      keyring = new HDKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -930,7 +963,8 @@ describe('hd-keyring', () => {
       expect(tx.isSigned()).toBe(false);
 
       const signed = await keyring.signTransaction(firstAcct, tx);
-      expect(signed.isSigned()).toBe(true);
+      const signedTx = TransactionFactory.fromTxData(signed);
+      expect(signedTx.isSigned()).toBe(true);
     });
 
     it('returns a signed tx object', async function () {
@@ -938,11 +972,13 @@ describe('hd-keyring', () => {
       expect(tx.isSigned()).toBe(false);
 
       const signed = await keyring.signTransaction(firstAcct, tx);
-      expect(signed.isSigned()).toBe(true);
+      const signedTx = TransactionFactory.fromTxData(signed);
+      expect(signedTx.isSigned()).toBe(true);
     });
 
     it('returns rejected promise if empty address is passed', async function () {
       const tx = TransactionFactory.fromTxData(txParams);
+      // @ts-expect-error provide invalid address
       await expect(keyring.signTransaction('', tx)).rejects.toThrow(
         'Must specify address.',
       );
@@ -952,7 +988,7 @@ describe('hd-keyring', () => {
       const tx = TransactionFactory.fromTxData(txParams);
       await expect(
         keyring.signTransaction(notKeyringAddress, tx),
-      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
+      ).rejects.toThrow('Eth-Hd-Keyring: Unable to find matching address.');
     });
   });
 });