@onekeyfe/hd-core 1.2.0-alpha.35 → 1.2.0-alpha.36

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -18,6 +18,79 @@ class TestAllNetworkMethod extends AllNetworkGetAddressBase {
 }
 
 describe('AllNetworkGetAddressBase tracing', () => {
+  test('resumes a Protocol V2 hidden wallet before running a nested chain method', async () => {
+    const calls: string[] = [];
+    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
+      calls.push('resume-hidden-session');
+      return Promise.resolve(true);
+    });
+    const innerMethod = {
+      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      getVersionRange: jest.fn().mockReturnValue({}),
+      assertProtocolSupported: jest.fn(),
+      init: jest.fn(),
+      name: 'evmGetAddress',
+      responseID: 43,
+      run: jest.fn().mockImplementation(() => {
+        calls.push('run-chain-method');
+        return Promise.resolve([{ address: '0xhidden' }]);
+      }),
+      setDevice: jest.fn(),
+      strictCheckDeviceSupport: false,
+    };
+    (findMethod as jest.Mock).mockReturnValue(innerMethod);
+    const method = new TestAllNetworkMethod({
+      id: 1,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        passphraseState: 'hidden-state',
+        bundle: [],
+      },
+    });
+    method.device = {
+      checkPassphraseStateSafety,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
+      },
+      getCurrentFirmwareType: jest.fn(),
+      getProtocol: jest.fn().mockReturnValue('V2'),
+      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
+      getCurrentMethodVersionRange: jest
+        .fn()
+        .mockImplementation((getRange: (type: string) => unknown) => getRange('pro2')),
+      instanceId: 'device-instance',
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isBootloader: jest.fn().mockReturnValue(false),
+      isRomloader: jest.fn().mockReturnValue(false),
+      off: jest.fn(),
+      on: jest.fn(),
+      state: { status: { unlocked: true } },
+      updateProtocolV2Status: jest.fn(),
+    } as any;
+
+    await method.callMethod(
+      'evmGetAddress',
+      {
+        bundle: [
+          {
+            _originRequestParams: {
+              network: 'evm',
+              path: "m/44'/60'/0'/0/0",
+            },
+          },
+        ],
+      },
+      0
+    );
+
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined);
+    expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
+  });
+
   test('releases the nested request context when an unhandled error escapes', async () => {
     const deviceInstanceId = 'device-instance';
     const innerMethod = {
@@ -51,6 +124,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       getCurrentMethodVersionRange: jest
         .fn()
         .mockImplementation((getRange: (type: string) => unknown) => getRange('classic')),
+      isProtocolV2: jest.fn().mockReturnValue(false),
       off: jest.fn(),
       on: jest.fn(),
     } as any;

package/__tests__/DeviceEventRegistration.test.ts

@@ -3,6 +3,8 @@ import { registerHardwareUiEventListeners } from '../src/core/deviceEventRegistr
 
 const handlers = {
   pin: jest.fn(),
+  pinOnDevice: jest.fn(),
+  pinOnDeviceComplete: jest.fn(),
   button: jest.fn(),
   passphrase: jest.fn(),
   passphraseOnDevice: jest.fn(),
@@ -21,6 +23,8 @@ describe('hardware UI event registration', () => {
     expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
     expect(device.on.mock.calls.map(([type]) => type)).toEqual([
       DEVICE.PIN,
+      DEVICE.PIN_ON_DEVICE,
+      DEVICE.PIN_ON_DEVICE_COMPLETE,
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,
@@ -34,6 +38,8 @@ describe('hardware UI event registration', () => {
     expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
     expect(device.on.mock.calls.map(([type]) => type)).toEqual([
       DEVICE.PIN,
+      DEVICE.PIN_ON_DEVICE,
+      DEVICE.PIN_ON_DEVICE_COMPLETE,
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,

package/__tests__/get-device-state.test.ts

@@ -1,4 +1,4 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceType } from '@onekeyfe/hd-transport';
 
 import { Device } from '../src/device/Device';
@@ -43,6 +43,70 @@ const getProtocolV2LoaderInfo = (mode: 'bootloader' | 'romloader') => ({
 });
 
 describe('getDeviceState', () => {
+  test('coalesces concurrent Protocol V2 runtime-context negotiation', async () => {
+    let resolveProtocolInfo:
+      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
+      | undefined;
+    const typedCall = jest.fn(
+      () =>
+        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
+          resolveProtocolInfo = resolve;
+        })
+    );
+    const device = createV2Device(typedCall);
+
+    const first = device.ensureProtocolV2RuntimeContext();
+    const second = device.ensureProtocolV2RuntimeContext();
+    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
+
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      protocolV2ApplicationInfo,
+      protocolV2ApplicationInfo,
+    ]);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+  });
+
+  test('renegotiates Protocol V2 runtime context after transport disconnect', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: protocolV2ApplicationInfo });
+    const device = createV2Device(typedCall);
+
+    await device.ensureProtocolV2RuntimeContext();
+    await device.ensureProtocolV2RuntimeContext();
+    device.markTransportDisconnected();
+    await device.ensureProtocolV2RuntimeContext();
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+  });
+
+  test('rejects every waiter when runtime-context negotiation is invalidated', async () => {
+    let resolveProtocolInfo:
+      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
+      | undefined;
+    const typedCall = jest.fn(
+      () =>
+        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
+          resolveProtocolInfo = resolve;
+        })
+    );
+    const device = createV2Device(typedCall);
+
+    const first = device.ensureProtocolV2RuntimeContext();
+    const second = device.ensureProtocolV2RuntimeContext();
+    const firstExpectation = expect(first).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInitializeFailed,
+    });
+    const secondExpectation = expect(second).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInitializeFailed,
+    });
+    device.markTransportDisconnected();
+    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
+
+    await Promise.all([firstExpectation, secondExpectation]);
+  });
+
   test('does not expose the internal wallet session', async () => {
     const device = createV2Device(jest.fn());
     device.updateState({ protocol: 'V2' }, 'initialize');
@@ -159,15 +223,20 @@ describe('getDeviceState', () => {
         throw new Error(`Unexpected request: ${requestType}`);
       });
       const device = createV2Device(typedCall);
-      device.updateState({ protocol: 'V2', status: { mode } }, 'initialize');
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType: EDeviceType.Pro2 },
+          status: { mode },
+          raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode) },
+        },
+        'initialize'
+      );
 
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-        'DeviceInfoGet',
-        'ProtocolInfoRequest',
-      ]);
+      expect(typedCall).not.toHaveBeenCalled();
     }
   );
 
@@ -187,7 +256,14 @@ describe('getDeviceState', () => {
       return { message: { init_states: true, unlocked: true, device_id: 'device-1' } };
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
 
     const state = await device.getDeviceState({ refreshSections: ['status'] });
 
@@ -205,7 +281,14 @@ describe('getDeviceState', () => {
       },
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
     const onState = jest.fn();
     device.on(DEVICE.STATE, onState);
 
@@ -250,13 +333,18 @@ describe('getDeviceState', () => {
       throw new Error(`Unexpected request: ${requestType}`);
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
 
     const state = await device.getDeviceState({ refreshSections: ['status', 'settings'] });
 
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceInfoGet',
-      'ProtocolInfoRequest',
       'DeviceStatusGet',
       'DeviceSettingsGet',
     ]);
@@ -288,7 +376,11 @@ describe('getDeviceState', () => {
     });
     const device = createV2Device(typedCall);
     device.updateState(
-      { protocol: 'V2', status: { mode: 'normal', unlocked: true } },
+      {
+        protocol: 'V2',
+        status: { mode: 'normal', unlocked: true },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
       'initialize'
     );
 

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

@@ -1,10 +1,11 @@
 import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
 
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import OpenWalletSession from '../src/api/OpenWalletSession';
 import { Device } from '../src/device/Device';
 import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
+import { ensureProtocolV2WalletSessionUnlocked } from '../src/protocols/protocol-v2/walletSession';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -43,6 +44,11 @@ const createDevice = ({
       }),
       promptPassphrase,
     },
+    ensureProtocolV2RuntimeContext: jest.fn(() =>
+      device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+        eventless_wallet_session: true,
+      })
+    ),
     getDeviceState: jest.fn().mockResolvedValue({
       identity: { deviceId: 'device-1' },
       status: { passphraseProtection },
@@ -82,6 +88,50 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.clear();
   });
 
+  test('unlocks a locked Protocol V2 device before restoring a wallet session', async () => {
+    const device = {
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: false } }),
+      },
+      isBootloader: jest.fn().mockReturnValue(false),
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isRomloader: jest.fn().mockReturnValue(false),
+      state: { status: { unlocked: false } },
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+      updateProtocolV2Status: jest.fn(function updateProtocolV2Status(
+        this: { state: { status: { unlocked: boolean } } },
+        status: { unlocked?: boolean }
+      ) {
+        this.state.status.unlocked = status.unlocked ?? this.state.status.unlocked;
+      }),
+    };
+
+    await expect(ensureProtocolV2WalletSessionUnlocked(device as any)).resolves.toBe(true);
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+    });
+  });
+
+  test('does not request PIN when wallet-session recovery finds the device unlocked', async () => {
+    const device = {
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
+      },
+      isBootloader: jest.fn().mockReturnValue(false),
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isRomloader: jest.fn().mockReturnValue(false),
+      state: { status: { unlocked: true } },
+      unlockDevice: jest.fn(),
+      updateProtocolV2Status: jest.fn(),
+    };
+
+    await expect(ensureProtocolV2WalletSessionUnlocked(device as any)).resolves.toBe(false);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+  });
+
   test.each([{ useEmptyPassphrase: true }, { initSession: true }, {}])(
     'requires the explicit mode in the new public API: %p',
     legacyParams => {
@@ -479,6 +529,7 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -656,7 +707,11 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
@@ -701,7 +756,11 @@ describe('openWalletSession', () => {
       passphraseState: null,
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
   });
 
@@ -721,6 +780,14 @@ describe('openWalletSession', () => {
     method.init();
     const device = createDevice({ typedCall });
     device.features.unlockedAttachPin = true;
+    device.getDeviceState = jest.fn().mockResolvedValue({
+      identity: { deviceId: 'device-1' },
+      status: {
+        unlocked: true,
+        unlockedAttachPin: true,
+        passphraseProtection: true,
+      },
+    });
     device.unlockDevice = jest.fn().mockImplementation(() => {
       device.features.unlockedAttachPin = false;
       return Promise.resolve(device.features);
@@ -731,7 +798,11 @@ describe('openWalletSession', () => {
       walletType: 'standard',
       passphraseState: null,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -939,7 +1010,9 @@ describe('openWalletSession', () => {
       },
       { cancelDeviceOnReject: false }
     );
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
+      emitUiEvent: false,
+    });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -1180,6 +1253,7 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1234,6 +1308,7 @@ describe('openWalletSession', () => {
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
     });
     const sessionGetCall = typedCall.mock.calls.findIndex(
       ([requestName]) => requestName === 'DeviceSessionGet'
@@ -1326,6 +1401,7 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'expired-session',
+      btc_test_address: 'hidden-state',
     });
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
@@ -1335,7 +1411,6 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state',
@@ -1362,7 +1437,56 @@ describe('openWalletSession', () => {
       passphraseState: 'hidden-state',
       resumed: false,
     });
-    expect(promptPassphrase).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      btc_test_address: 'hidden-state',
+    });
+    expect(promptPassphrase).not.toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
   });
+
+  test.each([
+    {
+      deriveCardano: false,
+      seedDomains: [DeviceSessionSeedDomain.SeedDomain_Standard],
+    },
+    {
+      deriveCardano: true,
+      seedDomains: [
+        DeviceSessionSeedDomain.SeedDomain_Standard,
+        DeviceSessionSeedDomain.SeedDomain_Cardano,
+      ],
+    },
+  ])('requests the selected seed domains: $seedDomains', async ({ deriveCardano, seedDomains }) => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'new-session',
+        },
+      });
+    const method = new OpenWalletSession({
+      payload: {
+        method: 'openWalletSession',
+        connectId: 'connect-id',
+        mode: 'select-hidden',
+        deriveCardano,
+      },
+    });
+    method.init();
+    method.device = createDevice({
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
+    }) as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state',
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: seedDomains,
+    });
+  });
 });

package/__tests__/protocol-v2-ui-lifecycle.test.ts

@@ -0,0 +1,56 @@
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+
+import { DEVICE } from '../src/events';
+import { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://example.com/',
+}));
+
+describe('Protocol V2 UI interaction lifecycle', () => {
+  test('emits a matching PIN phase completion after DeviceSessionAskPin succeeds', async () => {
+    const device = new Device({ id: 'connect-1' } as any);
+    device.isProtocolV2 = jest.fn(() => true);
+    device.updateProtocolV2Status = jest.fn(() => undefined as any);
+    device.commands = {
+      typedCall: jest.fn().mockResolvedValue({
+        message: { unlocked: true },
+      }),
+    } as any;
+    device.beginProtocolV2UiInteraction();
+
+    const starts: unknown[] = [];
+    const completions: unknown[] = [];
+    device.on(DEVICE.PIN_ON_DEVICE, (...args) => starts.push(args));
+    device.on(DEVICE.PIN_ON_DEVICE_COMPLETE, (...args) => completions.push(args));
+
+    await device.unlockDevice(DeviceSessionPinType.Main, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+    });
+
+    const startMetadata = (starts[0] as unknown[])[2] as Record<string, unknown>;
+    const completionMetadata = (completions[0] as unknown[])[1] as Record<string, unknown>;
+    expect(startMetadata.interaction).toMatchObject({
+      phase: 'pin',
+      transition: 'start',
+      protocol: 'V2',
+    });
+    expect(completionMetadata).toMatchObject({
+      interactionId: (startMetadata.interaction as { interactionId: string }).interactionId,
+      phaseId: (startMetadata.interaction as { phaseId: string }).phaseId,
+      phase: 'pin',
+      transition: 'complete',
+      outcome: 'succeeded',
+      protocol: 'V2',
+    });
+    expect(completionMetadata.sequence).toBeGreaterThan(
+      (startMetadata.interaction as { sequence: number }).sequence
+    );
+    expect(completionMetadata.phaseId).toBe(
+      (startMetadata.interaction as { phaseId: string }).phaseId
+    );
+  });
+});