@sidhujag/sysweb3-keyring 1.0.544 → 1.0.547

package/test/unit/network/network-management.spec.ts

@@ -0,0 +1,372 @@
+import { INetworkType, INetwork } from '@sidhujag/sysweb3-network';
+
+import { KeyringManager, KeyringAccountType } from '../../../src';
+import { FAKE_PASSWORD, PEACE_SEED_PHRASE } from '../../helpers/constants';
+import { setupMocks } from '../../helpers/setup';
+
+describe('Network Management', () => {
+  let keyringManager: KeyringManager;
+  let mockVaultStateGetter: jest.Mock;
+  let currentVaultState: any;
+
+  beforeEach(async () => {
+    setupMocks();
+    // Set up vault-keys that would normally be created by Pali's MainController
+    await setupTestVault(FAKE_PASSWORD);
+  });
+
+  describe('EVM Network Switching', () => {
+    beforeEach(async () => {
+      // Set up EVM vault state with Ethereum mainnet
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+    });
+
+    it('should switch between EVM networks', async () => {
+      // Start with Ethereum mainnet
+      expect(keyringManager.getNetwork().chainId).toBe(1);
+
+      // Switch to Polygon
+      const polygon = currentVaultState.networks.ethereum[137];
+      const result = await keyringManager.setSignerNetwork(polygon);
+
+      // Update mock vault state to simulate Redux state update
+      currentVaultState.activeNetwork = polygon;
+
+      expect(result.success).toBe(true);
+      expect(keyringManager.getNetwork().chainId).toBe(137);
+      expect(keyringManager.getNetwork().label).toBe('Polygon');
+    });
+
+    it('should preserve accounts when switching EVM networks', async () => {
+      // Add accounts on Ethereum
+      const account1 = await keyringManager.addNewAccount('Test Account');
+      const originalAddress = account1.address;
+
+      // Update vault state to include the new account
+      currentVaultState.accounts[KeyringAccountType.HDAccount][1] = {
+        id: 1,
+        label: 'Test Account',
+        address: account1.address,
+        xpub: account1.xpub,
+        xprv: '',
+        isImported: false,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+
+      // Switch to Polygon
+      const polygon = currentVaultState.networks.ethereum[137];
+      await keyringManager.setSignerNetwork(polygon);
+
+      // Account should still exist with same address
+      const account = keyringManager.getAccountById(
+        1,
+        KeyringAccountType.HDAccount
+      );
+      expect(account.address).toBe(originalAddress);
+      expect(account.label).toBe('Test Account');
+    });
+
+    it('should update provider when switching networks', async () => {
+      const ethereum = keyringManager.getNetwork();
+      expect(ethereum.url).toContain('rpc.ankr.com/eth');
+
+      // Switch to Mumbai testnet
+      const mumbai = currentVaultState.networks.ethereum[80001];
+      await keyringManager.setSignerNetwork(mumbai);
+
+      // Update mock vault state to simulate Redux state update
+      currentVaultState.activeNetwork = mumbai;
+
+      const network = keyringManager.getNetwork();
+      expect(network.url).toContain('rpc-mumbai.maticvigil.com');
+      expect(network.chainId).toBe(80001);
+    });
+
+    it('should handle rapid network switching', async () => {
+      const networks = [
+        currentVaultState.networks.ethereum[1], // Ethereum
+        currentVaultState.networks.ethereum[137], // Polygon
+        currentVaultState.networks.ethereum[80001], // Mumbai
+      ];
+
+      // Rapid switching
+      for (const network of networks) {
+        const result = await keyringManager.setSignerNetwork(network);
+
+        // Update mock vault state to simulate Redux state update
+        currentVaultState.activeNetwork = network;
+
+        expect(result.success).toBe(true);
+        expect(keyringManager.getNetwork().chainId).toBe(network.chainId);
+      }
+    });
+  });
+
+  describe('Multi-Keyring Architecture Constraints', () => {
+    it('should prevent UTXO to UTXO network switching', async () => {
+      // Create Syscoin keyring
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Syscoin,
+        chainId: 57,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+
+      // Try to switch to Bitcoin (different UTXO network)
+      const bitcoin: INetwork = {
+        chainId: 0,
+        currency: 'BTC',
+        label: 'Bitcoin',
+        url: 'https://blockstream.info',
+        kind: INetworkType.Syscoin, // UTXO type
+        slip44: 0, // Different slip44
+        explorer: '',
+      };
+
+      await expect(keyringManager.setSignerNetwork(bitcoin)).rejects.toThrow(
+        'Cannot switch between different UTXO networks'
+      );
+    });
+
+    it('should prevent EVM to UTXO chain type switching', async () => {
+      // Create EVM keyring
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+
+      // Try to switch to Syscoin
+      const syscoin = currentVaultState.networks.syscoin[57];
+
+      await expect(keyringManager.setSignerNetwork(syscoin)).rejects.toThrow(
+        'Cannot use Syscoin chain type with Ethereum network'
+      );
+    });
+
+    it('should maintain separate keyring instances per UTXO network', async () => {
+      // Create Syscoin mainnet keyring with mainnet network setup
+      const syscoinMainnetVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Syscoin,
+        chainId: 57,
+      });
+      // Set up mainnet-specific network in vault state
+      syscoinMainnetVaultState.activeNetwork = {
+        ...syscoinMainnetVaultState.networks.syscoin[57],
+        chainId: 57,
+        label: 'Syscoin Mainnet',
+      };
+      const syscoinMainnetVaultGetter = jest.fn(() => syscoinMainnetVaultState);
+
+      const syscoinKeyring = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        syscoinMainnetVaultGetter
+      );
+
+      // Create Syscoin testnet keyring with testnet network setup
+      const syscoinTestnetVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Syscoin,
+        chainId: 5700,
+      });
+      // Set up testnet-specific network in vault state
+      syscoinTestnetVaultState.activeNetwork = {
+        ...syscoinTestnetVaultState.networks.syscoin[5700],
+        chainId: 5700,
+        label: 'Syscoin Testnet',
+      };
+      const syscoinTestnetVaultGetter = jest.fn(() => syscoinTestnetVaultState);
+
+      const syscoinTestnetKeyring = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        syscoinTestnetVaultGetter
+      );
+
+      // They should be independent instances
+      expect(syscoinKeyring.getNetwork().chainId).toBe(57);
+      expect(syscoinTestnetKeyring.getNetwork().chainId).toBe(5700);
+
+      // Accounts should be valid Syscoin addresses
+      const mainnetAccount = syscoinKeyring.getActiveAccount().activeAccount;
+      const testnetAccount =
+        syscoinTestnetKeyring.getActiveAccount().activeAccount;
+
+      // Mainnet should use sys1 prefix, testnet should use tsys1 prefix
+      expect(mainnetAccount.address.startsWith('sys1')).toBe(true);
+      expect(testnetAccount.address.startsWith('tsys1')).toBe(true);
+
+      // xpub formats should be different for different networks
+      // Mainnet uses zpub format, testnet uses vpub format
+      // This is correct behavior - same seed but different network encodings
+      expect(mainnetAccount.xpub.startsWith('zpub')).toBe(true); // Mainnet format
+      expect(testnetAccount.xpub.startsWith('vpub')).toBe(true); // Testnet format
+      expect(mainnetAccount.xpub).not.toBe(testnetAccount.xpub); // Different formats
+    });
+  });
+
+  describe('Network State Synchronization', () => {
+    beforeEach(async () => {
+      // Set up EVM vault state
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+    });
+
+    it('should persist network changes in vault state', async () => {
+      const polygon = currentVaultState.networks.ethereum[137];
+      await keyringManager.setSignerNetwork(polygon);
+
+      // Update mock vault state to simulate Redux state update
+      currentVaultState.activeNetwork = polygon;
+
+      // Verify the network has changed
+      const currentNetwork = keyringManager.getNetwork();
+      expect(currentNetwork.chainId).toBe(137);
+      expect(currentNetwork.label).toBe('Polygon');
+    });
+
+    it('should clear RPC caches on network switch', async () => {
+      // clearRpcCaches is already being called during network switching
+      // We can verify this by checking that network switching works successfully
+      const polygon = currentVaultState.networks.ethereum[137];
+      const result = await keyringManager.setSignerNetwork(polygon);
+
+      // Update mock vault state to simulate Redux state update
+      currentVaultState.activeNetwork = polygon;
+
+      expect(result.success).toBe(true);
+      expect(keyringManager.getNetwork().chainId).toBe(137);
+    });
+
+    it('should handle network switching with existing accounts', async () => {
+      // Create accounts on Ethereum
+      const account2 = await keyringManager.addNewAccount('Account 2');
+      const imported = await keyringManager.importAccount(
+        '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318'
+      );
+
+      // Update vault state to include these accounts
+      currentVaultState.accounts[KeyringAccountType.HDAccount][1] = {
+        id: 1,
+        label: 'Account 2',
+        address: account2.address,
+        xpub: account2.xpub,
+        xprv: '',
+        isImported: false,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+      currentVaultState.accounts[KeyringAccountType.Imported][0] = {
+        id: 0,
+        label: 'Imported 1',
+        address: imported.address,
+        xpub: imported.xpub,
+        xprv: imported.xprv,
+        isImported: true,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+
+      // Switch network
+      const polygon = currentVaultState.networks.ethereum[137];
+      await keyringManager.setSignerNetwork(polygon);
+
+      // All accounts should still exist
+      const hdAccount = keyringManager.getAccountById(
+        1,
+        KeyringAccountType.HDAccount
+      );
+      expect(hdAccount.label).toBe('Account 2');
+
+      const importedAccount = keyringManager.getAccountById(
+        0,
+        KeyringAccountType.Imported
+      );
+      expect(importedAccount.address).toBe(imported.address);
+    });
+  });
+
+  describe('Network Error Handling', () => {
+    beforeEach(async () => {
+      // Set up EVM vault state
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+    });
+
+    it('should handle invalid chain type', async () => {
+      const invalidNetwork: INetwork = {
+        chainId: 999,
+        currency: 'INVALID',
+        label: 'Invalid Network',
+        url: 'http://invalid',
+        kind: 'INVALID' as any,
+        explorer: '',
+        slip44: 60,
+      };
+
+      await expect(
+        keyringManager.setSignerNetwork(invalidNetwork)
+      ).rejects.toThrow('Unsupported chain');
+    });
+  });
+});