@onekeyfe/hd-core 0.1.41 → 0.1.44

package/src/device/DeviceCommands.ts

@@ -1,4 +1,4 @@
-import type { Transport, Messages } from '@onekeyfe/hd-transport';
+import { Transport, Messages, FailureType } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
@@ -147,23 +147,23 @@ export class DeviceCommands {
       const { message } = res.message;
       let error: HardwareError | null = null;
       // Model One does not send any message in firmware update
-      if (code === 'Failure_FirmwareError' && !message) {
+      if (code === FailureType.Failure_FirmwareError && !message) {
         error = ERRORS.TypedError(HardwareErrorCode.FirmwareError);
       }
       // Failure_ActionCancelled message could be also missing
-      if (code === 'Failure_ActionCancelled') {
+      if (code === FailureType.Failure_ActionCancelled) {
         error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled);
       }
 
-      if (code === 'Failure_PinInvalid') {
+      if (code === FailureType.Failure_PinInvalid) {
         error = ERRORS.TypedError(HardwareErrorCode.PinInvalid, message);
       }
 
-      if (code === 'Failure_PinCancelled') {
+      if (code === FailureType.Failure_PinCancelled) {
         error = ERRORS.TypedError(HardwareErrorCode.PinCancelled);
       }
 
-      if (code === 'Failure_DataError' && message === 'Please confirm the BlindSign enabled') {
+      if (code === FailureType.Failure_DataError && message === 'Please confirm the BlindSign enabled') {
         error = ERRORS.TypedError(HardwareErrorCode.BlindSignDisabled);
       }
 
@@ -208,7 +208,6 @@ export class DeviceCommands {
       return this._promptPin(res.message.type).then(
         pin => {
           if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
-            // @ts-expect-error
             return this._commonCall('BixinPinInputOnDevice');
           }
           return this._commonCall('PinMatrixAck', { pin });

package/src/inject.ts

@@ -145,6 +145,32 @@ export const inject = ({
 
     firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
     requestWebUsbDevice: () => call({ method: 'requestWebUsbDevice' }),
+
+    tronGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'tronGetAddress' }),
+    tronSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'tronSignMessage' }),
+    tronSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'tronSignTransaction' }),
+
+    confluxGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'confluxGetAddress' }),
+    confluxSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'confluxSignMessage' }),
+    confluxSignMessageCIP23: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'confluxSignMessageCIP23' }),
+    confluxSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'confluxSignTransaction' }),
+
+    nearGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'nearGetAddress' }),
+    nearSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'nearSignTransaction' }),
+
+    aptosGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'aptosGetAddress' }),
+    aptosSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'aptosSignTransaction' }),
   };
   return api;
 };

package/src/types/api/aptosGetAddress.ts

@@ -0,0 +1,23 @@
+import { AptosAddress as HardwareAptosAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type AptosAddress = {
+  path: string;
+} & HardwareAptosAddress;
+
+export type AptosGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function aptosGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AptosGetAddressParams
+): Response<AptosAddress>;
+
+export declare function aptosGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: AptosGetAddressParams[] }
+): Response<Array<AptosAddress>>;

package/src/types/api/aptosSignTransaction.ts

@@ -0,0 +1,17 @@
+import { AptosSignedTx as HardwareAptosSignedTx } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type AptosSignedTx = {
+  path: string;
+} & HardwareAptosSignedTx;
+
+export type AptosSignTransactionParams = {
+  path: string | number[];
+  rawTx?: string;
+};
+
+export declare function aptosSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AptosSignTransactionParams,
+): Response<AptosSignedTx>;

package/src/types/api/confluxGetAddress.ts

@@ -0,0 +1,24 @@
+import { ConfluxAddress as HardwareConfluxAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type ConfluxAddress = {
+  path: string;
+} & HardwareConfluxAddress;
+
+export type ConfluxGetAddressParams = {
+  path: string | number[];
+  chainId?: number;
+  showOnOneKey?: boolean;
+};
+
+export declare function confluxGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & ConfluxGetAddressParams
+): Response<ConfluxAddress>;
+
+export declare function confluxGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: ConfluxGetAddressParams[] }
+): Response<Array<ConfluxAddress>>;

package/src/types/api/confluxSignMessage.ts

@@ -0,0 +1,13 @@
+import { ConfluxMessageSignature } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type ConfluxSignMessageParams = {
+  path: string | number[];
+  messageHex: string;
+};
+
+export declare function confluxSignMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & ConfluxSignMessageParams
+): Response<ConfluxMessageSignature>;

package/src/types/api/confluxSignMessageCIP23.ts

@@ -0,0 +1,14 @@
+import { ConfluxMessageSignature } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type ConfluxSignMessageCIP23Params = {
+  path: string | number[];
+  domainHash: string;
+  messageHash: string;
+};
+
+export declare function confluxSignMessageCIP23(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & ConfluxSignMessageCIP23Params
+): Response<ConfluxMessageSignature>;

package/src/types/api/confluxSignTransaction.ts

@@ -0,0 +1,32 @@
+import type { CommonParams, Response } from '../params';
+
+export type ConfluxSignedTx = {
+  v: string;
+  r: string;
+  s: string;
+};
+
+export type ConfluxTransaction = {
+  to: string;
+  value: string;
+  gasLimit: string;
+  gasPrice: string;
+  nonce: string;
+  epochHeight: string;
+  storageLimit: string;
+  chainId?: number;
+  data?: string;
+  data_initial_chunk?: string;
+  data_length?: string;
+};
+
+export type ConfluxSignTransactionParams = {
+  path: string | number[];
+  transaction: ConfluxTransaction;
+};
+
+export declare function confluxSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & ConfluxTransaction
+): Response<ConfluxSignedTx>;

package/src/types/api/deviceVerify.ts

@@ -5,8 +5,8 @@ export type DeviceVerifyParams = {
 };
 
 export type DeviceVerifySignature = {
-  cert: Buffer;
-  signature: Buffer;
+  cert: string;
+  signature: string;
 };
 
 export declare function deviceVerify(

package/src/types/api/export.ts

@@ -70,3 +70,28 @@ export type {
   StellarTransaction,
   StellarSignTransactionParams,
 } from './stellarSignTransaction';
+
+export type { TronAddress, TronGetAddressParams } from './tronGetAddress';
+export type { TronSignMessageParams } from './tronSignMessage';
+export type {
+  TronTransaction,
+  TronSignTransactionParams,
+  TronTransactionContract,
+  TronTransferContract,
+  TronTriggerSmartContract,
+} from './tronSignTransaction';
+
+export type { ConfluxAddress, ConfluxGetAddressParams } from './confluxGetAddress';
+export type { ConfluxSignMessageParams } from './confluxSignMessage';
+export type { ConfluxSignMessageCIP23Params } from './confluxSignMessageCIP23';
+export type {
+  ConfluxSignTransactionParams,
+  ConfluxSignedTx,
+  ConfluxTransaction,
+} from './confluxSignTransaction';
+
+export type { NearAddress, NearGetAddressParams } from './nearGetAddress';
+export type { NearSignTransactionParams } from './nearSignTransaction';
+
+export type { AptosAddress, AptosGetAddressParams } from './aptosGetAddress';
+export type { AptosSignedTx, AptosSignTransactionParams } from './aptosSignTransaction';

package/src/types/api/index.ts

@@ -1,11 +1,33 @@
 import { on, off, removeAllListeners } from './event';
+import { uiResponse } from './uiResponse';
+import { init } from './init';
+
+import { getLogs } from './getLogs';
+import { checkTransportRelease } from './checkTransportRelease';
+import { checkBridgeStatus } from './checkBridgeStatus';
+
 import { searchDevices } from './searchDevices';
 import { getFeatures } from './getFeatures';
+import { getPassphraseState } from './getPassphraseState';
 import { checkFirmwareRelease } from './checkFirmwareRelease';
-import { init } from './init';
 import { checkBLEFirmwareRelease } from './checkBLEFirmwareRelease';
-import { checkTransportRelease } from './checkTransportRelease';
-import { checkBridgeStatus } from './checkBridgeStatus';
+import { firmwareUpdate } from './firmwareUpdate';
+import { requestWebUsbDevice } from './requestWebUsbDevice';
+
+import { deviceReset } from './deviceReset';
+import { deviceRecovery } from './deviceRecovery';
+import { deviceVerify } from './deviceVerify';
+import { deviceWipe } from './deviceWipe';
+import { deviceRebootToBootloader } from './deviceRebootToBootloader';
+import { deviceBackup } from './deviceBackup';
+import { deviceChangePin } from './deviceChangePin';
+import { deviceSettings } from './deviceSettings';
+import { deviceFlags } from './deviceFlags';
+import { deviceUpdateReboot } from './deviceUpdateReboot';
+import { deviceSupportFeatures } from './deviceSupportFeatures';
+
+import { cipherKeyValue } from './cipherKeyValue';
+
 import { evmGetAddress } from './evmGetAddress';
 import { evmGetPublicKey } from './evmGetPublicKey';
 import { evmSignMessage } from './evmSignMessage';
@@ -13,39 +35,42 @@ import { evmSignMessageEIP712 } from './evmSignMessageEIP712';
 import { evmSignTransaction } from './evmSignTransaction';
 import { evmSignTypedData } from './evmSignTypedData';
 import { evmVerifyMessage } from './evmVerifyMessage';
+
 import { btcGetAddress } from './btcGetAddress';
 import { btcGetPublicKey } from './btcGetPublicKey';
 import { btcSignMessage } from './btcSignMessage';
 import { btcSignTransaction } from './btcSignTransaction';
 import { btcVerifyMessage } from './btcVerifyMessage';
-import { uiResponse } from './uiResponse';
-import { deviceReset } from './deviceReset';
-import { deviceRecovery } from './deviceRecovery';
-import { deviceVerify } from './deviceVerify';
-import { deviceWipe } from './deviceWipe';
-import { deviceRebootToBootloader } from './deviceRebootToBootloader';
-import { deviceBackup } from './deviceBackup';
-import { deviceChangePin } from './deviceChangePin';
-import { deviceSettings } from './deviceSettings';
-import { deviceFlags } from './deviceFlags';
-import { deviceUpdateReboot } from './deviceUpdateReboot';
+
 import { starcoinGetAddress } from './starcoinGetAddress';
 import { starcoinGetPublicKey } from './starcoinGetPublicKey';
 import { starcoinSignMessage } from './starcoinSignMessage';
 import { starcoinSignTransaction } from './starcoinSignTransaction';
 import { starcoinVerifyMessage } from './starcoinVerifyMessage';
+
 import { nemGetAddress } from './nemGetAddress';
 import { nemSignTransaction } from './nemSignTransaction';
+
 import { solGetAddress } from './solGetAddress';
 import { solSignTransaction } from './solSignTransaction';
+
 import { stellarGetAddress } from './stellarGetAddress';
 import { stellarSignTransaction } from './stellarSignTransaction';
-import { cipherKeyValue } from './cipherKeyValue';
-import { firmwareUpdate } from './firmwareUpdate';
-import { getLogs } from './getLogs';
-import { deviceSupportFeatures } from './deviceSupportFeatures';
-import { requestWebUsbDevice } from './requestWebUsbDevice';
-import { getPassphraseState } from './getPassphraseState';
+
+import { tronGetAddress } from './tronGetAddress';
+import { tronSignTransaction } from './tronSignTransaction';
+import { tronSignMessage } from './tronSignMessage';
+
+import { confluxGetAddress } from './confluxGetAddress';
+import { confluxSignMessage } from './confluxSignMessage';
+import { confluxSignMessageCIP23 } from './confluxSignMessageCIP23';
+import { confluxSignTransaction } from './confluxSignTransaction';
+
+import { nearGetAddress } from './nearGetAddress';
+import { nearSignTransaction } from './nearSignTransaction';
+
+import { aptosGetAddress } from './aptosGetAddress';
+import { aptosSignTransaction } from './aptosSignTransaction';
 
 export * from './export';
 
@@ -66,22 +91,16 @@ export type CoreApi = {
   /**
    * Core function
    */
-  searchDevices: typeof searchDevices;
-
-  requestWebUsbDevice: typeof requestWebUsbDevice;
-
-  getFeatures: typeof getFeatures;
-
-  checkFirmwareRelease: typeof checkFirmwareRelease;
-
-  checkBLEFirmwareRelease: typeof checkBLEFirmwareRelease;
-
   checkTransportRelease: typeof checkTransportRelease;
-
   checkBridgeStatus: typeof checkBridgeStatus;
 
-  cipherKeyValue: typeof cipherKeyValue;
-
+  /**
+   * Device function
+   */
+  searchDevices: typeof searchDevices;
+  requestWebUsbDevice: typeof requestWebUsbDevice;
+  getFeatures: typeof getFeatures;
+  getPassphraseState: typeof getPassphraseState;
   deviceBackup: typeof deviceBackup;
   deviceChangePin: typeof deviceChangePin;
   deviceFlags: typeof deviceFlags;
@@ -93,8 +112,15 @@ export type CoreApi = {
   deviceSupportFeatures: typeof deviceSupportFeatures;
   deviceVerify: typeof deviceVerify;
   deviceWipe: typeof deviceWipe;
-  getPassphraseState: typeof getPassphraseState;
+  checkFirmwareRelease: typeof checkFirmwareRelease;
+  checkBLEFirmwareRelease: typeof checkBLEFirmwareRelease;
+  firmwareUpdate: typeof firmwareUpdate;
 
+  cipherKeyValue: typeof cipherKeyValue;
+
+  /**
+   * EVM function
+   */
   evmGetAddress: typeof evmGetAddress;
   evmGetPublicKey: typeof evmGetPublicKey;
   evmSignMessage: typeof evmSignMessage;
@@ -103,26 +129,66 @@ export type CoreApi = {
   evmSignTypedData: typeof evmSignTypedData;
   evmVerifyMessage: typeof evmVerifyMessage;
 
+  /**
+   * BTC function
+   */
   btcGetAddress: typeof btcGetAddress;
   btcGetPublicKey: typeof btcGetPublicKey;
   btcSignMessage: typeof btcSignMessage;
   btcSignTransaction: typeof btcSignTransaction;
   btcVerifyMessage: typeof btcVerifyMessage;
 
+  /**
+   * Starcoin function
+   */
   starcoinGetAddress: typeof starcoinGetAddress;
   starcoinGetPublicKey: typeof starcoinGetPublicKey;
   starcoinSignMessage: typeof starcoinSignMessage;
   starcoinSignTransaction: typeof starcoinSignTransaction;
   starcoinVerifyMessage: typeof starcoinVerifyMessage;
 
+  /**
+   * Nem function
+   */
   nemGetAddress: typeof nemGetAddress;
   nemSignTransaction: typeof nemSignTransaction;
 
+  /**
+   * Solana function
+   */
   solGetAddress: typeof solGetAddress;
   solSignTransaction: typeof solSignTransaction;
 
+  /**
+   * Stellar function
+   */
   stellarGetAddress: typeof stellarGetAddress;
   stellarSignTransaction: typeof stellarSignTransaction;
 
-  firmwareUpdate: typeof firmwareUpdate;
+  /**
+   * Tron function
+   */
+  tronGetAddress: typeof tronGetAddress;
+  tronSignMessage: typeof tronSignMessage;
+  tronSignTransaction: typeof tronSignTransaction;
+
+  /**
+   * Conflux function
+   */
+  confluxGetAddress: typeof confluxGetAddress;
+  confluxSignMessage: typeof confluxSignMessage;
+  confluxSignMessageCIP23: typeof confluxSignMessageCIP23;
+  confluxSignTransaction: typeof confluxSignTransaction;
+
+  /**
+   * Near function
+   */
+  nearGetAddress: typeof nearGetAddress;
+  nearSignTransaction: typeof nearSignTransaction;
+
+  /**
+   * Aptos function
+   */
+  aptosGetAddress: typeof aptosGetAddress;
+  aptosSignTransaction: typeof aptosSignTransaction;
 };

package/src/types/api/nearGetAddress.ts

@@ -0,0 +1,23 @@
+import { NearAddress as HardwareNearAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type NearAddress = {
+  path: string;
+} & HardwareNearAddress;
+
+export type NearGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function nearGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & NearGetAddressParams,
+): Response<NearAddress>;
+
+export declare function nearGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: NearGetAddressParams[] },
+): Response<Array<NearAddress>>;

package/src/types/api/nearSignTransaction.ts

@@ -0,0 +1,13 @@
+import { NearSignedTx } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type NearSignTransactionParams = {
+  path: string | number[];
+  rawTx: string;
+};
+
+export declare function nearSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & NearSignTransactionParams,
+): Response<NearSignedTx>;

package/src/types/api/tronGetAddress.ts

@@ -0,0 +1,23 @@
+import { TronAddress as HardwareTronAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TronAddress = {
+  path: string;
+} & HardwareTronAddress;
+
+export type TronGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function tronGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & TronGetAddressParams,
+): Response<TronAddress>;
+
+export declare function tronGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: TronGetAddressParams[] },
+): Response<Array<TronAddress>>;

package/src/types/api/tronSignMessage.ts

@@ -0,0 +1,13 @@
+import { TronMessageSignature } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TronSignMessageParams = {
+  path: string | number[];
+  messageHex: string;
+};
+
+export declare function tronSignMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & TronSignMessageParams
+): Response<TronMessageSignature>;

package/src/types/api/tronSignTransaction.ts

@@ -0,0 +1,41 @@
+import { UintType, TronSignedTx } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TronTransferContract = {
+  toAddress?: string;
+  amount?: UintType;
+};
+
+export type TronTriggerSmartContract = {
+  contractAddress?: string;
+  callValue?: number;
+  data?: string;
+  callTokenValue?: number;
+  assetId?: number;
+};
+
+export type TronTransactionContract = {
+  transferContract?: TronTransferContract;
+  triggerSmartContract?: TronTriggerSmartContract;
+};
+
+export type TronTransaction = {
+  refBlockBytes: string;
+  refBlockHash: string;
+  expiration: number;
+  data?: string;
+  contract: TronTransactionContract;
+  timestamp: number;
+  feeLimit?: number;
+};
+
+export type TronSignTransactionParams = {
+  path: string | number[];
+  transaction: TronTransaction;
+};
+
+export declare function tronSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & TronSignTransactionParams,
+): Response<TronSignedTx>;

package/src/utils/deviceFeaturesUtils.ts

@@ -56,9 +56,9 @@ export const getDeviceTypeByDeviceId = (deviceId?: string): IDeviceType => {
 export const getDeviceUUID = (features: Features) => {
   const deviceType = getDeviceType(features);
   if (deviceType === 'classic') {
-    return features.onekey_serial;
+    return features.onekey_serial ?? '';
   }
-  return features.serial_no;
+  return features.serial_no ?? '';
 };
 
 export const getDeviceLabel = (features: Features) => {