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

package/src/api/helpers/protocolV2FileWrite.ts

@@ -1,193 +0,0 @@
-import {
-  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
-  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
-} from '@onekeyfe/hd-transport';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { DataManager } from '../../data-manager';
-
-import type { DeviceCommands } from '../../device/DeviceCommands';
-
-export type ProtocolV2FileWriteData = ArrayBuffer | Uint8Array | Blob | string;
-
-export type ProtocolV2FileWriteProgress = {
-  progress: number;
-  transferredBytes: number;
-  totalBytes: number;
-  rateBytesPerSecond?: number;
-  elapsedMs: number;
-};
-
-export type ProtocolV2FileWriteOptions = {
-  commands: Pick<DeviceCommands, 'typedCall'>;
-  path: string;
-  data: ProtocolV2FileWriteData;
-  offset?: number;
-  totalSize?: number;
-  chunkSize?: number;
-  chunkLen?: number;
-  overwrite?: boolean;
-  append?: boolean;
-  uiPercentage?: number;
-  timeoutMs?: number;
-  maxChunkRetries?: number;
-  throwIfAborted?: () => void;
-  onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
-};
-
-const MIN_FILE_CHUNK_SIZE = 64;
-
-function isRetryableFileWriteTimeout(error: unknown) {
-  if (!error || typeof error !== 'object') return false;
-  const candidate = error as { errorCode?: number; code?: number; message?: string };
-  const code = candidate.errorCode ?? candidate.code;
-  return (
-    code === HardwareErrorCode.BleTimeoutError ||
-    /Lowlevel response timeout/i.test(candidate.message ?? '')
-  );
-}
-
-function getProtocolV2FileChunkLimit() {
-  const env = DataManager.getSettings('env');
-  return env && DataManager.isBleConnect(env)
-    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
-}
-
-async function dataToUint8Array(data: ProtocolV2FileWriteData): Promise<Uint8Array> {
-  if (typeof data === 'string') return new TextEncoder().encode(data);
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  if (typeof Blob !== 'undefined' && data instanceof Blob) {
-    return new Uint8Array(await data.arrayBuffer());
-  }
-  throw ERRORS.TypedError(
-    HardwareErrorCode.CallMethodInvalidParameter,
-    'Unsupported FilesystemFileWrite data'
-  );
-}
-
-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_CHUNK_SIZE), maxChunkSize);
-}
-
-function getDeviceTransferProgress(before: number, after: number, total: number) {
-  if (!Number.isFinite(total) || total <= 0) return 100;
-  if (before <= 0 && after < total) return 0;
-  if (after >= total) return 100;
-  return Math.min(Math.max(Math.ceil((after / total) * 100), 1), 99);
-}
-
-function getConfirmedProgress(processed: number, total: number, written: number, length: number) {
-  if (Number.isFinite(processed) && Number.isFinite(total) && total > 0) {
-    if (processed >= total) return 100;
-    return Math.min(Math.max(Math.floor((processed / total) * 100), 0), 99);
-  }
-  if (length > 0) return written >= length ? 100 : Math.floor((written / length) * 100);
-  return 100;
-}
-
-export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
-  options.throwIfAborted?.();
-  const data = await dataToUint8Array(options.data);
-  const dataLength = data.byteLength;
-  const startOffset =
-    Number.isFinite(options.offset) && Number(options.offset) > 0 ? Number(options.offset) : 0;
-  const totalSize =
-    Number.isFinite(options.totalSize) && Number(options.totalSize) > 0
-      ? Number(options.totalSize)
-      : startOffset + dataLength;
-
-  if (totalSize < startOffset + dataLength) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${
-        startOffset + dataLength
-      }`
-    );
-  }
-
-  const chunkSize = normalizeChunkSize(
-    options.chunkSize ?? options.chunkLen,
-    getProtocolV2FileChunkLimit()
-  );
-  let written = 0;
-  let chunks = 0;
-  let lastMessage: Record<string, unknown> | undefined;
-  const startTime = Date.now();
-
-  while (written < dataLength) {
-    options.throwIfAborted?.();
-    const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
-    const offset = startOffset + written;
-    const progress =
-      options.uiPercentage ??
-      getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
-    const request = {
-      file: { path: options.path, offset, total_size: totalSize, data: chunk },
-      overwrite: chunks === 0 ? options.overwrite ?? false : false,
-      append: options.append ?? false,
-      ui_percentage: progress,
-    };
-    const maxChunkRetries = Math.max(Math.floor(options.maxChunkRetries ?? 0), 0);
-    let retryCount = 0;
-    let response;
-    let isWritePending = true;
-    while (isWritePending) {
-      try {
-        response = await options.commands.typedCall(
-          'FilesystemFileWrite',
-          'FilesystemFile',
-          request,
-          { timeoutMs: options.timeoutMs }
-        );
-        isWritePending = false;
-      } catch (error) {
-        if (retryCount >= maxChunkRetries || !isRetryableFileWriteTimeout(error)) throw error;
-        retryCount += 1;
-        options.throwIfAborted?.();
-      }
-    }
-    options.throwIfAborted?.();
-    lastMessage = response.message;
-    const rawProcessedByte = response.message?.processed_byte;
-    const processedByte = Number(rawProcessedByte);
-    if (
-      rawProcessedByte !== undefined &&
-      (!Number.isFinite(processedByte) ||
-        processedByte <= offset ||
-        processedByte > offset + chunk.byteLength)
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `FilesystemFileWrite invalid processed_byte ${processedByte}`
-      );
-    }
-    written =
-      rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
-    chunks += 1;
-    const elapsedMs = Date.now() - startTime;
-    const transferredBytes = Math.min(written, dataLength);
-    options.onProgress?.({
-      progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-      transferredBytes,
-      totalBytes: dataLength,
-      rateBytesPerSecond:
-        elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
-      elapsedMs,
-    });
-  }
-
-  return {
-    ...lastMessage,
-    path: options.path,
-    offset: startOffset,
-    total_size: totalSize,
-    processed_byte: startOffset + written,
-    chunks,
-  };
-}

package/src/api/protocol-v2/DeviceFactoryInfoGet.ts

@@ -1,20 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-
-export default class DeviceFactoryInfoGet extends BaseMethod {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = undefined;
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall(
-      'DeviceFactoryInfoGet',
-      'DeviceFactoryInfo',
-      {}
-    );
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/protocol-v2/DeviceFactoryInfoSet.ts

@@ -1,32 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-
-import type { DeviceFactoryInfoSetParams } from './helpers';
-
-export default class DeviceFactoryInfoSet extends BaseMethod<DeviceFactoryInfoSetParams> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = {
-      version: this.payload.version,
-      serial_number: this.payload.serial_number,
-      burn_in_completed: this.payload.burn_in_completed,
-      factory_test_completed: this.payload.factory_test_completed,
-      manufacture_time: this.payload.manufacture_time,
-    };
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('DeviceFactoryInfoSet', 'Success', {
-      info: {
-        version: this.params.version,
-        serial_number: this.params.serial_number,
-        burn_in_completed: this.params.burn_in_completed,
-        factory_test_completed: this.params.factory_test_completed,
-        manufacture_time: this.params.manufacture_time,
-      },
-    });
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/protocol-v2/DeviceFirmwareUpdate.ts

@@ -1,61 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-import {
-  PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
-  PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
-  isProtocolV2DeviceDisconnectedError,
-  normalizeFirmwareTargets,
-} from './helpers';
-import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
-
-import type { KnownDevice } from '../../types';
-import type { MessageFromOneKey } from '@onekeyfe/hd-transport';
-import type { DeviceFirmwareUpdateParams } from './helpers';
-
-export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdateParams> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = {
-      targets: this.payload.targets,
-      targetId: this.payload.targetId,
-      target_id: this.payload.target_id,
-      path: this.payload.path,
-    };
-  }
-
-  async run() {
-    const targets = normalizeFirmwareTargets(this.params);
-    try {
-      const res = await this.device.commands.typedCall(
-        'DeviceFirmwareUpdateRequest',
-        PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
-        {
-          targets,
-        },
-        {
-          ...PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
-          onIntermediateResponse: (response: MessageFromOneKey) => {
-            if (response.type !== 'DeviceFirmwareUpdateStatus') return;
-            this.postMessage(
-              createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-                device: this.device.toMessageObject() as KnownDevice,
-                progress: 99,
-                progressType: 'installingFirmware',
-              })
-            );
-          },
-        }
-      );
-      return res.message;
-    } catch (error) {
-      if (isProtocolV2DeviceDisconnectedError(error)) {
-        return {
-          message: 'Device firmware update started',
-        };
-      }
-      throw error;
-    }
-  }
-}

package/src/api/protocol-v2/DeviceGetFirmwareUpdateStatus.ts

@@ -1,55 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-import { invalidParameter } from '../helpers/filesystemValidation';
-
-import type { DeviceFirmwareUpdateStatusGetParams } from './helpers';
-import type { DeviceFirmwareUpdateRecordFields } from '@onekeyfe/hd-transport';
-
-const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = ['status', 'payload_version', 'path'] as const;
-
-function normalizeStatusFields(
-  fields: DeviceFirmwareUpdateStatusGetParams['fields']
-): DeviceFirmwareUpdateRecordFields | undefined {
-  if (fields === undefined || fields === null) return undefined;
-  if (typeof fields !== 'object' || Array.isArray(fields)) {
-    throw invalidParameter('Parameter [fields] must be an object.');
-  }
-
-  const unknownField = Object.keys(fields).find(
-    field => !DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS.includes(field as any)
-  );
-  if (unknownField) {
-    throw invalidParameter(`Unsupported firmware update status field: ${unknownField}`);
-  }
-
-  const normalized: DeviceFirmwareUpdateRecordFields = {};
-  for (const field of DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS) {
-    const value = fields[field];
-    if (value !== undefined) {
-      if (typeof value !== 'boolean') {
-        throw invalidParameter(`Parameter [fields.${field}] must be a boolean.`);
-      }
-      normalized[field] = value;
-    }
-  }
-  return normalized;
-}
-
-export default class DeviceGetFirmwareUpdateStatus extends BaseMethod<DeviceFirmwareUpdateStatusGetParams> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    const fields = normalizeStatusFields(this.payload.fields);
-    this.params = fields ? { fields } : {};
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall(
-      'DeviceFirmwareUpdateStatusGet',
-      'DeviceFirmwareUpdateStatus',
-      this.params
-    );
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/protocol-v2/DeviceGetOnboardingStatus.ts

@@ -1,18 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-
-export default class DeviceGetOnboardingStatus extends BaseMethod {
-  init() {
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-  }
-
-  async run() {
-    const { message } = await this.device.commands.typedCall(
-      'DevGetOnboardingStatus',
-      'DevOnboardingStatus',
-      {}
-    );
-    return message;
-  }
-}

package/src/api/protocol-v2/DeviceInfoGet.ts

@@ -1,145 +0,0 @@
-import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
-
-import { UI_REQUEST } from '../../constants/ui-request';
-import { PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS } from '../../protocols/protocol-v2';
-import { BaseMethod } from '../BaseMethod';
-import { invalidParameter } from '../helpers/filesystemValidation';
-
-export type DeviceInfoGetTargets = {
-  hw?: boolean;
-  fw?: boolean;
-  coprocessor?: boolean;
-  se1?: boolean;
-  se2?: boolean;
-  se3?: boolean;
-  se4?: boolean;
-};
-
-export type DeviceInfoGetTypes = {
-  version?: boolean;
-  build_id?: boolean;
-  hash?: boolean;
-  specific?: boolean;
-};
-
-export type DeviceInfoGetParams = {
-  targets?: DeviceInfoGetTargets;
-  types?: DeviceInfoGetTypes;
-};
-
-const TARGET_KEYS: (keyof DeviceInfoGetTargets)[] = [
-  'hw',
-  'fw',
-  'coprocessor',
-  'se1',
-  'se2',
-  'se3',
-  'se4',
-];
-
-const TYPE_KEYS: (keyof DeviceInfoGetTypes)[] = ['version', 'build_id', 'hash', 'specific'];
-
-const DEFAULT_TARGETS: DeviceInfoGetTargets = {
-  hw: true,
-  fw: true,
-  coprocessor: true,
-};
-
-const DEFAULT_TYPES: DeviceInfoGetTypes = {
-  version: true,
-  specific: true,
-};
-
-function pickBooleanKeys<T extends Record<string, boolean | undefined>>(
-  value: unknown,
-  keys: (keyof T)[]
-): T | undefined {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  const source = value as Record<string, unknown>;
-  const result = {} as T;
-  let hasKey = false;
-  for (const key of keys) {
-    if (source[key as string]) {
-      result[key] = true as T[keyof T];
-      hasKey = true;
-    }
-  }
-  return hasKey ? result : undefined;
-}
-
-function assertKnownKeys(value: unknown, keys: string[], name: string) {
-  if (value == null) return;
-  if (typeof value !== 'object' || Array.isArray(value)) {
-    throw invalidParameter(`Parameter [${name}] must be an object.`);
-  }
-  const allowed = new Set(keys);
-  const unknownKeys = Object.keys(value).filter(key => !allowed.has(key));
-  if (unknownKeys.length > 0) {
-    throw invalidParameter(
-      `Parameter [${name}] contains unsupported key(s): ${unknownKeys.join(', ')}.`
-    );
-  }
-}
-
-function normalizeTargets(value: unknown): DeviceInfoGetTargets | undefined {
-  assertKnownKeys(
-    value,
-    TARGET_KEYS.map(key => String(key)),
-    'targets'
-  );
-  return pickBooleanKeys<DeviceInfoGetTargets>(value, TARGET_KEYS);
-}
-
-function normalizeTypes(value: unknown): DeviceInfoGetTypes | undefined {
-  assertKnownKeys(
-    value,
-    TYPE_KEYS.map(key => String(key)),
-    'types'
-  );
-  return pickBooleanKeys<DeviceInfoGetTypes>(value, TYPE_KEYS);
-}
-
-/**
- * Raw DeviceInfoGet command for Protocol V2 only.
- *
- * The SDK builds targets/types on demand and returns the raw DeviceInfo message.
- * This command is internal; integrations should use getDeviceState.
- */
-export default class DeviceInfoGet extends BaseMethod<{
-  targets: DeviceInfoGetTargets;
-  types: DeviceInfoGetTypes;
-}> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.unlockPolicy = 'none';
-    this.allowDeviceMode = [
-      ...this.allowDeviceMode,
-      UI_REQUEST.NOT_INITIALIZE,
-      UI_REQUEST.BOOTLOADER,
-    ];
-    this.useDevicePassphraseState = false;
-    this.skipForceUpdateCheck = true;
-    this.params = {
-      targets: normalizeTargets(this.payload.targets) ?? DEFAULT_TARGETS,
-      types: normalizeTypes(this.payload.types) ?? DEFAULT_TYPES,
-    };
-  }
-
-  async run() {
-    if (!this.device.isProtocolV2()) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
-
-    const res = await this.device.commands.typedCall(
-      'DeviceInfoGet',
-      'DeviceInfo',
-      {
-        targets: this.params.targets,
-        types: this.params.types,
-      },
-      { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }
-    );
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/protocol-v2/DeviceReboot.ts

@@ -1,26 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-import { normalizeRebootType } from './helpers';
-
-import type { DeviceRebootParams } from './helpers';
-
-export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
-  init() {
-    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
-    this.requireProtocolV2 = true;
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = {
-      rebootType: this.payload.rebootType,
-      reboot_type: this.payload.reboot_type,
-    };
-  }
-
-  async run() {
-    const rebootType = normalizeRebootType(this.params.reboot_type ?? this.params.rebootType);
-    const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
-      reboot_type: rebootType,
-    });
-    this.device.markProtocolV2Reboot(rebootType);
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/protocol-v2/DeviceSessionOpen.ts

@@ -1,102 +0,0 @@
-import { assertCompleteDeviceSession } from '../../protocols/protocol-v2/deviceSession';
-import { BaseMethod } from '../BaseMethod';
-import { invalidParameter } from '../helpers/filesystemValidation';
-
-import type {
-  DeviceAttachPinOnDevice,
-  DeviceHostPassphrase,
-  DevicePassphraseOnDevice,
-  DeviceSessionResume,
-} from '@onekeyfe/hd-transport';
-
-type HiddenWalletSelection =
-  | {
-      host_passphrase: DeviceHostPassphrase;
-      passphrase_on_device?: never;
-      attach_pin_on_device?: never;
-    }
-  | {
-      host_passphrase?: never;
-      passphrase_on_device: DevicePassphraseOnDevice;
-      attach_pin_on_device?: never;
-    }
-  | {
-      host_passphrase?: never;
-      passphrase_on_device?: never;
-      attach_pin_on_device: DeviceAttachPinOnDevice;
-    };
-
-export type DeviceSessionOpenParams =
-  | { resume: DeviceSessionResume; select?: never }
-  | { resume?: never; select: HiddenWalletSelection };
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  !!value && typeof value === 'object' && !Array.isArray(value);
-
-const normalizeParams = (payload: Record<string, unknown>): DeviceSessionOpenParams => {
-  const hasResume = payload.resume !== undefined;
-  const hasSelect = payload.select !== undefined;
-  if (hasResume === hasSelect) {
-    throw invalidParameter('DeviceSessionOpen requires exactly one of [resume] or [select].');
-  }
-
-  if (hasResume) {
-    if (!isRecord(payload.resume) || typeof payload.resume.session_id !== 'string') {
-      throw invalidParameter('Parameter [resume.session_id] must be a non-empty string.');
-    }
-    const sessionId = payload.resume.session_id.trim();
-    if (!sessionId) {
-      throw invalidParameter('Parameter [resume.session_id] must be a non-empty string.');
-    }
-    return { resume: { session_id: sessionId } };
-  }
-
-  if (!isRecord(payload.select)) {
-    throw invalidParameter('Parameter [select] must be a hidden-wallet selection object.');
-  }
-  const { select } = payload;
-  const accessKeys = ['host_passphrase', 'passphrase_on_device', 'attach_pin_on_device'] as const;
-  const selected = accessKeys.filter(key => select[key] !== undefined);
-  const unknown = Object.keys(select).filter(
-    key => !accessKeys.includes(key as (typeof accessKeys)[number])
-  );
-  if (unknown.length > 0 || selected.length !== 1) {
-    throw invalidParameter('Parameter [select] requires exactly one hidden-wallet access mode.');
-  }
-
-  if (selected[0] === 'host_passphrase') {
-    const host = select.host_passphrase;
-    if (!isRecord(host) || typeof host.passphrase !== 'string') {
-      throw invalidParameter('Parameter [select.host_passphrase.passphrase] is required.');
-    }
-    const passphrase = host.passphrase.normalize('NFKD');
-    if (!passphrase || passphrase.includes('\0') || passphrase.length > 50) {
-      throw invalidParameter('Parameter [select.host_passphrase.passphrase] is invalid.');
-    }
-    return { select: { host_passphrase: { passphrase } } };
-  }
-
-  if (selected[0] === 'passphrase_on_device') {
-    return { select: { passphrase_on_device: {} } };
-  }
-  return { select: { attach_pin_on_device: {} } };
-};
-
-export default class DeviceSessionOpen extends BaseMethod<DeviceSessionOpenParams> {
-  init() {
-    this.requireProtocolV2 = true;
-    this.useDevicePassphraseState = false;
-    this.skipForceUpdateCheck = true;
-    this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
-  }
-
-  async run() {
-    const { message } = await this.device.commands.typedCall(
-      'DeviceSessionOpen',
-      'DeviceSession',
-      this.params
-    );
-    assertCompleteDeviceSession(message);
-    return message;
-  }
-}

package/src/api/protocol-v2/DeviceSettingsGet.ts

@@ -1,18 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-import { mapDeviceSettingsToState } from '../../device/DeviceStateMapper';
-
-export default class DeviceSettingsGet extends BaseMethod {
-  init() {
-    this.requireProtocolV2 = true;
-    this.unlockPolicy = 'none';
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = undefined;
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('DeviceSettingsGet', 'DeviceSettings', {});
-    this.device.updateState(mapDeviceSettingsToState(res.message), 'apply-settings');
-    return Promise.resolve(res.message);
-  }
-}