@onekeyfe/hd-core 1.2.0-alpha.21 → 1.2.0-alpha.22

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

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/FirmwareUpdateBaseMethod.ts

@@ -14,6 +14,7 @@ import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
 import { createFirmwareProgressThrottle } from './progressThrottle';
+import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
   IFirmwareUpdateProgressType,
@@ -24,6 +25,7 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
@@ -387,6 +389,54 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
+  async emmcCommonUpdateProcessFromSource({
+    source,
+    filePath,
+    processedSize,
+    totalSize,
+  }: {
+    source: FirmwareByteSource;
+    filePath: string;
+    processedSize?: number;
+    totalSize?: number;
+  }) {
+    if (!filePath.startsWith('0:')) {
+      throw new Error('filePath must start with 0:');
+    }
+    const env = DataManager.getSettings('env');
+    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
+
+    await writeFirmwareByteSource({
+      source,
+      chunkSize,
+      write: async ({ data, sourceOffset, length, first }) => {
+        const progress =
+          totalSize !== undefined && processedSize !== undefined
+            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
+            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
+        const writeRes = await this.emmcFileWriteWithRetry(
+          filePath,
+          length,
+          sourceOffset,
+          data,
+          first,
+          progress
+        );
+        if (!writeRes) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.EmmcFileWriteFirmwareError,
+            'transfer data error'
+          );
+        }
+        const processedBytes = Number(writeRes.message.processed_byte);
+        this.postProgressMessage(progress, 'transferData');
+        return Number.isFinite(processedBytes) ? processedBytes : length;
+      },
+    });
+
+    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
+  }
+
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,

package/src/api/firmware/FirmwareUpdateCapabilities.ts

@@ -0,0 +1,9 @@
+import type { FirmwareUpdateCapabilities } from '../../types/api/firmwareUpdateCapabilities';
+
+export const getFirmwareUpdateCapabilities = (): FirmwareUpdateCapabilities => ({
+  planSchemaVersion: 2,
+  preparedPlanSchemaVersion: 2,
+  hostBindingProtocolVersion: 2,
+  manifestModes: ['external-only', 'sdk-managed'],
+  supportsArtifactReader: true,
+});