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

package/koni/api/dotsama/transfer.js

@@ -4,110 +4,13 @@
 import { GearApi } from '@gear-js/api';
 import { getPSP22ContractPromise } from '@subwallet/extension-base/koni/api/tokens/wasm';
 import { getWasmContractGasLimit } from '@subwallet/extension-base/koni/api/tokens/wasm/utils';
-import { _BALANCE_TOKEN_GROUP, _MANTA_ZK_CHAIN_GROUP, _TRANSFER_CHAIN_GROUP, _TRANSFER_NOT_SUPPORTED_CHAINS, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _isChainEvmCompatible, _isNativeToken, _isTokenGearSmartContract, _isTokenWasmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _isBridgedToken, _isChainEvmCompatible, _isNativeToken, _isTokenGearSmartContract, _isTokenTransferredByEvm, _isTokenWasmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
 import { getGRC20ContractPromise } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
 import { BN, u8aToHex } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
-function isRefCount(accountInfo) {
-  return !!accountInfo.refcount;
-}
-export async function checkReferenceCount(networkKey, address, substrateApiMap, chainInfo) {
-  const apiProps = await substrateApiMap[networkKey].isReady;
-  const api = apiProps.api;
-  if (_isChainEvmCompatible(chainInfo)) {
-    return false;
-  }
-
-  // @ts-ignore
-  const accountInfo = await api.query.system.account(address);
-  return accountInfo ? isRefCount(accountInfo) ? !accountInfo.refcount.isZero() : !accountInfo.consumers.isZero() : false;
-}
-export async function checkSupportTransfer(networkKey, tokenInfo, substrateApiMap, chainInfo) {
-  const substrateApi = await substrateApiMap[networkKey].isReady;
-  if (!tokenInfo) {
-    return {
-      supportTransfer: false,
-      supportTransferAll: false
-    };
-  }
-  if (_isChainEvmCompatible(chainInfo)) {
-    return {
-      supportTransfer: true,
-      supportTransferAll: true
-    };
-  }
-  if (tokenInfo.symbol.startsWith(_ZK_ASSET_PREFIX) && _MANTA_ZK_CHAIN_GROUP.includes(tokenInfo.originChain)) {
-    return {
-      supportTransfer: false,
-      supportTransferAll: false
-    };
-  }
-  if (_TRANSFER_NOT_SUPPORTED_CHAINS.includes(networkKey)) {
-    return {
-      supportTransfer: false,
-      supportTransferAll: false
-    };
-  }
-  const api = substrateApi.api;
-  const isTxCurrenciesSupported = !!api && !!api.tx && !!api.tx.currencies;
-  const isTxBalancesSupported = !!api && !!api.tx && !!api.tx.balances;
-  const isTxTokensSupported = !!api && !!api.tx && !!api.tx.tokens;
-  const isTxEqBalancesSupported = !!api && !!api.tx && !!api.tx.eqBalances;
-  const result = {
-    supportTransfer: false,
-    supportTransferAll: false
-  };
-  if (!(isTxCurrenciesSupported || isTxBalancesSupported || isTxTokensSupported || isTxEqBalancesSupported)) {
-    return result;
-  }
-  if (_isTokenWasmSmartContract(tokenInfo) && api.query.contracts) {
-    // for PSP tokens
-    return {
-      supportTransfer: true,
-      supportTransferAll: true
-    };
-  }
-
-  // TODO: need review
-  if (_TRANSFER_CHAIN_GROUP.acala.includes(networkKey) && !_isNativeToken(tokenInfo) && isTxCurrenciesSupported) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-  } else if (_TRANSFER_CHAIN_GROUP.kintsugi.includes(networkKey) && !_isNativeToken(tokenInfo) && isTxTokensSupported) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-  } else if (_TRANSFER_CHAIN_GROUP.genshiro.includes(networkKey)
-  // && !_isNativeToken(tokenInfo) && isTxEqBalancesSupported
-  ) {
-    result.supportTransfer = false;
-    result.supportTransferAll = false;
-    // } else if (_TRANSFER_CHAIN_GROUP.crab.includes(networkKey) && _BALANCE_TOKEN_GROUP.crab.includes(tokenInfo.symbol)) {
-    //   result.supportTransfer = true;
-    //   result.supportTransferAll = true;
-  } else if (isTxBalancesSupported && _isNativeToken(tokenInfo)) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-  } else if (_TRANSFER_CHAIN_GROUP.bitcountry.includes(networkKey) && !_isNativeToken(tokenInfo) && _BALANCE_TOKEN_GROUP.bitcountry.includes(tokenInfo.symbol)) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-  } else if (_TRANSFER_CHAIN_GROUP.statemine.includes(networkKey) && !_isNativeToken(tokenInfo)) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-  } else if (_TRANSFER_CHAIN_GROUP.sora_substrate.includes(networkKey)) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-    // } else if (_TRANSFER_CHAIN_GROUP.riochain.includes(networkKey) && _isNativeToken(tokenInfo)) {
-    //   result.supportTransfer = true;
-    //   result.supportTransferAll = true;
-  } else if (_TRANSFER_CHAIN_GROUP.avail.includes(networkKey)) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-  } else if (_TRANSFER_CHAIN_GROUP.centrifuge.includes(networkKey)) {
-    result.supportTransfer = true;
-    result.supportTransferAll = true;
-  }
-  return result;
-}
 export const createTransferExtrinsic = async ({
   from,
   networkKey,
@@ -129,11 +32,17 @@ export const createTransferExtrinsic = async ({
   const isTxCurrenciesSupported = !!api && !!api.tx && !!api.tx.currencies;
   const isTxBalancesSupported = !!api && !!api.tx && !!api.tx.balances;
   const isTxTokensSupported = !!api && !!api.tx && !!api.tx.tokens;
-  // const isTxEqBalancesSupported = !!api && !!api.tx && !!api.tx.eqBalances;
   const isTxAssetsSupported = !!api && !!api.tx && !!api.tx.assets;
   let transferAmount; // for PSP-22 tokens, might be deprecated in the future
 
-  if (_isTokenWasmSmartContract(tokenInfo) && api.query.contracts) {
+  if (_isBridgedToken(tokenInfo) && api.tx.foreignAssets) {
+    const onChainInfo = _getTokenOnChainInfo(tokenInfo);
+    if (transferAll) {
+      transfer = api.tx.foreignAssets.transfer(onChainInfo, to, value);
+    } else {
+      transfer = api.tx.foreignAssets.transferKeepAlive(onChainInfo, to, value);
+    }
+  } else if (_isTokenWasmSmartContract(tokenInfo) && api.query.contracts) {
     const contractPromise = getPSP22ContractPromise(api, _getContractAddressOfToken(tokenInfo));
     // @ts-ignore
     const gasLimit = await getWasmContractGasLimit(api, from, 'psp22::transfer', contractPromise, {}, [from, value, {}]);
@@ -175,25 +84,10 @@ export const createTransferExtrinsic = async ({
     } else if (value) {
       transfer = api.tx.tokens.transfer(to, _getTokenOnChainInfo(tokenInfo) || _getTokenOnChainAssetId(tokenInfo), new BN(value));
     }
-  } else if (_TRANSFER_CHAIN_GROUP.genshiro.includes(networkKey)
-  // && isTxEqBalancesSupported
-  ) {
-    // transfer = api.tx.eqBalances.transfer(_getTokenOnChainAssetId(tokenInfo), to, value);
-    /* empty */
-    // } else if (!_isNativeToken(tokenInfo) && (_TRANSFER_CHAIN_GROUP.crab.includes(networkKey) || _BALANCE_TOKEN_GROUP.crab.includes(tokenInfo.symbol))) {
-    //   if (transferAll) {
-    //     transfer = api.tx.kton.transferAll(to, false);
-    //   } else if (value) {
-    //     transfer = api.tx.kton.transfer(to, new BN(value));
-    //   }
   } else if (_TRANSFER_CHAIN_GROUP.bitcountry.includes(networkKey) && !_isNativeToken(tokenInfo)) {
     transfer = api.tx.currencies.transfer(to, _getTokenOnChainInfo(tokenInfo), value);
   } else if (_TRANSFER_CHAIN_GROUP.statemine.includes(networkKey) && !_isNativeToken(tokenInfo)) {
     transfer = api.tx.assets.transfer(_getTokenOnChainAssetId(tokenInfo), to, value);
-    // } else if (_TRANSFER_CHAIN_GROUP.riochain.includes(networkKey)) {
-    //   if (_isNativeToken(tokenInfo)) {
-    //     transfer = api.tx.currencies.transferNativeCurrency(to, value);
-    //   }
   } else if (_TRANSFER_CHAIN_GROUP.sora_substrate.includes(networkKey) && isTxAssetsSupported) {
     transfer = api.tx.assets.transfer(_getTokenOnChainAssetId(tokenInfo), to, value);
   } else if (isTxBalancesSupported && _isNativeToken(tokenInfo)) {
@@ -211,4 +105,46 @@ export const createTransferExtrinsic = async ({
     }
   }
   return [transfer, transferAmount || value];
+};
+export const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) => {
+  try {
+    let estimatedFee;
+    if (_isChainEvmCompatible(chainInfo) && _isTokenTransferredByEvm(tokenInfo)) {
+      const web3 = api;
+      const transaction = {
+        value: 0,
+        to: '0x0000000000000000000000000000000000000000',
+        // null address
+        from: address
+      };
+      const gasLimit = await web3.api.eth.estimateGas(transaction);
+      const priority = await calculateGasFeeParams(web3, chainInfo.slug);
+      if (priority.baseGasFee) {
+        const maxFee = priority.maxFeePerGas;
+        estimatedFee = maxFee.multipliedBy(gasLimit);
+      } else {
+        estimatedFee = new BigN(priority.gasPrice).multipliedBy(gasLimit);
+      }
+    } else {
+      var _paymentInfo$partialF;
+      const substrateApi = api;
+      const chainApi = await substrateApi.isReady;
+      const [mockTx] = await createTransferExtrinsic({
+        from: address,
+        networkKey: chainInfo.slug,
+        substrateApi: chainApi,
+        to: address,
+        tokenInfo,
+        transferAll: true,
+        value: '1000000000000000000'
+      });
+      const paymentInfo = await (mockTx === null || mockTx === void 0 ? void 0 : mockTx.paymentInfo(address));
+      estimatedFee = new BigN((paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0'); // todo: should handle error case instead of setting fee to 0
+    }
+
+    return estimatedFee;
+  } catch (e) {
+    console.error('error mocking tx fee', e);
+    return new BigN(0);
+  }
 };

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

@@ -1,8 +1,9 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainStakingMetadata, NominatorMetadata, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { PalletNominationPoolsPoolMember } from '@subwallet/extension-base/core/substrate/nominationpools-pallet';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { NominationPoolInfo, PalletNominationPoolsPoolMember } from '@subwallet/extension-base/types';
+import { NominationPoolInfo } from '@subwallet/extension-base/types';
 export interface PalletStakingNominations {
     targets: string[];
     submittedIn: number;

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

@@ -383,7 +383,7 @@ export function getTopValidatorByPoints(validatorPointsList) {
 export const getMinStakeErrorMessage = (chainInfo, bnMinStake) => {
   const tokenInfo = _getChainNativeTokenBasicInfo(chainInfo);
   const number = formatNumber(bnMinStake.toString(), tokenInfo.decimals || 0, balanceFormatter);
-  return t('Insufficient stake. Please stake at least {{number}} {{tokenSymbol}} to get rewards', {
+  return t('Insufficient stake. You need to stake at least {{number}} {{tokenSymbol}} to earn rewards', {
     replace: {
       tokenSymbol: tokenInfo.symbol,
       number

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

@@ -1,5 +1,6 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import BigN from 'bignumber.js';
 import { SubmittableExtrinsic } from '@polkadot/api/types';
 interface CreateXcmExtrinsicProps {
     originTokenInfo: _ChainAsset;
@@ -10,4 +11,5 @@ interface CreateXcmExtrinsicProps {
     chainInfoMap: Record<string, _ChainInfo>;
 }
 export declare const createXcmExtrinsic: ({ chainInfoMap, destinationTokenInfo, originTokenInfo, recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
+export declare const getXcmMockTxFee: (substrateApi: _SubstrateApi, chainInfoMap: Record<string, _ChainInfo>, address: string, originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset) => Promise<BigN>;
 export {};

package/koni/api/xcm/index.js

@@ -5,7 +5,10 @@ import { getExtrinsicByPolkadotXcmPallet } from '@subwallet/extension-base/koni/
 import { getExtrinsicByXcmPalletPallet } from '@subwallet/extension-base/koni/api/xcm/xcmPallet';
 import { getExtrinsicByXtokensPallet } from '@subwallet/extension-base/koni/api/xcm/xTokens';
 import { _XCM_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import BigN from 'bignumber.js';
+import { u8aToHex } from '@polkadot/util';
+import { addressToEvm, isEthereumAddress } from '@polkadot/util-crypto';
 export const createXcmExtrinsic = async ({
   chainInfoMap,
   destinationTokenInfo,
@@ -31,4 +34,27 @@ export const createXcmExtrinsic = async ({
     extrinsic = getExtrinsicByXtokensPallet(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
   }
   return extrinsic;
+};
+export const getXcmMockTxFee = async (substrateApi, chainInfoMap, address, originTokenInfo, destinationTokenInfo) => {
+  try {
+    var _paymentInfo$partialF;
+    const destChainInfo = chainInfoMap[destinationTokenInfo.originChain];
+    const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+
+    // mock receiving account from sender
+    const recipient = !isEthereumAddress(address) && _isChainEvmCompatible(destChainInfo) && !_isChainEvmCompatible(originChainInfo) ? u8aToHex(addressToEvm(address)) : address;
+    const mockTx = await createXcmExtrinsic({
+      chainInfoMap,
+      destinationTokenInfo,
+      originTokenInfo,
+      recipient: recipient,
+      sendingValue: '1000000000000000000',
+      substrateApi
+    });
+    const paymentInfo = await mockTx.paymentInfo(address);
+    return new BigN((paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0');
+  } catch (e) {
+    console.error('error mocking xcm tx fee', e);
+    return new BigN(0);
+  }
 };

package/koni/api/xcm/polkadotXcm.js

@@ -1,32 +1,24 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { getBeneficiary, getDestinationChainLocation, getDestWeight, getTokenLocation } from '@subwallet/extension-base/koni/api/xcm/utils';
-import { _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getXcmBeneficiary, _getXcmDestWeight, _getXcmMultiAssets, _getXcmMultiLocation } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { isUseTeleportProtocol, STABLE_XCM_VERSION } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _isBridgedToken } from '@subwallet/extension-base/services/chain-service/utils';
 export function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
-  const weightParam = getDestWeight();
-  const version = ['statemint', 'statemine', 'shiden', 'astar'].includes(originChainInfo.slug) ? 'V3' : 'V1';
-  const beneficiary = getBeneficiary(destinationChainInfo, recipientAddress, version);
-  const destination = getDestinationChainLocation(originChainInfo, destinationChainInfo, version);
-  let assetLocation = getTokenLocation(tokenInfo, value, version);
+  let version = STABLE_XCM_VERSION;
   let method = 'limitedReserveTransferAssets';
-  if (['statemint', 'statemine'].includes(originChainInfo.slug) && _isSubstrateRelayChain(destinationChainInfo)) {
-    assetLocation = {
-      [version]: [{
-        id: {
-          Concrete: {
-            parents: 1,
-            interior: 'Here'
-          }
-        },
-        fun: {
-          Fungible: value
-        }
-      }]
-    };
+  if (_isBridgedToken(tokenInfo)) {
+    version = 4;
+    method = 'transferAssets';
+  }
+  if (isUseTeleportProtocol(originChainInfo, destinationChainInfo)) {
     method = 'limitedTeleportAssets';
   }
-  return api.tx.polkadotXcm[method](destination, beneficiary, assetLocation, 0,
+  const weightParam = _getXcmDestWeight(originChainInfo);
+  const destination = _getXcmMultiLocation(originChainInfo, destinationChainInfo, version);
+  const beneficiary = _getXcmBeneficiary(destinationChainInfo, recipientAddress, version);
+  const tokenLocation = _getXcmMultiAssets(tokenInfo, value, version);
+  return api.tx.polkadotXcm[method](destination, beneficiary, tokenLocation, 0,
   // FeeAssetItem
   weightParam);
 }

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

@@ -1,48 +1,3 @@
-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(destinationChainInfo: _ChainInfo, toAddress: string, version?: string): Record<string, any>;
-export declare function getBeneficiary(destinationChainInfo: _ChainInfo, recipientAddress: string, version?: string): {
-    [x: string]: {
-        parents: number;
-        interior: {
-            X1: Record<string, any>;
-        };
-    };
-};
-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;
-            };
-        };
-    };
-};
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare const STABLE_XCM_VERSION = 3;
+export declare function isUseTeleportProtocol(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;

package/koni/api/xcm/utils.js

@@ -1,118 +1,9 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
-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 = {
-  Limited: 5000000000
-};
-
-// get multilocation for destination chain from a parachain
-
-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,
-        id: decodeAddress(ss58Address)
-      }
-    };
-  }
-  if (_isChainEvmCompatible(destinationChainInfo)) {
-    return {
-      AccountKey20: {
-        network,
-        key: toAddress
-      }
-    };
-  }
-  return {
-    AccountId32: {
-      network,
-      id: decodeAddress(toAddress)
-    }
-  };
-}
-export function getBeneficiary(destinationChainInfo, recipientAddress, version = 'V1') {
-  const receiverLocation = getReceiverLocation(destinationChainInfo, recipientAddress, version);
-  return {
-    [version]: {
-      parents: 0,
-      interior: {
-        X1: receiverLocation
-      }
-    }
-  };
-}
-export function getDestWeight() {
-  return 'Unlimited';
-}
-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
-    }
-  };
+export const STABLE_XCM_VERSION = 3;
+export function isUseTeleportProtocol(originChainInfo, destChainInfo) {
+  const relayChainToSystemChain = ['polkadot'].includes(originChainInfo.slug) && ['statemint'].includes(destChainInfo.slug) || ['kusama'].includes(originChainInfo.slug) && ['statemine'].includes(destChainInfo.slug);
+  const systemChainToRelayChain = ['polkadot'].includes(destChainInfo.slug) && ['statemint'].includes(originChainInfo.slug) || ['kusama'].includes(destChainInfo.slug) && ['statemine'].includes(originChainInfo.slug);
+  return relayChainToSystemChain || systemChainToRelayChain;
 }

package/koni/api/xcm/xTokens.js

@@ -1,24 +1,26 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-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';
+import { _getXcmDestWeight, _getXcmMultiAssets, _getXcmMultiLocation } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { STABLE_XCM_VERSION } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _getTokenOnChainAssetId, _getTokenOnChainInfo, _getXcmAssetId, _getXcmAssetMultilocation, _getXcmAssetType } from '@subwallet/extension-base/services/chain-service/utils';
 function getCurrencyId(tokenInfo) {
-  if (['acala', 'karura'].includes(tokenInfo.originChain) && _isNativeToken(tokenInfo)) {
-    return _getXcmAssetMultilocation(tokenInfo);
-  } else if (['moonbeam', 'moonbase', 'moonriver'].includes(tokenInfo.originChain)) {
+  if (['moonbeam', 'moonbase', 'moonriver'].includes(tokenInfo.originChain)) {
     const tokenType = _getXcmAssetType(tokenInfo);
     const assetId = _getXcmAssetId(tokenInfo);
     return {
       [tokenType]: assetId
     };
-  } else if (['pioneer'].includes(tokenInfo.originChain)) {
-    return _getXcmAssetMultilocation(tokenInfo);
   }
   return _getTokenOnChainInfo(tokenInfo) || _getTokenOnChainAssetId(tokenInfo);
 }
 export function getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
-  const weightParam = ['pioneer'].includes(originChainInfo.slug) ? FOUR_INSTRUCTIONS_WEIGHT : getDestWeight();
-  const destVersion = ['moonbeam', 'moonriver', 'bifrost_dot', 'interlay', 'hydradx_main', 'acala', 'parallel', 'astar', 'shiden', 'centrifuge', 'manta_network'].includes(originChainInfo.slug) ? 'V3' : undefined;
-  return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getDestMultilocation(destinationChainInfo, recipientAddress, destVersion), weightParam);
+  const version = STABLE_XCM_VERSION;
+  const destination = _getXcmMultiLocation(originChainInfo, destinationChainInfo, version, recipientAddress);
+  if (!_getXcmAssetMultilocation(tokenInfo)) {
+    const tokenCurrencyId = getCurrencyId(tokenInfo);
+    return api.tx.xTokens.transfer(tokenCurrencyId, value, destination, _getXcmDestWeight(originChainInfo));
+  }
+  const tokenMultiAsset = _getXcmMultiAssets(tokenInfo, value, version);
+  return api.tx.xTokens.transferMultiassets(tokenMultiAsset, 0, destination, _getXcmDestWeight(originChainInfo));
 }

package/koni/api/xcm/xcmPallet.js

@@ -1,16 +1,16 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { getBeneficiary, getDestinationChainLocation, getDestWeight, getTokenLocation } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _getXcmBeneficiary, _getXcmDestWeight, _getXcmMultiAssets, _getXcmMultiLocation } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { isUseTeleportProtocol, STABLE_XCM_VERSION } 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 = 'V3';
-  const destination = getDestinationChainLocation(originChainInfo, destinationChainInfo, xcmVer);
-  const beneficiary = getBeneficiary(destinationChainInfo, recipientAddress, xcmVer);
-  const tokenLocation = getTokenLocation(tokenInfo, value, xcmVer);
+  const weightParam = _getXcmDestWeight(originChainInfo);
+  const destination = _getXcmMultiLocation(originChainInfo, destinationChainInfo, STABLE_XCM_VERSION);
+  const beneficiary = _getXcmBeneficiary(destinationChainInfo, recipientAddress, STABLE_XCM_VERSION);
+  const tokenLocation = _getXcmMultiAssets(tokenInfo, value, STABLE_XCM_VERSION);
   let method = 'limitedReserveTransferAssets';
-  if (['statemint', 'statemine'].includes(destinationChainInfo.slug)) {
+  if (isUseTeleportProtocol(originChainInfo, destinationChainInfo)) {
     method = 'limitedTeleportAssets';
   }
   return api.tx.xcmPallet[method](destination, beneficiary, tokenLocation, 0, weightParam);

package/koni/background/handlers/Extension.d.ts

@@ -124,9 +124,7 @@ export default class KoniExtension {
     private subscribeStaking;
     private subscribeHistory;
     private subscribeHistoryByChainAndAddress;
-    private validateTransfer;
     private makeTransfer;
-    private validateCrossChainTransfer;
     private makeCrossChainTransfer;
     private evmNftSubmitTransaction;
     private upsertChain;
@@ -140,12 +138,11 @@ export default class KoniExtension {
     private upsertCustomToken;
     private deleteCustomAsset;
     private validateCustomAsset;
-    private getAddressFreeBalance;
-    private transferGetMaxTransferable;
-    private subscribeAddressFreeBalance;
-    private transferCheckReferenceCount;
-    private transferCheckSupporting;
-    private transferGetExistentialDeposit;
+    private getAddressTransferableBalance;
+    private getMaxTransferable;
+    private getXcmMaxTransferable;
+    private getNativeTokenMaxTransferable;
+    private subscribeAddressTransferableBalance;
     private substrateNftSubmitTransaction;
     private enableChains;
     private getAccountMeta;
@@ -182,6 +179,7 @@ export default class KoniExtension {
     private keyringMigrateMasterPassword;
     private keyringUnlock;
     private keyringLock;
+    keyringLockSubscribe(cb: (state: boolean) => void): any;
     private keyringExportMnemonic;
     private resetWallet;
     private signingApprovePasswordV2;