@onekeyfe/hd-core 1.2.0-alpha.133 → 1.2.0-alpha.134

package/__tests__/DeviceCommands.test.ts

@@ -800,13 +800,7 @@ describe('DeviceCommands cancellation', () => {
     try {
       const commands = createCommands();
       commands.disposed = false;
-      commands.mainId = 'main-id';
       commands.callPromise = new Promise(() => {});
-      const disconnect = jest.fn().mockResolvedValue(undefined);
-      commands.transport = {
-        name: 'ReactNativeBleTransport',
-        disconnect,
-      } as any;
       const dispose = jest.fn().mockResolvedValue(undefined);
       commands.dispose = dispose;
 
@@ -816,7 +810,6 @@ describe('DeviceCommands cancellation', () => {
 
       await expect(cancellation).resolves.toBeUndefined();
       expect(dispose).toHaveBeenCalledWith(true);
-      expect(disconnect).toHaveBeenCalledWith('main-id');
       expect(commands.callPromise).toBeUndefined();
     } finally {
       jest.useRealTimers();

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

@@ -1,7 +1,7 @@
-import { EDeviceType, ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
-import { initConnector, initCore, isMissingDetectedProtocolV2Error } from '../src/core';
+import { initConnector, initCore } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
 import { Device } from '../src/device/Device';
@@ -82,23 +82,6 @@ describe('public device lifecycle events', () => {
     expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
   });
 
-  test('isolates pending cancellation cleanup by connect id', () => {
-    core = initCore();
-    const context = (core as any).getCoreContext();
-    const firstCleanup = createDeferred<void>();
-    const replacementCleanup = createDeferred<void>();
-
-    context.setPrePendingCallPromise('device-a', firstCleanup.promise);
-
-    expect(context.getPrePendingCallPromise('device-a')).toBe(firstCleanup.promise);
-    expect(context.getPrePendingCallPromise('device-b')).toBeUndefined();
-
-    context.setPrePendingCallPromise('device-a', replacementCleanup.promise);
-    context.removePrePendingCallPromise('device-a', firstCleanup.promise);
-
-    expect(context.getPrePendingCallPromise('device-a')).toBe(replacementCleanup.promise);
-  });
-
   test('keeps shared device lifecycle listeners across a device cache reset', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -251,22 +234,6 @@ describe('public device lifecycle events', () => {
     expect(device.getProtocol()).toBe('V2');
   });
 
-  test.each([
-    ['V2', true],
-    ['V1', false],
-  ] as const)(
-    'retries a missing detected protocol only for an explicit Protocol %s connection',
-    (connectProtocol, expected) => {
-      const method = { payload: { connectProtocol } } as never;
-      const error = {
-        errorCode: HardwareErrorCode.RuntimeError,
-        message: 'Device protocol has not been detected for ble-id',
-      };
-
-      expect(isMissingDetectedProtocolV2Error(method, error)).toBe(expected);
-    }
-  );
-
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -343,62 +310,6 @@ describe('public device lifecycle events', () => {
     }
   );
 
-  test('sends a fallback Cancel for an acquired Protocol V2 BLE call without a prompt callback', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
-    const device = createInitializedDevice('V2');
-    const post = jest.fn().mockResolvedValue(undefined);
-    const cancelDevice = jest.fn(() => cancelDeviceInPrompt(device, false));
-    const cancel = jest.fn().mockResolvedValue(undefined);
-    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
-    device.commands = {
-      transport: { post },
-      cancelDevice,
-      cancel,
-    } as never;
-
-    await device.interruptionFromUser();
-
-    expect(cancelDevice).toHaveBeenCalledTimes(1);
-    expect(post).toHaveBeenCalledWith(device.mainId, 'Cancel', {});
-    expect(cancel).toHaveBeenCalledTimes(1);
-  });
-
-  test('waits for the canceled run to finish releasing before cancellation completes', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
-    const device = createInitializedDevice('V2');
-    const operation = createDeferred<void>();
-    const releaseGate = createDeferred<void>();
-    const cancelError = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
-    const release = jest.spyOn(device, 'release').mockImplementation(() => releaseGate.promise);
-    device.commands = {
-      disposed: false,
-      cancel: jest.fn(() => {
-        operation.reject(cancelError);
-        return Promise.resolve();
-      }),
-    } as never;
-    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
-
-    const runResult = device.run(() => operation.promise).catch(error => error);
-    const cancellation = device.interruptionFromUser();
-    let cancellationCompleted = false;
-    cancellation.then(() => {
-      cancellationCompleted = true;
-    });
-
-    await new Promise(resolve => {
-      setImmediate(resolve);
-    });
-    expect(release).toHaveBeenCalledTimes(1);
-    expect(cancellationCompleted).toBe(false);
-
-    releaseGate.resolve();
-    await cancellation;
-    await expect(runResult).resolves.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
-    });
-  });
-
   test.each([
     [EDeviceType.Pro2, 'webusb', false, DeviceType.PRO2],
     [EDeviceType.Neo, 'webusb', false, DeviceType.NEO],

package/__tests__/device-settings.test.ts

@@ -2,9 +2,6 @@ import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import DeviceSettings from '../src/api/device/DeviceSettings';
-import { Device } from '../src/device/Device';
-import { DEVICE } from '../src/events';
-import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
 import { DEVICE_SETTINGS_NEVER_TIMEOUT_MS } from '../src/utils/deviceSettings';
 
 import type { Features } from '../src/types';
@@ -24,9 +21,6 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
   const typedCall = jest.fn().mockResolvedValue({ message: { message: 'Success' } });
   const updateState = jest.fn();
   const getDeviceState = jest.fn();
-  const refreshProtocolV2SettingsAfterMutation = jest.fn(() =>
-    getDeviceState({ refreshSections: ['status', 'settings'] })
-  );
   return {
     device: {
       features,
@@ -35,7 +29,6 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
       commands: { typedCall },
       updateState,
       getDeviceState,
-      refreshProtocolV2SettingsAfterMutation,
     },
     typedCall,
     updateState,
@@ -188,98 +181,7 @@ describe('DeviceSettings protocol routing', () => {
     expect(updateState).not.toHaveBeenCalled();
   });
 
-  it('reconciles stale passphrase and label after an unrelated Protocol V2 setting change', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'DeviceSettingsSet') {
-        return { message: { message: 'Success' } };
-      }
-      if (requestType === 'DeviceStatusGet') {
-        return {
-          message: {
-            init_states: true,
-            unlocked: false,
-            passphrase_enabled: false,
-          },
-        };
-      }
-      if (requestType === 'DeviceSettingsGet') {
-        return {
-          message: {
-            label: 'Current Label',
-            brightness: 80,
-            passphrase_enable: false,
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${requestType}`);
-    });
-    const device = Device.fromDescriptor({
-      id: 'pro2',
-      path: 'pro2',
-      protocolType: 'V2',
-    } as never);
-    (device as any).commands = { typedCall };
-    device.updateState(
-      {
-        protocol: 'V2',
-        identity: {
-          deviceType: EDeviceType.Pro2,
-          label: 'Stale Label',
-        },
-        status: {
-          mode: 'normal',
-          unlocked: false,
-          passphraseProtection: true,
-        },
-        settings: { brightness: 20 },
-        raw: {
-          protocolV2ProtocolInfo: {
-            version: 1,
-            build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
-            supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
-          },
-        },
-      },
-      'initialize'
-    );
-    const onState = jest.fn();
-    device.on(DEVICE.STATE, onState);
-    const method = new DeviceSettings({
-      id: 3,
-      payload: {
-        method: 'deviceSettings',
-        brightness: 80,
-      },
-    });
-    method.init();
-    (method as any).device = device;
-
-    await expect(method.run()).resolves.toEqual({ message: 'Success' });
-
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceSettingsSet',
-      'DeviceStatusGet',
-      'DeviceSettingsGet',
-    ]);
-    expect(device.state).toMatchObject({
-      identity: { label: 'Current Label' },
-      status: { passphraseProtection: false },
-      settings: { brightness: 80 },
-    });
-    expect(onState).toHaveBeenLastCalledWith(
-      device,
-      expect.objectContaining({
-        source: 'settings-read',
-        state: expect.objectContaining({
-          identity: expect.objectContaining({ label: 'Current Label' }),
-          status: expect.objectContaining({ passphraseProtection: false }),
-          settings: expect.objectContaining({ brightness: 80 }),
-        }),
-      })
-    );
-  });
-
-  it('uses the Pro2 passphrase page and refreshes device state after the toggle', async () => {
+  it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
     const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
     getDeviceState
       .mockResolvedValueOnce({
@@ -361,8 +263,8 @@ describe('DeviceSettings protocol routing', () => {
     expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['settings'] });
   });
 
-  it('does not overwrite Pro2 passphrase state when refreshed state does not match', async () => {
-    const { device, getDeviceState, updateState } = createDevice({ protocol: 'V2' });
+  it('rejects a successful Pro2 page response when the hardware did not reach the target', async () => {
+    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
     getDeviceState.mockResolvedValue({
       status: { passphraseProtection: false },
     });
@@ -376,12 +278,14 @@ describe('DeviceSettings protocol routing', () => {
     method.init();
     (method as any).device = device;
 
-    await expect(method.run()).resolves.toEqual({ message: 'Success' });
-    expect(updateState).not.toHaveBeenCalled();
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: 'Protocol V2 passphrase setting did not reach the requested value.',
+    });
   });
 
-  it('keeps the previous Pro2 passphrase state when refreshed state is unavailable after locking', async () => {
-    const { device, getDeviceState, updateState } = createDevice({ protocol: 'V2' });
+  it('accepts a locked Pro2 as confirmation after disabling passphrase', async () => {
+    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
     getDeviceState
       .mockResolvedValueOnce({
         status: { unlocked: true, passphraseProtection: true },
@@ -400,68 +304,6 @@ describe('DeviceSettings protocol routing', () => {
     (method as any).device = device;
 
     await expect(method.run()).resolves.toEqual({ message: 'Success' });
-    expect(updateState).not.toHaveBeenCalled();
-  });
-
-  it('preserves confirmed Pro2 passphrase state when the post-toggle status is locked', async () => {
-    let statusReadCount = 0;
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'DeviceStatusGet') {
-        statusReadCount += 1;
-        return {
-          message:
-            statusReadCount === 1
-              ? { init_states: true, unlocked: true, passphrase_enabled: true }
-              : { init_states: true, unlocked: false, passphrase_enabled: false },
-        };
-      }
-      if (requestType === 'DeviceSettingsPageShow') {
-        return { message: { message: 'Success' } };
-      }
-      if (requestType === 'DeviceSettingsGet') {
-        return { message: { label: 'Pro 2' } };
-      }
-      throw new Error(`Unexpected request: ${requestType}`);
-    });
-    const device = Device.fromDescriptor({
-      id: 'pro2-passphrase',
-      path: 'pro2-passphrase',
-      protocolType: 'V2',
-    } as never);
-    (device as any).commands = { typedCall };
-    device.updateState(
-      {
-        protocol: 'V2',
-        identity: { deviceType: EDeviceType.Pro2 },
-        status: {
-          mode: 'normal',
-          unlocked: true,
-          passphraseProtection: true,
-        },
-        raw: {
-          protocolV2ProtocolInfo: {
-            version: 1,
-            supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
-          },
-        },
-      },
-      'initialize'
-    );
-    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' });
-    expect(device.state?.status).toMatchObject({
-      unlocked: false,
-      passphraseProtection: true,
-    });
   });
 
   it('keeps Protocol V1 passphrase settings on ApplySettings', async () => {

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

@@ -352,7 +352,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     jest.restoreAllMocks();
   });
 
-  test('verifies the live device id without resetting the cached wallet session', async () => {
+  test('purges cached sessions and rejects when the live device identity changes', async () => {
     const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
     device.features = {
       protocol: 'V1',
@@ -363,7 +363,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
     const typedCall = jest.fn().mockResolvedValue({
       type: 'Features',
-      message: { device_id: 'live-device-b' },
+      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
     });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
@@ -371,11 +371,76 @@ describe('Protocol V1 wallet identity initialization', () => {
     await expect(
       device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    // Identity is validated from the single Initialize round trip; no separate
+    // GetFeatures preflight.
     expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.objectContaining({ passphrase_state: 'hidden-a' }),
+      expect.any(Object)
+    );
+    // Identity change purges the previous device's cached sessions (pre-existing
+    // reconcileDeviceIdentity behavior — never carry sessions across devices)…
+    expect(deviceWalletSessionStore.get('cached-device-a', 'hidden-a')).toBeUndefined();
+    // …and the session the mismatched Initialize cached under the wrong
+    // device's identity is dropped as well.
+    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
   });
 
-  test('resumes a cached V1 wallet after a non-destructive live identity read', async () => {
+  test('drops the wrong-device session even when reconfigure fails after Initialize', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'cached-device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
+    });
+    device.commands = { typedCall } as never;
+    // Pre-encode resync succeeds; the post-response reconfigure inside
+    // callInitialize rejects — the session write has already happened by then.
+    jest
+      .spyOn(TransportManager, 'reconfigure')
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error('configure failed'));
+
+    await expect(
+      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    // The wrong-device session must not survive the error path either.
+    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
+  });
+
+  test('re-syncs the V1 message schema for this device before encoding Initialize', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'device-a' },
+    });
+    device.commands = { typedCall } as never;
+    const reconfigure = jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    // A stale process-global schema (from another device) would silently strip
+    // passphrase_state from the wire message, so the resync must come first.
+    expect(reconfigure.mock.invocationCallOrder[0]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[0]
+    );
+  });
+
+  test('resumes a cached V1 wallet with a single identity-validated Initialize', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -384,22 +449,17 @@ describe('Protocol V1 wallet identity initialization', () => {
       passphraseProtection: true,
     } as never;
     deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
-      .mockResolvedValueOnce({
-        type: 'Features',
-        message: { device_id: 'device-a', session_id: 'session-a' },
-      });
+    const typedCall = jest.fn().mockResolvedValueOnce({
+      type: 'Features',
+      message: { device_id: 'device-a', session_id: 'session-a' },
+    });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
 
     await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
 
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
-    expect(typedCall).toHaveBeenNthCalledWith(
-      2,
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
       'Initialize',
       'Features',
       expect.objectContaining({
@@ -408,9 +468,10 @@ describe('Protocol V1 wallet identity initialization', () => {
       }),
       expect.any(Object)
     );
+    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
   });
 
-  test('selects the standard V1 wallet after a non-destructive live identity read', async () => {
+  test('selects the standard V1 wallet with a single identity-validated Initialize', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -420,17 +481,14 @@ describe('Protocol V1 wallet identity initialization', () => {
     } 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,
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
       'Initialize',
       'Features',
       {

package/__tests__/protocol-v2.test.ts

@@ -183,7 +183,6 @@ describe('DeviceUploadWallpaper', () => {
     stubDevice({
       ...device,
       ensureProtocolV2RuntimeContext: jest.fn().mockResolvedValue(wallpaperProtocolInfo),
-      refreshProtocolV2SettingsAfterMutation: jest.fn().mockResolvedValue({}),
     });
 
   test('encodes, uploads and applies a Pro2 wallpaper', async () => {
@@ -205,8 +204,7 @@ describe('DeviceUploadWallpaper', () => {
         jpegBase64: createJpegBase64(604, 1024),
       },
     });
-    const device = stubWallpaperDevice({ commands: { typedCall } });
-    (method as any).device = device;
+    (method as any).device = stubWallpaperDevice({ commands: { typedCall } });
     method.postMessage = jest.fn();
 
     method.init();
@@ -226,7 +224,6 @@ describe('DeviceUploadWallpaper', () => {
     expect(typedCall).toHaveBeenLastCalledWith('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: result.path },
     });
-    expect(device.refreshProtocolV2SettingsAfterMutation).toHaveBeenCalledTimes(1);
     expect(typedCall.mock.calls.some(call => call[0] === 'SetWallpaper')).toBe(false);
     expect(result).toMatchObject({ colorFormat: 'RGB565', message: 'wallpaper applied' });
     const fileWriteCallCount = typedCall.mock.calls.filter(
@@ -265,36 +262,6 @@ describe('DeviceUploadWallpaper', () => {
     expect(typedCall.mock.calls.some(call => call[0] === 'DeviceSettingsSet')).toBe(false);
   });
 
-  test('returns success when wallpaper read-back fails after apply', async () => {
-    const typedCall = jest.fn().mockImplementation((request, _response, params) => {
-      if (request === 'FilesystemDirMake') return { message: {} };
-      if (request === 'FilesystemFileWrite') {
-        const file = params.file as { data: Uint8Array; offset: number };
-        return { message: { processed_byte: file.offset + file.data.byteLength } };
-      }
-      if (request === 'DeviceSettingsSet') {
-        return { message: { message: 'wallpaper applied' } };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = new DeviceUploadWallpaper({
-      id: 1,
-      payload: {
-        method: 'deviceUploadWallpaper',
-        jpegBase64: createJpegBase64(604, 1024),
-      },
-    });
-    const device = stubWallpaperDevice({ commands: { typedCall } });
-    device.refreshProtocolV2SettingsAfterMutation.mockRejectedValueOnce(
-      new Error('settings read-back failed')
-    );
-    (method as any).device = device;
-    method.init();
-
-    await expect(method.run()).resolves.toMatchObject({ message: 'wallpaper applied' });
-    expect(device.refreshProtocolV2SettingsAfterMutation).toHaveBeenCalledTimes(1);
-  });
-
   test('rejects unsafe filenames before device communication', () => {
     const method = new DeviceUploadWallpaper({
       id: 1,

package/dist/api/device/DeviceSettings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeviceSettings.d.ts","sourceRoot":"","sources":["../../../src/api/device/DeviceSettings.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAgB3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA0D5D,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU,CAAC,aAAa,CAAC;IACnE,qBAAqB;IAIrB,IAAI;IA0EJ,eAAe;;;;;;;IAWT,GAAG;CA2HV"}
+{"version":3,"file":"DeviceSettings.d.ts","sourceRoot":"","sources":["../../../src/api/device/DeviceSettings.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAgB3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA0D5D,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU,CAAC,aAAa,CAAC;IACnE,qBAAqB;IAIrB,IAAI;IA0EJ,eAAe;;;;;;;IAWT,GAAG;CAyIV"}

package/dist/api/protocol-v2/DeviceUploadWallpaper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeviceUploadWallpaper.d.ts","sourceRoot":"","sources":["../../../src/api/protocol-v2/DeviceUploadWallpaper.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,OAAO,EAGL,KAAK,wBAAwB,EAE9B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,2BAA2B,GAAG;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,wBAAwB,CAAC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAmBF,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,UAAU,CAAC,2BAA2B,CAAC;IACxF,qBAAqB;IAIrB,OAAO,CAAC,OAAO,CAAC,CAA8D;IAE9E,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,IAAI,CAAM;IAElB,IAAI;YAwBU,kBAAkB;YAgBlB,eAAe;YAaf,MAAM;IAwBd,GAAG,IAAI,OAAO,CAAC,6BAA6B,CAAC;CAyBpD"}
+{"version":3,"file":"DeviceUploadWallpaper.d.ts","sourceRoot":"","sources":["../../../src/api/protocol-v2/DeviceUploadWallpaper.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAM3C,OAAO,EAGL,KAAK,wBAAwB,EAE9B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,2BAA2B,GAAG;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,wBAAwB,CAAC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAkBF,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,UAAU,CAAC,2BAA2B,CAAC;IACxF,qBAAqB;IAIrB,OAAO,CAAC,OAAO,CAAC,CAA8D;IAE9E,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,IAAI,CAAM;IAElB,IAAI;YAwBU,kBAAkB;YAgBlB,eAAe;YAaf,MAAM;IAwBd,GAAG,IAAI,OAAO,CAAC,6BAA6B,CAAC;CAgBpD"}

package/dist/core/index.d.ts

@@ -5,10 +5,8 @@ import DeviceConnector from '../device/DeviceConnector';
 import type { ConnectSettings } from '../types';
 import type { CoreMessage } from '../events';
 import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
-import type { BaseMethod } from '../api/BaseMethod';
 export type CoreContext = ReturnType<Core['getCoreContext']>;
 export declare const callAPI: (context: CoreContext, message: CoreMessage) => Promise<any>;
-export declare function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unknown): boolean;
 export declare const cancel: (context: CoreContext, connectId?: string) => void;
 export declare const onDeviceButtonHandler: (__0_0: Device, __0_1: import("../events").DeviceButtonRequestPayload) => void;
 export default class Core extends EventEmitter {
@@ -16,7 +14,7 @@ export default class Core extends EventEmitter {
     readonly sdkInstanceId: string;
     private requestQueue;
     private disposePromise?;
-    private prePendingCallPromises;
+    private prePendingCallPromise;
     private methodSynchronize;
     constructor();
     private getCoreContext;

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";AACA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAoClC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAsB1C,OAAO,eAAe,MAAM,2BAA2B,CAAC;AAYxD,OAAO,KAAK,EAAE,eAAe,EAAyB,MAAM,UAAU,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAmD,MAAM,WAAW,CAAC;AAI9F,OAAO,KAAK,EACV,6BAA6B,EAG9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAWpD,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAmE7D,eAAO,MAAM,OAAO,YAAmB,WAAW,WAAW,WAAW,iBAoFvE,CAAC;AA2qBF,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,WAQlF;AAsPD,eAAO,MAAM,MAAM,YAAa,WAAW,cAAc,MAAM,SAqF9D,CAAC;AAmGF,eAAO,MAAM,qBAAqB,gFAejC,CAAC;AAiLF,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,YAAY;IAC5C,OAAO,CAAC,cAAc,CAAoB;IAE1C,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO,CAAC,cAAc,CAAC,CAAgB;IAGvC,OAAO,CAAC,sBAAsB,CAAoC;IAElE,OAAO,CAAC,iBAAiB,CAAoB;;IAS7C,OAAO,CAAC,cAAc;IA6BhB,aAAa,CAAC,OAAO,EAAE,WAAW;IAuExC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAOV,gBAAgB;CAiC/B;AAED,eAAO,MAAM,QAAQ,YAIpB,CAAC;AAEF,eAAO,MAAM,aAAa,uBAYzB,CAAC;AAMF,eAAO,MAAM,IAAI,aACL,eAAe,aACd,GAAG,WACL,6BAA6B,8BAiBvC,CAAC;AAEF,eAAO,MAAM,eAAe;SAKrB,eAAe,CAAC,KAAK,CAAC;eAChB,GAAG;;UASf,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";AACA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAoClC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAsB1C,OAAO,eAAe,MAAM,2BAA2B,CAAC;AAYxD,OAAO,KAAK,EAAE,eAAe,EAAyB,MAAM,UAAU,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAmD,MAAM,WAAW,CAAC;AAI9F,OAAO,KAAK,EACV,6BAA6B,EAG9B,MAAM,wBAAwB,CAAC;AAWhC,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAmE7D,eAAO,MAAM,OAAO,YAAmB,WAAW,WAAW,WAAW,iBAoFvE,CAAC;AA44BF,eAAO,MAAM,MAAM,YAAa,WAAW,cAAc,MAAM,SAkF9D,CAAC;AAmGF,eAAO,MAAM,qBAAqB,gFAejC,CAAC;AAiLF,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,YAAY;IAC5C,OAAO,CAAC,cAAc,CAAoB;IAE1C,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO,CAAC,cAAc,CAAC,CAAgB;IAGvC,OAAO,CAAC,qBAAqB,CAA4B;IAEzD,OAAO,CAAC,iBAAiB,CAAoB;;IAS7C,OAAO,CAAC,cAAc;IAoBhB,aAAa,CAAC,OAAO,EAAE,WAAW;IAuExC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAOV,gBAAgB;CAiC/B;AAED,eAAO,MAAM,QAAQ,YAIpB,CAAC;AAEF,eAAO,MAAM,aAAa,uBAYzB,CAAC;AAMF,eAAO,MAAM,IAAI,aACL,eAAe,aACd,GAAG,WACL,6BAA6B,8BAiBvC,CAAC;AAEF,eAAO,MAAM,eAAe;SAKrB,eAAe,CAAC,KAAK,CAAC;eAChB,GAAG;;UASf,CAAC"}

package/dist/device/Device.d.ts

@@ -80,7 +80,6 @@ export declare class Device extends EventEmitter {
     get features(): Features | undefined;
     set features(features: Features | undefined);
     runPromise?: Deferred<void> | null;
-    private runCleanupPromise?;
     externalState: string[];
     unavailableCapabilities: UnavailableCapabilities;
     instance: number;
@@ -149,7 +148,6 @@ export declare class Device extends EventEmitter {
     private _initializeProtocolV2;
     getFeatures(): Promise<Features | undefined>;
     getDeviceState(params?: DeviceStateReadOptions): Promise<import("../types").DeviceState>;
-    refreshProtocolV2SettingsAfterMutation(): Promise<import("../types").DeviceState>;
     _updateFeatures(protoFeatures: PROTO.Features | Features, initSession?: boolean): void;
     updateState(patch: DeviceStatePatch, source: DeviceStateUpdateSource): import("../types").DeviceState & {
         raw?: import("../types").DeviceFeaturesRaw | undefined;