@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.58

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -91,11 +91,93 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      'hidden-state',
+      false,
+      undefined,
+      false
+    );
     expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });
 
+  test('resumes a Protocol V2 Cardano hidden wallet with the Cardano seed domain', async () => {
+    const calls: string[] = [];
+    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
+      calls.push('resume-cardano-session');
+      return Promise.resolve(true);
+    });
+    const innerMethod = {
+      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      getVersionRange: jest.fn().mockReturnValue({}),
+      assertProtocolSupported: jest.fn(),
+      init: jest.fn(),
+      name: 'cardanoGetAddress',
+      responseID: 45,
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockImplementation(() => {
+        calls.push('run-cardano-method');
+        return Promise.resolve([{ address: 'addr1hidden' }]);
+      }),
+      setDevice: jest.fn(),
+      strictCheckDeviceSupport: false,
+    };
+    (findMethod as jest.Mock).mockReturnValue(innerMethod);
+    const method = new TestAllNetworkMethod({
+      id: 5,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        passphraseState: 'hidden-state',
+        bundle: [],
+      },
+    });
+    method.protocolV2UnlockContext = { preflightCompleted: true };
+    const typedCall = jest.fn();
+    method.device = {
+      checkPassphraseStateSafety,
+      commands: {
+        typedCall,
+      },
+      getCurrentFirmwareType: jest.fn(),
+      getProtocol: jest.fn().mockReturnValue('V2'),
+      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
+      getCurrentMethodVersionRange: jest
+        .fn()
+        .mockImplementation((getRange: (type: string) => unknown) => getRange('pro2')),
+      instanceId: 'device-instance',
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isBootloader: jest.fn().mockReturnValue(false),
+      isRomloader: jest.fn().mockReturnValue(false),
+      off: jest.fn(),
+      on: jest.fn(),
+      state: { status: { unlocked: true } },
+      updateProtocolV2Status: jest.fn(),
+    } as any;
+
+    await method.callMethod(
+      'cardanoGetAddress',
+      {
+        bundle: [
+          {
+            _originRequestParams: {
+              network: 'ada',
+              path: "m/1852'/1815'/0'/0/0",
+            },
+          },
+        ],
+      },
+      0
+    );
+
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined, true);
+    expect(calls).toEqual(['resume-cardano-session', 'run-cardano-method']);
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
   test('resumes a Protocol V2 standard wallet before running a nested chain method', async () => {
     const calls: string[] = [];
     const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
@@ -168,7 +250,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined, false);
     expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });

package/__tests__/DeviceCommands.test.ts

@@ -363,9 +363,14 @@ describe('DeviceCommands failure mapping', () => {
     }
   );
 
-  it.each(['Cancelled', 'User cancelled typed data signing'])(
-    'maps the Protocol V2 MP engine cancellation response "%s" to ActionCancelled',
-    async message => {
+  it.each([
+    ['SignTx', 'Rejected by the user'],
+    ['EthereumSignTypedDataOneKey', ''],
+    ['SolanaSignTx', 'Localized cancellation message'],
+    ['GetAddress', 'Address confirmation rejected'],
+  ] as const)(
+    'maps Protocol V2 cancellation subcode 1 for %s regardless of message',
+    async (callType, message) => {
       const commands = createCommands();
 
       await expect(
@@ -378,7 +383,7 @@ describe('DeviceCommands failure mapping', () => {
               message,
             },
           } as any,
-          'SignTx'
+          callType
         )
       ).rejects.toMatchObject({
         errorCode: HardwareErrorCode.ActionCancelled,
@@ -401,6 +406,7 @@ describe('DeviceCommands failure mapping', () => {
           type: 'Failure',
           message: {
             code: 'Failure_ProcessError',
+            subcode: 1,
             message: 'Cancelled on device',
           },
         } as any,
@@ -411,7 +417,7 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
-  it('keeps an unrecognized Protocol V2 process subcode generic', async () => {
+  it('maps the DeviceError subcode 1 exception to DeviceBusy', async () => {
     const commands = createCommands();
 
     await expect(
@@ -427,7 +433,12 @@ describe('DeviceCommands failure mapping', () => {
         'DeviceSettingsPageShow'
       )
     ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
+      errorCode: HardwareErrorCode.DeviceBusy,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 1,
+        firmwareMessage: 'Another process error',
+      },
     });
   });
 

package/__tests__/core-initialization.test.ts

@@ -0,0 +1,23 @@
+import { DataManager } from '../src/data-manager';
+import { init } from '../src/core';
+
+import type { ConnectSettings } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+describe('Core initialization', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('does not create a partially initialized core when settings loading fails', async () => {
+    jest.spyOn(DataManager, 'load').mockRejectedValue(new Error('settings load failed'));
+
+    await expect(init({} as ConnectSettings, class TestTransport {})).rejects.toThrow(
+      'settings load failed'
+    );
+  });
+});

package/__tests__/device-connector-protocol.test.ts

@@ -0,0 +1,81 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import DeviceConnector from '../src/device/DeviceConnector';
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    load: jest.fn(),
+    getTransport: jest.fn(),
+  },
+}));
+
+jest.mock('../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(() => 'desktop-web-ble'),
+    isBleConnect: jest.fn(() => true),
+  },
+}));
+
+jest.mock('../src/device/DevicePool', () => ({
+  DevicePool: {
+    setConnector: jest.fn(),
+  },
+}));
+
+const transportManagerMock: {
+  default: {
+    getTransport: jest.Mock;
+  };
+} = jest.requireMock('../src/data-manager/TransportManager');
+
+describe('DeviceConnector protocol validation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('reports an explicit transport error when connector initialization ran too early', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue(undefined);
+    const connector = new DeviceConnector();
+
+    await expect(connector.enumerate()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.TransportNotConfigured,
+    });
+  });
+
+  it('uses the actively probed protocol returned by acquire when the cache was cleared', async () => {
+    const acquire = jest.fn().mockResolvedValue({
+      id: 'pro2-id',
+      path: 'pro2-id',
+      protocolType: 'V2',
+    });
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire,
+      getProtocolType: jest.fn(() => undefined),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('pro2-id', undefined, undefined, 'V2')).resolves.toEqual(
+      expect.objectContaining({ protocolType: 'V2' })
+    );
+    expect(acquire).toHaveBeenCalledWith(
+      expect.objectContaining({ uuid: 'pro2-id', expectedProtocol: 'V2' })
+    );
+  });
+
+  it('still rejects a real mismatch reported by the active protocol probe', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire: jest.fn().mockResolvedValue({
+        id: 'classic-id',
+        path: 'classic-id',
+        protocolType: 'V1',
+      }),
+      getProtocolType: jest.fn(() => 'V1'),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('classic-id', undefined, undefined, 'V2')).rejects.toThrow(
+      'Device protocol mismatch: expected V2, detected V1'
+    );
+  });
+});

package/__tests__/device-settings.test.ts

@@ -115,8 +115,8 @@ describe('DeviceSettings protocol routing', () => {
     );
   });
 
-  it('uses DeviceSettingsSet and commits the confirmed patch for Protocol V2', async () => {
-    const { device, typedCall, updateState } = createDevice({ protocol: 'V2' });
+  it('uses DeviceSettingsSet and reloads Protocol V2 status and settings from the device', async () => {
+    const { device, typedCall, updateState, getDeviceState } = createDevice({ protocol: 'V2' });
     const method = new DeviceSettings({
       id: 2,
       payload: {
@@ -141,21 +141,10 @@ describe('DeviceSettings protocol routing', () => {
         haptic_feedback: true,
       },
     });
-    expect(updateState).toHaveBeenCalledWith(
-      {
-        identity: { label: 'Shared Label' },
-        settings: {
-          language: 'ja',
-          bleEnabled: true,
-          autoLockDelayMs: 60_000,
-          hapticFeedback: true,
-        },
-      },
-      'settings-write'
-    );
-    expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
-      expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
-    );
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: ['status', 'settings'],
+    });
+    expect(updateState).not.toHaveBeenCalled();
   });
 
   it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
@@ -183,7 +172,39 @@ describe('DeviceSettings protocol routing', () => {
     });
     expect(typedCall).not.toHaveBeenCalledWith('DeviceSettingsSet', 'Success', expect.anything());
     expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['status'] });
-    expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['status'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['status', 'settings'],
+    });
+  });
+
+  it('reloads Protocol V2 status and settings after changing air-gap mode', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        settings: { airgapMode: false },
+      })
+      .mockResolvedValueOnce({
+        status: { unlocked: true },
+        settings: { airgapMode: true },
+      });
+    const method = new DeviceSettings({
+      id: 4,
+      payload: {
+        method: 'deviceSettings',
+        airgapMode: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DeviceAirgap,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['settings'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['status', 'settings'],
+    });
   });
 
   it('does not open a Pro2 settings page when the hardware already matches the target', async () => {

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

@@ -269,6 +269,30 @@ describe('Pro2 resource configuration', () => {
     expect(DataManager.getProtocolV2BootResources()).toEqual(bootResources);
   });
 
+  test('keeps base SDK initialization available when remote Pro2 resources are invalid', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
+    const configFetcher = jest.fn().mockResolvedValue(remoteConfig);
+
+    await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
+
+    expect(DataManager.getProtocolV2Resources()).toBeUndefined();
+    expect(DataManager.getProtocolV2BootResources()).toBeUndefined();
+  });
+
+  test('still blocks firmware mutation when the refreshed Pro2 resources are invalid', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
+    const settings = createSettings(jest.fn().mockResolvedValue(remoteConfig));
+    DataManager.settings = settings;
+
+    await expect(DataManager.forceReloadData()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.NetworkError,
+      message: expect.stringContaining('Invalid Pro2 resources config'),
+    });
+    expect(DataManager.lastCheckTimestamp).toBe(0);
+  });
+
   test('does not advance the cache timestamp when refresh fails', async () => {
     jest.spyOn(axios, 'get').mockRejectedValue(new Error('offline'));
     const settings = createSettings(jest.fn().mockResolvedValue(null));

package/__tests__/protocol-v2.test.ts

@@ -14,9 +14,6 @@ import DirList from '../src/api/DirList';
 import FileRead from '../src/api/FileRead';
 import FileWrite from '../src/api/FileWrite';
 import UploadPortfolio from '../src/api/UploadPortfolio';
-import DeviceFactoryCertificateRead from '../src/api/protocol-v2/DeviceFactoryCertificateRead';
-import DeviceFactoryCertificateWrite from '../src/api/protocol-v2/DeviceFactoryCertificateWrite';
-import DeviceFactoryChallengeSign from '../src/api/protocol-v2/DeviceFactoryChallengeSign';
 import DeviceFactoryInfoGet from '../src/api/protocol-v2/DeviceFactoryInfoGet';
 import DeviceFactoryInfoSet from '../src/api/protocol-v2/DeviceFactoryInfoSet';
 import DeviceFirmwareUpdate from '../src/api/protocol-v2/DeviceFirmwareUpdate';
@@ -4095,6 +4092,38 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
   });
 
+  test('announces bootloader success only after Protocol V2 bootloader mode is confirmed', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      features: { bootloader_mode: false, capabilities: [] },
+      isBootloader: () => false,
+      isRomloader: () => false,
+    });
+    (method as any).protocolV2Reboot = jest.fn().mockResolvedValue({
+      message: 'Device rebooted successfully',
+    });
+
+    const tipMessages: string[] = [];
+    method.postTipMessage = jest.fn((message: string) => {
+      tipMessages.push(message);
+    });
+    let successWasAnnouncedBeforeConfirmation = false;
+    (method as any).waitForProtocolV2BootloaderMode = jest.fn().mockImplementation(() => {
+      successWasAnnouncedBeforeConfirmation = tipMessages.includes('GoToBootloaderSuccess');
+      return Promise.resolve({ mode: 'bootloader' });
+    });
+
+    await (method as any).enterProtocolV2BootloaderMode();
+
+    expect(successWasAnnouncedBeforeConfirmation).toBe(false);
+    expect(tipMessages).toEqual(['AutoRebootToBootloader', 'GoToBootloaderSuccess']);
+  });
+
   test('keeps Protocol V2 bootloader active before firmware transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4120,6 +4149,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
     expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
+    expect(method.postTipMessage).toHaveBeenCalledWith('GoToBootloaderSuccess');
   });
 
   test('keeps Protocol V2 romloader active before firmware transfer', async () => {
@@ -5916,8 +5946,9 @@ describe('Protocol V2 firmware update targets', () => {
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
+      toMessageObject: () => ({ connectId: 'firmware-device' }),
     });
-    method.postProgressMessage = jest.fn();
+    method.postMessage = jest.fn();
 
     await (method as any).protocolV2CommonUpdateProcess({
       payload: new Uint8Array(4097).buffer,
@@ -5932,6 +5963,17 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.overwrite)).toEqual([true, false]);
     expect(writePayloads.every(payload => payload.append === false)).toBe(true);
     expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
+    expect(method.postMessage).toHaveBeenLastCalledWith({
+      event: 'UI_EVENT',
+      type: UI_REQUEST.FIRMWARE_PROGRESS,
+      payload: expect.objectContaining({
+        progress: 99,
+        progressType: 'transferData',
+        transferredBytes: 4097,
+        totalBytes: 4097,
+        elapsedMs: expect.any(Number),
+      }),
+    });
   });
 
   test('restarts the whole file from offset zero after an ambiguous chunk write failure', async () => {
@@ -7228,39 +7270,26 @@ describe('Protocol V2 current low-level methods', () => {
 
   test('sends DeviceFactoryInfoSet and DeviceFactoryInfoGet', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: {} });
-    const manufactureTime = {
-      year: 2026,
-      month: 8,
-      day: 1,
-      hour: 10,
-      minute: 20,
-      second: 30,
-    };
     const setMethod = new DeviceFactoryInfoSet({
       id: 1,
       payload: {
         method: 'deviceFactoryInfoSet',
-        version: 1,
         serial_number: 'PR2SERIAL',
         burn_in_completed: true,
-        factory_test_completed: true,
-        manufacture_time: manufactureTime,
       },
     });
     setMethod.init();
-    expect(setMethod.getSupportedProtocols()).toEqual(['V2']);
-    expect(setMethod.requireDeviceMode).toEqual([UI_REQUEST.BOOTLOADER]);
     (setMethod as any).device = stubDevice({ commands: { typedCall } });
 
     await setMethod.run();
 
     expect(typedCall).toHaveBeenCalledWith('DeviceFactoryInfoSet', 'Success', {
       info: {
-        version: 1,
+        version: undefined,
         serial_number: 'PR2SERIAL',
         burn_in_completed: true,
-        factory_test_completed: true,
-        manufacture_time: manufactureTime,
+        factory_test_completed: undefined,
+        manufacture_time: undefined,
       },
     });
 
@@ -7270,7 +7299,6 @@ describe('Protocol V2 current low-level methods', () => {
       payload: { method: 'deviceFactoryInfoGet' },
     });
     getMethod.init();
-    expect(getMethod.getSupportedProtocols()).toEqual(['V2']);
     (getMethod as any).device = stubDevice({ commands: { typedCall } });
 
     await getMethod.run();
@@ -7278,111 +7306,6 @@ describe('Protocol V2 current low-level methods', () => {
     expect(typedCall).toHaveBeenLastCalledWith('DeviceFactoryInfoGet', 'DeviceFactoryInfo', {});
   });
 
-  test('validates the write-once DeviceFactoryInfoSet payload before sending', () => {
-    expect(() =>
-      new DeviceFactoryInfoSet({
-        id: 1,
-        payload: {
-          method: 'deviceProvisionFactoryInfo',
-          serial_number: 'PR2SERIAL',
-        },
-      }).init()
-    ).toThrow('Parameter [manufacture_time] is required.');
-
-    expect(() =>
-      new DeviceFactoryInfoSet({
-        id: 1,
-        payload: {
-          method: 'deviceProvisionFactoryInfo',
-          version: 1,
-          serial_number: 'P'.repeat(25),
-          burn_in_completed: true,
-          factory_test_completed: true,
-          manufacture_time: {
-            year: 2026,
-            month: 8,
-            day: 1,
-            hour: 0,
-            minute: 0,
-            second: 0,
-          },
-        },
-      }).init()
-    ).toThrow('must not exceed 24 UTF-8 bytes');
-  });
-
-  test('writes, reads and signs with the Protocol V2 factory certificate API', async () => {
-    const typedCall = jest.fn().mockResolvedValue({ message: {} });
-    const write = new DeviceFactoryCertificateWrite({
-      id: 1,
-      payload: {
-        method: 'deviceWriteFactoryCertificate',
-        certificate: 'aabbcc',
-      },
-    });
-    write.init();
-    expect(write.getSupportedProtocols()).toEqual(['V2']);
-    expect(write.requireDeviceMode).toEqual([UI_REQUEST.BOOTLOADER]);
-    (write as any).device = stubDevice({ commands: { typedCall } });
-    await write.run();
-
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceCertificateWrite', 'Success', {
-      cert: {
-        cert_and_pubkey: 'aabbcc',
-        private_key: undefined,
-      },
-    });
-
-    const read = new DeviceFactoryCertificateRead({
-      id: 2,
-      payload: { method: 'deviceReadFactoryCertificate' },
-    });
-    read.init();
-    expect(read.getSupportedProtocols()).toEqual(['V2']);
-    (read as any).device = stubDevice({ commands: { typedCall } });
-    await read.run();
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceCertificateRead', 'DeviceCertificate', {});
-
-    const sign = new DeviceFactoryChallengeSign({
-      id: 3,
-      payload: {
-        method: 'deviceSignFactoryChallenge',
-        digest: '22'.repeat(32),
-      },
-    });
-    sign.init();
-    expect(sign.getSupportedProtocols()).toEqual(['V2']);
-    (sign as any).device = stubDevice({ commands: { typedCall } });
-    await sign.run();
-    expect(typedCall).toHaveBeenLastCalledWith(
-      'DeviceCertificateSign',
-      'DeviceCertificateSignature',
-      { data: '22'.repeat(32) }
-    );
-  });
-
-  test('rejects malformed Protocol V2 factory certificate fields', () => {
-    expect(() =>
-      new DeviceFactoryCertificateWrite({
-        id: 1,
-        payload: {
-          method: 'deviceWriteFactoryCertificate',
-          certificate: 'xyz',
-        },
-      }).init()
-    ).toThrow('even-length hexadecimal string');
-
-    expect(() =>
-      new DeviceFactoryChallengeSign({
-        id: 2,
-        payload: {
-          method: 'deviceSignFactoryChallenge',
-          digest: '11',
-        },
-      }).init()
-    ).toThrow('exactly 32 bytes');
-  });
-
   test('marks explicit Protocol V2 unlock as an on-device PIN interaction', () => {
     const method = new DeviceUnlock({
       id: 1,