@onekeyfe/hd-core 1.2.0-alpha.24 → 1.2.0-alpha.26

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -25,6 +25,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       connectId: 'connect-id',
       deviceId: 'device-id',
       getVersionRange: jest.fn().mockReturnValue({}),
+      assertProtocolSupported: jest.fn(),
       init: jest.fn(),
       name: 'xrpGetAddress',
       responseID: 42,
@@ -45,6 +46,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
     method.device = {
       instanceId: deviceInstanceId,
       getCurrentFirmwareType: jest.fn(),
+      getProtocol: jest.fn().mockReturnValue('V1'),
       getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
       getCurrentMethodVersionRange: jest
         .fn()

package/__tests__/chain-params-onekey-compatibility.test.ts

@@ -0,0 +1,229 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import BenfenGetAddress from '../src/api/benfen/BenfenGetAddress';
+import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+import EVMSignTransaction from '../src/api/evm/EVMSignTransaction';
+import EVMSignMessageEIP712 from '../src/api/evm/EVMSignMessageEIP712';
+import KaspaSignTransaction from '../src/api/kaspa/KaspaSignTransaction';
+import XrpSignTransaction from '../src/api/xrp/XrpSignTransaction';
+
+import type { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  getProtocolV1MessageSchema: jest.fn(() => 'v1CurrentSchema'),
+}));
+
+jest.mock('../src/device/Device', () => ({
+  Device: jest.fn(),
+}));
+
+const KASPA_PATH = "m/44'/111111'/0'/0/0";
+const KASPA_SCRIPT = `20${'ab'.repeat(32)}ac`;
+const KASPA_ADDRESS = 'kaspa:qr0lr4ml9fn3chekrqmjdkergxl93l4wrk3dankcgvjq776s9wn9jkdskewva';
+
+const buildKaspaPayload = () => ({
+  method: 'kaspaSignTransaction',
+  version: 0,
+  lockTime: 0,
+  inputs: [
+    {
+      path: KASPA_PATH,
+      prevTxId: 'aa'.repeat(32),
+      outputIndex: 0,
+      sequenceNumber: 0,
+      output: { satoshis: 200000, script: KASPA_SCRIPT },
+    },
+  ],
+  outputs: [{ satoshis: 100000, script: KASPA_SCRIPT, scriptVersion: 0 }],
+});
+
+describe('onekey public-chain parameter compatibility', () => {
+  it('keeps the historical EVM contract-deployment representation', () => {
+    const transaction = {
+      to: '',
+      value: '0x0',
+      gasPrice: '0x1',
+      gasLimit: '0x5208',
+      nonce: '0x0',
+      chainId: 1,
+      data: '0x6000',
+    };
+
+    const method = new EVMSignTransaction({
+      id: 1,
+      payload: {
+        method: 'evmSignTransaction',
+        path: "m/44'/60'/0'/0/0",
+        transaction,
+      },
+    });
+
+    expect(() => method.init()).not.toThrow();
+
+    const { to: _to, ...transactionWithoutTo } = transaction;
+    const missingTo = new EVMSignTransaction({
+      id: 2,
+      payload: {
+        method: 'evmSignTransaction',
+        path: "m/44'/60'/0'/0/0",
+        transaction: transactionWithoutTo,
+      },
+    });
+
+    expect(() => missingTo.init()).toThrow('Missing required parameter: to');
+  });
+
+  it('keeps Conflux to validation aligned with onekey', () => {
+    const method = new ConfluxSignTransaction({
+      id: 1,
+      payload: {
+        method: 'confluxSignTransaction',
+        path: "m/44'/503'/0'/0/0",
+        transaction: {
+          to: 'cfx:aak2rra2njvd77ezwjvx04kkds9fzagfe6d5r8e957',
+          value: '0x0',
+          gasLimit: '0x5208',
+          gasPrice: '0x1',
+          nonce: '0x0',
+          epochHeight: '0x1',
+          storageLimit: '0x0',
+          chainId: 1029,
+        },
+      },
+    });
+
+    expect(() => method.init()).toThrow('should be [hexString]');
+  });
+
+  it('keeps XRP payment amount as the historical number input', () => {
+    const createMethod = (amount: number | string) =>
+      new XrpSignTransaction({
+        id: 1,
+        payload: {
+          method: 'xrpSignTransaction',
+          path: "m/44'/144'/0'/0/0",
+          transaction: {
+            payment: {
+              amount,
+              destination: 'rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn',
+            },
+          },
+        },
+      });
+
+    expect(() => createMethod(1).init()).not.toThrow();
+    expect(() => createMethod('1').init()).toThrow('should be [number]');
+  });
+
+  it('keeps the Kaspa legacy schema while allowing the additive streaming shape', () => {
+    const legacyWithoutSigHash = new KaspaSignTransaction({
+      id: 1,
+      payload: buildKaspaPayload(),
+    });
+    expect(() => legacyWithoutSigHash.init()).toThrow('Missing required parameter: sigHashType');
+
+    const legacyWithoutScript = new KaspaSignTransaction({
+      id: 2,
+      payload: {
+        ...buildKaspaPayload(),
+        sigHashType: 0x41,
+        outputs: [{ satoshis: 100000, scriptVersion: 0 }],
+      },
+    });
+    expect(() => legacyWithoutScript.init()).toThrow('Missing required parameter: script');
+
+    const streaming = new KaspaSignTransaction({
+      id: 3,
+      payload: {
+        ...buildKaspaPayload(),
+        inputs: [
+          {
+            ...buildKaspaPayload().inputs[0],
+            output: { satoshis: 200000 },
+          },
+        ],
+        outputs: [{ satoshis: 100000, address: KASPA_ADDRESS }],
+      },
+    });
+    expect(() => streaming.init()).not.toThrow();
+  });
+
+  it('keeps validating the Kaspa legacy input amount', () => {
+    const payload = buildKaspaPayload();
+    const method = new KaspaSignTransaction({
+      id: 1,
+      payload: {
+        ...payload,
+        sigHashType: 0x41,
+        inputs: [
+          {
+            ...payload.inputs[0],
+            output: { script: KASPA_SCRIPT },
+          },
+        ],
+      },
+    });
+
+    expect(() => method.init()).toThrow('Missing required parameter: satoshis');
+  });
+
+  it('keeps the deprecated EIP-712 method callable on existing Protocol V1 devices', async () => {
+    const method = new EVMSignMessageEIP712({
+      id: 1,
+      payload: {
+        method: 'evmSignMessageEIP712',
+        path: "m/44'/60'/0'/0/0",
+        domainHash: `0x${'11'.repeat(32)}`,
+        messageHash: `0x${'22'.repeat(32)}`,
+      },
+    });
+    method.init();
+
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        address: '0x1234',
+        signature: 'abcd',
+      },
+    });
+    method.device = {
+      commands: { typedCall },
+      getCurrentFirmwareVersionString: jest.fn(() => '4.10.0'),
+      getCurrentMethodVersionRange: jest.fn(() => undefined),
+      getCurrentFirmwareType: jest.fn(() => EFirmwareType.Universal),
+      getProtocol: jest.fn(() => 'V1'),
+    } as unknown as Device;
+
+    await expect(method.run()).resolves.toEqual({
+      address: '0x1234',
+      signature: 'abcd',
+    });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects a Benfen response that omits the address', async () => {
+    const method = new BenfenGetAddress({
+      id: 1,
+      payload: {
+        method: 'benfenGetAddress',
+        path: "m/44'/728'/0'/0'/0'",
+        showOnOneKey: false,
+      },
+    });
+    method.init();
+    method.device = {
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: {} }),
+      },
+      getCurrentFirmwareVersionString: jest.fn(() => '1.0.0'),
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Classic),
+      isProtocolV2: jest.fn(() => false),
+    } as unknown as Device;
+
+    await expect(method.run()).rejects.toThrow(/address/i);
+  });
+});

package/__tests__/connectSettings.test.ts

@@ -1,19 +1,61 @@
+import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
+import type { RemoteConfigResponse } from '../src/types';
+
+jest.mock('axios', () => ({
+  get: jest.fn(),
+}));
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
+
 describe('parseConnectSettings', () => {
-  it('keeps custom configFetcher in parsed settings', () => {
-    const configFetcher = jest.fn();
+  const preloadedConfig = {
+    bridge: {},
+    classic: { firmware: [], ble: [] },
+    classic1s: { firmware: [], ble: [] },
+    classicpure: { firmware: [], ble: [] },
+    mini: { firmware: [], ble: [] },
+    touch: { firmware: [], ble: [] },
+    pro: { firmware: [], ble: [] },
+    pro2: { firmware: [], ble: [] },
+  } as unknown as RemoteConfigResponse;
+
+  it('keeps a serializable preloaded config in parsed settings', () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    expect(settings.firmwareManifestMode).toBe('sdk-managed');
+    expect(settings.preloadedConfig).toBe(preloadedConfig);
+  });
+
+  it('uses the preloaded config before the SDK network client', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    await DataManager.load(settings);
+
+    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
+  });
 
+  it('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      fetchConfig: true,
-      configFetcher,
+      firmwareManifestMode: 'external-only',
     });
 
-    expect(settings.configFetcher).toBe(configFetcher);
+    await expect(DataManager.load(settings)).rejects.toThrow(
+      'External firmware config snapshot is required'
+    );
+    expect(mockAxiosGet).not.toHaveBeenCalled();
   });
 });

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

@@ -1,3 +1,6 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import { Device } from '../src/device/Device';
 import { DEVICE } from '../src/events';
 import { EOneKeyDeviceMode } from '../src/types';
@@ -8,6 +11,127 @@ jest.mock('../src/data/config', () => ({
 }));
 
 describe('Device state events', () => {
+  test.each([
+    ['V1', EFirmwareType.BitcoinOnly],
+    ['V2', EFirmwareType.Universal],
+  ] as const)(
+    'reads the current %s firmware type from canonical state',
+    (protocol, firmwareType) => {
+      const device = Device.fromDescriptor({
+        id: `device-${protocol}`,
+        path: `device-${protocol}`,
+        protocolType: protocol,
+      } as never);
+      device.updateState({ protocol, identity: { firmwareType } }, 'initialize');
+      const featuresGetter = jest.spyOn(device, 'features', 'get').mockImplementation(() => {
+        throw new Error('Legacy Features projection should not be read');
+      });
+
+      expect(device.getCurrentFirmwareType()).toBe(firmwareType);
+      featuresGetter.mockRestore();
+    }
+  );
+
+  test('keeps the universal firmware fallback before device state is initialized', () => {
+    const device = Device.fromDescriptor({ id: 'pending', path: 'pending' } as never);
+
+    expect(device.getCurrentFirmwareType()).toBe(EFirmwareType.Universal);
+    expect(device.getCurrentDeviceType()).toBe(EDeviceType.Unknown);
+    expect(device.getCurrentDeviceId()).toBeUndefined();
+    expect(device.getCurrentSerialNo()).toBe('');
+    expect(device.getCurrentBleName()).toBeNull();
+    expect(device.getCurrentLabel()).toBeNull();
+    expect(device.getCurrentFirmwareVersionString()).toBe('0.0.0');
+    expect(device.getCurrentBLEFirmwareVersionString()).toBeUndefined();
+    expect(device.getCurrentBootloaderVersionString()).toBeUndefined();
+    expect(device.getFirmwareVersion()).toBeNull();
+    expect(device.getBLEFirmwareVersion()).toBeNull();
+    expect(device.isUnacquired()).toBe(true);
+  });
+
+  test('reads current device data from canonical state without projecting Features', () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-state',
+      path: 'pro2-state',
+      protocolType: 'V2',
+    } as never);
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: {
+          deviceType: EDeviceType.Pro2,
+          deviceId: 'wallet-id',
+          serialNo: 'SERIAL-PRO2',
+          label: null,
+          bleName: 'Pro2 1234',
+        },
+        status: {
+          mode: 'normal',
+          initialized: true,
+          unlocked: false,
+          noBackup: false,
+          passphraseProtection: false,
+        },
+        settings: { safetyChecks: Enum_SafetyCheckLevel.Strict },
+        versions: {
+          firmware: '5.1.2',
+          bootloader: '2.0.0',
+          ble: null,
+        },
+      },
+      'initialize'
+    );
+    const featuresGetter = jest.spyOn(device, 'features', 'get').mockImplementation(() => {
+      throw new Error('Legacy Features projection should not be read');
+    });
+
+    expect(device.getCurrentDeviceType()).toBe(EDeviceType.Pro2);
+    expect(device.getCurrentDeviceId()).toBe('wallet-id');
+    expect(device.getCurrentSerialNo()).toBe('SERIAL-PRO2');
+    expect(device.getCurrentBleName()).toBe('Pro2 1234');
+    expect(device.getCurrentLabel()).toBeNull();
+    expect((device as any).getCurrentDisplayName()).toBe('Pro2 1234');
+    expect(device.getCurrentPassphraseProtection()).toBe(false);
+    expect(device.getCurrentFirmwareVersionString()).toBe('5.1.2');
+    expect(device.getCurrentBLEFirmwareVersionString()).toBe('0.0.0');
+    expect(device.getCurrentBootloaderVersionString()).toBe('2.0.0');
+    expect(device.getCurrentSafetyChecks()).toBe(Enum_SafetyCheckLevel.Strict);
+    expect(device.getFirmwareVersion()).toEqual([5, 1, 2]);
+    expect(device.getBLEFirmwareVersion()).toEqual([0, 0, 0]);
+    expect(device.isBootloader()).toBe(false);
+    expect(device.isInitialized()).toBe(true);
+    expect(device.isSeedless()).toBe(false);
+    expect(device.isUnacquired()).toBe(false);
+    expect(device.hasUsePassphrase()).toBe(true);
+    expect(device.supportInputPinOnSoftware()).toEqual({ support: false });
+    expect(device.supportModifyHomescreen()).toEqual({ support: true });
+    featuresGetter.mockRestore();
+  });
+
+  test('keeps legacy display-name fallbacks separate from the canonical label', () => {
+    const device = Device.fromDescriptor({ id: 'pure', path: 'pure' } as never);
+    device.updateState(
+      {
+        protocol: 'V1',
+        identity: {
+          deviceType: EDeviceType.ClassicPure,
+          label: null,
+          bleName: null,
+        },
+        status: { mode: 'normal', initialized: true },
+      },
+      'initialize'
+    );
+
+    expect(device.getCurrentLabel()).toBeNull();
+    expect(device.getCurrentDisplayName()).toBe('OneKey Classic 1S');
+    expect(device.toMessageObject()).toMatchObject({
+      name: 'OneKey Classic 1S',
+      label: 'OneKey Classic 1S',
+      state: { identity: { label: null } },
+    });
+  });
+
   test('emits only the canonical state event for Protocol V2', () => {
     const device = Device.fromDescriptor({
       id: 'pro2',

package/__tests__/evmLedgerLegacySafety.test.ts

@@ -1,10 +1,11 @@
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
 import EvmGetAddress from '../src/api/evm/EVMGetAddress';
 import EVMGetPublicKey from '../src/api/evm/EVMGetPublicKey';
 import { findMethod } from '../src/api/utils';
 import { getDeviceType, getFirmwareType, getMethodVersionRange } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
-import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 
 import type { EDeviceType } from '@onekeyfe/hd-shared';
 
@@ -33,6 +34,7 @@ const createDevice = (onekeyDeviceType: string) => {
       },
       // BaseMethod reads state through Device accessors; reuse production mappers in the stub.
       isProtocolV2: () => false,
+      getProtocol: () => 'V1' as const,
       getCurrentDeviceType: () => getDeviceType(features as any),
       getCurrentSafetyChecks: () => features.safety_checks,
       getCurrentFirmwareType: () => getFirmwareType(features as any),

package/__tests__/firmware-update/check-all-firmware-release.test.ts

@@ -0,0 +1,127 @@
+import { ERRORS, EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import CheckAllFirmwareRelease from '../../src/api/CheckAllFirmwareRelease';
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  getBleFirmwareReleaseInfo,
+  getBootloaderReleaseInfo,
+  getFirmwareReleaseInfo,
+} from '../../src/api/firmware/releaseHelper';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../../src/api/firmware/FirmwareUpdatePlan', () => ({
+  buildFirmwareUpdatePlan: jest.fn(),
+}));
+
+jest.mock('../../src/api/firmware/releaseHelper', () => ({
+  getBleFirmwareReleaseInfo: jest.fn(),
+  getBootloaderReleaseInfo: jest.fn(),
+  getFirmwareReleaseInfo: jest.fn(),
+}));
+
+const mockBuildFirmwareUpdatePlan = buildFirmwareUpdatePlan as jest.MockedFunction<
+  typeof buildFirmwareUpdatePlan
+>;
+const mockGetBleFirmwareReleaseInfo = getBleFirmwareReleaseInfo as jest.MockedFunction<
+  typeof getBleFirmwareReleaseInfo
+>;
+const mockGetBootloaderReleaseInfo = getBootloaderReleaseInfo as jest.MockedFunction<
+  typeof getBootloaderReleaseInfo
+>;
+const mockGetFirmwareReleaseInfo = getFirmwareReleaseInfo as jest.MockedFunction<
+  typeof getFirmwareReleaseInfo
+>;
+
+const noUpdate = {
+  status: 'valid' as const,
+  release: undefined,
+};
+
+const createMethod = (serialNo = 'device-id') => {
+  const method = new CheckAllFirmwareRelease({
+    id: 1,
+    payload: {
+      method: 'checkAllFirmwareRelease',
+      platform: 'native',
+    },
+  });
+  method.init();
+  method.device = {
+    features: {
+      deviceType: EDeviceType.Classic1s,
+      serialNo,
+      firmwareType: EFirmwareType.Universal,
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+    },
+  } as typeof method.device;
+  return method;
+};
+
+describe('CheckAllFirmwareRelease', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetFirmwareReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBootloaderReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBleFirmwareReleaseInfo.mockReturnValue(noUpdate);
+  });
+
+  test('keeps release information available when an optional Plan cannot be built', async () => {
+    const firmware = {
+      status: 'outdated' as const,
+      release: {
+        url: 'https://firmware.onekey.so/classic/firmware.bin',
+        version: [3, 0, 0],
+      },
+    };
+    mockGetFirmwareReleaseInfo.mockReturnValue(firmware);
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Plan cannot be built', {
+        firmwareUpdateCode: 'FirmwarePlanInvalid',
+      });
+    });
+
+    await expect(createMethod('').run()).resolves.toEqual(
+      expect.objectContaining({
+        firmware,
+        bootloader: noUpdate,
+        ble: noUpdate,
+        firmwareUpdatePlan: undefined,
+      })
+    );
+  });
+
+  test('returns an optional Plan when the builder succeeds', async () => {
+    const plan = {
+      schemaVersion: 2 as const,
+      planDigest: 'a'.repeat(64),
+      executor: 'v3' as const,
+      deviceIdentity: 'device-id',
+      deviceModel: EDeviceType.Classic1s,
+      firmwareType: EFirmwareType.Universal,
+      platform: 'native' as const,
+      artifacts: [],
+      targetsToUpdate: [],
+    };
+    mockBuildFirmwareUpdatePlan.mockReturnValue(plan);
+
+    await expect(createMethod().run()).resolves.toEqual(
+      expect.objectContaining({
+        firmwareUpdatePlan: plan,
+      })
+    );
+  });
+
+  test('does not hide unexpected Plan builder failures', async () => {
+    const unexpectedError = new Error('unexpected builder failure');
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw unexpectedError;
+    });
+
+    await expect(createMethod().run()).rejects.toBe(unexpectedError);
+  });
+});