@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -95,7 +95,8 @@ describe('AllNetworkGetAddressBase tracing', () => {
       'hidden-state',
       false,
       undefined,
-      false
+      false,
+      undefined
     );
     expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
@@ -173,7 +174,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined, true);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      'hidden-state',
+      false,
+      undefined,
+      true,
+      undefined
+    );
     expect(calls).toEqual(['resume-cardano-session', 'run-cardano-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });
@@ -212,7 +219,10 @@ describe('AllNetworkGetAddressBase tracing', () => {
         bundle: [],
       },
     });
-    method.protocolV2UnlockContext = { preflightCompleted: true };
+    method.protocolV2UnlockContext = {
+      preflightCompleted: true,
+      preflightMainPinSelected: true,
+    };
     const typedCall = jest.fn();
     method.device = {
       checkPassphraseStateSafety,
@@ -250,7 +260,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined, false);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      undefined,
+      true,
+      undefined,
+      false,
+      true
+    );
     expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });

package/__tests__/DeviceCommands.test.ts

@@ -19,12 +19,28 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('logs passphrase call request and response without exposing the passphrase', async () => {
+  it.each(['File already exists', 'NFT already exists'])(
+    'maps duplicate file response "%s" to FileAlreadyExists',
+    async message => {
+      const commands = createCommands();
+      await expect(
+        commands._filterCommonTypes(
+          {
+            type: 'Failure',
+            message: { code: 'Failure_DataError', message },
+          } as any,
+          'NFTUpdate'
+        )
+      ).rejects.toMatchObject({ errorCode: HardwareErrorCode.FileAlreadyExists });
+    }
+  );
+
+  it('logs passphrase request and canonical response without exposing the passphrase', async () => {
     const commands = createCommands();
-    const requestLog = getLogger(LoggerNames.DeviceCommands);
-    const responseLog = getLogger(LoggerNames.Core);
-    requestLog.messages.length = 0;
-    responseLog.messages.length = 0;
+    const log = getLogger(LoggerNames.DeviceCommands);
+    const coreLog = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    coreLog.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
       call: jest.fn().mockResolvedValue({
@@ -36,13 +52,13 @@ describe('DeviceCommands failure mapping', () => {
     } as any;
 
     await expect(
-      commands.call('DeviceSessionAskPassphrase', {
+      commands._commonCall('DeviceSessionAskPassphrase', {
         passphrase: 'hidden-wallet-secret',
         on_device: false,
       })
     ).resolves.toMatchObject({ type: 'Success' });
 
-    expect(requestLog.messages.at(-1)?.message).toEqual([
+    expect(log.messages.at(-2)?.message).toEqual([
       '[DeviceCommands] [call] Sending',
       'DeviceSessionAskPassphrase',
       {
@@ -50,21 +66,82 @@ describe('DeviceCommands failure mapping', () => {
         on_device: false,
       },
     ]);
-    expect(responseLog.messages.at(-1)?.message).toEqual([
-      '[DeviceCommands] [call] Received',
-      'Success',
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
+      {
+        request: 'DeviceSessionAskPassphrase',
+        response: {
+          type: 'Success',
+          message: {
+            message: 'Passphrase accepted',
+          },
+        },
+      },
+    ]);
+    expect(
+      coreLog.messages.some(entry => entry.message[0] === '[DeviceCommands] [call] Received')
+    ).toBe(false);
+    expect(JSON.stringify([...log.messages, ...coreLog.messages])).not.toContain(
+      'hidden-wallet-secret'
+    );
+  });
+
+  it('redacts passphrases from transport errors logged through Core', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    const coreLog = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    coreLog.messages.length = 0;
+    const transportError = Object.assign(new Error('transport failed'), {
+      response: {
+        data: {
+          passphrase: 'hidden-wallet-secret',
+        },
+      },
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(
+      commands._commonCall('DeviceSessionAskPassphrase', {
+        passphrase: 'hidden-wallet-secret',
+        on_device: false,
+      })
+    ).rejects.toBe(transportError);
+
+    expect(coreLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Received error',
       {
-        message: 'Passphrase accepted',
+        request: 'DeviceSessionAskPassphrase',
+        errorCode: undefined,
+        response: {
+          passphrase: '[REDACTED]',
+        },
       },
     ]);
-    expect(JSON.stringify([...requestLog.messages, ...responseLog.messages])).not.toContain(
+    expect(JSON.stringify([...log.messages, ...coreLog.messages])).not.toContain(
       'hidden-wallet-secret'
     );
   });
 
-  it('logs DeviceStatus response fields without exposing the device ID', async () => {
+  it('preserves the Protocol V2 peer-removed pairing error code', async () => {
     const commands = createCommands();
-    const log = getLogger(LoggerNames.Core);
+    const transportError = Object.assign(new Error('Peer removed pairing information'), {
+      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(commands._commonCall('DeviceInfoGet', {})).rejects.toBe(transportError);
+  });
+
+  it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
     log.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
@@ -82,22 +159,27 @@ describe('DeviceCommands failure mapping', () => {
       }),
     } as any;
 
-    await expect(commands.call('DeviceStatusGet', {})).resolves.toMatchObject({
+    await expect(commands._commonCall('DeviceStatusGet', {})).resolves.toMatchObject({
       type: 'DeviceStatus',
     });
 
     const receivedLog = log.messages.at(-1)?.message;
     expect(receivedLog).toEqual([
-      '[DeviceCommands] [call] Received',
-      'DeviceStatus',
+      '_filterCommonTypes: ',
       {
-        device_id: '[REDACTED]',
-        unlocked: true,
-        init_states: true,
-        backup_required: false,
-        passphrase_enabled: true,
-        attach_to_pin_enabled: false,
-        unlocked_by_attach_to_pin: false,
+        request: 'DeviceStatusGet',
+        response: {
+          type: 'DeviceStatus',
+          message: {
+            device_id: '[REDACTED]',
+            unlocked: true,
+            init_states: true,
+            backup_required: false,
+            passphrase_enabled: true,
+            attach_to_pin_enabled: false,
+            unlocked_by_attach_to_pin: false,
+          },
+        },
       },
     ]);
     expect(JSON.stringify(receivedLog)).not.toContain('sensitive-device-id');
@@ -125,6 +207,59 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
+  it('logs the sanitized DeviceInfo response payload', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    log.messages.length = 0;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'DeviceInfo',
+          message: {
+            protocol_version: 2,
+            hw: {
+              Device_type: 7,
+              hardware_version: '1.0.0',
+            },
+            main_mcu: {
+              application: {
+                version: '5.0.0',
+                build_id: '20260811',
+                hash: 'firmware-hash',
+              },
+            },
+          },
+        } as any,
+        'DeviceInfoGet'
+      )
+    ).resolves.toMatchObject({ type: 'DeviceInfo' });
+
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
+      {
+        request: 'DeviceInfoGet',
+        response: {
+          type: 'DeviceInfo',
+          message: {
+            protocol_version: 2,
+            hw: {
+              Device_type: 7,
+              hardware_version: '1.0.0',
+            },
+            main_mcu: {
+              application: {
+                version: '5.0.0',
+                build_id: '20260811',
+                hash: 'firmware-hash',
+              },
+            },
+          },
+        },
+      },
+    ]);
+  });
+
   it('logs the sanitized DeviceFirmwareUpdateStatus response payload', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
@@ -170,6 +305,32 @@ describe('DeviceCommands failure mapping', () => {
     ]);
   });
 
+  it.each(['Failure_ProcessError', 5])(
+    'maps USB-priority link disabled to public BLE error 723 for code %s',
+    async code => {
+      const commands = createCommands();
+
+      await expect(
+        commands._filterCommonTypes(
+          {
+            type: 'Failure',
+            message: {
+              code,
+              message: ' link disabled ',
+            },
+          } as any,
+          'DeviceInfo'
+        )
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleUnavailableWhileUsbConnected,
+        params: {
+          failureCode: code,
+          firmwareMessage: ' link disabled ',
+        },
+      });
+    }
+  );
+
   it('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
     const commands = createCommands();
 
@@ -337,7 +498,7 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
-  it.each(['Cancelled on device', 'Confirm dismissed'])(
+  it.each(['Cancelled on device', 'Confirm dismissed', 'Update cancelled'])(
     'maps legacy Protocol V2 cancellation message "%s" without a subcode',
     async message => {
       const commands = createCommands();
@@ -561,17 +722,22 @@ describe('DeviceCommands failure mapping', () => {
 });
 
 describe('DeviceCommands Protocol V2 interactive response compatibility', () => {
-  it('still auto-acks ButtonRequest when no hardware UI listener is registered', async () => {
+  it('auto-acks Pro2 ButtonRequest and registers Cancel instead of Initialize', async () => {
     const commands = createCommands();
     const emit = jest.fn();
+    const cancelDevice = jest.spyOn(commands, 'cancelDevice').mockResolvedValue(undefined);
+    const cancelDeviceOnOneKeyDevice = jest
+      .spyOn(commands, 'cancelDeviceOnOneKeyDevice')
+      .mockResolvedValue(undefined);
     const commonCall = jest.fn().mockResolvedValue({
       type: 'Success',
       message: {},
     });
+    const setCancelableAction = jest.fn();
     commands.device = {
       ...commands.device,
       getCurrentDeviceType: jest.fn(() => 'pro2'),
-      setCancelableAction: jest.fn(),
+      setCancelableAction,
       emit,
       listenerCount: jest.fn(() => 0),
     } as any;
@@ -593,6 +759,9 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
       expect.objectContaining({ code: 'ButtonRequest_PinEntry' })
     );
     expect(commonCall).toHaveBeenCalledWith('ButtonAck', {}, undefined);
+    await setCancelableAction.mock.calls[0][0]();
+    expect(cancelDevice).toHaveBeenCalledTimes(1);
+    expect(cancelDeviceOnOneKeyDevice).not.toHaveBeenCalled();
   });
 
   it('rejects PassphraseRequest when the Pro2 UI listener is not registered', async () => {
@@ -644,7 +813,13 @@ describe('DeviceCommands cancellation', () => {
     try {
       const commands = createCommands();
       commands.disposed = false;
+      commands.mainId = 'main-id';
       commands.callPromise = new Promise(() => {});
+      const disconnect = jest.fn().mockResolvedValue(undefined);
+      commands.transport = {
+        name: 'ReactNativeBleTransport',
+        disconnect,
+      } as any;
       const dispose = jest.fn().mockResolvedValue(undefined);
       commands.dispose = dispose;
 
@@ -654,6 +829,7 @@ describe('DeviceCommands cancellation', () => {
 
       await expect(cancellation).resolves.toBeUndefined();
       expect(dispose).toHaveBeenCalledWith(true);
+      expect(disconnect).toHaveBeenCalledWith('main-id');
       expect(commands.callPromise).toBeUndefined();
     } finally {
       jest.useRealTimers();

package/__tests__/base64Data.test.ts

@@ -0,0 +1,69 @@
+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__/check-all-firmware-release-protocol-v2.test.ts

@@ -33,8 +33,6 @@ const validComponentIntegrity = {
 const release: IFirmwareReleaseInfo = {
   required: true,
   version: [2, 0, 0],
-  url: 'https://example.com/application-p1.bin',
-  fingerprint: 'release-fingerprint',
   changelog: {
     'zh-CN': '更新',
     'en-US': 'Update',
@@ -328,15 +326,16 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: 'required',
       resourceStatus: 'unknown',
       resourceArchive: resourceSource,
-      targetsToUpdate: ['boot', 'app_v1'],
+      targetsToUpdate: ['boot', 'app_v1', 'resource'],
       firmwareUpdatePlan: {
         executor: 'v4',
         platform: 'web',
         artifacts: [
           { artifactId: 'component:boot', target: 'boot' },
           { artifactId: 'component:app_v1', target: 'app_v1' },
+          { artifactId: 'resource:archive', target: 'resource' },
         ],
-        targetsToUpdate: ['boot', 'app_v1'],
+        targetsToUpdate: ['boot', 'app_v1', 'resource'],
       },
       firmware: {
         status: 'required',
@@ -377,7 +376,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
+      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
       firmwareUpdatePlan: {
         executor: 'v4',
         deviceIdentity: 'pro2-device-id',
@@ -387,8 +386,9 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
           { artifactId: 'component:app_v1', target: 'app_v1' },
           { artifactId: 'component:se02', target: 'se02' },
           { artifactId: 'component:se03', target: 'se03' },
+          { artifactId: 'resource:archive', target: 'resource' },
         ],
-        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
+        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
       },
     });
   });
@@ -582,12 +582,12 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['se01', 'se02'],
+      targetsToUpdate: ['se01', 'se02', 'resource'],
       firmwareUpdatePlan: {
         executor: 'v4',
         deviceModel: 'neo',
         platform: 'native',
-        targetsToUpdate: ['se01', 'se02'],
+        targetsToUpdate: ['se01', 'se02', 'resource'],
       },
     });
   });
@@ -618,18 +618,10 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
   });
 
-  test('adds a Protocol V2 resource target only when explicitly forced', async () => {
-    const currentRelease: IFirmwareReleaseInfo = {
+  test('selects the Protocol V2 resource archive using the DeviceState identity', async () => {
+    const releaseWithResources: IFirmwareReleaseInfo = {
       ...release,
-      required: false,
-      installOrder: ['applicationP1'],
-      components: {
-        applicationP1: {
-          target: 'APPLICATION_P1',
-          url: 'https://example.com/application-p1.okpkg',
-          version: [1, 0, 0],
-        },
-      },
+      resources: { source: resourceSource },
     };
     const method = new CheckAllFirmwareRelease({
       id: 1,
@@ -643,39 +635,98 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     method.device = {
       isProtocolV2: () => true,
       features: {
-        deviceType: 'pro2',
-        serialNo: 'pro2-device-id',
         firmwareVersion: '1.0.0',
+        serialNo: 'device-without-model-prefix',
       },
       getDeviceState: jest.fn().mockResolvedValue({
         identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
         status: { mode: 'normal' },
-        versions: { ...currentVersions, applicationP1: '1.0.0' },
+        versions: currentVersions,
       }),
     } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+    const getLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockImplementation(features =>
+        features.deviceType === 'pro2' ? releaseWithResources : undefined
+      );
 
     await expect(method.run()).resolves.toMatchObject({
-      status: 'valid',
-      hasUpgrade: true,
-      targetsToUpdate: ['resource'],
+      deviceType: 'pro2',
+      resourceArchive: resourceSource,
+      targetsToUpdate: expect.arrayContaining(['resource']),
       firmwareUpdatePlan: {
         executor: 'v4',
-        platform: 'desktop',
-        artifacts: [
-          {
-            artifactId: 'resource:archive',
-            target: 'resource',
-            role: 'resourceBundle',
-            container: 'zip',
-          },
-        ],
-        targetsToUpdate: ['resource'],
+        deviceModel: 'pro2',
+        targetsToUpdate: expect.arrayContaining(['resource']),
       },
     });
+    expect(getLatestReleaseSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ deviceType: 'pro2' }),
+      EFirmwareType.Universal
+    );
   });
 
+  test.each(['resource', 'boot_resources'] as const)(
+    'allows an explicitly forced Protocol V2 resource-only target through %s',
+    async forceTarget => {
+      const currentRelease: IFirmwareReleaseInfo = {
+        ...release,
+        required: false,
+        installOrder: ['applicationP1'],
+        components: {
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://example.com/application-p1.okpkg',
+            version: [1, 0, 0],
+          },
+        },
+      };
+      const method = new CheckAllFirmwareRelease({
+        id: 1,
+        payload: {
+          method: 'checkAllFirmwareRelease',
+          platform: 'desktop',
+          protocolV2ForceUpdateTargets: [forceTarget],
+        },
+      });
+      method.init();
+      method.device = {
+        isProtocolV2: () => true,
+        features: {
+          deviceType: 'pro2',
+          serialNo: 'pro2-device-id',
+          firmwareVersion: '1.0.0',
+        },
+        getDeviceState: jest.fn().mockResolvedValue({
+          identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+          status: { mode: 'normal' },
+          versions: { ...currentVersions, applicationP1: '1.0.0' },
+        }),
+      } as unknown as CheckAllFirmwareRelease['device'];
+      jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
+      jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+
+      await expect(method.run()).resolves.toMatchObject({
+        status: 'valid',
+        hasUpgrade: true,
+        targetsToUpdate: ['resource'],
+        firmwareUpdatePlan: {
+          executor: 'v4',
+          platform: 'desktop',
+          artifacts: [
+            {
+              artifactId: 'resource:archive',
+              target: 'resource',
+              role: 'resourceBundle',
+              container: 'zip',
+            },
+          ],
+          targetsToUpdate: ['resource'],
+        },
+      });
+    }
+  );
+
   test('requests and compares firmware hashes only when explicitly enabled', async () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
@@ -752,7 +803,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         protocol: 'V2',
         resourceStatus: 'unknown',
         resourceArchive: resourceSource,
-        targetsToUpdate: ['boot', 'app_v1'],
+        targetsToUpdate: ['boot', 'app_v1', 'resource'],
       });
       expect(typedCall).not.toHaveBeenCalled();
     }