@onekeyfe/hd-core 1.2.0-alpha.7 → 1.2.0-alpha.71

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

@@ -0,0 +1,343 @@
+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 seven 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'
+    );
+    expect(PROTOCOL_V2_RESOURCE_DEVICE_PATHS.firmware_logo).toBe(
+      'vol0:/bundles/firmware_logo.okpkg'
+    );
+  });
+
+  test('rejects incomplete, duplicate, or malformed stable sets', () => {
+    expect(() => parseProtocolV2Resources({ stable: resources.slice(1) })).toThrow(
+      '7 unique resource types'
+    );
+    expect(() =>
+      parseProtocolV2Resources({ stable: [...resources.slice(0, 6), resources[0]] })
+    ).toThrow('7 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(
+      7
+    );
+    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(7);
+  });
+
+  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

@@ -0,0 +1,91 @@
+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
+    );
+  });
+});