@sidhujag/sysweb3-keyring 1.0.544 → 1.0.547

package/test/unit/keyring-manager/import-watchonly.spec.ts

@@ -0,0 +1,181 @@
+import { INetworkType } from '@sidhujag/sysweb3-network';
+
+import { KeyringManager, KeyringAccountType } from '../../../src';
+import { FAKE_PASSWORD, PEACE_SEED_PHRASE } from '../../helpers/constants';
+import { setupMocks } from '../../helpers/setup';
+
+describe('Watch-only Import - KeyringManager', () => {
+  let keyringManager: KeyringManager;
+  let mockVaultStateGetter: jest.Mock;
+  let currentVaultState: any;
+
+  beforeEach(async () => {
+    setupMocks();
+    await setupTestVault(FAKE_PASSWORD);
+  });
+
+  describe('Single-address watch-only (address)', () => {
+    beforeEach(async () => {
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Syscoin,
+        chainId: 5700,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+    });
+
+    it('imports address as watch-only single-address and blocks derivation', async () => {
+      const addr = 'tsys1qtestaddressxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
+      const imported = await (keyringManager as any).importWatchOnly(
+        addr,
+        'Watch-only'
+      );
+      expect(imported.isImported).toBe(true);
+      // xpub === address marks single-address imported
+      expect(imported.xpub).toBe(addr);
+      expect(imported.xprv).toBe('');
+
+      // Insert into mock vault and activate
+      currentVaultState.accounts[KeyringAccountType.Imported][imported.id] = {
+        id: imported.id,
+        label: imported.label,
+        address: imported.address,
+        xpub: imported.xpub,
+        xprv: imported.xprv,
+        isImported: true,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+      currentVaultState.activeAccount = {
+        id: imported.id,
+        type: KeyringAccountType.Imported,
+      };
+
+      // Guards
+      const changeAddr = await keyringManager.getChangeAddress(imported.id);
+      expect(changeAddr).toBe(imported.address);
+      await expect(
+        keyringManager.getPubkey(imported.id, false)
+      ).rejects.toThrow(/watch-only|Public key|not available/i);
+      await expect(
+        keyringManager.getBip32Path(imported.id, false)
+      ).rejects.toThrow(/watch-only|BIP32|not available/i);
+    });
+  });
+
+  describe('XPUB/Descriptor watch-only', () => {
+    beforeEach(async () => {
+      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
+      );
+    });
+
+    it('imports xpub-like as watch-only and blocks derivation', async () => {
+      // Not a real xpub; importWatchOnly should still accept and mark watch-only
+      const xpub = 'zpub6testxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
+      const imported = await (keyringManager as any).importWatchOnly(
+        xpub,
+        'Watch-only XPUB'
+      );
+      expect(imported.xprv).toBe('');
+      expect(imported.xpub).toBe(xpub);
+
+      currentVaultState.accounts[KeyringAccountType.Imported][imported.id] = {
+        id: imported.id,
+        label: imported.label,
+        address: imported.address,
+        xpub: imported.xpub,
+        xprv: imported.xprv,
+        isImported: true,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+      currentVaultState.activeAccount = {
+        id: imported.id,
+        type: KeyringAccountType.Imported,
+      };
+
+      await expect(
+        keyringManager.getPubkey(imported.id, false)
+      ).rejects.toThrow(/watch-only|Public key|not available/i);
+      await expect(
+        keyringManager.getBip32Path(imported.id, false)
+      ).rejects.toThrow(/watch-only|BIP32|not available/i);
+    });
+
+    it('imports descriptor as watch-only and blocks derivation', async () => {
+      const desc = 'wpkh(xpub6testxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/0/*)';
+      const imported = await (keyringManager as any).importWatchOnly(
+        desc,
+        'Watch-only DESC'
+      );
+      expect(imported.xprv).toBe('');
+      expect(imported.xpub).toBe(desc);
+
+      currentVaultState.accounts[KeyringAccountType.Imported][imported.id] = {
+        id: imported.id,
+        label: imported.label,
+        address: imported.address,
+        xpub: imported.xpub,
+        xprv: imported.xprv,
+        isImported: true,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+      currentVaultState.activeAccount = {
+        id: imported.id,
+        type: KeyringAccountType.Imported,
+      };
+
+      await expect(
+        keyringManager.getPubkey(imported.id, false)
+      ).rejects.toThrow(/watch-only|Public key|not available/i);
+      await expect(
+        keyringManager.getBip32Path(imported.id, false)
+      ).rejects.toThrow(/watch-only|BIP32|not available/i);
+    });
+
+    it('rejects duplicate watch-only import by address', async () => {
+      const addr = 'sys1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq';
+      const first = await (keyringManager as any).importWatchOnly(addr, 'WO1');
+      currentVaultState.accounts[KeyringAccountType.Imported][first.id] = {
+        id: first.id,
+        label: first.label,
+        address: first.address,
+        xpub: first.xpub,
+        xprv: first.xprv,
+        isImported: true,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+      await expect(
+        (keyringManager as any).importWatchOnly(addr, 'WO2')
+      ).rejects.toThrow(/already exists/i);
+    });
+  });
+});

package/test/unit/keyring-manager/import-wif.spec.ts

@@ -0,0 +1,126 @@
+import { INetworkType } from '@sidhujag/sysweb3-network';
+import * as bjs from 'bitcoinjs-lib';
+import * as wif from 'wif';
+
+import { KeyringManager, KeyringAccountType } from '../../../src';
+import { FAKE_PASSWORD, PEACE_SEED_PHRASE } from '../../helpers/constants';
+import { setupMocks } from '../../helpers/setup';
+
+// Helper to generate deterministic WIFs from a fixed private key for given network
+const generateWif = (network: any): string => {
+  const priv = Buffer.from(
+    '0101010101010101010101010101010101010101010101010101010101010101',
+    'hex'
+  );
+  const version = network.wif; // 0x80 mainnet, 0xef testnet
+  return wif.encode({ version, privateKey: priv, compressed: true });
+};
+
+describe('WIF Import - KeyringManager', () => {
+  let keyringManager: KeyringManager;
+  let mockVaultStateGetter: jest.Mock;
+  let currentVaultState: any;
+
+  beforeEach(async () => {
+    setupMocks();
+    await setupTestVault(FAKE_PASSWORD);
+  });
+
+  describe('Syscoin mainnet', () => {
+    let MAINNET_WIF: string;
+
+    beforeEach(async () => {
+      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
+      );
+
+      MAINNET_WIF = generateWif(bjs.networks.bitcoin);
+    });
+
+    it('validates and imports a mainnet WIF as single-address account', async () => {
+      const validation = (keyringManager as any).validateWif(MAINNET_WIF);
+      expect(validation.isValid).toBe(true);
+
+      const imported = await keyringManager.importAccount(
+        MAINNET_WIF,
+        'WIF Import'
+      );
+      expect(imported.isImported).toBe(true);
+      expect(imported.label).toBe('WIF Import');
+      // xpub should equal address to mark single-address mode
+      expect(imported.xpub).toBe(imported.address);
+
+      // Update mock vault with imported account
+      currentVaultState.accounts[KeyringAccountType.Imported][imported.id] = {
+        id: imported.id,
+        label: imported.label,
+        address: imported.address,
+        xpub: imported.xpub,
+        xprv: imported.xprv,
+        isImported: true,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+      // Switch active account to the imported one for getter calls
+      currentVaultState.activeAccount = {
+        id: imported.id,
+        type: KeyringAccountType.Imported,
+      };
+
+      // Single-address getters behavior
+      const changeAddr = await keyringManager.getChangeAddress(imported.id);
+      expect(changeAddr).toBe(imported.address);
+      await expect(
+        keyringManager.getPubkey(imported.id, false)
+      ).rejects.toThrow(/not available|Public key/);
+      await expect(
+        keyringManager.getBip32Path(imported.id, false)
+      ).rejects.toThrow(/not available|BIP32/);
+    });
+  });
+
+  describe('Syscoin testnet mismatch', () => {
+    let TESTNET_WIF: string;
+
+    beforeEach(async () => {
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Syscoin,
+        chainId: 5700,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+
+      TESTNET_WIF = generateWif(bjs.networks.testnet);
+    });
+
+    it('rejects mainnet WIF on testnet (validateWif false)', async () => {
+      const mainnetWif = generateWif(bjs.networks.bitcoin);
+      const validation = (keyringManager as any).validateWif(mainnetWif);
+      expect(validation.isValid).toBe(false);
+    });
+
+    it('accepts testnet WIF on testnet', async () => {
+      const validation = (keyringManager as any).validateWif(TESTNET_WIF);
+      expect(validation.isValid).toBe(true);
+    });
+  });
+});