@metamask/eth-hd-keyring 6.0.1 → 6.0.2

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

@@ -1,4 +1,4 @@
-import {
+const {
   normalize,
   personalSign,
   recoverPersonalSignature,
@@ -6,27 +6,24 @@ import {
   signTypedData,
   SignTypedDataVersion,
   encrypt,
-  EthEncryptedData,
-} from '@metamask/eth-sig-util';
-import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';
-import { generateMnemonic as oldMMForkBIP39GenerateMnemonic } from '@metamask/bip39';
-import {
+} = require('@metamask/eth-sig-util');
+const { wordlist } = require('@metamask/scure-bip39/dist/wordlists/english');
+const oldMMForkBIP39 = require('@metamask/bip39');
+const {
   isValidAddress,
   bufferToHex,
   toBuffer,
   ecrecover,
   pubToAddress,
-} 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';
+} = 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:
 const privKeyHex =
@@ -42,23 +39,25 @@ 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: Buffer[] = [];
+      const mnemonics = [];
       for (let i = 0; i < 99; i++) {
-        mnemonics.push(oldMMForkBIP39GenerateMnemonic());
+        mnemonics.push(oldMMForkBIP39.generateMnemonic());
       }
 
       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();
-          expect(newAccounts[0]).toStrictEqual(oldAccounts[0]);
-          expect(newAccounts[1]).toStrictEqual(oldAccounts[1]);
-          expect(newAccounts[2]).toStrictEqual(oldAccounts[2]);
+          await expect(newAccounts[0]).toStrictEqual(oldAccounts[0]);
+
+          await expect(newAccounts[1]).toStrictEqual(oldAccounts[1]);
+
+          await expect(newAccounts[2]).toStrictEqual(oldAccounts[2]);
         }),
       );
     });
@@ -66,7 +65,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,
       });
@@ -77,7 +76,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,
       });
@@ -94,7 +93,7 @@ describe('hd-keyring', () => {
       const uInt8ArrayOfMnemonic = new Uint8Array(
         new Uint16Array(indices).buffer,
       );
-      const keyring = new HDKeyring({
+      const keyring = new HdKeyring({
         mnemonic: uInt8ArrayOfMnemonic,
         numberOfAccounts: 2,
       });
@@ -104,35 +103,23 @@ 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', async () => {
-      expect(() => {
-        // eslint-disable-next-line no-new
-        new HDKeyring({
-          numberOfAccounts: 1,
-        });
-      }).toThrow(
+    it('throws when numberOfAccounts is passed with no mnemonic', () => {
+      expect(
+        () =>
+          new HdKeyring({
+            numberOfAccounts: 2,
+          }),
+      ).toThrow(
         'Eth-Hd-Keyring: Deserialize method cannot be called with an opts value for numberOfAccounts and no menmonic',
       );
     });
@@ -142,7 +129,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();
@@ -150,7 +137,7 @@ describe('hd-keyring', () => {
     });
 
     it('constructor + generateRandomMnemonic', () => {
-      const keyring = new HDKeyring({
+      const keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 2,
       });
@@ -161,13 +148,12 @@ 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,
@@ -178,28 +164,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();
 
@@ -208,7 +194,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();
@@ -218,9 +204,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().encode(sampleMnemonic);
+      const uint8Array = new TextEncoder('utf-8').encode(sampleMnemonic);
       const mnemonicAsArrayOfUtf8EncodedBytes = Array.from(uint8Array);
-      const keyring = new HDKeyring({
+      const keyring = new HdKeyring({
         mnemonic: mnemonicAsArrayOfUtf8EncodedBytes,
       });
 
@@ -229,18 +215,11 @@ 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,
@@ -263,7 +242,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();
@@ -271,8 +250,8 @@ describe('hd-keyring', () => {
       });
 
       it('throws an error when no SRP has been generated yet', async () => {
-        const keyring = new HDKeyring();
-        await expect(keyring.addAccounts()).rejects.toThrow(
+        const keyring = new HdKeyring();
+        expect(() => keyring.addAccounts()).toThrow(
           'Eth-Hd-Keyring: No secret recovery phrase provided',
         );
       });
@@ -280,7 +259,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();
@@ -291,7 +270,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';
@@ -314,7 +293,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 = [
         {
@@ -325,9 +304,8 @@ describe('hd-keyring', () => {
       ];
       keyring.generateRandomMnemonic();
       await keyring.addAccounts(1);
-      const [rawAddress] = await keyring.getAccounts();
-      assert(rawAddress, 'addresses is empty');
-      const address = add0x(rawAddress);
+      const addresses = await keyring.getAccounts();
+      const address = addresses[0];
       const signature = await keyring.signTypedData(address, typedData);
       const restored = recoverTypedSignature({
         data: typedData,
@@ -348,12 +326,11 @@ 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 [rawAddress] = await keyring.getAccounts();
-      assert(rawAddress, 'addresses is empty');
-      const address = add0x(rawAddress);
+      const addresses = await keyring.getAccounts();
+      const address = addresses[0];
       const signature = await keyring.signTypedData(address, typedData, {
         version: SignTypedDataVersion.V1,
       });
@@ -368,13 +345,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' as const,
+        primaryType: 'EIP712Domain',
         message: {},
       };
 
@@ -382,9 +359,8 @@ describe('hd-keyring', () => {
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
-      const [rawAddress] = await keyring.getAccounts();
-      assert(rawAddress, 'addresses is empty');
-      const address = add0x(rawAddress);
+      const addresses = await keyring.getAccounts();
+      const address = addresses[0];
       const signature = await keyring.signTypedData(address, typedData, {
         version: SignTypedDataVersion.V3,
       });
@@ -399,7 +375,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: [
@@ -418,7 +394,7 @@ describe('hd-keyring', () => {
             { name: 'contents', type: 'string' },
           ],
         },
-        primaryType: 'Mail' as const,
+        primaryType: 'Mail',
         domain: {
           name: 'Ether Mail',
           version: '1',
@@ -440,9 +416,8 @@ describe('hd-keyring', () => {
 
       keyring.generateRandomMnemonic();
       await keyring.addAccounts(1);
-      const [rawAddress] = await keyring.getAccounts();
-      assert(rawAddress, 'addresses is empty');
-      const address = add0x(rawAddress);
+      const addresses = await keyring.getAccounts();
+      const address = addresses[0];
       const signature = await keyring.signTypedData(address, typedData, {
         version: SignTypedDataVersion.V3,
       });
@@ -457,9 +432,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`;
-      await keyring.deserialize({
+      keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
         hdPath: hdPathString,
@@ -471,9 +446,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`;
-      await keyring.deserialize({
+      keyring.deserialize({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
         hdPath: hdPathString,
@@ -493,14 +468,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,
         })
@@ -520,7 +495,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';
 
@@ -542,14 +517,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' as const,
+        primaryType: 'EIP712Domain',
         message: {},
       };
 
@@ -587,7 +562,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,
@@ -597,19 +572,17 @@ 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(
-        Buffer.from(keccak256(Buffer.from(localMessage))),
-      );
+      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: Hex) => {
+        addresses.map(async (accountAddress) => {
           return await keyring.signMessage(accountAddress, msgHashHex);
         }),
       );
@@ -628,7 +601,7 @@ 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,
@@ -640,20 +613,19 @@ describe('hd-keyring', () => {
     });
 
     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,
@@ -661,14 +633,14 @@ describe('hd-keyring', () => {
 
       await expect(
         keyring.signMessage(notKeyringAddress, message),
-      ).rejects.toThrow('Eth-Hd-Keyring: Unable to find matching address.');
+      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
     });
   });
 
   describe('#removeAccount', function () {
-    let keyring: HDKeyring;
+    let keyring;
     beforeEach(() => {
-      keyring = new HDKeyring({
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -676,12 +648,9 @@ describe('hd-keyring', () => {
 
     describe('if the account exists', function () {
       it('should remove that account', async function () {
-        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 addresses = await keyring.getAccounts();
+        expect(addresses).toHaveLength(1);
+        keyring.removeAccount(addresses[0]);
         const addressesAfterRemoval = await keyring.getAccounts();
         expect(addressesAfterRemoval).toHaveLength(0);
       });
@@ -698,9 +667,9 @@ describe('hd-keyring', () => {
   });
 
   describe('getAppKeyAddress', function () {
-    let keyring: HDKeyring;
+    let keyring;
     beforeEach(() => {
-      keyring = new HDKeyring({
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -751,7 +720,6 @@ 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`,
       );
@@ -765,9 +733,9 @@ describe('hd-keyring', () => {
   });
 
   describe('exportAccount', function () {
-    let keyring: HDKeyring;
+    let keyring;
     beforeEach(() => {
-      keyring = new HDKeyring({
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -783,16 +751,16 @@ describe('hd-keyring', () => {
 
     it('throw error if account is not present', async function () {
       await expect(keyring.exportAccount(notKeyringAddress)).rejects.toThrow(
-        'Eth-Hd-Keyring: Unable to find matching address.',
+        'HD Keyring - Unable to find matching address.',
       );
     });
   });
 
   describe('#encryptionPublicKey', function () {
     const publicKey = 'LV7lWhd0mUDcvxkMU2o6uKXftu25zq4bMYdmMqppXic=';
-    let keyring: HDKeyring;
+    let keyring;
     beforeEach(() => {
-      keyring = new HDKeyring({
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -806,7 +774,6 @@ 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.',
       );
@@ -815,14 +782,14 @@ describe('hd-keyring', () => {
     it('throw error if address is not present in the keyring', async function () {
       await expect(
         keyring.getEncryptionPublicKey(notKeyringAddress),
-      ).rejects.toThrow('Eth-Hd-Keyring: Unable to find matching address.');
+      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
     });
   });
 
   describe('#signTypedData V4 signature verification', function () {
-    let keyring: HDKeyring;
+    let keyring;
     beforeEach(() => {
-      keyring = new HDKeyring({
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -860,7 +827,7 @@ describe('hd-keyring', () => {
           chainId: 1,
           verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
         },
-        primaryType: 'Mail' as const,
+        primaryType: 'Mail',
         message: {
           from: {
             name: 'Cow',
@@ -886,8 +853,8 @@ describe('hd-keyring', () => {
       const addresses = await keyring.getAccounts();
       const [address] = addresses;
 
-      const signature = await keyring.signTypedData(address as Hex, typedData, {
-        version: SignTypedDataVersion.V4,
+      const signature = await keyring.signTypedData(address, typedData, {
+        version: 'V4',
       });
       expect(signature).toBe(expectedSignature);
       const restored = recoverTypedSignature({
@@ -901,10 +868,10 @@ describe('hd-keyring', () => {
 
   describe('#decryptMessage', function () {
     const message = 'Hello world!';
-    let encryptedMessage: EthEncryptedData, keyring: HDKeyring;
+    let encryptedMessage, keyring;
 
     beforeEach(async () => {
-      keyring = new HDKeyring({
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -930,20 +897,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('Eth-Hd-Keyring: Unable to find matching address.');
+      ).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, {} as Eip1024EncryptedData),
-      ).rejects.toThrow('Encryption type/version not supported.');
+      await expect(keyring.decryptMessage(firstAcct, {})).rejects.toThrow(
+        'Encryption type/version not supported.',
+      );
     });
   });
 
   describe('#signTransaction', function () {
-    let keyring: HDKeyring;
+    let keyring;
     beforeEach(() => {
-      keyring = new HDKeyring({
+      keyring = new HdKeyring({
         mnemonic: sampleMnemonic,
         numberOfAccounts: 1,
       });
@@ -963,8 +930,7 @@ describe('hd-keyring', () => {
       expect(tx.isSigned()).toBe(false);
 
       const signed = await keyring.signTransaction(firstAcct, tx);
-      const signedTx = TransactionFactory.fromTxData(signed);
-      expect(signedTx.isSigned()).toBe(true);
+      expect(signed.isSigned()).toBe(true);
     });
 
     it('returns a signed tx object', async function () {
@@ -972,13 +938,11 @@ describe('hd-keyring', () => {
       expect(tx.isSigned()).toBe(false);
 
       const signed = await keyring.signTransaction(firstAcct, tx);
-      const signedTx = TransactionFactory.fromTxData(signed);
-      expect(signedTx.isSigned()).toBe(true);
+      expect(signed.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.',
       );
@@ -988,7 +952,7 @@ describe('hd-keyring', () => {
       const tx = TransactionFactory.fromTxData(txParams);
       await expect(
         keyring.signTransaction(notKeyringAddress, tx),
-      ).rejects.toThrow('Eth-Hd-Keyring: Unable to find matching address.');
+      ).rejects.toThrow('HD Keyring - Unable to find matching address.');
     });
   });
 });