@onekeyfe/hd-core 1.2.0-alpha.21 → 1.2.0-alpha.23

package/__tests__/DeviceCommands.test.ts

@@ -41,6 +41,68 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
+  it('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 2,
+            message: 'Invalid session',
+          },
+        } as any,
+        'DeviceSessionGet'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WalletSessionInvalid,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 2,
+        firmwareMessage: 'Invalid session',
+      },
+    });
+  });
+
+  it('maps wallet-session user cancellation to ActionCancelled', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 1,
+            message: 'Cancelled on device',
+          },
+        } as any,
+        'DeviceSessionAskPassphrase'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+  });
+
+  it.each([
+    [3, HardwareErrorCode.DeviceCheckUnlockTypeError],
+    [4, HardwareErrorCode.DeviceNotOpenedPassphrase],
+  ])('maps wallet-session subcode %s to its canonical wallet error', async (subcode, code) => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: { code: 'Failure_ProcessError', subcode, message: 'Session selection failed' },
+        } as any,
+        'DeviceSessionAskPin'
+      )
+    ).rejects.toMatchObject({ errorCode: code });
+  });
+
   it('rejects the Pro2 bootloader DeviceStatusGet unsupported response', async () => {
     const commands = createCommands();
 
@@ -382,3 +444,26 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
     });
   });
 });
+
+describe('DeviceCommands cancellation', () => {
+  it('stops waiting after the bounded cancellation timeout', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    try {
+      const commands = createCommands();
+      commands.disposed = false;
+      commands.callPromise = new Promise(() => {});
+      const dispose = jest.fn().mockResolvedValue(undefined);
+      commands.dispose = dispose;
+
+      const cancellation = commands.cancel();
+      jest.advanceTimersByTime(10_000);
+      await Promise.resolve();
+
+      await expect(cancellation).resolves.toBeUndefined();
+      expect(dispose).toHaveBeenCalledWith(true);
+      expect(commands.callPromise).toBeUndefined();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+});

package/__tests__/connectSettings.test.ts

@@ -1,19 +1,61 @@
+import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
+import type { RemoteConfigResponse } from '../src/types';
+
+jest.mock('axios', () => ({
+  get: jest.fn(),
+}));
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
+
 describe('parseConnectSettings', () => {
-  it('keeps custom configFetcher in parsed settings', () => {
-    const configFetcher = jest.fn();
+  const preloadedConfig = {
+    bridge: {},
+    classic: { firmware: [], ble: [] },
+    classic1s: { firmware: [], ble: [] },
+    classicpure: { firmware: [], ble: [] },
+    mini: { firmware: [], ble: [] },
+    touch: { firmware: [], ble: [] },
+    pro: { firmware: [], ble: [] },
+    pro2: { firmware: [], ble: [] },
+  } as unknown as RemoteConfigResponse;
+
+  it('keeps a serializable preloaded config in parsed settings', () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    expect(settings.firmwareManifestMode).toBe('sdk-managed');
+    expect(settings.preloadedConfig).toBe(preloadedConfig);
+  });
+
+  it('uses the preloaded config before the SDK network client', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    await DataManager.load(settings);
+
+    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
+  });
 
+  it('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      fetchConfig: true,
-      configFetcher,
+      firmwareManifestMode: 'external-only',
     });
 
-    expect(settings.configFetcher).toBe(configFetcher);
+    await expect(DataManager.load(settings)).rejects.toThrow(
+      'External firmware config snapshot is required'
+    );
+    expect(mockAxiosGet).not.toHaveBeenCalled();
   });
 });

package/__tests__/device-identity.test.ts

@@ -1,13 +1,35 @@
 import { checkLiveDeviceId } from '../src/device/deviceIdentity';
+import ConfluxGetAddress from '../src/api/conflux/ConfluxGetAddress';
+import ConfluxSignMessage from '../src/api/conflux/ConfluxSignMessage';
+import ConfluxSignMessageCIP23 from '../src/api/conflux/ConfluxSignMessageCIP23';
+import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+import NexaSignTransaction from '../src/api/nexa/NexaSignTransaction';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
 
 describe('live device identity', () => {
+  test.each([
+    ['confluxGetAddress', ConfluxGetAddress],
+    ['confluxSignMessage', ConfluxSignMessage],
+    ['confluxSignMessageCIP23', ConfluxSignMessageCIP23],
+    ['confluxSignTransaction', ConfluxSignTransaction],
+    ['nexaSignTransaction', NexaSignTransaction],
+  ])('%s requires a live device id check', (methodName, Method) => {
+    const method = new Method({ payload: { method: methodName } });
+
+    expect(method.checkDeviceId).toBe(true);
+  });
+
   test('refreshes Protocol V2 status before comparing the expected device id', async () => {
     let currentDeviceId = 'OLD_DEVICE_ID';
     const device = {
       isProtocolV2: () => true,
-      getDeviceState: jest.fn().mockImplementation(async () => {
+      getDeviceState: jest.fn().mockImplementation(() => {
         currentDeviceId = 'NEW_DEVICE_ID';
-        return { identity: { deviceId: currentDeviceId } };
+        return Promise.resolve({ identity: { deviceId: currentDeviceId } });
       }),
       checkDeviceId: jest.fn((expected: string) => currentDeviceId === expected),
     };

package/__tests__/device-settings.test.ts

@@ -37,7 +37,6 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
 
 describe('DeviceSettings protocol routing', () => {
   it.each([
-    ['label', { label: 'Shared Label' }],
     ['language', { language: 'ja-JP' }],
     ['brightness', { brightness: 80 }],
     ['haptic feedback', { hapticFeedback: true }],
@@ -56,6 +55,7 @@ describe('DeviceSettings protocol routing', () => {
   });
 
   it.each([
+    ['label', { label: 'Shared Label' }],
     ['auto lock', { autoLockDelayMs: 60_000 }],
     ['auto shutdown', { autoShutdownDelayMs: 120_000 }],
     ['mixed settings', { brightness: 80, autoLockDelayMs: 60_000 }],
@@ -70,7 +70,7 @@ describe('DeviceSettings protocol routing', () => {
 
     method.init();
 
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
   });
 
   it('uses ApplySettings and commits the confirmed patch for Protocol V1', async () => {

package/__tests__/device-wallet-session-store.test.ts

@@ -1,10 +1,14 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import ClearSessionCache from '../src/api/ClearSessionCache';
+import DeviceWipe from '../src/api/device/DeviceWipe';
 import {
   DeviceWalletSessionStore,
   deviceWalletSessionStore,
 } from '../src/device/DeviceWalletSessionStore';
 import { Device } from '../src/device/Device';
 import { createCoreApi } from '../src/inject';
+import TransportManager from '../src/data-manager/TransportManager';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -93,6 +97,46 @@ describe('DeviceWalletSessionStore', () => {
   });
 });
 
+describe('Device wipe lifecycle invalidation', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('clears the old Protocol V2 identity and wallet sessions after wipe succeeds', async () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-descriptor',
+      path: 'pro2-path',
+      protocolType: 'V2',
+    } as never);
+    device.features = {
+      protocol: 'V2',
+      deviceId: 'old-device-id',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    device.passphraseState = 'hidden-a';
+    deviceWalletSessionStore.set('old-device-id', 'hidden-a', 'old-session');
+    deviceWalletSessionStore.set('pro2-path', 'hidden-a', 'temporary-session');
+    device.markPreInitialized({ passphraseState: 'hidden-a' });
+    device.commands = {
+      typedCall: jest.fn().mockResolvedValue({ message: { message: 'accepted' } }),
+    } as never;
+
+    const method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'accepted' });
+
+    expect(device.features).toBeUndefined();
+    expect(device.passphraseState).toBeUndefined();
+    expect(device.needReloadDevice).toBe(true);
+    expect(device.isPreInitializedValid(60_000)).toBe(false);
+    expect(deviceWalletSessionStore.get('old-device-id', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('pro2-path', 'hidden-a')).toBeUndefined();
+  });
+});
+
 describe('ClearSessionCache', () => {
   beforeEach(() => {
     deviceWalletSessionStore.clear();
@@ -116,7 +160,19 @@ describe('ClearSessionCache', () => {
     expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
   });
 
-  test('keeps legacy Features session fields as projections of the store', async () => {
+  test('rejects passphraseState without a deviceId instead of clearing every device', () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+    const method = new ClearSessionCache({
+      payload: { method: 'clearSessionCache', passphraseState: 'hidden-a' },
+    });
+
+    expect(() => method.init()).toThrow('Parameter [deviceId] is required with [passphraseState].');
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBe('session-a');
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+  });
+
+  test('keeps wallet sessions internal instead of projecting them through Features', async () => {
     const device = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
     device.features = {
       protocol: 'V1',
@@ -133,11 +189,14 @@ describe('ClearSessionCache', () => {
     } as never;
 
     expect(device.state).not.toHaveProperty('session');
+    expect(device.getInternalState()).toBe('session-a');
     expect(device.features).toMatchObject({
-      sessionId: 'session-a',
-      session_id: 'session-a',
-      passphraseState: 'hidden-a',
+      sessionId: null,
+      session_id: null,
     });
+    expect(device.features).not.toHaveProperty('passphraseState');
+    expect(device.features?.raw?.protocolV1Features).not.toHaveProperty('sessionId');
+    expect(device.features?.raw?.protocolV1Features).not.toHaveProperty('session_id');
 
     const method = new ClearSessionCache({
       payload: {
@@ -151,10 +210,20 @@ describe('ClearSessionCache', () => {
 
     expect(device.features?.sessionId).toBeNull();
     expect(device.features?.session_id).toBeNull();
-    expect(device.state?.raw?.protocolV1Features).toMatchObject({
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('sessionId');
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('session_id');
+  });
+
+  test('uses only the transport path as the temporary Protocol V2 cache key', () => {
+    const device = Device.fromDescriptor({ id: 'descriptor-id' } as never);
+    device.features = {
+      protocol: 'V2',
+      passphraseState: 'hidden-a',
       sessionId: 'session-a',
-      session_id: 'session-a',
-    });
+    } as never;
+
+    expect(device.getInternalState()).toBeUndefined();
+    expect(deviceWalletSessionStore.get('descriptor-id', 'hidden-a')).toBeUndefined();
   });
 
   test('clears one wallet without using a device', async () => {
@@ -211,3 +280,79 @@ describe('ClearSessionCache', () => {
     });
   });
 });
+
+describe('Protocol V1 wallet identity initialization', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+    jest.restoreAllMocks();
+  });
+
+  test('verifies the live device id before sending a cached wallet session', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'cached-device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'live-device-b' },
+    });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await expect(
+      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.not.objectContaining({ session_id: 'session-a' }),
+      expect.any(Object)
+    );
+  });
+
+  test('resumes a cached V1 wallet only after the live device id matches', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'session-a' },
+      });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'Initialize',
+      'Features',
+      expect.not.objectContaining({ session_id: 'session-a' }),
+      expect.any(Object)
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      expect.objectContaining({
+        session_id: 'session-a',
+        passphrase_state: 'hidden-a',
+      }),
+      expect.any(Object)
+    );
+  });
+});

package/__tests__/firmware-update/check-all-firmware-release.test.ts

@@ -0,0 +1,86 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import CheckAllFirmwareRelease from '../../src/api/CheckAllFirmwareRelease';
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  getBleFirmwareReleaseInfo,
+  getBootloaderReleaseInfo,
+  getFirmwareReleaseInfo,
+} from '../../src/api/firmware/releaseHelper';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../../src/api/firmware/FirmwareUpdatePlan', () => ({
+  buildFirmwareUpdatePlan: jest.fn(),
+}));
+
+jest.mock('../../src/api/firmware/releaseHelper', () => ({
+  getBleFirmwareReleaseInfo: jest.fn(),
+  getBootloaderReleaseInfo: jest.fn(),
+  getFirmwareReleaseInfo: jest.fn(),
+}));
+
+const mockBuildFirmwareUpdatePlan = buildFirmwareUpdatePlan as jest.MockedFunction<
+  typeof buildFirmwareUpdatePlan
+>;
+const mockGetBleFirmwareReleaseInfo = getBleFirmwareReleaseInfo as jest.MockedFunction<
+  typeof getBleFirmwareReleaseInfo
+>;
+const mockGetBootloaderReleaseInfo = getBootloaderReleaseInfo as jest.MockedFunction<
+  typeof getBootloaderReleaseInfo
+>;
+const mockGetFirmwareReleaseInfo = getFirmwareReleaseInfo as jest.MockedFunction<
+  typeof getFirmwareReleaseInfo
+>;
+
+describe('CheckAllFirmwareRelease', () => {
+  test('keeps release information available when an optional Plan cannot be built', async () => {
+    const firmware = {
+      status: 'outdated' as const,
+      release: {
+        url: 'https://firmware.onekey.so/classic/firmware.bin',
+        version: [3, 0, 0],
+      },
+    };
+    const noUpdate = {
+      status: 'valid' as const,
+      release: undefined,
+    };
+    mockGetFirmwareReleaseInfo.mockReturnValue(firmware);
+    mockGetBootloaderReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBleFirmwareReleaseInfo.mockReturnValue(noUpdate);
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw new Error('FirmwarePlanInvalid');
+    });
+
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        platform: 'native',
+      },
+    });
+    method.init();
+    method.device = {
+      features: {
+        deviceType: EDeviceType.Classic1s,
+        serialNo: '',
+        firmwareType: EFirmwareType.Universal,
+        firmwareVersion: '1.0.0',
+        bootloaderVersion: '1.0.0',
+      },
+    } as typeof method.device;
+
+    await expect(method.run()).resolves.toEqual(
+      expect.objectContaining({
+        firmware,
+        bootloader: noUpdate,
+        ble: noUpdate,
+        firmwareUpdatePlan: undefined,
+      })
+    );
+  });
+});

package/__tests__/firmware-update/firmware-artifact-source.test.ts

@@ -0,0 +1,119 @@
+import {
+  MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+  openFirmwareByteSource,
+  writeFirmwareByteSource,
+} from '../../src/api/firmware/FirmwareArtifactSource';
+
+import type { FirmwareArtifactReader } from '../../src/types/api/firmwareUpdate';
+
+const artifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: 6,
+  sha256: 'b'.repeat(64),
+};
+
+const createReader = () => {
+  const open = jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: artifact.size }));
+  const read = jest.fn(({ offset, length }: { readerId: string; offset: number; length: number }) =>
+    Promise.resolve({
+      data: Uint8Array.from([1, 2, 3, 4, 5, 6]).slice(offset, offset + length).buffer,
+      bytesRead: length,
+      eof: offset + length === artifact.size,
+    })
+  );
+  const close = jest.fn(() => Promise.resolve());
+  const reader: FirmwareArtifactReader = { open, read, close };
+  return { reader, open, read, close };
+};
+
+describe('FirmwareArtifactSource', () => {
+  it('reads an opaque artifact through bounded sequential reads', async () => {
+    const { reader, close } = createReader();
+    const source = await openFirmwareByteSource({ artifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+
+    const writes: Array<{ offset: number; data: number[] }> = [];
+    await writeFirmwareByteSource({
+      source,
+      chunkSize: 4,
+      write: ({ data, sourceOffset, length }) => {
+        writes.push({
+          offset: sourceOffset,
+          data: Array.from(new Uint8Array(data)),
+        });
+        return Promise.resolve(length);
+      },
+    });
+    await source.close();
+
+    expect(writes).toEqual([
+      { offset: 0, data: [1, 2, 3, 4] },
+      { offset: 4, data: [5, 6] },
+    ]);
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  it('rejects a reader whose opened size differs from the receipt', async () => {
+    const { reader, open, close } = createReader();
+    open.mockResolvedValue({
+      readerId: 'reader-1',
+      size: artifact.size + 1,
+    });
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  it('rejects paths and over-limit reads before invoking the host', async () => {
+    const { reader, read } = createReader();
+    await expect(
+      openFirmwareByteSource({
+        artifact: { ...artifact, artifactRef: '/tmp/firmware.bin' },
+        reader,
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+
+    const source = await openFirmwareByteSource({ artifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+    await expect(
+      writeFirmwareByteSource({
+        source,
+        chunkSize: MAX_FIRMWARE_ARTIFACT_READ_BYTES + 1,
+        write: ({ length }) => Promise.resolve(length),
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReadTooLarge',
+      },
+    });
+    expect(read).not.toHaveBeenCalled();
+    await source.close();
+  });
+
+  it('closes stale readers when open returns invalid metadata', async () => {
+    const { reader, open, close } = createReader();
+    open.mockResolvedValue({
+      readerId: '',
+      size: artifact.size,
+    });
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+    expect(close).not.toHaveBeenCalled();
+  });
+});