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

package/__tests__/DeviceCommands.test.ts

@@ -19,7 +19,7 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('does not log DeviceSessionGet response secrets', async () => {
+  it('does not log DeviceSessionOpen response secrets', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
     log.messages.length = 0;
@@ -33,7 +33,7 @@ describe('DeviceCommands failure mapping', () => {
             btc_test_address: 'secret-wallet-address',
           },
         } as any,
-        'DeviceSessionGet'
+        'DeviceSessionOpen'
       )
     ).resolves.toMatchObject({ type: 'DeviceSession' });
 
@@ -41,6 +41,68 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
+  it('maps an invalid DeviceSessionOpen resume to WalletSessionInvalid', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 2,
+            message: 'Invalid session',
+          },
+        } as any,
+        'DeviceSessionOpen'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WalletSessionInvalid,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 2,
+        firmwareMessage: 'Invalid session',
+      },
+    });
+  });
+
+  it('maps DeviceSessionOpen 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,
+        'DeviceSessionOpen'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+  });
+
+  it.each([
+    [3, HardwareErrorCode.DeviceCheckUnlockTypeError],
+    [4, HardwareErrorCode.DeviceNotOpenedPassphrase],
+  ])('maps DeviceSessionOpen 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,
+        'DeviceSessionOpen'
+      )
+    ).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

@@ -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,3 +1,5 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import ClearSessionCache from '../src/api/ClearSessionCache';
 import {
   DeviceWalletSessionStore,
@@ -5,6 +7,7 @@ import {
 } 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'),
@@ -116,7 +119,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 +148,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 +169,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 +239,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/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-host-binding.test.ts

@@ -0,0 +1,70 @@
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  resolveFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
+
+const createBinding = () => ({
+  artifactReader: {
+    open: jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: 4 })),
+    read: jest.fn(() =>
+      Promise.resolve({
+        data: new ArrayBuffer(4),
+        bytesRead: 4,
+        eof: true,
+      })
+    ),
+    close: jest.fn(() => Promise.resolve()),
+  },
+});
+
+describe('firmware host binding generation', () => {
+  afterEach(() => {
+    unregisterFirmwareUpdateHostBinding();
+  });
+
+  test('invalidates callbacks from a replaced generation', async () => {
+    const staleBinding = createBinding();
+    const staleGeneration = registerFirmwareUpdateHostBinding(staleBinding);
+    const stale = resolveFirmwareUpdateHostBinding(staleGeneration);
+    const activeGeneration = registerFirmwareUpdateHostBinding(createBinding());
+
+    expect(activeGeneration).toBeGreaterThan(staleGeneration);
+    expect(getFirmwareUpdateHostBindingGeneration()).toBe(activeGeneration);
+    await expect(
+      stale.artifactReader.read({
+        readerId: 'reader-1',
+        offset: 0,
+        length: 4,
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+      },
+    });
+    expect(unregisterFirmwareUpdateHostBinding(staleGeneration)).toBe(false);
+    expect(getFirmwareUpdateHostBindingGeneration()).toBe(activeGeneration);
+  });
+
+  test('closes an artifact opened during a generation race', async () => {
+    const binding = createBinding();
+    binding.artifactReader.open.mockImplementationOnce(() => {
+      registerFirmwareUpdateHostBinding(createBinding());
+      return Promise.resolve({ readerId: 'stale-reader', size: 4 });
+    });
+    const generation = registerFirmwareUpdateHostBinding(binding);
+    const guarded = resolveFirmwareUpdateHostBinding(generation);
+
+    await expect(
+      guarded.artifactReader.open({ artifactRef: `fw:${'a'.repeat(64)}` })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+      },
+    });
+    expect(binding.artifactReader.close).toHaveBeenCalledWith({
+      readerId: 'stale-reader',
+    });
+  });
+});

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

@@ -0,0 +1,13 @@
+import { getFirmwareUpdateCapabilities } from '../../src/api/firmware/FirmwareUpdateCapabilities';
+
+describe('getFirmwareUpdateCapabilities', () => {
+  it('advertises only the prepared artifact contract', () => {
+    expect(getFirmwareUpdateCapabilities()).toEqual({
+      planSchemaVersion: 2,
+      preparedPlanSchemaVersion: 2,
+      hostBindingProtocolVersion: 2,
+      manifestModes: ['external-only', 'sdk-managed'],
+      supportsArtifactReader: true,
+    });
+  });
+});