@onekeyfe/hd-core 1.1.34-alpha.3 → 1.1.34-alpha.4

package/__tests__/open-wallet-session.test.ts

@@ -1,565 +0,0 @@
-import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import GetPassphraseState from '../src/api/GetPassphraseState';
-import OpenWalletSession from '../src/api/OpenWalletSession';
-import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const createDevice = ({
-  passphraseProtection = true,
-  typedCall = jest.fn(),
-  promptPassphrase = jest.fn(),
-}: {
-  passphraseProtection?: boolean;
-  typedCall?: jest.Mock;
-  promptPassphrase?: jest.Mock;
-} = {}) => {
-  const device: Record<string, any> = {
-    passphraseState: undefined,
-    features: {
-      unlocked: true,
-      passphraseProtection,
-      attachToPinEnabled: false,
-    },
-    commands: { typedCall, promptPassphrase },
-    getDeviceState: jest.fn().mockResolvedValue({
-      identity: { deviceId: 'device-1' },
-    }),
-    getCurrentDeviceId: () => 'device-1',
-    getCurrentPassphraseProtection: () => passphraseProtection,
-    getInternalState: () =>
-      deviceWalletSessionStore.get('device-1', device.passphraseState as string | undefined),
-    updateInternalState: jest.fn(
-      (_enabled: boolean, passphraseState: string, deviceId: string, sessionId: string) => {
-        deviceWalletSessionStore.set(deviceId, passphraseState, sessionId);
-      }
-    ),
-    clearInternalState: jest.fn(() => {
-      if (device.passphraseState) {
-        deviceWalletSessionStore.delete('device-1', device.passphraseState);
-      }
-    }),
-    lockDevice: jest.fn(),
-    unlockDevice: jest.fn(),
-    initialize: jest.fn(),
-    emit: jest.fn(),
-    isProtocolV2: () => true,
-    getCurrentFirmwareType: () => 'universal',
-  };
-  return device;
-};
-
-describe('openWalletSession', () => {
-  beforeEach(() => {
-    deviceWalletSessionStore.clear();
-  });
-
-  test('keeps getPassphraseState unsupported on Protocol V2', async () => {
-    const method = new GetPassphraseState({
-      payload: { method: 'getPassphraseState', connectId: 'connect-id' },
-    });
-    method.device = createDevice() as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
-  });
-
-  test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
-      message: {
-        passphrase_state: 'current-wallet-state',
-        session_id: 'current-wallet-session',
-        unlocked_attach_pin: false,
-      },
-    });
-    const method = new GetPassphraseState({
-      payload: {
-        method: 'getPassphraseState',
-        connectId: 'connect-id',
-        useEmptyPassphrase: true,
-        initSession: true,
-        passphraseState: 'ignored-wallet-state',
-      },
-    });
-    const device = createDevice({ typedCall });
-    device.isProtocolV2 = () => false;
-    device.features = {
-      ...device.features,
-      deviceId: 'device-1',
-      passphraseProtection: true,
-      unlocked: true,
-      sessionId: null,
-    };
-    device.getCurrentFirmwareVersionString = () => '4.15.0';
-    device.getCurrentDeviceType = () => EDeviceType.Pro;
-    device.getFeatures = jest.fn();
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toBe('current-wallet-state');
-    expect(device.clearInternalState).not.toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: undefined,
-    });
-  });
-
-  test('opens the standard wallet through the Protocol V1 empty-passphrase flow', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
-      message: {
-        passphrase_state: 'main-wallet-state',
-        session_id: 'main-wallet-session',
-        unlocked_attach_pin: false,
-      },
-    });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        useEmptyPassphrase: true,
-        initSession: true,
-        passphraseState: 'stale-hidden-state',
-      },
-    });
-    method.init();
-    const device = createDevice({ typedCall });
-    device.isProtocolV2 = () => false;
-    device.features = {
-      ...device.features,
-      deviceId: 'device-1',
-      unlocked: true,
-      sessionId: null,
-    };
-    device.getCurrentFirmwareVersionString = () => '4.15.0';
-    device.getCurrentDeviceType = () => EDeviceType.Pro;
-    device.getFeatures = jest.fn();
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V1',
-      walletType: 'standard',
-      deviceId: 'device-1',
-      passphraseState: null,
-      resumed: false,
-    });
-    expect(method.payload.useEmptyPassphrase).toBe(true);
-    expect(typedCall).toHaveBeenCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: undefined,
-    });
-    expect(device.clearInternalState).toHaveBeenCalled();
-  });
-
-  test('uses the compatibility form to select a hidden wallet on Protocol V2', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'hidden-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id' },
-    });
-    method.init();
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      protocol: 'V2',
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-    });
-  });
-
-  test('uses legacy initSession to replace a hidden-wallet session on Protocol V2', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'new-hidden-state',
-        session_id: 'new-hidden-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'new hidden secret' });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        initSession: true,
-        deviceId: 'device-1',
-        passphraseState: 'stale-hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'stale-hidden-state', 'stale-hidden-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'new-hidden-state',
-      resumed: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: {
-        host_passphrase: { passphrase: 'new hidden secret' },
-      },
-    });
-    expect(deviceWalletSessionStore.get('device-1', 'stale-hidden-state')).toBeUndefined();
-    expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
-  });
-
-  test('does not clear another device wallet through legacy initSession', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'current-device-state',
-        session_id: 'current-device-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        initSession: true,
-        deviceId: 'other-device',
-        passphraseState: 'other-device-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('other-device', 'other-device-state', 'other-device-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      deviceId: 'device-1',
-      passphraseState: 'current-device-state',
-      resumed: false,
-    });
-    expect(deviceWalletSessionStore.get('other-device', 'other-device-state')).toBe(
-      'other-device-session'
-    );
-  });
-
-  test('uses a complete legacy wallet binding to resume on Protocol V2', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'renewed-session',
-      },
-    });
-    const promptPassphrase = jest.fn();
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        initSession: false,
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
-  test.each([
-    {
-      mode: 'standard',
-      initSession: true,
-    },
-    {
-      mode: 'select-hidden',
-      useEmptyPassphrase: false,
-    },
-    {
-      mode: 'select-hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-    },
-    {
-      mode: 'resume-hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      initSession: false,
-    },
-  ])('rejects legacy parameters combined with explicit mode: %o', params => {
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        ...params,
-      } as any,
-    });
-
-    expect(() => method.init()).toThrow(
-      expect.objectContaining({
-        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
-      })
-    );
-  });
-
-  test.each([{ initSession: 'true' }, { useEmptyPassphrase: 'false' }])(
-    'rejects a non-boolean legacy flag: %o',
-    params => {
-      const method = new OpenWalletSession({
-        payload: {
-          method: 'openWalletSession',
-          connectId: 'connect-id',
-          ...params,
-        } as any,
-      });
-
-      expect(() => method.init()).toThrow(
-        expect.objectContaining({
-          errorCode: HardwareErrorCode.CallMethodInvalidParameter,
-        })
-      );
-    }
-  );
-
-  test('reuses the SDK-managed Protocol V1 hidden-wallet session before validation', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
-      message: {
-        passphrase_state: 'hidden-state',
-        session_id: 'known-session',
-        unlocked_attach_pin: false,
-      },
-    });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.isProtocolV2 = () => false;
-    device.features = {
-      ...device.features,
-      deviceId: 'device-1',
-      unlocked: true,
-      sessionId: null,
-    };
-    device.getCurrentFirmwareVersionString = () => '4.15.0';
-    device.getCurrentDeviceType = () => EDeviceType.Pro;
-    device.getFeatures = jest.fn();
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      protocol: 'V1',
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(device.initialize).toHaveBeenCalledWith({
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-    });
-    expect(typedCall).toHaveBeenCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: 'hidden-state',
-    });
-  });
-
-  test('opens the standard wallet without selecting a hidden wallet', async () => {
-    const typedCall = jest.fn();
-    const promptPassphrase = jest.fn();
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
-    });
-    method.init();
-    const device = createDevice({ typedCall, promptPassphrase });
-    device.passphraseState = 'previous-hidden-state';
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'standard',
-      deviceId: 'device-1',
-      passphraseState: null,
-      resumed: false,
-    });
-    expect(typedCall).not.toHaveBeenCalled();
-    expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(device.passphraseState).toBeUndefined();
-  });
-
-  test('rejects a standard-wallet request when Protocol V2 is unlocked by Attach PIN', async () => {
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
-    });
-    method.init();
-    const device = createDevice();
-    device.features.unlockedAttachPin = true;
-    method.device = device as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
-    });
-    expect(device.lockDevice).toHaveBeenCalled();
-    expect(device.clearInternalState).toHaveBeenCalled();
-  });
-
-  test('selects a hidden wallet and keeps the session inside the SDK store', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'hidden-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-    });
-    method.init();
-    const device = createDevice({ typedCall, promptPassphrase });
-    device.passphraseState = 'previous-hidden-state';
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: {
-        host_passphrase: { passphrase: 'hidden secret' },
-      },
-    });
-    expect(device.passphraseState).toBeUndefined();
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
-  });
-
-  test.each([
-    {
-      missingField: 'session_id',
-      message: { btc_test_address: 'hidden-state' },
-    },
-    {
-      missingField: 'btc_test_address',
-      message: { session_id: 'hidden-session' },
-    },
-  ])(
-    'rejects an incomplete Protocol V2 hidden-wallet response missing $missingField',
-    async ({ message }) => {
-      const typedCall = jest.fn().mockResolvedValue({ message });
-      const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
-      const method = new OpenWalletSession({
-        payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-      });
-      method.init();
-      const device = createDevice({ typedCall, promptPassphrase });
-      method.device = device as any;
-
-      await expect(method.run()).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.RuntimeError,
-        message: 'DeviceSessionOpen returned an incomplete DeviceSession response.',
-      });
-      expect(device.clearInternalState).toHaveBeenCalled();
-      expect(device.updateInternalState).not.toHaveBeenCalled();
-    }
-  );
-
-  test('resumes a known hidden wallet without prompting or device selection', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'renewed-session',
-      },
-    });
-    const promptPassphrase = jest.fn();
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
-  test('does not fall back to wallet selection when a cached resume is invalid', async () => {
-    const typedCall = jest.fn().mockRejectedValue(
-      Object.assign(new Error('Invalid session'), {
-        errorCode: HardwareErrorCode.WalletSessionInvalid,
-      })
-    );
-    const promptPassphrase = jest.fn();
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'expired-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.WalletSessionInvalid,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
-  test('rejects resume-hidden when the SDK store has no matching session', async () => {
-    const typedCall = jest.fn();
-    const promptPassphrase = jest.fn();
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.WalletSessionInvalid,
-    });
-    expect(typedCall).not.toHaveBeenCalled();
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-});

package/__tests__/pro2Wallpaper.test.ts

@@ -1,39 +0,0 @@
-import { encodePro2Wallpaper } from '../src/utils/pro2Wallpaper';
-
-describe('encodePro2Wallpaper', () => {
-  test('encodes opaque pixels as aligned LVGL v9 RGB565 data', () => {
-    const result = encodePro2Wallpaper({
-      width: 2,
-      height: 1,
-      rgba: new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]),
-    });
-
-    expect(result.colorFormat).toBe('RGB565');
-    expect(Array.from(result.data.slice(0, 12))).toEqual([
-      0x19, 0x12, 0, 0, 2, 0, 1, 0, 4, 0, 0, 0,
-    ]);
-    expect(Array.from(result.data.slice(12))).toEqual([0x00, 0xf0, 0xc0, 0x07]);
-  });
-
-  test('encodes transparent pixels as RGB565A8 with alpha plane after RGB data', () => {
-    const result = encodePro2Wallpaper({
-      width: 2,
-      height: 1,
-      rgba: new Uint8Array([0, 0, 255, 128, 255, 255, 255, 255]),
-    });
-
-    expect(result.colorFormat).toBe('RGB565A8');
-    expect(result.data[1]).toBe(0x14);
-    expect(Array.from(result.data.slice(8, 10))).toEqual([4, 0]);
-    expect(Array.from(result.data.slice(12))).toEqual([0x1f, 0x00, 0xff, 0xff, 128, 255]);
-  });
-
-  test('rejects invalid dimensions and RGBA byte length', () => {
-    expect(() => encodePro2Wallpaper({ width: 0, height: 1, rgba: new Uint8Array() })).toThrow(
-      'width'
-    );
-    expect(() => encodePro2Wallpaper({ width: 2, height: 1, rgba: new Uint8Array(4) })).toThrow(
-      '8'
-    );
-  });
-});

package/__tests__/protocol-v2-bootloader-mode.test.ts

@@ -1,37 +0,0 @@
-import { Device } from '../src/device/Device';
-import { UI_REQUEST } from '../src/events/ui-request';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const createBootloaderDevice = (protocolType: 'V1' | 'V2') => {
-  const device = Device.fromDescriptor({
-    id: `${protocolType.toLowerCase()}-bootloader`,
-    path: `${protocolType.toLowerCase()}-bootloader`,
-    protocolType,
-  } as any);
-
-  (device as any).features = {
-    bootloaderMode: true,
-    initialized: true,
-    noBackup: false,
-  };
-
-  return device;
-};
-
-describe('Pro2 bootloader mode', () => {
-  test('does not block Protocol V2 methods in bootloader mode', () => {
-    const device = createBootloaderDevice('V2');
-
-    expect(device.hasUnexpectedMode([], [])).toBeNull();
-  });
-
-  test('keeps the Protocol V1 bootloader restriction', () => {
-    const device = createBootloaderDevice('V1');
-
-    expect(device.hasUnexpectedMode([], [])).toBe(UI_REQUEST.BOOTLOADER);
-  });
-});

package/__tests__/protocol-v2-firmware-targets.test.ts

@@ -1,19 +0,0 @@
-import { ProtocolV2FirmwareTargetType } from '../src/protocols/protocol-v2/firmware';
-
-describe('Protocol V2 firmware target contract', () => {
-  test('matches the current firmware-pro2 target ids', () => {
-    expect(ProtocolV2FirmwareTargetType).toEqual({
-      FW_MGMT_TARGET_INVALID: 0,
-      FW_MGMT_TARGET_CRATE: 1,
-      FW_MGMT_TARGET_ROMLOADER: 2,
-      FW_MGMT_TARGET_BOOTLOADER: 3,
-      FW_MGMT_TARGET_APPLICATION_P1: 4,
-      FW_MGMT_TARGET_APPLICATION_P2: 5,
-      FW_MGMT_TARGET_COPROCESSOR: 6,
-      FW_MGMT_TARGET_SE01: 7,
-      FW_MGMT_TARGET_SE02: 8,
-      FW_MGMT_TARGET_SE03: 9,
-      FW_MGMT_TARGET_SE04: 10,
-    });
-  });
-});