@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.12

package/__tests__/pro2HostAssetPackage.test.ts

@@ -0,0 +1,165 @@
+/* eslint-disable no-bitwise -- LZ4 decoding and deterministic test data generation require bitwise operations. */
+import { sha3_512 } from '@noble/hashes/sha3';
+
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../src/utils/pro2HostAssetPackage';
+
+const decodeRawLz4Block = (compressed: Uint8Array, expectedLength: number) => {
+  const output = new Uint8Array(expectedLength);
+  let inputOffset = 0;
+  let outputOffset = 0;
+
+  const readLength = (initialLength: number) => {
+    let length = initialLength;
+    if (length === 15) {
+      let extension = 255;
+      while (extension === 255) {
+        extension = compressed[inputOffset];
+        inputOffset += 1;
+        length += extension;
+      }
+    }
+    return length;
+  };
+
+  while (inputOffset < compressed.byteLength) {
+    const token = compressed[inputOffset];
+    inputOffset += 1;
+    const literalLength = readLength(token >>> 4);
+    output.set(compressed.subarray(inputOffset, inputOffset + literalLength), outputOffset);
+    inputOffset += literalLength;
+    outputOffset += literalLength;
+    if (inputOffset >= compressed.byteLength) break;
+
+    const matchOffset = compressed[inputOffset] | (compressed[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;
+};
+
+const decodeFirstPackageEntry = (packageData: Uint8Array, rawLength: number) => {
+  const containerHeaderSize = 0x5f90;
+  const archive = packageData.subarray(containerHeaderSize);
+  const archiveView = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const compressedOffset = archiveView.getUint32(42 + 0x100, true);
+  const compressed = archive.subarray(compressedOffset);
+  const compressedView = new DataView(
+    compressed.buffer,
+    compressed.byteOffset,
+    compressed.byteLength
+  );
+  const blockCount = compressedView.getUint16(0, true);
+  const blockSize = 1 << compressedView.getUint16(2, true);
+  let blockOffset = 8 + blockCount * 4;
+  const decodedBlocks: Uint8Array[] = [];
+
+  for (let index = 0; index < blockCount; index += 1) {
+    const compressedLength = compressedView.getUint32(8 + index * 4, true);
+    const expectedLength = Math.min(blockSize, rawLength - index * blockSize);
+    decodedBlocks.push(
+      decodeRawLz4Block(
+        compressed.subarray(blockOffset, blockOffset + compressedLength),
+        expectedLength
+      )
+    );
+    blockOffset += compressedLength;
+  }
+
+  const decoded = new Uint8Array(rawLength);
+  decodedBlocks.reduce((offset, block) => {
+    decoded.set(block, offset);
+    return offset + block.byteLength;
+  }, 0);
+  return decoded;
+};
+
+describe('Pro2 host asset package', () => {
+  test('builds the unsigned RESOURCE container and LZ4-blocked archive expected by firmware', () => {
+    const raw = new TextEncoder().encode('123456789');
+    const packageData = buildPro2HostAssetPackage([{ name: 'wallpaper.bin', data: raw }]);
+    const headerSize = 0x5f90;
+    const payload = packageData.subarray(headerSize);
+    const packageView = new DataView(
+      packageData.buffer,
+      packageData.byteOffset,
+      packageData.byteLength
+    );
+
+    expect(packageView.getUint32(0, true)).toBe(0x50504b4f);
+    expect(packageView.getUint32(4, true)).toBe(1);
+    expect(packageView.getUint32(8, true)).toBe(0x43534552);
+    expect(packageView.getUint32(0x0c, true)).toBe(headerSize);
+    expect(packageView.getUint32(0x10, true)).toBe(1);
+    expect(packageView.getUint32(0x14, true)).toBe(payload.byteLength);
+    expect(packageData.subarray(0x200, 0x240)).toEqual(sha3_512(payload));
+    expect(packageData.subarray(0x240, 0x280)).toEqual(sha3_512(packageData.subarray(0, 0x240)));
+    expect(packageData[0x400]).toBe(0);
+    expect(packageView.getUint32(0x408, true)).toBe(0x71717171);
+
+    const archiveView = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    expect(archiveView.getUint32(0, true)).toBe(0x52414b4f);
+    expect(archiveView.getUint32(4, true)).toBe(1);
+    expect(archiveView.getUint16(8, true)).toBe(1);
+    expect(new TextDecoder().decode(payload.subarray(43, 56))).toBe('wallpaper.bin');
+    expect(archiveView.getUint32(42 + 0x100, true)).toBe(340);
+    expect(archiveView.getUint32(42 + 0x104, true)).toBe(raw.byteLength);
+    expect(archiveView.getUint32(42 + 0x10c, true)).toBe(0xcbf43926);
+    expect(payload[42 + 0x114]).toBe(1);
+
+    const compressedOffset = archiveView.getUint32(42 + 0x100, true);
+    expect(archiveView.getUint16(compressedOffset, true)).toBe(1);
+    expect(archiveView.getUint16(compressedOffset + 2, true)).toBe(14);
+    expect(archiveView.getUint32(compressedOffset + 4, true)).toBe(0);
+    expect(archiveView.getUint32(compressedOffset + 8, true)).toBe(10);
+    expect(payload.subarray(compressedOffset + 12)).toEqual(new Uint8Array([0x90, ...raw]));
+  });
+
+  test('round-trips multi-block data byte-for-byte with best-match compression', () => {
+    const raw = Uint8Array.from({ length: 16_384 * 3 + 137 }, (_, index) => {
+      const column = index % 604;
+      const row = Math.floor(index / 604);
+      return (column * 31 + row * 17) & 0xff;
+    });
+
+    const packageData = buildPro2HostAssetPackage([{ name: 'wallpaper.bin', data: raw }]);
+
+    expect(decodeFirstPackageEntry(packageData, raw.byteLength)).toEqual(raw);
+  });
+
+  test('falls back to 8 KiB blocks when a compressed 16 KiB block exceeds firmware capacity', () => {
+    let state = 0x12345678;
+    const raw = Uint8Array.from({ length: 16_384 }, () => {
+      state ^= state << 13;
+      state ^= state >>> 17;
+      state ^= state << 5;
+      return state & 0xff;
+    });
+
+    const packageData = buildPro2HostAssetPackage([{ name: 'wallpaper.bin', data: raw }]);
+    const archive = packageData.subarray(0x5f90);
+    const archiveView = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+    const compressedOffset = archiveView.getUint32(42 + 0x100, true);
+
+    expect(archiveView.getUint16(compressedOffset + 2, true)).toBe(13);
+    expect(decodeFirstPackageEntry(packageData, raw.byteLength)).toEqual(raw);
+  });
+
+  test.each([
+    ['1.0.0', false],
+    ['1.0.1-beta.1', false],
+    ['1.0.1', true],
+    ['1.1.0', true],
+    [undefined, false],
+  ])('selects package uploads for firmware %s', (firmwareVersion, expected) => {
+    expect(supportsPro2HostAssetPackage(firmwareVersion)).toBe(expected);
+  });
+});

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

@@ -66,8 +66,6 @@ const createRemoteConfig = (): RemoteConfigResponse =>
         {
           required: false,
           version: [1, 0, 0],
-          url: 'https://example.com/pro2.okpkg',
-          fingerprint: 'a'.repeat(64),
           changelog: { 'zh-CN': 'Pro2', 'en-US': 'Pro2' },
           resources: { source: resourceSource },
         },
@@ -79,8 +77,6 @@ const createRemoteConfig = (): RemoteConfigResponse =>
         {
           required: false,
           version: [1, 0, 0],
-          url: 'https://example.com/neo.okpkg',
-          fingerprint: 'b'.repeat(64),
           changelog: { 'zh-CN': 'Neo', 'en-US': 'Neo' },
           resources: { source: neoResourceSource },
         },
@@ -109,6 +105,11 @@ describe('Pro2 resource configuration', () => {
     expect(
       isProtocolV2ResourceArchiveEntryName('bundles/firmware_logo-pro2-prod_resource-signed.okpkg')
     ).toBe(true);
+    expect(
+      isProtocolV2ResourceArchiveEntryName(
+        'pro2-prod_resource/bundles/firmware_logo-pro2-prod_resource-signed.okpkg'
+      )
+    ).toBe(true);
     expect(
       isProtocolV2ResourceArchiveEntryName(
         '__MACOSX/pro2-prod_resource 2/bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
@@ -119,6 +120,8 @@ describe('Pro2 resource configuration', () => {
         'bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
       )
     ).toBe(false);
+    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/manifest.json')).toBe(false);
+    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/.DS_Store')).toBe(false);
   });
 
   test('reads the version, hashes, and direct device path from a RESC package', () => {

package/__tests__/protocol-v2-unlock-policy.test.ts

@@ -151,8 +151,42 @@ describe('Protocol V2 unlock semantics', () => {
     });
 
     expect(method.unlockPolicy).toBe('unlock-before-run');
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, expect.any(Object));
     expect(run).toHaveBeenCalledTimes(1);
+    expect(method.protocolV2UnlockContext).toMatchObject({
+      preflightCompleted: true,
+      preflightStatusRefreshed: true,
+      preflightMainPinSelected: true,
+    });
+  });
+
+  test('allows either PIN type when pre-unlocking hidden-wallet selection', async () => {
+    const method = new OpenWalletSession({
+      id: 1,
+      payload: { method: 'openWalletSession', mode: 'select-hidden' },
+    });
+    method.init();
+    method.run = jest.fn().mockResolvedValue({ walletType: 'hidden' }) as any;
+    const features = { unlocked: false };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: false } }),
+      },
+      isProtocolV2: () => true,
+      isBootloader: () => false,
+      isRomloader: () => false,
+      updateProtocolV2Status: jest.fn(() => features),
+      unlockDevice: jest.fn().mockImplementation(() => {
+        features.unlocked = true;
+        return Promise.resolve(features);
+      }),
+    };
+
+    await runMethodWithUnlockPolicy(method, device as any);
+
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, expect.any(Object));
+    expect(method.protocolV2UnlockContext?.preflightMainPinSelected).toBe(false);
   });
 
   test('pre-unlocks an unregistered wallet business method', async () => {