@onekeyfe/hd-core 1.2.0-alpha.51 → 1.2.0-alpha.53

package/src/api/firmware/FirmwareArtifactSource.ts

@@ -1,278 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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)
-  );
-};

package/src/api/firmware/FirmwareUpdateCapabilities.ts

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