@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.90

package/__tests__/evmSignTransaction.test.ts

@@ -1,4 +1,5 @@
 import EVMSignTransaction from '../src/api/evm/EVMSignTransaction';
+import TransportManager from '../src/data-manager/TransportManager';
 
 import type { EVMTransactionEIP7702 } from '../src/types';
 
@@ -17,13 +18,17 @@ jest.mock('../src/device/Device', () => ({
   Device: jest.fn(),
 }));
 
+const mockTransportManager = jest.mocked(TransportManager);
+
 describe('EVMSignTransaction EIP-7702', () => {
   let mockDevice: any;
   let mockTypedCall: jest.Mock;
 
   beforeEach(() => {
+    mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1CurrentSchema');
     mockTypedCall = jest.fn();
     mockDevice = {
+      isProtocolV2: jest.fn(() => false),
       commands: {
         typedCall: {
           bind: jest.fn(() => mockTypedCall),
@@ -32,6 +37,70 @@ describe('EVMSignTransaction EIP-7702', () => {
     };
   });
 
+  describe('Protocol-specific schema routing', () => {
+    const transaction: EVMTransactionEIP7702 = {
+      to: '0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9',
+      value: '0x0',
+      gasLimit: '0x5208',
+      nonce: '0x0',
+      chainId: 1,
+      maxFeePerGas: '0xbebc200',
+      maxPriorityFeePerGas: '0x9502f900',
+      authorizationList: [
+        {
+          chainId: 1,
+          address: '0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9',
+          nonce: '0x1',
+        },
+      ],
+    };
+
+    const createTransactionMethod = () => {
+      const method = new EVMSignTransaction({
+        id: 1,
+        payload: {
+          method: 'evmSignTransaction',
+          path: "m/44'/60'/0'/0/0",
+          transaction,
+        },
+      });
+      method.device = mockDevice;
+      method.init();
+      return method;
+    };
+
+    it('keeps Protocol V2 on current OneKey messages after a legacy V1 device', async () => {
+      mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1LegacySchema');
+      mockDevice.isProtocolV2.mockReturnValue(true);
+      mockTypedCall.mockResolvedValue({
+        message: {
+          signature_v: 27,
+          signature_r: '01',
+          signature_s: '02',
+          authorization_signatures: [],
+        },
+      });
+
+      await expect(createTransactionMethod().run()).resolves.toMatchObject({
+        v: '0x1b',
+      });
+      expect(mockTypedCall).toHaveBeenCalledWith(
+        'EthereumSignTxEIP7702OneKey',
+        'EthereumTxRequestOneKey',
+        expect.any(Object)
+      );
+    });
+
+    it('continues to use legacy messages for a Protocol V1 legacy device', async () => {
+      mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1LegacySchema');
+
+      await expect(createTransactionMethod().run()).rejects.toThrow(
+        'EIP7702 not supported by Trezor'
+      );
+      expect(mockTypedCall).not.toHaveBeenCalled();
+    });
+  });
+
   describe('EIP-7702 Transaction Detection', () => {
     it('should detect EIP-7702 transaction with authorization list', () => {
       const transaction: EVMTransactionEIP7702 = {

package/__tests__/evmSignTypedData.test.ts

@@ -497,3 +497,83 @@ describe('EVMSignTypedData — hasClassicFamilyTypedDataFormatViolations', () =>
     });
   });
 });
+
+describe('EVMSignTypedData — OneKey Pro Safe Protocol V1', () => {
+  it('收到 Pro 的 Safe 请求后按 EthereumGnosisSafeTxAck 字段回传', async () => {
+    const data = {
+      types: {
+        EIP712Domain: [
+          { name: 'chainId', type: 'uint256' },
+          { name: 'verifyingContract', type: 'address' },
+        ],
+        SafeTx: [
+          { name: 'to', type: 'address' },
+          { name: 'value', type: 'uint256' },
+          { name: 'data', type: 'bytes' },
+          { name: 'operation', type: 'uint8' },
+          { name: 'safeTxGas', type: 'uint256' },
+          { name: 'baseGas', type: 'uint256' },
+          { name: 'gasPrice', type: 'uint256' },
+          { name: 'gasToken', type: 'address' },
+          { name: 'refundReceiver', type: 'address' },
+          { name: 'nonce', type: 'uint256' },
+        ],
+      },
+      primaryType: 'SafeTx',
+      domain: {
+        chainId: '0x89',
+        verifyingContract: '0x673f21761c5400531a37554a602fe0407addd0dd',
+      },
+      message: {
+        to: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        value: '1000',
+        data: '0x001234',
+        operation: '1',
+        safeTxGas: '256',
+        baseGas: '0',
+        gasPrice: '15',
+        gasToken: '0x0000000000000000000000000000000000000000',
+        refundReceiver: '0x0000000000000000000000000000000000000000',
+        nonce: '2',
+      },
+    } as EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+    const method = createMethod(data);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'EthereumTypedDataSignatureOneKey',
+      message: {
+        address: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        signature: 'abcd',
+      },
+    });
+
+    const result = await method.handleSignTypedData({
+      typedCall: typedCall as any,
+      signData: data,
+      response: { type: 'EthereumGnosisSafeTxRequest', message: {} } as any,
+      supportTrezor: false,
+    });
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'EthereumGnosisSafeTxAck',
+      ['EthereumTypedDataSignature', 'EthereumTypedDataSignatureOneKey'],
+      {
+        to: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        value: '03e8',
+        data: '1234',
+        operation: 1,
+        safeTxGas: '0100',
+        baseGas: '00',
+        gasPrice: '0f',
+        gasToken: '0x0000000000000000000000000000000000000000',
+        refundReceiver: '0x0000000000000000000000000000000000000000',
+        nonce: '02',
+        chain_id: 137,
+        verifyingContract: '0x673f21761c5400531a37554a602fe0407addd0dd',
+      }
+    );
+    expect(result).toEqual({
+      address: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+      signature: 'abcd',
+    });
+  });
+});

package/__tests__/filesystemValidation.test.ts

@@ -0,0 +1,53 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { validateProtocolV2FilesystemPath } from '../src/api/helpers/filesystemValidation';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('validateProtocolV2FilesystemPath', () => {
+  test('兼容并保留设备现有的卷内相对路径格式', () => {
+    expect(validateProtocolV2FilesystemPath('vol1:test.bin', 'path')).toBe('vol1:test.bin');
+  });
+
+  test('目录查询可以使用卷根目录', () => {
+    expect(
+      validateProtocolV2FilesystemPath('VOL1:', 'path', {
+        allowVolumeRoot: true,
+      })
+    ).toBe('vol1:');
+  });
+
+  test.each([
+    'vol1:/../firmware.bin',
+    'vol1:/wallets/./test.bin',
+    'vol1:/wallets//test.bin',
+    'vol1:\\wallets\\test.bin',
+    'vol2:/test.bin',
+    '/test.bin',
+  ])('拒绝不安全或未知范围的路径：%s', path => {
+    expect(() => validateProtocolV2FilesystemPath(path, 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+
+  test('文件操作不允许使用卷根目录', () => {
+    expect(() => validateProtocolV2FilesystemPath('vol1:', 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+
+  test('按 UTF-8 字节数拒绝超出设备最小路径缓冲区的路径', () => {
+    expect(() => validateProtocolV2FilesystemPath(`vol1:/${'测'.repeat(41)}`, 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+});

package/__tests__/firmware-memory-host.test.ts

@@ -0,0 +1,112 @@
+import { prepareFirmwareUpdateV4MemoryHost } from '../src/api/firmware/FirmwareMemoryHost';
+
+import type { CoreApi } from '../src/types/api';
+import type { FirmwareUpdatePlan } from '../src/types/api/firmwareUpdatePlan';
+
+describe('prepareFirmwareUpdateV4MemoryHost', () => {
+  test('registers artifact-backed component and resource readers', async () => {
+    const componentBinary = new Uint8Array([1, 2, 3, 4]).buffer;
+    const archiveBinary = new Uint8Array([5, 6]).buffer;
+    const manifestBinary = new TextEncoder().encode('{"schema":1}').buffer;
+    let artifactReader: Parameters<
+      CoreApi['registerFirmwareUpdateHostBinding']
+    >[0]['artifactReader'];
+    const unregisterFirmwareUpdateHostBinding = jest.fn();
+    const sdk = {
+      prepareFirmwareUpdatePlan: jest.fn(({ plan, artifacts }) => ({
+        schemaVersion: 2,
+        preparedPlanDigest: 'b'.repeat(64),
+        planDigest: plan.planDigest,
+        networkPolicy: 'forbid',
+        executor: plan.executor,
+        deviceIdentity: plan.deviceIdentity,
+        deviceModel: plan.deviceModel,
+        firmwareType: plan.firmwareType,
+        platform: plan.platform,
+        leaseRef: 'test-lease',
+        targetsToUpdate: plan.targetsToUpdate,
+        artifacts: plan.artifacts.map(planArtifact => {
+          const input = artifacts.find(item => item.artifactId === planArtifact.artifactId);
+          return {
+            ...planArtifact,
+            artifact: input?.artifact,
+            materializedEntries: input?.materializedEntries,
+          };
+        }),
+      })),
+      registerFirmwareUpdateHostBinding: jest.fn(binding => {
+        artifactReader = binding.artifactReader;
+        return 7;
+      }),
+      unregisterFirmwareUpdateHostBinding,
+    } as unknown as Pick<
+      CoreApi,
+      | 'prepareFirmwareUpdatePlan'
+      | 'registerFirmwareUpdateHostBinding'
+      | 'unregisterFirmwareUpdateHostBinding'
+    >;
+    const plan = {
+      schemaVersion: 2,
+      planDigest: 'a'.repeat(64),
+      executor: 'v4',
+      deviceIdentity: 'device-id',
+      deviceModel: 'pro2',
+      firmwareType: 0,
+      platform: 'web',
+      targetsToUpdate: ['boot', 'resource'],
+      artifacts: [
+        {
+          artifactId: 'component:boot',
+          role: 'component',
+          target: 'boot',
+          url: 'https://example.com/boot.okpkg',
+          container: 'raw',
+        },
+        {
+          artifactId: 'resource:archive',
+          role: 'resourceBundle',
+          target: 'resource',
+          url: 'https://example.com/resource.zip',
+          container: 'zip',
+          logicalName: 'resource-archive',
+        },
+      ],
+    } as FirmwareUpdatePlan;
+
+    const host = prepareFirmwareUpdateV4MemoryHost({
+      sdk,
+      plan,
+      artifacts: [
+        { artifactId: 'component:boot', binary: componentBinary },
+        {
+          artifactId: 'resource:archive',
+          binary: archiveBinary,
+          materializedEntries: [{ entryName: 'manifest.json', binary: manifestBinary }],
+        },
+      ],
+    });
+
+    expect(host.hostBindingGeneration).toBe(7);
+    expect(sdk.registerFirmwareUpdateHostBinding).toHaveBeenCalledWith(
+      expect.objectContaining({ preparedPlanDigest: host.preparedPlan.preparedPlanDigest })
+    );
+    const componentArtifact = host.preparedPlan.artifacts.find(
+      artifact => artifact.target === 'boot'
+    )?.artifact;
+    expect(componentArtifact?.size).toBe(componentBinary.byteLength);
+    new Uint8Array(componentBinary).fill(9);
+    const opened = await artifactReader!.open({
+      artifactRef: componentArtifact!.artifactRef,
+    });
+    const chunk = await artifactReader!.read({
+      readerId: opened.readerId,
+      offset: 1,
+      length: 2,
+    });
+    expect(Array.from(new Uint8Array(chunk.data))).toEqual([2, 3]);
+    await artifactReader!.close({ readerId: opened.readerId });
+
+    host.release();
+    expect(unregisterFirmwareUpdateHostBinding).toHaveBeenCalledWith(7);
+  });
+});

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

@@ -0,0 +1,175 @@
+import { EDeviceType, EFirmwareType, ERRORS, 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(),
+  validateFirmwareUpdatePlanForceTargets: jest.fn(value => value ?? []),
+}));
+
+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 = {
+    isProtocolV2: jest.fn(() => false),
+    features: {
+      deviceType: EDeviceType.Classic1s,
+      serialNo,
+      firmwareType: EFirmwareType.Universal,
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+    },
+  } as typeof method.device;
+  return method;
+};
+
+const createMethodWithForceTargets = () => {
+  const method = createMethod();
+  method.payload = {
+    ...method.payload,
+    forceUpdateTargets: ['firmware', 'resource'],
+  };
+  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('passes host-selected update targets to the Plan builder', async () => {
+    mockBuildFirmwareUpdatePlan.mockReturnValue({
+      schemaVersion: 2,
+      planDigest: 'a'.repeat(64),
+      executor: 'v2',
+      deviceIdentity: 'device-id',
+      deviceModel: EDeviceType.Classic1s,
+      firmwareType: EFirmwareType.Universal,
+      platform: 'native',
+      artifacts: [],
+      targetsToUpdate: [],
+    });
+
+    await createMethodWithForceTargets().run();
+
+    expect(mockBuildFirmwareUpdatePlan).toHaveBeenCalledWith(
+      expect.objectContaining({
+        forceUpdateTargets: ['firmware', 'resource'],
+      })
+    );
+  });
+
+  test('does not hide a Plan failure for an explicitly forced target', async () => {
+    const planError = ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Forced firmware target is unavailable',
+      {
+        firmwareUpdateCode: 'FirmwarePlanInvalid',
+      }
+    );
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw planError;
+    });
+
+    await expect(createMethodWithForceTargets().run()).rejects.toBe(planError);
+  });
+
+  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);
+  });
+});

package/__tests__/firmware-update/device-update-bootloader.test.ts

@@ -0,0 +1,91 @@
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import DeviceUpdateBootloader from '../../src/api/device/DeviceUpdateBootloader';
+import {
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
+
+jest.mock('../../src/api/firmware/FirmwareUpdatePreparedPlan', () => ({
+  assertFirmwareUpdatePreparedPlanBinding: jest.fn(),
+  assertFirmwareUpdatePreparedPlanDeviceIdentity: jest.fn(),
+  validateFirmwareUpdatePreparedPlan: jest.fn((preparedPlan: unknown) => preparedPlan),
+}));
+
+jest.mock('../../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(),
+    isBleConnect: jest.fn(),
+  },
+}));
+
+jest.mock('../../src/device/DevicePool', () => ({
+  DevicePool: {},
+}));
+
+const artifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: 4,
+  sha256: 'a'.repeat(64),
+};
+
+const createMethod = () => {
+  const closeError = new Error('artifact reader close failed');
+  const close = jest.fn().mockRejectedValue(closeError);
+  const artifactReader = {
+    open: jest.fn().mockResolvedValue({ readerId: 'reader-1', size: artifact.size }),
+    read: jest.fn(),
+    close,
+  };
+  const hostBindingGeneration = registerFirmwareUpdateHostBinding({
+    artifactReader,
+    preparedPlanDigest: 'a'.repeat(64),
+  });
+  const method = new DeviceUpdateBootloader({
+    id: 1,
+    payload: {
+      method: 'deviceUpdateBootloader',
+      artifact,
+      hostBindingGeneration,
+      preparedPlan: { preparedPlanDigest: 'a'.repeat(64) },
+    },
+  });
+  (method as any).device = {
+    features: {
+      deviceType: EDeviceType.Touch,
+      serialNo: 'touch-device-id',
+    },
+    getCurrentDeviceType: () => EDeviceType.Touch,
+    getCurrentFirmwareType: () => EFirmwareType.Universal,
+  };
+  return { close, closeError, method };
+};
+
+describe('DeviceUpdateBootloader artifact source cleanup', () => {
+  afterEach(() => {
+    unregisterFirmwareUpdateHostBinding();
+    jest.restoreAllMocks();
+  });
+
+  test('does not replace a successful update result when source close fails', async () => {
+    const { close, method } = createMethod();
+    jest.spyOn(method, 'updateTouchBootloader').mockResolvedValue(true);
+
+    await expect(method.run()).resolves.toBe(true);
+
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  test('does not replace the original hardware error when source close fails', async () => {
+    const { close, method } = createMethod();
+    const hardwareError = ERRORS.TypedError(
+      HardwareErrorCode.FirmwareError,
+      'original bootloader hardware error'
+    );
+    jest.spyOn(method, 'updateTouchBootloader').mockRejectedValue(hardwareError);
+
+    await expect(method.run()).rejects.toBe(hardwareError);
+
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+});