@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.130

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/evm/protocol.ts

@@ -0,0 +1,6 @@
+import TransportManager from '../../data-manager/TransportManager';
+
+import type { Device } from '../../device/Device';
+
+export const shouldUseLegacyV1EvmMessages = (device: Pick<Device, 'isProtocolV2'>): boolean =>
+  !device.isProtocolV2() && TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema';

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,305 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+
+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 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 readVerifiedFirmwareArtifact = async ({
+  artifact,
+  reader,
+}: {
+  artifact: FirmwareArtifactReference;
+  reader: FirmwareArtifactReader;
+}): Promise<ArrayBuffer> => {
+  assertFirmwareArtifactReference(artifact);
+  const source = await ReaderFirmwareByteSource.open(artifact, reader);
+  try {
+    const binary = await readFirmwareByteSourceFully(source);
+    const actualSha256 = bytesToHex(sha256(new Uint8Array(binary)));
+    if (actualSha256 !== artifact.sha256.toLowerCase()) {
+      return artifactError(
+        'FirmwareArtifactReceiptMismatch',
+        'Firmware artifact bytes do not match the approved SHA-256 receipt'
+      );
+    }
+    return binary;
+  } finally {
+    await source.close().catch(() => undefined);
+  }
+};
+
+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'
+    );
+  }
+  const verifiedBinary = await readVerifiedFirmwareArtifact({ artifact, reader });
+  return createMemoryFirmwareByteSource(verifiedBinary);
+};
+
+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,123 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { clearFirmwareUpdatePreparedPlanDeviceIdentityPin } from './FirmwareUpdatePreparedPlan';
+
+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.preparedPlanDigest !== 'string' ||
+      !/^[0-9a-f]{64}$/i.test(binding.preparedPlanDigest) ||
+      typeof binding.artifactReader?.open !== 'function' ||
+      typeof binding.artifactReader.read !== 'function' ||
+      typeof binding.artifactReader.close !== 'function'
+    ) {
+      return bindingError('Firmware host binding is invalid');
+    }
+    const replacedPreparedPlanDigest = this.binding?.preparedPlanDigest;
+    this.generation += 1;
+    this.binding = binding;
+    if (replacedPreparedPlanDigest) {
+      clearFirmwareUpdatePreparedPlanDeviceIdentityPin(replacedPreparedPlanDigest);
+    }
+    return this.generation;
+  }
+
+  unregister(generation?: number): boolean {
+    if (generation !== undefined && generation !== this.generation) {
+      return false;
+    }
+    const releasedPreparedPlanDigest = this.binding?.preparedPlanDigest;
+    this.generation += 1;
+    this.binding = undefined;
+    if (releasedPreparedPlanDigest) {
+      clearFirmwareUpdatePreparedPlanDeviceIdentityPin(releasedPreparedPlanDigest);
+    }
+    return true;
+  }
+
+  getGeneration(): number {
+    return this.generation;
+  }
+
+  resolve(generation: number, preparedPlanDigest?: string): FirmwareUpdateHostBinding {
+    if (
+      !Number.isSafeInteger(generation) ||
+      generation <= 0 ||
+      generation !== this.generation ||
+      !this.binding
+    ) {
+      return bindingError(`Firmware host binding generation ${generation} is stale`);
+    }
+    const { binding } = this;
+    if (
+      preparedPlanDigest !== undefined &&
+      binding.preparedPlanDigest.toLowerCase() !== preparedPlanDigest.toLowerCase()
+    ) {
+      return bindingError(
+        `Firmware host binding generation ${generation} does not match the prepared plan`
+      );
+    }
+    const assertCurrent = () => {
+      if (generation !== this.generation || binding !== this.binding) {
+        bindingError(`Firmware host binding generation ${generation} is stale`);
+      }
+    };
+    return {
+      preparedPlanDigest: binding.preparedPlanDigest,
+      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,
+  preparedPlanDigest?: string
+): FirmwareUpdateHostBinding =>
+  firmwareHostBindingRegistry.resolve(generation ?? Number.NaN, preparedPlanDigest);

package/src/api/firmware/FirmwareMemoryHost.ts

@@ -0,0 +1,143 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type { CoreApi } from '../../types/api';
+import type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+} from '../../types/api/firmwareUpdate';
+import type { FirmwareUpdatePlan } from '../../types/api/firmwareUpdatePlan';
+
+export type FirmwareMemoryArtifactEntry = {
+  entryName: string;
+  binary: ArrayBuffer;
+};
+
+export type FirmwareMemoryArtifact = {
+  artifactId: string;
+  binary: ArrayBuffer;
+  materializedEntries?: FirmwareMemoryArtifactEntry[];
+};
+
+export type FirmwareUpdateV4MemoryHost = {
+  preparedPlan: ReturnType<CoreApi['prepareFirmwareUpdatePlan']>;
+  hostBindingGeneration: number;
+  release: () => void;
+};
+
+let memoryHostSequence = 0;
+
+const createReference = (binary: ArrayBuffer, prefix: string): FirmwareArtifactReference => {
+  const digest = bytesToHex(sha256(new Uint8Array(binary)));
+  return {
+    artifactRef: `fwmem:${prefix}:${digest.slice(0, 32)}`,
+    size: binary.byteLength,
+    sha256: digest,
+  };
+};
+
+export function prepareFirmwareUpdateV4MemoryHost({
+  sdk,
+  plan,
+  artifacts,
+}: {
+  sdk: Pick<
+    CoreApi,
+    | 'prepareFirmwareUpdatePlan'
+    | 'registerFirmwareUpdateHostBinding'
+    | 'unregisterFirmwareUpdateHostBinding'
+  >;
+  plan: FirmwareUpdatePlan;
+  artifacts: FirmwareMemoryArtifact[];
+}): FirmwareUpdateV4MemoryHost {
+  if (plan.executor !== 'v4') {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Firmware memory host only supports V4 plans'
+    );
+  }
+  memoryHostSequence += 1;
+  const hostId = `${Date.now()}:${memoryHostSequence}`;
+  const binaries = new Map<string, Uint8Array>();
+  const inputs = artifacts.map((input, artifactIndex) => {
+    const artifactBinary = new Uint8Array(input.binary).slice();
+    const artifact = createReference(
+      artifactBinary.buffer as ArrayBuffer,
+      `${hostId}:artifact:${artifactIndex}`
+    );
+    binaries.set(artifact.artifactRef, artifactBinary);
+    const materializedEntries = input.materializedEntries?.map((entry, entryIndex) => {
+      const entryArtifact = createReference(
+        entry.binary,
+        `${hostId}:entry:${artifactIndex}:${entryIndex}`
+      );
+      // Entry references are compact receipts for bytes that will be re-derived
+      // from the verified archive. Retaining another readable copy here doubles
+      // resource memory without adding an execution trust boundary.
+      return {
+        entryName: entry.entryName,
+        artifact: entryArtifact,
+      };
+    });
+    return {
+      artifactId: input.artifactId,
+      artifact,
+      ...(materializedEntries?.length ? { materializedEntries } : {}),
+    };
+  });
+  const preparedPlan = sdk.prepareFirmwareUpdatePlan({
+    plan,
+    leaseRef: `fwmemlease:${hostId}`,
+    artifacts: inputs,
+  });
+  const readers = new Map<string, Uint8Array>();
+  let readerSequence = 0;
+  const artifactReader: FirmwareArtifactReader = {
+    open({ artifactRef }) {
+      const binary = binaries.get(artifactRef);
+      if (!binary) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Firmware memory artifact is unavailable'
+        );
+      }
+      readerSequence += 1;
+      const readerId = `fwmemreader:${hostId}:${readerSequence}`;
+      readers.set(readerId, binary);
+      return Promise.resolve({ readerId, size: binary.byteLength });
+    },
+    read({ readerId, offset, length }) {
+      const binary = readers.get(readerId);
+      if (!binary || offset < 0 || length <= 0 || offset + length > binary.byteLength) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Firmware memory artifact read is invalid'
+        );
+      }
+      const data = binary.slice(offset, offset + length).buffer;
+      return Promise.resolve({
+        data,
+        bytesRead: data.byteLength,
+        eof: offset + length === binary.byteLength,
+      });
+    },
+    close({ readerId }) {
+      readers.delete(readerId);
+      return Promise.resolve();
+    },
+  };
+  const hostBindingGeneration = sdk.registerFirmwareUpdateHostBinding({
+    artifactReader,
+    preparedPlanDigest: preparedPlan.preparedPlanDigest,
+  });
+  return {
+    preparedPlan,
+    hostBindingGeneration,
+    release: () => {
+      sdk.unregisterFirmwareUpdateHostBinding(hostBindingGeneration);
+      readers.clear();
+      binaries.clear();
+    },
+  };
+}

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