@onekeyfe/hd-core 1.2.0-alpha.54 → 1.2.0-alpha.55

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -1,4 +1,5 @@
 import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
+import AllNetworkGetAddress from '../src/api/allnetwork/AllNetworkGetAddress';
 import { findMethod } from '../src/api/utils';
 import { getActiveRequestsByDeviceInstance } from '../src/utils/tracing';
 
@@ -18,6 +19,235 @@ 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,
+      unlockPolicy: 'unlock-before-run',
+      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.protocolV2UnlockContext = { preflightCompleted: true };
+    const typedCall = jest.fn();
+    method.device = {
+      checkPassphraseStateSafety,
+      commands: {
+        typedCall,
+      },
+      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']);
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  test('resumes a Protocol V2 standard wallet before running a nested chain method', async () => {
+    const calls: string[] = [];
+    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
+      calls.push('resume-standard-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: 44,
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockImplementation(() => {
+        calls.push('run-chain-method');
+        return Promise.resolve([{ address: '0xstandard' }]);
+      }),
+      setDevice: jest.fn(),
+      strictCheckDeviceSupport: false,
+    };
+    (findMethod as jest.Mock).mockReturnValue(innerMethod);
+    const method = new TestAllNetworkMethod({
+      id: 2,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        useEmptyPassphrase: true,
+        bundle: [],
+      },
+    });
+    method.protocolV2UnlockContext = { preflightCompleted: true };
+    const typedCall = jest.fn();
+    method.device = {
+      checkPassphraseStateSafety,
+      commands: {
+        typedCall,
+      },
+      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(undefined, true, undefined);
+    expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  test('runs Protocol V2 addresses one at a time so each command receives a wallet session', async () => {
+    const method = new AllNetworkGetAddress({
+      id: 3,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        useEmptyPassphrase: true,
+        bundle: [
+          { network: 'evm', path: "m/44'/60'/0'/0/0" },
+          { network: 'evm', path: "m/44'/60'/0'/0/1" },
+        ],
+      },
+    });
+    method.device = {
+      isProtocolV2: jest.fn().mockReturnValue(true),
+    } as any;
+    method.postMessage = jest.fn();
+    const callMethod = jest
+      .fn()
+      .mockResolvedValueOnce([{ payload: { address: '0x1' }, success: true }])
+      .mockResolvedValueOnce([{ payload: { address: '0x2' }, success: true }]);
+    method.callMethod = callMethod;
+
+    await method.getAllNetworkAddress(7);
+
+    expect(callMethod).toHaveBeenCalledTimes(2);
+    expect(callMethod).toHaveBeenNthCalledWith(
+      1,
+      'evmGetAddress',
+      expect.objectContaining({ bundle: [expect.any(Object)] }),
+      7
+    );
+    expect(callMethod).toHaveBeenNthCalledWith(
+      2,
+      'evmGetAddress',
+      expect.objectContaining({ bundle: [expect.any(Object)] }),
+      7
+    );
+  });
+
+  test('keeps same-method address batching for Protocol V1', async () => {
+    const method = new AllNetworkGetAddress({
+      id: 4,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        useEmptyPassphrase: true,
+        bundle: [
+          { network: 'evm', path: "m/44'/60'/0'/0/0" },
+          { network: 'evm', path: "m/44'/60'/0'/0/1" },
+        ],
+      },
+    });
+    method.device = {
+      isProtocolV2: jest.fn().mockReturnValue(false),
+    } as any;
+    method.postMessage = jest.fn();
+    const callMethod = jest.fn().mockResolvedValue([
+      { payload: { address: '0x1' }, success: true },
+      { payload: { address: '0x2' }, success: true },
+    ]);
+    method.callMethod = callMethod;
+
+    await method.getAllNetworkAddress(7);
+
+    expect(callMethod).toHaveBeenCalledTimes(1);
+    expect(callMethod).toHaveBeenCalledWith(
+      'evmGetAddress',
+      expect.objectContaining({ bundle: [expect.any(Object), expect.any(Object)] }),
+      7
+    );
+  });
+
   test('releases the nested request context when an unhandled error escapes', async () => {
     const deviceInstanceId = 'device-instance';
     const innerMethod = {
@@ -51,6 +281,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__/DeviceCommands.test.ts

@@ -125,6 +125,51 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
+  it('logs the sanitized DeviceFirmwareUpdateStatus response payload', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    log.messages.length = 0;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'DeviceFirmwareUpdateStatus',
+          message: {
+            records: [
+              {
+                target_id: 4,
+                status: 2,
+                payload_version: 0x010203,
+                path: 'vol0:/application_p1.bin',
+              },
+            ],
+          },
+        } as any,
+        'DeviceFirmwareUpdateStatusGet'
+      )
+    ).resolves.toMatchObject({ type: 'DeviceFirmwareUpdateStatus' });
+
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
+      {
+        request: 'DeviceFirmwareUpdateStatusGet',
+        response: {
+          type: 'DeviceFirmwareUpdateStatus',
+          message: {
+            records: [
+              {
+                target_id: 4,
+                status: 2,
+                payload_version: 0x010203,
+                path: 'vol0:/application_p1.bin',
+              },
+            ],
+          },
+        },
+      },
+    ]);
+  });
+
   it('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
     const commands = createCommands();
 

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__/check-all-firmware-release-protocol-v2.test.ts

@@ -5,6 +5,7 @@ import CheckAllFirmwareRelease, {
 } from '../src/api/CheckAllFirmwareRelease';
 import { DataManager } from '../src/data-manager';
 import { createCoreApi } from '../src/inject';
+import { PROTOCOL_V2_RESOURCE_DEVICE_PATHS } from '../src/protocols/protocol-v2/resources';
 
 import type { CoreApi } from '../src/types/api';
 import type { DeviceStateVersions, IFirmwareReleaseInfo } from '../src/types';
@@ -72,7 +73,74 @@ const release: IFirmwareReleaseInfo = {
   ],
 };
 
+const stableResources = ['images', 'animation', 'wallpaper', 'translations', 'roobert', 'noto'].map(
+  (type, index) => ({
+    type,
+    url: `https://example.com/${type}.okpkg`,
+    size: 0x52a0 + index + 1,
+    fileHash: 'a'.repeat(64),
+    headerHash: index.toString(16).padStart(128, '0'),
+  })
+);
+
+const createFilesystemTypedCall = (missingAll = false) => {
+  const resourceByPath = new Map(
+    stableResources.map(resource => [
+      PROTOCOL_V2_RESOURCE_DEVICE_PATHS[
+        resource.type as keyof typeof PROTOCOL_V2_RESOURCE_DEVICE_PATHS
+      ],
+      resource,
+    ])
+  );
+  return jest.fn((requestType: string, _responseType: string, payload: Record<string, any>) => {
+    if (requestType === 'ResourceInventoryGet') {
+      throw new Error('ResourceInventoryGet is unavailable on released firmware');
+    }
+    if (requestType === 'FilesystemPathInfoQuery') {
+      const resource = resourceByPath.get(payload.path);
+      return {
+        message: {
+          exist: Boolean(resource) && !missingAll,
+          directory: false,
+          size: missingAll ? 0 : resource?.size,
+        },
+      };
+    }
+    if (requestType === 'FilesystemFileRead') {
+      const resource = resourceByPath.get(payload.file.path);
+      if (!resource || missingAll) throw new Error('missing resource');
+      const header = new Uint8Array(0x52a0);
+      const view = new DataView(header.buffer);
+      'OKPP'.split('').forEach((char, index) => {
+        header[index] = char.charCodeAt(0);
+      });
+      'RESC'.split('').forEach((char, index) => {
+        header[0x08 + index] = char.charCodeAt(0);
+      });
+      view.setUint32(0x0c, header.byteLength, true);
+      for (let index = 0; index < resource.headerHash.length / 2; index++) {
+        header[0x240 + index] = Number.parseInt(
+          resource.headerHash.slice(index * 2, index * 2 + 2),
+          16
+        );
+      }
+      const offset = Number(payload.file.offset);
+      const chunkLength = Number(payload.chunk_len);
+      return {
+        message: {
+          data: header.slice(offset, offset + chunkLength),
+        },
+      };
+    }
+    throw new Error(`Unexpected request: ${requestType}`);
+  });
+};
+
 describe('checkAllFirmwareRelease Protocol V2 support', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   test('builds ordered firmwareUpdateV4 targets from recommended component versions', () => {
     const result = buildProtocolV2FirmwareRelease({
       currentVersions,
@@ -84,7 +152,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: 'required',
       hasUpgrade: true,
       required: true,
-      targetsToUpdate: ['boot', 'app_v1', 'resource'],
+      targetsToUpdate: ['boot', 'app_v1'],
       components: [
         { configKey: 'bootloader', status: 'outdated', updateTarget: 'boot' },
         { configKey: 'applicationP1', status: 'outdated', updateTarget: 'app_v1' },
@@ -142,6 +210,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         applicationP1Hash: 'aa'.repeat(32),
         applicationP2Hash: 'bb'.repeat(32),
       },
+      checkFirmwareHash: true,
       remotePayloadHashes: {
         applicationP1: 'aa'.repeat(64),
         applicationP2: 'cc'.repeat(64),
@@ -160,6 +229,37 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
   });
 
+  test('uses version-only comparison for same-version packages by default', () => {
+    const packageSet: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      resourceBundles: undefined,
+      installOrder: ['applicationP1'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          version: [1, 0, 0],
+          url: 'https://example.com/application-p1.okpkg',
+          payloadHash: 'cc'.repeat(64),
+        },
+      },
+    };
+
+    expect(
+      buildProtocolV2FirmwareRelease({
+        currentVersions: { ...currentVersions, applicationP1: '1.0.0' },
+        currentVerification: { applicationP1Hash: 'aa'.repeat(32) },
+        firmwareType: EFirmwareType.Universal,
+        release: packageSet,
+      })
+    ).toMatchObject({
+      status: 'valid',
+      hasUpgrade: false,
+      targetsToUpdate: [],
+      components: [{ configKey: 'applicationP1', status: 'valid' }],
+    });
+  });
+
   test('keeps same-version hash-aware components unknown without metadata payloadHash', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
@@ -180,6 +280,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       buildProtocolV2FirmwareRelease({
         currentVersions: { ...currentVersions, applicationP1: '1.0.0' },
         currentVerification: { applicationP1Hash: 'aa'.repeat(32) },
+        checkFirmwareHash: true,
         firmwareType: EFirmwareType.Universal,
         release: packageSet,
       })
@@ -215,6 +316,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const result = buildProtocolV2FirmwareRelease({
       currentVersions,
       currentVerification: { applicationP1Hash: 'aa'.repeat(32) },
+      checkFirmwareHash: true,
       remotePayloadHashes: { applicationP1: 'cc'.repeat(64) },
       firmwareType: EFirmwareType.Universal,
       release: packageSet,
@@ -223,7 +325,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(result.targetsToUpdate).toEqual(['app_v1', 'app_v2']);
   });
 
-  test('uses the existing method on Protocol V2 and keeps its public API name', async () => {
+  test('does not read vol0 resource inventory while Protocol V2 is in Application mode', async () => {
     const method = new CheckAllFirmwareRelease({
       id: 1,
       payload: {
@@ -240,6 +342,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: { mode: 'normal' },
       versions: currentVersions,
     });
+    const typedCall = createFilesystemTypedCall(true);
     method.device = {
       isProtocolV2: () => true,
       features: {
@@ -247,32 +350,124 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         firmwareVersion: '1.0.0',
       },
       getDeviceState,
+      getCommands: () => ({ typedCall }),
     } as unknown as CheckAllFirmwareRelease['device'];
     jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+    jest.spyOn(DataManager, 'getProtocolV2Resources').mockReturnValue(stableResources as any);
 
     await expect(method.run()).resolves.toMatchObject({
       protocol: 'V2',
       deviceType: 'pro2',
       status: 'required',
-      targetsToUpdate: ['boot', 'app_v1', 'resource'],
+      resourceStatus: 'unknown',
+      targetsToUpdate: ['boot', 'app_v1'],
       firmware: {
         status: 'required',
       },
     });
+    expect(typedCall).not.toHaveBeenCalled();
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: ['identity', 'versions'],
+    });
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
 
+  test('requests and compares firmware hashes only when explicitly enabled', async () => {
+    const packageSet: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      resourceBundles: undefined,
+      installOrder: ['applicationP1'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          version: [1, 0, 0],
+          url: 'https://example.com/application-p1.okpkg',
+          payloadHash: 'cc'.repeat(64),
+        },
+      },
+    };
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        firmwareType: EFirmwareType.Universal,
+        checkFirmwareHash: true,
+      },
+    });
+    method.init();
+    const getDeviceState = jest.fn().mockResolvedValue({
+      identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+      status: { mode: 'normal' },
+      versions: { ...currentVersions, applicationP1: '1.0.0' },
+      verification: { applicationP1Hash: 'aa'.repeat(32) },
+    });
+    method.device = {
+      isProtocolV2: () => true,
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
+      getDeviceState,
+      getCommands: () => ({ typedCall: jest.fn() }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(packageSet);
+    jest.spyOn(DataManager, 'getProtocolV2Resources').mockReturnValue(undefined);
+
+    await expect(method.run()).resolves.toMatchObject({
+      status: 'outdated',
+      targetsToUpdate: ['app_v1'],
+    });
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: ['identity', 'versions', 'verification'],
+    });
+  });
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'uses filesystem inventory in %s mode instead of forcing all resources',
+    async mode => {
+      const method = new CheckAllFirmwareRelease({
+        id: 1,
+        payload: {
+          method: 'checkAllFirmwareRelease',
+          firmwareType: EFirmwareType.Universal,
+        },
+      });
+      method.init();
+      const typedCall = createFilesystemTypedCall();
+      method.device = {
+        isProtocolV2: () => true,
+        features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
+        getDeviceState: jest.fn().mockResolvedValue({
+          identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+          status: { mode },
+          versions: currentVersions,
+        }),
+        getCommands: () => ({ typedCall }),
+      } as unknown as CheckAllFirmwareRelease['device'];
+      jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+      jest.spyOn(DataManager, 'getProtocolV2Resources').mockReturnValue(stableResources as any);
+
+      await expect(method.run()).resolves.toMatchObject({
+        protocol: 'V2',
+        resourceStatus: 'valid',
+        targetsToUpdate: ['boot', 'app_v1'],
+      });
+      expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
+      expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileRead')).toBe(true);
+    }
+  );
+
   test('continues forwarding the existing public method', async () => {
     const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
     const api = createCoreApi(call as CoreApi['call']) as CoreApi;
 
     await api.checkAllFirmwareRelease('pro2-connect-id', {
+      checkFirmwareHash: true,
       firmwareType: EFirmwareType.Universal,
       retryCount: 0,
     });
 
     expect(call).toHaveBeenCalledWith({
       connectId: 'pro2-connect-id',
+      checkFirmwareHash: true,
       firmwareType: EFirmwareType.Universal,
       retryCount: 0,
       method: 'checkAllFirmwareRelease',

package/__tests__/connectSettings.test.ts

@@ -1,61 +1,19 @@
-import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
-import type { RemoteConfigResponse } from '../src/types';
-
-jest.mock('axios', () => ({
-  get: jest.fn(),
-}));
-
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
-
 describe('parseConnectSettings', () => {
-  const preloadedConfig = {
-    bridge: {},
-    classic: { firmware: [], ble: [] },
-    classic1s: { firmware: [], ble: [] },
-    classicpure: { firmware: [], ble: [] },
-    mini: { firmware: [], ble: [] },
-    touch: { firmware: [], ble: [] },
-    pro: { firmware: [], ble: [] },
-    pro2: { firmware: [], ble: [] },
-  } as unknown as RemoteConfigResponse;
-
-  it('keeps a serializable preloaded config in parsed settings', () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    expect(settings.firmwareManifestMode).toBe('sdk-managed');
-    expect(settings.preloadedConfig).toBe(preloadedConfig);
-  });
-
-  it('uses the preloaded config before the SDK network client', async () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    await DataManager.load(settings);
-
-    expect(mockAxiosGet).not.toHaveBeenCalled();
-    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
-  });
+  it('keeps custom configFetcher in parsed settings', () => {
+    const configFetcher = jest.fn();
 
-  it('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      firmwareManifestMode: 'external-only',
+      fetchConfig: true,
+      configFetcher,
     });
 
-    await expect(DataManager.load(settings)).rejects.toThrow(
-      'External firmware config snapshot is required'
-    );
-    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(settings.configFetcher).toBe(configFetcher);
   });
 });