@subwallet/extension-base 1.0.7-1 → 1.0.8-0

package/koni/api/staking/bonding/relayChain.js

@@ -3,7 +3,7 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { StakingStatus, StakingTxErrorType, StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
-import { calculateAlephZeroValidatorReturn, calculateChainStakedReturn, calculateInflation, calculateValidatorStakedReturn, getCommission, parseIdentity, parsePoolStashAddress, transformPoolName } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { calculateAlephZeroValidatorReturn, calculateChainStakedReturn, calculateInflation, calculateTernoaValidatorReturn, calculateValidatorStakedReturn, getCommission, parseIdentity, parsePoolStashAddress, transformPoolName } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
 import { _STAKING_CHAIN_GROUP, _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
 import { reformatAddress } from '@subwallet/extension-base/utils';
@@ -138,7 +138,7 @@ export async function getRelayChainStakingMetadata(chainInfo, substrateApi) {
     chain,
     type: StakingType.NOMINATED,
     era: parseInt(currentEra),
-    expectedReturn,
+    expectedReturn: !_STAKING_CHAIN_GROUP.ternoa.includes(chain) ? expectedReturn : undefined,
     // in %, annually
     inflation,
     minStake: minStake.toString(),
@@ -477,7 +477,8 @@ export async function getRelayValidatorsInfo(chain, substrateApi, decimals, chai
   const currentEra = _era.toString();
   const allValidators = [];
   const validatorInfoList = [];
-  const [_totalEraStake, _eraStakers, _minBond] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond()]);
+  const [_totalEraStake, _eraStakers, _minBond, _stakingRewards] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond(), chainApi.api.query.stakingRewards && chainApi.api.query.stakingRewards.data()]);
+  const stakingRewards = _stakingRewards === null || _stakingRewards === void 0 ? void 0 : _stakingRewards.toPrimitive();
   const maxNominatorRewarded = chainApi.api.consts.staking.maxNominatorRewardedPerValidator.toString();
   const bnTotalEraStake = new BN(_totalEraStake.toString());
   const eraStakers = _eraStakers;
@@ -540,7 +541,15 @@ export async function getRelayValidatorsInfo(chain, substrateApi, decimals, chai
   for (const validator of validatorInfoList) {
     const commission = extraInfoMap[validator.address].commission;
     const bnValidatorStake = totalStakeMap[validator.address].div(bnDecimals);
-    validator.expectedReturn = _STAKING_CHAIN_GROUP.aleph.includes(chain) ? calculateAlephZeroValidatorReturn(chainStakingMetadata.expectedReturn, getCommission(commission)) : calculateValidatorStakedReturn(chainStakingMetadata.expectedReturn, bnValidatorStake, bnAvgStake, getCommission(commission));
+    if (_STAKING_CHAIN_GROUP.aleph.includes(chain)) {
+      validator.expectedReturn = calculateAlephZeroValidatorReturn(chainStakingMetadata.expectedReturn, getCommission(commission));
+    } else if (_STAKING_CHAIN_GROUP.ternoa.includes(chain)) {
+      const rewardPerValidator = new BN(stakingRewards.sessionExtraRewardPayout).divn(allValidators.length).div(bnDecimals);
+      const validatorStake = totalStakeMap[validator.address].div(bnDecimals).toNumber();
+      validator.expectedReturn = calculateTernoaValidatorReturn(rewardPerValidator.toNumber(), validatorStake, getCommission(commission));
+    } else {
+      validator.expectedReturn = calculateValidatorStakedReturn(chainStakingMetadata.expectedReturn, bnValidatorStake, bnAvgStake, getCommission(commission));
+    }
     validator.commission = parseFloat(commission.split('%')[0]);
     validator.blocked = extraInfoMap[validator.address].blocked;
     validator.identity = extraInfoMap[validator.address].identity;

package/koni/api/staking/bonding/utils.d.ts

@@ -102,6 +102,10 @@ export interface Unlocking {
     remainingEras: BN;
     value: BN;
 }
+export interface TernoaStakingRewardsStakingRewardsData {
+    sessionEraPayout: string;
+    sessionExtraRewardPayout: string;
+}
 export declare function parsePoolStashAddress(api: ApiPromise, index: number, poolId: number, poolsPalletId: string): string;
 export declare function transformPoolName(input: string): string;
 export declare function parseIdentity(identityInfo: PalletIdentityRegistration | null): string | undefined;
@@ -111,6 +115,7 @@ export declare function calcInflationRewardCurve(minInflation: number, stakedFra
 export declare function calculateInflation(totalEraStake: BN, totalIssuance: BN, numAuctions: number, networkKey: string): number;
 export declare function calculateChainStakedReturn(inflation: number, totalEraStake: BN, totalIssuance: BN, networkKey: string): number;
 export declare function calculateAlephZeroValidatorReturn(chainStakedReturn: number, commission: number): number;
+export declare function calculateTernoaValidatorReturn(rewardPerValidator: number, validatorStake: number, commission: number): number;
 export declare function calculateValidatorStakedReturn(chainStakedReturn: number, totalValidatorStake: BN, avgStake: BN, commission: number): number;
 export declare function getCommission(commissionString: string): number;
 export interface InflationConfig {

package/koni/api/staking/bonding/utils.js

@@ -86,6 +86,12 @@ export function calculateChainStakedReturn(inflation, totalEraStake, totalIssuan
 export function calculateAlephZeroValidatorReturn(chainStakedReturn, commission) {
   return chainStakedReturn * (100 - commission) / 100;
 }
+export function calculateTernoaValidatorReturn(rewardPerValidator, validatorStake, commission) {
+  const percentRewardForNominators = (100 - commission) / 100;
+  const rewardForNominators = rewardPerValidator * percentRewardForNominators;
+  const stakeRatio = rewardForNominators / validatorStake;
+  return stakeRatio * 365 * 100;
+}
 export function calculateValidatorStakedReturn(chainStakedReturn, totalValidatorStake, avgStake, commission) {
   const bnAdjusted = avgStake.mul(BN_HUNDRED).div(totalValidatorStake);
   const adjusted = bnAdjusted.toNumber() * chainStakedReturn;

package/koni/api/xcm/polkadotXcm.js

@@ -1,49 +1,30 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { getBeneficiary, getDestWeight } from '@subwallet/extension-base/koni/api/xcm/utils';
-import { _getSubstrateParaId, _getXcmAssetMultilocation, _isSubstrateParaChain, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
-function getDestinationChainLocation(destinationChainInfo) {
-  if (_isSubstrateParaChain(destinationChainInfo)) {
-    return {
-      V1: {
-        parents: 1,
-        interior: {
-          X1: {
-            Parachain: _getSubstrateParaId(destinationChainInfo)
-          }
-        }
-      }
-    };
-  }
-  return {
-    // to relaychain by default
-    V1: {
-      parents: 1,
-      interior: 'Here'
-    }
-  };
-}
-function getAssetLocation(tokenInfo, sendingValue) {
-  const multilocation = _getXcmAssetMultilocation(tokenInfo);
-  return {
-    V1: [{
-      id: multilocation,
-      fun: {
-        Fungible: sendingValue
-      }
-    }]
-  };
-}
+import { getBeneficiary, getDestinationChainLocation, getDestWeight, getTokenLocation } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _isNativeToken, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
 export function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
   const weightParam = getDestWeight();
-  const beneficiary = getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress);
-  const destination = getDestinationChainLocation(destinationChainInfo);
-  const assetLocation = getAssetLocation(tokenInfo, value);
+  const beneficiary = getBeneficiary(destinationChainInfo, recipientAddress);
+  const destination = getDestinationChainLocation(originChainInfo, destinationChainInfo);
+  let assetLocation = getTokenLocation(tokenInfo, value);
   let method = 'limitedReserveTransferAssets';
-  if (['astar', 'shiden'].includes(originChainInfo.slug)) {
+  if (['astar', 'shiden'].includes(originChainInfo.slug) && !_isNativeToken(tokenInfo)) {
     method = 'limitedReserveWithdrawAssets';
-  } else if (_isSubstrateRelayChain(destinationChainInfo)) {
+  } else if (['statemint', 'statemine'].includes(originChainInfo.slug) && _isSubstrateRelayChain(destinationChainInfo)) {
+    assetLocation = {
+      V1: [{
+        id: {
+          Concrete: {
+            parents: 1,
+            interior: 'Here'
+          }
+        },
+        fun: {
+          Fungible: value
+        }
+      }]
+    };
     method = 'limitedTeleportAssets';
   }
   return api.tx.polkadotXcm[method](destination, beneficiary, assetLocation, 0,

package/koni/api/xcm/utils.d.ts

@@ -1,10 +1,10 @@
-import { _ChainInfo } from '@subwallet/chain-list/types';
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 export declare const FOUR_INSTRUCTIONS_WEIGHT = 5000000000;
 export declare const FOUR_INSTRUCTIONS_LIMITED_WEIGHT: {
     Limited: number;
 };
-export declare function getReceiverLocation(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, toAddress: string): Record<string, any>;
-export declare function getBeneficiary(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string, version?: string): {
+export declare function getReceiverLocation(destinationChainInfo: _ChainInfo, toAddress: string, version?: string): Record<string, any>;
+export declare function getBeneficiary(destinationChainInfo: _ChainInfo, recipientAddress: string, version?: string): {
     [x: string]: {
         parents: number;
         interior: {
@@ -13,3 +13,36 @@ export declare function getBeneficiary(originChainInfo: _ChainInfo, destinationC
     };
 };
 export declare function getDestWeight(): string;
+export declare function getTokenLocation(tokenInfo: _ChainAsset, sendingValue: string, version?: string): {
+    [x: string]: {
+        id: Record<string, any>;
+        fun: {
+            Fungible: string;
+        };
+    }[];
+};
+export declare function getDestMultilocation(destinationChainInfo: _ChainInfo, recipient: string, version?: string): {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X2: Record<string, any>[];
+        };
+    };
+} | {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X1: Record<string, any>;
+        };
+    };
+};
+export declare function getDestinationChainLocation(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, version?: string): {
+    [x: string]: {
+        parents: number;
+        interior: string | {
+            X1: {
+                Parachain: number;
+            };
+        };
+    };
+};

package/koni/api/xcm/utils.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
-import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getSubstrateParaId, _getXcmAssetMultilocation, _isChainEvmCompatible, _isNativeToken, _isSubstrateParaChain, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { decodeAddress, evmToAddress } from '@polkadot/util-crypto';
 export const FOUR_INSTRUCTIONS_WEIGHT = 5000000000;
 export const FOUR_INSTRUCTIONS_LIMITED_WEIGHT = {
@@ -11,13 +11,14 @@ export const FOUR_INSTRUCTIONS_LIMITED_WEIGHT = {
 
 // get multilocation for destination chain from a parachain
 
-export function getReceiverLocation(originChainInfo, destinationChainInfo, toAddress) {
+export function getReceiverLocation(destinationChainInfo, toAddress, version) {
+  const network = version && version === 'V3' ? undefined : 'Any';
   if (destinationChainInfo.slug === COMMON_CHAIN_SLUGS.ASTAR_EVM) {
     const ss58Address = evmToAddress(toAddress, 2006); // TODO: shouldn't pass addressPrefix directly
 
     return {
       AccountId32: {
-        network: 'Any',
+        network,
         id: decodeAddress(ss58Address)
       }
     };
@@ -25,20 +26,20 @@ export function getReceiverLocation(originChainInfo, destinationChainInfo, toAdd
   if (_isChainEvmCompatible(destinationChainInfo)) {
     return {
       AccountKey20: {
-        network: 'Any',
+        network,
         key: toAddress
       }
     };
   }
   return {
     AccountId32: {
-      network: 'Any',
+      network,
       id: decodeAddress(toAddress)
     }
   };
 }
-export function getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress, version = 'V1') {
-  const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, recipientAddress);
+export function getBeneficiary(destinationChainInfo, recipientAddress, version = 'V1') {
+  const receiverLocation = getReceiverLocation(destinationChainInfo, recipientAddress, version);
   return {
     [version]: {
       parents: 0,
@@ -50,8 +51,68 @@ export function getBeneficiary(originChainInfo, destinationChainInfo, recipientA
 }
 export function getDestWeight() {
   return 'Unlimited';
-  // return api.tx.xTokens.transfer.meta.args[3].type.toString() ===
-  // 'XcmV2WeightLimit'
-  //   ? 'Unlimited'
-  //   : FOUR_INSTRUCTIONS_WEIGHT;
+}
+export function getTokenLocation(tokenInfo, sendingValue, version = 'V1') {
+  if (!_isNativeToken(tokenInfo)) {
+    const multilocation = _getXcmAssetMultilocation(tokenInfo);
+    return {
+      [version]: [{
+        id: multilocation,
+        fun: {
+          Fungible: sendingValue
+        }
+      }]
+    };
+  }
+  return {
+    [version]: [{
+      id: {
+        Concrete: {
+          parents: 0,
+          interior: 'Here'
+        }
+      },
+      fun: {
+        Fungible: sendingValue
+      }
+    }]
+  };
+}
+export function getDestMultilocation(destinationChainInfo, recipient, version = 'V1') {
+  const receiverLocation = getReceiverLocation(destinationChainInfo, recipient, version);
+  if (_isSubstrateParaChain(destinationChainInfo)) {
+    const interior = {
+      X2: [{
+        Parachain: _getSubstrateParaId(destinationChainInfo)
+      }, receiverLocation]
+    };
+    return {
+      [version]: {
+        parents: 1,
+        interior
+      }
+    };
+  }
+  return {
+    [version]: {
+      parents: 1,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  };
+}
+export function getDestinationChainLocation(originChainInfo, destinationChainInfo, version = 'V1') {
+  const parents = _isSubstrateRelayChain(originChainInfo) ? 0 : 1;
+  const interior = _isSubstrateParaChain(destinationChainInfo) ? {
+    X1: {
+      Parachain: _getSubstrateParaId(destinationChainInfo)
+    }
+  } : 'Here';
+  return {
+    [version]: {
+      parents,
+      interior
+    }
+  };
 }

package/koni/api/xcm/xTokens.js

@@ -1,9 +1,8 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { FOUR_INSTRUCTIONS_WEIGHT, getDestWeight, getReceiverLocation } from '@subwallet/extension-base/koni/api/xcm/utils';
-import { _XCM_TYPE } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getSubstrateParaId, _getTokenOnChainInfo, _getXcmAssetId, _getXcmAssetMultilocation, _getXcmAssetType, _getXcmTransferType, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { FOUR_INSTRUCTIONS_WEIGHT, getDestMultilocation, getDestWeight } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _getTokenOnChainAssetId, _getTokenOnChainInfo, _getXcmAssetId, _getXcmAssetMultilocation, _getXcmAssetType, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 function getCurrencyId(tokenInfo) {
   if (['acala', 'karura'].includes(tokenInfo.originChain) && _isNativeToken(tokenInfo)) {
     return _getXcmAssetMultilocation(tokenInfo);
@@ -16,38 +15,10 @@ function getCurrencyId(tokenInfo) {
   } else if (['pioneer'].includes(tokenInfo.originChain)) {
     return _getXcmAssetMultilocation(tokenInfo);
   }
-  return _getTokenOnChainInfo(tokenInfo);
-}
-function getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, toAddress) {
-  const xcmType = _getXcmTransferType(originChainInfo, destinationChainInfo);
-  const paraId = _getSubstrateParaId(destinationChainInfo);
-  const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, toAddress);
-  if (xcmType === _XCM_TYPE.PP) {
-    // parachain -> parachain
-    const interior = {
-      X2: [{
-        Parachain: paraId
-      }, receiverLocation]
-    };
-    return {
-      V1: {
-        parents: 1,
-        interior
-      }
-    };
-  }
-
-  // parachain -> relaychain by default
-  return {
-    V1: {
-      parents: 1,
-      interior: {
-        X1: receiverLocation
-      }
-    }
-  };
+  return _getTokenOnChainInfo(tokenInfo) || _getTokenOnChainAssetId(tokenInfo);
 }
 export function getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
-  const weightParam = ['pioneer'].includes(originChainInfo.slug) ? FOUR_INSTRUCTIONS_WEIGHT : getDestWeight();
-  return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, recipientAddress), weightParam);
+  const weightParam = ['pioneer', 'hydradx_main'].includes(originChainInfo.slug) ? FOUR_INSTRUCTIONS_WEIGHT : getDestWeight();
+  const destVersion = ['moonbeam', 'moonriver'].includes(originChainInfo.slug) ? 'V3' : undefined;
+  return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getDestMultilocation(destinationChainInfo, recipientAddress, destVersion), weightParam);
 }

package/koni/api/xcm/xcmPallet.js

@@ -1,44 +1,14 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { getBeneficiary, getDestWeight } from '@subwallet/extension-base/koni/api/xcm/utils';
-import { _getSubstrateParaId } from '@subwallet/extension-base/services/chain-service/utils';
-function getDestinationChainLocation(destinationChainInfo, version = 'V1') {
-  return {
-    [version]: {
-      parents: 0,
-      interior: {
-        X1: {
-          Parachain: _getSubstrateParaId(destinationChainInfo)
-        }
-      }
-    }
-  };
-}
-function getTokenLocation(sendingValue, version = 'V2') {
-  return {
-    // always native token of relaychain
-    [version]: [{
-      id: {
-        Concrete: {
-          parents: 0,
-          interior: 'Here'
-        }
-      },
-      fun: {
-        Fungible: sendingValue
-      }
-    }]
-  };
-}
-
+import { getBeneficiary, getDestinationChainLocation, getDestWeight, getTokenLocation } from '@subwallet/extension-base/koni/api/xcm/utils';
 // this pallet is only used by Relaychains
 export function getExtrinsicByXcmPalletPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
   const weightParam = getDestWeight();
-  const xcmVer = ['kusama'].includes(originChainInfo.slug) ? 'V2' : 'V1';
-  const destination = getDestinationChainLocation(destinationChainInfo, xcmVer);
-  const beneficiary = getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress, xcmVer);
-  const tokenLocation = getTokenLocation(value, xcmVer);
+  const xcmVer = ['kusama'].includes(originChainInfo.slug) ? 'V3' : 'V1';
+  const destination = getDestinationChainLocation(originChainInfo, destinationChainInfo, xcmVer);
+  const beneficiary = getBeneficiary(destinationChainInfo, recipientAddress, xcmVer);
+  const tokenLocation = getTokenLocation(tokenInfo, value, xcmVer);
   let method = 'limitedReserveTransferAssets';
   if (['statemint', 'statemine'].includes(destinationChainInfo.slug)) {
     method = 'limitedTeleportAssets';

package/koni/background/handlers/Extension.js

@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import Common from '@ethereumjs/common';
+import { _AssetType } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { isJsonPayload, SEED_DEFAULT_LENGTH, SEED_LENGTHS } from '@subwallet/extension-base/background/handlers/Extension';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { createSubscription } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { AccountExternalErrorCode, BasicTxErrorType, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, StakingType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { ALL_ACCOUNT_KEY, ALL_GENESIS_HASH } from '@subwallet/extension-base/constants';
+import { AccountExternalErrorCode, BasicTxErrorType, BasicTxWarningCode, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, StakingType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
+import { ALL_ACCOUNT_KEY, ALL_GENESIS_HASH, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { ALLOWED_PATH } from '@subwallet/extension-base/defaults';
 import { parseSubstrateTransaction } from '@subwallet/extension-base/koni/api/dotsama/parseTransaction';
 import { checkReferenceCount, checkSupportTransfer, createTransferExtrinsic } from '@subwallet/extension-base/koni/api/dotsama/transfer';
@@ -25,6 +27,7 @@ import { reformatAddress } from '@subwallet/extension-base/utils';
 import { convertSubjectInfoToAddresses } from '@subwallet/extension-base/utils/address';
 import { createTransactionFromRLP, signatureToHex } from '@subwallet/extension-base/utils/eth';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import { balanceFormatter, formatNumber } from '@subwallet/extension-base/utils/number';
 import { createPair } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import BigN from 'bignumber.js';
@@ -1398,31 +1401,58 @@ export default class KoniExtension {
 
     // Get native token amount
     const freeBalance = await this.#koniState.balanceService.getTokenFreeBalance(from, networkKey, tokenSlug);
-    if (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenTransferredByEvm(tokenInfo)) {
-      // TODO: review this
-      chainType = ChainType.EVM;
-      const txVal = transferAll ? freeBalance.value : value || '0';
-
-      // Estimate with EVM API
-      if (_isTokenEvmSmartContract(tokenInfo) || _isLocalToken(tokenInfo)) {
-        [transaction, transferAmount.value] = await getERC20TransactionObject(_getContractAddressOfToken(tokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApiMap);
+    try {
+      if (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenTransferredByEvm(tokenInfo)) {
+        // TODO: review this
+        chainType = ChainType.EVM;
+        const txVal = transferAll ? freeBalance.value : value || '0';
+
+        // Estimate with EVM API
+        if (_isTokenEvmSmartContract(tokenInfo) || _isLocalToken(tokenInfo)) {
+          [transaction, transferAmount.value] = await getERC20TransactionObject(_getContractAddressOfToken(tokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApiMap);
+        } else {
+          [transaction, transferAmount.value] = await getEVMTransactionObject(chainInfo, to, txVal, !!transferAll, evmApiMap);
+        }
       } else {
-        [transaction, transferAmount.value] = await getEVMTransactionObject(chainInfo, to, txVal, !!transferAll, evmApiMap);
+        const substrateApi = this.#koniState.getSubstrateApi(networkKey);
+        [transaction, transferAmount.value] = await createTransferExtrinsic({
+          transferAll: !!transferAll,
+          value: value || '0',
+          from: from,
+          networkKey,
+          tokenInfo,
+          to: to,
+          substrateApi
+        });
       }
-    } else {
-      const substrateApi = this.#koniState.getSubstrateApi(networkKey);
-      [transaction, transferAmount.value] = await createTransferExtrinsic({
-        transferAll: !!transferAll,
-        value: value || '0',
-        from: from,
-        networkKey,
-        tokenInfo,
-        to: to,
-        substrateApi
-      });
+    } catch (e) {
+      const error = e;
+      if (error.message.includes('transfer amount exceeds balance')) {
+        error.message = 'Not enough balance';
+      }
+      throw error;
     }
     const transferNativeAmount = isTransferNativeToken ? transferAmount.value : '0';
     this.addContact(to);
+    const additionalValidator = async inputTransaction => {
+      const minAmount = tokenInfo.minAmount || '0';
+      if (!isTransferNativeToken) {
+        const {
+          value: balance
+        } = await this.#koniState.balanceService.getTokenFreeBalance(from, networkKey, tokenSlug);
+        if (new BigN(balance).minus(transferAmount.value).lt(minAmount)) {
+          inputTransaction.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
+        }
+      }
+      const {
+        value: receiverBalance
+      } = await this.#koniState.balanceService.getTokenFreeBalance(to, networkKey, tokenSlug);
+      if (new BigN(receiverBalance).plus(transferAmount.value).lt(minAmount)) {
+        const atLeast = new BigN(minAmount).minus(receiverBalance).plus((tokenInfo.decimals || 0) === 0 ? 0 : 1);
+        const atLeastStr = formatNumber(atLeast, tokenInfo.decimals || 0, balanceFormatter);
+        inputTransaction.errors.push(new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, `You must transfer at least ${atLeastStr} ${tokenInfo.symbol} to keep the destination account alive`));
+      }
+    };
     return this.#koniState.transactionService.handleTransaction({
       errors,
       warnings,
@@ -1434,8 +1464,9 @@ export default class KoniExtension {
       data: inputData,
       extrinsicType: isTransferNativeToken ? ExtrinsicType.TRANSFER_BALANCE : ExtrinsicType.TRANSFER_TOKEN,
       ignoreWarnings: transferAll,
-      isTransferAll: transferAll,
-      edAsWarning: isTransferNativeToken
+      isTransferAll: isTransferNativeToken ? transferAll : false,
+      edAsWarning: isTransferNativeToken,
+      additionalValidator: additionalValidator
     });
   }
   validateCrossChainTransfer(destinationNetworkKey, sendingTokenSlug, sender, sendingValue) {
@@ -1463,6 +1494,8 @@ export default class KoniExtension {
     if (errors.length > 0) {
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(errors);
     }
+    let additionalValidator;
+    let eventsHandler;
     if (fromKeyPair && destinationTokenInfo) {
       const substrateApi = this.#koniState.getSubstrateApi(originNetworkKey);
       const chainInfoMap = this.#koniState.getChainInfoMap();
@@ -1474,6 +1507,40 @@ export default class KoniExtension {
         chainInfoMap,
         substrateApi
       });
+      additionalValidator = async inputTransaction => {
+        const destMinAmount = destinationTokenInfo.minAmount || '0';
+        const atLeast = new BigN(destMinAmount).multipliedBy(XCM_MIN_AMOUNT_RATIO);
+        if (new BigN(value).lt(atLeast)) {
+          const atLeastStr = formatNumber(atLeast, destinationTokenInfo.decimals || 0, balanceFormatter);
+          inputTransaction.errors.push(new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, `You must transfer at least ${atLeastStr} ${originTokenInfo.symbol} to keep the destination account alive`));
+        }
+        const srcMinAmount = originTokenInfo.minAmount || '0';
+        const isTransferNativeToken = originTokenInfo.assetType === _AssetType.NATIVE;
+        if (!isTransferNativeToken) {
+          const {
+            value: balance
+          } = await this.#koniState.balanceService.getTokenFreeBalance(from, originNetworkKey, originTokenInfo.slug);
+          if (new BigN(balance).minus(value).lt(srcMinAmount)) {
+            inputTransaction.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
+          }
+        }
+      };
+      eventsHandler = eventEmitter => {
+        eventEmitter.on('send', () => {
+          try {
+            const dest = keyring.getPair(to);
+            if (dest) {
+              this.updateAssetSetting({
+                autoEnableNativeToken: false,
+                tokenSlug: destinationTokenInfo.slug,
+                assetSetting: {
+                  visible: true
+                }
+              }).catch(console.error);
+            }
+          } catch (e) {}
+        });
+      };
     }
     this.addContact(to);
     return await this.#koniState.transactionService.handleTransaction({
@@ -1485,8 +1552,11 @@ export default class KoniExtension {
       extrinsicType: ExtrinsicType.TRANSFER_XCM,
       chainType: ChainType.SUBSTRATE,
       transferNativeAmount: _isNativeToken(originTokenInfo) ? value : '0',
+      ignoreWarnings: inputData.transferAll,
       isTransferAll: inputData.transferAll,
-      errors
+      errors,
+      additionalValidator: additionalValidator,
+      eventsHandler: eventsHandler
     });
   }
   async evmNftSubmitTransaction(inputData) {
@@ -1524,8 +1594,11 @@ export default class KoniExtension {
   disableChain(networkKey) {
     return this.#koniState.disableChain(networkKey);
   }
-  async enableChain(networkKey) {
-    return await this.#koniState.enableChain(networkKey);
+  async enableChain({
+    chainSlug,
+    enableTokens
+  }) {
+    return await this.#koniState.enableChain(chainSlug, enableTokens);
   }
   async validateNetwork({
     existedChainSlug,
@@ -1715,9 +1788,15 @@ export default class KoniExtension {
       isSendingSelf
     };
   }
-  async enableChains(targetKeys) {
+  async enableChains({
+    chainSlugs,
+    enableTokens
+  }) {
     try {
-      await Promise.all(targetKeys.map(networkKey => this.enableChain(networkKey)));
+      await Promise.all(chainSlugs.map(chainSlug => this.enableChain({
+        chainSlug,
+        enableTokens
+      })));
     } catch (e) {
       return false;
     }
@@ -2839,6 +2918,7 @@ export default class KoniExtension {
       return Object.fromEntries(Object.entries(rs).map(([key, value]) => {
         const {
           additionalValidator,
+          eventsHandler,
           transaction,
           ...transactionResult
         } = value;