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

package/src/api/GetDeviceState.ts

@@ -1,55 +0,0 @@
-import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
-
-import { UI_REQUEST } from '../constants/ui-request';
-import { BaseMethod } from './BaseMethod';
-
-import type { DeviceStateSection } from '../types';
-import type { DeviceStateScope, GetDeviceStateParams } from '../types/api/getDeviceState';
-
-const SCOPE_SECTIONS: Record<DeviceStateScope, DeviceStateSection[]> = {
-  runtime: ['status'],
-  settings: ['status', 'settings'],
-  firmware: ['status', 'identity', 'versions', 'verification'],
-};
-
-const isLoaderMode = (mode: string) => mode === 'bootloader' || mode === 'romloader';
-
-export default class GetDeviceState extends BaseMethod<
-  Required<Pick<GetDeviceStateParams, 'scope'>>
-> {
-  init() {
-    const scope = (this.payload.scope ?? 'runtime') as DeviceStateScope;
-    if (!Object.prototype.hasOwnProperty.call(SCOPE_SECTIONS, scope)) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodInvalidParameter,
-        `Unsupported device state scope: ${String(scope)}`
-      );
-    }
-    this.allowDeviceMode = [
-      ...this.allowDeviceMode,
-      UI_REQUEST.NOT_INITIALIZE,
-      UI_REQUEST.BOOTLOADER,
-    ];
-    this.unlockPolicy = 'none';
-    this.useDevicePassphraseState = false;
-    this.skipForceUpdateCheck = true;
-    this.params = { scope };
-  }
-
-  async run() {
-    const state = await this.device.getDeviceState({
-      refreshSections: SCOPE_SECTIONS[this.params.scope],
-    });
-    if (
-      this.params.scope === 'settings' &&
-      this.device.isProtocolV2() &&
-      isLoaderMode(state.status.mode)
-    ) {
-      throw createDeviceNotSupportMethodError(
-        `${this.name}:${this.params.scope}`,
-        this.device.getCurrentFirmwareType()
-      );
-    }
-    return state;
-  }
-}

package/src/api/OpenWalletSession.ts

@@ -1,211 +0,0 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
-import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
-import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
-import { BaseMethod } from './BaseMethod';
-import { invalidParameter } from './helpers/filesystemValidation';
-
-import type {
-  OpenWalletSessionParams,
-  OpenWalletSessionPayload,
-} from '../types/api/openWalletSession';
-
-const requiredString = (value: unknown, name: string) => {
-  if (typeof value !== 'string' || !value.trim()) {
-    throw invalidParameter(`Parameter [${name}] must be a non-empty string.`);
-  }
-  return value.trim();
-};
-
-const optionalBoolean = (value: unknown, name: string) => {
-  if (value !== undefined && typeof value !== 'boolean') {
-    throw invalidParameter(`Parameter [${name}] must be a boolean.`);
-  }
-  return value;
-};
-
-const wasResumed = (session: unknown) =>
-  !!session &&
-  typeof session === 'object' &&
-  'resumed' in session &&
-  (session as { resumed?: unknown }).resumed === true;
-
-type NormalizedOpenWalletSessionParams = OpenWalletSessionParams & {
-  legacySessionToClear?: {
-    deviceId?: string;
-    passphraseState: string;
-  };
-};
-
-const normalizeParams = (payload: Record<string, unknown>): NormalizedOpenWalletSessionParams => {
-  if (payload.mode !== undefined) {
-    if (
-      payload.mode !== 'standard' &&
-      payload.mode !== 'select-hidden' &&
-      payload.mode !== 'resume-hidden'
-    ) {
-      throw invalidParameter(
-        'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
-      );
-    }
-    if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
-      throw invalidParameter(
-        'Parameters [useEmptyPassphrase] and [initSession] cannot be used with [mode].'
-      );
-    }
-    if (payload.mode === 'standard' || payload.mode === 'select-hidden') {
-      if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
-        throw invalidParameter(
-          'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
-        );
-      }
-      return { mode: payload.mode };
-    }
-    return {
-      mode: 'resume-hidden',
-      deviceId: requiredString(payload.deviceId, 'deviceId'),
-      passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-    };
-  }
-
-  const useEmptyPassphrase = optionalBoolean(payload.useEmptyPassphrase, 'useEmptyPassphrase');
-  const initSession = optionalBoolean(payload.initSession, 'initSession');
-  if (useEmptyPassphrase === true) {
-    return { mode: 'standard' };
-  }
-  if (initSession === true) {
-    const deviceId =
-      payload.deviceId === undefined ? undefined : requiredString(payload.deviceId, 'deviceId');
-    const passphraseState =
-      payload.passphraseState === undefined
-        ? undefined
-        : requiredString(payload.passphraseState, 'passphraseState');
-    return {
-      mode: 'select-hidden',
-      ...(passphraseState
-        ? {
-            legacySessionToClear: {
-              deviceId,
-              passphraseState,
-            },
-          }
-        : {}),
-    };
-  }
-
-  const hasWalletBinding = payload.deviceId !== undefined || payload.passphraseState !== undefined;
-  if (!hasWalletBinding) {
-    return { mode: 'select-hidden' };
-  }
-  return {
-    mode: 'resume-hidden',
-    deviceId: requiredString(payload.deviceId, 'deviceId'),
-    passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-  };
-};
-
-export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSessionParams> {
-  init() {
-    this.useDevicePassphraseState = false;
-    this.skipForceUpdateCheck = true;
-    this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
-    this.payload.useEmptyPassphrase = this.params.mode === 'standard';
-  }
-
-  async run(): Promise<OpenWalletSessionPayload> {
-    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
-    const currentDeviceId = state.identity.deviceId;
-    if (!currentDeviceId) {
-      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
-    }
-
-    const { legacySessionToClear } = this.params;
-    if (
-      legacySessionToClear &&
-      (!legacySessionToClear.deviceId || legacySessionToClear.deviceId === currentDeviceId)
-    ) {
-      deviceWalletSessionStore.delete(currentDeviceId, legacySessionToClear.passphraseState);
-    }
-
-    const protocol = this.device.isProtocolV2() ? 'V2' : 'V1';
-
-    if (this.params.mode === 'standard') {
-      this.device.passphraseState = undefined;
-      const session = this.device.isProtocolV2()
-        ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
-        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-            onlyMainPin: true,
-            initSession: this.payload.initSession,
-          });
-      if (session.unlockedAttachPin) {
-        try {
-          await this.device.lockDevice();
-        } catch {
-          // The wallet context is rejected even when an older device cannot be locked.
-        }
-        this.device.clearInternalState();
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
-      }
-      return {
-        protocol,
-        walletType: 'standard',
-        deviceId: currentDeviceId,
-        passphraseState: null,
-        resumed: wasResumed(session),
-      };
-    }
-
-    if (this.params.mode === 'resume-hidden') {
-      if (currentDeviceId !== this.params.deviceId) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-      }
-      this.device.passphraseState = this.params.passphraseState;
-      const cachedSessionId = deviceWalletSessionStore.get(
-        this.params.deviceId,
-        this.params.passphraseState
-      );
-      if (!cachedSessionId) {
-        throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
-      }
-      if (!this.device.isProtocolV2()) {
-        await this.device.initialize({
-          deviceId: this.params.deviceId,
-          passphraseState: this.params.passphraseState,
-        });
-      }
-      const session = this.device.isProtocolV2()
-        ? await getProtocolV2WalletSession(this.device, {
-            expectedPassphraseState: this.params.passphraseState,
-            recoverInvalidSession: false,
-          })
-        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-            expectPassphraseState: this.params.passphraseState,
-          });
-      if (!session.passphraseState) {
-        this.device.clearInternalState();
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
-      }
-      return {
-        protocol,
-        walletType: 'hidden',
-        deviceId: currentDeviceId,
-        passphraseState: session.passphraseState ?? null,
-        resumed: wasResumed(session) || session.newSession === cachedSessionId,
-      };
-    }
-
-    this.device.passphraseState = undefined;
-    const session = this.device.isProtocolV2()
-      ? await getProtocolV2WalletSession(this.device, { initSession: true })
-      : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
-    const walletType = session.passphraseState ? 'hidden' : 'standard';
-    return {
-      protocol,
-      walletType,
-      deviceId: currentDeviceId,
-      passphraseState: session.passphraseState ?? null,
-      resumed: wasResumed(session),
-    };
-  }
-}

package/src/api/PathInfo.ts

@@ -1,41 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-import {
-  validateOptionalNonNegativeInteger,
-  validateProtocolV2FilesystemPath,
-} from './helpers/filesystemValidation';
-
-export type PathInfoParams = {
-  path: string;
-  timeoutMs?: number | string;
-};
-
-export default class PathInfo extends BaseMethod<PathInfoParams> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = {
-      path: validateProtocolV2FilesystemPath(this.payload.path, 'path', {
-        allowVolumeRoot: true,
-      }),
-      timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
-    };
-  }
-
-  async run() {
-    const timeoutMs =
-      this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs);
-    const res = await this.device.commands.typedCall(
-      'FilesystemPathInfoQuery',
-      'FilesystemPathInfo',
-      {
-        path: this.params.path,
-      },
-      {
-        timeoutMs,
-      }
-    );
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/UploadPortfolio.ts

@@ -1,50 +0,0 @@
-import FileWrite from './FileWrite';
-
-export type UploadPortfolioParams = {
-  packageBytes: ArrayBuffer | Uint8Array | Blob;
-  operationId?: string;
-  timeoutMs?: number | string;
-};
-
-const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
-const PORTFOLIO_CHUNK_SIZE = 2048;
-const PORTFOLIO_RESPONSE_TIMEOUT_MS = 5_000;
-const PORTFOLIO_MAX_ABORT_LATENCY_MS = PORTFOLIO_RESPONSE_TIMEOUT_MS * 2 + 2_000;
-
-export default class UploadPortfolio extends FileWrite {
-  init() {
-    const { packageBytes, timeoutMs } = this.payload as UploadPortfolioParams;
-    const responseTimeoutMs = Math.min(
-      timeoutMs === undefined ? PORTFOLIO_RESPONSE_TIMEOUT_MS : Number(timeoutMs),
-      PORTFOLIO_RESPONSE_TIMEOUT_MS
-    );
-    this.payload = {
-      ...this.payload,
-      path: PORTFOLIO_PENDING_PATH,
-      offset: 0,
-      data: packageBytes,
-      chunkSize: PORTFOLIO_CHUNK_SIZE,
-      overwrite: true,
-      append: false,
-      emitProgress: false,
-      timeoutMs: responseTimeoutMs,
-    };
-    super.init();
-    this.executionPriority = 'background';
-    this.maxAbortLatencyMs = PORTFOLIO_MAX_ABORT_LATENCY_MS;
-    this.unlockPolicy = 'retry-on-locked';
-    // Portfolio is a background write/apply flow and never synthesizes UI events.
-    this.protocolV2UiMode = 'none';
-  }
-
-  async run() {
-    const stagedFile = await super.run();
-    this.throwIfAborted();
-    const timeoutMs = Number(this.params.timeoutMs);
-    await this.device.commands.typedCall('PortfolioUpdate', 'Success', {}, { timeoutMs });
-    return {
-      ...stagedFile,
-      portfolioUpdated: true,
-    };
-  }
-}

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