@onekeyfe/hd-core 1.2.0-alpha.3 → 1.2.0-alpha.31

package/src/api/evm/EVMSignMessage.ts

@@ -10,6 +10,10 @@ import signMessageLegacyV1 from './legacyV1/signMessage';
 import type { EthereumSignMessageOneKey } from '@onekeyfe/hd-transport';
 
 export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];

package/src/api/evm/EVMSignMessageEIP712.ts

@@ -35,10 +35,6 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
 
   getVersionRange(): DeviceFirmwareRange {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_mini: {
         min: '2.1.9',
       },
@@ -49,13 +45,7 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
   }
 
   async run() {
-    this.checkFeatureVersionLimit(
-      () => true,
-      () => this.getVersionRange(),
-      {
-        strictCheckDeviceSupport: true,
-      }
-    );
+    this.assertProtocolSupported(this.device.getProtocol(), this.device.getCurrentFirmwareType());
 
     const res = await this.device.commands.typedCall(
       'EthereumSignMessageEIP712',

package/src/api/evm/EVMSignTransaction.ts

@@ -18,6 +18,10 @@ import type {
 import type { SchemaParam } from '../helpers/paramsValidator';
 
 export default class EVMSignTransaction extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   addressN: number[] = [];
 
   isEIP1559 = false;

package/src/api/evm/EVMSignTypedData.ts

@@ -32,9 +32,8 @@ import type {
 } from '@onekeyfe/hd-transport';
 
 /**
- * EthereumTypedDataStructAckOneKey 与 EthereumTypedDataStructAck 的字段结构与
- * 枚举数值完全一致（生成产物的 OneKey/Trezor 双份消息），仅枚举名义类型不同；
- * 这里做无运行时成本的名义转换，避免在调用点散落 any。
+ * 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;
@@ -57,6 +56,10 @@ const MINI_MAX_ARRAY_TYPE_FIELDS = 24;
 const MINI_MAX_ARRAY_ELEMENTS = 24;
 
 export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -227,8 +230,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     if (response.type === 'EthereumGnosisSafeTxRequest') {
       const { data } = this.params;
       const verifyingContract = data.domain?.verifyingContract;
-      // EthereumGnosisSafeTxAck.verifyingContract 在 proto 中是 required 字段，
-      // Gnosis Safe 签名缺少 verifyingContract 没有意义，这里给出明确的参数错误。
+      // verifyingContract is required by proto and essential to a Gnosis Safe signature.
       if (!verifyingContract) {
         throw ERRORS.TypedError(
           HardwareErrorCode.CallMethodInvalidParameter,

package/src/api/evm/EVMVerifyMessage.ts

@@ -9,6 +9,10 @@ import verifyMessage from './latest/verifyMessage';
 import type { EthereumVerifyMessageOneKey } from '@onekeyfe/hd-transport';
 
 export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneKey> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];

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

@@ -7,8 +7,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetAddressOneKey;
 }): Promise<MessageResponse<'EthereumAddress'>> {
-  // legacy EthereumGetAddress 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // 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,

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

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetPublicKeyOneKey;
 }): Promise<MessageResponse<'EthereumPublicKey'>> {
-  // legacy EthereumGetPublicKey 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // 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,

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

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumSignMessageOneKey;
 }): Promise<EthereumMessageSignature> {
-  // legacy EthereumSignMessage 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // 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,

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

@@ -16,8 +16,8 @@ export const signTypedData = async ({
 }) => {
   const { primaryType }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
 
-  // legacy EthereumSignTypedData 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // 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,

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

@@ -38,8 +38,8 @@ export const signTypedHash = async ({
     }
   }
 
-  // legacy EthereumSignTypedHash 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // 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 ?? '',

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

@@ -7,8 +7,8 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumVerifyMessageOneKey;
 }): Promise<Success> {
-  // legacy EthereumVerifyMessage 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // 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,

package/src/api/filecoin/FilecoinGetAddress.ts

@@ -7,6 +7,10 @@ import type { FilecoinGetAddress as HardwareFilecoinGetAddress } from '@onekeyfe
 import type { FilecoinAddress, FilecoinGetAddressParams } from '../../types';
 
 export default class FilecoinGetAddress extends BaseMethod<HardwareFilecoinGetAddress[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/filecoin/FilecoinSignTransaction.ts

@@ -7,6 +7,10 @@ import type { FilecoinSignTransactionParams } from '../../types';
 import type { FilecoinSignTx as HardwareFilecoinSignTx } from '@onekeyfe/hd-transport';
 
 export default class FilecoinSignTransaction extends BaseMethod<HardwareFilecoinSignTx> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

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;
+};
+
+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;
+};

package/src/api/firmware/FirmwareHostBinding.ts

@@ -0,0 +1,100 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type { FirmwareUpdateHostBinding } from '../../types/api/firmwareUpdate';
+
+const bindingError = (message: string): never => {
+  throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, message, {
+    firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+  });
+};
+
+class FirmwareHostBindingRegistry {
+  private generation = 0;
+
+  private binding?: FirmwareUpdateHostBinding;
+
+  register(binding: FirmwareUpdateHostBinding): number {
+    if (
+      !binding ||
+      typeof binding.artifactReader?.open !== 'function' ||
+      typeof binding.artifactReader.read !== 'function' ||
+      typeof binding.artifactReader.close !== 'function'
+    ) {
+      return bindingError('Firmware host binding is invalid');
+    }
+    this.generation += 1;
+    this.binding = binding;
+    return this.generation;
+  }
+
+  unregister(generation?: number): boolean {
+    if (generation !== undefined && generation !== this.generation) {
+      return false;
+    }
+    this.generation += 1;
+    this.binding = undefined;
+    return true;
+  }
+
+  getGeneration(): number {
+    return this.generation;
+  }
+
+  resolve(generation: number): FirmwareUpdateHostBinding {
+    if (
+      !Number.isSafeInteger(generation) ||
+      generation <= 0 ||
+      generation !== this.generation ||
+      !this.binding
+    ) {
+      return bindingError(`Firmware host binding generation ${generation} is stale`);
+    }
+    const { binding } = this;
+    const assertCurrent = () => {
+      if (generation !== this.generation || binding !== this.binding) {
+        bindingError(`Firmware host binding generation ${generation} is stale`);
+      }
+    };
+    return {
+      artifactReader: {
+        open: async input => {
+          assertCurrent();
+          const opened = await binding.artifactReader.open(input);
+          try {
+            assertCurrent();
+          } catch (error) {
+            if (opened?.readerId) {
+              await binding.artifactReader
+                .close({ readerId: opened.readerId })
+                .catch(() => undefined);
+            }
+            throw error;
+          }
+          return opened;
+        },
+        read: async input => {
+          assertCurrent();
+          const result = await binding.artifactReader.read(input);
+          assertCurrent();
+          return result;
+        },
+        close: input => binding.artifactReader.close(input),
+      },
+    };
+  }
+}
+
+const firmwareHostBindingRegistry = new FirmwareHostBindingRegistry();
+
+export const registerFirmwareUpdateHostBinding = (binding: FirmwareUpdateHostBinding): number =>
+  firmwareHostBindingRegistry.register(binding);
+
+export const unregisterFirmwareUpdateHostBinding = (generation?: number): boolean =>
+  firmwareHostBindingRegistry.unregister(generation);
+
+export const getFirmwareUpdateHostBindingGeneration = (): number =>
+  firmwareHostBindingRegistry.getGeneration();
+
+export const resolveFirmwareUpdateHostBinding = (
+  generation: number | undefined
+): FirmwareUpdateHostBinding => firmwareHostBindingRegistry.resolve(generation ?? Number.NaN);

package/src/api/firmware/FirmwarePreparationError.ts

@@ -0,0 +1,12 @@
+import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+export const normalizeFirmwarePreparationError = (error: unknown) => {
+  if (error instanceof HardwareError && error.params?.firmwareUpdateCode) {
+    return error;
+  }
+
+  return ERRORS.TypedError(
+    HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    error instanceof Error ? error.message : String(error)
+  );
+};