@onekeyfe/hd-core 0.1.41 → 0.1.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "0.1.41",
+  "version": "0.1.44",
   "description": "> TODO: description",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -24,8 +24,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "^0.1.41",
-    "@onekeyfe/hd-transport": "^0.1.41",
+    "@onekeyfe/hd-shared": "^0.1.44",
+    "@onekeyfe/hd-transport": "^0.1.44",
     "axios": "^0.27.2",
     "bignumber.js": "^9.0.2",
     "js-sha256": "^0.9.0",
@@ -36,5 +36,5 @@
     "@types/parse-uri": "^1.0.0",
     "@types/semver": "^7.3.9"
   },
-  "gitHead": "0c5bf8f29b26ee02a5587aa716db4dfd7b17defd"
+  "gitHead": "fb673918587877267cbbeca6e0c6abbc56a0d0fa"
 }

package/src/api/BaseMethod.ts

@@ -133,14 +133,17 @@ export abstract class BaseMethod<Params = undefined> {
   }
 
   /**
-   * Check the level of safety_check when performing transactions on the test network on touch
+   * Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
    * @returns {void}
    */
   async checkSafetyLevelOnTestNet() {
     const deviceType = getDeviceType(this.device.features);
     if (deviceType !== 'touch') return;
     let checkFlag = false;
-    if (this.name === 'evmSignTransaction' && Number(this.payload?.transaction?.chainId) !== 1) {
+    if (
+      this.name === 'evmSignTransaction' &&
+      [3, 4, 5, 42].includes(Number(this.payload?.transaction?.chainId))
+    ) {
       checkFlag = true;
     }
     if (checkFlag && this.device.features?.safety_checks === 'Strict') {

package/src/api/aptos/AptosGetAddress.ts

@@ -0,0 +1,60 @@
+import { AptosGetAddress as HardwareAptosGetAddress } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { AptosAddress, AptosGetAddressParams } from '../../types';
+
+export default class AptosGetAddress extends BaseMethod<HardwareAptosGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: AptosGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  async run() {
+    const responses: AptosAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('AptosGetAddress', 'AptosAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/aptos/AptosSignTransaction.ts

@@ -0,0 +1,45 @@
+import { AptosSignTx as HardwareAptosSignTx } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class AptosSignTransaction extends BaseMethod<HardwareAptosSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    const { path, rawTx } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('AptosSignTx', 'AptosSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/conflux/ConfluxGetAddress.ts

@@ -0,0 +1,67 @@
+import { ConfluxGetAddress as HardwareConfluxGetAddress } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { ConfluxAddress, ConfluxGetAddressParams } from '../../types/api/confluxGetAddress';
+
+export default class ConfluxGetAddress extends BaseMethod<HardwareConfluxGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: ConfluxGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'chainId', type: 'number' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        chain_id: batch.chainId,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: ConfluxAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('ConfluxGetAddress', 'ConfluxAddress', {
+        ...param,
+      });
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        ...res.message,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/conflux/ConfluxSignMessage.ts

@@ -0,0 +1,48 @@
+import { ConfluxSignMessage as HardwareConfluxSignMessage } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class ConfluxSignMessage extends BaseMethod<HardwareConfluxSignMessage> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+    ]);
+
+    const { path, messageHex } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: formatAnyHex(messageHex),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'ConfluxSignMessage',
+      'ConfluxMessageSignature',
+      {
+        ...this.params,
+      },
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/conflux/ConfluxSignMessageCIP23.ts

@@ -0,0 +1,48 @@
+import { ConfluxSignMessageCIP23 as HardwareConfluxSignMessageCIP23 } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class ConfluxSignMessageCIP23 extends BaseMethod<HardwareConfluxSignMessageCIP23> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'domainHash', type: 'hexString', required: true },
+      { name: 'messageHash', type: 'hexString', required: true },
+    ]);
+
+    const { path, domainHash, messageHash } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      domain_hash: formatAnyHex(domainHash),
+      message_hash: formatAnyHex(messageHash),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'ConfluxSignMessageCIP23',
+      'ConfluxMessageSignature',
+      {
+        ...this.params,
+      },
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/conflux/ConfluxSignTransaction.ts

@@ -0,0 +1,134 @@
+import { ConfluxSignTx, ConfluxTxRequest } from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import {
+  ConfluxSignedTx,
+  ConfluxSignTransactionParams,
+  ConfluxTransaction,
+} from '../../types/api/confluxSignTransaction';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { SchemaParam, validateParams } from '../helpers/paramsValidator';
+
+import { cutString } from '../helpers/stringUtils';
+import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
+
+export default class ConfluxSignTransaction extends BaseMethod {
+  addressN: number[] = [];
+
+  formattedTx: ConfluxTransaction | undefined;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+    const { path, transaction } = this.payload;
+    this.addressN = validatePath(path, 3);
+
+    const tx: ConfluxSignTransactionParams['transaction'] = transaction;
+
+    // check if transaction is valid
+    const schema: SchemaParam[] = [
+      { name: 'to', type: 'hexString', required: true },
+      { name: 'value', type: 'hexString', required: true },
+      { name: 'gasLimit', type: 'hexString', required: true },
+      { name: 'gasPrice', type: 'hexString', required: true },
+      { name: 'nonce', type: 'hexString', required: true },
+      { name: 'epochHeight', type: 'hexString', required: true },
+      { name: 'storageLimit', type: 'hexString', required: true },
+      { name: 'chainId', type: 'number', required: true },
+      { name: 'data', type: 'hexString' },
+    ];
+
+    validateParams(tx, schema);
+
+    this.formattedTx = formatAnyHex(tx);
+  }
+
+  processTxRequest = async (request: ConfluxTxRequest, data: string): Promise<ConfluxSignedTx> => {
+    if (!request.data_length) {
+      const v = request.signature_v;
+      const r = request.signature_r;
+      const s = request.signature_s;
+
+      if (v == null || r == null || s == null) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'sign transaction failed');
+      }
+
+      return Promise.resolve({
+        v: `0x${v.toString(16)}`,
+        r: `0x${r}`,
+        s: `0x${s}`,
+      });
+    }
+
+    const [first, rest] = cutString(data, request.data_length * 2);
+    const response = await this.device.commands.typedCall('ConfluxTxAck', 'ConfluxTxRequest', {
+      data_chunk: first,
+    });
+
+    return this.processTxRequest(response.message, rest);
+  };
+
+  evmSignTx = async (addressN: number[], tx: ConfluxTransaction) => {
+    const { to, value, gasPrice, gasLimit, nonce, data, chainId, epochHeight, storageLimit } = tx;
+
+    const length = data == null ? 0 : data.length / 2;
+
+    const [first, rest] = cutString(data, 1024 * 2);
+
+    let message: ConfluxSignTx = {
+      address_n: addressN,
+      nonce: stripHexStartZeroes(nonce),
+      gas_price: stripHexStartZeroes(gasPrice),
+      gas_limit: stripHexStartZeroes(gasLimit),
+      to,
+      value: stripHexStartZeroes(value),
+      epoch_height: stripHexStartZeroes(epochHeight),
+      storage_limit: stripHexStartZeroes(storageLimit),
+      chain_id: chainId,
+    };
+
+    if (length !== 0) {
+      message = {
+        ...message,
+        data_length: length,
+        data_initial_chunk: first,
+      };
+    }
+
+    const response = await this.device.commands.typedCall(
+      'ConfluxSignTx',
+      'ConfluxTxRequest',
+      message,
+    );
+
+    return this.processTxRequest(response.message, rest);
+  };
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const { addressN, formattedTx } = this;
+    if (formattedTx == null) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'ConfluxSignTransaction: format tx error',
+      );
+    }
+
+    const signedTx = await this.evmSignTx(addressN, formattedTx);
+
+    return Promise.resolve(signedTx);
+  }
+}

package/src/api/helpers/stringUtils.ts

@@ -6,3 +6,6 @@ export const cutString = (str: string | undefined, cutLen: number): [string, str
   const second = str.slice(cutLen);
   return [first, second];
 };
+
+export const toSnakeCase = (val: string): string =>
+  val.replace(/([A-Z])/g, el => '_' + el.toLowerCase());

package/src/api/index.ts

@@ -1,11 +1,7 @@
 export { default as searchDevices } from './SearchDevices';
 export { default as getFeatures } from './GetFeatures';
-export { default as cipherKeyValue } from './CipherKeyValue';
-export { default as btcGetAddress } from './btc/BTCGetAddress';
-export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
-export { default as btcSignMessage } from './btc/BTCSignMessage';
-export { default as btcSignTransaction } from './btc/BTCSignTransaction';
-export { default as btcVerifyMessage } from './btc/BTCVerifyMessage';
+export { default as getPassphraseState } from './GetPassphraseState';
+export { default as getLogs } from './GetLogs';
 export { default as checkFirmwareRelease } from './CheckFirmwareRelease';
 export { default as checkBLEFirmwareRelease } from './CheckBLEFirmwareRelease';
 export { default as checkTransportRelease } from './CheckTransportRelease';
@@ -21,6 +17,22 @@ export { default as deviceUpdateReboot } from './device/DeviceUpdateReboot';
 export { default as deviceSupportFeatures } from './device/DeviceSupportFeatures';
 export { default as deviceVerify } from './device/DeviceVerify';
 export { default as deviceWipe } from './device/DeviceWipe';
+export { default as firmwareUpdate } from './FirmwareUpdate';
+export { default as requestWebUsbDevice } from './RequestWebUsbDevice';
+
+export { default as cipherKeyValue } from './CipherKeyValue';
+
+export { default as btcGetAddress } from './btc/BTCGetAddress';
+export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
+export { default as btcSignMessage } from './btc/BTCSignMessage';
+export { default as btcSignTransaction } from './btc/BTCSignTransaction';
+export { default as btcVerifyMessage } from './btc/BTCVerifyMessage';
+
+export { default as confluxGetAddress } from './conflux/ConfluxGetAddress';
+export { default as confluxSignMessage } from './conflux/ConfluxSignMessage';
+export { default as confluxSignMessageCIP23 } from './conflux/ConfluxSignMessageCIP23';
+export { default as confluxSignTransaction } from './conflux/ConfluxSignTransaction';
+
 export { default as evmGetAddress } from './evm/EVMGetAddress';
 export { default as evmGetPublicKey } from './evm/EVMGetPublicKey';
 export { default as evmSignMessage } from './evm/EVMSignMessage';
@@ -28,6 +40,7 @@ export { default as evmSignMessageEIP712 } from './evm/EVMSignMessageEIP712';
 export { default as evmSignTransaction } from './evm/EVMSignTransaction';
 export { default as evmSignTypedData } from './evm/EVMSignTypedData';
 export { default as evmVerifyMessage } from './evm/EVMVerifyMessage';
+
 export { default as starcoinGetAddress } from './starcoin/StarcoinGetAddress';
 export { default as starcoinGetPublicKey } from './starcoin/StarcoinGetPublicKey';
 export { default as starcoinSignMessage } from './starcoin/StarcoinSignMessage';
@@ -43,9 +56,12 @@ export { default as solSignTransaction } from './solana/SolSignTransaction';
 export { default as stellarGetAddress } from './stellar/StellarGetAddress';
 export { default as stellarSignTransaction } from './stellar/StellarSignTransaction';
 
-export { default as firmwareUpdate } from './FirmwareUpdate';
+export { default as tronGetAddress } from './tron/TronGetAddress';
+export { default as tronSignMessage } from './tron/TronSignMessage';
+export { default as tronSignTransaction } from './tron/TronSignTransaction';
 
-export { default as requestWebUsbDevice } from './RequestWebUsbDevice';
+export { default as nearGetAddress } from './near/NearGetAddress';
+export { default as nearSignTransaction } from './near/NearSignTransaction';
 
-export { default as getPassphraseState } from './GetPassphraseState';
-export { default as getLogs } from './GetLogs';
+export { default as aptosGetAddress } from './aptos/AptosGetAddress';
+export { default as aptosSignTransaction } from './aptos/AptosSignTransaction';

package/src/api/near/NearGetAddress.ts

@@ -0,0 +1,68 @@
+import { NearGetAddress as HardwareNearGetAddress } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { NearGetAddressParams, NearAddress } from '../../types';
+
+export default class NearGetAddress extends BaseMethod<HardwareNearGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: NearGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: NearAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NearGetAddress', 'NearAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/near/NearSignTransaction.ts

@@ -0,0 +1,45 @@
+import { NearSignTx as HardwareNearSignTx } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class NearSignTransaction extends BaseMethod<HardwareNearSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    const { path, rawTx } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('NearSignTx', 'NearSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/solana/SolGetAddress.ts

@@ -43,12 +43,10 @@ export default class SolGetAddress extends BaseMethod<SolanaGetAddress[]> {
     for (let i = 0; i < this.params.length; i++) {
       const param = this.params[i];
 
-      // @ts-expect-error
       const res = await this.device.commands.typedCall('SolanaGetAddress', 'SolanaAddress', {
         ...param,
       });
 
-      // @ts-expect-error
       const { address } = res.message;
 
       responses.push({

package/src/api/solana/SolSignTransaction.ts

@@ -53,12 +53,10 @@ export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[
     for (let i = 0; i < this.params.length; i++) {
       const param = this.params[i];
 
-      // @ts-expect-error
       const res = await this.device.commands.typedCall('SolanaSignTx', 'SolanaSignedTx', {
         ...param,
       });
 
-      // @ts-expect-error
       const { signature } = res.message;
 
       responses.push({