@subwallet/extension-base 1.2.3-1 → 1.2.5-0

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

@@ -1,7 +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): string;
+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

@@ -1,6 +1,13 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+import BigN from 'bignumber.js';
 export function _getActiveStakeInNominationPool(memberInfo) {
-  return memberInfo.points.toString();
+  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.js

@@ -62,10 +62,9 @@ function _getSystemPalletTotalBalanceV2(accountInfo) {
 function _getSystemPalletTransferableV1(accountInfo, existentialDeposit, strictMode) {
   const bnAppliedExistentialDeposit = new BigN(_getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMode));
   const bnAppliedFrozen = BigN.max(accountInfo.data.feeFrozen, accountInfo.data.miscFrozen);
-  const bnTotalBalance = new BigN(_getSystemPalletTotalBalanceV1(accountInfo));
-  const bnTransferableBalance = bnTotalBalance.minus(BigN.max(bnAppliedFrozen, accountInfo.data.reserved, bnAppliedExistentialDeposit));
+  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).toFixed();
+  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,10 +1,7 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
-import { SupportTransferResponse } from '@subwallet/extension-base/background/KoniTypes';
 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;

package/koni/api/dotsama/transfer.js

@@ -4,112 +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, _isTokenTransferredByEvm, _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,
@@ -131,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, {}]);
@@ -177,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)) {
@@ -236,10 +128,11 @@ export const getTransferMockTxFee = async (address, chainInfo, tokenInfo, api) =
     } else {
       var _paymentInfo$partialF;
       const substrateApi = api;
+      const chainApi = await substrateApi.isReady;
       const [mockTx] = await createTransferExtrinsic({
         from: address,
         networkKey: chainInfo.slug,
-        substrateApi,
+        substrateApi: chainApi,
         to: address,
         tokenInfo,
         transferAll: true,

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

@@ -1,6 +1,7 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { NominationInfo, NominatorMetadata, StakingType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
 import { _SubstrateInflationParams } from '@subwallet/extension-base/services/chain-service/constants';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { EarningStatus, PalletStakingEraRewardPoints, YieldPoolInfo, YieldPositionInfo } from '@subwallet/extension-base/types';
 import BigNumber from 'bignumber.js';
 import { ApiPromise } from '@polkadot/api';
@@ -158,8 +159,11 @@ export declare function getEarningStatusByNominations(bnTotalActiveStake: BN, no
 export declare function getValidatorLabel(chain: string): "dApp" | "Validator" | "Collator";
 export declare function getAvgValidatorEraReward(supportedDays: number, eraRewardHistory: Codec[]): BigNumber;
 export declare function getSupportedDaysByHistoryDepth(erasPerDay: number, maxSupportedEras: number, liveDay?: number): number;
-export declare function getValidatorPointsMap(eraRewardMap: Record<string, PalletStakingEraRewardPoints>): Record<string, BigNumber>;
-export declare function getTopValidatorByPoints(validatorPointsList: Record<string, BigNumber>): string[];
+export declare function getRelayValidatorPointsMap(eraRewardMap: Record<string, PalletStakingEraRewardPoints>): Record<string, BigNumber>;
+export declare function getRelayTopValidatorByPoints(validatorPointsList: Record<string, BigNumber>): string[];
+export declare function getRelayBlockedValidatorList(validators: any[]): string[];
+export declare function getRelayEraRewardMap(eraRewardPointArray: Codec[], startEraForPoints: number): Record<string, PalletStakingEraRewardPoints>;
+export declare function getRelayMaxNominations(substrateApi: _SubstrateApi): Promise<string>;
 export declare const getMinStakeErrorMessage: (chainInfo: _ChainInfo, bnMinStake: BN) => string;
 export declare const getMaxValidatorErrorMessage: (chainInfo: _ChainInfo, max: number) => string;
 export declare const getExistUnstakeErrorMessage: (chain: string, type?: StakingType, isStakeMore?: boolean) => string;

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

@@ -354,13 +354,12 @@ export function getSupportedDaysByHistoryDepth(erasPerDay, maxSupportedEras, liv
     return maxSupportDay;
   }
 }
-export function getValidatorPointsMap(eraRewardMap) {
+export function getRelayValidatorPointsMap(eraRewardMap) {
   // mapping store validator and totalPoints
   const validatorTotalPointsMap = {};
   Object.values(eraRewardMap).forEach(info => {
     const individual = info.individual;
-    Object.entries(individual).forEach(([validator, rawPoints]) => {
-      const points = rawPoints.replaceAll(',', '');
+    Object.entries(individual).forEach(([validator, points]) => {
       if (!validatorTotalPointsMap[validator]) {
         validatorTotalPointsMap[validator] = new BigNumber(points);
       } else {
@@ -370,7 +369,7 @@ export function getValidatorPointsMap(eraRewardMap) {
   });
   return validatorTotalPointsMap;
 }
-export function getTopValidatorByPoints(validatorPointsList) {
+export function getRelayTopValidatorByPoints(validatorPointsList) {
   const sortValidatorPointsList = Object.fromEntries(Object.entries(validatorPointsList).sort((a, b) => a[1].minus(b[1]).toNumber()).reverse());
 
   // keep 50% first validator
@@ -380,6 +379,36 @@ export function getTopValidatorByPoints(validatorPointsList) {
   const top50PercentRecord = Object.fromEntries(top50PercentEntries);
   return Object.keys(top50PercentRecord);
 }
+export function getRelayBlockedValidatorList(validators) {
+  const blockValidatorList = [];
+  for (const validator of validators) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const validatorAddress = validator[0].toHuman()[0];
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const validatorPrefs = validator[1].toHuman();
+    const isBlocked = validatorPrefs.blocked;
+    if (isBlocked) {
+      blockValidatorList.push(validatorAddress);
+    }
+  }
+  return blockValidatorList;
+}
+export function getRelayEraRewardMap(eraRewardPointArray, startEraForPoints) {
+  const eraRewardMap = {};
+  for (const item of eraRewardPointArray) {
+    eraRewardMap[startEraForPoints] = item.toPrimitive();
+    startEraForPoints++;
+  }
+  return eraRewardMap;
+}
+export async function getRelayMaxNominations(substrateApi) {
+  var _substrateApi$api$con, _substrateApi$api$con2, _substrateApi$api$cal;
+  await substrateApi.isReady;
+  const maxNominations = ((_substrateApi$api$con = substrateApi.api.consts.staking) === null || _substrateApi$api$con === void 0 ? void 0 : (_substrateApi$api$con2 = _substrateApi$api$con.maxNominations) === null || _substrateApi$api$con2 === void 0 ? void 0 : _substrateApi$api$con2.toString()) || '16';
+  const _maxNominationsByNominationQuota = await ((_substrateApi$api$cal = substrateApi.api.call.stakingApi) === null || _substrateApi$api$cal === void 0 ? void 0 : _substrateApi$api$cal.nominationsQuota(0)); // todo: review param. Currently return constant for all param.
+  const maxNominationsByNominationQuota = _maxNominationsByNominationQuota === null || _maxNominationsByNominationQuota === void 0 ? void 0 : _maxNominationsByNominationQuota.toString();
+  return maxNominationsByNominationQuota || maxNominations;
+}
 export const getMinStakeErrorMessage = (chainInfo, bnMinStake) => {
   const tokenInfo = _getChainNativeTokenBasicInfo(chainInfo);
   const number = formatNumber(bnMinStake.toString(), tokenInfo.decimals || 0, balanceFormatter);

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;