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

package/src/api/firmware/FirmwareCheckpoint.ts

@@ -1,188 +0,0 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import type {
-  FirmwareCheckpoint,
-  FirmwareCheckpointParams,
-  FirmwareCheckpointStage,
-} from '../../types/api/firmwareUpdate';
-
-const CHECKPOINT_TIMEOUT_MS = 5000;
-const MAX_CHECKPOINT_TARGET_LENGTH = 160;
-
-type FirmwareCheckpointState = {
-  latestSequence: number;
-  tail: Promise<void>;
-};
-
-const checkpointStateBySink = new WeakMap<
-  NonNullable<FirmwareCheckpointParams['checkpointSink']>,
-  FirmwareCheckpointState
->();
-
-const checkpointError = (message: string) =>
-  ERRORS.TypedError(HardwareErrorCode.RuntimeError, message, {
-    firmwareUpdateCode: 'FirmwareCheckpointRejected',
-  });
-
-export const validateFirmwareCheckpoint = (value: unknown): FirmwareCheckpoint => {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw checkpointError('Firmware resume checkpoint is invalid');
-  }
-  const checkpoint = value as Partial<FirmwareCheckpoint>;
-  const allowedKeys = new Set([
-    'schemaVersion',
-    'sequence',
-    'stage',
-    'destructiveActionStarted',
-    'target',
-    'epoch',
-  ]);
-  if (
-    Object.keys(checkpoint).some(key => !allowedKeys.has(key)) ||
-    !['schemaVersion', 'sequence', 'stage', 'destructiveActionStarted'].every(key =>
-      Object.prototype.hasOwnProperty.call(checkpoint, key)
-    ) ||
-    checkpoint.schemaVersion !== 1 ||
-    !Number.isSafeInteger(checkpoint.sequence) ||
-    (checkpoint.sequence as number) < 1 ||
-    ![
-      'EPOCH_STARTED',
-      'EPOCH_COMPLETED',
-      'BEFORE_DEVICE_MODE_CHANGE',
-      'FILE_TRANSFER_STARTED',
-      'FILE_TRANSFER_COMPLETED',
-      'INSTALL_REQUESTED',
-      'INSTALL_ACCEPTED',
-      'FINAL_VERIFIED',
-    ].includes(checkpoint.stage as string) ||
-    checkpoint.destructiveActionStarted !== true ||
-    (checkpoint.target !== undefined &&
-      (!checkpoint.target ||
-        checkpoint.target.length > MAX_CHECKPOINT_TARGET_LENGTH ||
-        /(?:https?|file):\/\//iu.test(checkpoint.target) ||
-        /^(?:\/|[A-Za-z]:[\\/])/u.test(checkpoint.target))) ||
-    (checkpoint.epoch !== undefined &&
-      (!Number.isSafeInteger(checkpoint.epoch) || checkpoint.epoch < 0))
-  ) {
-    throw checkpointError('Firmware resume checkpoint fields are invalid');
-  }
-  return checkpoint as FirmwareCheckpoint;
-};
-
-const validateCheckpointParams = (params: FirmwareCheckpointParams, required: boolean) => {
-  const { checkpointSequenceStart, checkpointSink } = params;
-  const resumeCheckpoint =
-    params.resumeCheckpoint === undefined
-      ? undefined
-      : validateFirmwareCheckpoint(params.resumeCheckpoint);
-  if (
-    checkpointSequenceStart !== undefined &&
-    (!Number.isSafeInteger(checkpointSequenceStart) || checkpointSequenceStart < 0)
-  ) {
-    throw checkpointError('Firmware checkpoint sequence is invalid');
-  }
-  if (
-    checkpointSink !== undefined &&
-    (typeof checkpointSink !== 'object' ||
-      checkpointSink === null ||
-      typeof checkpointSink.commit !== 'function')
-  ) {
-    throw checkpointError('Firmware checkpoint sink is invalid');
-  }
-  if (required && !checkpointSink) {
-    throw checkpointError('Prepared firmware update requires a checkpoint sink');
-  }
-  if (resumeCheckpoint && checkpointSequenceStart !== resumeCheckpoint.sequence) {
-    throw checkpointError('Firmware checkpoint sequence does not match recovery state');
-  }
-};
-
-const waitForCheckpoint = async (commit: Promise<void>) => {
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  try {
-    await Promise.race([
-      commit,
-      new Promise<never>((_, reject) => {
-        timeoutId = setTimeout(
-          () => reject(checkpointError('Firmware checkpoint commit timed out')),
-          CHECKPOINT_TIMEOUT_MS
-        );
-      }),
-    ]);
-  } finally {
-    if (timeoutId) clearTimeout(timeoutId);
-  }
-};
-
-export class FirmwareCheckpointWriter {
-  private readonly sink: FirmwareCheckpointParams['checkpointSink'];
-
-  private readonly sequenceStart: number;
-
-  constructor(params: FirmwareCheckpointParams, { required = false } = {}) {
-    validateCheckpointParams(params, required);
-    this.sink = params.checkpointSink;
-    this.sequenceStart = params.checkpointSequenceStart ?? 0;
-  }
-
-  async commit({
-    stage,
-    target,
-    epoch,
-  }: {
-    stage: FirmwareCheckpointStage;
-    target?: string;
-    epoch?: number;
-  }): Promise<void> {
-    if (!this.sink) return;
-    if (
-      (target !== undefined &&
-        (!target ||
-          target.length > MAX_CHECKPOINT_TARGET_LENGTH ||
-          /(?:https?|file):\/\//iu.test(target) ||
-          /^(?:\/|[A-Za-z]:[\\/])/u.test(target))) ||
-      (epoch !== undefined && (!Number.isSafeInteger(epoch) || epoch < 0))
-    ) {
-      throw checkpointError('Firmware checkpoint metadata is invalid');
-    }
-
-    let state = checkpointStateBySink.get(this.sink);
-    if (!state) {
-      state = {
-        latestSequence: this.sequenceStart,
-        tail: Promise.resolve(),
-      };
-      checkpointStateBySink.set(this.sink, state);
-    } else if (this.sequenceStart > state.latestSequence) {
-      state.latestSequence = this.sequenceStart;
-    }
-    const activeState = state;
-
-    const queuedCommit = activeState.tail.then(async () => {
-      const sequence = activeState.latestSequence + 1;
-      const checkpoint: FirmwareCheckpoint = {
-        schemaVersion: 1,
-        sequence,
-        stage,
-        destructiveActionStarted: true,
-        ...(target ? { target } : {}),
-        ...(epoch !== undefined ? { epoch } : {}),
-      };
-      try {
-        await this.sink?.commit(checkpoint);
-        activeState.latestSequence = sequence;
-      } catch (error) {
-        throw checkpointError(
-          `Firmware checkpoint commit was rejected: ${
-            error instanceof Error ? error.message : 'unknown error'
-          }`
-        );
-      }
-    });
-
-    // Keep the real commit serialized even when the caller's timeout fires. A
-    // later call cannot overtake an unresolved or late checkpoint write.
-    activeState.tail = queuedCommit.catch(() => undefined);
-    await waitForCheckpoint(queuedCommit);
-  }
-}

package/src/api/firmware/FirmwareHostBinding.ts

@@ -1,108 +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' ||
-      typeof binding.checkpointSink?.commit !== '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),
-      },
-      checkpointSink: {
-        commit: async checkpoint => {
-          assertCurrent();
-          await binding.checkpointSink.commit(checkpoint);
-          assertCurrent();
-        },
-      },
-    };
-  }
-}
-
-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/FirmwareUpdateCapabilities.ts

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