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

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -0,0 +1,427 @@
+import semver from 'semver';
+import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { serializedPath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { CoreApi } from '../../types';
+import type {
+  AllNetworkAddressParams,
+  INetwork,
+  AllNetworkAddress,
+  CommonResponseParams,
+} from '../../types/api/allNetworkGetAddress';
+import { PROTO } from '../../constants';
+
+import { findMethod } from '../utils';
+import { IFRAME } from '../../events';
+import { getDeviceFirmwareVersion, getMethodVersionRange } from '../../utils';
+import { Device } from '../../device/Device';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+const Mainnet = 'mainnet';
+
+export type NetworkConfig = {
+  methodName: keyof CoreApi;
+  getParams?: (baseParams: AllNetworkAddressParams, chainName?: string, methodName?: string) => any;
+  dependOnMethodName?: (keyof CoreApi)[];
+};
+
+export type INetworkReal = Exclude<INetwork, 'tbtc' | 'bch' | 'doge' | 'ltc' | 'neurai'>;
+
+export type NetworkConfigMap = {
+  [K in INetworkReal]: NetworkConfig;
+};
+
+export const networkAliases: {
+  [key: string]: { name: INetworkReal; coin: string };
+} = {
+  tbtc: { name: 'btc', coin: 'Testnet' },
+  bch: { name: 'btc', coin: 'Bcash' },
+  doge: { name: 'btc', coin: 'Dogecoin' },
+  ltc: { name: 'btc', coin: 'Litecoin' },
+  neurai: { name: 'btc', coin: 'Neurai' },
+};
+
+const networkConfigMap: NetworkConfigMap = {
+  btc: {
+    methodName: 'btcGetPublicKey',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => ({
+      coin: chainName,
+      ...baseParams,
+    }),
+  },
+  evm: {
+    methodName: 'evmGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => {
+      const { path, showOnOneKey } = baseParams;
+      let chainId;
+      if (chainName) {
+        chainId = parseInt(chainName);
+      }
+      return {
+        chainId,
+        path,
+        showOnOneKey,
+      };
+    },
+  },
+  sol: {
+    methodName: 'solGetAddress',
+  },
+  algo: {
+    methodName: 'algoGetAddress',
+  },
+  near: {
+    methodName: 'nearGetAddress',
+  },
+  stc: {
+    methodName: 'starcoinGetAddress',
+  },
+  cfx: {
+    methodName: 'confluxGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => {
+      const { path, showOnOneKey } = baseParams;
+      return {
+        chainId: parseInt(chainName ?? '1029'),
+        path,
+        showOnOneKey,
+      };
+    },
+  },
+  tron: {
+    methodName: 'tronGetAddress',
+  },
+  aptos: {
+    methodName: 'aptosGetAddress',
+  },
+  xrp: {
+    methodName: 'xrpGetAddress',
+  },
+  cosmos: {
+    methodName: 'cosmosGetPublicKey',
+    getParams: (baseParams: AllNetworkAddressParams) => {
+      const { path, prefix, showOnOneKey } = baseParams;
+      return {
+        hrp: prefix,
+        path,
+        showOnOneKey,
+      };
+    },
+  },
+  ada: {
+    methodName: 'cardanoGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => {
+      const { path, showOnOneKey } = baseParams;
+
+      const addressPath =
+        typeof path === 'string' ? `${path}/0/0` : serializedPath([...path, 0, 0]);
+      const stakingPath =
+        typeof path === 'string' ? `${path}/2/0` : serializedPath([...path, 2, 0]);
+
+      let networkId = 1;
+      if (chainName) {
+        networkId = chainName === Mainnet ? 1 : 0;
+      }
+
+      return {
+        addressParameters: {
+          addressType: PROTO.CardanoAddressType.BASE,
+          path: addressPath,
+          stakingPath,
+        },
+        protocolMagic: 764824073,
+        networkId,
+        derivationType: PROTO.CardanoDerivationType.ICARUS,
+        showOnOneKey,
+        address: '',
+        isCheck: false,
+      };
+    },
+  },
+  sui: {
+    methodName: 'suiGetAddress',
+  },
+  benfen: {
+    methodName: 'benfenGetAddress',
+  },
+  fil: {
+    methodName: 'filecoinGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => {
+      const { path, showOnOneKey } = baseParams;
+      let isTestnet = false;
+      if (chainName) {
+        isTestnet = chainName !== Mainnet;
+      }
+      return {
+        isTestnet,
+        path,
+        showOnOneKey,
+      };
+    },
+  },
+  dot: {
+    methodName: 'polkadotGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => {
+      const { path, prefix, showOnOneKey } = baseParams;
+      if (!prefix || !chainName) {
+        throw new Error('Invalid params');
+      }
+      return {
+        prefix: parseInt(prefix),
+        network: chainName,
+        path,
+        showOnOneKey,
+      };
+    },
+  },
+  kaspa: {
+    methodName: 'kaspaGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams) => {
+      const { path, prefix, showOnOneKey, useTweak } = baseParams;
+      return {
+        scheme: 'schnorr',
+        prefix,
+        path,
+        showOnOneKey,
+        useTweak,
+      };
+    },
+  },
+  nexa: {
+    methodName: 'nexaGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams) => {
+      const { path, prefix, showOnOneKey } = baseParams;
+      return {
+        scheme: 'Schnorr',
+        prefix,
+        path,
+        showOnOneKey,
+      };
+    },
+  },
+  dynex: {
+    methodName: 'dnxGetAddress',
+  },
+  nervos: {
+    methodName: 'nervosGetAddress',
+    getParams: (baseParams: AllNetworkAddressParams, chainName?: string) => {
+      const { path, showOnOneKey } = baseParams;
+      return {
+        network: chainName,
+        path,
+        showOnOneKey,
+      };
+    },
+  },
+  scdo: {
+    methodName: 'scdoGetAddress',
+  },
+  ton: {
+    methodName: 'tonGetAddress',
+  },
+  alph: {
+    methodName: 'alephiumGetAddress',
+  },
+  nostr: {
+    methodName: 'nostrGetPublicKey',
+  },
+  neo: {
+    methodName: 'neoGetAddress',
+  },
+};
+
+type MethodParams = {
+  methodName: keyof CoreApi;
+  params: Parameters<CoreApi[keyof CoreApi]>[0];
+  _originRequestParams: AllNetworkAddressParams;
+  _originalIndex: number;
+};
+
+export default abstract class AllNetworkGetAddressBase extends BaseMethod<
+  {
+    address_n: number[];
+    show_display: boolean;
+    network: string;
+    chain_name?: string;
+  }[]
+> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [{ name: 'bundle', type: 'array' }]);
+
+    // check bundle
+    this.payload?.bundle?.forEach((batch: AllNetworkAddressParams) => {
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'network', type: 'string', required: true },
+        { name: 'chainName', type: 'string' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+    });
+  }
+
+  generateMethodName({
+    network,
+    payload,
+    originalIndex,
+  }: {
+    network: INetwork;
+    payload: AllNetworkAddressParams;
+    originalIndex: number;
+  }): MethodParams {
+    const { name: networkName, coin } = networkAliases[network] || {
+      name: network,
+      coin: payload?.chainName,
+    };
+    const config = networkConfigMap[networkName];
+    if (!config) {
+      throw new Error(`Unsupported network: ${network}`);
+    }
+
+    return {
+      methodName: config.methodName,
+      params: {
+        ...(config?.getParams?.(payload, coin, config.methodName) ?? payload),
+        originPayload: payload,
+      },
+      _originRequestParams: payload,
+      _originalIndex: originalIndex,
+    };
+  }
+
+  async callMethod(
+    methodName: keyof CoreApi,
+    params: any & {
+      bundle: (any & { _originRequestParams: CommonResponseParams })[];
+    }
+  ) {
+    const method: BaseMethod = findMethod({
+      event: IFRAME.CALL,
+      type: IFRAME.CALL,
+      payload: {
+        connectId: this.payload.connectId,
+        deviceId: this.payload.deviceId,
+        method: methodName,
+        ...params,
+      },
+    });
+
+    method.connector = this.connector;
+    method.postMessage = this.postMessage;
+
+    let result: AllNetworkAddress[];
+    try {
+      method.init();
+      method.setDevice?.(this.device);
+
+      preCheckDeviceSupport(this.device, method);
+
+      const response = await method.run();
+
+      if (!Array.isArray(response) || response.length === 0) {
+        throw new Error('No response');
+      }
+
+      result = response.map((item, index) => ({
+        ...params.bundle[index]._originRequestParams,
+        success: true,
+        payload: item,
+      }));
+    } catch (e: any) {
+      const error = handleSkippableHardwareError(e, this.device, method);
+
+      if (error) {
+        result = params.bundle.map((item: { _originRequestParams: any }) => ({
+          ...item._originRequestParams,
+          success: false,
+          payload: {
+            error: error.message,
+            code: error.errorCode,
+            params: error.params,
+            connectId: method.connectId,
+            deviceId: method.deviceId,
+          },
+        }));
+      } else {
+        throw e;
+      }
+    }
+
+    return result;
+  }
+
+  abstract getAllNetworkAddress(): Promise<AllNetworkAddress[]>;
+
+  async run() {
+    return Promise.resolve(this.getAllNetworkAddress());
+  }
+}
+
+/**
+ * @experiment Check if the device supports the method
+ * @param device
+ * @param method BaseMethod
+ */
+function preCheckDeviceSupport(device: Device, method: BaseMethod) {
+  const versionRange = getMethodVersionRange(
+    device.features,
+    type => method.getVersionRange()[type]
+  );
+  const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+
+  if (
+    versionRange &&
+    semver.valid(versionRange.min) &&
+    semver.lt(currentVersion, versionRange.min)
+  ) {
+    throw ERRORS.createNeedUpgradeFirmwareHardwareError(currentVersion, versionRange.min);
+  } else if (method.strictCheckDeviceSupport && !versionRange) {
+    throw ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportMethod);
+  }
+}
+
+function handleSkippableHardwareError(
+  e: any,
+  device: Device,
+  method: BaseMethod
+): HardwareError | undefined {
+  let error: HardwareError | undefined;
+
+  if (e instanceof HardwareError && e.errorCode !== HardwareErrorCode.RuntimeError) {
+    const { errorCode } = e;
+    if (errorCode === HardwareErrorCode.CallMethodInvalidParameter) {
+      error = e;
+    } else if (errorCode === HardwareErrorCode.CallMethodNeedUpgradeFirmware) {
+      error = e;
+    } else if (errorCode === HardwareErrorCode.DeviceNotSupportMethod) {
+      error = e;
+    }
+  } else if (e.message?.includes('Failure_UnexpectedMessage')) {
+    const versionRange = getMethodVersionRange(
+      device.features,
+      type => method.getVersionRange()[type]
+    );
+    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+
+    if (
+      versionRange &&
+      semver.valid(versionRange.min) &&
+      semver.lt(currentVersion, versionRange.min)
+    ) {
+      error = ERRORS.createNeedUpgradeFirmwareHardwareError(currentVersion, versionRange.min);
+    } else {
+      error = ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportMethod, e.message);
+    }
+  } else if (
+    e.message?.toLowerCase()?.includes('forbidden key path') ||
+    e.message?.toLowerCase()?.includes('invalid path')
+  ) {
+    error = ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, e.message);
+  }
+
+  return error;
+}

package/src/api/allnetwork/AllNetworkGetAddressByLoop.ts

@@ -0,0 +1,104 @@
+import { createDeferred } from '@onekeyfe/hd-shared';
+import type {
+  AllNetworkAddress,
+  AllNetworkGetAddressParamsByLoop,
+} from '../../types/api/allNetworkGetAddress';
+
+import { IFRAME } from '../../events';
+import AllNetworkGetAddressBase from './AllNetworkGetAddressBase';
+
+export default class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase {
+  async getAllNetworkAddress() {
+    const { callbackId, callbackIdFinish } = this.payload as AllNetworkGetAddressParamsByLoop;
+    if (!callbackId) {
+      throw new Error('callbackId is required');
+    }
+    if (!callbackIdFinish) {
+      throw new Error('callbackIdFinish is required');
+    }
+
+    const bundle = this.payload.bundle || [this.payload];
+
+    // process callbacks in background
+    const callbackPromise = this.processCallbacksInBackground(bundle, callbackId, callbackIdFinish);
+    this.device.pendingCallbackPromise = createDeferred(callbackPromise);
+
+    // register to context for scheduling management
+    if (this.context && this.payload.connectId) {
+      this.context.registerCallbackTask(this.payload.connectId, this.device.pendingCallbackPromise);
+    }
+
+    // return empty array immediately
+    return Promise.resolve([]);
+  }
+
+  private async processCallbacksInBackground(
+    bundle: any[],
+    callbackId: string,
+    callbackIdFinish: string
+  ): Promise<void> {
+    try {
+      const allResults: AllNetworkAddress[] = [];
+
+      for (let i = 0; i < bundle.length; i++) {
+        const item = bundle[i];
+
+        try {
+          const methodParams = this.generateMethodName({
+            network: item.network,
+            payload: item,
+            originalIndex: i,
+          });
+
+          const singleMethodParams = {
+            bundle: [methodParams.params],
+          };
+
+          const response = await this.callMethod(methodParams.methodName, singleMethodParams);
+
+          const singleResult = {
+            ...item,
+            ...response[0],
+          };
+          allResults.push(singleResult);
+
+          this.sendItemCallback(callbackId, singleResult, null, i);
+        } catch (error: any) {
+          this.sendItemCallback(callbackId, null, error, i);
+          // continue to process other items, do not throw error
+          console.error(`Error processing item ${i}:`, error);
+        }
+      }
+
+      this.sendFinishCallback(callbackIdFinish, allResults);
+    } finally {
+      this.context?.cancelCallbackTasks(this.payload.connectId);
+    }
+  }
+
+  private sendFinishCallback(callbackId: string, data: AllNetworkAddress[]) {
+    this.postMessage({
+      event: IFRAME.CALLBACK,
+      type: IFRAME.CALLBACK,
+      payload: {
+        callbackId,
+        data,
+      },
+    });
+  }
+
+  private sendItemCallback(callbackId: string, data: any, error: any, itemIndex: number) {
+    this.postMessage({
+      event: IFRAME.CALLBACK,
+      type: IFRAME.CALLBACK,
+      payload: {
+        callbackId,
+        data: {
+          ...data,
+          index: itemIndex,
+        },
+        error: error ? { message: error.message, code: error.code } : null,
+      },
+    });
+  }
+}

package/src/api/cosmos/CosmosGetPublicKey.ts

@@ -2,7 +2,7 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import { CosmosAddress, CosmosGetPublicKeyParams } from '../../types';
+import type { CosmosAddress, CosmosGetPublicKeyParams } from '../../types';
 import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
 
 export default class CosmosGetPublicKey extends BaseMethod<any> {

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

@@ -52,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 (
@@ -195,6 +195,11 @@ const onCallDevice = async (
     DevicePool.clearDeviceCache(method.payload.connectId);
   }
 
+  // 等待之前的 callback 任务完成（确保设备不会并发调用）
+  if (method.connectId) {
+    await context.waitForCallbackTasks(method.connectId);
+  }
+
   await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
   const task = requestQueue.createTask(method);
@@ -225,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);
@@ -240,6 +246,10 @@ const onCallDevice = async (
   );
 
   try {
+    if (method.connectId) {
+      await context.waitForCallbackTasks(method.connectId);
+    }
+
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
     const inner = async (): Promise<void> => {
@@ -710,6 +720,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(
@@ -947,7 +961,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();
@@ -960,6 +974,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),
     };
   }
 
@@ -1010,6 +1031,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;
     }