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

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -0,0 +1,473 @@
+import semver from 'semver';
+import {
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+  HardwareErrorCodeMessage,
+} 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 { createUiMessage, DEVICE, IFRAME } from '../../events';
+import { getDeviceFirmwareVersion, getMethodVersionRange } from '../../utils';
+import { Device, DeviceEvents } from '../../device/Device';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { onDeviceButtonHandler } from '../../core';
+
+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;
+  }[]
+> {
+  abortController: AbortController | null = null;
+
+  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);
+      method.context = this.context;
+
+      const onSignalAbort = () => {
+        console.log('=====>>>>> onSignalAbort');
+        this.abortController?.abort(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+      };
+
+      const _onDeviceButtonHandler = (...[device, request]: [...DeviceEvents['button']]) => {
+        if (
+          request.code === 'ButtonRequest_PinEntry' ||
+          request.code === 'ButtonRequest_AttachPin'
+        ) {
+          onSignalAbort();
+        } else {
+          onDeviceButtonHandler(device, request);
+        }
+      };
+
+      // pro pin event
+      this.device.on(DEVICE.BUTTON, _onDeviceButtonHandler);
+      // classic pin event
+      this.device.on(DEVICE.PIN, onSignalAbort);
+      this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
+
+      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() {
+    if (!this.device.features?.unlocked) {
+      // unlock device
+      const features = await this.device.unlockDevice();
+      if (features.passphrase_protection) {
+        // check passphrase state
+        await this.device.checkPassphraseStateSafety();
+      }
+      this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    }
+
+    this.abortController = new AbortController();
+
+    return this.getAllNetworkAddress().catch(e => {
+      if (e instanceof HardwareError && e.errorCode === HardwareErrorCode.RepeatUnlocking) {
+        throw ERRORS.TypedError(HardwareErrorCode.RepeatUnlocking, e.message);
+      }
+      throw e;
+    });
+  }
+}
+
+/**
+ * @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.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,151 @@
+import {
+  createDeferred,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+  HardwareErrorCodeMessage,
+} from '@onekeyfe/hd-shared';
+import type {
+  AllNetworkAddress,
+  AllNetworkGetAddressParamsByLoop,
+} from '../../types/api/allNetworkGetAddress';
+
+import { IFRAME } from '../../events';
+import AllNetworkGetAddressBase from './AllNetworkGetAddressBase';
+import { Unsuccessful } from '../../types';
+
+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];
+
+        if (this.abortController?.signal.aborted) {
+          throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+        }
+
+        const methodParams = this.generateMethodName({
+          network: item.network,
+          payload: item,
+          originalIndex: i,
+        });
+
+        const singleMethodParams = {
+          bundle: [methodParams.params],
+        };
+
+        const response = await this.callMethod(methodParams.methodName, singleMethodParams);
+
+        if (this.abortController?.signal.aborted) {
+          throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+        }
+
+        const singleResult = {
+          ...item,
+          ...response[0],
+        };
+        allResults.push(singleResult);
+
+        this.sendItemCallback(callbackId, singleResult, i);
+      }
+
+      this.sendFinishCallback({
+        callbackId: callbackIdFinish,
+        data: allResults,
+      });
+    } catch (error: any) {
+      let errorCode = error.errorCode || error.code;
+      let errorMessage = error.message;
+
+      if (error instanceof HardwareError) {
+        errorCode = error.errorCode;
+        errorMessage = error.message;
+      } else if (error.message === HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]) {
+        errorCode = HardwareErrorCode.RepeatUnlocking;
+        errorMessage = error.message;
+      } else {
+        const hardwareError = ERRORS.TypedError(HardwareErrorCode.RuntimeError, error.message);
+        errorCode = hardwareError.errorCode;
+        errorMessage = hardwareError.message;
+      }
+
+      this.sendFinishCallback({
+        callbackId,
+        error: {
+          success: false,
+          payload: {
+            error: errorMessage,
+            code: errorCode,
+          },
+        },
+      });
+    } finally {
+      this.context?.cancelCallbackTasks(this.payload.connectId);
+      this.abortController = null;
+    }
+  }
+
+  private sendFinishCallback({
+    callbackId,
+    data,
+    error,
+  }: {
+    callbackId: string;
+    data?: AllNetworkAddress[];
+    error?: Unsuccessful;
+  }) {
+    this.postMessage({
+      event: IFRAME.CALLBACK,
+      type: IFRAME.CALLBACK,
+      payload: {
+        callbackId,
+        data,
+        error,
+      },
+    });
+  }
+
+  private sendItemCallback(callbackId: string, data: any, itemIndex: number) {
+    this.postMessage({
+      event: IFRAME.CALLBACK,
+      type: IFRAME.CALLBACK,
+      payload: {
+        callbackId,
+        data: {
+          ...data,
+          index: itemIndex,
+        },
+      },
+    });
+  }
+}

package/src/api/btc/BTCGetPublicKey.ts

@@ -1,4 +1,5 @@
 import type { GetPublicKey } from '@onekeyfe/hd-transport';
+import { HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { getScriptType, isTaprootPath, serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
@@ -121,6 +122,18 @@ export default class BTCGetPublicKey extends BaseMethod<GetPublicKey[]> {
         });
       }
     } catch (error) {
+      if (error instanceof HardwareError) {
+        const { errorCode } = error;
+        if (
+          errorCode === HardwareErrorCode.PinCancelled ||
+          errorCode === HardwareErrorCode.ActionCancelled ||
+          errorCode === HardwareErrorCode.ResponseUnexpectTypeError ||
+          errorCode === HardwareErrorCode.PinInvalid
+        ) {
+          throw error;
+        }
+      }
+
       // clear responses
       responses = [];
 

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> {