@onekeyfe/hd-core 1.1.4-alpha.2 → 1.1.4-alpha.3

package/src/api/device/DeviceUnlock.ts

@@ -1,59 +1,12 @@
 import { LockDevice } from '@onekeyfe/hd-transport';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import semver from 'semver';
 import { BaseMethod } from '../BaseMethod';
-import { toHardened } from '../helpers/pathUtils';
-import { DeviceFirmwareRange } from '../../types';
-import { getDeviceFirmwareVersion, getMethodVersionRange } from '../../utils';
 
 export default class DeviceUnlock extends BaseMethod<LockDevice> {
   init() {
     this.useDevicePassphraseState = false;
   }
 
-  supportUnlockVersionRange(): DeviceFirmwareRange {
-    return {
-      pro: {
-        min: '4.15.0',
-      },
-    };
-  }
-
   async run() {
-    const firmwareVersion = getDeviceFirmwareVersion(this.device.features)?.join('.');
-    const versionRange = getMethodVersionRange(
-      this.device.features,
-      type => this.supportUnlockVersionRange()[type]
-    );
-
-    if (versionRange && semver.gte(firmwareVersion, versionRange.min)) {
-      const res = await this.device.commands.typedCall('UnLockDevice', 'UnLockDeviceResponse');
-      if (this.device.features) {
-        this.device.features.unlocked = res.message.unlocked == null ? null : res.message.unlocked;
-        this.device.features.unlocked_attach_pin =
-          res.message.unlocked_attach_pin == null ? undefined : res.message.unlocked_attach_pin;
-        this.device.features.passphrase_protection =
-          res.message.passphrase_protection == null ? null : res.message.passphrase_protection;
-
-        return Promise.resolve(this.device.features);
-      }
-
-      const featuresRes = await this.device.commands.typedCall('GetFeatures', 'Features');
-      return Promise.resolve(featuresRes.message);
-    }
-
-    const { type } = await this.device.commands.typedCall('GetAddress', 'Address', {
-      address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
-      coin_name: 'Testnet',
-      script_type: 'SPENDADDRESS',
-      show_display: false,
-    });
-
-    // @ts-expect-error
-    if (type === 'CallMethodError') {
-      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Get the passphrase state error');
-    }
-    const res = await this.device.commands.typedCall('GetFeatures', 'Features');
-    return Promise.resolve(res.message);
+    return this.device.unlockDevice();
   }
 }

package/src/api/evm/EVMGetPublicKey.ts

@@ -13,6 +13,8 @@ import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
 export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneKey[]> {
   hasBundle = false;
 
+  confirmShowOnOneKey = false;
+
   useBatch = false;
 
   init() {
@@ -20,9 +22,13 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
 
     this.hasBundle = !!this.payload?.bundle;
-    this.useBatch = this.payload?.bundle?.every(
-      (item: EVMGetPublicKeyParams) => item.showOnOneKey !== true
+
+    this.confirmShowOnOneKey = this.payload?.bundle?.some(
+      (item: EVMGetPublicKeyParams) => !!item.showOnOneKey
     );
+
+    this.useBatch = !this.confirmShowOnOneKey && this.hasBundle && this.payload.useBatch;
+
     const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
 
     // check payload
@@ -66,7 +72,7 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
   async run() {
     const responses: EVMPublicKey[] = [];
 
-    if (this.useBatch && this.hasBundle && supportBatchPublicKey(this.device?.features)) {
+    if (this.useBatch && supportBatchPublicKey(this.device?.features)) {
       try {
         const res = await batchGetPublickeys(this.device, this.params, 'secp256k1', 60, {
           includeNode: false,

package/src/api/index.ts

@@ -41,6 +41,7 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 export { default as cipherKeyValue } from './CipherKeyValue';
 
 export { default as allNetworkGetAddress } from './allnetwork/AllNetworkGetAddress';
+export { default as allNetworkGetAddressByLoop } from './allnetwork/AllNetworkGetAddressByLoop';
 
 export { default as btcGetAddress } from './btc/BTCGetAddress';
 export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';

package/src/core/RequestQueue.ts

@@ -13,6 +13,8 @@ export type RequestTask = {
 export default class RequestQueue {
   private requestQueue = new Map<number, RequestTask>();
 
+  private pendingCallbackTasks = new Map<string, Deferred<void>>();
+
   // 生成唯一请求ID
   public generateRequestId = (method?: BaseMethod) => {
     if (method && method.responseID != null) {
@@ -104,4 +106,28 @@ export default class RequestQueue {
   public releaseTask(requestId: number) {
     this.requestQueue.delete(requestId);
   }
+
+  public registerPendingCallbackTask(connectId: string, callbackPromise: Deferred<void>) {
+    this.pendingCallbackTasks.set(connectId, callbackPromise);
+
+    callbackPromise.promise.finally(() => {
+      Log.debug(`Callback task completed for connectId: ${connectId}`);
+      this.pendingCallbackTasks.delete(connectId);
+    });
+  }
+
+  public async waitForPendingCallbackTasks(connectId: string): Promise<void> {
+    const pendingTask = this.pendingCallbackTasks.get(connectId);
+    if (pendingTask) {
+      Log.debug(`Waiting for pending callback task to complete for connectId: ${connectId}`);
+      await pendingTask.promise;
+    }
+  }
+
+  public cancelCallbackTasks(connectId: string) {
+    const pendingTask = this.pendingCallbackTasks.get(connectId);
+    if (pendingTask) {
+      pendingTask.resolve();
+    }
+  }
 }

package/src/core/index.ts

@@ -3,19 +3,17 @@ import EventEmitter from 'events';
 import { Features, LowlevelTransportSharedPlugin, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 import {
   createDeferred,
-  Deferred,
-  ERRORS,
-  HardwareError,
-  HardwareErrorCode,
   createDeprecatedHardwareError,
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
-  createDefectiveFirmwareError,
+  Deferred,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
 } from '@onekeyfe/hd-shared';
 import {
   getDeviceFirmwareVersion,
-  getDeviceBLEFirmwareVersion,
   enableLog,
   getLogger,
   LoggerNames,
@@ -23,10 +21,6 @@ import {
   wait,
   getMethodVersionRange,
 } from '../utils';
-import {
-  findDefectiveBatchDevice,
-  getDefectiveDeviceInfo,
-} from '../utils/findDefectiveBatchDevice';
 import { supportNewPassphrase } from '../utils/deviceFeaturesUtils';
 import { Device, DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
@@ -58,7 +52,7 @@ import { getSynchronize } from '../utils/getSynchronize';
 
 const Log = getLogger(LoggerNames.Core);
 
-type CoreContext = ReturnType<Core['getCoreContext']>;
+export type CoreContext = ReturnType<Core['getCoreContext']>;
 
 function hasDeriveCardano(method: BaseMethod): boolean {
   if (
@@ -201,6 +195,11 @@ const onCallDevice = async (
     DevicePool.clearDeviceCache(method.payload.connectId);
   }
 
+  // wait for previous callback tasks to complete (ensure device does not call concurrently)
+  if (method.connectId) {
+    await context.waitForCallbackTasks(method.connectId);
+  }
+
   await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
   const task = requestQueue.createTask(method);
@@ -231,6 +230,7 @@ const onCallDevice = async (
 
   Log.debug('Call API - setDevice: ', device.mainId);
   method.setDevice?.(device);
+  method.context = context;
 
   device.on(DEVICE.PIN, onDevicePinHandler);
   device.on(DEVICE.BUTTON, onDeviceButtonHandler);
@@ -246,6 +246,10 @@ const onCallDevice = async (
   );
 
   try {
+    if (method.connectId) {
+      await context.waitForCallbackTasks(method.connectId);
+    }
+
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
     const inner = async (): Promise<void> => {
@@ -257,96 +261,35 @@ const onCallDevice = async (
 
       if (device.features) {
         await DataManager.checkAndReloadData();
-
-        // 检测故障固件设备
-        if (findDefectiveBatchDevice(device.features)) {
-          const defectiveInfo = getDefectiveDeviceInfo(device.features);
-          if (defectiveInfo) {
-            throw createDefectiveFirmwareError(
-              defectiveInfo.serialNo,
-              defectiveInfo.seVersion || 'Unknown',
-              defectiveInfo.deviceType,
-              method.connectId,
-              method.deviceId
-            );
-          }
-        }
-
         const newVersionStatus = DataManager.getFirmwareStatus(device.features);
         const bleVersionStatus = DataManager.getBLEFirmwareStatus(device.features);
-
-        const currentFirmwareVersion = getDeviceFirmwareVersion(device.features).join('.');
-        const currentBleVersion = getDeviceBLEFirmwareVersion(device.features).join('.');
         if (
           (newVersionStatus === 'required' || bleVersionStatus === 'required') &&
           method.skipForceUpdateCheck === false
         ) {
-          // Get current version information for error reporting
-          const currentVersions = {
-            firmware: currentFirmwareVersion,
-            ble: currentBleVersion,
-          };
-
-          // Provide more specific error message based on which version check failed
-          if (newVersionStatus === 'required' && bleVersionStatus === 'required') {
-            throw createNewFirmwareForceUpdateHardwareError(
-              method.connectId,
-              method.deviceId,
-              'both',
-              currentVersions
-            );
-          } else if (newVersionStatus === 'required') {
-            throw createNewFirmwareForceUpdateHardwareError(
-              method.connectId,
-              method.deviceId,
-              'firmware',
-              currentVersions
-            );
-          } else {
-            throw createNewFirmwareForceUpdateHardwareError(
-              method.connectId,
-              method.deviceId,
-              'ble',
-              currentVersions
-            );
-          }
+          throw createNewFirmwareForceUpdateHardwareError(method.connectId, method.deviceId);
         }
 
         if (versionRange) {
-          if (
-            semver.valid(versionRange.min) &&
-            semver.lt(currentFirmwareVersion, versionRange.min)
-          ) {
+          const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+          if (semver.valid(versionRange.min) && semver.lt(currentVersion, versionRange.min)) {
             if (newVersionStatus === 'none' || newVersionStatus === 'valid') {
-              throw createNewFirmwareUnReleaseHardwareError(
-                currentFirmwareVersion,
-                versionRange.min,
-                method.name
-              );
+              throw createNewFirmwareUnReleaseHardwareError(currentVersion, versionRange.min);
             }
 
             return Promise.reject(
-              createNeedUpgradeFirmwareHardwareError(
-                currentFirmwareVersion,
-                versionRange.min,
-                method.name
-              )
+              createNeedUpgradeFirmwareHardwareError(currentVersion, versionRange.min)
             );
           }
           if (
             versionRange.max &&
             semver.valid(versionRange.max) &&
-            semver.gte(currentFirmwareVersion, versionRange.max)
+            semver.gte(currentVersion, versionRange.max)
           ) {
-            return Promise.reject(
-              createDeprecatedHardwareError(currentFirmwareVersion, versionRange.max, method.name)
-            );
+            return Promise.reject(createDeprecatedHardwareError(currentVersion, versionRange.max));
           }
         } else if (method.strictCheckDeviceSupport) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.DeviceNotSupportMethod,
-            `Method '${method.name}' is not supported by this device`
-          );
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportMethod);
         }
       }
 
@@ -735,6 +678,7 @@ const ensureConnected = async (
             HardwareErrorCode.BleWriteCharacteristicError,
             HardwareErrorCode.BleAlreadyConnected,
             HardwareErrorCode.FirmwareUpdateLimitOneDevice,
+            HardwareErrorCode.SelectDevice,
             HardwareErrorCode.DeviceDetectInBootloaderMode,
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission,
@@ -777,6 +721,10 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       // }
       // setPrePendingCallPromise(device?.interruptionFromUser());
       // requestQueue.abortRequestsByConnectId(connectId);
+
+      // cancel callback tasks
+      requestQueue.cancelCallbackTasks(connectId);
+
       const requestIds = requestQueue.getRequestTasksId();
       Log.debug(
         `Cancel Api connect requestQueues: length:${requestIds.length} requestIds:${requestIds.join(
@@ -910,7 +858,7 @@ const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin
   callback(null, uiResp.payload);
 };
 
-const onDeviceButtonHandler = (...[device, request]: [...DeviceEvents['button']]) => {
+export const onDeviceButtonHandler = (...[device, request]: [...DeviceEvents['button']]) => {
   postMessage(createDeviceMessage(DEVICE.BUTTON, { ...request, device: device.toMessageObject() }));
 
   if (request.code === 'ButtonRequest_PinEntry' || request.code === 'ButtonRequest_AttachPin') {
@@ -1014,7 +962,7 @@ const removeUiPromise = (promise: Deferred<any>) => {
 export default class Core extends EventEmitter {
   private requestQueue = new RequestQueue();
 
-  // 上一个请求的 promise 完成，后续需要清理的工作，需要在下一次请求前完成
+  // background task
   private prePendingCallPromise: Promise<void> | undefined;
 
   private methodSynchronize = getSynchronize();
@@ -1027,6 +975,13 @@ export default class Core extends EventEmitter {
       setPrePendingCallPromise: (promise: Promise<void> | undefined) => {
         this.prePendingCallPromise = promise;
       },
+      // callback 任务管理
+      registerCallbackTask: (connectId: string, callbackPromise: Deferred<any>) => {
+        this.requestQueue.registerPendingCallbackTask(connectId, callbackPromise);
+      },
+      waitForCallbackTasks: (connectId: string) =>
+        this.requestQueue.waitForPendingCallbackTasks(connectId),
+      cancelCallbackTasks: (connectId: string) => this.requestQueue.cancelCallbackTasks(connectId),
     };
   }
 
@@ -1077,6 +1032,11 @@ export default class Core extends EventEmitter {
         cancel(this.getCoreContext(), message.payload.connectId);
         break;
       }
+      case IFRAME.CALLBACK: {
+        Log.log('callback message: ', message);
+        postMessage(message);
+        break;
+      }
       default:
         break;
     }

package/src/device/Device.ts

@@ -1,4 +1,5 @@
 import EventEmitter from 'events';
+import semver from 'semver';
 import { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
 import {
   createDeferred,
@@ -16,6 +17,7 @@ import {
   getDeviceType,
   getDeviceUUID,
   getLogger,
+  getMethodVersionRange,
   LoggerNames,
 } from '../utils';
 import {
@@ -28,6 +30,7 @@ import type DeviceConnector from './DeviceConnector';
 import { DeviceCommands, PassphrasePromptResponse } from './DeviceCommands';
 
 import {
+  type DeviceFirmwareRange,
   EOneKeyDeviceMode,
   type Device as DeviceTyped,
   type Features,
@@ -43,6 +46,7 @@ import {
 import { PROTO } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
+import { toHardened } from '../api/helpers/pathUtils';
 
 export type InitOptions = {
   initSession?: boolean;
@@ -151,6 +155,8 @@ export class Device extends EventEmitter {
 
   passphraseState: string | undefined = undefined;
 
+  pendingCallbackPromise?: Deferred<void>;
+
   constructor(descriptor: DeviceDescriptor) {
     super();
     this.originalDescriptor = descriptor;
@@ -264,6 +270,18 @@ export class Device extends EventEmitter {
       (this.isUsedHere() && !this.keepSession && this.mainId) ||
       (this.mainId && DataManager.isBleConnect(env))
     ) {
+      // wait for callback tasks to complete before releasing device
+      if (this.pendingCallbackPromise) {
+        try {
+          Log.debug(
+            'Waiting for callback tasks to complete before releasing device (in release method)'
+          );
+          await this.pendingCallbackPromise.promise;
+        } catch (error) {
+          Log.error('Error waiting for callback tasks in release method:', error);
+        }
+      }
+
       if (this.commands) {
         this.commands.dispose(false);
         if (this.commands.callPromise) {
@@ -732,6 +750,54 @@ export class Device extends EventEmitter {
     return res.message;
   }
 
+  supportUnlockVersionRange(): DeviceFirmwareRange {
+    return {
+      pro: {
+        min: '4.15.0',
+      },
+    };
+  }
+
+  async unlockDevice() {
+    const firmwareVersion = getDeviceFirmwareVersion(this.features)?.join('.');
+    const versionRange = getMethodVersionRange(
+      this.features,
+      type => this.supportUnlockVersionRange()[type]
+    );
+
+    if (versionRange && semver.gte(firmwareVersion, versionRange.min)) {
+      const res = await this.commands.typedCall('UnLockDevice', 'UnLockDeviceResponse');
+      if (this.features) {
+        this.features.unlocked = res.message.unlocked == null ? null : res.message.unlocked;
+        this.features.unlocked_attach_pin =
+          res.message.unlocked_attach_pin == null ? undefined : res.message.unlocked_attach_pin;
+        this.features.passphrase_protection =
+          res.message.passphrase_protection == null ? null : res.message.passphrase_protection;
+
+        return Promise.resolve(this.features);
+      }
+
+      const featuresRes = await this.commands.typedCall('GetFeatures', 'Features');
+      this._updateFeatures(featuresRes.message);
+      return Promise.resolve(featuresRes.message);
+    }
+
+    const { type } = await this.commands.typedCall('GetAddress', 'Address', {
+      address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
+      coin_name: 'Testnet',
+      script_type: 'SPENDADDRESS',
+      show_display: false,
+    });
+
+    // @ts-expect-error
+    if (type === 'CallMethodError') {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'unlock device error');
+    }
+    const res = await this.commands.typedCall('GetFeatures', 'Features');
+    this._updateFeatures(res.message);
+    return Promise.resolve(res.message);
+  }
+
   async checkPassphraseStateSafety(
     passphraseState?: string,
     useEmptyPassphrase?: boolean,

package/src/events/call.ts

@@ -58,6 +58,16 @@ export interface IFrameSwitchTransportMessage {
   payload: { env: ConnectSettings['env'] };
 }
 
+export interface IFrameCallbackMessage {
+  event: typeof IFRAME.CALLBACK;
+  type: typeof IFRAME.CALLBACK;
+  payload: {
+    callbackId: string;
+    data?: any;
+    error?: any;
+  };
+}
+
 export const RESPONSE_EVENT = 'RESPONSE_EVENT';
 
 export interface MethodResponseMessage {

package/src/events/core.ts

@@ -1,6 +1,11 @@
 import { HardwareError } from '@onekeyfe/hd-shared';
 import { Unsuccessful } from '../types/params';
-import { IFrameCallMessage, IFrameCancelMessage, IFrameSwitchTransportMessage } from './call';
+import {
+  IFrameCallMessage,
+  IFrameCancelMessage,
+  IFrameSwitchTransportMessage,
+  IFrameCallbackMessage,
+} from './call';
 import { DeviceEventMessage } from './device';
 import { IFrameEventMessage } from './iframe';
 import { UiEventMessage } from './ui-request';
@@ -18,6 +23,7 @@ export type CoreMessage = {
   | IFrameCallMessage
   | IFrameCancelMessage
   | IFrameSwitchTransportMessage
+  | IFrameCallbackMessage
   | UiResponseMessage
   | UiEventMessage
   | DeviceEventMessage

package/src/events/iframe.ts

@@ -8,6 +8,7 @@ export const IFRAME = {
   CALL: 'iframe-call',
   CANCEL: 'iframe-cancel',
   SWITCH_TRANSPORT: 'iframe-switch-transport',
+  CALLBACK: 'iframe-callback',
 } as const;
 
 export interface IFrameInit {
@@ -29,7 +30,17 @@ export interface IFrameSwitchTransport {
   };
 }
 
-export type IFrameEvent = IFrameInit | IFrameBridge | IFrameSwitchTransport;
+export interface IFrameCallback {
+  type: typeof IFRAME.CALLBACK;
+  payload: {
+    callbackId: string;
+    data?: any;
+    error?: any;
+    finished?: boolean;
+  };
+}
+
+export type IFrameEvent = IFrameInit | IFrameBridge | IFrameSwitchTransport | IFrameCallback;
 export type IFrameEventMessage = IFrameEvent & { event: typeof UI_EVENT };
 
 export const createIFrameMessage: MessageFactoryFn<typeof UI_EVENT, IFrameEvent> = (

package/src/index.ts

@@ -1,4 +1,4 @@
-import { inject, InjectApi } from './inject';
+import { inject, InjectApi, executeCallback, cleanupCallback } from './inject';
 import { lowLevelInject, LowLevelInjectApi, LowLevelCoreApi } from './lowLevelInject';
 import { topLevelInject } from './topLevelInject';
 import { CoreApi } from './types/api';
@@ -14,6 +14,7 @@ export * from './data-manager';
 export * from './events';
 export * from './types';
 export { whitelist, whitelistExtension } from './data/config';
+export { executeCallback, cleanupCallback };
 
 const HardwareSdk = ({
   init,

package/src/inject.ts

@@ -1,6 +1,31 @@
 import { EventEmitter } from 'events';
 import { CallMethod } from './events';
 import { CoreApi } from './types/api';
+import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
+
+type CallbackFunction = (data?: any, error?: { message: string; code?: number }) => void;
+
+const callbackManager = new Map<string, CallbackFunction>();
+
+const generateCallbackId = () =>
+  `callback_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+
+const registerCallback = (id: string, callback: CallbackFunction) => {
+  callbackManager.set(id, callback);
+};
+
+const executeCallback = (id: string, ...args: any[]) => {
+  const callback = callbackManager.get(id);
+  if (callback) {
+    callback(...args);
+  }
+};
+
+const cleanupCallback = (id: string) => {
+  callbackManager.delete(id);
+};
+
+export { executeCallback, cleanupCallback };
 
 export interface InjectApi {
   call: CallMethod;
@@ -147,6 +172,28 @@ export const createCoreApi = (
 
   allNetworkGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'allNetworkGetAddress' }),
+  allNetworkGetAddressByLoop: (connectId, deviceId, params) => {
+    const { onLoopItemResponse, onAllItemsResponse, ...restParams } = params;
+
+    const callbackId = generateCallbackId();
+    registerCallback(callbackId, onLoopItemResponse);
+
+    const callbackIdFinish = generateCallbackId();
+    registerCallback(callbackIdFinish, (data?: AllNetworkAddress[]) => {
+      onAllItemsResponse?.(data);
+      cleanupCallback(callbackIdFinish);
+      cleanupCallback(callbackId);
+    });
+
+    return call({
+      ...restParams,
+      connectId,
+      deviceId,
+      method: 'allNetworkGetAddressByLoop',
+      callbackId,
+      callbackIdFinish,
+    });
+  },
 
   evmGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'evmGetAddress' }),

package/src/types/api/allNetworkGetAddress.ts

@@ -1,4 +1,4 @@
-import type { CommonParams, Response } from '../params';
+import type { CommonParams, Response, Unsuccessful } from '../params';
 import type { CardanoAddressParameters } from './cardano';
 
 export type INetwork =
@@ -91,10 +91,10 @@ type AllNetworkAddressPayload =
       xpubSegwit: string;
     };
 
-export type AllNetworkAddress = CommonResponseParams & {
+export type AllNetworkAddress = AllNetworkAddressParams & {
   success: boolean;
   payload?:
-    | AllNetworkAddressPayload
+    | (AllNetworkAddressPayload & { rootFingerprint: number })
     | {
         error: string;
         code: number;
@@ -108,8 +108,22 @@ export type AllNetworkGetAddressParams = {
   bundle: AllNetworkAddressParams[];
 };
 
+export type AllNetworkGetAddressParamsByLoop = AllNetworkGetAddressParams & {
+  callbackId?: string;
+  callbackIdFinish?: string;
+  onLoopItemResponse: (data?: AllNetworkAddress) => void;
+  onAllItemsResponse: (data?: AllNetworkAddress[], error?: Unsuccessful) => void;
+};
+
 export declare function allNetworkGetAddress(
   connectId: string,
   deviceId: string,
   params: CommonParams & AllNetworkGetAddressParams
 ): Response<AllNetworkAddress[]>;
+
+export declare function allNetworkGetAddressByLoop(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AllNetworkGetAddressParamsByLoop
+  // only return empty array
+): Response<AllNetworkAddress[]>;

package/src/types/api/evmGetPublicKey.ts

@@ -14,6 +14,7 @@ export type EVMGetPublicKeyParams = {
   path: string | number[];
   showOnOneKey?: boolean;
   chainId?: number;
+  useBatch?: boolean;
 };
 
 export declare function evmGetPublicKey(