@onekeyfe/hd-core 1.1.2-alpha.1 → 1.1.2-alpha.2

package/src/device/Device.ts

@@ -151,6 +151,8 @@ export class Device extends EventEmitter {
 
   passphraseState: string | undefined = undefined;
 
+  pendingCallbackPromise?: Deferred<void>;
+
   constructor(descriptor: DeviceDescriptor) {
     super();
     this.originalDescriptor = descriptor;
@@ -264,6 +266,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) {

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

@@ -91,7 +91,7 @@ type AllNetworkAddressPayload =
       xpubSegwit: string;
     };
 
-export type AllNetworkAddress = CommonResponseParams & {
+export type AllNetworkAddress = AllNetworkAddressParams & {
   success: boolean;
   payload?:
     | AllNetworkAddressPayload
@@ -108,8 +108,24 @@ export type AllNetworkGetAddressParams = {
   bundle: AllNetworkAddressParams[];
 };
 
+export type AllNetworkGetAddressParamsByLoop = {
+  callbackId?: string;
+  callbackIdFinish?: string;
+  onLoopItemResponse: (
+    data?: AllNetworkAddress,
+    error?: { message: string; code?: number }
+  ) => void;
+  onAllItemsResponse: (data?: AllNetworkAddress[]) => 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
+): Response<string[]>;

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(

package/src/types/api/index.ts

@@ -43,7 +43,7 @@ import { setU2FCounter } from './setU2FCounter';
 
 import { cipherKeyValue } from './cipherKeyValue';
 
-import { allNetworkGetAddress } from './allNetworkGetAddress';
+import { allNetworkGetAddress, allNetworkGetAddressByLoop } from './allNetworkGetAddress';
 
 import { evmGetAddress } from './evmGetAddress';
 import { evmGetPublicKey } from './evmGetPublicKey';
@@ -230,6 +230,7 @@ export type CoreApi = {
    * All network function
    */
   allNetworkGetAddress: typeof allNetworkGetAddress;
+  allNetworkGetAddressByLoop: typeof allNetworkGetAddressByLoop;
 
   /**
    * EVM function