@onekeyfe/hd-core 0.1.41 → 0.1.44

package/src/api/stellar/StellarSignTransaction.ts

@@ -1,9 +1,14 @@
-import { StellarSignedTx, StellarSignTx as HardwareStellarSignTx } from '@onekeyfe/hd-transport';
+import {
+  StellarMemoType,
+  StellarSignedTx,
+  StellarSignTx as HardwareStellarSignTx,
+} 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 { StellarOperation, StellarSignTransactionParams } from '../../types';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 export default class StellarSignTransaction extends BaseMethod<HardwareStellarSignTx> {
   operations: any[] = [];
@@ -153,9 +158,13 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
       { name: 'transaction', type: 'object', required: true },
     ]);
 
+    const { transaction, networkPassphrase } = this.payload as StellarSignTransactionParams;
+    if (!transaction.timebounds) {
+      throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'timebounds is required');
+    }
+
     // init params
     const addressN = validatePath(this.payload.path, 3);
-    const { transaction, networkPassphrase } = this.payload as StellarSignTransactionParams;
 
     this.params = {
       address_n: addressN,
@@ -164,13 +173,11 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
       fee: transaction.fee,
       sequence_number: transaction.sequence,
       num_operations: transaction.operations.length,
+      memo_type: StellarMemoType.NONE,
+      timebounds_start: transaction.timebounds.minTime,
+      timebounds_end: transaction.timebounds.maxTime,
     };
 
-    if (transaction.timebounds) {
-      this.params.timebounds_start = transaction.timebounds.minTime;
-      this.params.timebounds_end = transaction.timebounds.maxTime;
-    }
-
     if (transaction.memo) {
       this.params.memo_type = transaction.memo.type;
       this.params.memo_text = transaction.memo.text;

package/src/api/tron/TronGetAddress.ts

@@ -0,0 +1,68 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { TronGetAddressParams, TronAddress } from '../../types';
+import { TronGetAddress as HardwareTronGetAddress } from '@onekeyfe/hd-transport';
+
+export default class TronGetAddress extends BaseMethod<HardwareTronGetAddress[]> {
+  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: TronGetAddressParams) => {
+      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: TronAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('TronGetAddress', 'TronAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/tron/TronSignMessage.ts

@@ -0,0 +1,48 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { stripHexPrefix } from '../helpers/hexUtils';
+import { TronSignMessage as HardwareTronSignMessage } from '@onekeyfe/hd-transport';
+
+export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage> {
+  init() {
+    this.checkDeviceId = true;
+    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: stripHexPrefix(messageHex),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall(
+      'TronSignMessage',
+      'TronMessageSignature',
+      {
+        ...this.params,
+      },
+    );
+
+    return Promise.resolve(response.message);
+  }
+}

package/src/api/tron/TronSignTransaction.ts

@@ -0,0 +1,87 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { TronTransaction } from '../../types/api/tronSignTransaction';
+import { TronSignTx } from '@onekeyfe/hd-transport';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class TronSignTransaction extends BaseMethod<TronSignTx> {
+  parseTx(tx: TronTransaction, address_n: number[]): TronSignTx {
+    const unSignTx = {
+      address_n,
+      data: tx.data,
+      timestamp: tx.timestamp,
+      fee_limit: tx.feeLimit,
+      ref_block_bytes: tx.refBlockBytes,
+      ref_block_hash: tx.refBlockHash,
+      expiration: tx.expiration,
+      contract: {},
+    };
+
+    if (tx.contract) {
+      if (tx.contract.transferContract) {
+        unSignTx.contract = {
+          transfer_contract: {
+            to_address: tx.contract.transferContract.toAddress,
+            amount: tx.contract.transferContract.amount,
+          },
+        };
+      }
+      if (tx.contract.triggerSmartContract) {
+        unSignTx.contract = {
+          trigger_smart_contract: {
+            contract_address: tx.contract.triggerSmartContract.contractAddress,
+            call_value: tx.contract.triggerSmartContract.callValue,
+            data: tx.contract.triggerSmartContract.data,
+            call_token_value: tx.contract.triggerSmartContract.callTokenValue,
+            asset_id: tx.contract.triggerSmartContract.assetId,
+          },
+        };
+      }
+    }
+
+    return unSignTx;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+
+    const { path, transaction } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    validateParams(transaction, [
+      { name: 'refBlockBytes', type: 'hexString', required: true },
+      { name: 'refBlockHash', type: 'hexString', required: true },
+      { name: 'expiration', type: 'number', required: true },
+      { name: 'timestamp', type: 'number', required: true },
+      { name: 'contract', type: 'object', required: true },
+    ]);
+
+    // init params
+    this.params = this.parseTx(formatAnyHex(transaction), addressN);
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall('TronSignTx', 'TronSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(response.message);
+  }
+}

package/src/core/index.ts

@@ -242,7 +242,7 @@ export const callAPI = async (message: CoreMessage) => {
         }
       }
 
-      // 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.
       try {
         await method.checkSafetyLevelOnTestNet();
       } catch (e) {
@@ -640,7 +640,20 @@ export default class Core extends EventEmitter {
 
       case IFRAME.CALL: {
         const response = await callAPI(message);
-        return response;
+        const { success, payload } = response;
+
+        if (success) {
+          return response;
+        }
+
+        return {
+          ...response,
+          payload: {
+            ...payload,
+            connectId: message.payload?.connectId ?? '',
+            deviceId: message.payload?.deviceId ?? '',
+          },
+        };
       }
       case IFRAME.CANCEL: {
         cancel(message.payload.connectId);