@sidhujag/sysweb3-keyring 1.0.547 → 1.0.548

package/test/helpers/setup.ts

@@ -1,714 +0,0 @@
-// Test setup file
-import { INetworkType } from '@sidhujag/sysweb3-network';
-import { randomBytes, createHmac } from 'crypto';
-import { TextEncoder, TextDecoder } from 'util';
-
-import { KeyringAccountType } from '../../src';
-
-// Extend global type to include setupTestVault and mockVaultState utilities
-declare global {
-  function setupTestVault(password?: string): Promise<void>;
-  function createMockVaultState(options?: {
-    activeAccountId?: number;
-    activeAccountType?: KeyringAccountType;
-    networkType?: INetworkType;
-    chainId?: number;
-  }): any;
-  const mockVaultState: any;
-}
-
-// Polyfill for TextEncoder/TextDecoder in Node.js environment
-global.TextEncoder = TextEncoder;
-global.TextDecoder = TextDecoder as any;
-
-// Polyfill crypto.getRandomValues for Node.js
-global.crypto = {
-  getRandomValues: (arr: Uint8Array) => {
-    const bytes = randomBytes(arr.length);
-    arr.set(bytes);
-    return arr;
-  },
-} as any;
-
-// Mock browser globals that Trezor expects
-global.self = global as any;
-(global as any).window = global;
-(global as any).document = {
-  createElement: () => ({}),
-  body: {
-    appendChild: () => {
-      // Empty implementation for mock DOM element appendChild
-    },
-  },
-};
-
-// Mock ledgerService from @ledgerhq/hw-app-eth
-jest.mock('@ledgerhq/hw-app-eth', () => ({
-  __esModule: true,
-  default: jest.fn().mockImplementation(() => ({
-    getAddress: jest.fn(),
-    signTransaction: jest.fn(),
-    signPersonalMessage: jest.fn(),
-    signEIP712HashedMessage: jest.fn(),
-  })),
-  ledgerService: {
-    resolveTransaction: jest.fn().mockResolvedValue({}),
-  },
-}));
-
-// Mock environment variables if needed
-process.env.SEED_PEACE_GLOBE =
-  process.env.SEED_PEACE_GLOBE ||
-  'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-process.env.PRIVATE_KEY_ACCOUNT =
-  process.env.PRIVATE_KEY_ACCOUNT ||
-  '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-process.env.PRIVATE_KEY_ACCOUNT_ADDRESS =
-  process.env.PRIVATE_KEY_ACCOUNT_ADDRESS ||
-  '0x1234567890123456789012345678901234567890';
-process.env.SEED_ACCOUNT_ADDRESS_AT_EVM =
-  process.env.SEED_ACCOUNT_ADDRESS_AT_EVM ||
-  '0x1234567890123456789012345678901234567890';
-process.env.SEED_ACCOUNT_ADDRESS_AT_UTX0 =
-  process.env.SEED_ACCOUNT_ADDRESS_AT_UTX0 ||
-  'tsys1q4v8sagt0znwaxdscrzhvu8t33n7vj8j45czpv4';
-process.env.SEED_SWALLOW_HEALTH =
-  process.env.SEED_SWALLOW_HEALTH ||
-  'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon';
-
-// Mock the providers module
-jest.mock('../../src/providers', () => ({
-  CustomJsonRpcProvider: jest.fn().mockImplementation((_signal, _url) => {
-    const { BigNumber } = jest.requireActual('@ethersproject/bignumber');
-
-    // Determine chainId based on URL
-    let chainId = 57; // Default Syscoin mainnet
-    let name = 'syscoin';
-
-    if (_url) {
-      if (_url.includes('rpc.ankr.com/eth') || _url.includes('mainnet')) {
-        chainId = 1;
-        name = 'mainnet';
-      } else if (
-        _url.includes('tanenbaum') ||
-        _url.includes('test') ||
-        _url.includes('5700')
-      ) {
-        chainId = 5700;
-        name = 'syscoin-testnet';
-      } else if (_url.includes('mumbai') || _url.includes('80001')) {
-        chainId = 80001;
-        name = 'mumbai';
-      } else if (_url.includes('polygon') && !_url.includes('mumbai')) {
-        chainId = 137;
-        name = 'polygon';
-      }
-    }
-
-    // Create signer first
-    const signer = {
-      getAddress: jest
-        .fn()
-        .mockResolvedValue('0x1234567890123456789012345678901234567890'),
-      sendTransaction: jest.fn().mockResolvedValue({
-        hash: '0x1234567890123456789012345678901234567890123456789012345678901234',
-        wait: jest.fn().mockResolvedValue({ status: 1 }),
-      }),
-      connect: jest.fn().mockReturnThis(),
-      provider: null as any, // Will be set below
-    };
-
-    const provider = {
-      getNetwork: jest.fn().mockResolvedValue({ chainId, name }),
-      getBalance: jest
-        .fn()
-        .mockResolvedValue(BigNumber.from('1000000000000000000')),
-      getCode: jest.fn().mockResolvedValue('0x'),
-      estimateGas: jest.fn().mockResolvedValue(BigNumber.from('21000')),
-      getGasPrice: jest.fn().mockResolvedValue(BigNumber.from('20000000000')),
-      getTransactionCount: jest.fn().mockResolvedValue(0),
-      sendTransaction: jest.fn().mockResolvedValue({
-        hash: '0x1234567890123456789012345678901234567890123456789012345678901234',
-        wait: jest.fn().mockResolvedValue({ status: 1 }),
-      }),
-      call: jest
-        .fn()
-        .mockResolvedValue(
-          '0x0000000000000000000000000000000000000000000000000000000000000001'
-        ),
-      getBlock: jest.fn().mockResolvedValue({
-        number: 12345,
-        timestamp: Math.floor(Date.now() / 1000),
-        baseFeePerGas: BigNumber.from('20000000000'),
-        gasLimit: BigNumber.from('30000000'),
-        gasUsed: BigNumber.from('21000'),
-        transactions: [],
-        hash: '0x1234567890123456789012345678901234567890123456789012345678901234',
-      }),
-      send: jest.fn().mockImplementation((method: string) => {
-        if (method === 'eth_maxPriorityFeePerGas') {
-          return Promise.resolve('0x5f5e100'); // 1 gwei
-        }
-        return Promise.resolve('0x0');
-      }),
-      getTransaction: jest.fn().mockResolvedValue({
-        hash: '0x1234567890123456789012345678901234567890123456789012345678901234',
-        from: '0x1234567890123456789012345678901234567890',
-        to: '0x0987654321098765432109876543210987654321',
-        nonce: 0,
-        gasLimit: BigNumber.from('21000'),
-        gasPrice: BigNumber.from('20000000000'),
-        maxFeePerGas: BigNumber.from('40000000000'),
-        maxPriorityFeePerGas: BigNumber.from('2000000000'),
-        value: BigNumber.from('0'),
-        chainId: 1,
-        wait: jest.fn().mockResolvedValue({ status: 1 }),
-      }),
-      getSigner: jest.fn().mockReturnValue(signer),
-      // Add missing methods that ethers.js expects
-      resolveName: jest.fn().mockImplementation((nameOrAddress) => {
-        // If it's already an address, return it; otherwise return null (no ENS resolution)
-        if (
-          nameOrAddress &&
-          nameOrAddress.startsWith('0x') &&
-          nameOrAddress.length === 42
-        ) {
-          return Promise.resolve(nameOrAddress);
-        }
-        return Promise.resolve(null);
-      }),
-      lookupAddress: jest.fn().mockResolvedValue(null),
-      waitForTransaction: jest.fn().mockImplementation((hash) => {
-        return Promise.resolve({
-          hash,
-          status: 1,
-          confirmations: 1,
-          blockNumber: 12345,
-          blockHash:
-            '0x1234567890123456789012345678901234567890123456789012345678901234',
-          gasUsed: BigNumber.from('21000'),
-        });
-      }),
-      getResolver: jest.fn().mockResolvedValue(null),
-      getAvatar: jest.fn().mockResolvedValue(null),
-      network: { chainId },
-      _isProvider: true,
-    };
-
-    // Set circular reference
-    signer.provider = provider;
-
-    return provider;
-  }),
-  CustomL2JsonRpcProvider: jest.fn().mockImplementation((_signal, _url) => {
-    // Return the same mock as CustomJsonRpcProvider for simplicity
-    const CustomJsonRpcProviderMock = jest.requireMock(
-      '../../src/providers'
-    ).CustomJsonRpcProvider;
-    return new CustomJsonRpcProviderMock(_signal, _url);
-  }),
-}));
-
-// Mock storage for sysweb3-core
-const mockStorage = new Map();
-
-// Mock sysweb3-core storage
-jest.mock('@sidhujag/sysweb3-core', () => ({
-  sysweb3Di: {
-    getStateStorageDb: () => ({
-      get: jest.fn(async (key: string) => {
-        return mockStorage.get(key) || null;
-      }),
-      set: jest.fn((key: string, value: any) => {
-        mockStorage.set(key, value);
-        return Promise.resolve();
-      }),
-      deleteItem: jest.fn((key: string) => {
-        mockStorage.delete(key);
-        return Promise.resolve();
-      }),
-      clear: jest.fn(() => {
-        mockStorage.clear();
-        return Promise.resolve();
-      }),
-      setClient: jest.fn(),
-    }),
-  },
-}));
-
-// Mock sysweb3-utils to support token operations
-jest.mock('@sidhujag/sysweb3-utils', () => {
-  const actualUtils = jest.requireActual('@sidhujag/sysweb3-utils');
-  return {
-    ...actualUtils,
-    getAsset: jest.fn().mockResolvedValue({
-      assetGuid: '123456789',
-      symbol: 'TEST',
-      decimals: 8,
-      maxSupply: 1000000,
-      totalSupply: 500000,
-    }),
-  };
-});
-
-// Mock syscoinjs utilities - only network calls, use real HDSigner for deterministic crypto
-jest.mock('syscoinjs-lib', () => {
-  const actualSyscoinjs = jest.requireActual('syscoinjs-lib');
-
-  // Create a mock HDSigner class that extends the real one
-  class MockHDSigner extends actualSyscoinjs.utils.HDSigner {
-    // Override sign method to avoid real PSBT signing
-    async sign(psbt) {
-      // If psbt is a string (from mock), just return it
-      if (typeof psbt === 'string') {
-        return psbt;
-      }
-
-      // If it's a mock PSBT object, return a properly signed mock
-      if (psbt && psbt.data && psbt.data.inputs) {
-        // Mock the signing process
-        return {
-          ...psbt,
-          signed: true,
-          extractTransaction: jest.fn().mockReturnValue({
-            getId: jest.fn().mockReturnValue('mock_txid'),
-            toHex: jest.fn().mockReturnValue('mock_hex'),
-          }),
-          finalizeAllInputs: jest.fn(),
-          validateSignaturesOfAllInputs: jest.fn().mockReturnValue(true),
-        };
-      }
-
-      // Otherwise return the psbt as-is
-      return psbt;
-    }
-  }
-
-  return {
-    ...actualSyscoinjs,
-    utils: {
-      ...actualSyscoinjs.utils,
-      // Replace HDSigner with our mock version
-      HDSigner: MockHDSigner,
-      // Only mock network-dependent functions
-      fetchBackendAccount: jest.fn().mockResolvedValue({
-        balance: 100000000, // 1 SYS in satoshis
-        tokens: [],
-        address: 'tsys1q4v8sagt0znwaxdscrzhvu8t33n7vj8j45czpv4',
-      }),
-      fetchEstimateFee: jest.fn().mockResolvedValue(10), // Return reasonable fee rate (10 satoshis per 1024 bytes)
-      fetchBackendRawTx: jest.fn().mockResolvedValue('mockedRawTx'),
-      fetchBackendUTXOS: jest.fn().mockResolvedValue([]),
-      sanitizeBlockbookUTXOs: jest.fn().mockReturnValue([]),
-      getMemoFromOpReturn: jest.fn(),
-      createTransaction: jest.fn().mockResolvedValue({
-        psbt: 'mocked_psbt',
-        assets: [],
-      }),
-      syscoinNetworks: {
-        mainnet: {},
-        testnet: {},
-      },
-    },
-    createPSBTFromRes: jest.fn().mockReturnValue({
-      psbt: 'mocked_psbt',
-      assets: [],
-    }),
-    signTransaction: jest.fn().mockResolvedValue('signed_tx'),
-    sendTransaction: jest.fn().mockResolvedValue({ txid: 'mocked_txid' }),
-    SyscoinJSLib: jest.fn().mockImplementation((hd, url) => ({
-      blockbookURL: url || 'https://blockbook-dev.elint.services/',
-      Signer: hd,
-      createTransaction: jest.fn().mockResolvedValue({
-        psbt: 'mocked_psbt_object',
-        fee: 0.0001, // 0.0001 SYS fee
-      }),
-      decodeRawTransaction: jest.fn().mockReturnValue({
-        txid: 'mocked_txid',
-        version: 1,
-        locktime: 0,
-        vin: [],
-        vout: [],
-      }),
-      assetAllocationSend: jest.fn().mockResolvedValue({
-        psbt: 'mocked_spt_psbt',
-        fee: 0.0001,
-      }),
-      send: jest.fn().mockResolvedValue({
-        extractTransaction: jest.fn().mockReturnValue({
-          getId: jest.fn().mockReturnValue('mock_transaction_id'),
-        }),
-      }),
-    })),
-  };
-});
-
-// Mock fetch to avoid network requests
-global.fetch = jest.fn((url) => {
-  if (url.includes('/api/v2') && !url.includes('xpub')) {
-    // Determine coin name based on URL
-    let coinName = 'Syscoin'; // Default to mainnet
-    let chainType = 'main';
-
-    // Check if it's a testnet URL
-    if (
-      url.includes('dev') ||
-      url.includes('test') ||
-      url.includes('tanenbaum')
-    ) {
-      coinName = 'Syscoin Testnet';
-      chainType = 'test';
-    }
-
-    return Promise.resolve({
-      ok: true,
-      json: () =>
-        Promise.resolve({
-          blockbook: { coin: coinName },
-          backend: { chain: chainType },
-        }),
-    } as any);
-  }
-  if (url.includes('xpub') || url.includes('fetchBackendAccount')) {
-    return Promise.resolve({
-      ok: true,
-      json: () =>
-        Promise.resolve({
-          balance: 100000000,
-          tokens: [],
-          address: 'tsys1q4v8sagt0znwaxdscrzhvu8t33n7vj8j45czpv4',
-        }),
-    } as any);
-  }
-  if (url.includes('fetchEstimateFee')) {
-    return Promise.resolve({
-      ok: true,
-      json: () => Promise.resolve({ result: 10000 }),
-    } as any);
-  }
-  // Default Ethereum RPC response
-  return Promise.resolve({
-    ok: true,
-    json: () =>
-      Promise.resolve({
-        jsonrpc: '2.0',
-        id: 1,
-        result: '0x1',
-      }),
-  } as any);
-}) as any;
-
-// Clear storage before each test to ensure clean state
-beforeEach(() => {
-  mockStorage.clear();
-});
-
-// Also clear after each test to prevent cross-test pollution
-afterEach(() => {
-  mockStorage.clear();
-});
-
-// Helper function to set up a basic vault for tests
-global.setupTestVault = async (password = 'Asdqwe123!') => {
-  const { sysweb3Di } = jest.requireMock('@sidhujag/sysweb3-core');
-  const storage = sysweb3Di.getStateStorageDb();
-
-  // Check if vault-keys already exist - if so, don't recreate them (idempotent)
-  const existingVaultKeys = await storage.get('vault-keys');
-  if (existingVaultKeys && existingVaultKeys.salt && existingVaultKeys.hash) {
-    // Vault already set up, verify password matches
-    const expectedHash = createHmac('sha512', existingVaultKeys.salt)
-      .update(password)
-      .digest('hex');
-    if (expectedHash === existingVaultKeys.hash) {
-      // Same password, vault is already correctly set up
-      return;
-    }
-    // Different password - need to recreate
-  }
-
-  // Create a vault with plain mnemonic (it will be encrypted by storage)
-  const CryptoJS = jest.requireActual('crypto-js');
-  const mnemonic =
-    'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-
-  // Vault should contain plain mnemonic - the storage layer handles encryption
-  const vault = { mnemonic: mnemonic };
-  const encryptedVault = CryptoJS.AES.encrypt(
-    JSON.stringify(vault),
-    password
-  ).toString();
-
-  await storage.set('vault', encryptedVault);
-
-  // Use CONSISTENT salts for testing (not random) to prevent password validation mismatches
-  const salt = 'test-salt-12345678901234567890123456789012'; // Fixed 32-char salt
-  const hash = createHmac('sha512', salt).update(password).digest('hex');
-
-  await storage.set('vault-keys', {
-    hash,
-    salt,
-  });
-};
-
-// Create mock vault state utility function
-global.createMockVaultState = (options = {}) => {
-  const {
-    activeAccountId = 0,
-    activeAccountType = KeyringAccountType.HDAccount,
-    networkType = INetworkType.Syscoin,
-    chainId,
-  } = options;
-
-  // Derive real addresses from the test seed phrase for consistency
-  const testSeedPhrase =
-    'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-  const testPassword = 'Asdqwe123!'; // Must match FAKE_PASSWORD from constants
-
-  let address, xpub, xprv;
-  if (networkType === INetworkType.Ethereum) {
-    // Derive real EVM address from test seed
-    const { HDNode } = jest.requireActual('@ethersproject/hdnode');
-    const { getAddressDerivationPath } = jest.requireActual(
-      '../../src/utils/derivation-paths'
-    );
-
-    const hdNode = HDNode.fromMnemonic(testSeedPhrase);
-    const ethDerivationPath = getAddressDerivationPath(
-      'eth',
-      60,
-      0,
-      false,
-      activeAccountId
-    );
-    const derivedAccount = hdNode.derivePath(ethDerivationPath);
-
-    address = derivedAccount.address;
-    xpub = derivedAccount.publicKey;
-
-    // Encrypt the private key like the real vault does
-    const CryptoJS = jest.requireActual('crypto-js');
-    const crypto = jest.requireActual('crypto');
-    const salt = 'test-salt-12345678901234567890123456789012';
-    const sessionPassword = crypto
-      .createHmac('sha512', salt)
-      .update(testPassword)
-      .digest('hex');
-    xprv = CryptoJS.AES.encrypt(
-      derivedAccount.privateKey,
-      sessionPassword
-    ).toString();
-  } else {
-    // For UTXO, use syscoinjs to derive real xpub and address from test seed
-    const { getSyscoinSigners } = jest.requireActual('../../src/signers');
-    const { getNetworkConfig } = jest.requireActual(
-      '@sidhujag/sysweb3-network'
-    );
-    const CryptoJS = jest.requireActual('crypto-js');
-    const crypto = jest.requireActual('crypto');
-
-    try {
-      // Determine slip44 and coin name based on chainId
-      const slip44 = chainId === 57 ? 57 : 1; // mainnet = 57, testnet = 1
-      const currency = chainId === 57 ? 'SYS' : 'TSYS';
-      const coinName = chainId === 57 ? 'Syscoin' : 'Syscoin Testnet'; // Use full coin names from coins.ts
-
-      // Get network config for proper syscoin parameters
-      const networkConfig = getNetworkConfig(slip44, coinName);
-
-      // Create mock RPC config for syscoinjs
-      const mockRpc = {
-        formattedNetwork: {
-          url:
-            chainId === 57
-              ? 'https://blockbook.elint.services/'
-              : 'https://blockbook-dev.elint.services/',
-          slip44,
-          currency,
-          chainId,
-        },
-        networkConfig,
-      };
-
-      // Use syscoinjs to create HD signer with proper network parameters
-      const { hd } = getSyscoinSigners({
-        mnemonic: testSeedPhrase,
-        rpc: mockRpc,
-      });
-
-      // Create account at the specified index (synchronous)
-      hd.createAccount(84);
-      hd.setAccountIndex(activeAccountId);
-
-      // Get the real xpub and address from syscoinjs
-      xpub = hd.getAccountXpub();
-      address = hd.createAddress(0, false, 84); // receiving address at index 0
-    } catch (error) {
-      // Fallback to known working addresses if syscoinjs derivation fails
-      console.warn(
-        'Syscoinjs derivation failed, using fallback addresses:',
-        error.message
-      );
-      if (chainId === 57) {
-        // Use a known mainnet address format
-        address = 'sys1q4kk5wqjwdzxh6zt7hpfj3zwrhv5v5v5ht8fqv8';
-        xpub =
-          'zpub6rFR7y4Q2AijBEqTUquhVz398htDFrtymD9xYYfG1m4wgmUn9Q5Vgg2KHJD5YQJpFHxhtQQh3yJiRMLrYjfF5VGN1yPYxkQWxgd6YWBvYcB';
-      } else {
-        // Use a known testnet address format
-        address = 'tsys1qhkd3x4r8p5w2e5n9v3h8j2m4b6c9z7f5g3h2k7';
-        xpub =
-          'tpubDDJC8T2bGJkQs6Qu7xRELGF9KNKpfF8nTy6tGNT7BudJw32VhJ7HkF7yGG7LfQ6SFGgM4V4MYWGCE7h4K7JbE7QGJFSD9P5a6f1vNMrDbqZ';
-      }
-    }
-
-    // Encrypt a mock private key
-    const salt = 'test-salt-12345678901234567890123456789012';
-    const sessionPassword = crypto
-      .createHmac('sha512', salt)
-      .update(testPassword)
-      .digest('hex');
-    const mockPrivateKey =
-      'L1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
-    xprv = CryptoJS.AES.encrypt(mockPrivateKey, sessionPassword).toString();
-  }
-
-  // Create mock networks structure
-  const networks = {
-    syscoin: {
-      57: {
-        chainId: 57,
-        currency: 'SYS',
-        label: 'Syscoin Mainnet',
-        url: 'https://blockbook.elint.services/',
-        kind: INetworkType.Syscoin,
-        explorer: 'https://explorer.syscoin.org/',
-        slip44: 57,
-      },
-      5700: {
-        chainId: 5700,
-        currency: 'TSYS',
-        label: 'Syscoin Testnet',
-        url: 'https://blockbook-dev.elint.services/',
-        kind: INetworkType.Syscoin,
-        explorer: 'https://explorer-testnet.syscoin.org/',
-        slip44: 1,
-      },
-    },
-    ethereum: {
-      1: {
-        chainId: 1,
-        currency: 'ETH',
-        label: 'Ethereum Mainnet',
-        url: 'https://rpc.ankr.com/eth',
-        kind: INetworkType.Ethereum,
-        explorer: 'https://etherscan.io/',
-        slip44: 60,
-      },
-      57: {
-        chainId: 57,
-        currency: 'SYS',
-        label: 'Syscoin NEVM',
-        url: 'https://rpc.syscoin.org',
-        kind: INetworkType.Ethereum,
-        explorer: 'https://explorer.syscoin.org/',
-        slip44: 60,
-      },
-      5700: {
-        chainId: 5700,
-        currency: 'TSYS',
-        label: 'Syscoin NEVM Testnet',
-        url: 'https://rpc.tanenbaum.io',
-        kind: INetworkType.Ethereum,
-        explorer: 'https://explorer.tanenbaum.io/',
-        slip44: 60,
-      },
-      137: {
-        chainId: 137,
-        currency: 'MATIC',
-        label: 'Polygon',
-        url: 'https://polygon-rpc.com',
-        kind: INetworkType.Ethereum,
-        explorer: 'https://polygonscan.com/',
-        slip44: 60,
-      },
-      80001: {
-        chainId: 80001,
-        currency: 'MATIC',
-        label: 'Mumbai',
-        url: 'https://rpc-mumbai.maticvigil.com',
-        kind: INetworkType.Ethereum,
-        explorer: 'https://mumbai.polygonscan.com/',
-        slip44: 60,
-      },
-    },
-  };
-
-  // Determine the network based on type and chainId
-  let activeNetwork;
-  if (networkType === INetworkType.Syscoin) {
-    const syscoinChainId = chainId || 57; // Default to mainnet
-    activeNetwork = networks.syscoin[syscoinChainId];
-  } else if (networkType === INetworkType.Ethereum) {
-    const ethChainId = chainId || 1; // Default to Ethereum mainnet
-    activeNetwork = networks.ethereum[ethChainId];
-  } else {
-    throw new Error(`Unsupported network type: ${networkType}`);
-  }
-
-  if (!activeNetwork) {
-    throw new Error(
-      `Network not found for type ${networkType} and chainId ${chainId}`
-    );
-  }
-
-  // Create mock accounts structure with generic labels - tests should verify what keyring manager actually produces
-  const accounts = {
-    [KeyringAccountType.HDAccount]: {
-      0: {
-        id: 0,
-        address,
-        xpub,
-        xprv, // Now includes encrypted private key like real vault
-        label: `Account 1`, // Generic label - tests should expect what keyring manager actually creates
-        balances: { syscoin: 0, ethereum: 0 },
-        isImported: false,
-        isTrezorWallet: false,
-        isLedgerWallet: false,
-        assets: { syscoin: [], ethereum: [] },
-      },
-    },
-    [KeyringAccountType.Imported]: {},
-    [KeyringAccountType.Trezor]: {},
-    [KeyringAccountType.Ledger]: {},
-  };
-
-  return {
-    activeAccount: { id: activeAccountId, type: activeAccountType },
-    accounts,
-    activeNetwork,
-    networks,
-    isUnlocked: false,
-    lastLogin: null,
-  };
-};
-
-// Default mock vault state (for backward compatibility) - Ethereum mainnet by default
-(global as any).mockVaultState = global.createMockVaultState({
-  networkType: INetworkType.Ethereum,
-  chainId: 1,
-});
-
-// Export setupMocks function for use in test files
-export const setupMocks = () => {
-  // Reset any global state
-  jest.clearAllMocks();
-
-  // Don't clear storage here - let the beforeEach/afterEach hooks handle it
-  // This prevents clearing vault-keys between keyring creation and password validation
-
-  // Reset vault data if it exists
-  if ((global as any).storedVaultData) {
-    (global as any).storedVaultData = null;
-  }
-};