@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNominationPoolReward = getNominationPoolReward;
+exports.getRelayPoolingOnChain = getRelayPoolingOnChain;
+exports.getRelayStakingOnChain = getRelayStakingOnChain;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function getRelayStakingOnChain(substrateApi, useAddresses, chainInfoMap, chain, callback) {
+  var _substrateApi$api$que;
+  const {
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfoMap[chain]);
+  return (_substrateApi$api$que = substrateApi.api.query.staking) === null || _substrateApi$api$que === void 0 ? void 0 : _substrateApi$api$que.ledger.multi(useAddresses, ledgers => {
+    let unit = '';
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42) || undefined;
+        const data = ledger.toHuman();
+        if (data && data.active) {
+          const _totalBalance = data.total;
+          const _activeBalance = data.active;
+          let bnUnlockingBalance = new _util.BN(0);
+          data.unlocking.forEach(_ref => {
+            let {
+              value
+            } = _ref;
+            value = value.split(' ')[0];
+            const _unlockingBalance = value.replaceAll(',', '');
+            bnUnlockingBalance = bnUnlockingBalance.add(new _util.BN(_unlockingBalance));
+          });
+          let amount = _totalBalance ? _totalBalance.split(' ')[0] : '';
+          amount = amount.replaceAll(',', '');
+          unit = _totalBalance ? _totalBalance.split(' ')[1] : '';
+          const bnTotalBalance = new _util.BN(amount);
+          amount = _activeBalance ? _activeBalance.split(' ')[0] : '';
+          amount = amount.replaceAll(',', '');
+          unit = _activeBalance ? _activeBalance.split(' ')[1] : '';
+          const bnActiveBalance = new _util.BN(amount);
+          const stakingItem = {
+            name: chainInfoMap[chain].name,
+            chain: chain,
+            balance: bnTotalBalance.toString(),
+            activeBalance: bnActiveBalance.toString(),
+            unlockingBalance: bnUnlockingBalance.toString(),
+            nativeToken: symbol,
+            unit: unit || symbol,
+            state: _KoniTypes.APIItemState.READY,
+            type: _KoniTypes.StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        } else {
+          const stakingItem = {
+            name: chainInfoMap[chain].name,
+            chain: chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: unit || symbol,
+            state: _KoniTypes.APIItemState.READY,
+            type: _KoniTypes.StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        }
+      }
+    }
+  });
+}
+function getRelayPoolingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  var _parentApi$api$query, _parentApi$api$query$;
+  const {
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(networks[chain]);
+  return (_parentApi$api$query = parentApi.api.query) === null || _parentApi$api$query === void 0 ? void 0 : (_parentApi$api$query$ = _parentApi$api$query.nominationPools) === null || _parentApi$api$query$ === void 0 ? void 0 : _parentApi$api$query$.poolMembers.multi(useAddresses, ledgers => {
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+        const data = ledger.toHuman();
+        if (data !== null) {
+          const bondedBalance = data.points;
+          const unbondedBalance = data.unbondingEras;
+          let unlockingBalance = new _util.BN(0);
+          let totalBalance = new _util.BN(0);
+          Object.entries(unbondedBalance).forEach(_ref2 => {
+            let [era, value] = _ref2;
+            const bnUnbondedBalance = new _util.BN(value.replaceAll(',', ''));
+            unlockingBalance = unlockingBalance.add(bnUnbondedBalance);
+          });
+          const bnBondedBalance = new _util.BN(bondedBalance.replaceAll(',', ''));
+          totalBalance = totalBalance.add(bnBondedBalance).add(unlockingBalance);
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: totalBalance.toString(),
+            activeBalance: bnBondedBalance.toString(),
+            unlockingBalance: unlockingBalance.toString(),
+            nativeToken: symbol,
+            unit: symbol,
+            state: _KoniTypes.APIItemState.READY,
+            type: _KoniTypes.StakingType.POOLED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        } else {
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: symbol,
+            state: _KoniTypes.APIItemState.READY,
+            type: _KoniTypes.StakingType.POOLED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        }
+      }
+    }
+  });
+}
+async function getNominationPoolReward(addresses, chainInfoMap, substrateApiMap) {
+  const targetNetworks = [];
+  const validAddresses = [];
+  Object.keys(chainInfoMap).forEach(key => {
+    targetNetworks.push(key);
+  });
+  addresses.forEach(address => {
+    if (!(0, _utilCrypto.isEthereumAddress)(address)) {
+      validAddresses.push(address);
+    }
+  });
+  const rewardList = [];
+  try {
+    await Promise.all(targetNetworks.map(async networkKey => {
+      const substrateApi = await substrateApiMap[networkKey].isReady;
+      await Promise.all(validAddresses.map(async address => {
+        var _substrateApi$api$cal, _substrateApi$api$cal2;
+        const _unclaimedReward = await ((_substrateApi$api$cal = substrateApi.api.call) === null || _substrateApi$api$cal === void 0 ? void 0 : (_substrateApi$api$cal2 = _substrateApi$api$cal.nominationPoolsApi) === null || _substrateApi$api$cal2 === void 0 ? void 0 : _substrateApi$api$cal2.pendingRewards(address));
+        if (_unclaimedReward) {
+          rewardList.push({
+            address: address,
+            chain: networkKey,
+            unclaimedReward: _unclaimedReward.toString(),
+            name: chainInfoMap[networkKey].name,
+            state: _KoniTypes.APIItemState.READY,
+            type: _KoniTypes.StakingType.POOLED
+          });
+        }
+      }));
+    }));
+  } catch (e) {
+    console.error('Error fetching unclaimed reward for nomination pool', e);
+    return rewardList;
+  }
+  return rewardList;
+}

package/cjs/koni/api/staking/subsquidStaking.js

@@ -0,0 +1,109 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAllSubsquidStaking = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _config = require("@subwallet/extension-base/koni/api/staking/config");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _axios = _interopRequireDefault(require("axios"));
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const getSubsquidQuery = (account, chain) => {
+  if (chain === 'moonbeam' || chain === 'moonriver' || chain === 'astar') {
+    return `
+    query MyQuery {
+      stakerById(id: "${account}") {
+        totalReward
+        activeBond
+        rewards(limit: 1, orderBy: blockNumber_DESC) {
+          amount
+        }
+      }
+    }`;
+  }
+  return `
+  query MyQuery {
+    stakerById(id: "${account}") {
+      totalReward
+      totalSlash
+      activeBond
+      rewards(limit: 1, orderBy: blockNumber_DESC) {
+        amount
+      }
+    }
+  }`;
+};
+const getSubsquidStaking = async (accounts, chain, chainInfoMap) => {
+  try {
+    const result = [];
+    await Promise.all(accounts.map(async account => {
+      if ((0, _utils._isChainEvmCompatible)(chainInfoMap[chain]) && (0, _utilCrypto.isEthereumAddress)(account) || !(0, _utils._isChainEvmCompatible)(chainInfoMap[chain]) && !(0, _utilCrypto.isEthereumAddress)(account)) {
+        const parsedAccount = (0, _utils2.reformatAddress)(account, (0, _utils._getChainSubstrateAddressPrefix)(chainInfoMap[chain]));
+        const stakingRewardItem = {
+          chain: chain,
+          name: chainInfoMap[chain].name,
+          state: _KoniTypes.APIItemState.READY,
+          type: _KoniTypes.StakingType.NOMINATED,
+          address: (0, _utils2.reformatAddress)(account, 42)
+        };
+        const resp = await (0, _axios.default)({
+          url: _config.SUBSQUID_ENDPOINTS[chain],
+          method: 'post',
+          data: {
+            query: getSubsquidQuery(parsedAccount, chain)
+          }
+        });
+        if (resp.status === 200) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          const respData = resp.data.data;
+          const rewardItem = respData.stakerById;
+          if (rewardItem) {
+            const latestReward = rewardItem.rewards[0];
+            if (rewardItem.totalReward) {
+              stakingRewardItem.totalReward = rewardItem.totalReward;
+            }
+            if (rewardItem.totalSlash) {
+              stakingRewardItem.totalSlash = rewardItem.totalSlash;
+            }
+            if (latestReward && latestReward.amount) {
+              stakingRewardItem.latestReward = latestReward.amount;
+            }
+          }
+        }
+        if (stakingRewardItem.totalReward && parseFloat(stakingRewardItem.totalReward) > 0) {
+          result.push(stakingRewardItem);
+        }
+      }
+    }));
+    return result;
+  } catch (e) {
+    console.error(`error getting ${chain} staking reward from subsquid`, e);
+    return [];
+  }
+};
+const getAllSubsquidStaking = async (accounts, chainInfoMap) => {
+  let rewardList = [];
+  const filteredNetworks = [];
+  Object.values(chainInfoMap).forEach(network => {
+    if (_config.INDEXER_SUPPORTED_STAKING_CHAINS.includes(network.slug)) {
+      filteredNetworks.push(network.slug);
+    }
+  });
+  try {
+    await Promise.all(filteredNetworks.map(async network => {
+      const rewardItems = await getSubsquidStaking(accounts, network, chainInfoMap);
+      rewardList = rewardList.concat(rewardItems);
+    }));
+  } catch (e) {
+    console.error('Error fetching staking reward from SubSquid', e);
+    return rewardList;
+  }
+  return rewardList;
+};
+exports.getAllSubsquidStaking = getAllSubsquidStaking;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseStakingBalance = parseStakingBalance;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function parseStakingBalance(balance, chain, network) {
+  const {
+    decimals
+  } = (0, _utils._getChainNativeTokenBasicInfo)(network[chain]);
+  return (0, _utils2.toUnit)(balance, decimals);
+}

package/cjs/koni/api/subquery/__generated__/DotSamaHistory.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/koni/api/subquery/subquery.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.newApolloClient = newApolloClient;
+var _client = require("@apollo/client");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function newApolloClient(uri) {
+  return new _client.ApolloClient({
+    cache: new _client.InMemoryCache(),
+    link: (0, _client.createHttpLink)({
+      uri: uri,
+      fetch: _crossFetch.default
+    })
+  });
+}

package/cjs/koni/api/tokens/evm/balance.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEVMBalance = getEVMBalance;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function getEVMBalance(networkKey, addresses, evmApiMap) {
+  const web3Api = evmApiMap[networkKey];
+  return await Promise.all(addresses.map(async address => {
+    return await web3Api.api.eth.getBalance(address);
+  }));
+}

package/cjs/koni/api/tokens/evm/transfer.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getERC20TransactionObject = getERC20TransactionObject;
+exports.getERC721Transaction = getERC721Transaction;
+exports.getEVMTransactionObject = getEVMTransactionObject;
+exports.handleTransferBalanceResult = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _web = require("@subwallet/extension-base/koni/api/tokens/evm/web3");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _helper = require("@subwallet/extension-base/services/chain-service/helper");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const handleTransferBalanceResult = _ref => {
+  let {
+    callback,
+    changeValue,
+    networkKey,
+    receipt,
+    response,
+    updateState
+  } = _ref;
+  response.status = true;
+  let fee;
+  if (_constants._BALANCE_PARSING_CHAIN_GROUP.bobabeam.indexOf(networkKey) > -1) {
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    fee = (0, _util.hexToBn)(receipt.l1Fee || '0x0').add((0, _util.hexToBn)(receipt.l2BobaFee || '0x0')).toString();
+  } else {
+    fee = (receipt.gasUsed * receipt.effectiveGasPrice).toString();
+  }
+  response.txResult = {
+    change: changeValue || '0',
+    fee
+  };
+  updateState && updateState({
+    status: receipt.status ? _KoniTypes.ExternalRequestPromiseStatus.COMPLETED : _KoniTypes.ExternalRequestPromiseStatus.FAILED
+  });
+  callback(response);
+};
+exports.handleTransferBalanceResult = handleTransferBalanceResult;
+async function getEVMTransactionObject(chainInfo, to, value, transferAll, evmApiMap) {
+  const networkKey = chainInfo.slug;
+  const web3Api = evmApiMap[networkKey];
+  const gasPrice = await web3Api.api.eth.getGasPrice();
+  const transactionObject = {
+    gasPrice: gasPrice,
+    to: to
+  };
+  const gasLimit = await web3Api.api.eth.estimateGas(transactionObject);
+  transactionObject.gas = gasLimit;
+  const estimateFee = parseInt(gasPrice) * gasLimit;
+  transactionObject.value = transferAll ? new _util.BN(value).add(new _util.BN(estimateFee).neg()) : value;
+  return [transactionObject, transactionObject.value.toString()];
+}
+async function getERC20TransactionObject(assetAddress, chainInfo, from, to, value, transferAll, evmApiMap) {
+  const networkKey = chainInfo.slug;
+  const evmApi = evmApiMap[networkKey];
+  const erc20Contract = (0, _web.getERC20Contract)(networkKey, assetAddress, evmApiMap);
+  let freeAmount = new _util.BN(0);
+  let transferValue = value;
+  if (transferAll) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const bal = await erc20Contract.methods.balanceOf(from).call();
+    freeAmount = new _util.BN(bal || '0');
+    transferValue = freeAmount.toString() || '0';
+  }
+  function generateTransferData(to, transferValue) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    return erc20Contract.methods.transfer(to, transferValue).encodeABI();
+  }
+  const transferData = generateTransferData(to, transferValue);
+  const [gasLimit, gasPrice] = await Promise.all([
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  erc20Contract.methods.transfer(to, transferValue).estimateGas({
+    from
+  }), evmApi.api.eth.getGasPrice()]);
+  const transactionObject = {
+    gasPrice: gasPrice,
+    gas: gasLimit,
+    from,
+    to: assetAddress,
+    data: transferData
+  };
+  if (transferAll) {
+    transferValue = new _util.BN(freeAmount).toString();
+    transactionObject.data = generateTransferData(to, transferValue);
+  }
+  return [transactionObject, transferValue];
+}
+async function getERC721Transaction(web3Api, contractAddress, senderAddress, recipientAddress, tokenId) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  const contract = new web3Api.api.eth.Contract(_helper._ERC721_ABI, contractAddress);
+  const [gasLimit, gasPrice] = await Promise.all([
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  contract.methods.safeTransferFrom(senderAddress, recipientAddress, tokenId).estimateGas({
+    from: senderAddress
+  }), web3Api.api.eth.getGasPrice()]);
+  return {
+    from: senderAddress,
+    gasPrice,
+    gas: gasLimit,
+    to: contractAddress,
+    value: '0x00',
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    data: contract.methods.safeTransferFrom(senderAddress, recipientAddress, tokenId).encodeABI()
+  };
+}

package/cjs/koni/api/tokens/evm/web3.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getERC20Contract = void 0;
+var _helper = require("@subwallet/extension-base/services/chain-service/helper");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const getERC20Contract = function (networkKey, assetAddress, evmApiMap) {
+  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+  return new evmApiMap[networkKey].api.eth.Contract(_helper._ERC20_ABI, assetAddress, options);
+};
+exports.getERC20Contract = getERC20Contract;

package/cjs/koni/api/tokens/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEqualContractAddress = isEqualContractAddress;
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function isEqualContractAddress(address1, address2) {
+  if ((0, _utilCrypto.isEthereumAddress)(address1) && (0, _utilCrypto.isEthereumAddress)(address2)) {
+    return address1.toLowerCase() === address2.toLowerCase(); // EVM address is case-insensitive
+  }
+
+  return address2 === address1;
+}

package/cjs/koni/api/tokens/wasm/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPSP22ContractPromise = getPSP22ContractPromise;
+exports.getPSP34ContractPromise = getPSP34ContractPromise;
+exports.getPSP34TransferExtrinsic = getPSP34TransferExtrinsic;
+var _helper = require("@subwallet/extension-base/services/chain-service/helper");
+var _apiContract = require("@polkadot/api-contract");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getPSP22ContractPromise(apiPromise, contractAddress) {
+  return new _apiContract.ContractPromise(apiPromise, _helper._PSP22_ABI, contractAddress);
+}
+function getPSP34ContractPromise(apiPromise, contractAddress) {
+  return new _apiContract.ContractPromise(apiPromise, _helper._PSP34_ABI, contractAddress);
+}
+async function getPSP34TransferExtrinsic(networkKey, substrateApi, senderAddress, recipientAddress, params) {
+  const contractAddress = params.contractAddress;
+  const onChainOption = params.onChainOption;
+  try {
+    const contractPromise = getPSP34ContractPromise(substrateApi.api, contractAddress);
+    const transferQuery = await contractPromise.query['psp34::transfer'](senderAddress, {
+      gasLimit: -1
+    }, recipientAddress, onChainOption, {});
+    const gasLimit = transferQuery.gasRequired.toString();
+    return contractPromise.tx['psp34::transfer']({
+      gasLimit
+    }, recipientAddress, onChainOption, {});
+  } catch (e) {
+    console.error('Error getting WASM NFT transfer extrinsic', e);
+    return null;
+  }
+}

package/cjs/koni/api/xcm/astar.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.astarEstimateCrossChainFee = astarEstimateCrossChainFee;
+exports.astarGetXcmExtrinsic = astarGetXcmExtrinsic;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// const ASSET_TO_LOCATION_MAP: Record<string, Record<string, Record<string, any>>> = {
+//   astar: {
+//     '18446744073709551617': { // aUSD
+//       parents: 1, interior: { X2: [{ Parachain: 2000 }, { GeneralKey: '0x0001' }] }
+//     },
+//     '340282366920938463463374607431768211455': { // DOT
+//       parents: 1, interior: 'Here'
+//     }
+//   },
+//   shiden: {
+//     '18446744073709551616': { // aUSD
+//       parents: 1, interior: { X2: [{ Parachain: 2000 }, { GeneralKey: '0x0081' }] }
+//     },
+//     '340282366920938463463374607431768211455': {
+//       parents: 1, interior: 'Here'
+//     }
+//   }
+// };
+
+async function astarEstimateCrossChainFee(originNetworkKey, destinationNetworkKey, recipient, sender, sendingValue, substrateApiMap, originTokenInfo, chainInfoMap) {
+  const substrateApi = await substrateApiMap[originNetworkKey].isReady;
+  const destinationChainInfo = chainInfoMap[destinationNetworkKey];
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const assetLocation = (0, _utils._getXcmAssetMultilocation)(originTokenInfo);
+  let receiverLocation = {
+    AccountId32: {
+      network: 'Any',
+      id: (0, _utilCrypto.decodeAddress)(recipient)
+    }
+  };
+  let destinationChainLocation = {
+    V1: {
+      // find the destination chain
+      parents: 1,
+      interior: {
+        X1: {
+          Parachain: (0, _utils._getSubstrateParaId)(destinationChainInfo)
+        }
+      }
+    }
+  };
+  if ((0, _utils._isChainEvmCompatible)(destinationChainInfo)) {
+    receiverLocation = {
+      AccountKey20: {
+        network: 'Any',
+        id: recipient
+      }
+    };
+  }
+  if ((0, _utils._isSubstrateRelayChain)(destinationChainInfo)) {
+    // check if sending to relaychain
+    destinationChainLocation = {
+      V1: {
+        // find the destination chain
+        parents: 1,
+        interior: 'Here'
+      }
+    };
+  }
+  const extrinsic = substrateApi.api.tx.polkadotXcm.reserveWithdrawAssets(destinationChainLocation, {
+    V1: {
+      // find the receiver
+      parents: 0,
+      // parents for beneficiary is always 0
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  }, {
+    V1: [
+    // find the asset
+    {
+      id: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        Concrete: assetLocation
+      },
+      fun: {
+        Fungible: sendingValue
+      }
+    }]
+  }, 0);
+  console.log('astar xcm tx here', extrinsic.toHex());
+  const paymentInfo = await extrinsic.paymentInfo(sender);
+  return paymentInfo.partialFee.toString();
+}
+function astarGetXcmExtrinsic(originNetworkKey, destinationNetworkKey, recipient, sendingValue, api, originTokenInfo, chainInfoMap) {
+  const destinationChainInfo = chainInfoMap[destinationNetworkKey];
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const assetLocation = (0, _utils._getXcmAssetMultilocation)(originTokenInfo);
+  let receiverLocation = {
+    AccountId32: {
+      network: 'Any',
+      id: (0, _utilCrypto.decodeAddress)(recipient)
+    }
+  };
+  let destinationChainLocation = {
+    V1: {
+      // find the destination chain
+      parents: 1,
+      interior: {
+        X1: {
+          Parachain: (0, _utils._getSubstrateParaId)(destinationChainInfo)
+        }
+      }
+    }
+  };
+  if ((0, _utils._isChainEvmCompatible)(destinationChainInfo)) {
+    receiverLocation = {
+      AccountKey20: {
+        network: 'Any',
+        id: recipient
+      }
+    };
+  }
+  if ((0, _utils._isSubstrateRelayChain)(destinationChainInfo)) {
+    destinationChainLocation = {
+      V1: {
+        // find the destination chain
+        parents: 1,
+        interior: 'Here'
+      }
+    };
+  }
+  return api.tx.polkadotXcm.reserveWithdrawAssets(destinationChainLocation, {
+    V1: {
+      // find the receiver
+      parents: 0,
+      // parents for beneficiary is always 0
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  }, {
+    V1: [
+    // find the asset
+    {
+      id: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        Concrete: assetLocation
+      },
+      fun: {
+        Fungible: sendingValue
+      }
+    }]
+  }, 0);
+}