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

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

@@ -0,0 +1,70 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+
+import type { Device } from '../../src/device/Device';
+import type { FirmwareByteSource } from '../../src/api/firmware/FirmwareArtifactSource';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('uploadFirmwareFromSource', () => {
+  it('serves legacy Touch firmware requests without materializing the complete artifact', async () => {
+    const size = 700 * 1024;
+    const requestedRanges: Array<{ offset: number; length: number }> = [];
+    const source: FirmwareByteSource = {
+      size,
+      readAt: jest.fn((offset: number, length: number) => {
+        requestedRanges.push({ offset, length });
+        return Promise.resolve(new ArrayBuffer(length));
+      }),
+      close: jest.fn(() => Promise.resolve()),
+    };
+    let nextOffset = 0;
+    const requestedLength = 128 * 1024;
+    const typedCall = jest.fn((type: string) => {
+      if (type === 'FirmwareErase') {
+        return Promise.resolve({
+          type: 'FirmwareRequest',
+          message: {
+            offset: nextOffset,
+            length: Math.min(requestedLength, size - nextOffset),
+          },
+        });
+      }
+      if (type === 'FirmwareUpload') {
+        nextOffset += Math.min(requestedLength, size - nextOffset);
+        if (nextOffset < size) {
+          return Promise.resolve({
+            type: 'FirmwareRequest',
+            message: {
+              offset: nextOffset,
+              length: Math.min(requestedLength, size - nextOffset),
+            },
+          });
+        }
+        return Promise.resolve({
+          type: 'Success',
+          message: { message: 'installed' },
+        });
+      }
+      return Promise.reject(new Error(`Unexpected command: ${type}`));
+    });
+    const device = {
+      features: undefined,
+      emit: jest.fn(),
+      getCurrentDeviceType: () => EDeviceType.Touch,
+      toMessageObject: () => ({}),
+    } as unknown as Device;
+
+    await expect(
+      uploadFirmwareFromSource('firmware', typedCall as never, jest.fn(), device, source)
+    ).resolves.toEqual({ message: 'installed' });
+
+    expect(requestedRanges).toHaveLength(Math.ceil(size / requestedLength));
+    expect(requestedRanges.every(({ length }) => length <= 256 * 1024)).toBe(true);
+    expect(requestedRanges.some(({ length }) => length === size)).toBe(false);
+  });
+});

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

@@ -28,6 +28,7 @@ const createDevice = ({
     commands: { typedCall, promptPassphrase },
     getDeviceState: jest.fn().mockResolvedValue({
       identity: { deviceId: 'device-1' },
+      status: { passphraseProtection },
     }),
     getCurrentDeviceId: () => 'device-1',
     getCurrentPassphraseProtection: () => passphraseProtection,
@@ -145,6 +146,7 @@ describe('openWalletSession', () => {
       walletType: 'standard',
       deviceId: 'device-1',
       passphraseState: null,
+      sessionId: 'main-wallet-session',
       resumed: false,
     });
     expect(method.payload.useEmptyPassphrase).toBe(true);
@@ -175,6 +177,43 @@ describe('openWalletSession', () => {
     });
   });
 
+  test('classifies the selected Pro2 wallet from the post-unlock device state', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state-after-unlock',
+          session_id: 'hidden-session-after-unlock',
+        },
+      });
+    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({ passphraseProtection: false, typedCall, promptPassphrase });
+    device.features.unlocked = false;
+    device.getCurrentPassphraseProtection = () => device.features.passphraseProtection;
+    device.unlockDevice = jest.fn().mockImplementation(() => {
+      device.features.unlocked = true;
+      device.features.passphraseProtection = true;
+      return Promise.resolve(device.features);
+    });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toEqual({
+      protocol: 'V2',
+      walletType: 'hidden',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-state-after-unlock',
+      sessionId: 'hidden-session-after-unlock',
+      resumed: false,
+    });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(promptPassphrase).toHaveBeenCalledTimes(1);
+  });
+
   test('uses legacy initSession to replace a hidden-wallet session on Protocol V2', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       message: {
@@ -201,10 +240,16 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       deviceId: 'device-1',
       passphraseState: 'new-hidden-state',
+      sessionId: 'new-hidden-session',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: { host_passphrase: { passphrase: 'new hidden secret' } },
+    });
+    expect(promptPassphrase).toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'stale-hidden-state')).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
   });
@@ -266,10 +311,11 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       deviceId: 'device-1',
       passphraseState: 'hidden-state',
+      sessionId: 'renewed-session',
       resumed: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      resume: { session_id: 'known-session' },
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -378,7 +424,7 @@ describe('openWalletSession', () => {
   });
 
   test('opens the standard wallet without selecting a hidden wallet', async () => {
-    const typedCall = jest.fn();
+    const typedCall = jest.fn().mockResolvedValue({ message: { version: 2 } });
     const promptPassphrase = jest.fn();
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
@@ -395,17 +441,61 @@ describe('openWalletSession', () => {
       passphraseState: null,
       resumed: false,
     });
-    expect(typedCall).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
   });
 
+  test('opens a locked Protocol V2 standard wallet after deviceId becomes available', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: { version: 2 } });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
+    });
+    method.init();
+    const device = createDevice({ typedCall });
+    device.features.unlocked = false;
+    device.getDeviceState = jest
+      .fn()
+      .mockResolvedValueOnce({
+        identity: { deviceId: undefined },
+        status: { passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        identity: { deviceId: 'device-1' },
+        status: { passphraseProtection: true },
+      });
+    device.unlockDevice = jest.fn().mockImplementation(() => {
+      device.features.unlocked = true;
+      return Promise.resolve(device.features);
+    });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toEqual({
+      protocol: 'V2',
+      walletType: 'standard',
+      deviceId: 'device-1',
+      passphraseState: null,
+      resumed: false,
+    });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.getDeviceState).toHaveBeenCalledTimes(2);
+  });
+
   test('rejects a standard-wallet request when Protocol V2 is unlocked by Attach PIN', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        btc_test_address: 'attach-wallet-state',
+        session_id: 'attach-wallet-session',
+      },
+    });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
     });
     method.init();
-    const device = createDevice();
+    const device = createDevice({ typedCall });
     device.features.unlockedAttachPin = true;
     method.device = device as any;
 
@@ -416,7 +506,7 @@ describe('openWalletSession', () => {
     expect(device.clearInternalState).toHaveBeenCalled();
   });
 
-  test('selects a hidden wallet and keeps the session inside the SDK store', async () => {
+  test('selects a hidden wallet and returns the CLI compatibility session', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       message: {
         btc_test_address: 'hidden-state',
@@ -437,14 +527,63 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       deviceId: 'device-1',
       passphraseState: 'hidden-state',
+      sessionId: 'hidden-session',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: { host_passphrase: { passphrase: 'hidden secret' } },
+    });
+    expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
+  test('selects on-device passphrase entry through DeviceSessionOpen', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: { btc_test_address: 'device-state', session_id: 'device-session' },
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'device-state',
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: { passphrase_on_device: {} },
+    });
+  });
+
+  test('selects Attach PIN only when the device reports an existing binding', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: { btc_test_address: 'attach-state', session_id: 'attach-session' },
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({ typedCall, promptPassphrase });
+    device.features.attachToPinEnabled = true;
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'attach-state',
+    });
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      expect.objectContaining({ existsAttachPinUser: true }),
+      { cancelDeviceOnReject: false }
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: { attach_pin_on_device: {} },
+    });
+  });
+
   test.each([
     {
       missingField: 'session_id',
@@ -468,7 +607,7 @@ describe('openWalletSession', () => {
 
       await expect(method.run()).rejects.toMatchObject({
         errorCode: HardwareErrorCode.RuntimeError,
-        message: 'DeviceSessionGet returned an incomplete DeviceSession response.',
+        message: 'DeviceSessionOpen returned an incomplete DeviceSession response.',
       });
       expect(device.clearInternalState).toHaveBeenCalled();
       expect(device.updateInternalState).not.toHaveBeenCalled();
@@ -501,14 +640,115 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       deviceId: 'device-1',
       passphraseState: 'hidden-state',
+      sessionId: 'renewed-session',
       resumed: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      resume: { session_id: 'known-session' },
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
 
+  test('validates a locked Protocol V2 resume binding after deviceId refresh', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        btc_test_address: 'hidden-state',
+        session_id: 'renewed-session',
+      },
+    });
+    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.features.unlocked = false;
+    device.getDeviceState = jest
+      .fn()
+      .mockResolvedValueOnce({
+        identity: { deviceId: undefined },
+        status: { passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        identity: { deviceId: 'device-1' },
+        status: { passphraseProtection: true },
+      });
+    device.unlockDevice = jest.fn().mockImplementation(() => {
+      device.features.unlocked = true;
+      return Promise.resolve(device.features);
+    });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      protocol: 'V2',
+      walletType: 'hidden',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-state',
+      resumed: true,
+    });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.getDeviceState).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      resume: { session_id: 'known-session' },
+    });
+    const sessionOpenCall = typedCall.mock.calls.findIndex(
+      ([requestName]) => requestName === 'DeviceSessionOpen'
+    );
+    expect(device.getDeviceState.mock.invocationCallOrder[1]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[sessionOpenCall]
+    );
+  });
+
+  test('rejects a Protocol V2 resume when the refreshed deviceId does not match', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        btc_test_address: 'hidden-state',
+        session_id: 'renewed-session',
+      },
+    });
+    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.features.unlocked = false;
+    device.getDeviceState = jest
+      .fn()
+      .mockResolvedValueOnce({
+        identity: { deviceId: undefined },
+        status: { passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        identity: { deviceId: 'other-device' },
+        status: { passphraseProtection: true },
+      });
+    device.unlockDevice = jest.fn().mockImplementation(() => {
+      device.features.unlocked = true;
+      return Promise.resolve(device.features);
+    });
+    method.device = device as any;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckDeviceIdError,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+    expect(device.clearInternalState).not.toHaveBeenCalled();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBeUndefined();
+  });
+
   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'), {

package/__tests__/pro2Wallpaper.test.ts

@@ -10,18 +10,7 @@ describe('encodePro2Wallpaper', () => {
 
     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,
+      0x19, 0x12, 0, 0, 2, 0, 1, 0, 4, 0, 0, 0,
     ]);
     expect(Array.from(result.data.slice(12))).toEqual([0x00, 0xf0, 0xc0, 0x07]);
   });
@@ -40,11 +29,11 @@ describe('encodePro2Wallpaper', () => {
   });
 
   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');
+    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-unlock-policy.test.ts

@@ -0,0 +1,45 @@
+import * as publicMethods from '../src/api';
+import {
+  PROTOCOL_V2_RETRY_ON_LOCKED_METHODS,
+  getProtocolV2UnlockPolicy,
+} from '../src/protocols/protocol-v2/unlockPolicy';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+describe('Protocol V2 public method unlock policy', () => {
+  test('classifies the complete public method table with an explicit replay allowlist', () => {
+    const publicMethodNames = Object.keys(publicMethods);
+    const retryMethodNames = new Set<string>(PROTOCOL_V2_RETRY_ON_LOCKED_METHODS);
+
+    expect(publicMethodNames.length).toBeGreaterThan(100);
+    expect(new Set(PROTOCOL_V2_RETRY_ON_LOCKED_METHODS).size).toBe(
+      PROTOCOL_V2_RETRY_ON_LOCKED_METHODS.length
+    );
+
+    for (const methodName of PROTOCOL_V2_RETRY_ON_LOCKED_METHODS) {
+      expect(publicMethods).toHaveProperty(methodName);
+    }
+
+    for (const methodName of publicMethodNames) {
+      expect(getProtocolV2UnlockPolicy(methodName)).toBe(
+        retryMethodNames.has(methodName) ? 'retry-on-locked' : 'none'
+      );
+    }
+  });
+
+  test.each([
+    'deviceUnlock',
+    'deviceLock',
+    'deviceWipe',
+    'deviceChangePin',
+    'deviceSettings',
+    'firmwareUpdateV4',
+    'deviceUploadWallpaper',
+    'uploadPortfolio',
+  ])('does not make the state-changing method %s replayable by default', methodName => {
+    expect(getProtocolV2UnlockPolicy(methodName)).toBe('none');
+  });
+});