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

package/src/core/index.ts

@@ -1,5 +1,5 @@
 import semver from 'semver';
-import { EventEmitter } from 'events';
+import EventEmitter from 'events';
 import { DeviceSessionPinType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
@@ -75,7 +75,6 @@ import type {
   TransportDeviceDisconnectEvent,
 } from '@onekeyfe/hd-transport';
 import type { BaseMethod } from '../api/BaseMethod';
-import type { CoreMethodExtension } from '../api/methodExtension';
 
 const Log = getLogger(LoggerNames.Core);
 const PRE_INITIALIZE_TTL_MS = 60 * 1000;
@@ -87,11 +86,6 @@ const preWarmDoneAt = new Map<string, number>();
 
 export type CoreContext = ReturnType<Core['getCoreContext']>;
 
-export type CoreOptions = {
-  methodExtensions?: readonly CoreMethodExtension[];
-  allowDestructiveOperations?: boolean;
-};
-
 function hasDeriveCardano(method: BaseMethod): boolean {
   if (
     method.name.startsWith('allNetworkGetAddress') &&
@@ -162,10 +156,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   // find api method
   let method!: BaseMethod;
   try {
-    method = findMethod(message as IFrameCallMessage, {
-      extensions: context.methodExtensions,
-      allowDestructiveOperations: context.allowDestructiveOperations,
-    });
+    method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
     const shouldPostMessage = createUiProgressMessageFilter();
     method.postMessage = event => {
@@ -661,6 +652,12 @@ const onCallDevice = async (
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
       } catch (error) {
+        // Device.run may release the request before transport callbacks finish after a timeout.
+        // Ignore the stale callback because the caller already received the connection error.
+        if (!requestQueue.getTask(method.responseID)) {
+          Log.debug(`Call API - Ignore late inner method result`, error);
+          return;
+        }
         Log.debug(`Call API - Inner Method Run Error`, error);
         messageResponse = createResponseMessage(method.responseID, false, { error });
         requestQueue.resolveRequest(method.responseID, messageResponse);
@@ -1486,11 +1483,8 @@ export default class Core extends EventEmitter {
 
   private methodSynchronize = getSynchronize();
 
-  private readonly options: CoreOptions;
-
-  constructor(options: CoreOptions = {}) {
+  constructor() {
     super();
-    this.options = options;
     this.tracingContext = createSdkTracingContext();
     this.sdkInstanceId = this.tracingContext.sdkInstanceId;
     Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
@@ -1499,8 +1493,6 @@ export default class Core extends EventEmitter {
   private getCoreContext() {
     return {
       sdkInstanceId: this.sdkInstanceId,
-      methodExtensions: this.options.methodExtensions ?? [],
-      allowDestructiveOperations: this.options.allowDestructiveOperations === true,
       tracingContext: this.tracingContext,
       requestQueue: this.requestQueue,
       methodSynchronize: this.methodSynchronize,
@@ -1631,8 +1623,8 @@ export default class Core extends EventEmitter {
   }
 }
 
-export const initCore = (options?: CoreOptions) => {
-  const core = new Core(options);
+export const initCore = () => {
+  const core = new Core();
   _core = core;
   return core;
 };
@@ -1658,26 +1650,22 @@ const initTransport = (Transport: any, plugin?: LowlevelTransportSharedPlugin) =
 export const init = async (
   settings: ConnectSettings,
   Transport: any,
-  plugin?: LowlevelTransportSharedPlugin,
-  options?: CoreOptions
+  plugin?: LowlevelTransportSharedPlugin
 ) => {
   try {
-    try {
-      await DataManager.load(settings);
-      initTransport(Transport, plugin);
-    } catch {
-      Log.error('DataManager.load error');
-    }
+    await DataManager.load(settings);
+    initTransport(Transport, plugin);
     enableLog(DataManager.getSettings('debug'));
     if (DataManager.getSettings('env') !== 'react-native') {
       setLoggerPostMessage(postMessage);
     }
-    initCore(options);
+    initCore();
     initConnector();
 
     return _core;
   } catch (error) {
     Log.error('core init', error);
+    throw error;
   }
 };
 

package/src/data-manager/DataManager.ts

@@ -26,6 +26,7 @@ import type {
   Features,
   IDeviceBLEFirmwareStatus,
   IDeviceFirmwareStatus,
+  IProtocolV2Resources,
   ITransportStatus,
   IVersionArray,
   RemoteConfigResponse,
@@ -112,6 +113,8 @@ export default class DataManager {
 
   static lastCheckTimestamp = 0;
 
+  static protocolV2ResourcesConfigError: Error | undefined;
+
   static getFirmwareStatus = (
     features: Features,
     firmwareType: EFirmwareType
@@ -400,6 +403,7 @@ export default class DataManager {
 
   static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
+    this.protocolV2ResourcesConfigError = undefined;
     if (!settings.fetchConfig) {
       return false;
     }
@@ -446,9 +450,20 @@ export default class DataManager {
 
     // 3. Apply config if available
     if (data) {
-      const pro2Resources = parseProtocolV2Resources(
-        (data.pro2 as { resources?: unknown } | undefined)?.resources
-      );
+      let pro2Resources: IProtocolV2Resources | undefined;
+      try {
+        pro2Resources = parseProtocolV2Resources(
+          (data.pro2 as { resources?: unknown } | undefined)?.resources
+        );
+      } catch (error) {
+        // Firmware resource metadata is not required for base communication. If the
+        // remote config is temporarily incomplete, disable this resource update only.
+        this.protocolV2ResourcesConfigError =
+          error instanceof Error ? error : new Error(String(error));
+        Log.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
+      }
+      const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
+      const { resources: _unvalidatedResources, ...pro2Config } = enrichedPro2Config;
       Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
       this.deviceMap = {
         [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
@@ -458,7 +473,7 @@ export default class DataManager {
         [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
         [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
         [EDeviceType.Pro2]: {
-          ...this.enrichFirmwareReleaseInfo(data.pro2),
+          ...pro2Config,
           ...(pro2Resources ? { resources: pro2Resources } : undefined),
         },
       };
@@ -505,6 +520,12 @@ export default class DataManager {
         'Unable to refresh the latest remote config'
       );
     }
+    if (this.protocolV2ResourcesConfigError) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.NetworkError,
+        `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
+      );
+    }
     this.lastCheckTimestamp = getTimeStamp();
   }
 

package/src/data-manager/TransportManager.ts

@@ -121,6 +121,12 @@ export default class TransportManager {
   }
 
   static setTransport(TransportConstructor: any, plugin?: LowlevelTransportSharedPlugin) {
+    if (typeof TransportConstructor !== 'function') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportNotConfigured,
+        'Transport constructor is not available'
+      );
+    }
     const env = DataManager.getSettings('env');
     if (env === 'react-native') {
       /** Actually initializes the ReactNativeTransport */

package/src/device/DeviceCommands.ts

@@ -55,8 +55,10 @@ const DEVICE_SESSION_CALLS = new Set([
   'DeviceSessionAskPassphrase',
 ]);
 
-// Protocol V2 subcodes are domain-scoped, so cross-domain cancellation fallback
-// must use explicit firmware cancellation messages instead of a global number map.
+const PROTOCOL_V2_ACTION_CANCELLED_SUBCODE = 1;
+
+// Older Protocol V2 firmware may omit the cancellation subcode, so retain a
+// narrow message fallback for compatibility.
 const isProtocolV2ActionCancelledMessage = (message: string) =>
   /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
     message
@@ -499,6 +501,15 @@ export class DeviceCommands {
         const normalizedMessage = message?.trim() ?? '';
         const isProtocolV2ActionCancelledFailure =
           this.device.isProtocolV2() && isProtocolV2ActionCancelledMessage(normalizedMessage);
+        const isProtocolV2ActionCancelledSubcode =
+          this.device.isProtocolV2() && subcode === PROTOCOL_V2_ACTION_CANCELLED_SUBCODE;
+        // DeviceErrorCode currently reuses subcode 1 for Busy. Resolve that
+        // domain-specific exception before applying the common cancellation map.
+        const isProtocolV2DeviceBusyFailure =
+          this.device.isProtocolV2() &&
+          callType.startsWith('Device') &&
+          !DEVICE_SESSION_CALLS.has(callType) &&
+          subcode === DeviceErrorCode.DeviceError_Busy;
         const isLegacyProtocolV2LockedFailure =
           this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
         if (
@@ -556,8 +567,15 @@ export class DeviceCommands {
             subcode,
             firmwareMessage: message,
           });
+        } else if (isProtocolV2DeviceBusyFailure) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
         } else if (
           subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
+          isProtocolV2ActionCancelledSubcode ||
           isProtocolV2ActionCancelledFailure
         ) {
           error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled, message, {

package/src/device/DeviceConnector.ts

@@ -14,7 +14,7 @@ import type { OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/
 const Log = getLogger(LoggerNames.DeviceConnector);
 
 export default class DeviceConnector {
-  transport: Transport;
+  transport?: Transport;
 
   listenTimestamp = 0;
 
@@ -30,9 +30,21 @@ export default class DeviceConnector {
     DevicePool.setConnector(this);
   }
 
+  private getActiveTransport(): Transport {
+    const transport = this.transport ?? TransportManager.getTransport();
+    if (!transport) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportNotConfigured,
+        'Device connector was created before transport initialization'
+      );
+    }
+    this.transport = transport;
+    return transport;
+  }
+
   async enumerate() {
     try {
-      const descriptors = await this.transport.enumerate();
+      const descriptors = await this.getActiveTransport().enumerate();
       this.upcoming = descriptors;
       this._reportDevicesChange();
       return { descriptors } as DeviceDescriptorDiff;
@@ -50,11 +62,10 @@ export default class DeviceConnector {
     let descriptors: DeviceDescriptor[];
 
     try {
+      const transport = this.getActiveTransport();
       Log.debug('Start listening', current);
       this.listenTimestamp = new Date().getTime();
-      descriptors = waitForEvent
-        ? await this.transport.listen(current)
-        : await this.transport.enumerate();
+      descriptors = waitForEvent ? await transport.listen(current) : await transport.enumerate();
       if (!this.listening) return; // do not continue if stop() was called
 
       this.upcoming = descriptors;
@@ -88,16 +99,17 @@ export default class DeviceConnector {
     Log.debug('acquire', path, session, expectedProtocol, protocolHint);
     const env = DataManager.getSettings('env');
     try {
+      const transport = this.getActiveTransport();
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await this.transport.acquire({
+        res = await transport.acquire({
           uuid: path,
           forceCleanRunPromise,
           expectedProtocol,
           protocolHint,
         });
       } else {
-        res = await this.transport.acquire({
+        res = await transport.acquire({
           path,
           previous: session ?? null,
           expectedProtocol,
@@ -105,7 +117,13 @@ export default class DeviceConnector {
         });
       }
       if (expectedProtocol) {
-        const detectedProtocol = this.transport.getProtocolType(path);
+        // The acquire response is the stable snapshot from this active probe. A delayed
+        // disconnect from an older generation may clear caches, so do not rely on cache alone.
+        const acquiredProtocol =
+          typeof res === 'object' && res !== null
+            ? (res as DeviceDescriptor).protocolType
+            : undefined;
+        const detectedProtocol = acquiredProtocol ?? transport.getProtocolType(path);
         if (detectedProtocol !== expectedProtocol) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
@@ -122,7 +140,7 @@ export default class DeviceConnector {
 
   async release(session: string, onclose: boolean) {
     try {
-      const res = await this.transport.release(session, onclose);
+      const res = await this.getActiveTransport().release(session, onclose);
       return res;
     } catch (error) {
       safeThrowError(error);
@@ -131,8 +149,9 @@ export default class DeviceConnector {
 
   async disconnect(session: string | undefined | null) {
     try {
-      if (this.transport.disconnect && !!session) {
-        await this.transport.disconnect(session);
+      const transport = this.getActiveTransport();
+      if (transport.disconnect && !!session) {
+        await transport.disconnect(session);
       }
     } catch (error) {
       safeThrowError(error);
@@ -140,10 +159,11 @@ export default class DeviceConnector {
   }
 
   promptDeviceAccess(): Promise<USBDevice | BluetoothDevice | null> {
-    if (!this.transport.promptDeviceAccess) {
+    const transport = this.getActiveTransport();
+    if (!transport.promptDeviceAccess) {
       return Promise.resolve(null);
     }
-    return this.transport.promptDeviceAccess();
+    return transport.promptDeviceAccess();
   }
 
   _reportDevicesChange() {

package/src/index.ts

@@ -10,11 +10,6 @@ export type { LowLevelCoreApi, LowLevelInjectApi } from './lowLevelInject';
 export type { TopLevelInjectApi } from './topLevelInject';
 
 export { default as Core, init as initCore, switchTransport } from './core';
-export type { CoreOptions } from './core';
-export { factoryApiMethodExtension, testApiMethodExtension } from './api/methodExtension';
-export type { CoreMethodConstructor, CoreMethodExtension } from './api/methodExtension';
-export { FACTORY_API_METHOD_NAMES, TEST_API_METHOD_NAMES } from './api/extensionMethodNames';
-export { createFactoryApi, createTestApi } from './inject';
 
 export * from './constants';
 export * from './utils';

package/src/inject.ts

@@ -1,10 +1,8 @@
-import { FACTORY_API_METHOD_NAMES, TEST_API_METHOD_NAMES } from './api/extensionMethodNames';
-
 import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type { Unsuccessful } from './types';
 import type { EventEmitter } from 'events';
 import type { CallMethod } from './events';
-import type { CoreApi, FactoryApi, TestApi, TestApiMethods } from './types/api';
+import type { CoreApi } from './types/api';
 import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
 
 type CallbackFunction = (data?: any, error?: Unsuccessful) => void;
@@ -133,7 +131,10 @@ export const inject = ({
   return api;
 };
 
-type ApiControlMethodName =
+export const createCoreApi = (
+  call: CoreApi['call']
+): Omit<
+  CoreApi,
   | 'on'
   | 'off'
   | 'emit'
@@ -145,11 +146,8 @@ type ApiControlMethodName =
   | 'uiResponse'
   | 'cancel'
   | 'updateSettings'
-  | 'switchTransport';
-
-type InjectedApi<TApi> = Omit<TApi, ApiControlMethodName>;
-
-const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
+  | 'switchTransport'
+> => ({
   getLogs: () => call({ method: 'getLogs' }),
   clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**
@@ -217,16 +215,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
   deviceReboot: (connectId, params) => call({ ...params, connectId, method: 'deviceReboot' }),
   deviceGetOnboardingStatus: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
-  deviceProvisionFactoryInfo: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceProvisionFactoryInfo' }),
-  deviceReadFactoryInfo: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceReadFactoryInfo' }),
-  deviceWriteFactoryCertificate: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceWriteFactoryCertificate' }),
-  deviceReadFactoryCertificate: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceReadFactoryCertificate' }),
-  deviceSignFactoryChallenge: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSignFactoryChallenge' }),
   deviceUploadWallpaper: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceUploadWallpaper' }),
   deviceUploadNft: (connectId, params) => call({ ...params, connectId, method: 'deviceUploadNft' }),
@@ -297,19 +285,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
   evmVerifyMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'evmVerifyMessage' }),
 
-  evmGetAddressTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmGetAddressTrezor' }),
-  evmGetPublicKeyTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmGetPublicKeyTrezor' }),
-  evmSignMessageTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmSignMessageTrezor' }),
-  evmSignTransactionTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmSignTransactionTrezor' }),
-  evmSignTypedDataTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmSignTypedDataTrezor' }),
-  evmVerifyMessageTrezor: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'evmVerifyMessageTrezor' }),
-
   btcGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcGetAddress' }),
   btcGetPublicKey: (connectId, deviceId, params) =>
@@ -322,25 +297,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
     call({ ...params, connectId, deviceId, method: 'btcSignTransaction' }),
   btcVerifyMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcVerifyMessage' }),
-  btcGetOwnershipId: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'btcGetOwnershipId' }),
-  btcGetOwnershipProof: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'btcGetOwnershipProof' }),
-  btcAuthorizeCoinJoin: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'btcAuthorizeCoinJoin' }),
-
-  cryptoBatchGetPublickeys: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoBatchGetPublickeys' }),
-  cryptoCipherKeyValue: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoCipherKeyValue' }),
-  cryptoCosiCommit: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoCosiCommit' }),
-  cryptoCosiSign: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoCosiSign' }),
-  cryptoGetECDHSessionKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoGetECDHSessionKey' }),
-  cryptoSignIdentity: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'cryptoSignIdentity' }),
 
   starcoinGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'starcoinGetAddress' }),
@@ -357,8 +313,6 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
     call({ ...params, connectId, deviceId, method: 'nemGetAddress' }),
   nemSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'nemSignTransaction' }),
-  nemDecryptMessage: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'nemDecryptMessage' }),
 
   solGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'solGetAddress' }),
@@ -524,164 +478,8 @@ const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
   benfenSignMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'benfenSignMessage' }),
 
-  /**
-   * Test-only APIs.
-   */
-  tezosGetAddress: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'tezosGetAddress' }),
-  tezosGetPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'tezosGetPublicKey' }),
-  tezosSignTx: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'tezosSignTx' }),
-
-  binanceGetAddress: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'binanceGetAddress' }),
-  binanceGetPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'binanceGetPublicKey' }),
-  binanceSignTx: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'binanceSignTx' }),
-
-  moneroGetWatchKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'moneroGetWatchKey' }),
-  moneroGetAddress: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'moneroGetAddress' }),
-
-  eosGetPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'eosGetPublicKey' }),
-  eosSignTx: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'eosSignTx' }),
-
-  webAuthnAddResidentCredential: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'webAuthnAddResidentCredential' }),
-  webAuthnListResidentCredentials: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'webAuthnListResidentCredentials' }),
-  webAuthnRemoveResidentCredential: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'webAuthnRemoveResidentCredential' }),
-
-  getPublicKeyMultiple: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'getPublicKeyMultiple' }),
-  listResDir: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'listResDir' }),
-  nftWriteData: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'nftWriteData' }),
-  nftWriteInfo: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'nftWriteInfo' }),
-  readSEPublicKey: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'readSEPublicKey' }),
-  resourceUpdate: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'resourceUpdate' }),
-
-  bixinBackupDevice: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinBackupDevice' }),
-  bixinLoadDevice: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinLoadDevice' }),
-  bixinMessageSE: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinMessageSE' }),
-  bixinVerifyDeviceRequest: (connectId, deviceId, params) =>
-    call({ ...params, connectId, deviceId, method: 'bixinVerifyDeviceRequest' }),
-
-  deviceSpiFlashWrite: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSpiFlashWrite' }),
-  deviceSpiFlashRead: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSpiFlashRead' }),
-  deviceInfoSettings: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceInfoSettings' }),
-  deviceGetInfo: (connectId, params) => call({ ...params, connectId, method: 'deviceGetInfo' }),
-  deviceReadSEPublicCert: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceReadSEPublicCert' }),
-  deviceWriteSEPrivateKey: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceWriteSEPrivateKey' }),
-  deviceWriteSEPublicCert: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceWriteSEPublicCert' }),
-  deviceSESignMessage: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSESignMessage' }),
-  deviceGetFirmwareHash: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceGetFirmwareHash' }),
-  deviceUnlockPath: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceUnlockPath' }),
-  devicePing: (connectId, params) => call({ ...params, connectId, method: 'devicePing' }),
-  deviceGetEntropy: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceGetEntropy' }),
-  deviceSdProtect: (connectId, params) => call({ ...params, connectId, method: 'deviceSdProtect' }),
-  deviceChangeWipeCode: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceChangeWipeCode' }),
-  deviceEndSession: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceEndSession' }),
-  deviceLoad: (connectId, params) => call({ ...params, connectId, method: 'deviceLoad' }),
-  deviceDoPreauthorized: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceDoPreauthorized' }),
-  deviceCancelAuthorization: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceCancelAuthorization' }),
-
-  emmcDirList: (connectId, params) => call({ ...params, connectId, method: 'emmcDirList' }),
-  emmcDirMake: (connectId, params) => call({ ...params, connectId, method: 'emmcDirMake' }),
-  emmcDirRemove: (connectId, params) => call({ ...params, connectId, method: 'emmcDirRemove' }),
-  emmcFileDelete: (connectId, params) => call({ ...params, connectId, method: 'emmcFileDelete' }),
-  emmcFileRead: (connectId, params) => call({ ...params, connectId, method: 'emmcFileRead' }),
-  emmcFileWrite: (connectId, params) => call({ ...params, connectId, method: 'emmcFileWrite' }),
-  emmcFixPermission: (connectId, params) =>
-    call({ ...params, connectId, method: 'emmcFixPermission' }),
-  emmcPathInfo: (connectId, params) => call({ ...params, connectId, method: 'emmcPathInfo' }),
-
-  debugLinkDecision: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkDecision' }),
-  debugLinkEraseSdCard: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkEraseSdCard' }),
-  debugLinkFlashErase: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkFlashErase' }),
-  debugLinkGetState: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkGetState' }),
-  debugLinkMemoryRead: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkMemoryRead' }),
-  debugLinkMemoryWrite: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkMemoryWrite' }),
-  debugLinkRecordScreen: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkRecordScreen' }),
-  debugLinkReseedRandom: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkReseedRandom' }),
-  debugLinkStop: (connectId, params) => call({ ...params, connectId, method: 'debugLinkStop' }),
-  debugLinkWatchLayout: (connectId, params) =>
-    call({ ...params, connectId, method: 'debugLinkWatchLayout' }),
-
-  firmwareEraseEx: (connectId, params) => call({ ...params, connectId, method: 'firmwareEraseEx' }),
-  firmwareErase: (connectId, params) => call({ ...params, connectId, method: 'firmwareErase' }),
-  firmwareUpdateEmmcTest: (connectId, params) =>
-    call({ ...params, connectId, method: 'firmwareUpdateEmmcTest' }),
-  firmwareUploadTest: (connectId, params) =>
-    call({ ...params, connectId, method: 'firmwareUploadTest' }),
-  reboot: (connectId, params) => call({ ...params, connectId, method: 'reboot' }),
-  selfTest: (connectId, params) => call({ ...params, connectId, method: 'selfTest' }),
-
   neoGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'neoGetAddress' }),
   neoSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'neoSignTransaction' }),
 });
-
-const pickApiMethods = <TApi extends object>(
-  api: InjectedApi<TestApi>,
-  methodNames: readonly string[]
-): TApi => {
-  const selected: Record<string, unknown> = {};
-  methodNames.forEach(methodName => {
-    selected[methodName] = api[methodName as keyof typeof api];
-  });
-  return selected as TApi;
-};
-
-export const createCoreApi = (call: CoreApi['call']): InjectedApi<CoreApi> => {
-  const api = createAllCoreApi(call);
-  const extensionMethodNames = new Set<string>([
-    ...TEST_API_METHOD_NAMES,
-    ...FACTORY_API_METHOD_NAMES,
-  ]);
-  return Object.fromEntries(
-    Object.entries(api).filter(([methodName]) => !extensionMethodNames.has(methodName))
-  ) as InjectedApi<CoreApi>;
-};
-
-export const createTestApi = (call: CoreApi['call']): TestApiMethods =>
-  pickApiMethods<TestApiMethods>(createAllCoreApi(call), TEST_API_METHOD_NAMES);
-
-export const createFactoryApi = (call: CoreApi['call']): FactoryApi =>
-  pickApiMethods<FactoryApi>(createAllCoreApi(call), FACTORY_API_METHOD_NAMES);