@subwallet/extension-base 1.2.3-0 → 1.2.4-0

package/core/logic-validation/transfer.js

@@ -0,0 +1,199 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, BasicTxWarningCode, ExtrinsicType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
+import { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
+import { _canAccountBeReaped } from '@subwallet/extension-base/core/substrate/system-pallet';
+import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getTokenMinAmount, _isNativeToken, _isTokenEvmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { balanceFormatter, formatNumber } from '@subwallet/extension-base/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
+import { t } from 'i18next';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+
+// normal transfer
+export function validateTransferRequest(tokenInfo, from, to, value, transferAll) {
+  const errors = [];
+  const keypair = keyring.getPair(from);
+  let transferValue;
+  if (!transferAll) {
+    if (value === undefined) {
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Transfer amount is required')));
+    }
+    if (value) {
+      transferValue = new BigN(value);
+    }
+  }
+  if (!tokenInfo) {
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found token from registry')));
+  }
+  if (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenEvmSmartContract(tokenInfo) && _getContractAddressOfToken(tokenInfo).length === 0) {
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found ERC20 address for this token')));
+  }
+  return [errors, keypair, transferValue];
+}
+export function additionalValidateTransfer(tokenInfo, extrinsicType, receiverTransferTokenFreeBalance, transferAmount, senderTransferTokenTransferable) {
+  const minAmount = _getTokenMinAmount(tokenInfo);
+  let warning;
+  let error;
+
+  // Check ed of not native token for sender
+  if (extrinsicType === ExtrinsicType.TRANSFER_TOKEN && senderTransferTokenTransferable) {
+    if (new BigN(senderTransferTokenTransferable).minus(transferAmount).lt(minAmount)) {
+      warning = new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+  }
+
+  // Check ed for receiver
+  if (new BigN(receiverTransferTokenFreeBalance).plus(transferAmount).lt(minAmount)) {
+    const atLeast = new BigN(minAmount).minus(receiverTransferTokenFreeBalance).plus((tokenInfo.decimals || 0) === 0 ? 0 : 1);
+    const atLeastStr = formatNumber(atLeast, tokenInfo.decimals || 0, balanceFormatter, {
+      maxNumberFormat: tokenInfo.decimals || 6
+    });
+    error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('You must transfer at least {{amount}} {{symbol}} to keep the destination account alive', {
+      replace: {
+        amount: atLeastStr,
+        symbol: tokenInfo.symbol
+      }
+    }));
+  }
+  return [warning, error];
+}
+
+// xcm transfer
+export function validateXcmTransferRequest(destTokenInfo, sender, sendingValue) {
+  const errors = [];
+  const keypair = keyring.getPair(sender);
+  const transferValue = new BigN(sendingValue);
+  if (!destTokenInfo) {
+    errors.push(new TransactionError(TransferTxErrorType.INVALID_TOKEN, t('Not found token from registry')));
+  }
+  return [errors, keypair, transferValue];
+}
+export function additionalValidateXcmTransfer(originTokenInfo, destinationTokenInfo, sendingAmount, senderTransferable) {
+  const destMinAmount = _getTokenMinAmount(destinationTokenInfo);
+  const minSendingRequired = new BigN(destMinAmount).multipliedBy(XCM_MIN_AMOUNT_RATIO);
+  let error;
+  let warning;
+
+  // Check ed for receiver
+  if (new BigN(sendingAmount).lt(minSendingRequired)) {
+    const atLeastStr = formatNumber(minSendingRequired, destinationTokenInfo.decimals || 0, balanceFormatter, {
+      maxNumberFormat: destinationTokenInfo.decimals || 6
+    });
+    error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('You must transfer at least {{amount}} {{symbol}} to keep the destination account alive', {
+      replace: {
+        amount: atLeastStr,
+        symbol: originTokenInfo.symbol
+      }
+    }));
+  }
+
+  // Check ed for sender
+  if (!_isNativeToken(originTokenInfo)) {
+    if (new BigN(senderTransferable).minus(sendingAmount).lt(_getTokenMinAmount(originTokenInfo))) {
+      warning = new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+  }
+  return [warning, error];
+}
+
+// general validations
+export function checkSupportForTransaction(validationResponse, transaction) {
+  const {
+    extrinsicType
+  } = validationResponse;
+  if (!transaction) {
+    if (extrinsicType === ExtrinsicType.SEND_NFT) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED, t('This feature is not yet available for this NFT')));
+    } else {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+  }
+}
+export async function estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi) {
+  const estimateFee = {
+    symbol: '',
+    decimals: 0,
+    value: '0',
+    tooHigh: false
+  };
+  const {
+    decimals,
+    symbol
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  estimateFee.decimals = decimals;
+  estimateFee.symbol = symbol;
+  if (transaction) {
+    try {
+      if (isSubstrateTransaction(transaction)) {
+        estimateFee.value = (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
+      } else {
+        const gasLimit = await evmApi.api.eth.estimateGas(transaction);
+        const priority = await calculateGasFeeParams(evmApi, chainInfo.slug);
+        if (priority.baseGasFee) {
+          const maxFee = priority.maxFeePerGas; // TODO: Need review
+
+          estimateFee.value = maxFee.multipliedBy(gasLimit).toFixed(0);
+        } else {
+          estimateFee.value = new BigN(priority.gasPrice).multipliedBy(gasLimit).toFixed(0);
+        }
+        estimateFee.tooHigh = priority.busyNetwork;
+      }
+    } catch (e) {
+      const error = e;
+      if (error.message.includes('gas required exceeds allowance') && error.message.includes('insufficient funds')) {
+        validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+      }
+    }
+  }
+  return estimateFee;
+}
+export function checkSigningAccountForTransaction(validationResponse) {
+  const pair = keyring.getPair(validationResponse.address);
+  if (!pair) {
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Unable to find account')));
+  } else {
+    var _pair$meta;
+    if ((_pair$meta = pair.meta) !== null && _pair$meta !== void 0 && _pair$meta.isReadOnly) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('This account is watch-only')));
+    }
+  }
+}
+export function checkBalanceWithTransactionFee(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable) {
+  if (!validationResponse.estimateFee) {
+    // todo: estimateFee should be must-have, need to refactor interface
+    return;
+  }
+  const {
+    edAsWarning,
+    extrinsicType,
+    isTransferAll,
+    skipFeeValidation
+  } = transactionInput;
+  if (skipFeeValidation) {
+    return;
+  }
+  const bnFee = new BigN(validationResponse.estimateFee.value);
+  const bnNativeTokenAvailable = new BigN(nativeTokenAvailable.value);
+  const bnNativeTokenTransferAmount = new BigN(validationResponse.transferNativeAmount || '0');
+  if (!bnNativeTokenAvailable.gt(0)) {
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+  }
+  const isChainNotSupportTransferAll = [..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.genshiro, ..._TRANSFER_CHAIN_GROUP.bitcountry, ..._TRANSFER_CHAIN_GROUP.statemine].includes(nativeTokenInfo.originChain);
+  if (bnNativeTokenTransferAmount.plus(bnFee).gt(bnNativeTokenAvailable) && (!isTransferAll || isChainNotSupportTransferAll)) {
+    validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE)); // todo: should be generalized and reused in all features
+  }
+
+  // todo: only system.pallet has metadata, we should add for other pallets and mechanisms as well
+  const isNeedCheckRemainingBalance = !isTransferAll && extrinsicType === ExtrinsicType.TRANSFER_BALANCE && nativeTokenAvailable.metadata && _canAccountBeReaped(nativeTokenAvailable.metadata);
+  const isRemainingBalanceValid = bnNativeTokenAvailable.minus(bnNativeTokenTransferAmount).minus(bnFee).lt(_getTokenMinAmount(nativeTokenInfo));
+  if (isNeedCheckRemainingBalance && isRemainingBalanceValid) {
+    edAsWarning ? validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT)) : validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
+  }
+}

package/core/substrate/nominationpools-pallet.d.ts

@@ -0,0 +1,10 @@
+import BigN from 'bignumber.js';
+export declare type PalletNominationPoolsPoolMember = {
+    poolId: number;
+    points: number;
+    lastRecordedRewardCounter: number;
+    unbondingEras: Record<string, number>;
+};
+export declare function _getActiveStakeInNominationPool(memberInfo: PalletNominationPoolsPoolMember): BigN;
+export declare function _getUnbondingStakeInNominationPool(memberInfo: PalletNominationPoolsPoolMember): BigN;
+export declare function _getTotalStakeInNominationPool(memberInfo: PalletNominationPoolsPoolMember): BigN;

package/core/substrate/nominationpools-pallet.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import BigN from 'bignumber.js';
+export function _getActiveStakeInNominationPool(memberInfo) {
+  return new BigN(memberInfo.points.toString());
+}
+export function _getUnbondingStakeInNominationPool(memberInfo) {
+  return new BigN(Object.values(memberInfo.unbondingEras).reduce((a, b) => a + b, 0));
+}
+export function _getTotalStakeInNominationPool(memberInfo) {
+  return _getActiveStakeInNominationPool(memberInfo).plus(_getUnbondingStakeInNominationPool(memberInfo));
+}

package/core/substrate/system-pallet.d.ts

@@ -0,0 +1,27 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+export declare type FrameSystemAccountInfoV2 = Omit<FrameSystemAccountInfoV1, 'data'> & {
+    data: {
+        free: number;
+        reserved: number;
+        frozen: number;
+        flags: number;
+    };
+};
+export declare type FrameSystemAccountInfoV1 = {
+    nonce: number;
+    consumers: number;
+    providers: number;
+    sufficients: number;
+    data: {
+        free: number | string;
+        reserved: number;
+        miscFrozen: number;
+        feeFrozen: number;
+    };
+};
+export declare type FrameSystemAccountInfo = FrameSystemAccountInfoV1 | FrameSystemAccountInfoV2;
+export declare function _getSystemPalletTransferable(accountInfo: FrameSystemAccountInfo, existentialDeposit: string, extrinsicType?: ExtrinsicType): string;
+export declare function _canAccountBeReaped(accountInfo: FrameSystemAccountInfo): boolean;
+export declare function _isAccountActive(accountInfo: FrameSystemAccountInfo): boolean;
+export declare function _getSystemPalletTotalBalance(accountInfo: FrameSystemAccountInfo): string;
+export declare function _getAppliedExistentialDepositWithExtrinsicType(accountInfo: FrameSystemAccountInfo, existentialDeposit: string, extrinsicType?: ExtrinsicType): string;

package/core/substrate/system-pallet.js

@@ -0,0 +1,70 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import BigN from 'bignumber.js';
+
+// https://crates.parity.io/frame_system/struct.AccountInfo.html
+// https://wiki.polkadot.network/docs/learn-account-balances
+
+function isV1(accountInfo) {
+  return accountInfo.data.miscFrozen !== undefined && accountInfo.data.feeFrozen !== undefined;
+}
+export function _getSystemPalletTransferable(accountInfo, existentialDeposit, extrinsicType) {
+  const strictMode = !extrinsicType || ![ExtrinsicType.TRANSFER_BALANCE].includes(extrinsicType); // always apply strict mode to keep account alive unless explicitly specified otherwise
+
+  if (isV1(accountInfo)) {
+    return _getSystemPalletTransferableV1(accountInfo, existentialDeposit, strictMode);
+  } else {
+    return _getSystemPalletTransferableV2(accountInfo, existentialDeposit, strictMode);
+  }
+}
+export function _canAccountBeReaped(accountInfo) {
+  return accountInfo.consumers === 0; // might need to check refCount
+}
+
+export function _isAccountActive(accountInfo) {
+  return accountInfo.providers === 0 && accountInfo.consumers === 0;
+}
+export function _getSystemPalletTotalBalance(accountInfo) {
+  if (isV1(accountInfo)) {
+    return _getSystemPalletTotalBalanceV1(accountInfo);
+  } else {
+    return _getSystemPalletTotalBalanceV2(accountInfo);
+  }
+}
+export function _getAppliedExistentialDepositWithExtrinsicType(accountInfo, existentialDeposit, extrinsicType) {
+  const strictMode = !extrinsicType || ![ExtrinsicType.TRANSFER_BALANCE].includes(extrinsicType); // always apply strict mode to keep account alive unless explicitly specified otherwise
+
+  return _getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode);
+}
+
+// ----------------------------------------------------------------------
+
+function _getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode) {
+  // strict mode will always apply existential deposit to keep account alive
+  if (strictMode) {
+    return existentialDeposit;
+  }
+  return _canAccountBeReaped(accountInfo) ? '0' : existentialDeposit; // account for ED here will go better with max transfer logic
+}
+
+function _getSystemPalletTransferableV2(accountInfo, existentialDeposit, strictMode) {
+  const bnFree = new BigN(accountInfo.data.free);
+  const bnLocked = new BigN(accountInfo.data.frozen).minus(accountInfo.data.reserved); // locked can go below 0 but this shouldn't matter
+  const bnAppliedExistentialDeposit = new BigN(_getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode));
+  const bnTransferableBalance = bnFree.minus(BigN.max(bnLocked, bnAppliedExistentialDeposit));
+  return BigN.max(bnTransferableBalance, 0).toFixed();
+}
+function _getSystemPalletTotalBalanceV2(accountInfo) {
+  return new BigN(accountInfo.data.free).plus(accountInfo.data.reserved).toFixed();
+}
+function _getSystemPalletTransferableV1(accountInfo, existentialDeposit, strictMode) {
+  const bnAppliedExistentialDeposit = new BigN(_getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode));
+  const bnAppliedFrozen = BigN.max(accountInfo.data.feeFrozen, accountInfo.data.miscFrozen);
+  const bnTransferableBalance = new BigN(accountInfo.data.free).minus(BigN.max(bnAppliedFrozen, bnAppliedExistentialDeposit));
+  return BigN.max(bnTransferableBalance, 0).toFixed();
+}
+function _getSystemPalletTotalBalanceV1(accountInfo) {
+  return new BigN(accountInfo.data.free).plus(accountInfo.data.reserved).toFixed();
+}

package/core/substrate/xcm-parser.d.ts

@@ -0,0 +1,49 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { _Address } from '@subwallet/extension-base/background/KoniTypes';
+export declare function _getXcmDestWeight(originChainInfo: _ChainInfo): "Unlimited" | 5000000000;
+export declare function _getXcmBeneficiary(destChainInfo: _ChainInfo, recipient: _Address, version: number): {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X1: {
+                AccountId32: {
+                    network: string | undefined;
+                    id: Uint8Array;
+                };
+                AccountKey20?: undefined;
+            } | {
+                AccountKey20: {
+                    network: string | undefined;
+                    key: string;
+                };
+                AccountId32?: undefined;
+            } | ({
+                AccountId32: {
+                    network: string | undefined;
+                    id: Uint8Array;
+                };
+                AccountKey20?: undefined;
+            } | {
+                AccountKey20: {
+                    network: string | undefined;
+                    key: string;
+                };
+                AccountId32?: undefined;
+            })[];
+        };
+    };
+};
+export declare function _getXcmMultiAssets(tokenInfo: _ChainAsset, value: string, version: number): {
+    [x: string]: {
+        id: Record<string, any>;
+        fun: {
+            Fungible: string;
+        };
+    }[];
+};
+export declare function _getXcmMultiLocation(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo, version: number, recipient?: _Address): {
+    [x: string]: {
+        parents: number;
+        interior: unknown;
+    };
+};

package/core/substrate/xcm-parser.js

@@ -0,0 +1,181 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { _getChainSubstrateAddressPrefix, _getEvmChainId, _getSubstrateParaId, _getSubstrateRelayParent, _getXcmAssetMultilocation, _isChainEvmCompatible, _isSubstrateParaChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { decodeAddress, evmToAddress } from '@polkadot/util-crypto';
+const FOUR_INSTRUCTIONS_WEIGHT = 5000000000;
+const UNLIMITED_WEIGHT = 'Unlimited';
+export function _getXcmDestWeight(originChainInfo) {
+  if (['pioneer'].includes(originChainInfo.slug)) {
+    return FOUR_INSTRUCTIONS_WEIGHT;
+  }
+  return UNLIMITED_WEIGHT;
+}
+export function _getXcmBeneficiary(destChainInfo, recipient, version) {
+  const receiverLocation = version < 4 // from V4, X1 is also an array
+  ? _getRecipientLocation(destChainInfo, recipient, version) : [_getRecipientLocation(destChainInfo, recipient, version)];
+  return {
+    [`V${version}`]: {
+      parents: 0,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  };
+}
+export function _getXcmMultiAssets(tokenInfo, value, version) {
+  const assetId = _getAssetIdentifier(tokenInfo, version);
+  return {
+    [`V${version}`]: [{
+      id: assetId,
+      fun: {
+        Fungible: value
+      }
+    }]
+  };
+}
+export function _getXcmMultiLocation(originChainInfo, destChainInfo, version, recipient) {
+  const isWithinSameConsensus = _isXcmWithinSameConsensus(originChainInfo, destChainInfo);
+  const parents = _getMultiLocationParent(originChainInfo, isWithinSameConsensus);
+  const interior = _getMultiLocationInterior(destChainInfo, isWithinSameConsensus, version, recipient);
+  return {
+    [`V${version}`]: {
+      parents,
+      interior
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+function _isXcmWithinSameConsensus(originChainInfo, destChainInfo) {
+  return _getSubstrateRelayParent(originChainInfo) === destChainInfo.slug || _getSubstrateRelayParent(destChainInfo) === originChainInfo.slug || _getSubstrateRelayParent(originChainInfo) === _getSubstrateRelayParent(destChainInfo);
+}
+function _getMultiLocationParent(originChainInfo, isWithinSameConsensus) {
+  let parent = 0; // how many hops up the hierarchy
+
+  if (_isSubstrateParaChain(originChainInfo)) {
+    parent += 1;
+  }
+  if (!isWithinSameConsensus) {
+    parent += 1;
+  }
+  return parent;
+}
+function _getMultiLocationInterior(destChainInfo, isWithinSameConsensus, version, recipient) {
+  const junctions = [];
+  if (isWithinSameConsensus) {
+    if (_isSubstrateParaChain(destChainInfo)) {
+      junctions.push({
+        Parachain: _getSubstrateParaId(destChainInfo)
+      });
+    }
+  } else {
+    junctions.push({
+      GlobalConsensus: _getGlobalConsensusJunction(destChainInfo, version)
+    });
+    if (_isSubstrateParaChain(destChainInfo)) {
+      junctions.push({
+        Parachain: _getSubstrateParaId(destChainInfo)
+      });
+    }
+  }
+  if (recipient) {
+    junctions.push(_getRecipientLocation(destChainInfo, recipient, version));
+  }
+  if (junctions.length === 0 && !recipient) {
+    return 'Here';
+  }
+  if (version < 4 && junctions.length === 1) {
+    return {
+      X1: junctions[0]
+    };
+  }
+  return {
+    [`X${junctions.length}`]: junctions
+  };
+}
+function _getGlobalConsensusJunction(destChainInfo, version) {
+  let chainSlug = destChainInfo.slug;
+  let evmChainId;
+  if (_isSubstrateParaChain(destChainInfo)) {
+    const relaySlug = _getSubstrateRelayParent(destChainInfo);
+    if (!relaySlug) {
+      throw Error('Parachain must have a parent chainSlug');
+    }
+    chainSlug = relaySlug;
+  } else {
+    evmChainId = _getEvmChainId(destChainInfo);
+  }
+  if (evmChainId) {
+    return {
+      Ethereum: {
+        chainId: evmChainId
+      }
+    };
+  }
+  switch (chainSlug) {
+    case COMMON_CHAIN_SLUGS.POLKADOT:
+      return version < 4 ? {
+        Polkadot: null
+      } : 'Polkadot';
+    case COMMON_CHAIN_SLUGS.KUSAMA:
+      return version < 4 ? {
+        Kusama: null
+      } : 'Kusama';
+    default:
+      return version < 4 ? {
+        Rococo: null
+      } : 'Rococo';
+  }
+}
+function _getRecipientLocation(destChainInfo, recipient, version) {
+  const network = _getNetworkByVersion(version);
+  if (destChainInfo.slug === COMMON_CHAIN_SLUGS.ASTAR_EVM) {
+    const ss58Address = evmToAddress(recipient, _getChainSubstrateAddressPrefix(destChainInfo)); // TODO: shouldn't pass addressPrefix directly
+
+    return {
+      AccountId32: {
+        network,
+        id: decodeAddress(ss58Address)
+      }
+    };
+  }
+  if (_isChainEvmCompatible(destChainInfo)) {
+    return {
+      AccountKey20: {
+        network,
+        key: recipient
+      }
+    };
+  }
+  return {
+    AccountId32: {
+      network,
+      id: decodeAddress(recipient)
+    }
+  };
+}
+function _getAssetIdentifier(tokenInfo, version) {
+  const assetIdentifier = _getXcmAssetMultilocation(tokenInfo);
+  if (!assetIdentifier) {
+    throw new Error('Asset must have multilocation');
+  }
+  return version >= 4 // from V4, Concrete is removed
+  ? assetIdentifier : {
+    Concrete: assetIdentifier
+  };
+}
+function _getNetworkByVersion(version) {
+  switch (version) {
+    case 1:
+    case 2:
+      return 'Any';
+    case 3:
+    case 4:
+      return undefined;
+    default:
+      return undefined;
+  }
+}

package/koni/api/dotsama/transfer.d.ts

@@ -1,9 +1,7 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
-import { SupportTransferResponse } from '@subwallet/extension-base/background/KoniTypes';
-import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import BigN from 'bignumber.js';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
-export declare function checkReferenceCount(networkKey: string, address: string, substrateApiMap: Record<string, _SubstrateApi>, chainInfo: _ChainInfo): Promise<boolean>;
-export declare function checkSupportTransfer(networkKey: string, tokenInfo: _ChainAsset, substrateApiMap: Record<string, _SubstrateApi>, chainInfo: _ChainInfo): Promise<SupportTransferResponse>;
 interface CreateTransferExtrinsicProps {
     substrateApi: _SubstrateApi;
     networkKey: string;
@@ -14,4 +12,5 @@ interface CreateTransferExtrinsicProps {
     tokenInfo: _ChainAsset;
 }
 export declare const createTransferExtrinsic: ({ from, networkKey, substrateApi, to, tokenInfo, transferAll, value }: CreateTransferExtrinsicProps) => Promise<[SubmittableExtrinsic | null, string]>;
+export declare const getTransferMockTxFee: (address: string, chainInfo: _ChainInfo, tokenInfo: _ChainAsset, api: _SubstrateApi | _EvmApi) => Promise<BigN>;
 export {};