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

package/__tests__/deviceUploadNft.test.ts

@@ -1,293 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const createRgba = (width: number, height: number) => {
-  const data = new Uint8Array(width * height * 4);
-  for (let index = 3; index < data.length; index += 4) data[index] = 0xff;
-  return data;
-};
-
-const createMethod = ({
-  typedCall,
-  supportedMessages = [60805, 60808, 61500],
-  useFullBundle = false,
-}: {
-  typedCall: jest.Mock;
-  supportedMessages?: number[];
-  useFullBundle?: boolean;
-}) => {
-  const method = new DeviceUploadNft({
-    id: 1,
-    payload: {
-      method: 'deviceUploadNft',
-      image: { width: 540, height: 540, rgba: createRgba(540, 540) },
-      thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
-      title: 'CryptoPunk #3100',
-      subtitle: 'CryptoPunks',
-      timestampMs: 1_760_000_000_000,
-      chunkSize: 2048,
-      paceMs: 0,
-    },
-  });
-  (method as any).device = {
-    commands: { typedCall },
-    ensureProtocolV2RuntimeContext: jest.fn(() =>
-      Promise.resolve({
-        version: 2,
-        build_fingerprint: 'application__1.0.0__test__DEV__DEBUG',
-        supported_messages: supportedMessages,
-      })
-    ),
-    getCurrentFirmwareType: jest.fn(),
-  };
-  method.postMessage = jest.fn();
-
-  if (useFullBundle) {
-    method.init();
-  } else {
-    (method as any).params = { chunkSize: 2048, paceMs: 0, timeoutMs: 15_000 };
-    (method as any).bundle = {
-      basename: 'nft-deadbeef-1760000000000',
-      image: new Uint8Array([1]),
-      thumbnail: new Uint8Array([2]),
-      metadata: new TextEncoder().encode('{"title":"NFT","subtitle":""}'),
-    };
-  }
-
-  return method;
-};
-
-const fileWriteSuccess = (params: { file: { offset: number; data: Uint8Array } }) => ({
-  message: {
-    processed_byte: params.file.offset + params.file.data.byteLength,
-  },
-});
-
-const nftFileList = (count: number, basenameAt?: number) =>
-  Array.from({ length: count }, (_, index) => {
-    const basename =
-      index === basenameAt
-        ? 'nft-deadbeef-1760000000000'
-        : `nft-${index.toString(16).padStart(8, '0')}-${1760000000001 + index}`;
-    return [`${basename}.bin`, `${basename}_m.bin`, `${basename}.json`];
-  })
-    .flat()
-    .join('\n');
-
-describe('DeviceUploadNft', () => {
-  test('defaults to maximum-size chunks without artificial pacing', () => {
-    const method = new DeviceUploadNft({
-      id: 1,
-      payload: {
-        method: 'deviceUploadNft',
-        image: { width: 540, height: 540, rgba: createRgba(540, 540) },
-        thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
-        title: 'CryptoPunk #3100',
-        subtitle: 'CryptoPunks',
-        timestampMs: 1_760_000_000_000,
-      },
-    });
-
-    method.init();
-
-    expect((method as any).params).toMatchObject({
-      chunkSize: 2048,
-      paceMs: 0,
-    });
-  });
-
-  test('uploads the triplet in order without creating the firmware-owned directory', async () => {
-    const typedCall = jest.fn((request: string, _response: string, params: any) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: '' } };
-      }
-      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') return { message: { message: 'NFT updated' } };
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall, useFullBundle: true });
-
-    const result = await method.run();
-
-    const requests = typedCall.mock.calls.map(call => call[0]);
-    expect(requests[0]).toBe('FilesystemDirList');
-    expect(typedCall).toHaveBeenNthCalledWith(
-      1,
-      'FilesystemDirList',
-      'FilesystemDir',
-      { path: 'vol1:/nft', depth: 1 },
-      { timeoutMs: 15_000 }
-    );
-    expect(requests).not.toContain('FilesystemDirMake');
-    expect(requests.at(-1)).toBe('NftUpdate');
-    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
-    const paths = fileWrites.map(call => call[2].file.path as string);
-    const imagePath = paths[0];
-    const thumbnailStart = paths.findIndex(path => path.endsWith('_m.bin'));
-    const metadataStart = paths.findIndex(path => path.endsWith('.json'));
-    expect(imagePath).toMatch(/^vol1:\/nft\/nft-[a-f0-9]{8}-1760000000000\.bin$/);
-    expect(thumbnailStart).toBeGreaterThan(0);
-    expect(metadataStart).toBeGreaterThan(thumbnailStart);
-    expect(new Set(paths.slice(0, thumbnailStart))).toEqual(new Set([imagePath]));
-    expect(new Set(paths.slice(thumbnailStart, metadataStart))).toEqual(
-      new Set([result.thumbnailPath])
-    );
-    expect(typedCall).toHaveBeenLastCalledWith(
-      'NftUpdate',
-      'Success',
-      { file_name_no_ext: result.basename },
-      { timeoutMs: 15_000 }
-    );
-    expect(result).toMatchObject({
-      nftUpdated: true,
-      message: 'NFT updated',
-      totalSize: 583_212 + 138_876 + 53,
-    });
-    expect(method.postMessage).toHaveBeenLastCalledWith({
-      event: 'UI_EVENT',
-      type: 'ui-device_progress',
-      payload: expect.objectContaining({
-        progress: 100,
-        transferredBytes: result.totalSize,
-        totalBytes: result.totalSize,
-      }),
-    });
-  });
-
-  test('retries one timed-out NftUpdate with the same basename', async () => {
-    const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
-      code: 'response-timeout',
-    });
-    let updateCalls = 0;
-    const typedCall = jest.fn((request: string, _response: string, params: any) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: '' } };
-      }
-      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') {
-        updateCalls += 1;
-        if (updateCalls === 1) throw timeout;
-        return { message: { message: 'NFT updated' } };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
-
-    const updateRequests = typedCall.mock.calls.filter(call => call[0] === 'NftUpdate');
-    expect(updateRequests).toHaveLength(2);
-    expect(updateRequests[1]).toEqual(updateRequests[0]);
-  });
-
-  test('does not retry a non-timeout NftUpdate failure', async () => {
-    const typedCall = jest.fn((request: string, _response: string, params: any) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: '' } };
-      }
-      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') throw new Error('Invalid NFT metadata');
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).rejects.toThrow('Invalid NFT metadata');
-    expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(1);
-  });
-
-  test('propagates a second NftUpdate timeout after one retry', async () => {
-    const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
-      code: 'response-timeout',
-    });
-    const typedCall = jest.fn((request: string, _response: string, params: any) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: '' } };
-      }
-      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') throw timeout;
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).rejects.toBe(timeout);
-    expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(2);
-  });
-
-  test('does not publish when a file write fails', async () => {
-    const typedCall = jest.fn((request: string) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: '' } };
-      }
-      if (request === 'FilesystemFileWrite') throw new Error('Filesystem full');
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).rejects.toThrow('Filesystem full');
-    expect(typedCall.mock.calls.some(call => call[0] === 'NftUpdate')).toBe(false);
-  });
-
-  test('rejects unsupported firmware before writing files', async () => {
-    const typedCall = jest.fn();
-    const method = createMethod({ typedCall, supportedMessages: [60805] });
-
-    await expect(method.run()).rejects.toBeDefined();
-    expect(typedCall).not.toHaveBeenCalled();
-  });
-
-  test('rejects a new NFT before writing when ten complete NFT bundles exist', async () => {
-    const typedCall = jest.fn((request: string) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: nftFileList(10) } };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.NftStorageLimitReached,
-      params: { count: 10, limit: 10 },
-    });
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['FilesystemDirList']);
-  });
-
-  test('allows an idempotent retry for a basename already counted at the limit', async () => {
-    const typedCall = jest.fn((request: string, _response: string, params: any) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: nftFileList(10, 0) } };
-      }
-      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') return { message: {} };
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
-    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileWrite')).toBe(true);
-  });
-
-  test('does not count unrelated or incomplete files as stored NFTs', async () => {
-    const typedCall = jest.fn((request: string, _response: string, params: any) => {
-      if (request === 'FilesystemDirList') {
-        return {
-          message: {
-            path: 'vol1:/nft',
-            child_files: `${nftFileList(9)}\nnft-ffffffff-1760000009999.json\nnotes.txt`,
-          },
-        };
-      }
-      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') return { message: {} };
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
-  });
-});

package/__tests__/pro2Nft.test.ts

@@ -1,108 +0,0 @@
-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__/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',
-    });
-  });
-});