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

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

@@ -0,0 +1,565 @@
+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__/preInitialize.test.ts

@@ -1,4 +1,9 @@
 import { Device } from '../src/device/Device';
+import { initCore } from '../src/core';
+import PreInitialize from '../src/api/device/PreInitialize';
+import { IFRAME } from '../src/events';
+
+import type Core from '../src/core';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -6,6 +11,10 @@ jest.mock('../src/data/config', () => ({
 }));
 
 describe('preInitialize', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   it('matches pre-initialized state by passphraseState only', () => {
     const device = Object.create(Device.prototype) as Device;
 
@@ -19,4 +28,28 @@ describe('preInitialize', () => {
       })
     ).toBe(true);
   });
+
+  it('cleans request lifecycle when preInitialize is acknowledged without connectId', async () => {
+    const core: Core = initCore();
+    const disposeSpy = jest.spyOn(PreInitialize.prototype, 'dispose');
+
+    try {
+      const response = await core.handleMessage({
+        id: 1001,
+        type: IFRAME.CALL,
+        payload: {
+          method: 'preInitialize',
+        },
+      } as any);
+
+      expect(response).toMatchObject({
+        success: true,
+        payload: true,
+      });
+      expect((core as any).tracingContext.activeRequests.has(1001)).toBe(false);
+      expect(disposeSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      core.dispose();
+    }
+  });
 });

package/__tests__/pro2Wallpaper.test.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,37 @@
+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);
+  });
+});