@onekeyfe/hd-core 1.2.2-alpha.104 → 1.2.2-alpha.106

package/README.md

@@ -26,7 +26,7 @@ import Core from '@onekeyfe/hd-core';
 
 ## Docs
 
-Documentation is available [hardware-js-sdk](https://developer.onekey.so/connect-to-hardware/hardware-sdk/start)
+Documentation is available [Hardware SDK Getting Started](https://developer.onekey.so/en/hardware-sdk/getting-started)
 
 ## Examples
 // TODO: add example url

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -1,5 +1,8 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
 import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
 import AllNetworkGetAddress from '../src/api/allnetwork/AllNetworkGetAddress';
+import AllNetworkGetAddressByLoop from '../src/api/allnetwork/AllNetworkGetAddressByLoop';
 import { findMethod } from '../src/api/utils';
 import { getActiveRequestsByDeviceInstance } from '../src/utils/tracing';
 
@@ -18,11 +21,161 @@ class TestAllNetworkMethod extends AllNetworkGetAddressBase {
   }
 }
 
+describe('Pro2 all-network loading lifecycle', () => {
+  function setup(callback = false) {
+    const Method = callback ? AllNetworkGetAddressByLoop : AllNetworkGetAddress;
+    const method = new Method({
+      id: 1,
+      payload: {
+        method: callback ? 'allNetworkGetAddressByLoop' : 'allNetworkGetAddress',
+        connectId: 'test-device',
+        callbackId: 'item',
+        callbackIdFinish: 'finish',
+        bundle: [
+          { network: 'evm', path: "m/44'/60'/0'/0/0" },
+          { network: 'sol', path: "m/44'/501'/0'" },
+        ],
+      },
+    });
+    const calls: string[] = [];
+    const typedCall = jest.fn((type: string, _response: string, message: { action?: number }) => {
+      calls.push(type === 'DeviceAnimationControl' ? `animation:${message.action}` : type);
+      return Promise.resolve({ message: { root_fingerprint: 0 } });
+    });
+    method.device = {
+      commands: { typedCall, disposed: false },
+      isProtocolV2: jest.fn(() => true),
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Pro2),
+      ensureProtocolV2RuntimeContext: jest.fn(() =>
+        Promise.resolve({ supported_messages: [60461] })
+      ),
+    } as any;
+    method.postMessage = jest.fn();
+    method.context = {
+      registerCallbackTask: jest.fn(),
+      cancelCallbackTasks: jest.fn(() => method.device.pendingCallbackPromise?.resolve()),
+    } as any;
+    const callMethod = jest.spyOn(method, 'callMethod').mockImplementation(name => {
+      calls.push(name);
+      return Promise.resolve([{ success: true, payload: {} }] as any);
+    });
+    return { method, calls, typedCall, callMethod };
+  }
+
+  test('keeps one session across fingerprint and all chain requests', async () => {
+    const { method, calls } = setup();
+    await method.run();
+    expect(calls).toEqual([
+      'animation:1',
+      'GetPublicKey',
+      'evmGetAddress',
+      'solGetAddress',
+      'animation:2',
+    ]);
+  });
+
+  test.each(['V1', 'unsupported', 'Neo'])('does not change %s device behavior', async variant => {
+    const { method, calls } = setup();
+    if (variant === 'V1') jest.spyOn(method.device, 'isProtocolV2').mockReturnValue(false);
+    if (variant === 'Neo')
+      jest.spyOn(method.device, 'getCurrentDeviceType').mockReturnValue(EDeviceType.Neo);
+    if (variant === 'unsupported') {
+      jest
+        .spyOn(method.device, 'ensureProtocolV2RuntimeContext')
+        .mockResolvedValue({ supported_messages: [] } as any);
+    }
+    await method.run();
+    expect(calls).toEqual(['GetPublicKey', 'evmGetAddress', 'solGetAddress']);
+  });
+
+  test('does not reconnect for cleanup after chain failure', async () => {
+    const { method, calls, callMethod } = setup();
+    const error = new Error('chain failed');
+    callMethod.mockRejectedValue(error);
+    await expect(method.run()).rejects.toBe(error);
+    expect(calls).toEqual(['animation:1', 'GetPublicKey']);
+  });
+
+  test('does not replace a successful result when Stop fails', async () => {
+    const { method, calls, typedCall } = setup();
+    typedCall.mockResolvedValueOnce({ message: { root_fingerprint: 0 } });
+    typedCall.mockResolvedValueOnce({ message: { root_fingerprint: 0 } });
+    typedCall.mockImplementationOnce(() => {
+      calls.push('stop-failed');
+      return Promise.reject(new Error('cleanup failed'));
+    });
+    await expect(method.run()).resolves.toHaveLength(2);
+    expect(calls).toEqual(['evmGetAddress', 'solGetAddress', 'stop-failed']);
+  });
+
+  test('does not continue wallet commands when starting the session fails', async () => {
+    const { method, typedCall, callMethod } = setup();
+    const error = new Error('link disconnected');
+    typedCall.mockRejectedValueOnce(error);
+    await expect(method.run()).rejects.toBe(error);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(callMethod).not.toHaveBeenCalled();
+  });
+
+  test.each(['success', 'failure', 'cancel'])(
+    'keeps callback loading until background %s',
+    async outcome => {
+      const { method, calls, callMethod } = setup(true);
+      let finishChain: () => void = () => {};
+      const chainPending = new Promise<void>(resolve => {
+        finishChain = resolve;
+      });
+      callMethod.mockImplementationOnce(async () => {
+        calls.push('chain-pending');
+        await chainPending;
+        if (outcome === 'failure') throw new Error('chain failed');
+        if (outcome === 'cancel') method.abortController?.abort();
+        return [{ success: true, payload: {} }] as any;
+      });
+      await expect(method.run()).resolves.toEqual([]);
+      expect(calls).toEqual(['animation:1', 'GetPublicKey', 'chain-pending']);
+      finishChain();
+      await method.device.pendingCallbackPromise?.promise;
+      expect(calls.filter(call => call === 'animation:2')).toHaveLength(
+        outcome === 'success' ? 1 : 0
+      );
+      expect(method.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          payload: expect.objectContaining({ callbackId: 'finish' }),
+        })
+      );
+    }
+  );
+
+  test('does not send further commands when the fingerprint response is invalid', async () => {
+    const { method, typedCall, callMethod } = setup();
+    typedCall.mockResolvedValueOnce({ message: { root_fingerprint: 0 } });
+    typedCall.mockResolvedValueOnce({ message: {} } as any);
+    await expect(method.run()).rejects.toThrow();
+    expect(callMethod).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledTimes(2);
+  });
+
+  test.each(['disposed', 'replaced'])(
+    'does not send cleanup through a %s connection',
+    async state => {
+      const { method, calls, callMethod } = setup();
+      callMethod.mockImplementation(() => {
+        if (state === 'disposed') method.device.commands.disposed = true;
+        else method.device.commands = { typedCall: jest.fn() } as any;
+        return Promise.resolve([{ success: true, payload: {} }] as any);
+      });
+      await method.run();
+      expect(calls).toEqual(['animation:1', 'GetPublicKey']);
+    }
+  );
+});
+
 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');
+      calls.push('restore-wallet-session');
       return Promise.resolve(true);
     });
     const innerMethod = {
@@ -98,7 +251,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       undefined,
       undefined
     );
-    expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
+    expect(calls).toEqual(['restore-wallet-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });
 

package/__tests__/core-error-output.test.ts

@@ -1,4 +1,8 @@
-import { initCore } from '../src/core';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { initConnector, initCore } from '../src/core';
+import { DataManager } from '../src/data-manager';
+import TransportManager from '../src/data-manager/TransportManager';
 import { IFRAME } from '../src/events';
 
 jest.mock('../src/data/config', () => ({
@@ -9,12 +13,99 @@ jest.mock('../src/data/config', () => ({
 jest.mock('../src/data-manager/TransportManager', () => ({
   __esModule: true,
   default: {
+    load: jest.fn(),
     configure: jest.fn().mockResolvedValue(undefined),
     getTransport: jest.fn(() => undefined),
   },
 }));
 
 describe('Core 错误输出边界', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test.each([
+    HardwareErrorCode.BleDeviceNotBonded,
+    HardwareErrorCode.BleDeviceBondedCanceled,
+    HardwareErrorCode.BleDeviceDisconnected,
+    HardwareErrorCode.PollingTimeout,
+  ])(
+    'preserves terminal BLE error %s in the public response without polling again',
+    async errorCode => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      const error = ERRORS.TypedError(errorCode);
+      const acquire = jest.fn().mockRejectedValue(error);
+      jest.spyOn(TransportManager, 'getTransport').mockReturnValue({
+        acquire,
+        release: jest.fn().mockResolvedValue(true),
+        stop: jest.fn().mockResolvedValue(undefined),
+      } as never);
+      const core = initCore();
+      initConnector();
+
+      try {
+        const response = await core.handleMessage({
+          id: 1,
+          event: IFRAME.CALL,
+          type: IFRAME.CALL,
+          payload: {
+            method: 'getDeviceState',
+            connectId: 'ble-pairing-test',
+            forceProtocolDetection: true,
+            retryCount: 1,
+            pollIntervalTime: 1,
+            timeout: 1000,
+          },
+        } as never);
+
+        expect(response).toMatchObject({
+          success: false,
+          payload: { code: errorCode, error: error.message },
+        });
+        expect(acquire).toHaveBeenCalledTimes(1);
+      } finally {
+        await core.dispose();
+      }
+    }
+  );
+
+  test('desktop BLE still polls after a transient disconnect instead of failing immediately', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-web-ble' as never);
+    const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+    const acquire = jest.fn().mockRejectedValue(error);
+    jest.spyOn(TransportManager, 'getTransport').mockReturnValue({
+      acquire,
+      release: jest.fn().mockResolvedValue(true),
+      stop: jest.fn().mockResolvedValue(undefined),
+    } as never);
+    const core = initCore();
+    initConnector();
+
+    try {
+      const response = await core.handleMessage({
+        id: 1,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: {
+          method: 'getDeviceState',
+          connectId: 'desktop-ble-disconnect-test',
+          forceProtocolDetection: true,
+          retryCount: 1,
+          pollIntervalTime: 1,
+          timeout: 1000,
+        },
+      } as never);
+
+      expect(response).toMatchObject({
+        success: false,
+        payload: { code: HardwareErrorCode.DeviceNotFound },
+      });
+      expect(acquire.mock.calls.length).toBeGreaterThan(1);
+    } finally {
+      await core.dispose();
+    }
+  });
+
   test('连接失败只返回结构化错误，不直接写入 stdout', async () => {
     const stdout = jest.spyOn(console, 'log').mockImplementation(() => undefined);
     const core = initCore();

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

@@ -3,6 +3,7 @@ import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
 import {
   cancel,
+  getPostCallPendingPromise,
   initConnector,
   initCore,
   isDeviceIdentityMismatchError,
@@ -13,6 +14,7 @@ import {
   resolveBleConnectProtocol,
 } from '../src/core';
 import { DataManager } from '../src/data-manager';
+import GetDeviceState from '../src/api/GetDeviceState';
 import TransportManager from '../src/data-manager/TransportManager';
 import { Device } from '../src/device/Device';
 import { cancelDeviceInPrompt, cancelDeviceWithInitialize } from '../src/device/DeviceCommands';
@@ -74,6 +76,104 @@ describe('public device lifecycle events', () => {
     jest.restoreAllMocks();
   });
 
+  test.each(['V1', 'V2'] as const)(
+    'preserves the %s acknowledged result and waits for release before the next acquire',
+    async protocol => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      jest.spyOn(DataManager, 'checkAndReloadData').mockResolvedValue(undefined);
+      jest.spyOn(TransportManager, 'configure').mockResolvedValue(undefined);
+      const device = createInitializedDevice(protocol);
+      jest.spyOn(Device, 'fromDescriptor').mockReturnValue(device);
+      const acquire = jest.spyOn(device, 'acquire').mockResolvedValue(undefined);
+      jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
+      jest.spyOn(device, 'hasUnexpectedMode').mockReturnValue(undefined);
+      jest.spyOn(device, 'getCurrentMethodVersionRange').mockReturnValue({} as never);
+      device.commands = { disposed: false, dispose: jest.fn(), checkDisposed: jest.fn() } as never;
+      const methodRun = jest.spyOn(GetDeviceState.prototype, 'run').mockResolvedValue({} as never);
+      const releaseGate = createDeferred<void>();
+      const release = jest.spyOn(device, 'release').mockReturnValue(releaseGate.promise);
+      core = initCore();
+      const call = (id: number) =>
+        core!.handleMessage({
+          id,
+          event: IFRAME.CALL,
+          type: IFRAME.CALL,
+          payload: {
+            method: 'getDeviceState',
+            connectId: 'release-device',
+            connectProtocol: protocol,
+          },
+        } as CoreMessage);
+      await expect(call(301)).resolves.toMatchObject({ success: true });
+      const nextCall = call(302);
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      try {
+        expect(methodRun).toHaveBeenCalledTimes(1);
+        expect(release).toHaveBeenCalledTimes(1);
+        expect(acquire).toHaveBeenCalledTimes(1);
+      } finally {
+        releaseGate.resolve();
+      }
+      await expect(nextCall).resolves.toMatchObject({ success: true });
+      expect(acquire).toHaveBeenCalledTimes(2);
+    }
+  );
+
+  test.each([
+    ['webusb', EDeviceType.Pro2],
+    ['desktop-webusb', EDeviceType.Pro2],
+    ['node-usb', EDeviceType.Neo],
+  ] as const)('waits one second after %s signing on %s', async (env, deviceType) => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+    const cooldown = createDeferred<void>();
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation((callback, delay) => {
+      cooldown.promise.then(() => callback());
+      return 0 as never;
+    });
+    const cleanup = createDeferred<void>();
+    const pending = getPostCallPendingPromise(
+      { name: 'evmSignTransaction' } as never,
+      {
+        getCurrentDeviceType: () => deviceType,
+        waitForRunCleanup: () => cleanup.promise,
+      } as never
+    );
+    let settled = false;
+    pending.then(() => {
+      settled = true;
+    });
+
+    cleanup.resolve();
+    await Promise.resolve();
+    expect(settled).toBe(false);
+    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 1000);
+    cooldown.resolve();
+    await pending;
+    expect(settled).toBe(true);
+  });
+
+  test.each([
+    ['react-native', EDeviceType.Pro2, 'evmSignTransaction'],
+    ['webusb', EDeviceType.Classic, 'evmSignTransaction'],
+    ['webusb', EDeviceType.Pro2, 'evmGetAddress'],
+  ] as const)('does not add a signing cooldown for %s, %s, %s', async (env, deviceType, name) => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+    const cleanup = createDeferred<void>();
+    const pending = getPostCallPendingPromise(
+      { name } as never,
+      {
+        getCurrentDeviceType: () => deviceType,
+        waitForRunCleanup: () => cleanup.promise,
+      } as never
+    );
+
+    expect(pending).toBe(cleanup.promise);
+    cleanup.resolve();
+    await expect(pending).resolves.toBeUndefined();
+  });
+
   test('prefers Protocol V2 only when the method contract is explicitly V2-only', () => {
     const createMethod = (protocols: readonly ('V1' | 'V2')[], connectProtocol?: 'V1' | 'V2') =>
       ({
@@ -105,7 +205,7 @@ describe('public device lifecycle events', () => {
     expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
   });
 
-  test('isolates pending cancellation cleanup by connect id', () => {
+  test('isolates pending cancellation cleanup by connect id and waits for every cleanup', async () => {
     core = initCore();
     const context = (core as any).getCoreContext();
     const firstCleanup = createDeferred<void>();
@@ -117,9 +217,20 @@ describe('public device lifecycle events', () => {
     expect(context.getPrePendingCallPromise('device-b')).toBeUndefined();
 
     context.setPrePendingCallPromise('device-a', replacementCleanup.promise);
+    const combined = context.getPrePendingCallPromise('device-a');
     context.removePrePendingCallPromise('device-a', firstCleanup.promise);
 
-    expect(context.getPrePendingCallPromise('device-a')).toBe(replacementCleanup.promise);
+    expect(context.getPrePendingCallPromise('device-a')).toBe(combined);
+    let drained = false;
+    combined.then(() => {
+      drained = true;
+    });
+    replacementCleanup.resolve();
+    await Promise.resolve();
+    expect(drained).toBe(false);
+    firstCleanup.resolve();
+    await combined;
+    expect(drained).toBe(true);
   });
 
   test('cancels only requests associated with the requested connect id', () => {
@@ -158,6 +269,154 @@ describe('public device lifecycle events', () => {
     expect(deviceB.interruptionFromUser).not.toHaveBeenCalled();
   });
 
+  test.each(['callback', 'cleanup'] as const)(
+    'cancels a request waiting for %s before acquire',
+    async phase => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      const acquire = jest.spyOn(Device.prototype, 'acquire').mockResolvedValue(undefined);
+      core = initCore();
+      const context = (core as any).getCoreContext();
+      const gate = createDeferred<void>();
+      const connectId = `queued-${phase}`;
+      if (phase === 'callback') context.registerCallbackTask(connectId, gate);
+      else context.setPrePendingCallPromise(connectId, gate.promise);
+      const result = core.handleMessage({
+        id: 201,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'getDeviceState', connectId, connectProtocol: 'V2' },
+      } as CoreMessage);
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      expect(context.requestQueue.getRequestTasksIdByConnectId(connectId)).toHaveLength(1);
+      cancel(context, connectId);
+      await expect(result).resolves.toMatchObject({
+        success: false,
+        payload: { code: HardwareErrorCode.CallQueueActionCancelled },
+      });
+      gate.resolve();
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      expect(acquire).not.toHaveBeenCalled();
+      expect(context.requestQueue.getRequestTasksId()).toHaveLength(0);
+    }
+  );
+
+  test.each([
+    ['V1', 'callback'],
+    ['V1', 'cleanup'],
+    ['V2', 'callback'],
+    ['V2', 'cleanup'],
+  ] as const)(
+    'does not run a cancelled %s request waiting for %s after acquire',
+    async (protocol, phase) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      jest.spyOn(DataManager, 'checkAndReloadData').mockResolvedValue(undefined);
+      jest.spyOn(TransportManager, 'configure').mockResolvedValue(undefined);
+      const device = createInitializedDevice(protocol);
+      jest.spyOn(Device, 'fromDescriptor').mockReturnValue(device);
+      const acquire = jest.spyOn(device, 'acquire').mockResolvedValue(undefined);
+      jest.spyOn(device, 'hasUnexpectedMode').mockReturnValue(undefined);
+      jest.spyOn(device, 'getCurrentMethodVersionRange').mockReturnValue({} as never);
+      device.commands = { disposed: false, dispose: jest.fn(), checkDisposed: jest.fn() } as never;
+      const deviceRun = jest.spyOn(device, 'run');
+      core = initCore();
+      const context = (core as any).getCoreContext();
+      const gate = createDeferred<void>();
+      const connectId = `post-acquire-${protocol}-${phase}`;
+      jest.spyOn(device, 'initialize').mockImplementation(() => {
+        if (phase === 'callback') context.registerCallbackTask(connectId, gate);
+        else context.setPrePendingCallPromise(connectId, gate.promise);
+        return Promise.resolve();
+      });
+
+      const result = core.handleMessage({
+        id: 203,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'getDeviceState', connectId, connectProtocol: protocol },
+      } as CoreMessage);
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      expect(acquire).toHaveBeenCalledTimes(1);
+      expect(deviceRun).not.toHaveBeenCalled();
+
+      cancel(context, connectId);
+      await expect(result).resolves.toMatchObject({
+        success: false,
+        payload: { code: HardwareErrorCode.CallQueueActionCancelled },
+      });
+      gate.resolve();
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      expect(deviceRun).not.toHaveBeenCalled();
+    }
+  );
+
+  test('keeps the cleanup barrier when its deadline expires', async () => {
+    const realSetTimeout = setTimeout;
+    jest
+      .spyOn(global, 'setTimeout')
+      .mockImplementation((callback, delay, ...args) =>
+        realSetTimeout(callback, delay === 15_000 ? 0 : delay, ...args)
+      );
+    {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      const acquire = jest.spyOn(Device.prototype, 'acquire').mockResolvedValue(undefined);
+      core = initCore();
+      const context = (core as any).getCoreContext();
+      const gate = createDeferred<void>();
+      context.setPrePendingCallPromise('draining-device', gate.promise);
+      const result = core.handleMessage({
+        id: 202,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'getDeviceState', connectId: 'draining-device', connectProtocol: 'V2' },
+      } as CoreMessage);
+      await expect(result).resolves.toMatchObject({
+        success: false,
+        payload: { code: HardwareErrorCode.DeviceBusy },
+      });
+      expect(acquire).not.toHaveBeenCalled();
+      expect(context.getPrePendingCallPromise('draining-device')).toBe(gate.promise);
+      gate.resolve();
+    }
+  });
+
+  test.each(['V1', 'V2'] as const)(
+    'keeps repeated and late %s cancellation scoped to the old commands',
+    async protocol => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      const device = createInitializedDevice(protocol);
+      const gate = createDeferred<void>();
+      const oldCancel = jest.fn().mockResolvedValue(undefined);
+      device.commands = { cancel: oldCancel } as never;
+      device.setCancelableAction(() => gate.promise);
+      const first = device.interruptionFromUser();
+      expect(device.interruptionFromUser()).toBe(first);
+      device.beginConnectionAttempt();
+      const newCancel = jest.fn();
+      const newRun = createDeferred<void>();
+      const rejected = jest.spyOn(newRun, 'reject');
+      device.commands = { cancel: newCancel } as never;
+      device.runPromise = newRun;
+      const newAction = jest.fn().mockResolvedValue(undefined);
+      device.setCancelableAction(newAction);
+      gate.resolve();
+      await first;
+      expect(oldCancel).toHaveBeenCalledTimes(1);
+      expect(newCancel).not.toHaveBeenCalled();
+      expect(rejected).not.toHaveBeenCalled();
+      newRun.promise.catch(() => undefined);
+      await device.interruptionFromUser();
+      expect(newAction).toHaveBeenCalledTimes(1);
+    }
+  );
+
   test('aborts every request before cancel-all rejects WebUSB tasks', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
     core = initCore();
@@ -389,6 +648,38 @@ describe('public device lifecycle events', () => {
     expect(isRetryableBleConnectionError(method, error)).toBe(false);
   });
 
+  test.each(['V1', 'V2'] as const)(
+    'stops the outer BLE poll after a manager reset for Protocol %s',
+    async connectProtocol => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      jest.spyOn(TransportManager, 'configure').mockResolvedValue(undefined);
+      const acquire = jest
+        .spyOn(Device.prototype, 'acquire')
+        .mockRejectedValue(
+          ERRORS.TypedError(HardwareErrorCode.PollingTimeout, 'BLE setup wedged repeatedly')
+        );
+      core = initCore();
+      const response = await core.handleMessage({
+        id: `manager-reset-${connectProtocol}`,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: {
+          method: 'getDeviceState',
+          connectId: `manager-reset-device-${connectProtocol}`,
+          connectProtocol,
+          retryCount: 1,
+          pollIntervalTime: 1,
+        },
+      } as CoreMessage);
+
+      expect(response).toMatchObject({
+        success: false,
+        payload: { code: HardwareErrorCode.PollingTimeout },
+      });
+      expect(acquire).toHaveBeenCalledTimes(1);
+    }
+  );
+
   test.each([
     [HardwareErrorCode.BleDeviceBondError, true],
     [HardwareErrorCode.BlePeerRemovedPairingInformation, true],
@@ -561,6 +852,26 @@ describe('public device lifecycle events', () => {
     expect(cancel).toHaveBeenCalledTimes(1);
   });
 
+  test.each(['V1', 'V2'] as const)(
+    'disconnects and resolves when Protocol %s cancellation cleanup fails',
+    async protocol => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      const device = createInitializedDevice(protocol);
+      const cleanupError = new Error('cancel cleanup failed');
+      const cancel = jest.fn().mockRejectedValue(cleanupError);
+      const disconnect = jest.fn().mockResolvedValue(undefined);
+      device.deviceConnector = { disconnect } as never;
+      device.commands = { cancel } as never;
+      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+
+      await expect(device.interruptionFromUser()).resolves.toBeUndefined();
+
+      expect(cancel).toHaveBeenCalledTimes(1);
+      expect(disconnect).toHaveBeenCalledWith(device.mainId);
+      expect(device.hasDeviceAcquire()).toBe(false);
+    }
+  );
+
   test('does not finish acquire after the user already cancelled', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = createInitializedDevice('V2');

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

@@ -17,7 +17,7 @@ jest.mock('../src/data-manager/TransportManager', () => ({
 }));
 
 describe('openWalletSession error response', () => {
-  test('returns a structured invalid-parameter response for an incomplete resume request', async () => {
+  test('returns a structured invalid-parameter response for the removed resume-hidden mode', async () => {
     const core = initCore();
 
     const response = await core.handleMessage({
@@ -34,7 +34,7 @@ describe('openWalletSession error response', () => {
     expect(response).toMatchObject({
       success: false,
       payload: {
-        error: 'Missing required parameter: deviceId',
+        error: 'Parameter [mode] must be one of standard or select-hidden.',
         code: HardwareErrorCode.CallMethodInvalidParameter,
       },
     });