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

package/__tests__/DeviceCommands.test.ts

@@ -19,6 +19,90 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
+  it('logs passphrase call request and response without exposing the passphrase', async () => {
+    const commands = createCommands();
+    const requestLog = getLogger(LoggerNames.DeviceCommands);
+    const responseLog = getLogger(LoggerNames.Core);
+    requestLog.messages.length = 0;
+    responseLog.messages.length = 0;
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockResolvedValue({
+        type: 'Success',
+        message: {
+          message: 'Passphrase accepted',
+        },
+      }),
+    } as any;
+
+    await expect(
+      commands.call('DeviceSessionAskPassphrase', {
+        passphrase: 'hidden-wallet-secret',
+        on_device: false,
+      })
+    ).resolves.toMatchObject({ type: 'Success' });
+
+    expect(requestLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Sending',
+      'DeviceSessionAskPassphrase',
+      {
+        passphrase: '[REDACTED]',
+        on_device: false,
+      },
+    ]);
+    expect(responseLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Received',
+      'Success',
+      {
+        message: 'Passphrase accepted',
+      },
+    ]);
+    expect(JSON.stringify([...requestLog.messages, ...responseLog.messages])).not.toContain(
+      'hidden-wallet-secret'
+    );
+  });
+
+  it('logs DeviceStatus response fields without exposing the device ID', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockResolvedValue({
+        type: 'DeviceStatus',
+        message: {
+          device_id: 'sensitive-device-id',
+          unlocked: true,
+          init_states: true,
+          backup_required: false,
+          passphrase_enabled: true,
+          attach_to_pin_enabled: false,
+          unlocked_by_attach_to_pin: false,
+        },
+      }),
+    } as any;
+
+    await expect(commands.call('DeviceStatusGet', {})).resolves.toMatchObject({
+      type: 'DeviceStatus',
+    });
+
+    const receivedLog = log.messages.at(-1)?.message;
+    expect(receivedLog).toEqual([
+      '[DeviceCommands] [call] Received',
+      'DeviceStatus',
+      {
+        device_id: '[REDACTED]',
+        unlocked: true,
+        init_states: true,
+        backup_required: false,
+        passphrase_enabled: true,
+        attach_to_pin_enabled: false,
+        unlocked_by_attach_to_pin: false,
+      },
+    ]);
+    expect(JSON.stringify(receivedLog)).not.toContain('sensitive-device-id');
+  });
+
   it('does not log DeviceSessionGet response secrets', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -160,6 +160,37 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
   });
 
+  test('keeps same-version hash-aware components unknown without metadata payloadHash', () => {
+    const packageSet: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      resourceBundles: undefined,
+      installOrder: ['applicationP1'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          version: [1, 0, 0],
+          url: 'https://untrusted.example/application-p1.okpkg',
+          fingerprint: 'file-sha256-p1',
+        },
+      },
+    };
+
+    expect(
+      buildProtocolV2FirmwareRelease({
+        currentVersions: { ...currentVersions, applicationP1: '1.0.0' },
+        currentVerification: { applicationP1Hash: 'aa'.repeat(32) },
+        firmwareType: EFirmwareType.Universal,
+        release: packageSet,
+      })
+    ).toMatchObject({
+      status: 'unknown',
+      hasUpgrade: false,
+      targetsToUpdate: [],
+      components: [{ configKey: 'applicationP1', status: 'unknown' }],
+    });
+  });
+
   test('updates both application packages when normal mode only reports P1', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,

package/__tests__/core-dispose.test.ts

@@ -17,18 +17,18 @@ describe('Core.dispose', () => {
     const connectorStop = jest.spyOn(connector, 'stop');
     const transportStop = jest.fn().mockResolvedValue(undefined);
     jest.spyOn(TransportManager, 'getTransport').mockReturnValue({ stop: transportStop } as never);
-    const resetDevicePool = jest.spyOn(DevicePool, 'resetState');
+    const disposeDevicePool = jest.spyOn(DevicePool, 'dispose');
     const core = new Core();
 
     const firstDispose = core.dispose();
     expect(connectorStop).toHaveBeenCalledTimes(1);
     expect(transportStop).toHaveBeenCalledTimes(1);
-    expect(resetDevicePool).toHaveBeenCalledTimes(1);
+    expect(disposeDevicePool).toHaveBeenCalledTimes(1);
 
     await firstDispose;
     await core.dispose();
     expect(connectorStop).toHaveBeenCalledTimes(1);
     expect(transportStop).toHaveBeenCalledTimes(1);
-    expect(resetDevicePool).toHaveBeenCalledTimes(1);
+    expect(disposeDevicePool).toHaveBeenCalledTimes(1);
   });
 });

package/__tests__/device-lifecycle-events.test.ts

@@ -79,6 +79,57 @@ describe('public device lifecycle events', () => {
     expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
   });
 
+  test('keeps shared device lifecycle listeners across a device cache reset', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+    const messages: CoreMessage[] = [];
+    core.on(CORE_EVENT, message => messages.push(message));
+    const device = createInitializedDevice('V2');
+
+    DevicePool.resetState();
+    DevicePool.emitter.emit(DEVICE.CONNECT, device);
+    DevicePool.emitter.emit(DEVICE.DISCONNECT, device);
+
+    expect(messages.filter(message => message.type === DEVICE.CONNECT)).toHaveLength(1);
+    expect(messages.filter(message => message.type === DEVICE.DISCONNECT)).toHaveLength(1);
+  });
+
+  test('uses a cached protocol as a fallback-capable acquire hint', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire();
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, 'V1');
+    expect(device.getProtocol()).toBe('V2');
+    expect(device.originalDescriptor.protocolType).toBe('V2');
+  });
+
+  test('keeps an explicit connectProtocol as a strict expected protocol', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire('V2');
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V2', undefined);
+    expect(device.getProtocol()).toBe('V2');
+  });
+
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -125,6 +176,7 @@ describe('public device lifecycle events', () => {
     const device = createInitializedDevice('V2');
 
     expect(device.toMessageObject()?.status).toBe('available');
+    expect(device.toMessageObject()?.connectProtocol).toBe('V2');
 
     (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
     expect(device.toMessageObject()?.status).toBe('used');

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

@@ -9,11 +9,11 @@ jest.mock('../src/data/config', () => ({
 
 describe('DevicePool state lifecycle', () => {
   beforeEach(() => {
-    DevicePool.resetState();
+    DevicePool.dispose();
   });
 
   afterEach(() => {
-    DevicePool.resetState();
+    DevicePool.dispose();
   });
 
   test('refreshes runtime state for a cached Protocol V2 discovery result', async () => {
@@ -74,6 +74,18 @@ describe('DevicePool state lifecycle', () => {
     expect(DevicePool.disconnectPool).toEqual([]);
   });
 
+  test('preserves shared listeners when resetting cached device state', () => {
+    const listener = jest.fn();
+    DevicePool.emitter.on(DEVICE.CONNECT, listener);
+    DevicePool.devicesCache = { stale: {} as Device };
+
+    DevicePool.resetState();
+    DevicePool.emitter.emit(DEVICE.CONNECT, { path: 'next-device' });
+
+    expect(DevicePool.devicesCache).toEqual({});
+    expect(listener).toHaveBeenCalledWith({ path: 'next-device' });
+  });
+
   test('releases a newly created device when initialization fails', async () => {
     const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
     const release = jest.fn().mockResolvedValue(undefined);

package/__tests__/device-settings.test.ts

@@ -40,6 +40,9 @@ describe('DeviceSettings protocol routing', () => {
     ['language', { language: 'ja-JP' }],
     ['brightness', { brightness: 80 }],
     ['haptic feedback', { hapticFeedback: true }],
+    ['animation', { animationEnabled: true }],
+    ['tap to wake', { tapToWake: true }],
+    ['device name display', { deviceNameDisplayEnabled: true }],
   ])('does not unlock Protocol V2 before changing %s', (_name, settings) => {
     const method = new DeviceSettings({
       id: 1,
@@ -226,6 +229,28 @@ describe('DeviceSettings protocol routing', () => {
     });
   });
 
+  it('accepts a locked Pro2 as confirmation after disabling passphrase', async () => {
+    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        status: { unlocked: true, passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        status: { unlocked: false, passphraseProtection: true },
+      });
+    const method = new DeviceSettings({
+      id: 6,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: false,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+  });
+
   it('keeps Protocol V1 passphrase settings on ApplySettings', async () => {
     const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V1' });
     const method = new DeviceSettings({

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

@@ -1,6 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+import { DeviceType, Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 import {
   mapApplySettingsToState,
   mapDeviceSettingsToState,
@@ -109,7 +109,7 @@ describe('DeviceStateMapper', () => {
     const patch = mapProtocolV2DeviceInfoToState(
       {
         protocol_version: 2,
-        hw: { serial_no: 'SERIAL-1' },
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
         fw: {
           application: { version: '5.0.0', build_id: 'p1-build', hash: [0x01, 0x02] },
           application_data: { version: '5.0.1', build_id: 'p2-build', hash: [0x03, 0x04] },
@@ -145,6 +145,17 @@ describe('DeviceStateMapper', () => {
     expect(patch.status?.unlocked).toBeUndefined();
   });
 
+  test('maps the hardware model independently from Protocol V2', () => {
+    const pro = mapProtocolV2DeviceInfoToState({
+      protocol_version: 2,
+      hw: { Device_type: 'PRO' as unknown as DeviceType, serial_no: 'SERIAL-PRO' },
+    });
+    const unknown = mapProtocolV2DeviceInfoToState({ protocol_version: 2, hw: {} });
+
+    expect(pro.identity).toMatchObject({ deviceType: EDeviceType.Pro, model: 'pro' });
+    expect(unknown.identity).toMatchObject({ deviceType: EDeviceType.Unknown, model: null });
+  });
+
   test('keeps normal mode when Protocol V2 application and SE versions are returned together', () => {
     const patch = mapProtocolV2DeviceInfoToState(
       {

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

@@ -73,7 +73,7 @@ describe('DeviceStateProjector', () => {
     });
   });
 
-  test('returns an isolated compatibility snapshot', () => {
+  test('returns an isolated compatibility snapshot without internal raw state', () => {
     const state = createEmptyDeviceState({ deviceType: EDeviceType.Pro });
     state.protocol = 'V1';
     state.capabilities = [1];
@@ -85,10 +85,10 @@ describe('DeviceStateProjector', () => {
     const features = projectFeatures(state);
     features.capabilities.push(2);
     if (features.verify) features.verify.firmwareBuildId = 'mutated';
-    if (features.raw?.protocolV1Features) features.raw.protocolV1Features.label = 'Mutated';
 
     expect(state.capabilities).toEqual([1]);
     expect(state.verification?.firmwareBuildId).toBe('build-1');
     expect(state.raw.protocolV1Features?.label).toBe('Original');
+    expect(features).not.toHaveProperty('raw');
   });
 });

package/__tests__/device-utils.test.ts

@@ -61,6 +61,7 @@ describe('device feature selectors', () => {
     } as PROTO.Features;
 
     expect(getDeviceType(features)).toBe(EDeviceType.Classic);
+    expect(getDeviceFirmwareVersion(features)).toEqual([0, 0, 0]);
     expect(getDeviceBootloaderVersion(features)).toEqual([1, 8, 3]);
   });
 

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

@@ -1,6 +1,7 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import ClearSessionCache from '../src/api/ClearSessionCache';
+import GetPassphraseState from '../src/api/GetPassphraseState';
 import DeviceWipe from '../src/api/device/DeviceWipe';
 import {
   DeviceWalletSessionStore,
@@ -35,6 +36,38 @@ describe('DeviceWalletSessionStore', () => {
     expect(store.get('device-2', 'hidden-a')).toBe('session-c');
   });
 
+  test('keeps SDK session handles without mirroring hardware eviction policy', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setStandard('device-1', 'wallet-a', 'session-a');
+    store.set('device-1', 'wallet-b', 'session-b');
+    store.set('device-1', 'wallet-c', 'session-c');
+    store.set('device-1', 'wallet-d', 'session-d');
+
+    expect(store.get('device-1', 'wallet-a')).toBe('session-a');
+    expect(store.getStandard('device-1')).toEqual({
+      passphraseState: 'wallet-a',
+      sessionId: 'session-a',
+    });
+    expect(store.get('device-1', 'wallet-b')).toBe('session-b');
+    expect(store.get('device-1', 'wallet-c')).toBe('session-c');
+    expect(store.get('device-1', 'wallet-d')).toBe('session-d');
+  });
+
+  test('indexes the standard wallet without replacing hidden-wallet sessions', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'hidden-session-a');
+
+    store.setStandard('device-1', 'standard-state', 'standard-session-1');
+    store.setStandard('device-1', 'standard-state', 'standard-session-2');
+
+    expect(store.getStandard('device-1')).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session-2',
+    });
+    expect(store.get('device-1', 'standard-state')).toBe('standard-session-2');
+    expect(store.get('device-1', 'hidden-a')).toBe('hidden-session-a');
+  });
+
   test('keeps pending sessions unreadable until wallet binding', () => {
     const store = new DeviceWalletSessionStore();
     store.setPending('device-1', 'pending-session');
@@ -46,6 +79,7 @@ describe('DeviceWalletSessionStore', () => {
   test('migrates descriptor keys to stable device ids', () => {
     const store = new DeviceWalletSessionStore();
     store.set('ble-path', 'hidden-a', 'session-a');
+    store.setStandard('ble-path', 'standard-state', 'standard-session');
     store.setPending('ble-path', 'pending-session');
 
     store.reconcileDeviceIdentity({
@@ -55,10 +89,37 @@ describe('DeviceWalletSessionStore', () => {
 
     expect(store.get('ble-path', 'hidden-a')).toBeUndefined();
     expect(store.get('stable-device-id', 'hidden-a')).toBe('session-a');
+    expect(store.getStandard('ble-path')).toBeUndefined();
+    expect(store.getStandard('stable-device-id')).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session',
+    });
     expect(store.getPending('ble-path')).toBeUndefined();
     expect(store.getPending('stable-device-id')).toBe('pending-session');
   });
 
+  test('keeps every known handle when descriptor sessions merge into a stable device id', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setStandard('stable-device-id', 'wallet-a', 'session-a');
+    store.set('stable-device-id', 'wallet-b', 'session-b');
+    store.set('ble-path', 'wallet-c', 'session-c');
+    store.set('ble-path', 'wallet-d', 'session-d');
+
+    store.reconcileDeviceIdentity({
+      temporaryKey: 'ble-path',
+      nextDeviceId: 'stable-device-id',
+    });
+
+    expect(store.get('stable-device-id', 'wallet-a')).toBe('session-a');
+    expect(store.getStandard('stable-device-id')).toEqual({
+      passphraseState: 'wallet-a',
+      sessionId: 'session-a',
+    });
+    expect(store.get('stable-device-id', 'wallet-b')).toBe('session-b');
+    expect(store.get('stable-device-id', 'wallet-c')).toBe('session-c');
+    expect(store.get('stable-device-id', 'wallet-d')).toBe('session-d');
+  });
+
   test('drops sessions from an old stable identity without overwriting the new device', () => {
     const store = new DeviceWalletSessionStore();
     store.set('device-a', 'hidden-a', 'session-a');
@@ -82,11 +143,16 @@ describe('DeviceWalletSessionStore', () => {
     const store = new DeviceWalletSessionStore();
     store.set('device-1', 'hidden-a', 'session-a');
     store.set('device-1', 'hidden-b', 'session-b');
+    store.setStandard('device-1', 'standard-state', 'standard-session');
     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');
+    expect(store.getStandard('device-1')?.sessionId).toBe('standard-session');
+
+    store.delete('device-1', 'standard-state');
+    expect(store.getStandard('device-1')).toBeUndefined();
 
     store.deleteDevice('device-1');
     expect(store.get('device-1', 'hidden-b')).toBeUndefined();
@@ -195,8 +261,7 @@ describe('ClearSessionCache', () => {
       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');
+    expect(device.features).not.toHaveProperty('raw');
 
     const method = new ClearSessionCache({
       payload: {
@@ -287,7 +352,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     jest.restoreAllMocks();
   });
 
-  test('verifies the live device id before sending a cached wallet session', async () => {
+  test('verifies the live device id without resetting the cached wallet session', async () => {
     const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
     device.features = {
       protocol: 'V1',
@@ -307,15 +372,10 @@ describe('Protocol V1 wallet identity initialization', () => {
       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)
-    );
+    expect(typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
   });
 
-  test('resumes a cached V1 wallet only after the live device id matches', async () => {
+  test('resumes a cached V1 wallet after a non-destructive live identity read', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -337,22 +397,82 @@ describe('Protocol V1 wallet identity initialization', () => {
     await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
 
     expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
     expect(typedCall).toHaveBeenNthCalledWith(
-      1,
+      2,
       'Initialize',
       'Features',
-      expect.not.objectContaining({ session_id: 'session-a' }),
+      expect.objectContaining({
+        session_id: 'session-a',
+        passphrase_state: 'hidden-a',
+      }),
       expect.any(Object)
     );
+  });
+
+  test('selects the standard V1 wallet after a non-destructive live identity read', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: false,
+    } as never;
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
     expect(typedCall).toHaveBeenNthCalledWith(
       2,
       'Initialize',
       'Features',
-      expect.objectContaining({
-        session_id: 'session-a',
-        passphrase_state: 'hidden-a',
-      }),
+      {
+        passphrase_state: undefined,
+        is_contains_attach: true,
+      },
       expect.any(Object)
     );
   });
 });
+
+describe('Protocol V1 passphrase state classification', () => {
+  test('does not expose a standard-wallet address as passphrase state', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Address',
+      message: { address: 'standard-wallet-address' },
+    });
+    const method = new GetPassphraseState({
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-a',
+      },
+    });
+    method.device = {
+      features: {},
+      commands: { typedCall },
+      isProtocolV2: () => false,
+      getCurrentDeviceType: () => EDeviceType.Classic,
+      getCurrentFirmwareVersionString: () => '1.0.0',
+      getCurrentPassphraseProtection: () => false,
+      getCurrentDeviceId: () => 'device-a',
+      getFeatures: jest.fn(),
+      getInternalState: () => undefined,
+      updateInternalState: jest.fn(),
+    } as never;
+
+    await expect(method.run()).resolves.toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('GetAddress', 'Address', {
+      address_n: expect.any(Array),
+      coin_name: 'Testnet',
+      script_type: 'SPENDADDRESS',
+      show_display: false,
+    });
+  });
+});