@onekeyfe/hd-core 1.2.0-alpha.17 → 1.2.0-alpha.170

package/__tests__/pro2Nft.test.ts

@@ -0,0 +1,108 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import {
+  PRO2_NFT_IMAGE_HEIGHT,
+  PRO2_NFT_IMAGE_WIDTH,
+  PRO2_NFT_THUMBNAIL_HEIGHT,
+  PRO2_NFT_THUMBNAIL_WIDTH,
+  buildPro2NftBundle,
+} from '../src/utils/pro2Nft';
+
+const rgba = (width: number, height: number, alpha = 0xff) => {
+  const data = new Uint8Array(width * height * 4);
+  for (let index = 3; index < data.length; index += 4) data[index] = alpha;
+  return data;
+};
+
+describe('buildPro2NftBundle', () => {
+  test('builds the exact Pro2 RGB565 triplet and basename', () => {
+    const bundle = buildPro2NftBundle({
+      image: {
+        width: PRO2_NFT_IMAGE_WIDTH,
+        height: PRO2_NFT_IMAGE_HEIGHT,
+        rgba: rgba(PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT),
+      },
+      thumbnail: {
+        width: PRO2_NFT_THUMBNAIL_WIDTH,
+        height: PRO2_NFT_THUMBNAIL_HEIGHT,
+        rgba: rgba(PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT),
+      },
+      title: 'CryptoPunk #3100',
+      subtitle: 'CryptoPunks',
+      timestampMs: 1_760_000_000_000,
+    });
+
+    expect(bundle.image.byteLength).toBe(583_212);
+    expect(bundle.thumbnail.byteLength).toBe(138_876);
+    expect(Array.from(bundle.image.slice(0, 12))).toEqual([
+      0x19, 0x12, 0, 0, 28, 2, 28, 2, 56, 4, 0, 0,
+    ]);
+    expect(Array.from(bundle.thumbnail.slice(0, 12))).toEqual([
+      0x19, 0x12, 0, 0, 7, 1, 7, 1, 16, 2, 0, 0,
+    ]);
+    expect(new TextDecoder().decode(bundle.metadata)).toBe(
+      '{"title":"CryptoPunk #3100","subtitle":"CryptoPunks"}'
+    );
+    expect(bytesToHex(blake2s(bundle.image))).toBe(
+      'af4b5f8fe216cfd0ef4a9162a42b5c66a73466f2491066f66f756c4e28cc869e'
+    );
+    expect(bytesToHex(blake2s(bundle.thumbnail))).toBe(
+      '44591afae1163cc14651d77644501c6a110f96506889b825cab0351ff4de857d'
+    );
+    expect(bytesToHex(blake2s(bundle.metadata))).toBe(
+      'e30d4dc2cddd441c9f1438c783e05a623ccf76f2f6219d4281769dda1b3635b5'
+    );
+    expect(bundle.basename).toBe('nft-af4b5f8f-1760000000000');
+  });
+
+  test('composites transparent pixels onto black without an alpha plane', () => {
+    const image = rgba(PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT);
+    image.set([255, 255, 255, 0], 0);
+    const bundle = buildPro2NftBundle({
+      image: { width: PRO2_NFT_IMAGE_WIDTH, height: PRO2_NFT_IMAGE_HEIGHT, rgba: image },
+      thumbnail: {
+        width: PRO2_NFT_THUMBNAIL_WIDTH,
+        height: PRO2_NFT_THUMBNAIL_HEIGHT,
+        rgba: rgba(PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT, 0),
+      },
+      title: 'NFT',
+      subtitle: '',
+      timestampMs: 1,
+    });
+
+    expect(bundle.image[1]).toBe(0x12);
+    expect(Array.from(bundle.image.slice(12, 14))).toEqual([0, 0]);
+    expect(bundle.thumbnail.byteLength).toBe(138_876);
+  });
+
+  test('rejects invalid dimensions and metadata byte lengths', () => {
+    const validThumbnail = {
+      width: PRO2_NFT_THUMBNAIL_WIDTH,
+      height: PRO2_NFT_THUMBNAIL_HEIGHT,
+      rgba: rgba(PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT),
+    };
+    expect(() =>
+      buildPro2NftBundle({
+        image: { width: 1, height: 1, rgba: new Uint8Array(4) },
+        thumbnail: validThumbnail,
+        title: 'NFT',
+        subtitle: '',
+        timestampMs: 1,
+      })
+    ).toThrow('540x540');
+    expect(() =>
+      buildPro2NftBundle({
+        image: {
+          width: PRO2_NFT_IMAGE_WIDTH,
+          height: PRO2_NFT_IMAGE_HEIGHT,
+          rgba: rgba(PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT),
+        },
+        thumbnail: validThumbnail,
+        title: 'a'.repeat(64),
+        subtitle: '',
+        timestampMs: 1,
+      })
+    ).toThrow('1 to 63');
+  });
+});

package/__tests__/pro2Wallpaper.test.ts

@@ -1,5 +1,48 @@
 import { encodePro2Wallpaper } from '../src/utils/pro2Wallpaper';
 
+// The test decoder mirrors LZ4's bit-packed token and offset format.
+/* eslint-disable no-bitwise */
+
+function decodeLz4Block(data: Uint8Array, expectedLength: number) {
+  const output = new Uint8Array(expectedLength);
+  let inputOffset = 0;
+  let outputOffset = 0;
+
+  const readLength = (initialLength: number) => {
+    let length = initialLength;
+    if (length === 0x0f) {
+      let extension = 0xff;
+      while (extension === 0xff) {
+        extension = data[inputOffset];
+        inputOffset += 1;
+        length += extension;
+      }
+    }
+    return length;
+  };
+
+  while (inputOffset < data.byteLength) {
+    const token = data[inputOffset];
+    inputOffset += 1;
+    const literalLength = readLength(token >> 4);
+    output.set(data.subarray(inputOffset, inputOffset + literalLength), outputOffset);
+    inputOffset += literalLength;
+    outputOffset += literalLength;
+    if (inputOffset >= data.byteLength) break;
+
+    const matchOffset = data[inputOffset] | (data[inputOffset + 1] << 8);
+    inputOffset += 2;
+    const matchLength = readLength(token & 0x0f) + 4;
+    for (let index = 0; index < matchLength; index += 1) {
+      output[outputOffset] = output[outputOffset - matchOffset];
+      outputOffset += 1;
+    }
+  }
+
+  expect(outputOffset).toBe(expectedLength);
+  return output;
+}
+
 describe('encodePro2Wallpaper', () => {
   test('encodes opaque pixels as aligned LVGL v9 RGB565 data', () => {
     const result = encodePro2Wallpaper({
@@ -10,20 +53,9 @@ describe('encodePro2Wallpaper', () => {
 
     expect(result.colorFormat).toBe('RGB565');
     expect(Array.from(result.data.slice(0, 12))).toEqual([
-      0x19,
-      0x12,
-      0,
-      0,
-      2,
-      0,
-      1,
-      0,
-      4,
-      0,
-      0,
-      0,
+      0x19, 0x12, 0, 0, 2, 0, 1, 0, 4, 0, 0, 0,
     ]);
-    expect(Array.from(result.data.slice(12))).toEqual([0x00, 0xf0, 0xc0, 0x07]);
+    expect(Array.from(result.data.slice(12))).toEqual([0x00, 0xf8, 0xe0, 0x07]);
   });
 
   test('encodes transparent pixels as RGB565A8 with alpha plane after RGB data', () => {
@@ -39,12 +71,35 @@ describe('encodePro2Wallpaper', () => {
     expect(Array.from(result.data.slice(12))).toEqual([0x1f, 0x00, 0xff, 0xff, 128, 255]);
   });
 
+  test('encodes an I8 palette and pixel indices as an LVGL LZ4 block', () => {
+    const result = encodePro2Wallpaper({
+      width: 2,
+      height: 1,
+      rgba: new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]),
+      encoding: 'i8-lz4',
+    });
+
+    expect(result.colorFormat).toBe('I8');
+    expect(Array.from(result.data.slice(0, 12))).toEqual([
+      0x19, 0x0a, 0x08, 0, 2, 0, 1, 0, 2, 0, 0, 0,
+    ]);
+    const view = new DataView(result.data.buffer, result.data.byteOffset, result.data.byteLength);
+    expect(view.getUint32(12, true)).toBe(2);
+    expect(view.getUint32(16, true)).toBe(result.data.byteLength - 24);
+    expect(view.getUint32(20, true)).toBe(1026);
+
+    const rawData = decodeLz4Block(result.data.slice(24), 1026);
+    expect(Array.from(rawData.slice(210 * 4, 210 * 4 + 4))).toEqual([0, 0, 255, 255]);
+    expect(Array.from(rawData.slice(36 * 4, 36 * 4 + 4))).toEqual([0, 255, 0, 255]);
+    expect(Array.from(rawData.slice(-2))).toEqual([210, 36]);
+  });
+
   test('rejects invalid dimensions and RGBA byte length', () => {
-    expect(() =>
-      encodePro2Wallpaper({ width: 0, height: 1, rgba: new Uint8Array() })
-    ).toThrow('width');
-    expect(() =>
-      encodePro2Wallpaper({ width: 2, height: 1, rgba: new Uint8Array(4) })
-    ).toThrow('8');
+    expect(() => encodePro2Wallpaper({ width: 0, height: 1, rgba: new Uint8Array() })).toThrow(
+      'width'
+    );
+    expect(() => encodePro2Wallpaper({ width: 2, height: 1, rgba: new Uint8Array(4) })).toThrow(
+      '8'
+    );
   });
 });

package/__tests__/protocol-binding.test.ts

@@ -0,0 +1,89 @@
+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-firmware-targets.test.ts

@@ -1,4 +1,21 @@
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { ProtocolV2FirmwareTargetType } from '../src/protocols/protocol-v2/firmware';
+import {
+  assertProtocolV2FirmwareTargetsSupported,
+  isProtocolV2FirmwareFingerprintValid,
+} from '../src/api/FirmwareUpdateV4';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const componentArtifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: 1,
+  sha256: 'b'.repeat(64),
+};
 
 describe('Protocol V2 firmware target contract', () => {
   test('matches the current firmware-pro2 target ids', () => {
@@ -16,4 +33,92 @@ describe('Protocol V2 firmware target contract', () => {
       FW_MGMT_TARGET_SE04: 10,
     });
   });
+
+  test('validates the full package SHA-256 fingerprint from config', () => {
+    const binary = Uint8Array.from([1, 2, 3]);
+
+    expect(
+      isProtocolV2FirmwareFingerprintValid(
+        binary,
+        '039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81'
+      )
+    ).toBe(true);
+    expect(isProtocolV2FirmwareFingerprintValid(binary, '00'.repeat(32))).toBe(false);
+  });
+
+  test('allows only SE01 and SE02 firmware targets on Neo', () => {
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, {
+        platform: 'web',
+        targetsToUpdate: ['se01', 'se02'],
+      })
+    ).not.toThrow();
+
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, {
+        platform: 'web',
+        targetsToUpdate: ['se03'],
+        se04Binary: new ArrayBuffer(1),
+      })
+    ).toThrow('Neo only supports SE01 and SE02; unsupported firmware targets: se03, se04');
+  });
+
+  test('ignores unselected SE binaries when the caller supplied a target subset', () => {
+    const params = {
+      platform: 'web' as const,
+      targetsToUpdate: ['app_v1'] as Array<'app_v1'>,
+      se03Binary: new ArrayBuffer(1),
+      se04Binary: new ArrayBuffer(1),
+      componentArtifacts: {
+        se03: componentArtifact,
+        se04: componentArtifact,
+      },
+    };
+
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, params, true)
+    ).not.toThrow();
+    expect(() => assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, params)).toThrow(
+      'Neo only supports SE01 and SE02; unsupported firmware targets: se03, se04'
+    );
+  });
+
+  test('rejects Neo SE03 and SE04 componentArtifacts without a target list', () => {
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, {
+        platform: 'web',
+        componentArtifacts: {
+          se03: componentArtifact,
+          se04: componentArtifact,
+        },
+      })
+    ).toThrow('Neo only supports SE01 and SE02; unsupported firmware targets: se03, se04');
+  });
+
+  test('keeps all four SE firmware targets available on Pro2', () => {
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Pro2, {
+        platform: 'web',
+        targetsToUpdate: ['se03'],
+        se04Binary: new ArrayBuffer(1),
+        componentArtifacts: { se04: componentArtifact },
+      })
+    ).not.toThrow();
+  });
+
+  test('fails closed when SE03 or SE04 is requested without a confirmed device type', () => {
+    try {
+      assertProtocolV2FirmwareTargetsSupported(undefined, {
+        platform: 'web',
+        targetsToUpdate: ['se03'],
+      });
+      throw new Error('Expected unsupported target validation to fail');
+    } catch (error) {
+      expect(error).toMatchObject({ errorCode: HardwareErrorCode.DeviceNotSupportMethod });
+      expect(error).toHaveProperty(
+        'message',
+        'Cannot safely update se03 without a confirmed Pro2 device type'
+      );
+    }
+  });
 });

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

@@ -0,0 +1,28 @@
+import { validateProtocolV2PingMessage } from '../src/api/protocol-v2/Ping';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+describe('Protocol V2 diagnostic Ping validation', () => {
+  test('accepts messages up to the firmware UTF-8 byte limit', () => {
+    expect(validateProtocolV2PingMessage('x'.repeat(63))).toBe('x'.repeat(63));
+    expect(validateProtocolV2PingMessage('测'.repeat(21))).toBe('测'.repeat(21));
+  });
+
+  test('rejects messages larger than the firmware UTF-8 byte limit', () => {
+    expect(() => validateProtocolV2PingMessage('x'.repeat(64))).toThrow(
+      'Protocol V2 Ping message must not exceed 63 UTF-8 bytes.'
+    );
+    expect(() => validateProtocolV2PingMessage('测'.repeat(22))).toThrow(
+      'Protocol V2 Ping message must not exceed 63 UTF-8 bytes.'
+    );
+  });
+
+  test('rejects non-string messages at the runtime API boundary', () => {
+    expect(() => validateProtocolV2PingMessage(64)).toThrow(
+      'Protocol V2 Ping message must be a string.'
+    );
+  });
+});