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

package/src/api/tezos/TezosGetPublicKey.ts

@@ -0,0 +1,63 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { TezosGetPublicKey as HardwareTezosGetPublicKey } from '@onekeyfe/hd-transport';
+
+export default class TezosGetPublicKey extends BaseMethod<HardwareTezosGetPublicKey[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: any) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  async run() {
+    const responses: any[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('TezosGetPublicKey', 'TezosPublicKey', {
+        ...param,
+      });
+
+      const { public_key } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        public_key,
+      };
+      responses.push(result);
+
+      this.postPreviousAddressMessage(result);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/tezos/TezosSignTx.ts

@@ -0,0 +1,44 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { TezosSignTx as HardwareTezosSignTx } from '@onekeyfe/hd-transport';
+
+export default class TezosSignTx extends BaseMethod<HardwareTezosSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { path } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      branch: new Uint8Array(4),
+      reveal: this.payload.reveal,
+      transaction: this.payload.transaction,
+      origination: this.payload.origination,
+      delegation: this.payload.delegation,
+      proposal: this.payload.proposal,
+      ballot: this.payload.ballot,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('TezosSignTx', 'TezosSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/utils.ts

@@ -3,13 +3,47 @@ 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 function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
+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> {
   const { method } = message.payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
@@ -20,6 +54,17 @@ export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMe
     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`

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,6 +75,7 @@ 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;
@@ -86,6 +87,11 @@ 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') &&
@@ -156,7 +162,10 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   // find api method
   let method!: BaseMethod;
   try {
-    method = findMethod(message as IFrameCallMessage);
+    method = findMethod(message as IFrameCallMessage, {
+      extensions: context.methodExtensions,
+      allowDestructiveOperations: context.allowDestructiveOperations,
+    });
     method.connector = _connector;
     const shouldPostMessage = createUiProgressMessageFilter();
     method.postMessage = event => {
@@ -1477,8 +1486,11 @@ export default class Core extends EventEmitter {
 
   private methodSynchronize = getSynchronize();
 
-  constructor() {
+  private readonly options: CoreOptions;
+
+  constructor(options: CoreOptions = {}) {
     super();
+    this.options = options;
     this.tracingContext = createSdkTracingContext();
     this.sdkInstanceId = this.tracingContext.sdkInstanceId;
     Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
@@ -1487,6 +1499,8 @@ 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,
@@ -1617,8 +1631,8 @@ export default class Core extends EventEmitter {
   }
 }
 
-export const initCore = () => {
-  const core = new Core();
+export const initCore = (options?: CoreOptions) => {
+  const core = new Core(options);
   _core = core;
   return core;
 };
@@ -1644,7 +1658,8 @@ const initTransport = (Transport: any, plugin?: LowlevelTransportSharedPlugin) =
 export const init = async (
   settings: ConnectSettings,
   Transport: any,
-  plugin?: LowlevelTransportSharedPlugin
+  plugin?: LowlevelTransportSharedPlugin,
+  options?: CoreOptions
 ) => {
   try {
     try {
@@ -1657,7 +1672,7 @@ export const init = async (
     if (DataManager.getSettings('env') !== 'react-native') {
       setLoggerPostMessage(postMessage);
     }
-    initCore();
+    initCore(options);
     initConnector();
 
     return _core;

package/src/index.ts

@@ -10,6 +10,11 @@ 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,8 +1,10 @@
+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 } from './types/api';
+import type { CoreApi, FactoryApi, TestApi, TestApiMethods } from './types/api';
 import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
 
 type CallbackFunction = (data?: any, error?: Unsuccessful) => void;
@@ -131,10 +133,7 @@ export const inject = ({
   return api;
 };
 
-export const createCoreApi = (
-  call: CoreApi['call']
-): Omit<
-  CoreApi,
+type ApiControlMethodName =
   | 'on'
   | 'off'
   | 'emit'
@@ -146,8 +145,11 @@ export const createCoreApi = (
   | 'uiResponse'
   | 'cancel'
   | 'updateSettings'
-  | 'switchTransport'
-> => ({
+  | 'switchTransport';
+
+type InjectedApi<TApi> = Omit<TApi, ApiControlMethodName>;
+
+const createAllCoreApi = (call: CoreApi['call']): InjectedApi<TestApi> => ({
   getLogs: () => call({ method: 'getLogs' }),
   clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**
@@ -215,6 +217,16 @@ export const createCoreApi = (
   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' }),
@@ -285,6 +297,19 @@ export const createCoreApi = (
   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) =>
@@ -297,6 +322,25 @@ export const createCoreApi = (
     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' }),
@@ -313,6 +357,8 @@ export const createCoreApi = (
     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' }),
@@ -478,8 +524,164 @@ export const createCoreApi = (
   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);

package/src/types/api/binanceGetAddress.ts

@@ -0,0 +1,17 @@
+import type { BinanceAddress as HardwareBinanceAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TezosAddress = {
+  path: string;
+} & HardwareBinanceAddress;
+
+export type BinanceAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function binanceGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BinanceAddressParams
+): Response<TezosAddress>;

package/src/types/api/binanceGetPublicKey.ts

@@ -0,0 +1,17 @@
+import type { BinancePublicKey as HardwareBinancePublicKey } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TezosPublicKey = {
+  path: string;
+} & HardwareBinancePublicKey;
+
+export type BinanceGetPublicKeyParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function binanceGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BinanceGetPublicKeyParams
+): Response<TezosPublicKey>;

package/src/types/api/binanceSignTx.ts

@@ -0,0 +1,15 @@
+import type {
+  BinanceSignedTx,
+  BinanceSignTx as HardwareBinanceSignTx,
+} from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type BinanceSignTxParams = {
+  path: string | number[];
+} & Omit<HardwareBinanceSignTx, 'address_n'>;
+
+export declare function binanceSignTx(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BinanceSignTxParams
+): Response<BinanceSignedTx>;

package/src/types/api/bixinBackupDevice.ts

@@ -0,0 +1,8 @@
+import type { Success } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export declare function bixinBackupDevice(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams
+): Response<Success>;

package/src/types/api/bixinLoadDevice.ts

@@ -0,0 +1,8 @@
+import type { BixinLoadDevice, Success } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export declare function bixinLoadDevice(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BixinLoadDevice
+): Response<Success>;

package/src/types/api/bixinMessageSE.ts

@@ -0,0 +1,8 @@
+import type { BixinMessageSE, BixinOutMessageSE } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export declare function bixinMessageSE(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BixinMessageSE
+): Response<BixinOutMessageSE>;

package/src/types/api/bixinVerifyDeviceRequest.ts

@@ -0,0 +1,8 @@
+import type { BixinVerifyDeviceAck, BixinVerifyDeviceRequest } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export declare function bixinVerifyDeviceRequest(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BixinVerifyDeviceRequest
+): Response<BixinVerifyDeviceAck>;

package/src/types/api/btcAuthorizeCoinJoin.ts

@@ -0,0 +1,18 @@
+import type { InputScriptType, OwnershipProof } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type BTCAuthorizeCoinJoin = {
+  path: string | number[];
+  coin?: string;
+  scriptType?: InputScriptType;
+  coordinator: string;
+  max_total_fee: number;
+  fee_per_anonymity?: number;
+  amount_unit?: number;
+};
+
+export declare function btcAuthorizeCoinJoin(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BTCAuthorizeCoinJoin
+): Response<OwnershipProof>;