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

package/__tests__/device-utils.test.ts

@@ -0,0 +1,106 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import {
+  getDeviceSerialNo,
+  getDeviceType,
+  getDeviceUUID,
+  getFirmwareType,
+} from '../src/utils/deviceInfoUtils';
+import {
+  getDeviceBLEFirmwareVersion,
+  getDeviceBoardloaderVersion,
+  getDeviceBootloaderVersion,
+  getDeviceFirmwareVersion,
+} from '../src/utils/deviceVersionUtils';
+import {
+  buildProtocolV1FeaturesPayload,
+  buildProtocolV2FeaturesPayload,
+} from '../src/deviceProfile';
+
+import type { PROTO } from '../src/constants';
+
+describe('device feature selectors', () => {
+  test('reads legacy Protocol V1 features without exposing the internal builder', () => {
+    const features = {
+      onekey_device_type: 'CLASSIC1S',
+      onekey_serial_no: 'CP123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_firmware_version: 'v3.5.0',
+      onekey_boot_version: '2.8.0-alpha.1',
+      onekey_board_version: '1.2.3+board',
+      onekey_ble_version: '1.4.0+ble',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic1s);
+    expect(getDeviceSerialNo(features)).toBe('CP123456');
+    expect(getFirmwareType(features)).toBe(EFirmwareType.BitcoinOnly);
+    expect(getDeviceFirmwareVersion(features)).toEqual([3, 5, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 8, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 2, 3]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([1, 4, 0]);
+  });
+
+  test('keeps getDeviceUUID as a compatibility alias', () => {
+    const features = {
+      onekey_serial_no: 'PR123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_board_version: '1.2.3',
+      onekey_ble_version: '2.3.4',
+    } as PROTO.Features;
+
+    expect(getDeviceUUID(features)).toBe(getDeviceSerialNo(features));
+  });
+
+  test('uses bootloader version parts from old Protocol V1 firmware', () => {
+    const features = {
+      bootloader_mode: true,
+      major_version: 1,
+      minor_version: 8,
+      patch_version: 3,
+      model: '1',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic);
+    expect(getDeviceBootloaderVersion(features)).toEqual([1, 8, 3]);
+  });
+
+  test('shares Protocol V1 compatibility semantics with the internal builder', () => {
+    const rawFeatures = {
+      onekey_device_type: 'PRO',
+      onekey_serial_no: 'PR123456',
+      onekey_firmware_version: '4.16.0',
+      onekey_boot_version: '2.8.0',
+      fw_vendor: 'OneKey Bitcoin-only',
+    } as PROTO.Features;
+    const normalized = buildProtocolV1FeaturesPayload(rawFeatures);
+
+    expect(getDeviceType(normalized)).toBe(getDeviceType(rawFeatures));
+    expect(getDeviceSerialNo(normalized)).toBe(getDeviceSerialNo(rawFeatures));
+    expect(getFirmwareType(normalized)).toBe(getFirmwareType(rawFeatures));
+    expect(getDeviceFirmwareVersion(normalized)).toEqual(getDeviceFirmwareVersion(rawFeatures));
+    expect(getDeviceBootloaderVersion(normalized)).toEqual(getDeviceBootloaderVersion(rawFeatures));
+  });
+
+  test('reads normalized Protocol V2 features through the same public selectors', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { serial_no: 'P2-001' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+          romloader: { version: '1.0.0' },
+        },
+        coprocessor: {
+          application: { version: '3.0.0' },
+        },
+      },
+    });
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Pro2);
+    expect(getDeviceSerialNo(features)).toBe('P2-001');
+    expect(getDeviceFirmwareVersion(features)).toEqual([5, 0, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 0, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 0, 0]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([3, 0, 0]);
+  });
+});

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

@@ -0,0 +1,191 @@
+import ClearSessionCache from '../src/api/ClearSessionCache';
+import {
+  DeviceWalletSessionStore,
+  deviceWalletSessionStore,
+} from '../src/device/DeviceWalletSessionStore';
+import { Device } from '../src/device/Device';
+import { createCoreApi } from '../src/inject';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('DeviceWalletSessionStore', () => {
+  test('requires passphraseState for wallet session lookup', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+
+    expect(store.get('device-1', undefined)).toBeUndefined();
+    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
+  });
+
+  test('isolates wallets and devices', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+    store.set('device-1', 'hidden-b', 'session-b');
+    store.set('device-2', 'hidden-a', 'session-c');
+
+    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
+    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
+  });
+
+  test('keeps pending sessions unreadable until wallet binding', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setPending('device-1', 'pending-session');
+
+    expect(store.get('device-1', undefined)).toBeUndefined();
+    expect(store.getPending('device-1')).toBe('pending-session');
+  });
+
+  test('migrates descriptor keys to stable device ids', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('ble-path', 'hidden-a', 'session-a');
+    store.setPending('ble-path', 'pending-session');
+
+    store.migrateDeviceKey('ble-path', 'stable-device-id');
+
+    expect(store.get('ble-path', 'hidden-a')).toBeUndefined();
+    expect(store.get('stable-device-id', 'hidden-a')).toBe('session-a');
+    expect(store.getPending('ble-path')).toBeUndefined();
+    expect(store.getPending('stable-device-id')).toBe('pending-session');
+  });
+
+  test('clears one wallet, one device, or all sessions', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+    store.set('device-1', 'hidden-b', 'session-b');
+    store.set('device-2', 'hidden-a', 'session-c');
+
+    store.delete('device-1', 'hidden-a');
+    expect(store.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+
+    store.deleteDevice('device-1');
+    expect(store.get('device-1', 'hidden-b')).toBeUndefined();
+    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
+
+    store.clear();
+    expect(store.get('device-2', 'hidden-a')).toBeUndefined();
+  });
+});
+
+describe('ClearSessionCache', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('uses DeviceWalletSessionStore as the only cache source', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+    method.init();
+    await method.run();
+
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+  });
+
+  test('keeps legacy Features session fields as projections of the store', async () => {
+    const device = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-a',
+      sessionId: 'session-a',
+      session_id: 'session-a',
+      raw: {
+        protocolV1Features: {
+          sessionId: 'session-a',
+          session_id: 'session-a',
+        },
+      },
+    } as never;
+
+    expect(device.state).not.toHaveProperty('session');
+    expect(device.features).toMatchObject({
+      sessionId: 'session-a',
+      session_id: 'session-a',
+      passphraseState: 'hidden-a',
+    });
+
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+    method.init();
+    await method.run();
+
+    expect(device.features?.sessionId).toBeNull();
+    expect(device.features?.session_id).toBeNull();
+    expect(device.state?.raw?.protocolV1Features).toMatchObject({
+      sessionId: 'session-a',
+      session_id: 'session-a',
+    });
+  });
+
+  test('clears one wallet without using a device', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-1', 'hidden-b', 'session-b');
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+
+    method.init();
+
+    expect(method.useDevice).toBe(false);
+    await expect(method.run()).resolves.toEqual({ cleared: true });
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-b')).toBe('session-b');
+  });
+
+  test('clears one device or the full runtime store', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+
+    const clearDevice = new ClearSessionCache({
+      payload: { method: 'clearSessionCache', deviceId: 'device-1' },
+    });
+    clearDevice.init();
+    await clearDevice.run();
+
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+
+    const clearAll = new ClearSessionCache({
+      payload: { method: 'clearSessionCache' },
+    });
+    clearAll.init();
+    await clearAll.run();
+
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBeUndefined();
+  });
+
+  test('routes cache clearing through the active CoreApi call channel', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: { cleared: true } });
+    const api = createCoreApi(call as any);
+
+    await api.clearSessionCache({ deviceId: 'device-1', passphraseState: 'hidden-a' });
+
+    expect(call).toHaveBeenCalledWith({
+      method: 'clearSessionCache',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-a',
+    });
+  });
+});

package/__tests__/evmLedgerLegacySafety.test.ts

@@ -2,6 +2,8 @@ import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddress
 import EvmGetAddress from '../src/api/evm/EVMGetAddress';
 import EVMGetPublicKey from '../src/api/evm/EVMGetPublicKey';
 import { findMethod } from '../src/api/utils';
+import { getDeviceType, getFirmwareType, getMethodVersionRange } from '../src/utils';
+import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -14,16 +16,25 @@ jest.mock('../src/api/utils', () => ({
 
 const createDevice = (onekeyDeviceType: string) => {
   const typedCall = jest.fn();
+  const features = {
+    deviceType: onekeyDeviceType.toLowerCase(),
+    safety_checks: 'Strict',
+  };
   return {
     typedCall,
     device: {
-      features: {
-        onekey_device_type: onekeyDeviceType,
-        safety_checks: 'Strict',
-      },
+      features,
       commands: {
         typedCall,
       },
+      // BaseMethod reads state through Device accessors; reuse production mappers in the stub.
+      isProtocolV2: () => false,
+      getCurrentDeviceType: () => getDeviceType(features as any),
+      getCurrentSafetyChecks: () => features.safety_checks,
+      getCurrentFirmwareType: () => getFirmwareType(features as any),
+      getCurrentFirmwareVersionString: () => getDeviceFirmwareVersion(features as any)?.join('.'),
+      getCurrentMethodVersionRange: (fn: (model: any) => any) =>
+        getMethodVersionRange(features as any, fn),
     },
   };
 };

package/__tests__/evmSignTransaction.test.ts

@@ -10,7 +10,7 @@ jest.mock('../src/data/config', () => ({
 
 // Mock the device and transport manager
 jest.mock('../src/data-manager/TransportManager', () => ({
-  getMessageVersion: jest.fn(() => 'v2'),
+  getProtocolV1MessageSchema: jest.fn(() => 'v1CurrentSchema'),
 }));
 
 jest.mock('../src/device/Device', () => ({

package/__tests__/evmSignTypedData.test.ts

@@ -9,7 +9,7 @@ jest.mock('../src/data/config', () => ({
 }));
 
 jest.mock('../src/data-manager/TransportManager', () => ({
-  getMessageVersion: jest.fn(() => 'v2'),
+  getProtocolV1MessageSchema: jest.fn(() => 'v1CurrentSchema'),
 }));
 
 jest.mock('../src/device/Device', () => ({

package/__tests__/filesystemValidation.test.ts

@@ -0,0 +1,53 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { validateProtocolV2FilesystemPath } from '../src/api/helpers/filesystemValidation';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('validateProtocolV2FilesystemPath', () => {
+  test('兼容并保留设备现有的卷内相对路径格式', () => {
+    expect(validateProtocolV2FilesystemPath('vol1:test.bin', 'path')).toBe('vol1:test.bin');
+  });
+
+  test('目录查询可以使用卷根目录', () => {
+    expect(
+      validateProtocolV2FilesystemPath('VOL1:', 'path', {
+        allowVolumeRoot: true,
+      })
+    ).toBe('vol1:');
+  });
+
+  test.each([
+    'vol1:/../firmware.bin',
+    'vol1:/wallets/./test.bin',
+    'vol1:/wallets//test.bin',
+    'vol1:\\wallets\\test.bin',
+    'vol2:/test.bin',
+    '/test.bin',
+  ])('拒绝不安全或未知范围的路径：%s', path => {
+    expect(() => validateProtocolV2FilesystemPath(path, 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+
+  test('文件操作不允许使用卷根目录', () => {
+    expect(() => validateProtocolV2FilesystemPath('vol1:', 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+
+  test('按 UTF-8 字节数拒绝超出设备最小路径缓冲区的路径', () => {
+    expect(() => validateProtocolV2FilesystemPath(`vol1:/${'测'.repeat(41)}`, 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+});

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();
+  });
+});

package/__tests__/firmware-update/firmware-checkpoint.test.ts

@@ -0,0 +1,105 @@
+import { FirmwareCheckpointWriter } from '../../src/api/firmware/FirmwareCheckpoint';
+
+describe('FirmwareCheckpointWriter', () => {
+  it('requires an awaitable sink for prepared firmware execution', () => {
+    expect(() => new FirmwareCheckpointWriter({}, { required: true })).toThrow(
+      'Prepared firmware update requires a checkpoint sink'
+    );
+  });
+
+  it('serializes checkpoints and continues the sequence across SDK calls', async () => {
+    const checkpoints: Array<{ sequence: number; stage: string }> = [];
+    const sink = {
+      commit(checkpoint: { sequence: number; stage: string }) {
+        checkpoints.push(checkpoint);
+        return Promise.resolve();
+      },
+    };
+    const first = new FirmwareCheckpointWriter({
+      checkpointSink: sink,
+      checkpointSequenceStart: 4,
+    });
+    const second = new FirmwareCheckpointWriter({
+      checkpointSink: sink,
+      checkpointSequenceStart: 4,
+    });
+
+    await first.commit({
+      stage: 'BEFORE_DEVICE_MODE_CHANGE',
+      target: 'firmware',
+    });
+    await second.commit({
+      stage: 'FILE_TRANSFER_STARTED',
+      target: 'firmware',
+    });
+
+    expect(checkpoints).toEqual([
+      expect.objectContaining({
+        schemaVersion: 1,
+        sequence: 5,
+        stage: 'BEFORE_DEVICE_MODE_CHANGE',
+        destructiveActionStarted: true,
+      }),
+      expect.objectContaining({
+        schemaVersion: 1,
+        sequence: 6,
+        stage: 'FILE_TRANSFER_STARTED',
+        destructiveActionStarted: true,
+      }),
+    ]);
+  });
+
+  it('fails closed when the sink rejects', async () => {
+    const writer = new FirmwareCheckpointWriter(
+      {
+        checkpointSink: {
+          commit: jest.fn().mockRejectedValue(new Error('disk unavailable')),
+        },
+      },
+      { required: true }
+    );
+
+    await expect(
+      writer.commit({
+        stage: 'BEFORE_DEVICE_MODE_CHANGE',
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareCheckpointRejected',
+      },
+    });
+  });
+
+  it('fails closed when a commit does not settle before the deadline', async () => {
+    const timeoutSpy = jest
+      .spyOn(global, 'setTimeout')
+      .mockImplementation((callback: (...args: any[]) => void) => {
+        Promise.resolve().then(callback);
+        return 1 as unknown as ReturnType<typeof setTimeout>;
+      });
+    const writer = new FirmwareCheckpointWriter(
+      {
+        checkpointSink: {
+          commit: () =>
+            new Promise<void>(() => {
+              // The pending promise exercises the checkpoint deadline.
+            }),
+        },
+      },
+      { required: true }
+    );
+
+    const commit = writer.commit({
+      stage: 'FILE_TRANSFER_STARTED',
+      target: 'firmware',
+    });
+    const assertion = expect(commit).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareCheckpointRejected',
+      },
+    });
+
+    await assertion;
+    timeoutSpy.mockRestore();
+  });
+});