@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.58

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -15,6 +15,7 @@ import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
 
 import type {
+  FirmwareProgress,
   IFirmwareUpdateProgressType,
   IFirmwareUpdateTipMessage,
 } from '../../events/ui-request';
@@ -28,6 +29,11 @@ const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 
+type FirmwareTransferMetrics = Pick<
+  FirmwareProgress['payload'],
+  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+>;
+
 const isDeviceDisconnectedError = (error: unknown) => {
   const message = error instanceof Error ? error.message : String(error ?? '');
   return (
@@ -82,12 +88,17 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @description Post the progress message
    * @param progress Post the percentage of the progress
    */
-  postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
+  postProgressMessage = (
+    progress: number,
+    progressType: IFirmwareUpdateProgressType,
+    metrics?: FirmwareTransferMetrics
+  ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
         progress,
         progressType,
+        ...metrics,
       })
     );
   };

package/src/api/helpers/protocolV2FileWrite.ts

@@ -5,9 +5,12 @@ import {
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { DataManager } from '../../data-manager';
+import { LoggerNames, getLogger } from '../../utils/logger';
 
 import type { DeviceCommands } from '../../device/DeviceCommands';
 
+const Log = getLogger(LoggerNames.Method);
+
 export type ProtocolV2FileWriteData = ArrayBuffer | Uint8Array | Blob | string;
 
 export type ProtocolV2FileWriteProgress = {
@@ -18,6 +21,12 @@ export type ProtocolV2FileWriteProgress = {
   elapsedMs: number;
 };
 
+export type ProtocolV2FileWriteChunkContext = {
+  offset: number;
+  chunkLength: number;
+  totalSize: number;
+};
+
 export type ProtocolV2FileWriteOptions = {
   commands: Pick<DeviceCommands, 'typedCall'>;
   path: string;
@@ -30,14 +39,54 @@ export type ProtocolV2FileWriteOptions = {
   append?: boolean;
   uiPercentage?: number;
   timeoutMs?: number;
+  writeWithResponse?: boolean;
   maxChunkRetries?: number;
   paceMs?: number;
   throwIfAborted?: () => void;
+  getUiPercentage?: (context: ProtocolV2FileWriteChunkContext) => number | undefined;
   onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
 };
 
 const MIN_FILE_CHUNK_SIZE = 64;
 const FILE_TRANSFER_RATE_WINDOW_MS = 1000;
+const FILE_TRANSFER_LOG_INTERVAL_MS = 10_000;
+const SESSION_ERROR = 'session not found';
+
+function formatFileTransferRate(bytesPerSecond: number) {
+  return (Math.max(bytesPerSecond, 0) / 1024).toFixed(2);
+}
+
+function getAverageFileTransferRate(transferredBytes: number, elapsedMs: number) {
+  if (elapsedMs <= 0) return 0;
+  return Math.round((Math.max(transferredBytes, 0) / elapsedMs) * 1000);
+}
+
+function getFileTransferTransport() {
+  const env = DataManager.getSettings('env');
+  return env && DataManager.isBleConnect(env) ? 'BLE' : String(env ?? 'unknown');
+}
+
+function logFileTransferMetrics({
+  transport,
+  status,
+  transferredBytes,
+  totalBytes,
+  elapsedMs,
+  rateBytesPerSecond,
+}: {
+  transport: string;
+  status: 'progress' | 'completed' | 'failed';
+  transferredBytes: number;
+  totalBytes: number;
+  elapsedMs: number;
+  rateBytesPerSecond: number;
+}) {
+  Log.log(
+    `[FileWrite] metrics transport=${transport} status=${status} bytes=${transferredBytes}/${totalBytes} elapsed=${(
+      elapsedMs / 1000
+    ).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s`
+  );
+}
 
 export function isProtocolV2ResponseTimeout(error: unknown) {
   if (!error || typeof error !== 'object') return false;
@@ -125,89 +174,159 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
   let rateWindowStartedAt = startTime;
   let rateWindowStartedBytes = 0;
   let rateBytesPerSecond: number | undefined;
+  let lastConfirmedAt = startTime;
+  let logWindowStartedAt = startTime;
+  let logWindowStartedBytes = 0;
+  const transport = getFileTransferTransport();
 
-  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 }
+  try {
+    while (written < dataLength) {
+      options.throwIfAborted?.();
+      const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
+      const offset = startOffset + written;
+      const progress =
+        options.uiPercentage ??
+        options.getUiPercentage?.({
+          offset,
+          chunkLength: chunk.byteLength,
+          totalSize,
+        }) ??
+        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 {
+          const callOptions =
+            options.writeWithResponse === undefined
+              ? { timeoutMs: options.timeoutMs }
+              : {
+                  ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                  writeWithResponse: options.writeWithResponse,
+                };
+          response = await options.commands.typedCall(
+            'FilesystemFileWrite',
+            'FilesystemFile',
+            request,
+            callOptions
+          );
+          isWritePending = false;
+        } catch (error) {
+          if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
+          retryCount += 1;
+          options.throwIfAborted?.();
+        }
+      }
+      if (!response) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'FilesystemFileWrite completed without a response'
         );
-        isWritePending = false;
-      } catch (error) {
-        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
-        retryCount += 1;
-        options.throwIfAborted?.();
+      }
+      const responseType = (response as { type?: string }).type;
+      if (responseType && responseType !== 'FilesystemFile') {
+        const responseError = (response as { message?: { error?: unknown } }).message?.error;
+        if (typeof responseError === 'string' && responseError.includes(SESSION_ERROR)) {
+          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
+        }
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileWrite received unexpected response ${responseType}`
+        );
+      }
+      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 now = Date.now();
+      lastConfirmedAt = now;
+      const elapsedMs = now - startTime;
+      const transferredBytes = Math.min(written, dataLength);
+      const rateWindowElapsedMs = now - rateWindowStartedAt;
+      if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
+        const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
+        rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
+        rateWindowStartedAt = now;
+        rateWindowStartedBytes = transferredBytes;
+      } else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
+        rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
+      }
+      options.onProgress?.({
+        progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
+        transferredBytes,
+        totalBytes: dataLength,
+        rateBytesPerSecond,
+        elapsedMs,
+      });
+      const logWindowElapsedMs = now - logWindowStartedAt;
+      if (logWindowElapsedMs >= FILE_TRANSFER_LOG_INTERVAL_MS && transferredBytes < dataLength) {
+        const logWindowBytes = Math.max(transferredBytes - logWindowStartedBytes, 0);
+        logFileTransferMetrics({
+          transport,
+          status: 'progress',
+          transferredBytes,
+          totalBytes: dataLength,
+          elapsedMs,
+          rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+        });
+        logWindowStartedAt = now;
+        logWindowStartedBytes = transferredBytes;
+      }
+      if (options.paceMs && options.paceMs > 0) {
+        await new Promise(resolve => {
+          setTimeout(resolve, options.paceMs);
+        });
       }
     }
-    if (!response) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'FilesystemFileWrite completed without a response'
-      );
-    }
-    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;
+  } catch (error) {
     const now = Date.now();
-    const elapsedMs = now - startTime;
-    const transferredBytes = Math.min(written, dataLength);
-    const rateWindowElapsedMs = now - rateWindowStartedAt;
-    if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
-      const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
-      rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
-      rateWindowStartedAt = now;
-      rateWindowStartedBytes = transferredBytes;
-    } else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
-      rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
-    }
-    options.onProgress?.({
-      progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-      transferredBytes,
+    const elapsedMs = Math.max(now - startTime, 0);
+    const logWindowElapsedMs = Math.max(now - logWindowStartedAt, 0);
+    const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+    logFileTransferMetrics({
+      transport,
+      status: 'failed',
+      transferredBytes: written,
       totalBytes: dataLength,
-      rateBytesPerSecond,
       elapsedMs,
+      rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
     });
-    if (options.paceMs && options.paceMs > 0) {
-      await new Promise(resolve => {
-        setTimeout(resolve, options.paceMs);
-      });
-    }
+    throw error;
   }
 
+  const elapsedMs = Math.max(lastConfirmedAt - startTime, 0);
+  const logWindowElapsedMs = Math.max(lastConfirmedAt - logWindowStartedAt, 0);
+  const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+  logFileTransferMetrics({
+    transport,
+    status: 'completed',
+    transferredBytes: written,
+    totalBytes: dataLength,
+    elapsedMs,
+    rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+  });
+
   return {
     ...lastMessage,
     path: options.path,

package/src/api/index.ts

@@ -49,9 +49,6 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 // Pro2 business API
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
-export { default as deviceReadFactoryInfo } from './protocol-v2/DeviceFactoryInfoGet';
-export { default as deviceReadFactoryCertificate } from './protocol-v2/DeviceFactoryCertificateRead';
-export { default as deviceSignFactoryChallenge } from './protocol-v2/DeviceFactoryChallengeSign';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
 export { default as deviceUploadNft } from './protocol-v2/DeviceUploadNft';
 export { default as uploadPortfolio } from './UploadPortfolio';

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

@@ -1,5 +1,4 @@
 import { BaseMethod } from '../BaseMethod';
-import { UI_REQUEST } from '../../constants/ui-request';
 
 export default class DeviceFactoryInfoGet extends BaseMethod {
   getSupportedProtocols() {
@@ -10,8 +9,6 @@ export default class DeviceFactoryInfoGet extends BaseMethod {
     // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.unlockPolicy = 'none';
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
     this.params = undefined;
   }
 

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

@@ -1,6 +1,4 @@
 import { BaseMethod } from '../BaseMethod';
-import { UI_REQUEST } from '../../constants/ui-request';
-import { validateDeviceFactoryInfoSetParams } from './helpers';
 
 import type { DeviceFactoryInfoSetParams } from './helpers';
 
@@ -13,10 +11,13 @@ export default class DeviceFactoryInfoSet extends BaseMethod<DeviceFactoryInfoSe
     // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.unlockPolicy = 'none';
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
-    this.params = validateDeviceFactoryInfoSetParams(this.payload);
+    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() {

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

@@ -37,11 +37,11 @@ export type DeviceFirmwareUpdateStatusGetParams = {
 };
 
 export type DeviceFactoryInfoSetParams = {
-  version: number;
-  serial_number: string;
-  burn_in_completed: boolean;
-  factory_test_completed: boolean;
-  manufacture_time: {
+  version?: number;
+  serial_number?: string;
+  burn_in_completed?: boolean;
+  factory_test_completed?: boolean;
+  manufacture_time?: {
     year: number;
     month: number;
     day: number;
@@ -51,153 +51,6 @@ export type DeviceFactoryInfoSetParams = {
   };
 };
 
-export type DeviceFactoryCertificateWriteParams = {
-  certificate: string;
-  privateKey?: string;
-};
-
-export type DeviceFactoryChallengeSignParams = {
-  digest: string;
-};
-
-const FACTORY_SERIAL_MAX_UTF8_BYTES = 24;
-const FACTORY_CERTIFICATE_MAX_BYTES = 512;
-const FACTORY_PRIVATE_KEY_BYTES = 32;
-const FACTORY_CHALLENGE_DIGEST_BYTES = 32;
-
-const getUtf8ByteLength = (value: string) =>
-  Array.from(value).reduce((length, character) => {
-    const codePoint = character.codePointAt(0) ?? 0;
-    if (codePoint <= 0x7f) return length + 1;
-    if (codePoint <= 0x7ff) return length + 2;
-    if (codePoint <= 0xffff) return length + 3;
-    return length + 4;
-  }, 0);
-
-const validateRequiredBoolean = (value: unknown, name: string): boolean => {
-  if (typeof value !== 'boolean') {
-    throw invalidParameter(`Parameter [${name}] is required and must be a boolean.`);
-  }
-  return value;
-};
-
-const validateIntegerInRange = (
-  value: unknown,
-  name: string,
-  minimum: number,
-  maximum: number
-): number => {
-  if (
-    typeof value !== 'number' ||
-    !Number.isSafeInteger(value) ||
-    value < minimum ||
-    value > maximum
-  ) {
-    throw invalidParameter(
-      `Parameter [${name}] must be an integer between ${minimum} and ${maximum}.`
-    );
-  }
-  return value;
-};
-
-const validateHexBytes = (
-  value: unknown,
-  name: string,
-  options: { exactBytes?: number; maxBytes?: number }
-): string => {
-  const hex = validateNonEmptyString(value, name).trim();
-  if (!/^(?:[0-9a-fA-F]{2})+$/.test(hex)) {
-    throw invalidParameter(`Parameter [${name}] must be an even-length hexadecimal string.`);
-  }
-  const byteLength = hex.length / 2;
-  if (options.exactBytes !== undefined && byteLength !== options.exactBytes) {
-    throw invalidParameter(`Parameter [${name}] must contain exactly ${options.exactBytes} bytes.`);
-  }
-  if (options.maxBytes !== undefined && byteLength > options.maxBytes) {
-    throw invalidParameter(`Parameter [${name}] must not exceed ${options.maxBytes} bytes.`);
-  }
-  return hex;
-};
-
-export function validateDeviceFactoryInfoSetParams(
-  payload: Partial<DeviceFactoryInfoSetParams>
-): DeviceFactoryInfoSetParams {
-  const serialNumber = validateNonEmptyString(payload.serial_number, 'serial_number').trim();
-  if (getUtf8ByteLength(serialNumber) > FACTORY_SERIAL_MAX_UTF8_BYTES) {
-    throw invalidParameter(
-      `Parameter [serial_number] must not exceed ${FACTORY_SERIAL_MAX_UTF8_BYTES} UTF-8 bytes.`
-    );
-  }
-
-  const time = payload.manufacture_time;
-  if (!time || typeof time !== 'object') {
-    throw invalidParameter('Parameter [manufacture_time] is required.');
-  }
-  const manufactureTime = {
-    year: validateIntegerInRange(time.year, 'manufacture_time.year', 2000, 9999),
-    month: validateIntegerInRange(time.month, 'manufacture_time.month', 1, 12),
-    day: validateIntegerInRange(time.day, 'manufacture_time.day', 1, 31),
-    hour: validateIntegerInRange(time.hour, 'manufacture_time.hour', 0, 23),
-    minute: validateIntegerInRange(time.minute, 'manufacture_time.minute', 0, 59),
-    second: validateIntegerInRange(time.second, 'manufacture_time.second', 0, 59),
-  };
-  const normalizedDate = new Date(
-    Date.UTC(
-      manufactureTime.year,
-      manufactureTime.month - 1,
-      manufactureTime.day,
-      manufactureTime.hour,
-      manufactureTime.minute,
-      manufactureTime.second
-    )
-  );
-  if (
-    normalizedDate.getUTCFullYear() !== manufactureTime.year ||
-    normalizedDate.getUTCMonth() + 1 !== manufactureTime.month ||
-    normalizedDate.getUTCDate() !== manufactureTime.day
-  ) {
-    throw invalidParameter('Parameter [manufacture_time] must be a valid calendar date.');
-  }
-
-  return {
-    version: validateIntegerInRange(payload.version, 'version', 0, 255),
-    serial_number: serialNumber,
-    burn_in_completed: validateRequiredBoolean(payload.burn_in_completed, 'burn_in_completed'),
-    factory_test_completed: validateRequiredBoolean(
-      payload.factory_test_completed,
-      'factory_test_completed'
-    ),
-    manufacture_time: manufactureTime,
-  };
-}
-
-export function validateDeviceFactoryCertificateWriteParams(
-  payload: Partial<DeviceFactoryCertificateWriteParams>
-): DeviceFactoryCertificateWriteParams {
-  return {
-    certificate: validateHexBytes(payload.certificate, 'certificate', {
-      maxBytes: FACTORY_CERTIFICATE_MAX_BYTES,
-    }),
-    ...(payload.privateKey === undefined
-      ? {}
-      : {
-          privateKey: validateHexBytes(payload.privateKey, 'privateKey', {
-            exactBytes: FACTORY_PRIVATE_KEY_BYTES,
-          }),
-        }),
-  };
-}
-
-export function validateDeviceFactoryChallengeSignParams(
-  payload: Partial<DeviceFactoryChallengeSignParams>
-): DeviceFactoryChallengeSignParams {
-  return {
-    digest: validateHexBytes(payload.digest, 'digest', {
-      exactBytes: FACTORY_CHALLENGE_DIGEST_BYTES,
-    }),
-  };
-}
-
 const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
   Normal: DeviceRebootType.Normal,
   normal: DeviceRebootType.Normal,

package/src/api/utils.ts

@@ -3,47 +3,13 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import * as ApiMethods from './index';
 
 import type { BaseMethod } from './BaseMethod';
-import type { CoreMethodExtension } from './methodExtension';
 import type { IFrameCallMessage } from '../events';
 
 type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => BaseMethod<any>;
 
 const publicMethodRegistry = ApiMethods as unknown as Record<string, MethodConstructor>;
 
-export type FindMethodOptions = {
-  extensions?: readonly CoreMethodExtension[];
-  allowDestructiveOperations?: boolean;
-};
-
-const findExtensionMethod = (
-  method: string,
-  extensions: readonly CoreMethodExtension[]
-): { constructor: MethodConstructor; destructive: boolean } | undefined => {
-  let match: { constructor: MethodConstructor; destructive: boolean } | undefined;
-
-  for (const extension of extensions) {
-    const constructor = extension.methods[method];
-    if (constructor) {
-      if (match) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.CallMethodInvalidParameter,
-          `Method ${method} is registered by multiple extensions`
-        );
-      }
-      match = {
-        constructor,
-        destructive: extension.destructiveMethods?.includes(method) === true,
-      };
-    }
-  }
-
-  return match;
-};
-
-export function findMethod(
-  message: IFrameCallMessage & { id?: number },
-  options: FindMethodOptions = {}
-): BaseMethod<any> {
+export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
   const { method } = message.payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
@@ -54,17 +20,6 @@ export function findMethod(
     return new MethodConstructor(message);
   }
 
-  const extensionMethod = findExtensionMethod(method, options.extensions ?? []);
-  if (extensionMethod) {
-    if (extensionMethod.destructive && options.allowDestructiveOperations !== true) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodInvalidParameter,
-        `Destructive method ${method} requires allowDestructiveOperations`
-      );
-    }
-    return new extensionMethod.constructor(message);
-  }
-
   throw ERRORS.TypedError(
     HardwareErrorCode.CallMethodInvalidParameter,
     `Method ${method} is not set`