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

package/dist/utils/pro2Wallpaper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pro2Wallpaper.d.ts","sourceRoot":"","sources":["../../src/utils/pro2Wallpaper.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,MAAM,MAAM,wBAAwB,GAAG,QAAQ,GAAG,UAAU,CAAC;AA8B7D,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;CAChC,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,wBAAwB,CAAA;CAAE,CAkE9D"}

package/src/api/ClearSessionCache.ts

@@ -1,28 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
-
-import type { ClearSessionCacheParams } from '../types/api/sessionCache';
-
-export default class ClearSessionCache extends BaseMethod<ClearSessionCacheParams> {
-  init() {
-    this.useDevice = false;
-    this.useDevicePassphraseState = false;
-    this.skipForceUpdateCheck = true;
-    this.params = {
-      deviceId: this.payload.deviceId,
-      passphraseState: this.payload.passphraseState,
-    };
-  }
-
-  run() {
-    const { deviceId, passphraseState } = this.params;
-    if (!deviceId) {
-      deviceWalletSessionStore.clear();
-    } else if (!passphraseState) {
-      deviceWalletSessionStore.deleteDevice(deviceId);
-    } else {
-      deviceWalletSessionStore.delete(deviceId, passphraseState);
-    }
-    return Promise.resolve({ cleared: true as const });
-  }
-}

package/src/api/DirList.ts

@@ -1,33 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-import {
-  validateOptionalNonNegativeInteger,
-  validateProtocolV2FilesystemPath,
-} from './helpers/filesystemValidation';
-
-export type DirListParams = {
-  path: string;
-  depth?: number;
-};
-
-export default class DirList extends BaseMethod<DirListParams> {
-  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,
-      }),
-      depth: validateOptionalNonNegativeInteger(this.payload.depth, 'depth'),
-    };
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('FilesystemDirList', 'FilesystemDir', {
-      path: this.params.path,
-      depth: this.params.depth,
-    });
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/DirMake.ts

@@ -1,23 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
-
-export type DirMakeParams = {
-  path: string;
-};
-
-export default class DirMake extends BaseMethod<DirMakeParams> {
-  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') };
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('FilesystemDirMake', 'Success', {
-      path: this.params.path,
-    });
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/DirRemove.ts

@@ -1,23 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
-
-export type DirRemoveParams = {
-  path: string;
-};
-
-export default class DirRemove extends BaseMethod<DirRemoveParams> {
-  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') };
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('FilesystemDirRemove', 'Success', {
-      path: this.params.path,
-    });
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/FileDelete.ts

@@ -1,23 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
-
-export type FileDeleteParams = {
-  path: string;
-};
-
-export default class FileDelete extends BaseMethod<FileDeleteParams> {
-  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') };
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('FilesystemFileDelete', 'Success', {
-      path: this.params.path,
-    });
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/FileRead.ts

@@ -1,183 +0,0 @@
-import {
-  PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
-  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
-} from '@onekeyfe/hd-transport';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { BaseMethod } from './BaseMethod';
-import {
-  validateNonNegativeInteger,
-  validateOptionalNonNegativeInteger,
-  validateOptionalPercentage,
-  validateProtocolV2FilesystemPath,
-} from './helpers/filesystemValidation';
-import { hexToBytes, isHexString, stripHexPrefix } from './helpers/hexUtils';
-import { DataManager } from '../data-manager';
-
-export type FileReadParams = {
-  path: string;
-  offset?: number;
-  totalSize?: number;
-  chunkLen?: number;
-  uiPercentage?: number;
-};
-
-const MIN_FILE_READ_CHUNK_SIZE = 64;
-
-function getProtocolV2FileReadChunkLimit() {
-  const env = DataManager.getSettings('env');
-  if (env && DataManager.isBleConnect(env)) {
-    return PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
-  }
-  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
-}
-
-function normalizeChunkSize(value: unknown, maxChunkSize: number): number {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric) || numeric <= 0) return maxChunkSize;
-  return Math.min(Math.max(Math.floor(numeric), MIN_FILE_READ_CHUNK_SIZE), maxChunkSize);
-}
-
-function toFiniteNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string') {
-    const numeric = Number(value);
-    return Number.isFinite(numeric) ? numeric : undefined;
-  }
-  if (value && typeof value === 'object') {
-    const longLike = value as { toNumber?: () => number };
-    if (typeof longLike.toNumber === 'function') {
-      const numeric = longLike.toNumber();
-      return Number.isFinite(numeric) ? numeric : undefined;
-    }
-  }
-  return undefined;
-}
-
-function toUint8Array(value: unknown): Uint8Array {
-  if (value instanceof Uint8Array) return value;
-  if (value instanceof ArrayBuffer) return new Uint8Array(value);
-  if (ArrayBuffer.isView(value)) {
-    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  }
-  if (typeof value === 'string') {
-    const hex = stripHexPrefix(value);
-    if (!hex) return new Uint8Array(0);
-    if (!isHexString(hex) || hex.length % 2 !== 0) return new Uint8Array(0);
-    return hexToBytes(hex);
-  }
-  return new Uint8Array(0);
-}
-
-function getDeviceTransferProgress(
-  bytesBeforeChunk: number,
-  bytesAfterChunk: number,
-  totalBytes: number
-) {
-  if (!Number.isFinite(totalBytes) || totalBytes <= 0) {
-    return 100;
-  }
-  if (bytesBeforeChunk <= 0 && bytesAfterChunk < totalBytes) {
-    return 0;
-  }
-  if (bytesAfterChunk >= totalBytes) {
-    return 100;
-  }
-  return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
-}
-
-export default class FileRead extends BaseMethod<FileReadParams> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    const path = validateProtocolV2FilesystemPath(this.payload.path, 'path');
-    this.params = {
-      path,
-      offset: validateNonNegativeInteger(this.payload.offset, 'offset', 0),
-      totalSize: validateNonNegativeInteger(this.payload.totalSize, 'totalSize', 0),
-      chunkLen: validateOptionalNonNegativeInteger(this.payload.chunkLen, 'chunkLen'),
-      uiPercentage: validateOptionalPercentage(this.payload.uiPercentage, 'uiPercentage'),
-    };
-  }
-
-  async run() {
-    const startOffset = this.params.offset ?? 0;
-    const requestedLength = Number(this.params.totalSize);
-    const chunkSize = normalizeChunkSize(this.params.chunkLen, getProtocolV2FileReadChunkLimit());
-    let totalLength = Number.isFinite(requestedLength) && requestedLength > 0 ? requestedLength : 0;
-
-    if (totalLength === 0) {
-      const pathInfoRes = await this.device.commands.typedCall(
-        'FilesystemPathInfoQuery',
-        'FilesystemPathInfo',
-        {
-          path: this.params.path,
-        }
-      );
-      const fileSize = toFiniteNumber(pathInfoRes.message?.size);
-      if (!pathInfoRes.message?.exist || pathInfoRes.message?.directory) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `FilesystemFileRead path is not a file: ${this.params.path}`
-        );
-      }
-      if (fileSize === undefined || fileSize < startOffset) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `FilesystemFileRead invalid offset ${startOffset} for ${this.params.path}`
-        );
-      }
-      totalLength = fileSize - startOffset;
-    }
-
-    const chunks: Uint8Array[] = [];
-    let read = 0;
-    let lastMessage: Record<string, unknown> | undefined;
-
-    while (read < totalLength) {
-      const readLen = Math.min(chunkSize, totalLength - read);
-      const offset = startOffset + read;
-      const progress =
-        this.params.uiPercentage ?? getDeviceTransferProgress(read, read + readLen, totalLength);
-      const res = await this.device.commands.typedCall('FilesystemFileRead', 'FilesystemFile', {
-        file: {
-          path: this.params.path,
-          offset,
-          total_size: 0,
-        },
-        chunk_len: readLen,
-        ui_percentage: progress,
-      });
-      const data = toUint8Array(res.message?.data);
-      lastMessage = res.message;
-
-      if (data.byteLength === 0) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `FilesystemFileRead received empty data at offset ${offset}`
-        );
-      }
-
-      chunks.push(data);
-      read += data.byteLength;
-    }
-
-    const combined = new Uint8Array(read);
-    let cursor = 0;
-    chunks.forEach(chunk => {
-      combined.set(chunk, cursor);
-      cursor += chunk.byteLength;
-    });
-
-    return Promise.resolve({
-      ...lastMessage,
-      path: this.params.path,
-      offset: startOffset,
-      total_size: totalLength,
-      data: combined,
-      chunks: chunks.length,
-    });
-  }
-}

package/src/api/FileWrite.ts

@@ -1,71 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-import {
-  validateNonNegativeInteger,
-  validateOptionalNonNegativeInteger,
-  validateOptionalPercentage,
-  validateProtocolV2FilesystemPath,
-  validateRequiredData,
-} from './helpers/filesystemValidation';
-import { writeProtocolV2File } from './helpers/protocolV2FileWrite';
-import { UI_REQUEST, createUiMessage } from '../events/ui-request';
-
-export type FileWriteParams = {
-  path: string;
-  offset?: number;
-  totalSize?: number;
-  data: ArrayBuffer | Uint8Array | Blob | string;
-  chunkSize?: number;
-  chunkLen?: number;
-  overwrite?: boolean;
-  append?: boolean;
-  emitProgress?: boolean;
-  uiPercentage?: number;
-  timeoutMs?: number | string;
-};
-
-export default class FileWrite extends BaseMethod<FileWriteParams> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    validateRequiredData(this.payload.data, 'data');
-    const path = validateProtocolV2FilesystemPath(this.payload.path, 'path');
-    const offset = validateNonNegativeInteger(this.payload.offset, 'offset', 0);
-    this.params = {
-      path,
-      offset,
-      totalSize: validateNonNegativeInteger(this.payload.totalSize, 'totalSize', 0),
-      data: this.payload.data,
-      chunkSize: validateOptionalNonNegativeInteger(this.payload.chunkSize, 'chunkSize'),
-      chunkLen: validateOptionalNonNegativeInteger(this.payload.chunkLen, 'chunkLen'),
-      overwrite: this.payload.overwrite ?? offset === 0,
-      append: this.payload.append ?? false,
-      emitProgress: this.payload.emitProgress ?? true,
-      uiPercentage: validateOptionalPercentage(this.payload.uiPercentage, 'uiPercentage'),
-      timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
-    };
-  }
-
-  async run() {
-    return writeProtocolV2File({
-      commands: this.device.commands,
-      path: this.params.path,
-      data: this.params.data,
-      offset: this.params.offset,
-      totalSize: this.params.totalSize,
-      chunkSize: this.params.chunkSize,
-      chunkLen: this.params.chunkLen,
-      overwrite: this.params.overwrite,
-      append: this.params.append,
-      uiPercentage: this.params.uiPercentage,
-      timeoutMs: this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs),
-      throwIfAborted: () => this.throwIfAborted(),
-      onProgress: payload => {
-        if (this.params.emitProgress && typeof this.postMessage === 'function') {
-          this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, payload));
-        }
-      },
-    });
-  }
-}