@onekeyfe/hd-core 1.2.0-alpha.66 → 1.2.0-alpha.67

package/__tests__/protocol-binding.test.ts

@@ -1,89 +0,0 @@
-import { createCoreApi, createProtocolAwareCall } from '../src/inject';
-
-import type { CoreApi } from '../src/types/api';
-
-describe('SDK protocol binding', () => {
-  test('exposes a minimal API that returns the actively detected protocol', async () => {
-    const response = { success: true as const, payload: 'V2' as const };
-    const rawCall = jest.fn().mockResolvedValue(response);
-    const api = createCoreApi(rawCall as CoreApi['call']);
-
-    await expect(api.detectDeviceConnectProtocol('USB_DEVICE_A')).resolves.toBe(response);
-    expect(rawCall).toHaveBeenCalledWith({
-      connectId: 'USB_DEVICE_A',
-      forceProtocolDetection: true,
-      method: 'detectDeviceConnectProtocol',
-    });
-  });
-
-  test('injects a strict protocol into every later call and isolates devices', async () => {
-    const rawCall = jest.fn(params => Promise.resolve({ success: true, payload: params }));
-    const protocolAwareCall = createProtocolAwareCall(rawCall as CoreApi['call']);
-    const api = createCoreApi(protocolAwareCall.call);
-
-    protocolAwareCall.setDeviceConnectProtocol('USB_DEVICE_A', 'V2');
-    protocolAwareCall.setDeviceConnectProtocol('ble-device-b', 'V1');
-
-    await api.deviceWipe('usb_device_a');
-    await api.deviceSupportFeatures('BLE-DEVICE-B');
-    await api.getFeatures('USB_DEVICE_A', { connectProtocol: 'V1' });
-    await api.getDeviceState('USB_DEVICE_A', { forceProtocolDetection: true });
-    await protocolAwareCall.call({
-      connectId: 'USB_DEVICE_A',
-      method: 'deviceUpdateReboot',
-    });
-
-    expect(rawCall).toHaveBeenNthCalledWith(1, {
-      connectId: 'usb_device_a',
-      method: 'deviceWipe',
-      connectProtocol: 'V2',
-    });
-    expect(rawCall).toHaveBeenNthCalledWith(2, {
-      connectId: 'BLE-DEVICE-B',
-      method: 'deviceSupportFeatures',
-      connectProtocol: 'V1',
-    });
-    expect(rawCall).toHaveBeenNthCalledWith(3, {
-      connectId: 'USB_DEVICE_A',
-      method: 'getFeatures',
-      connectProtocol: 'V1',
-    });
-    expect(rawCall).toHaveBeenNthCalledWith(4, {
-      connectId: 'USB_DEVICE_A',
-      method: 'getDeviceState',
-      forceProtocolDetection: true,
-    });
-    expect(rawCall).toHaveBeenNthCalledWith(5, {
-      connectId: 'USB_DEVICE_A',
-      method: 'deviceUpdateReboot',
-      connectProtocol: 'V2',
-    });
-  });
-
-  test('keeps bindings local to one SDK instance and supports clearing them', async () => {
-    const firstRawCall = jest.fn(() => Promise.resolve({ success: true, payload: {} }));
-    const secondRawCall = jest.fn(() => Promise.resolve({ success: true, payload: {} }));
-    const first = createProtocolAwareCall(firstRawCall as CoreApi['call']);
-    const second = createProtocolAwareCall(secondRawCall as CoreApi['call']);
-
-    first.setDeviceConnectProtocol('same-device', 'V2');
-    await first.call({ connectId: 'same-device', method: 'deviceWipe' });
-    await second.call({ connectId: 'same-device', method: 'deviceWipe' });
-    first.setDeviceConnectProtocol('same-device', undefined);
-    await first.call({ connectId: 'same-device', method: 'deviceWipe' });
-
-    expect(firstRawCall).toHaveBeenNthCalledWith(1, {
-      connectId: 'same-device',
-      method: 'deviceWipe',
-      connectProtocol: 'V2',
-    });
-    expect(secondRawCall).toHaveBeenCalledWith({
-      connectId: 'same-device',
-      method: 'deviceWipe',
-    });
-    expect(firstRawCall).toHaveBeenNthCalledWith(2, {
-      connectId: 'same-device',
-      method: 'deviceWipe',
-    });
-  });
-});

package/__tests__/protocol-v2-resources.test.ts

@@ -1,340 +0,0 @@
-import axios from 'axios';
-import { sha256 } from '@noble/hashes/sha256';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { DataManager } from '../src/data-manager';
-import {
-  PROTOCOL_V2_RESOURCE_DEVICE_PATHS,
-  PROTOCOL_V2_RESOURCE_TYPES,
-  buildProtocolV2ResourceUpdatePlan,
-  isProtocolV2ResourceFileValid,
-  parseProtocolV2Resources,
-  readProtocolV2ResourceInventory,
-} from '../src/protocols/protocol-v2/resources';
-
-import type {
-  ConnectSettings,
-  IProtocolV2BootResources,
-  IProtocolV2Resource,
-  RemoteConfigResponse,
-} from '../src/types';
-
-jest.mock('axios');
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0-test'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
-}));
-
-const bytesToHex = (bytes: Uint8Array) =>
-  Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
-
-const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
-
-const createResourceHeader = (headerHash: string) => {
-  const header = new Uint8Array(PROTOCOL_V2_OKPP_HEADER_SIZE);
-  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 < headerHash.length / 2; index++) {
-    header[0x240 + index] = Number.parseInt(headerHash.slice(index * 2, index * 2 + 2), 16);
-  }
-  return header;
-};
-
-const resources: IProtocolV2Resource[] = PROTOCOL_V2_RESOURCE_TYPES.map((type, index) => ({
-  type,
-  url: `https://example.com/${type}.okpkg`,
-  size: index + 100,
-  fileHash: index.toString(16).padStart(64, '0'),
-  headerHash: index.toString(16).padStart(128, '0'),
-}));
-
-const bootResources: IProtocolV2BootResources = {
-  required: false,
-  target: 'RES',
-  manifestUrl: 'https://example.com/manifest.json',
-  files: [
-    {
-      name: 'bootloader_crest.bin',
-      url: 'https://example.com/assets/bootloader_crest.bin',
-      devicePath: 'vol0:/assets/loaders/boot.staging/graphics/bootloader_crest.bin',
-      size: 1234,
-      fileHash: 'ab'.repeat(32),
-    },
-  ],
-};
-
-const createSettings = (configFetcher: ConnectSettings['configFetcher']): ConnectSettings =>
-  ({
-    env: 'node',
-    fetchConfig: true,
-    preRelease: true,
-    configFetcher,
-  } as ConnectSettings);
-
-const createRemoteConfig = (): RemoteConfigResponse =>
-  ({
-    classic: { firmware: [], ble: [] },
-    classic1s: { firmware: [], ble: [] },
-    classicpure: { firmware: [], ble: [] },
-    mini: { firmware: [], ble: [] },
-    touch: { firmware: [], ble: [] },
-    pro: { firmware: [], ble: [] },
-    pro2: { firmware: [], ble: [], resources: { stable: resources, boot: bootResources } },
-    bridge: {},
-  } as unknown as RemoteConfigResponse);
-
-describe('Pro2 resource configuration', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    DataManager.lastCheckTimestamp = 0;
-  });
-
-  test('accepts exactly six resources and normalizes their deterministic order', () => {
-    const parsed = parseProtocolV2Resources({
-      stable: [...resources].reverse(),
-      boot: bootResources,
-    });
-
-    expect(parsed?.stable.map(item => item.type)).toEqual(PROTOCOL_V2_RESOURCE_TYPES);
-    expect(parsed?.boot).toEqual(bootResources);
-    expect(PROTOCOL_V2_RESOURCE_DEVICE_PATHS.translations).toBe(
-      'vol0:/bundles/translations/translations.okpkg'
-    );
-  });
-
-  test('rejects incomplete, duplicate, or malformed stable sets', () => {
-    expect(() => parseProtocolV2Resources({ stable: resources.slice(1) })).toThrow(
-      'six unique resource types'
-    );
-    expect(() =>
-      parseProtocolV2Resources({ stable: [...resources.slice(0, 5), resources[0]] })
-    ).toThrow('six unique resource types');
-    expect(() =>
-      parseProtocolV2Resources({
-        stable: resources.map((resource, index) =>
-          index === 0 ? { ...resource, headerHash: 'bad' } : resource
-        ),
-      })
-    ).toThrow('headerHash');
-  });
-
-  test('requires boot resources to remain optional and use RES file entries', () => {
-    expect(() =>
-      parseProtocolV2Resources({
-        stable: resources,
-        boot: { ...bootResources, required: true },
-      })
-    ).toThrow('required flag');
-    expect(() =>
-      parseProtocolV2Resources({
-        stable: resources,
-        boot: { ...bootResources, target: 'INVALID' },
-      })
-    ).toThrow('expected RES');
-    expect(() =>
-      parseProtocolV2Resources({
-        stable: resources,
-        boot: {
-          ...bootResources,
-          files: [{ ...bootResources.files[0], devicePath: '../outside.bin' }],
-        },
-      })
-    ).toThrow('devicePath');
-
-    for (const devicePath of [
-      'vol0:/assets/loaders\\bootloader_crest.bin',
-      'vol0:/assets/loaders\\\\bootloader_crest.bin',
-    ]) {
-      expect(() =>
-        parseProtocolV2Resources({
-          stable: resources,
-          boot: {
-            ...bootResources,
-            files: [{ ...bootResources.files[0], devicePath }],
-          },
-        })
-      ).toThrow('devicePath');
-    }
-  });
-
-  test('downloads nothing when all resource identities match', () => {
-    const inventory = resources.map(({ type, size, headerHash }) => ({ type, size, headerHash }));
-
-    expect(
-      buildProtocolV2ResourceUpdatePlan({ resources, inventory, mode: 'application' })
-    ).toEqual({ status: 'valid', resources: [] });
-  });
-
-  test('builds inventory from existing filesystem calls without ResourceInventoryGet', async () => {
-    const installedResources = resources.map((resource, index) => ({
-      ...resource,
-      size: PROTOCOL_V2_OKPP_HEADER_SIZE + index + 1,
-    }));
-    const resourceByPath = new Map(
-      installedResources.map(resource => [
-        PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type],
-        resource,
-      ])
-    );
-    const typedCall = 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),
-              directory: false,
-              size: resource?.size ?? 0,
-            },
-          };
-        }
-        if (requestType === 'FilesystemFileRead') {
-          const resource = resourceByPath.get(payload.file.path);
-          if (!resource) throw new Error('missing resource');
-          const header = createResourceHeader(resource.headerHash);
-          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}`);
-      }
-    );
-
-    await expect(
-      readProtocolV2ResourceInventory({
-        commands: { typedCall },
-        resources: installedResources,
-        chunkSize: 4000,
-      })
-    ).resolves.toEqual(
-      installedResources.map(({ type, size, headerHash }) => ({ type, size, headerHash }))
-    );
-    expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
-    expect(typedCall.mock.calls.filter(call => call[0] === 'FilesystemPathInfoQuery')).toHaveLength(
-      6
-    );
-    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileRead')).toBe(true);
-  });
-
-  test('selects only the changed or missing resource in application mode', () => {
-    const inventory = resources
-      .filter(resource => resource.type !== 'noto')
-      .map(({ type, size, headerHash }) => ({
-        type,
-        size: type === 'images' ? size + 1 : size,
-        headerHash,
-      }));
-
-    const result = buildProtocolV2ResourceUpdatePlan({
-      resources,
-      inventory,
-      mode: 'application',
-    });
-
-    expect(result.status).toBe('outdated');
-    expect(result.resources.map(resource => resource.type)).toEqual(['images', 'noto']);
-  });
-
-  test('reports unknown without an application inventory and selects all in recovery mode', () => {
-    expect(buildProtocolV2ResourceUpdatePlan({ resources, mode: 'application' })).toEqual({
-      status: 'unknown',
-      resources: [],
-    });
-    expect(
-      buildProtocolV2ResourceUpdatePlan({ resources, mode: 'bootloader-recovery' }).resources
-    ).toHaveLength(6);
-  });
-
-  test('uses a filesystem inventory for incremental recovery mode updates', () => {
-    const inventory = resources.slice(1).map(({ type, size, headerHash }) => ({
-      type,
-      size,
-      headerHash,
-    }));
-
-    expect(
-      buildProtocolV2ResourceUpdatePlan({
-        resources,
-        inventory,
-        mode: 'bootloader-recovery',
-      }).resources.map(resource => resource.type)
-    ).toEqual(['images']);
-  });
-
-  test('verifies both full file size and SHA-256 before transfer', () => {
-    const bytes = new Uint8Array([1, 2, 3]);
-    const binary = bytes.buffer;
-    const identity = { size: bytes.byteLength, fileHash: bytesToHex(sha256(bytes)) };
-
-    expect(isProtocolV2ResourceFileValid(binary, identity)).toBe(true);
-    expect(isProtocolV2ResourceFileValid(binary, { ...identity, size: 4 })).toBe(false);
-    expect(isProtocolV2ResourceFileValid(binary, { ...identity, fileHash: '0'.repeat(64) })).toBe(
-      false
-    );
-  });
-
-  test('applies a validated pre-release config and exposes the stable resource set', async () => {
-    const configFetcher = jest.fn().mockResolvedValue(createRemoteConfig());
-
-    await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
-
-    expect(configFetcher).toHaveBeenCalledWith(
-      expect.stringMatching(/^https:\/\/data\.onekey\.so\/pre-config\.json\?noCache=/)
-    );
-    expect(DataManager.getProtocolV2Resources()).toEqual(resources);
-    expect(DataManager.getProtocolV2BootResources()).toEqual(bootResources);
-  });
-
-  test('keeps base SDK initialization available when remote Pro2 resources are invalid', async () => {
-    const remoteConfig = createRemoteConfig();
-    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
-    const configFetcher = jest.fn().mockResolvedValue(remoteConfig);
-
-    await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
-
-    expect(DataManager.getProtocolV2Resources()).toBeUndefined();
-    expect(DataManager.getProtocolV2BootResources()).toBeUndefined();
-  });
-
-  test('only blocks resource mutation when the refreshed Pro2 resources are invalid', async () => {
-    const remoteConfig = createRemoteConfig();
-    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
-    const settings = createSettings(jest.fn().mockResolvedValue(remoteConfig));
-    DataManager.settings = settings;
-
-    await expect(DataManager.forceReloadData()).resolves.toBeUndefined();
-    await expect(DataManager.forceReloadData({ requireResources: true })).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
-      message: expect.stringContaining('Invalid Pro2 resources config'),
-    });
-    expect(DataManager.lastCheckTimestamp).toBeGreaterThan(0);
-  });
-
-  test('does not advance the cache timestamp when refresh fails', async () => {
-    jest.spyOn(axios, 'get').mockRejectedValue(new Error('offline'));
-    const settings = createSettings(jest.fn().mockResolvedValue(null));
-    DataManager.settings = settings;
-
-    await DataManager.checkAndReloadData();
-
-    expect(DataManager.lastCheckTimestamp).toBe(0);
-    await expect(DataManager.forceReloadData()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.NetworkError,
-      message: 'Unable to refresh the latest remote config',
-    });
-    expect(DataManager.lastCheckTimestamp).toBe(0);
-  });
-});

package/__tests__/protocol-v2-ui-lifecycle.test.ts

@@ -1,91 +0,0 @@
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
-
-import { DEVICE } from '../src/events';
-import { Device } from '../src/device/Device';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0-test'),
-  DEFAULT_DOMAIN: 'https://example.com/',
-}));
-
-describe('Protocol V2 UI interaction lifecycle', () => {
-  test('synthesizes finish metadata for a progress-only operation', () => {
-    const device = new Device({ id: 'connect-progress' } as any);
-    device.isProtocolV2 = jest.fn(() => true);
-    device.beginProtocolV2UiInteraction();
-
-    const metadata = device.finishProtocolV2UiInteraction('succeeded', {
-      ensureMetadata: true,
-    });
-
-    expect(metadata).toMatchObject({
-      phase: 'processing',
-      transition: 'finish',
-      outcome: 'succeeded',
-      protocol: 'V2',
-    });
-  });
-
-  test('keeps finish metadata after the Protocol V2 transport is released', () => {
-    const device = new Device({ id: 'connect-released' } as any);
-    const isProtocolV2 = jest.fn().mockReturnValueOnce(true).mockReturnValue(false);
-    device.isProtocolV2 = isProtocolV2;
-    device.beginProtocolV2UiInteraction();
-
-    const metadata = device.finishProtocolV2UiInteraction('succeeded', {
-      ensureMetadata: true,
-    });
-
-    expect(metadata).toMatchObject({
-      phase: 'processing',
-      transition: 'finish',
-      outcome: 'succeeded',
-      protocol: 'V2',
-    });
-  });
-
-  test('emits a matching PIN phase completion after DeviceSessionAskPin succeeds', async () => {
-    const device = new Device({ id: 'connect-1' } as any);
-    device.isProtocolV2 = jest.fn(() => true);
-    device.updateProtocolV2Status = jest.fn(() => undefined as any);
-    device.commands = {
-      typedCall: jest.fn().mockResolvedValue({
-        message: { unlocked: true },
-      }),
-    } as any;
-    device.beginProtocolV2UiInteraction();
-
-    const starts: unknown[] = [];
-    const completions: unknown[] = [];
-    device.on(DEVICE.PIN_ON_DEVICE, (...args) => starts.push(args));
-    device.on(DEVICE.PIN_ON_DEVICE_COMPLETE, (...args) => completions.push(args));
-
-    await device.unlockDevice(DeviceSessionPinType.Main, {
-      source: 'unlock-coordinator',
-      reason: 'device-locked',
-      deviceOnly: true,
-    });
-
-    const startMetadata = (starts[0] as unknown[])[2] as Record<string, unknown>;
-    const completionMetadata = (completions[0] as unknown[])[1] as Record<string, unknown>;
-    expect(startMetadata.interaction).toMatchObject({
-      phase: 'pin',
-      transition: 'start',
-      protocol: 'V2',
-    });
-    expect(completionMetadata).toMatchObject({
-      interactionId: (startMetadata.interaction as { interactionId: string }).interactionId,
-      phaseId: (startMetadata.interaction as { phaseId: string }).phaseId,
-      phase: 'pin',
-      transition: 'complete',
-      outcome: 'succeeded',
-      protocol: 'V2',
-    });
-    expect(completionMetadata.sequence).toBeGreaterThan(
-      (startMetadata.interaction as { sequence: number }).sequence
-    );
-    expect(completionMetadata.phaseId).toBe(
-      (startMetadata.interaction as { phaseId: string }).phaseId
-    );
-  });
-});

package/__tests__/uiProgressThrottle.test.ts

@@ -1,74 +0,0 @@
-import { createUiMessage } from '../src/events';
-import { UI_REQUEST } from '../src/events/ui-request';
-import { createUiProgressMessageFilter } from '../src/utils/uiProgressThrottle';
-
-import type { KnownDevice } from '../src/types';
-
-describe('createUiProgressMessageFilter', () => {
-  let currentTime: number;
-  let shouldPostMessage: ReturnType<typeof createUiProgressMessageFilter>;
-
-  beforeEach(() => {
-    currentTime = 1_000;
-    shouldPostMessage = createUiProgressMessageFilter(250, () => currentTime);
-  });
-
-  const firmwareProgress = (
-    progress: number,
-    progressType: 'transferData' | 'installingFirmware' = 'transferData'
-  ) =>
-    createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-      device: {} as KnownDevice,
-      progress,
-      progressType,
-    });
-
-  test('limits firmware progress to one event per interval', () => {
-    expect(shouldPostMessage(firmwareProgress(1))).toBe(true);
-
-    currentTime += 100;
-    expect(shouldPostMessage(firmwareProgress(1))).toBe(false);
-
-    currentTime += 150;
-    expect(shouldPostMessage(firmwareProgress(1))).toBe(true);
-  });
-
-  test('limits transfer and install progress independently', () => {
-    expect(shouldPostMessage(firmwareProgress(1, 'transferData'))).toBe(true);
-    expect(shouldPostMessage(firmwareProgress(1, 'installingFirmware'))).toBe(true);
-
-    currentTime += 10;
-    expect(shouldPostMessage(firmwareProgress(2, 'transferData'))).toBe(false);
-    expect(shouldPostMessage(firmwareProgress(2, 'installingFirmware'))).toBe(false);
-  });
-
-  test('emits phase boundaries immediately and suppresses duplicate boundaries', () => {
-    expect(shouldPostMessage(firmwareProgress(0))).toBe(true);
-    expect(shouldPostMessage(firmwareProgress(0))).toBe(false);
-
-    currentTime += 10;
-    expect(shouldPostMessage(firmwareProgress(50))).toBe(false);
-    expect(shouldPostMessage(firmwareProgress(100))).toBe(true);
-    expect(shouldPostMessage(firmwareProgress(100))).toBe(false);
-
-    expect(shouldPostMessage(firmwareProgress(0))).toBe(true);
-  });
-
-  test('treats decreasing progress as a new phase', () => {
-    expect(shouldPostMessage(firmwareProgress(80))).toBe(true);
-
-    currentTime += 10;
-    expect(shouldPostMessage(firmwareProgress(20))).toBe(true);
-  });
-
-  test('also limits device progress and leaves other UI events unchanged', () => {
-    const deviceProgress = (progress: number) =>
-      createUiMessage(UI_REQUEST.DEVICE_PROGRESS, { progress });
-
-    expect(shouldPostMessage(deviceProgress(1))).toBe(true);
-    currentTime += 10;
-    expect(shouldPostMessage(deviceProgress(2))).toBe(false);
-
-    expect(shouldPostMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW))).toBe(true);
-  });
-});