@onekeyfe/hd-core 1.2.0-alpha.50 → 1.2.0-alpha.52

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -18,83 +18,6 @@ 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('releases the nested request context when an unhandled error escapes', async () => {
     const deviceInstanceId = 'device-instance';
     const innerMethod = {
@@ -128,7 +51,6 @@ describe('AllNetworkGetAddressBase tracing', () => {
       getCurrentMethodVersionRange: jest
         .fn()
         .mockImplementation((getRange: (type: string) => unknown) => getRange('classic')),
-      isProtocolV2: jest.fn().mockReturnValue(false),
       off: jest.fn(),
       on: jest.fn(),
     } as any;

package/__tests__/DeviceEventRegistration.test.ts

@@ -3,8 +3,6 @@ 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(),
@@ -23,8 +21,6 @@ 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,
@@ -38,8 +34,6 @@ 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,7 +5,6 @@ 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';
@@ -73,74 +72,7 @@ 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,
@@ -152,7 +84,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: 'required',
       hasUpgrade: true,
       required: true,
-      targetsToUpdate: ['boot', 'app_v1'],
+      targetsToUpdate: ['boot', 'app_v1', 'resource'],
       components: [
         { configKey: 'bootloader', status: 'outdated', updateTarget: 'boot' },
         { configKey: 'applicationP1', status: 'outdated', updateTarget: 'app_v1' },
@@ -291,7 +223,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(result.targetsToUpdate).toEqual(['app_v1', 'app_v2']);
   });
 
-  test('does not read vol0 resource inventory while Protocol V2 is in Application mode', async () => {
+  test('uses the existing method on Protocol V2 and keeps its public API name', async () => {
     const method = new CheckAllFirmwareRelease({
       id: 1,
       payload: {
@@ -308,7 +240,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: { mode: 'normal' },
       versions: currentVersions,
     });
-    const typedCall = createFilesystemTypedCall(true);
     method.device = {
       isProtocolV2: () => true,
       features: {
@@ -316,60 +247,21 @@ 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',
-      resourceStatus: 'unknown',
-      targetsToUpdate: ['boot', 'app_v1'],
+      targetsToUpdate: ['boot', 'app_v1', 'resource'],
       firmware: {
         status: 'required',
       },
     });
-    expect(typedCall).not.toHaveBeenCalled();
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
 
-  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;

package/__tests__/connectSettings.test.ts

@@ -1,19 +1,61 @@
+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', () => {
-  it('keeps custom configFetcher in parsed settings', () => {
-    const configFetcher = jest.fn();
+  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('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      fetchConfig: true,
-      configFetcher,
+      firmwareManifestMode: 'external-only',
     });
 
-    expect(settings.configFetcher).toBe(configFetcher);
+    await expect(DataManager.load(settings)).rejects.toThrow(
+      'External firmware config snapshot is required'
+    );
+    expect(mockAxiosGet).not.toHaveBeenCalled();
   });
 });

package/__tests__/device-initialize-timeout.test.ts

@@ -0,0 +1,56 @@
+import { Device } from '../src/device/Device';
+import TransportManager from '../src/data-manager/TransportManager';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+function buildV1Device() {
+  const device = Object.create(Device.prototype) as Device;
+  const typedCall = jest.fn(() => Promise.resolve({ message: { device_id: 'device' } }));
+  Object.assign(device, {
+    commands: { typedCall },
+    stateStore: { getState: () => undefined },
+    isProtocolV2: () => false,
+    _updateFeatures: jest.fn(),
+    getInternalState: jest.fn(() => undefined),
+  });
+  return { device, typedCall };
+}
+
+describe('Device.initialize Protocol V1 timeout', () => {
+  beforeEach(() => {
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('passes a custom Initialize timeout through to typedCall', async () => {
+    const { device, typedCall } = buildV1Device();
+
+    await device.initialize({ timeoutMs: 2500 });
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.objectContaining({ is_contains_attach: true }),
+      { timeoutMs: 2500 }
+    );
+  });
+
+  test('keeps the 25s Initialize timeout by default', async () => {
+    const { device, typedCall } = buildV1Device();
+
+    await device.initialize();
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.objectContaining({ is_contains_attach: true }),
+      { timeoutMs: 25 * 1000 }
+    );
+  });
+});

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

@@ -1,4 +1,3 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
 import { initConnector, initCore } from '../src/core';
@@ -96,25 +95,7 @@ describe('public device lifecycle events', () => {
     expect(messages.filter(message => message.type === DEVICE.DISCONNECT)).toHaveLength(1);
   });
 
-  test('uses a verified cached protocol 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: 'V1' });
-    device.deviceConnector = { acquire } as never;
-
-    await device.acquire();
-
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined);
-    expect(device.getProtocol()).toBe('V1');
-    expect(device.originalDescriptor.protocolType).toBe('V1');
-  });
-
-  test('bypasses a cached protocol only for explicit active detection', async () => {
+  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',
@@ -125,96 +106,13 @@ describe('public device lifecycle events', () => {
     const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
     device.deviceConnector = { acquire } as never;
 
-    await device.acquire(undefined, { forceProtocolDetection: true });
+    await device.acquire();
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined);
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, 'V1');
     expect(device.getProtocol()).toBe('V2');
     expect(device.originalDescriptor.protocolType).toBe('V2');
   });
 
-  test('does not reuse a stale protocol when active detection returns no 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' });
-    const release = jest.fn().mockResolvedValue(undefined);
-    device.deviceConnector = { acquire, release } as never;
-    await expect(
-      device.acquire(undefined, {
-        forceProtocolDetection: true,
-        throwOnRunPromiseError: true,
-      })
-    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.RuntimeError });
-    expect(device.originalDescriptor.protocolType).toBe('V1');
-    expect(device.hasDeviceAcquire()).toBe(false);
-    expect(release).toHaveBeenCalledWith('ble-id', false);
-  });
-
-  test('actively reacquires an already connected device without initializing it', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
-    const device = Device.fromDescriptor({
-      id: 'usb-device',
-      path: 'usb-device',
-      session: 'old-session',
-      protocolType: 'V1',
-    } as never);
-    device.mainId = 'old-session';
-    device.commands = { disposed: false } as never;
-    const release = jest.spyOn(device, 'release').mockImplementation(() => {
-      device.mainId = null;
-      device.originalDescriptor.session = null;
-      device.commands.disposed = true;
-      return Promise.resolve();
-    });
-    const acquire = jest.spyOn(device, 'acquire').mockImplementation(() => {
-      device.mainId = 'new-session';
-      device.originalDescriptor.session = 'new-session';
-      device.originalDescriptor.protocolType = 'V2';
-      device.commands.disposed = false;
-      return Promise.resolve();
-    });
-    const initialize = jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
-
-    await device.run(() => Promise.resolve(undefined), {
-      forceProtocolDetection: true,
-      skipInitialize: true,
-    });
-
-    expect(release).toHaveBeenCalled();
-    expect(acquire).toHaveBeenCalledWith(undefined, {
-      forceProtocolDetection: true,
-    });
-    expect(initialize).not.toHaveBeenCalled();
-    expect(device.getProtocol()).toBe('V2');
-  });
-
-  test('keeps the freshly probed React Native BLE session until the call completes', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
-    const device = Device.fromDescriptor({
-      id: 'ble-device',
-      path: 'ble-device',
-      commType: 'ble',
-      protocolType: 'V1',
-    } as never);
-    device.mainId = 'ble-device';
-    device.commands = { disposed: false } as never;
-    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
-    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
-    const run = jest.fn().mockResolvedValue(undefined);
-
-    await device.run(run, {
-      forceProtocolDetection: true,
-      skipInitialize: true,
-    });
-
-    expect(run).toHaveBeenCalledTimes(1);
-    expect(release).toHaveBeenCalledTimes(1);
-  });
-
   test('keeps an explicit connectProtocol as a strict expected protocol', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = Device.fromDescriptor({