@subwallet/extension-base 1.3.17-0 → 1.3.18-0

package/utils/fee/combine.d.ts

@@ -0,0 +1,12 @@
+import { EvmEIP1559FeeOption, EvmFeeInfo, FeeOption, SubstrateFeeInfo, SubstrateTipInfo } from '@subwallet/extension-base/types';
+interface EvmFeeCombine {
+    gasPrice?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+}
+export declare const combineEthFee: (feeInfo: EvmFeeInfo, feeOptions?: FeeOption, feeCustom?: EvmEIP1559FeeOption) => EvmFeeCombine;
+interface SubstrateFeeCombine {
+    tip: string;
+}
+export declare const combineSubstrateFee: (_fee: SubstrateFeeInfo, _feeOptions?: FeeOption, feeCustom?: SubstrateTipInfo) => SubstrateFeeCombine;
+export {};

package/utils/fee/combine.js

@@ -0,0 +1,42 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const combineEthFee = (feeInfo, feeOptions, feeCustom) => {
+  let maxFeePerGas;
+  let maxPriorityFeePerGas;
+  if (feeOptions && feeOptions !== 'custom') {
+    var _feeInfo$options, _feeInfo$options2;
+    maxFeePerGas = (_feeInfo$options = feeInfo.options) === null || _feeInfo$options === void 0 ? void 0 : _feeInfo$options[feeOptions].maxFeePerGas;
+    maxPriorityFeePerGas = (_feeInfo$options2 = feeInfo.options) === null || _feeInfo$options2 === void 0 ? void 0 : _feeInfo$options2[feeOptions].maxPriorityFeePerGas;
+  } else if (feeOptions === 'custom' && feeCustom) {
+    maxFeePerGas = feeCustom.maxFeePerGas;
+    maxPriorityFeePerGas = feeCustom.maxPriorityFeePerGas;
+  } else {
+    var _feeInfo$options3, _feeInfo$options4;
+    maxFeePerGas = (_feeInfo$options3 = feeInfo.options) === null || _feeInfo$options3 === void 0 ? void 0 : _feeInfo$options3[feeInfo.options.default].maxFeePerGas;
+    maxPriorityFeePerGas = (_feeInfo$options4 = feeInfo.options) === null || _feeInfo$options4 === void 0 ? void 0 : _feeInfo$options4[feeInfo.options.default].maxPriorityFeePerGas;
+  }
+  if (feeInfo.gasPrice) {
+    return {
+      gasPrice: feeInfo.gasPrice
+    };
+  } else {
+    return {
+      maxFeePerGas,
+      maxPriorityFeePerGas
+    };
+  }
+};
+export const combineSubstrateFee = (_fee, _feeOptions, feeCustom) => {
+  let tip;
+  if (_feeOptions && _feeOptions !== 'custom') {
+    tip = _fee.options[_feeOptions].tip;
+  } else if (_feeOptions === 'custom' && feeCustom && 'tip' in feeCustom) {
+    tip = feeCustom.tip;
+  } else {
+    tip = _fee.options[_fee.options.default].tip;
+  }
+  return {
+    tip
+  };
+};

package/utils/fee/index.d.ts

@@ -0,0 +1,2 @@
+export * from './combine';
+export * from './transfer';

package/utils/fee/index.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./combine.js";
+export * from "./transfer.js";

package/utils/fee/transfer.d.ts

@@ -0,0 +1,22 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { AmountData } from '@subwallet/extension-base/background/KoniTypes';
+import { _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { FeeChainType, FeeInfo, TransactionFee } from '@subwallet/extension-base/types';
+import { ResponseSubscribeTransfer } from '@subwallet/extension-base/types/balance/transfer';
+export interface CalculateMaxTransferable extends TransactionFee {
+    address: string;
+    srcToken: _ChainAsset;
+    destToken?: _ChainAsset;
+    srcChain: _ChainInfo;
+    destChain: _ChainInfo;
+    substrateApi: _SubstrateApi;
+    evmApi: _EvmApi;
+    tonApi: _TonApi;
+    isTransferLocalTokenAndPayThatTokenAsFee: boolean;
+    isTransferNativeTokenAndPayLocalTokenAsFee: boolean;
+    nativeToken: _ChainAsset;
+}
+export declare const detectTransferTxType: (srcToken: _ChainAsset, srcChain: _ChainInfo, destChain: _ChainInfo) => FeeChainType;
+export declare const calculateMaxTransferable: (id: string, request: CalculateMaxTransferable, freeBalance: AmountData, fee: FeeInfo) => Promise<ResponseSubscribeTransfer>;
+export declare const calculateTransferMaxTransferable: (id: string, request: CalculateMaxTransferable, freeBalance: AmountData, fee: FeeInfo) => Promise<ResponseSubscribeTransfer>;
+export declare const calculateXCMMaxTransferable: (id: string, request: CalculateMaxTransferable, freeBalance: AmountData, fee: FeeInfo) => Promise<ResponseSubscribeTransfer>;

package/utils/fee/transfer.js

@@ -0,0 +1,363 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { XCM_FEE_RATIO } from '@subwallet/extension-base/constants';
+import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/extension-base/services/balance-service/transfer/smart-contract';
+import { createTransferExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
+import { createTonTransaction } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
+import { createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, createPolygonBridgeExtrinsic, createSnowBridgeExtrinsic, createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { isAvailChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
+import { _isPolygonChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
+import { _isPosChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
+import { _getContractAddressOfToken, _isChainEvmCompatible, _isChainTonCompatible, _isLocalToken, _isNativeToken, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateToAmountByReservePool, FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE } from '@subwallet/extension-base/services/fee-service/utils';
+import { isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { BN_ZERO } from '@subwallet/extension-base/utils';
+import { isTonAddress } from '@subwallet/keyring';
+import BigN from 'bignumber.js';
+import { u8aToHex } from '@polkadot/util';
+import { addressToEvm, isEthereumAddress } from '@polkadot/util-crypto';
+import { combineEthFee, combineSubstrateFee } from "./combine.js";
+export const detectTransferTxType = (srcToken, srcChain, destChain) => {
+  const isXcmTransfer = srcChain.slug !== destChain.slug;
+  if (isXcmTransfer) {
+    const isAvailBridgeFromEvm = _isPureEvmChain(srcChain) && isAvailChainBridge(destChain.slug);
+    const isSnowBridgeEvmTransfer = _isPureEvmChain(srcChain) && _isSnowBridgeXcm(srcChain, destChain) && !isAvailBridgeFromEvm;
+    const isPolygonBridgeTransfer = _isPolygonChainBridge(srcChain.slug, destChain.slug);
+    const isPosBridgeTransfer = _isPosChainBridge(srcChain.slug, destChain.slug);
+    return isAvailBridgeFromEvm || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer ? 'evm' : 'substrate';
+  } else {
+    if (_isChainEvmCompatible(srcChain) && _isTokenTransferredByEvm(srcToken)) {
+      return 'evm';
+    } else if (_isChainTonCompatible(srcChain) && _isTokenTransferredByTon(srcToken)) {
+      return 'ton';
+    } else {
+      return 'substrate';
+    }
+  }
+};
+export const calculateMaxTransferable = async (id, request, freeBalance, fee) => {
+  const {
+    destChain,
+    srcChain
+  } = request;
+  const isXcmTransfer = srcChain.slug !== destChain.slug;
+  let maxTransferableAmount;
+  if (isXcmTransfer) {
+    maxTransferableAmount = await calculateXCMMaxTransferable(id, request, freeBalance, fee);
+  } else {
+    maxTransferableAmount = await calculateTransferMaxTransferable(id, request, freeBalance, fee);
+  }
+  maxTransferableAmount.feePercentageSpecialCase = FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE;
+  return maxTransferableAmount;
+};
+export const calculateTransferMaxTransferable = async (id, request, freeBalance, fee) => {
+  const {
+    address,
+    destChain,
+    evmApi,
+    feeCustom,
+    feeOption,
+    isTransferLocalTokenAndPayThatTokenAsFee,
+    isTransferNativeTokenAndPayLocalTokenAsFee,
+    nativeToken,
+    srcChain,
+    srcToken,
+    substrateApi,
+    tonApi
+  } = request;
+  const feeChainType = fee.type;
+  let estimatedFee;
+  let feeOptions;
+  let maxTransferable;
+  let error;
+  const fakeAddress = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+  const substrateAddress = fakeAddress; // todo: move this
+  const evmAddress = u8aToHex(addressToEvm(fakeAddress)); // todo: move this
+
+  const recipient = _isChainEvmCompatible(destChain) ? evmAddress : substrateAddress;
+  try {
+    let transaction;
+    if (isEthereumAddress(address) && isEthereumAddress(recipient) && _isTokenTransferredByEvm(srcToken)) {
+      // todo: refactor: merge getERC20TransactionObject & getEVMTransactionObject
+      // Estimate with EVM API
+      if (_isTokenEvmSmartContract(srcToken) || _isLocalToken(srcToken)) {
+        [transaction] = await getERC20TransactionObject({
+          assetAddress: _getContractAddressOfToken(srcToken),
+          chain: srcChain.slug,
+          evmApi,
+          feeCustom,
+          feeInfo: fee,
+          feeOption,
+          from: address,
+          to: recipient,
+          transferAll: false,
+          value: '0'
+        });
+      } else {
+        [transaction] = await getEVMTransactionObject({
+          chain: srcChain.slug,
+          evmApi,
+          feeCustom,
+          feeInfo: fee,
+          feeOption,
+          from: address,
+          to: recipient,
+          transferAll: false,
+          value: '0'
+        });
+      }
+    } else if (isTonAddress(address) && _isTokenTransferredByTon(srcToken)) {
+      [transaction] = await createTonTransaction({
+        tokenInfo: srcToken,
+        from: address,
+        to: address,
+        networkKey: srcChain.slug,
+        value: '0',
+        transferAll: false,
+        // currently not used
+        tonApi
+      });
+    } else {
+      [transaction] = await createTransferExtrinsic({
+        transferAll: false,
+        value: '0',
+        from: address,
+        networkKey: srcChain.slug,
+        tokenInfo: srcToken,
+        to: recipient,
+        substrateApi
+      });
+    }
+    if (feeChainType === 'evm') {
+      var _tx$gas;
+      // Calculate fee for evm transaction
+      const tx = transaction;
+      const gasLimit = ((_tx$gas = tx.gas) === null || _tx$gas === void 0 ? void 0 : _tx$gas.toString()) || (await evmApi.api.eth.estimateGas(tx)).toString();
+      const _feeCustom = feeCustom;
+      const combineFee = combineEthFee(fee, feeOption, _feeCustom);
+      if (combineFee.maxFeePerGas) {
+        estimatedFee = new BigN(combineFee.maxFeePerGas).multipliedBy(gasLimit).toFixed(0);
+      } else {
+        estimatedFee = new BigN(combineFee.gasPrice || '0').multipliedBy(gasLimit).toFixed(0);
+      }
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: gasLimit.toString()
+      };
+    } else if (feeChainType === 'substrate') {
+      // Calculate fee for substrate transaction
+      try {
+        var _paymentInfo$partialF;
+        const mockTx = transaction;
+        const paymentInfo = await mockTx.paymentInfo(address);
+        estimatedFee = (paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0';
+      } catch (e) {
+        estimatedFee = '0';
+      }
+      const _feeCustom = feeCustom;
+      const tip = combineSubstrateFee(fee, feeOption, _feeCustom).tip;
+      estimatedFee = new BigN(estimatedFee).plus(tip).toFixed(0);
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    } else {
+      if (transaction && isTonTransaction(transaction)) {
+        estimatedFee = transaction.estimateFee;
+        feeOptions = {
+          ...fee,
+          estimatedFee: estimatedFee
+        };
+      } else {
+        // Not implemented yet
+        estimatedFee = '0';
+        feeOptions = {
+          ...fee,
+          estimatedFee: '0'
+        };
+      }
+    }
+  } catch (e) {
+    estimatedFee = '0';
+    if (fee.type === 'evm') {
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: '0'
+      };
+    } else {
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    }
+    error = e.message || 'Unable to estimate fee';
+    console.warn('Unable to estimate fee', e);
+  }
+  if (isTransferLocalTokenAndPayThatTokenAsFee && feeChainType === 'substrate') {
+    const estimatedFeeNative = (BigInt(estimatedFee) * BigInt(FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE) / BigInt(100)).toString();
+    const estimatedFeeLocal = await calculateToAmountByReservePool(substrateApi.api, nativeToken, srcToken, estimatedFeeNative);
+    maxTransferable = BigN(freeBalance.value).minus(estimatedFeeLocal);
+  } else if (isTransferNativeTokenAndPayLocalTokenAsFee) {
+    maxTransferable = BigN(freeBalance.value);
+  } else {
+    if (!_isNativeToken(srcToken)) {
+      maxTransferable = BigN(freeBalance.value);
+    } else {
+      maxTransferable = BigN(freeBalance.value).minus(new BigN(estimatedFee));
+    }
+  }
+  return {
+    maxTransferable: maxTransferable.gt(BN_ZERO) ? maxTransferable.toFixed(0) || '0' : '0',
+    feeOptions: feeOptions,
+    feeType: feeChainType,
+    id: id,
+    error
+  };
+};
+export const calculateXCMMaxTransferable = async (id, request, freeBalance, fee) => {
+  const {
+    address,
+    destChain,
+    destToken,
+    evmApi,
+    feeCustom,
+    feeOption,
+    isTransferLocalTokenAndPayThatTokenAsFee,
+    isTransferNativeTokenAndPayLocalTokenAsFee,
+    nativeToken,
+    srcChain,
+    srcToken,
+    substrateApi
+  } = request;
+  const feeChainType = fee.type;
+  let estimatedFee;
+  let feeOptions;
+  let maxTransferable;
+  let error;
+  const isAvailBridgeFromEvm = _isPureEvmChain(srcChain) && isAvailChainBridge(destChain.slug);
+  const isAvailBridgeFromAvail = isAvailChainBridge(srcChain.slug) && _isPureEvmChain(destChain);
+  const isSnowBridgeEvmTransfer = _isPureEvmChain(srcChain) && _isSnowBridgeXcm(srcChain, destChain) && !isAvailBridgeFromEvm;
+  const isPolygonBridgeTransfer = _isPolygonChainBridge(srcChain.slug, destChain.slug);
+  const isPosBridgeTransfer = _isPosChainBridge(srcChain.slug, destChain.slug);
+  const fakeAddress = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+  const substrateAddress = fakeAddress; // todo: move this
+  const evmAddress = u8aToHex(addressToEvm(fakeAddress)); // todo: move this
+
+  const recipient = _isChainEvmCompatible(destChain) ? evmAddress : substrateAddress;
+  try {
+    if (!destToken) {
+      throw Error('Destination token is not available');
+    }
+    const params = {
+      destinationTokenInfo: destToken,
+      originTokenInfo: srcToken,
+      // If value is 0, substrate will throw error when estimating fee
+      sendingValue: feeChainType === 'substrate' ? '1000000000000000000' : '0',
+      sender: address,
+      recipient,
+      destinationChain: destChain,
+      originChain: srcChain,
+      substrateApi,
+      evmApi,
+      feeCustom,
+      feeOption,
+      feeInfo: fee
+    };
+    let funcCreateExtrinsic;
+    if (isPosBridgeTransfer || isPolygonBridgeTransfer) {
+      funcCreateExtrinsic = createPolygonBridgeExtrinsic;
+    } else if (isSnowBridgeEvmTransfer) {
+      funcCreateExtrinsic = createSnowBridgeExtrinsic;
+    } else if (isAvailBridgeFromEvm) {
+      funcCreateExtrinsic = createAvailBridgeTxFromEth;
+    } else if (isAvailBridgeFromAvail) {
+      funcCreateExtrinsic = createAvailBridgeExtrinsicFromAvail;
+    } else {
+      funcCreateExtrinsic = createXcmExtrinsic;
+    }
+    const extrinsic = await funcCreateExtrinsic(params);
+    if (feeChainType === 'evm') {
+      var _tx$gas2;
+      // Calculate fee for evm transaction
+      const tx = extrinsic;
+      const gasLimit = ((_tx$gas2 = tx.gas) === null || _tx$gas2 === void 0 ? void 0 : _tx$gas2.toString()) || (await evmApi.api.eth.estimateGas(tx)).toString();
+      const _feeCustom = feeCustom;
+      const combineFee = combineEthFee(fee, feeOption, _feeCustom);
+      if (combineFee.maxFeePerGas) {
+        estimatedFee = new BigN(combineFee.maxFeePerGas).multipliedBy(gasLimit).toFixed(0);
+      } else {
+        estimatedFee = new BigN(combineFee.gasPrice || '0').multipliedBy(gasLimit).toFixed(0);
+      }
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: gasLimit.toString()
+      };
+    } else if (feeChainType === 'substrate') {
+      // Calculate fee for substrate transaction
+      try {
+        var _paymentInfo$partialF2;
+        const paymentInfo = await extrinsic.paymentInfo(address);
+        estimatedFee = (paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF2 = paymentInfo.partialFee) === null || _paymentInfo$partialF2 === void 0 ? void 0 : _paymentInfo$partialF2.toString()) || '0';
+      } catch (e) {
+        estimatedFee = '0';
+      }
+      const _feeCustom = feeCustom;
+      const tip = combineSubstrateFee(fee, feeOption, _feeCustom).tip;
+      estimatedFee = new BigN(estimatedFee).plus(tip).toFixed(0);
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    } else {
+      // Not implemented yet
+      estimatedFee = '0';
+      feeOptions = {
+        ...fee,
+        estimatedFee: '0'
+      };
+    }
+  } catch (e) {
+    estimatedFee = '0';
+    if (fee.type === 'evm') {
+      feeOptions = {
+        ...fee,
+        estimatedFee,
+        gasLimit: '0'
+      };
+    } else {
+      feeOptions = {
+        ...fee,
+        estimatedFee
+      };
+    }
+    error = e.message || 'Unable to estimate fee';
+    console.warn('Unable to estimate fee', e);
+  }
+  if (!destToken) {
+    maxTransferable = BN_ZERO;
+  } else if (isTransferLocalTokenAndPayThatTokenAsFee && feeChainType === 'substrate') {
+    const estimatedFeeNative = (BigInt(estimatedFee) * BigInt(FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE) / BigInt(100)).toString();
+    const estimatedFeeLocal = await calculateToAmountByReservePool(substrateApi.api, nativeToken, srcToken, estimatedFeeNative);
+    maxTransferable = BigN(freeBalance.value).minus(estimatedFeeLocal);
+  } else if (isTransferNativeTokenAndPayLocalTokenAsFee) {
+    maxTransferable = BigN(freeBalance.value);
+  } else {
+    if (!_isNativeToken(srcToken)) {
+      maxTransferable = BigN(freeBalance.value);
+    } else {
+      maxTransferable = BigN(freeBalance.value).minus(new BigN(estimatedFee).multipliedBy(XCM_FEE_RATIO));
+    }
+  }
+  return {
+    maxTransferable: maxTransferable.gt(BN_ZERO) ? maxTransferable.toFixed(0) || '0' : '0',
+    feeOptions: feeOptions,
+    feeType: feeChainType,
+    id: id,
+    error
+  };
+};

package/utils/index.d.ts

@@ -55,6 +55,7 @@ export * from './asset';
 export * from './auth';
 export * from './environment';
 export * from './eth';
+export * from './fee';
 export * from './fetchEvmChainInfo';
 export * from './fetchStaticData';
 export * from './gear';

package/utils/index.js

@@ -330,6 +330,7 @@ export * from "./asset.js";
 export * from "./auth.js";
 export * from "./environment.js";
 export * from "./eth.js";
+export * from "./fee/index.js";
 export * from "./fetchEvmChainInfo.js";
 export * from "./fetchStaticData.js";
 export * from "./gear/index.js";