@onekeyfe/hd-core 1.1.34-alpha.2 → 1.1.34-alpha.3

package/src/api/evm/EVMSignTypedData.ts

@@ -9,7 +9,6 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex, parseChainId, stripHexStartZeroes } from '../helpers/hexUtils';
-import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { existCapability } from '../../utils/capabilitieUtils';
 import {
   DeviceModelToTypes,
@@ -26,11 +25,19 @@ import { encodeData, getFieldType, parseArrayType } from '../helpers/typeNameUti
 import type {
   EthereumTypedDataSignature,
   EthereumTypedDataStructAck,
+  EthereumTypedDataStructAckOneKey,
   MessageKey,
   MessageResponse,
   TypedCall,
 } from '@onekeyfe/hd-transport';
 
+/**
+ * EthereumTypedDataStructAckOneKey and EthereumTypedDataStructAck have identical
+ * fields and enum values. This zero-cost nominal conversion avoids scattered `any`.
+ */
+const toOneKeyStructAck = (ack: EthereumTypedDataStructAck): EthereumTypedDataStructAckOneKey =>
+  ack as unknown as EthereumTypedDataStructAckOneKey;
+
 export type EVMSignTypedDataParams = {
   addressN: number[];
   metamaskV4Compat: boolean;
@@ -130,7 +137,6 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
       if (supportTrezor) {
         response = await typedCall(
           'EthereumTypedDataStructAck',
-          // @ts-ignore
           [
             'EthereumTypedDataStructRequest',
             'EthereumTypedDataValueRequest',
@@ -141,13 +147,12 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
       } else {
         response = await typedCall(
           'EthereumTypedDataStructAckOneKey',
-          // @ts-ignore
           [
             'EthereumTypedDataStructRequestOneKey',
             'EthereumTypedDataValueRequestOneKey',
             'EthereumTypedDataSignatureOneKey',
           ],
-          dataStruckAck
+          toOneKeyStructAck(dataStruckAck)
         );
       }
     }
@@ -183,7 +188,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         } else if (typeof memberData === 'object' && memberData !== null) {
           const memberTypeDefinition = types[memberTypeName][index];
           memberTypeName = memberTypeDefinition.type;
-          memberData = memberData[memberTypeDefinition.name];
+          memberData = (memberData as Record<string, unknown>)[memberTypeDefinition.name];
         } else {
           // TODO
         }
@@ -220,6 +225,14 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     if (response.type === 'EthereumGnosisSafeTxRequest') {
       const { data } = this.params;
+      const verifyingContract = data.domain?.verifyingContract;
+      // verifyingContract is required by proto and essential to a Gnosis Safe signature.
+      if (!verifyingContract) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'EIP712Domain.verifyingContract is required for Gnosis Safe transaction'
+        );
+      }
       const param = {
         to: data.message.to,
         value: formatAnyHex(new BigNumber(data.message.value).toString(16)),
@@ -232,11 +245,10 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         refundReceiver: data.message.refundReceiver,
         nonce: formatAnyHex(new BigNumber(data.message.nonce).toString(16)),
         chain_id: parseChainId(data.domain.chainId),
-        verifyingContract: data.domain.verifyingContract,
+        verifyingContract,
       };
       response = await typedCall(
         'EthereumGnosisSafeTxAck',
-        // @ts-ignore
         ['EthereumTypedDataSignature', 'EthereumTypedDataSignatureOneKey'],
         param
       );
@@ -262,8 +274,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let supportTrezor = false;
     let response: MessageResponse<MessageKey>;
-    switch (TransportManager.getMessageVersion()) {
-      case 'v1':
+    switch (TransportManager.getProtocolV1MessageSchema()) {
+      case 'v1LegacySchema':
         supportTrezor = true;
         response = await signTypedDataLegacyV1({
           typedCall: this.device.commands.typedCall.bind(this.device.commands),
@@ -274,7 +286,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         });
         break;
 
-      case 'latest':
+      case 'v1CurrentSchema':
       default:
         supportTrezor = false;
         response = await signTypedData({
@@ -310,8 +322,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }) {
     if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
 
-    switch (TransportManager.getMessageVersion()) {
-      case 'v1':
+    switch (TransportManager.getProtocolV1MessageSchema()) {
+      case 'v1LegacySchema':
         return signTypedHashLegacyV1({
           typedCall,
           addressN,
@@ -321,7 +333,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
           device: this.device,
         });
 
-      case 'latest':
+      case 'v1CurrentSchema':
       default:
         return signTypedHash({
           typedCall,
@@ -348,8 +360,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let biggerLimit = 1024; // 1k
 
-    const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
-    const currentDeviceType = getDeviceType(this.device.features);
+    const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
+    const currentDeviceType = this.device.getCurrentDeviceType();
     const supportBiggerDataVersion = '4.4.0';
 
     const supportBiggerData =
@@ -532,9 +544,9 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }
 
   supportSignTyped() {
-    const deviceType = getDeviceType(this.device.features);
+    const deviceType = this.device.getCurrentDeviceType();
     if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-      const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+      const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
       const supportSignTypedVersion = '2.2.0';
 
       if (semver.lt(currentVersion, supportSignTypedVersion)) {
@@ -564,7 +576,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     // For Classic / Mini:
     // - If parsed typed-data capability is missing, keep using blind-sign.
     // - For Mini with parsed capability, add extra format checks before parsed signing.
-    const deviceType = getDeviceType(this.device.features);
+    const deviceType = this.device.getCurrentDeviceType();
     if (
       DeviceModelToTypes.model_mini.includes(deviceType) &&
       (!supportEip712OnClassic || this.hasClassicFamilyTypedDataFormatViolations(this.params.data))

package/src/api/evm/EVMVerifyMessage.ts

@@ -31,7 +31,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneK
   }
 
   async run() {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
       return verifyMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/latest/signTypedHash.ts

@@ -1,8 +1,6 @@
 import semver from 'semver';
 import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
-import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils';
-
 import type { Device } from '../../../device/Device';
 import type { MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
 
@@ -21,10 +19,10 @@ export const signTypedHash = async ({
   domainHash: string;
   messageHash: string | undefined;
 }): Promise<MessageResponse<'EthereumTypedDataSignatureOneKey'>> => {
-  const deviceType = getDeviceType(device.features);
+  const deviceType = device.getCurrentDeviceType();
   if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
     // Touch Pro Sign NestedArrays
-    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+    const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
     const supportNestedArraysSignVersion = '4.2.0';
 
     // 4.2.0 is the first version that supports nested arrays in signTypedData

package/src/api/evm/legacyV1/getAddress.ts

@@ -7,10 +7,12 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetAddressOneKey;
 }): Promise<MessageResponse<'EthereumAddress'>> {
-  return typedCall('EthereumGetAddress', 'EthereumAddress', {
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
+  const message = {
     address_n: param.address_n,
     show_display: param.show_display,
-    // @ts-ignore
     chain_id: param.chain_id,
-  });
+  };
+  return typedCall('EthereumGetAddress', 'EthereumAddress', message);
 }

package/src/api/evm/legacyV1/getPublicKey.ts

@@ -11,10 +11,12 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetPublicKeyOneKey;
 }): Promise<MessageResponse<'EthereumPublicKey'>> {
-  return typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
+  const message = {
     address_n: param.address_n,
     show_display: param.show_display,
-    // @ts-ignore
     chain_id: param.chain_id,
-  });
+  };
+  return typedCall('EthereumGetPublicKey', 'EthereumPublicKey', message);
 }

package/src/api/evm/legacyV1/signMessage.ts

@@ -11,12 +11,14 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumSignMessageOneKey;
 }): Promise<EthereumMessageSignature> {
-  const res = await typedCall('EthereumSignMessage', 'EthereumMessageSignature', {
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
+  const message = {
     address_n: params.address_n,
     message: params.message,
-    // @ts-ignore
     chain_id: params.chain_id,
-  });
+  };
+  const res = await typedCall('EthereumSignMessage', 'EthereumMessageSignature', message);
 
   return Promise.resolve(res.message);
 }

package/src/api/evm/legacyV1/signTypedData.ts

@@ -16,22 +16,23 @@ export const signTypedData = async ({
 }) => {
   const { primaryType }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
 
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
+  const message = {
+    address_n: addressN,
+    primary_type: primaryType as string,
+    metamask_v4_compat: metamaskV4Compat,
+    chain_id: chainId,
+  };
   const response = await typedCall(
     'EthereumSignTypedData',
-    // @ts-ignore
     [
       'EthereumTypedDataStructRequest',
       'EthereumTypedDataValueRequest',
       'EthereumTypedDataSignature',
       'EthereumGnosisSafeTxRequest',
     ],
-    {
-      address_n: addressN,
-      primary_type: primaryType as string,
-      metamask_v4_compat: metamaskV4Compat,
-      // @ts-ignore
-      chain_id: chainId,
-    }
+    message
   );
   return response;
 };

package/src/api/evm/legacyV1/signTypedHash.ts

@@ -1,8 +1,6 @@
 import semver from 'semver';
 import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
-import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils';
-
 import type { Device } from '../../../device/Device';
 import type { MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
 
@@ -24,10 +22,10 @@ export const signTypedHash = async ({
   | MessageResponse<'EthereumTypedDataSignature'>
   | MessageResponse<'EthereumTypedDataSignatureOneKey'>
 > => {
-  const deviceType = getDeviceType(device.features);
+  const deviceType = device.getCurrentDeviceType();
   if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
     // Touch Pro Sign NestedArrays
-    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+    const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
     const supportNestedArraysSignVersion = '4.2.0';
 
     // 4.2.0 is the first version that supports nested arrays in signTypedData
@@ -40,11 +38,13 @@ export const signTypedHash = async ({
     }
   }
 
-  return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
+  const message = {
     address_n: addressN,
     domain_separator_hash: domainHash ?? '',
     message_hash: messageHash,
-    // @ts-ignore
     chain_id: chainId,
-  });
+  };
+  return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', message);
 };

package/src/api/evm/legacyV1/verifyMessage.ts

@@ -7,13 +7,15 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumVerifyMessageOneKey;
 }): Promise<Success> {
-  const res = await typedCall('EthereumVerifyMessage', 'Success', {
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
+  const message = {
     signature: params.signature,
     message: params.message,
     address: params.address,
-    // @ts-ignore
     chain_id: params.chain_id,
-  });
+  };
+  const res = await typedCall('EthereumVerifyMessage', 'Success', message);
 
   return Promise.resolve(res.message);
 }

package/src/api/firmware/FirmwareArtifactSource.ts

@@ -0,0 +1,278 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+} from '../../types/api/firmwareUpdate';
+
+export const MAX_FIRMWARE_ARTIFACT_READ_BYTES = 256 * 1024;
+
+export interface FirmwareByteSource {
+  readonly size: number;
+  readAt(offset: number, length: number): Promise<ArrayBuffer>;
+  close(): Promise<void>;
+}
+
+const artifactError = (
+  code:
+    | 'FirmwareArtifactReceiptMismatch'
+    | 'FirmwareArtifactReaderInvalid'
+    | 'FirmwareArtifactReadOutOfBounds'
+    | 'FirmwareArtifactReadTooLarge',
+  message: string
+): never => {
+  throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, message, {
+    firmwareUpdateCode: code,
+  });
+};
+
+const assertSafeSize = (value: number, name: string) => {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    artifactError('FirmwareArtifactReceiptMismatch', `${name} must be a positive safe integer`);
+  }
+};
+
+export const assertFirmwareArtifactReference = (
+  artifact: FirmwareArtifactReference
+): FirmwareArtifactReference => {
+  if (
+    !artifact ||
+    typeof artifact.artifactRef !== 'string' ||
+    artifact.artifactRef.length === 0 ||
+    artifact.artifactRef.length > 160 ||
+    artifact.artifactRef.includes('/') ||
+    artifact.artifactRef.includes('\\')
+  ) {
+    artifactError(
+      'FirmwareArtifactReceiptMismatch',
+      'Firmware artifactRef must be an opaque identifier'
+    );
+  }
+  assertSafeSize(artifact.size, 'Firmware artifact size');
+  if (typeof artifact.sha256 !== 'string' || !/^[a-f0-9]{64}$/i.test(artifact.sha256)) {
+    artifactError(
+      'FirmwareArtifactReceiptMismatch',
+      'Firmware artifact sha256 must be a 32-byte hexadecimal digest'
+    );
+  }
+  return artifact;
+};
+
+export const assertFirmwareArtifactRead = (size: number, offset: number, length: number) => {
+  if (
+    !Number.isSafeInteger(offset) ||
+    offset < 0 ||
+    offset >= size ||
+    !Number.isSafeInteger(length) ||
+    length <= 0 ||
+    offset + length > size
+  ) {
+    artifactError(
+      'FirmwareArtifactReadOutOfBounds',
+      `Firmware artifact read is outside size ${size}: offset=${offset}, length=${length}`
+    );
+  }
+  if (length > MAX_FIRMWARE_ARTIFACT_READ_BYTES) {
+    artifactError(
+      'FirmwareArtifactReadTooLarge',
+      `Firmware artifact read length ${length} exceeds ${MAX_FIRMWARE_ARTIFACT_READ_BYTES}`
+    );
+  }
+};
+
+const createMemoryFirmwareByteSource = (binary: ArrayBuffer): FirmwareByteSource => {
+  let bytes: Uint8Array | null = new Uint8Array(binary);
+  const { byteLength: size } = binary;
+  assertSafeSize(size, 'Firmware binary size');
+  return {
+    size,
+    readAt: (offset, length) => {
+      if (!bytes) {
+        return Promise.reject(
+          ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Firmware byte source is closed', {
+            firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+          })
+        );
+      }
+      assertFirmwareArtifactRead(size, offset, length);
+      return Promise.resolve(bytes.slice(offset, offset + length).buffer);
+    },
+    close: () => {
+      bytes = null;
+      return Promise.resolve();
+    },
+  };
+};
+
+class ReaderFirmwareByteSource implements FirmwareByteSource {
+  readonly size: number;
+
+  private closed = false;
+
+  private reading = false;
+
+  private constructor(
+    private readonly reader: FirmwareArtifactReader,
+    private readonly readerId: string,
+    size: number
+  ) {
+    this.size = size;
+  }
+
+  static async open(
+    artifact: FirmwareArtifactReference,
+    reader: FirmwareArtifactReader
+  ): Promise<ReaderFirmwareByteSource> {
+    const opened = await reader.open({ artifactRef: artifact.artifactRef });
+    if (
+      !opened ||
+      typeof opened.readerId !== 'string' ||
+      opened.readerId.length === 0 ||
+      !Number.isSafeInteger(opened.size) ||
+      opened.size !== artifact.size
+    ) {
+      if (opened?.readerId) {
+        await reader.close({ readerId: opened.readerId }).catch(() => undefined);
+      }
+      return artifactError(
+        'FirmwareArtifactReceiptMismatch',
+        `Firmware artifact opened with size ${opened?.size ?? 'unknown'}, expected ${artifact.size}`
+      );
+    }
+    return new ReaderFirmwareByteSource(reader, opened.readerId, opened.size);
+  }
+
+  async readAt(offset: number, length: number): Promise<ArrayBuffer> {
+    if (this.closed) {
+      return artifactError('FirmwareArtifactReaderInvalid', 'Firmware artifact reader is closed');
+    }
+    if (this.reading) {
+      return artifactError(
+        'FirmwareArtifactReaderInvalid',
+        'Firmware artifact reader only permits one in-flight read'
+      );
+    }
+    assertFirmwareArtifactRead(this.size, offset, length);
+    this.reading = true;
+    try {
+      const result = await this.reader.read({
+        readerId: this.readerId,
+        offset,
+        length,
+      });
+      const expectedEof = offset + length === this.size;
+      if (
+        !result ||
+        !(result.data instanceof ArrayBuffer) ||
+        result.data.byteLength !== length ||
+        result.bytesRead !== length ||
+        result.eof !== expectedEof
+      ) {
+        return artifactError(
+          'FirmwareArtifactReaderInvalid',
+          'Firmware artifact reader returned an invalid read result'
+        );
+      }
+      return result.data;
+    } finally {
+      this.reading = false;
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.reader.close({ readerId: this.readerId });
+  }
+}
+
+export const openFirmwareByteSource = async ({
+  binary,
+  artifact,
+  reader,
+}: {
+  binary?: ArrayBuffer;
+  artifact?: FirmwareArtifactReference;
+  reader?: FirmwareArtifactReader;
+}): Promise<FirmwareByteSource | null> => {
+  if (binary && artifact) {
+    return artifactError(
+      'FirmwareArtifactReceiptMismatch',
+      'Firmware input must not contain both binary and artifactRef'
+    );
+  }
+  if (binary) {
+    return createMemoryFirmwareByteSource(binary);
+  }
+  if (!artifact) {
+    return null;
+  }
+  assertFirmwareArtifactReference(artifact);
+  if (!reader) {
+    return artifactError(
+      'FirmwareArtifactReaderInvalid',
+      'Firmware artifact reader is required for artifactRef input'
+    );
+  }
+  return ReaderFirmwareByteSource.open(artifact, reader);
+};
+
+export const readFirmwareByteSourceFully = async (
+  source: FirmwareByteSource
+): Promise<ArrayBuffer> => {
+  const output = new Uint8Array(source.size);
+  let offset = 0;
+  while (offset < source.size) {
+    const length = Math.min(MAX_FIRMWARE_ARTIFACT_READ_BYTES, source.size - offset);
+    output.set(new Uint8Array(await source.readAt(offset, length)), offset);
+    offset += length;
+  }
+  return output.buffer;
+};
+
+export const writeFirmwareByteSource = async ({
+  source,
+  chunkSize,
+  write,
+}: {
+  source: FirmwareByteSource;
+  chunkSize: number;
+  write: (input: {
+    data: ArrayBuffer;
+    sourceOffset: number;
+    length: number;
+    first: boolean;
+  }) => Promise<number>;
+}) => {
+  if (
+    !Number.isSafeInteger(chunkSize) ||
+    chunkSize <= 0 ||
+    chunkSize > MAX_FIRMWARE_ARTIFACT_READ_BYTES
+  ) {
+    return artifactError(
+      'FirmwareArtifactReadTooLarge',
+      `Firmware artifact chunk size must be between 1 and ${MAX_FIRMWARE_ARTIFACT_READ_BYTES}`
+    );
+  }
+  let offset = 0;
+  while (offset < source.size) {
+    const length = Math.min(chunkSize, source.size - offset);
+    const data = await source.readAt(offset, length);
+    const processed = await write({
+      data,
+      sourceOffset: offset,
+      length,
+      first: offset === 0,
+    });
+    if (processed !== length) {
+      return artifactError(
+        'FirmwareArtifactReaderInvalid',
+        `Firmware artifact writer processed ${processed} bytes, expected ${length}`
+      );
+    }
+    offset += length;
+  }
+  return offset;
+};