@onekeyfe/hd-core 1.2.0-alpha.64 → 1.2.0-alpha.66

package/__tests__/firmware-update/firmware-update-v2-download-before-boot.test.ts

@@ -1,8 +1,8 @@
-import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import { getBinary } from '../../src/api/firmware/getBinary';
-import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/data/config', () => ({
@@ -18,8 +18,7 @@ jest.mock('../../src/api/firmware/getBinary', () => ({
 
 jest.mock('../../src/api/firmware/uploadFirmware', () => ({
   updateResources: jest.fn(),
-  updateResourcesFromSources: jest.fn(),
-  uploadFirmwareFromSource: jest.fn(),
+  uploadFirmware: jest.fn(),
 }));
 
 jest.mock('../../src/device/DevicePool', () => ({
@@ -30,9 +29,7 @@ jest.mock('../../src/device/DevicePool', () => ({
 }));
 
 const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
-const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
-  typeof uploadFirmwareFromSource
->;
+const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
 
 type DeviceType = 'CLASSIC1S' | 'PURE';
 
@@ -178,26 +175,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).toHaveBeenCalledTimes(1);
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
-  });
-
-  it('preserves structured preparation errors before any firmware mutation', async () => {
-    const preparationError = ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Firmware must be prepared by the external firmware host',
-      {
-        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-        artifactName: 'firmware',
-      }
-    );
-    mockGetBinary.mockRejectedValue(preparationError);
-    const { method, typedCall, acquire } = createMethod();
-
-    await expect(method.run()).rejects.toBe(preparationError);
-
-    expectNoFirmwareMutationCalls(typedCall);
-    expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -238,11 +216,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           binary: firmwareBinary,
         } as Awaited<ReturnType<typeof getBinary>>);
       });
-      mockUploadFirmwareFromSource.mockImplementation(() => {
+      mockUploadFirmware.mockImplementation(() => {
         callOrder.push('upload');
-        return Promise.resolve(
-          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
-        );
+        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
       });
       const { method, typedCall } = createMethod({
         updateType,
@@ -272,15 +248,15 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           },
         })
       );
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         updateType,
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: firmwareBinary.byteLength,
-        }),
-        true,
+        {
+          payload: firmwareBinary,
+          rebootOnSuccess: true,
+        },
         isUpdateBootloader
       );
     }
@@ -295,11 +271,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
         binary: firmwareBinary,
       } as Awaited<ReturnType<typeof getBinary>>);
     });
-    mockUploadFirmwareFromSource.mockImplementation(() => {
+    mockUploadFirmware.mockImplementation(() => {
       callOrder.push('upload');
       return Promise.resolve({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
     });
     const { method, typedCall, acquire } = createMethod({
       bootloaderMode: true,
@@ -324,9 +300,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           resolveDownload = resolve;
         })
     );
-    mockUploadFirmwareFromSource.mockResolvedValue({
+    mockUploadFirmware.mockResolvedValue({
       success: true,
-    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method, typedCall } = createMethod();
 
     const runPromise = method.run();
@@ -357,7 +333,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
 
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -366,23 +342,23 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
   ])(
     'keeps the non-empty %s binary overload and never downloads it again',
     async (_kind, binary) => {
-      mockUploadFirmwareFromSource.mockResolvedValue({
+      mockUploadFirmware.mockResolvedValue({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
       const { method } = createMethod({ binary });
 
       await method.run();
 
       expect(mockGetBinary).not.toHaveBeenCalled();
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         'firmware',
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: binary.byteLength,
-        }),
-        true,
+        {
+          payload: binary,
+          rebootOnSuccess: true,
+        },
         undefined
       );
     }
@@ -393,21 +369,17 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     ['DataView', new DataView(new Uint8Array([9, 3, 4, 9]).buffer, 1, 2), [3, 4]],
     ['custom Buffer', createCustomBuffer(4), [1, 2, 3, 4]],
   ])('normalizes a non-empty %s before rebooting', async (_kind, binary, expectedBytes) => {
-    let uploadedBytes: number[] = [];
-    mockUploadFirmwareFromSource.mockImplementation(
-      async (_updateType, _typedCall, _postMessage, _device, source) => {
-        uploadedBytes = Array.from(new Uint8Array(await source.readAt(0, source.size)));
-        return {
-          success: true,
-        } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>;
-      }
-    );
+    mockUploadFirmware.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method } = createMethod({ binary });
 
     await method.run();
 
     expect(mockGetBinary).not.toHaveBeenCalled();
-    expect(uploadedBytes).toEqual(expectedBytes);
+    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
+    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
   });
 
   it.each([
@@ -425,6 +397,6 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).not.toHaveBeenCalled();
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 });

package/__tests__/get-device-state.test.ts

@@ -1,4 +1,4 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceType } from '@onekeyfe/hd-transport';
 
 import { Device } from '../src/device/Device';
@@ -43,6 +43,70 @@ const getProtocolV2LoaderInfo = (mode: 'bootloader' | 'romloader') => ({
 });
 
 describe('getDeviceState', () => {
+  test('coalesces concurrent Protocol V2 runtime-context negotiation', async () => {
+    let resolveProtocolInfo:
+      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
+      | undefined;
+    const typedCall = jest.fn(
+      () =>
+        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
+          resolveProtocolInfo = resolve;
+        })
+    );
+    const device = createV2Device(typedCall);
+
+    const first = device.ensureProtocolV2RuntimeContext();
+    const second = device.ensureProtocolV2RuntimeContext();
+    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
+
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      protocolV2ApplicationInfo,
+      protocolV2ApplicationInfo,
+    ]);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+  });
+
+  test('renegotiates Protocol V2 runtime context after transport disconnect', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: protocolV2ApplicationInfo });
+    const device = createV2Device(typedCall);
+
+    await device.ensureProtocolV2RuntimeContext();
+    await device.ensureProtocolV2RuntimeContext();
+    device.markTransportDisconnected();
+    await device.ensureProtocolV2RuntimeContext();
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+  });
+
+  test('rejects every waiter when runtime-context negotiation is invalidated', async () => {
+    let resolveProtocolInfo:
+      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
+      | undefined;
+    const typedCall = jest.fn(
+      () =>
+        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
+          resolveProtocolInfo = resolve;
+        })
+    );
+    const device = createV2Device(typedCall);
+
+    const first = device.ensureProtocolV2RuntimeContext();
+    const second = device.ensureProtocolV2RuntimeContext();
+    const firstExpectation = expect(first).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInitializeFailed,
+    });
+    const secondExpectation = expect(second).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInitializeFailed,
+    });
+    device.markTransportDisconnected();
+    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
+
+    await Promise.all([firstExpectation, secondExpectation]);
+  });
+
   test('does not expose the internal wallet session', async () => {
     const device = createV2Device(jest.fn());
     device.updateState({ protocol: 'V2' }, 'initialize');
@@ -159,15 +223,20 @@ describe('getDeviceState', () => {
         throw new Error(`Unexpected request: ${requestType}`);
       });
       const device = createV2Device(typedCall);
-      device.updateState({ protocol: 'V2', status: { mode } }, 'initialize');
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType: EDeviceType.Pro2 },
+          status: { mode },
+          raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode) },
+        },
+        'initialize'
+      );
 
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-        'DeviceInfoGet',
-        'ProtocolInfoRequest',
-      ]);
+      expect(typedCall).not.toHaveBeenCalled();
     }
   );
 
@@ -187,7 +256,14 @@ describe('getDeviceState', () => {
       return { message: { init_states: true, unlocked: true, device_id: 'device-1' } };
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
 
     const state = await device.getDeviceState({ refreshSections: ['status'] });
 
@@ -205,7 +281,14 @@ describe('getDeviceState', () => {
       },
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
     const onState = jest.fn();
     device.on(DEVICE.STATE, onState);
 
@@ -250,13 +333,18 @@ describe('getDeviceState', () => {
       throw new Error(`Unexpected request: ${requestType}`);
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
 
     const state = await device.getDeviceState({ refreshSections: ['status', 'settings'] });
 
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceInfoGet',
-      'ProtocolInfoRequest',
       'DeviceStatusGet',
       'DeviceSettingsGet',
     ]);
@@ -288,7 +376,11 @@ describe('getDeviceState', () => {
     });
     const device = createV2Device(typedCall);
     device.updateState(
-      { protocol: 'V2', status: { mode: 'normal', unlocked: true } },
+      {
+        protocol: 'V2',
+        status: { mode: 'normal', unlocked: true },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
       'initialize'
     );
 
@@ -374,6 +466,34 @@ describe('getDeviceState', () => {
     });
   });
 
+  test.each([
+    EDeviceType.Classic,
+    EDeviceType.Classic1s,
+    EDeviceType.ClassicPure,
+    EDeviceType.Mini,
+  ])('keeps the GetFeatures-only firmware path for %s', async deviceType => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        onekey_device_type: deviceType.toUpperCase(),
+        initialized: true,
+        onekey_firmware_version: '3.5.0',
+        se_ver: '1.1.0.2',
+      },
+    });
+    const device = createV1Device(typedCall);
+
+    const state = await device.getDeviceState({
+      refreshSections: ['identity', 'versions', 'verification'],
+    });
+
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['GetFeatures']);
+    expect(state.versions).toMatchObject({
+      firmware: '3.5.0',
+      se: '1.1.0.2',
+      se01: '1.1.0.2',
+    });
+  });
+
   test('does not clear Protocol V1 firmware details during a later runtime refresh', async () => {
     let getFeaturesCount = 0;
     const typedCall = jest.fn().mockImplementation((requestType: string) => {

package/__tests__/homescreen.test.ts

@@ -1,6 +1,6 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
-import { getHomeScreenSize } from '../src/utils/homescreen';
+import { getHomeScreenSize, getNftSize } from '../src/utils/homescreen';
 
 describe('getHomeScreenSize', () => {
   it('returns the Pro 2 wallpaper dimensions', () => {
@@ -21,4 +21,44 @@ describe('getHomeScreenSize', () => {
       })
     ).toBeUndefined();
   });
+
+  it('does not reuse the wallpaper homeScreenType for Pro 2 NFT dimensions', () => {
+    expect(
+      getHomeScreenSize({
+        deviceType: EDeviceType.Pro2,
+        homeScreenType: 'Nft',
+        thumbnail: false,
+      })
+    ).toEqual({ width: 604, height: 1024 });
+    expect(
+      getHomeScreenSize({
+        deviceType: EDeviceType.Pro2,
+        homeScreenType: 'Nft',
+        thumbnail: true,
+      })
+    ).toBeUndefined();
+  });
+});
+
+describe('getNftSize', () => {
+  it('returns the Pro 2 NFT image and thumbnail dimensions independently', () => {
+    expect(getNftSize({ deviceType: EDeviceType.Pro2 })).toEqual({ width: 540, height: 540 });
+    expect(getNftSize({ deviceType: EDeviceType.Pro2, thumbnail: true })).toEqual({
+      width: 263,
+      height: 263,
+    });
+  });
+
+  it('preserves the legacy NFT dimensions', () => {
+    expect(getNftSize({ deviceType: EDeviceType.Touch })).toEqual({ width: 480, height: 800 });
+    expect(getNftSize({ deviceType: EDeviceType.Touch, thumbnail: true })).toEqual({
+      width: 238,
+      height: 238,
+    });
+    expect(getNftSize({ deviceType: EDeviceType.Pro, thumbnail: true })).toEqual({
+      width: 226,
+      height: 226,
+      radius: 40,
+    });
+  });
 });

package/__tests__/kaspa-use-tweak-pro2.test.ts

@@ -6,7 +6,7 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-describe('Kaspa Pro2 useTweak capability', () => {
+describe('Kaspa Pro2 product-family useTweak capability', () => {
   test.each([
     ['get address', KaspaGetAddress],
     ['sign transaction', KaspaSignTransaction],
@@ -14,7 +14,7 @@ describe('Kaspa Pro2 useTweak capability', () => {
     const method = new Method({ id: 1, payload: {} } as never);
 
     expect(method.getUseTweakVersionRange()).toMatchObject({
-      pro2: { min: '0.0.0' },
+      model_pro2: { min: '0.0.0' },
     });
   });
 });

package/__tests__/kaspaSignTransaction.test.ts

@@ -465,7 +465,7 @@ describe('KaspaSignTransaction protocol negotiation', () => {
     expect(mockTypedCall.mock.calls[4][0]).toBe('KaspaTxAckInput');
   });
 
-  describe('previous-transaction id mismatch', () => {
+  describe('streaming error propagation', () => {
     const PREV_ID = 'aa'.repeat(32);
     const withRefTxs = {
       outputs: [{ satoshis: 100000, script: SCRIPT, address: ADDRESS }],
@@ -486,7 +486,7 @@ describe('KaspaSignTransaction protocol negotiation', () => {
         )
         .mockRejectedValueOnce(error);
 
-    it('surfaces the device rejection under its own error code', async () => {
+    it('propagates a previous-transaction id mismatch without retrying', async () => {
       streamThenReject(
         ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
@@ -494,32 +494,9 @@ describe('KaspaSignTransaction protocol negotiation', () => {
         )
       );
 
-      await expect(runMethod(withRefTxs)).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.KaspaPrevTxIdMismatch,
-      });
-      // Never silently re-signs without refTxs.
-      expect(mockTypedCall).toHaveBeenCalledTimes(2);
-    });
-
-    it('leaves an unrelated device error untouched', async () => {
-      streamThenReject(
-        ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Failure_ProcessError,some other device error'
-        )
-      );
-
       await expect(runMethod(withRefTxs)).rejects.toMatchObject({
         errorCode: HardwareErrorCode.RuntimeError,
-      });
-      expect(mockTypedCall).toHaveBeenCalledTimes(2);
-    });
-
-    it('leaves user cancellation untouched', async () => {
-      streamThenReject(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
-
-      await expect(runMethod(withRefTxs)).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.ActionCancelled,
+        message: expect.stringContaining('Kaspa previous transaction id mismatch'),
       });
       expect(mockTypedCall).toHaveBeenCalledTimes(2);
     });

package/__tests__/logBlockEvent.test.ts

@@ -104,7 +104,7 @@ describe('getLogBlockLabel', () => {
     });
   });
 
-  it.each(['deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
     'keeps metadata and replaces binary payloads with their size for %s',
     method => {
       const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };

package/__tests__/method-protocol-support.test.ts

@@ -1,6 +1,7 @@
 import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from '../src/api/BaseMethod';
+import { findMethod } from '../src/api/utils';
 import BTCGetAddress from '../src/api/btc/BTCGetAddress';
 import DeviceReboot from '../src/api/protocol-v2/DeviceReboot';
 import SolGetAddress from '../src/api/solana/SolGetAddress';
@@ -20,6 +21,24 @@ class DefaultMethod extends BaseMethod {
 }
 
 describe('method protocol support', () => {
+  test('creates a protocol detection method that returns only the current protocol', async () => {
+    const method = findMethod({
+      id: 6,
+      payload: {
+        method: 'detectDeviceConnectProtocol',
+        connectId: 'ble-device',
+      },
+    } as never);
+
+    method.init();
+    (method as unknown as { device: unknown }).device = {
+      getProtocol: () => 'V2',
+    };
+
+    expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    await expect(method.run()).resolves.toBe('V2');
+  });
+
   test('defaults existing methods to Protocol V1 only', () => {
     const method = new DefaultMethod({
       id: 1,