fixed yarn tests

Author: Zetazzz

packages/amino/src/coins.spec.ts

@@ -14,22 +14,22 @@ describe("coins", () => {
     });
 
     it("throws for non-safe-integer values", () => {
-      expect(() => coin(1.23, "utoken")).toThrowError(/Given amount is not a safe integer/i);
-      expect(() => coin(NaN, "utoken")).toThrowError(/Given amount is not a safe integer/i);
-      expect(() => coin(Number.POSITIVE_INFINITY, "utoken")).toThrowError(
+      expect(() => coin(1.23, "utoken")).toThrow(/Given amount is not a safe integer/i);
+      expect(() => coin(NaN, "utoken")).toThrow(/Given amount is not a safe integer/i);
+      expect(() => coin(Number.POSITIVE_INFINITY, "utoken")).toThrow(
         /Given amount is not a safe integer/i,
       );
-      expect(() => coin(Number.MAX_SAFE_INTEGER + 1, "utoken")).toThrowError(
+      expect(() => coin(Number.MAX_SAFE_INTEGER + 1, "utoken")).toThrow(
         /Given amount is not a safe integer/i,
       );
     });
 
     it("throws for negative values", () => {
-      expect(() => coin(-1, "utoken")).toThrowError(/Given amount is not a safe integer/i);
-      expect(() => coin(Number.MIN_SAFE_INTEGER, "utoken")).toThrowError(
+      expect(() => coin(-1, "utoken")).toThrow(/Given amount is not a safe integer/i);
+      expect(() => coin(Number.MIN_SAFE_INTEGER, "utoken")).toThrow(
         /Given amount is not a safe integer/i,
       );
-      expect(() => coin(Number.NEGATIVE_INFINITY, "utoken")).toThrowError(
+      expect(() => coin(Number.NEGATIVE_INFINITY, "utoken")).toThrow(
         /Given amount is not a safe integer/i,
       );
     });
@@ -48,13 +48,13 @@ describe("coins", () => {
     });
 
     it("throws for invalid amount strings", () => {
-      expect(() => coin("-1", "utoken")).toThrowError(/Invalid unsigned integer string format/i);
-      expect(() => coin("0x01", "utoken")).toThrowError(/Invalid unsigned integer string format/i);
-      expect(() => coin("NaN", "utoken")).toThrowError(/Invalid unsigned integer string format/i);
-      expect(() => coin("1.0", "utoken")).toThrowError(/Invalid unsigned integer string format/i);
-      expect(() => coin("1 ", "utoken")).toThrowError(/Invalid unsigned integer string format/i);
-      expect(() => coin(" 1", "utoken")).toThrowError(/Invalid unsigned integer string format/i);
-      expect(() => coin("1.1827350506e+26", "utoken")).toThrowError(
+      expect(() => coin("-1", "utoken")).toThrow(/Invalid unsigned integer string format/i);
+      expect(() => coin("0x01", "utoken")).toThrow(/Invalid unsigned integer string format/i);
+      expect(() => coin("NaN", "utoken")).toThrow(/Invalid unsigned integer string format/i);
+      expect(() => coin("1.0", "utoken")).toThrow(/Invalid unsigned integer string format/i);
+      expect(() => coin("1 ", "utoken")).toThrow(/Invalid unsigned integer string format/i);
+      expect(() => coin(" 1", "utoken")).toThrow(/Invalid unsigned integer string format/i);
+      expect(() => coin("1.1827350506e+26", "utoken")).toThrow(
         /Invalid unsigned integer string format/i,
       );
     });
@@ -221,24 +221,24 @@ describe("coins", () => {
 
     it("throws for invalid inputs", () => {
       // denom missing
-      expect(() => parseCoins("3456")).toThrowError(/invalid coin string/i);
+      expect(() => parseCoins("3456")).toThrow(/invalid coin string/i);
 
       // amount missing
-      expect(() => parseCoins("ucosm")).toThrowError(/invalid coin string/i);
+      expect(() => parseCoins("ucosm")).toThrow(/invalid coin string/i);
 
       // denom starting with slash
-      expect(() => parseCoins("3456/ibc")).toThrowError(/invalid coin string/i);
+      expect(() => parseCoins("3456/ibc")).toThrow(/invalid coin string/i);
 
       // denom too short
-      expect(() => parseCoins("3456a")).toThrowError(/invalid coin string/i);
-      expect(() => parseCoins("3456aa")).toThrowError(/invalid coin string/i);
+      expect(() => parseCoins("3456a")).toThrow(/invalid coin string/i);
+      expect(() => parseCoins("3456aa")).toThrow(/invalid coin string/i);
 
       // denom too long
       expect(() =>
         parseCoins(
           "3456abcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefgha",
         ),
-      ).toThrowError(/invalid coin string/i);
+      ).toThrow(/invalid coin string/i);
     });
   });
 
@@ -271,7 +271,7 @@ describe("coins", () => {
         amount: "20000",
         denom: "ucosm",
       };
-      expect(() => addCoins(balance1, balance2)).toThrowError(
+      expect(() => addCoins(balance1, balance2)).toThrow(
         /Trying to add two coins with different denoms/i,
       );
     });

packages/amino/src/encoding.spec.ts

@@ -35,7 +35,7 @@ describe("encoding", () => {
       const pubkey = fromBase64(
         "BE8EGB7ro1ORuFhjOnZcSgwYlpe0DSFjVNUIkNNQxwKQE7WHpoHoNswYeoFkuYpYSKK4mzFzMV/dB0DVAy4lnNU=",
       );
-      expect(() => encodeSecp256k1Pubkey(pubkey)).toThrowError(/public key must be compressed secp256k1/i);
+      expect(() => encodeSecp256k1Pubkey(pubkey)).toThrow(/public key must be compressed secp256k1/i);
     });
   });
 
@@ -49,10 +49,10 @@ describe("encoding", () => {
     });
 
     it("throws for wrong pubkey lengths", () => {
-      expect(() => encodeEd25519Pubkey(Random.getBytes(31))).toThrowError(
+      expect(() => encodeEd25519Pubkey(Random.getBytes(31))).toThrow(
         /ed25519 public key must be 32 bytes long/i,
       );
-      expect(() => encodeEd25519Pubkey(Random.getBytes(64))).toThrowError(
+      expect(() => encodeEd25519Pubkey(Random.getBytes(64))).toThrow(
         /ed25519 public key must be 32 bytes long/i,
       );
     });
@@ -129,7 +129,7 @@ describe("encoding", () => {
         },
       });
 
-      expect(() => decodeAminoPubkey(fromHex("22C1F7E20705"))).toThrowError(/expecting 0x08 prefix/i);
+      expect(() => decodeAminoPubkey(fromHex("22C1F7E20705"))).toThrow(/expecting 0x08 prefix/i);
     });
   });
 

packages/amino/src/multisig.spec.ts

@@ -73,10 +73,10 @@ describe("multisig", () => {
     });
 
     it("throws for threshold larger than number of keys", () => {
-      expect(() => createMultisigThresholdPubkey([test1, test2, test3], 4)).toThrowError(
+      expect(() => createMultisigThresholdPubkey([test1, test2, test3], 4)).toThrow(
         /threshold k = 4 exceeds number of keys n = 3/i,
       );
-      expect(() => createMultisigThresholdPubkey([test1, test2, test3], 75)).toThrowError(
+      expect(() => createMultisigThresholdPubkey([test1, test2, test3], 75)).toThrow(
         /threshold k = 75 exceeds number of keys n = 3/i,
       );
     });

packages/amino/src/signature.spec.ts

@@ -26,7 +26,7 @@ describe("signature", () => {
       const signature = fromBase64(
         "1nUcIH0CLT0/nQ0mBTDrT6kMG20NY/PsH7P2gc4bpYNGLEYjBmdWevXUJouSE/9A/60QG9cYeqyTe5kFDeIPxQ==",
       );
-      expect(() => encodeSecp256k1Signature(pubkey, signature)).toThrowError(
+      expect(() => encodeSecp256k1Signature(pubkey, signature)).toThrow(
         /public key must be compressed secp256k1/i,
       );
     });
@@ -39,7 +39,7 @@ describe("signature", () => {
         ),
         99,
       ]);
-      expect(() => encodeSecp256k1Signature(pubkey, signature)).toThrowError(
+      expect(() => encodeSecp256k1Signature(pubkey, signature)).toThrow(
         /signature must be 64 bytes long/i,
       );
     });

packages/auth/src/keys/private-key.spec.ts

@@ -1,118 +1,119 @@
 import { HDPath } from '@interchainjs/types';
 import { BaseCryptoBytes } from '@interchainjs/utils';
 import { PrivateKey } from './private-key';
-import { createCosmosConfig, createEthereumConfig } from '../config/builders';
+import { createCosmosConfig } from '../../../../networks/cosmos/src/auth/config';
+import { createEthereumConfig } from '../../../../networks/ethereum/src/auth/config';
 
 describe('PrivateKey', () => {
   const testMnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-  
+
   describe('fromMnemonic', () => {
     it('should create private keys from mnemonic for Cosmos', async () => {
       const hdPaths = [
         HDPath.cosmos(0, 0, 0),
         HDPath.cosmos(0, 0, 1),
       ];
-      
+
       const config = createCosmosConfig().privateKeyConfig;
       const privateKeys = await PrivateKey.fromMnemonic(testMnemonic, hdPaths, config);
-      
+
       expect(privateKeys).toHaveLength(2);
       expect(privateKeys[0].hdPath?.toString()).toBe('m/44\'/118\'/0\'/0/0');
       expect(privateKeys[1].hdPath?.toString()).toBe('m/44\'/118\'/0\'/0/1');
     });
-    
+
     it('should create private keys from mnemonic for Ethereum', async () => {
       const hdPath = HDPath.eth(0, 0, 0);
       const config = createEthereumConfig().privateKeyConfig;
       const privateKeys = await PrivateKey.fromMnemonic(testMnemonic, [hdPath], config);
-      
+
       expect(privateKeys).toHaveLength(1);
       expect(privateKeys[0].hdPath?.toString()).toBe('m/44\'/60\'/0\'/0/0');
     });
   });
-  
+
   describe('fromHex', () => {
     it('should create private key from hex string', () => {
       const hexKey = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
       const config = createCosmosConfig().privateKeyConfig;
-      
+
       const privateKey = PrivateKey.fromHex(hexKey, config);
-      
+
       expect(privateKey.toHex()).toBe(hexKey);
       expect(privateKey.config.algo).toBe('secp256k1');
     });
   });
-  
+
   describe('fromBytes', () => {
     it('should create private key from bytes', () => {
       const bytes = new Uint8Array(32).fill(42);
       const cryptoBytes = BaseCryptoBytes.from(bytes);
       const config = createCosmosConfig().privateKeyConfig;
-      
+
       const privateKey = PrivateKey.fromBytes(cryptoBytes, config);
-      
+
       expect(privateKey.value.value).toEqual(bytes);
       expect(privateKey.config.algo).toBe('secp256k1');
     });
   });
-  
+
   describe('toPublicKey', () => {
     it('should derive public key with default compression', async () => {
       const hdPath = HDPath.cosmos(0, 0, 0);
       const config = createCosmosConfig().privateKeyConfig;
       const privateKeys = await PrivateKey.fromMnemonic(testMnemonic, [hdPath], config);
-      
+
       const publicKey = privateKeys[0].toPublicKey();
-      
+
       expect(publicKey.compressed).toBe(true);
       expect(publicKey.algo).toBe('secp256k1');
     });
-    
+
     it('should derive public key with custom compression', async () => {
       const hdPath = HDPath.eth(0, 0, 0);
       const config = createEthereumConfig().privateKeyConfig;
       const privateKeys = await PrivateKey.fromMnemonic(testMnemonic, [hdPath], config);
-      
+
       const publicKey = privateKeys[0].toPublicKey({ compressed: false });
-      
+
       expect(publicKey.compressed).toBe(false);
       expect(publicKey.algo).toBe('secp256k1');
     });
   });
-  
+
   describe('sign', () => {
     it('should sign data', async () => {
       const hdPath = HDPath.cosmos(0, 0, 0);
       const config = createCosmosConfig().privateKeyConfig;
       const privateKeys = await PrivateKey.fromMnemonic(testMnemonic, [hdPath], config);
-      
+
       const message = new TextEncoder().encode('Hello, InterchainJS!');
       const signature = await privateKeys[0].sign(message);
-      
+
       expect(signature).toBeDefined();
       expect(signature.value).toBeInstanceOf(Uint8Array);
       expect(signature.value.length).toBeGreaterThan(0);
     });
   });
-  
+
   describe('serialization', () => {
     it('should convert to hex', async () => {
       const hdPath = HDPath.cosmos(0, 0, 0);
       const config = createCosmosConfig().privateKeyConfig;
       const privateKeys = await PrivateKey.fromMnemonic(testMnemonic, [hdPath], config);
-      
+
       const hex = privateKeys[0].toHex();
-      
+
       expect(hex).toMatch(/^[0-9a-f]{64}$/);
     });
-    
+
     it('should convert to base64', async () => {
       const hdPath = HDPath.cosmos(0, 0, 0);
       const config = createCosmosConfig().privateKeyConfig;
       const privateKeys = await PrivateKey.fromMnemonic(testMnemonic, [hdPath], config);
-      
+
       const base64 = privateKeys[0].toBase64();
-      
+
       expect(base64).toMatch(/^[A-Za-z0-9+/]+=*$/);
     });
   });