@onekeyfe/hd-core 1.2.0-alpha.106 → 1.2.0-alpha.107

package/src/utils/pro2Nft.ts

@@ -109,34 +109,6 @@ export function buildPro2NftBundle(options: {
   const { image, thumbnail, title, subtitle, timestampMs } = options;
   assertImage('image', image, PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT);
   assertImage('thumbnail', thumbnail, PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT);
-  const encodedImage = encodePro2Image({ ...image, alphaMode: 'black-background' }).data;
-  const encodedThumbnail = encodePro2Image({
-    ...thumbnail,
-    alphaMode: 'black-background',
-  }).data;
-  return buildPro2NftBundleFromEncodedImages({
-    image: encodedImage,
-    thumbnail: encodedThumbnail,
-    title,
-    subtitle,
-    timestampMs,
-  });
-}
-
-export function buildPro2NftBundleFromEncodedImages(options: {
-  image: Uint8Array;
-  thumbnail: Uint8Array;
-  title: string;
-  subtitle: string;
-  timestampMs: number;
-}): Pro2NftBundle {
-  const { image, thumbnail, title, subtitle, timestampMs } = options;
-  if (!(image instanceof Uint8Array) || image.byteLength === 0) {
-    throw invalidParameter('Parameter [image] must contain encoded NFT image data.');
-  }
-  if (!(thumbnail instanceof Uint8Array) || thumbnail.byteLength === 0) {
-    throw invalidParameter('Parameter [thumbnail] must contain encoded NFT thumbnail data.');
-  }
   const titleLength = typeof title === 'string' ? utf8Length(title) : 0;
   const subtitleLength =
     typeof subtitle === 'string' ? utf8Length(subtitle) : Number.POSITIVE_INFINITY;
@@ -150,16 +122,21 @@ export function buildPro2NftBundleFromEncodedImages(options: {
     throw invalidParameter('Parameter [timestampMs] must be a positive safe integer.');
   }
 
+  const encodedImage = encodePro2Image({ ...image, alphaMode: 'black-background' }).data;
+  const encodedThumbnail = encodePro2Image({
+    ...thumbnail,
+    alphaMode: 'black-background',
+  }).data;
   const metadata = new TextEncoder().encode(JSON.stringify({ title, subtitle }));
   if (metadata.byteLength === 0 || metadata.byteLength > 512) {
     throw invalidParameter('Pro2 NFT metadata must contain 1 to 512 UTF-8 bytes.');
   }
 
-  const hash8 = bytesToHex(blake2s(image)).slice(0, 8);
+  const hash8 = bytesToHex(blake2s(encodedImage)).slice(0, 8);
   return {
     basename: `nft-${hash8}-${timestampMs}`,
-    image,
-    thumbnail,
+    image: encodedImage,
+    thumbnail: encodedThumbnail,
     metadata,
   };
 }

package/__tests__/base64Data.test.ts

@@ -1,70 +0,0 @@
-import { Buffer } from 'buffer';
-
-import { encode as encodeJpeg } from 'jpeg-js';
-
-import { decodeCanonicalBase64, decodeJpegBase64ToRgba } from '../src/api/helpers/base64Data';
-
-const createJpegBase64 = (width: number, height: number) => {
-  const rgba = new Uint8Array(width * height * 4).fill(0xff);
-  return encodeJpeg({ width, height, data: rgba }, 80).data.toString('base64');
-};
-
-describe('Base64 resource data', () => {
-  test('decodes canonical Base64 to a detached Uint8Array', () => {
-    const decoded = decodeCanonicalBase64({
-      value: 'AQID',
-      parameterName: 'packageBase64',
-      maxBytes: 3,
-    });
-
-    expect(decoded).toBeInstanceOf(Uint8Array);
-    expect(Array.from(decoded)).toEqual([1, 2, 3]);
-  });
-
-  test.each(['', 'not-base64', 'AB==', 'data:image/jpeg;base64,AQID'])(
-    'rejects non-canonical Base64 input %p',
-    value => {
-      expect(() =>
-        decodeCanonicalBase64({ value, parameterName: 'data', maxBytes: 1024 })
-      ).toThrow();
-    }
-  );
-
-  test('rejects oversized Base64 before decoding', () => {
-    const value = Buffer.alloc(64 * 1024 + 17).toString('base64');
-    expect(() =>
-      decodeCanonicalBase64({ value, parameterName: 'data', maxBytes: 64 * 1024 })
-    ).toThrow('maximum supported size');
-  });
-
-  test('decodes and validates a JPEG with the expected dimensions', () => {
-    const decoded = decodeJpegBase64ToRgba({
-      jpegBase64: createJpegBase64(2, 1),
-      parameterName: 'jpegBase64',
-      expectedWidth: 2,
-      expectedHeight: 1,
-    });
-
-    expect(decoded).toMatchObject({ width: 2, height: 1 });
-    expect(decoded.data).toHaveLength(8);
-  });
-
-  test('rejects non-JPEG bytes and unexpected dimensions', () => {
-    expect(() =>
-      decodeJpegBase64ToRgba({
-        jpegBase64: 'AQID',
-        parameterName: 'jpegBase64',
-        expectedWidth: 2,
-        expectedHeight: 1,
-      })
-    ).toThrow('JPEG image');
-    expect(() =>
-      decodeJpegBase64ToRgba({
-        jpegBase64: createJpegBase64(2, 1),
-        parameterName: 'jpegBase64',
-        expectedWidth: 1,
-        expectedHeight: 1,
-      })
-    ).toThrow('1x1');
-  });
-});

package/__tests__/firmware-update/firmware-update-v4-install-poll.test.ts

@@ -1,145 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
-import { DataManager } from '../../src/data-manager';
-
-import type { Device } from '../../src/device/Device';
-
-jest.mock('../../src/data/config', () => ({
-  DEFAULT_DOMAIN: 'https://example.com/',
-  getSDKVersion: () => '0.0.0-test',
-}));
-
-describe('FirmwareUpdateV4 install polling', () => {
-  let getSettingsSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    getSettingsSpy = jest
-      .spyOn(DataManager, 'getSettings')
-      .mockReturnValue('react-native' as never);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  test('polls status instead of replaying install after React Native BLE releases', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-ble',
-      },
-    });
-    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-    const typedCall = jest
-      .fn()
-      .mockRejectedValueOnce(new Error('React Native BLE transport released'))
-      .mockResolvedValueOnce({
-        message: {
-          records: [
-            {
-              target_id: 4,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-              path: 'vol0:/application_p1.bin',
-            },
-          ],
-        },
-      });
-
-    method.device = {
-      getCommands: () => ({ typedCall }),
-    } as unknown as Device;
-    method.postTipMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-
-    const firmwareUpdate = method as unknown as {
-      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
-      waitForProtocolV2FirmwareUpdateComplete: (value: typeof targets) => Promise<void>;
-      reconnectProtocolV2Device: () => Promise<void>;
-      verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
-    };
-    firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
-    firmwareUpdate.verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({});
-
-    await expect(
-      firmwareUpdate.protocolV2StartFirmwareUpdate({ targets })
-    ).resolves.toBeUndefined();
-    await expect(
-      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets)
-    ).resolves.toBeUndefined();
-
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall.mock.calls[0]?.[0]).toBe('DeviceFirmwareUpdateRequest');
-    expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
-  });
-
-  test('does not treat an explicit workflow cancellation as an install reboot', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        connectId: 'pro2-ble',
-      },
-    });
-    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-    const typedCall = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
-    const abortController = new AbortController();
-    abortController.abort();
-
-    method.abortSignal = abortController.signal;
-    method.device = {
-      getCommands: () => ({ typedCall }),
-    } as unknown as Device;
-
-    await expect(
-      (
-        method as unknown as {
-          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
-        }
-      ).protocolV2StartFirmwareUpdate({ targets })
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.CallQueueActionCancelled,
-    });
-
-    expect(typedCall).toHaveBeenCalledTimes(1);
-  });
-
-  test.each([
-    ['webusb', 'React Native BLE transport released'],
-    ['react-native', 'Connection error has occured: Device disconnected'],
-  ])(
-    'requires both a BLE environment and an explicit transport release signal: %s / %s',
-    async (env, message) => {
-      getSettingsSpy.mockReturnValue(env);
-      const method = new FirmwareUpdateV4({
-        id: 1,
-        payload: {
-          method: 'firmwareUpdateV4',
-          connectId: 'pro2-device',
-        },
-      });
-      const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-      const typedCall = jest.fn().mockRejectedValue(new Error(message));
-
-      method.device = {
-        getCommands: () => ({ typedCall }),
-      } as unknown as Device;
-      method.postTipMessage = jest.fn();
-      method.postProgressMessage = jest.fn();
-
-      await expect(
-        (
-          method as unknown as {
-            protocolV2StartFirmwareUpdate: (params: {
-              targets: typeof targets;
-            }) => Promise<unknown>;
-          }
-        ).protocolV2StartFirmwareUpdate({ targets })
-      ).rejects.toThrow(message);
-
-      expect(method.postTipMessage).not.toHaveBeenCalled();
-      expect(method.postProgressMessage).not.toHaveBeenCalled();
-    }
-  );
-});

package/__tests__/resourceBase64Boundary.test.ts

@@ -1,48 +0,0 @@
-import { HardwareTopLevelSdk } from '../src';
-import { findMethod } from '../src/api/utils';
-
-import type { LowLevelCoreApi } from '../src';
-
-jest.mock('../src/data/config', () => ({
-  DEFAULT_DOMAIN: 'https://example.com/',
-  getSDKVersion: () => '0.0.0-test',
-}));
-
-const crossJsonOnlyBridge = (value: unknown): unknown => JSON.parse(JSON.stringify(value));
-
-describe('Base64 resource boundary', () => {
-  test('keeps Portfolio, wallpaper and NFT payloads JSON-safe across TopLevel and LowLevel', async () => {
-    const restoredPayloads: Array<Record<string, any>> = [];
-    const lowLevelApi = {
-      call: jest.fn(params => {
-        const method = findMethod({ id: 1, payload: crossJsonOnlyBridge(params) } as any);
-        restoredPayloads.push(method.payload);
-        return Promise.resolve({ success: true, payload: {} });
-      }),
-      init: jest.fn(() => Promise.resolve(true)),
-    } as unknown as LowLevelCoreApi;
-    const sdk = HardwareTopLevelSdk();
-    await sdk.init({}, lowLevelApi);
-
-    await sdk.uploadPortfolio('connect-id', { packageBase64: 'AQID' });
-    await sdk.deviceUploadWallpaper('connect-id', { jpegBase64: '/9j/' });
-    await sdk.deviceUploadNft('connect-id', {
-      imageJpegBase64: '/9j/',
-      thumbnailJpegBase64: '/9j/',
-      title: 'NFT',
-      subtitle: '',
-    });
-
-    expect(restoredPayloads.map(payload => payload.method)).toEqual([
-      'uploadPortfolio',
-      'deviceUploadWallpaper',
-      'deviceUploadNft',
-    ]);
-    expect(restoredPayloads[0].packageBase64).toBe('AQID');
-    expect(restoredPayloads[1].jpegBase64).toBe('/9j/');
-    expect(restoredPayloads[2]).toMatchObject({
-      imageJpegBase64: '/9j/',
-      thumbnailJpegBase64: '/9j/',
-    });
-  });
-});

package/__tests__/ton-sign-message.test.ts

@@ -1,84 +0,0 @@
-import { EDeviceType } from '@onekeyfe/hd-shared';
-
-import TonSignMessage from '../src/api/ton/TonSignMessage';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const createMethod = (deviceType: EDeviceType) => {
-  const method = new TonSignMessage({
-    id: 1,
-    payload: {
-      method: 'tonSignMessage',
-    },
-  });
-
-  Object.defineProperty(method, 'device', {
-    value: {
-      getCurrentDeviceType: () => deviceType,
-    },
-  });
-
-  return method;
-};
-
-describe('TonSignMessage response compatibility', () => {
-  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
-    'uses the corrected signing_message field for %s',
-    async deviceType => {
-      const method = createMethod(deviceType);
-
-      await expect(
-        method.processTxRequest(
-          {
-            signature: 'signature',
-            signing_message: 'serialized-message',
-          },
-          ''
-        )
-      ).resolves.toEqual({
-        signature: 'signature',
-        signing_message: 'serialized-message',
-        skip_validate: false,
-      });
-    }
-  );
-
-  test('normalizes the legacy Protocol V1 field without removing it', async () => {
-    const method = createMethod(EDeviceType.Classic1s);
-
-    await expect(
-      method.processTxRequest(
-        {
-          signature: 'signature',
-          signning_message: 'message-hash',
-        },
-        ''
-      )
-    ).resolves.toEqual({
-      signature: 'signature',
-      signning_message: 'message-hash',
-      signing_message: 'message-hash',
-      skip_validate: true,
-    });
-  });
-
-  test('skips validation when blind signing omits the signing message', async () => {
-    const method = createMethod(EDeviceType.Pro2);
-
-    await expect(
-      method.processTxRequest(
-        {
-          signature: 'signature',
-        },
-        ''
-      )
-    ).resolves.toEqual({
-      signature: 'signature',
-      signing_message: undefined,
-      skip_validate: true,
-    });
-  });
-});

package/dist/api/helpers/base64Data.d.ts

@@ -1,16 +0,0 @@
-export declare function decodeCanonicalBase64({ value, parameterName, maxBytes, }: {
-    value: unknown;
-    parameterName: string;
-    maxBytes: number;
-}): Uint8Array;
-export declare function decodeJpegBase64ToRgba({ jpegBase64, parameterName, expectedWidth, expectedHeight, }: {
-    jpegBase64: unknown;
-    parameterName: string;
-    expectedWidth: number;
-    expectedHeight: number;
-}): {
-    width: number;
-    height: number;
-    data: Uint8Array;
-};
-//# sourceMappingURL=base64Data.d.ts.map

package/dist/api/helpers/base64Data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base64Data.d.ts","sourceRoot":"","sources":["../../../src/api/helpers/base64Data.ts"],"names":[],"mappings":"AAUA,wBAAgB,qBAAqB,CAAC,EACpC,KAAK,EACL,aAAa,EACb,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,UAAU,CAmBb;AAED,wBAAgB,sBAAsB,CAAC,EACrC,UAAU,EACV,aAAa,EACb,aAAa,EACb,cAAc,GACf,EAAE;IACD,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAmCtD"}

package/src/api/helpers/base64Data.ts

@@ -1,85 +0,0 @@
-import { Buffer } from 'buffer';
-import { decode as decodeJpeg } from 'jpeg-js';
-
-import { invalidParameter } from './filesystemValidation';
-
-const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-const JPEG_CONTAINER_OVERHEAD_BYTES = 64 * 1024;
-const JPEG_MAX_MEMORY_USAGE_IN_MB = 32;
-const JPEG_MAX_RESOLUTION_IN_MP = 1;
-
-export function decodeCanonicalBase64({
-  value,
-  parameterName,
-  maxBytes,
-}: {
-  value: unknown;
-  parameterName: string;
-  maxBytes: number;
-}): Uint8Array {
-  if (typeof value !== 'string' || value.length === 0) {
-    throw invalidParameter(`Parameter [${parameterName}] must be a non-empty Base64 string.`);
-  }
-  if (value.length > Math.ceil(maxBytes / 3) * 4) {
-    throw invalidParameter(`Parameter [${parameterName}] exceeds the maximum supported size.`);
-  }
-  if (value.length % 4 !== 0 || !BASE64_PATTERN.test(value)) {
-    throw invalidParameter(`Parameter [${parameterName}] must use canonical Base64 encoding.`);
-  }
-
-  const decoded = Buffer.from(value, 'base64');
-  if (decoded.byteLength === 0 || decoded.byteLength > maxBytes) {
-    throw invalidParameter(`Parameter [${parameterName}] exceeds the maximum supported size.`);
-  }
-  if (decoded.toString('base64') !== value) {
-    throw invalidParameter(`Parameter [${parameterName}] must use canonical Base64 encoding.`);
-  }
-  return Uint8Array.from(decoded);
-}
-
-export function decodeJpegBase64ToRgba({
-  jpegBase64,
-  parameterName,
-  expectedWidth,
-  expectedHeight,
-}: {
-  jpegBase64: unknown;
-  parameterName: string;
-  expectedWidth: number;
-  expectedHeight: number;
-}): { width: number; height: number; data: Uint8Array } {
-  const jpegBytes = decodeCanonicalBase64({
-    value: jpegBase64,
-    parameterName,
-    maxBytes: expectedWidth * expectedHeight * 8 + JPEG_CONTAINER_OVERHEAD_BYTES,
-  });
-  if (jpegBytes[0] !== 0xff || jpegBytes[1] !== 0xd8) {
-    throw invalidParameter(`Parameter [${parameterName}] must contain a JPEG image.`);
-  }
-
-  let decoded: { width: number; height: number; data: Uint8Array };
-  try {
-    decoded = decodeJpeg(jpegBytes, {
-      useTArray: true,
-      formatAsRGBA: true,
-      tolerantDecoding: false,
-      maxResolutionInMP: JPEG_MAX_RESOLUTION_IN_MP,
-      maxMemoryUsageInMB: JPEG_MAX_MEMORY_USAGE_IN_MB,
-    });
-  } catch {
-    throw invalidParameter(`Parameter [${parameterName}] must contain a valid JPEG image.`);
-  }
-
-  if (decoded.width !== expectedWidth || decoded.height !== expectedHeight) {
-    throw invalidParameter(
-      `Parameter [${parameterName}] must contain a ${expectedWidth}x${expectedHeight} JPEG image.`
-    );
-  }
-  const expectedLength = expectedWidth * expectedHeight * 4;
-  if (decoded.data.byteLength !== expectedLength) {
-    throw invalidParameter(
-      `Decoded parameter [${parameterName}] must contain ${expectedLength} RGBA bytes.`
-    );
-  }
-  return decoded;
-}