@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,101 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExternalRequestPromiseStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { getERC20Contract } from '@subwallet/extension-base/koni/api/tokens/evm/web3';
+import { _BALANCE_PARSING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _ERC721_ABI } from '@subwallet/extension-base/services/chain-service/helper';
+import { BN, hexToBn } from '@polkadot/util';
+export const handleTransferBalanceResult = ({
+  callback,
+  changeValue,
+  networkKey,
+  receipt,
+  response,
+  updateState
+}) => {
+  response.status = true;
+  let fee;
+  if (_BALANCE_PARSING_CHAIN_GROUP.bobabeam.indexOf(networkKey) > -1) {
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    fee = hexToBn(receipt.l1Fee || '0x0').add(hexToBn(receipt.l2BobaFee || '0x0')).toString();
+  } else {
+    fee = (receipt.gasUsed * receipt.effectiveGasPrice).toString();
+  }
+  response.txResult = {
+    change: changeValue || '0',
+    fee
+  };
+  updateState && updateState({
+    status: receipt.status ? ExternalRequestPromiseStatus.COMPLETED : ExternalRequestPromiseStatus.FAILED
+  });
+  callback(response);
+};
+export 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 BN(value).add(new BN(estimateFee).neg()) : value;
+  return [transactionObject, transactionObject.value.toString()];
+}
+export async function getERC20TransactionObject(assetAddress, chainInfo, from, to, value, transferAll, evmApiMap) {
+  const networkKey = chainInfo.slug;
+  const evmApi = evmApiMap[networkKey];
+  const erc20Contract = getERC20Contract(networkKey, assetAddress, evmApiMap);
+  let freeAmount = new 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 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 BN(freeAmount).toString();
+    transactionObject.data = generateTransferData(to, transferValue);
+  }
+  return [transactionObject, transferValue];
+}
+export async function getERC721Transaction(web3Api, contractAddress, senderAddress, recipientAddress, tokenId) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  const contract = new web3Api.api.eth.Contract(_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/koni/api/tokens/evm/web3.d.ts

@@ -0,0 +1,3 @@
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { Contract } from 'web3-eth-contract';
+export declare const getERC20Contract: (networkKey: string, assetAddress: string, evmApiMap: Record<string, _EvmApi>, options?: {}) => Contract;

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

@@ -0,0 +1,9 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _ERC20_ABI } from '@subwallet/extension-base/services/chain-service/helper';
+export const getERC20Contract = (networkKey, assetAddress, evmApiMap, options = {}) => {
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+  return new evmApiMap[networkKey].api.eth.Contract(_ERC20_ABI, assetAddress, options);
+};

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

@@ -0,0 +1 @@
+export declare function isEqualContractAddress(address1: string, address2: string): boolean;

package/koni/api/tokens/index.js

@@ -0,0 +1,11 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export function isEqualContractAddress(address1, address2) {
+  if (isEthereumAddress(address1) && isEthereumAddress(address2)) {
+    return address1.toLowerCase() === address2.toLowerCase(); // EVM address is case-insensitive
+  }
+
+  return address2 === address1;
+}

package/koni/api/tokens/wasm/index.d.ts

@@ -0,0 +1,6 @@
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { ApiPromise } from '@polkadot/api';
+import { ContractPromise } from '@polkadot/api-contract';
+export declare function getPSP22ContractPromise(apiPromise: ApiPromise, contractAddress: string): ContractPromise;
+export declare function getPSP34ContractPromise(apiPromise: ApiPromise, contractAddress: string): ContractPromise;
+export declare function getPSP34TransferExtrinsic(networkKey: string, substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null>;

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

@@ -0,0 +1,28 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _PSP22_ABI, _PSP34_ABI } from '@subwallet/extension-base/services/chain-service/helper';
+import { ContractPromise } from '@polkadot/api-contract';
+export function getPSP22ContractPromise(apiPromise, contractAddress) {
+  return new ContractPromise(apiPromise, _PSP22_ABI, contractAddress);
+}
+export function getPSP34ContractPromise(apiPromise, contractAddress) {
+  return new ContractPromise(apiPromise, _PSP34_ABI, contractAddress);
+}
+export 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/koni/api/xcm/index.d.ts

@@ -0,0 +1,13 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { SubmittableExtrinsic } from '@polkadot/api/types';
+interface CreateXcmExtrinsicProps {
+    originTokenInfo: _ChainAsset;
+    destinationTokenInfo: _ChainAsset;
+    recipient: string;
+    sendingValue: string;
+    substrateApi: _SubstrateApi;
+    chainInfoMap: Record<string, _ChainInfo>;
+}
+export declare const createXcmExtrinsic: ({ chainInfoMap, destinationTokenInfo, originTokenInfo, recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
+export {};

package/koni/api/xcm/index.js

@@ -0,0 +1,141 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { getExtrinsicByPolkadotXcmPallet } from '@subwallet/extension-base/koni/api/xcm/polkadotXcm';
+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';
+export const createXcmExtrinsic = async ({
+  chainInfoMap,
+  destinationTokenInfo,
+  originTokenInfo,
+  recipient,
+  sendingValue,
+  substrateApi
+}) => {
+  const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+  const destinationChainInfo = chainInfoMap[destinationTokenInfo.originChain];
+  const chainApi = await substrateApi.isReady;
+  const api = chainApi.api;
+  let extrinsic;
+  if (_XCM_CHAIN_GROUP.polkadotXcm.includes(originTokenInfo.originChain)) {
+    extrinsic = getExtrinsicByPolkadotXcmPallet(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
+  } else if (_XCM_CHAIN_GROUP.xcmPallet.includes(originTokenInfo.originChain)) {
+    extrinsic = getExtrinsicByXcmPalletPallet(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
+  } else {
+    extrinsic = getExtrinsicByXtokensPallet(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
+  }
+  console.log('XCM extrinsic: ', extrinsic.toHex());
+  return extrinsic;
+};
+
+// TODO: add + refine logic for more chains
+// export function updateXcmResponseTxResult (
+//   networkKey: string,
+//   tokenInfo: _ChainAsset,
+//   response: TransactionResponse,
+//   records: EventRecord[]
+// ) {
+//   if (!response.txResult) {
+//     response.txResult = { change: '0' };
+//   }
+//
+//   let isFeeUseMainTokenSymbol = true;
+//
+//   for (let index = 0; index < records.length; index++) {
+//     const record = records[index];
+//
+//     if (_XCM_CHAIN_GROUP.acala.includes(networkKey) && !_isNativeToken(tokenInfo)) {
+//       if (record.event.section === 'currencies' &&
+//         record.event.method.toLowerCase() === 'transferred') {
+//         if (index === 0) {
+//           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+//           response.txResult.fee = record.event.data[3]?.toString() || '0';
+//           response.txResult.feeSymbol = tokenInfo.symbol;
+//
+//           isFeeUseMainTokenSymbol = false;
+//         } else {
+//           response.txResult.change = record.event.data[3]?.toString() || '0';
+//           response.txResult.changeSymbol = tokenInfo.symbol;
+//         }
+//       }
+//
+//       if (record.event.section === 'tokens' &&
+//         record.event.method.toLowerCase() === 'withdrawn') {
+//         response.txResult.change = record.event.data[2]?.toString() || '0';
+//         response.txResult.changeSymbol = tokenInfo.symbol;
+//       }
+//     } else if (_XCM_CHAIN_GROUP.kintsugi.includes(networkKey) && !_isNativeToken(tokenInfo)) {
+//       if (record.event.section === 'tokens' &&
+//         record.event.method.toLowerCase() === 'transfer') {
+//         response.txResult.change = record.event.data[3]?.toString() || '0';
+//         response.txResult.changeSymbol = tokenInfo.symbol;
+//       }
+//     } else if (_XCM_CHAIN_GROUP.genshiro.includes(networkKey) && !_isNativeToken(tokenInfo)) {
+//       if (record.event.section === 'eqBalances' &&
+//         record.event.method.toLowerCase() === 'transfer') {
+//         response.txResult.change = record.event.data[3]?.toString() || '0';
+//         response.txResult.changeSymbol = tokenInfo.symbol;
+//       }
+//     } else if (_XCM_CHAIN_GROUP.bifrost.includes(networkKey) && !_isNativeToken(tokenInfo)) {
+//       if (record.event.section === 'tokens' &&
+//         record.event.method.toLowerCase() === 'withdrawn') {
+//         response.txResult.change = record.event.data[2]?.toString() || '0';
+//         response.txResult.changeSymbol = tokenInfo.symbol;
+//       } else if (record.event.section === 'balances' &&
+//         record.event.method.toLowerCase() === 'transfer') {
+//         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+//         response.txResult.change = record.event.data[2]?.toString() || '0';
+//         response.txResult.changeSymbol = tokenInfo.symbol;
+//       }
+//     } else if (_XCM_CHAIN_GROUP.astar.includes(networkKey) && !_isNativeToken(tokenInfo)) {
+//       if (record.event.section === 'assets' &&
+//         record.event.method.toLowerCase() === 'burned') {
+//         response.txResult.change = record.event.data[2]?.toString() || '0';
+//         response.txResult.changeSymbol = tokenInfo.symbol;
+//       }
+//     } else if (_XCM_CHAIN_GROUP.moonbeam.includes(networkKey) && !_isNativeToken(tokenInfo)) {
+//       if (record.event.section === 'assets' &&
+//         record.event.method.toLowerCase() === 'burned') {
+//         response.txResult.change = record.event.data[2]?.toString() || '0';
+//         response.txResult.changeSymbol = tokenInfo.symbol;
+//       }
+//     } else if (_XCM_CHAIN_GROUP.statemine.includes(networkKey)) {
+//       if (!_isNativeToken(tokenInfo)) {
+//         if (record.event.section === 'assets' &&
+//           record.event.method.toLowerCase() === 'transferred') {
+//           response.txResult.change = record.event.data[3]?.toString() || '0';
+//           response.txResult.changeSymbol = tokenInfo.symbol;
+//         }
+//       } else {
+//         if (record.event.section === 'balances' &&
+//           record.event.method.toLowerCase() === 'withdraw') {
+//           response.txResult.change = record.event.data[1]?.toString() || '0';
+//           response.txResult.changeSymbol = tokenInfo.symbol;
+//         }
+//       }
+//     } else {
+//       if (record.event.section === 'balances' &&
+//         record.event.method.toLowerCase() === 'transfer') {
+//         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+//         response.txResult.change = record.event.data[2]?.toString() || '0';
+//       } else if (record.event.section === 'xTokens' &&
+//         record.event.method.toLowerCase() === 'transferred') {
+//         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+//         response.txResult.change = record.event.data[2]?.toString() || '0';
+//       }
+//     }
+//
+//     if (isFeeUseMainTokenSymbol && record.event.section === 'balances' && record.event.method.toLowerCase() === 'withdraw') {
+//       if (!response.txResult.fee) {
+//         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+//         response.txResult.fee = record.event.data[1]?.toString() || '0';
+//       }
+//     } else if (isFeeUseMainTokenSymbol && record.event.section === 'tokens' && record.event.method.toLowerCase() === 'withdrawn') {
+//       if (!response.txResult.fee) {
+//         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+//         response.txResult.fee = record.event.data[2]?.toString() || '0';
+//       }
+//     }
+//   }
+// }

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

@@ -0,0 +1,3 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ApiPromise } from '@polkadot/api';
+export declare function getExtrinsicByPolkadotXcmPallet(tokenInfo: _ChainAsset, originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string, value: string, api: ApiPromise): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>;

package/koni/api/xcm/polkadotXcm.js

@@ -0,0 +1,52 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { FOUR_INSTRUCTIONS_WEIGHT, getBeneficiary, NETWORK_USE_UNLIMITED_WEIGHT, POLKADOT_UNLIMITED_WEIGHT } 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
+      }
+    }]
+  };
+}
+export function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? POLKADOT_UNLIMITED_WEIGHT : FOUR_INSTRUCTIONS_WEIGHT;
+  const beneficiary = getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress);
+  const destination = getDestinationChainLocation(destinationChainInfo);
+  const assetLocation = getAssetLocation(tokenInfo, value);
+  let method = 'limitedReserveTransferAssets';
+  if (['astar', 'shiden'].includes(originChainInfo.slug)) {
+    method = 'reserveWithdrawAssets';
+  } else if (_isSubstrateRelayChain(destinationChainInfo)) {
+    method = 'limitedTeleportAssets';
+  }
+  return api.tx.polkadotXcm[method](destination, beneficiary, assetLocation, 0,
+  // FeeAssetItem
+  weightParam);
+}

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

@@ -0,0 +1,16 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare const FOUR_INSTRUCTIONS_WEIGHT: {
+    Limited: number;
+};
+export declare const POLKADOT_LIMITED_WEIGHT = 1000000000;
+export declare const POLKADOT_UNLIMITED_WEIGHT = "Unlimited";
+export declare function getReceiverLocation(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, toAddress: string): Record<string, any>;
+export declare function getBeneficiary(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string): {
+    V1: {
+        parents: number;
+        interior: {
+            X1: Record<string, any>;
+        };
+    };
+};
+export declare const NETWORK_USE_UNLIMITED_WEIGHT: string[];

package/koni/api/xcm/utils.js

@@ -0,0 +1,52 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { _getChainSubstrateAddressPrefix, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { decodeAddress, evmToAddress } from '@polkadot/util-crypto';
+export const FOUR_INSTRUCTIONS_WEIGHT = {
+  Limited: 5000000000
+};
+export const POLKADOT_LIMITED_WEIGHT = 1000000000;
+export const POLKADOT_UNLIMITED_WEIGHT = 'Unlimited';
+
+// get multilocation for destination chain from a parachain
+
+export function getReceiverLocation(originChainInfo, destinationChainInfo, toAddress) {
+  // @ts-ignore
+  if (destinationChainInfo.slug === COMMON_CHAIN_SLUGS.ASTAR_EVM || destinationChainInfo.slug === 'astarEvm') {
+    const ss58Address = evmToAddress(toAddress, _getChainSubstrateAddressPrefix(destinationChainInfo));
+    return {
+      AccountId32: {
+        network: 'Any',
+        id: decodeAddress(ss58Address)
+      }
+    };
+  }
+  if (_isChainEvmCompatible(destinationChainInfo)) {
+    return {
+      AccountKey20: {
+        network: 'Any',
+        key: toAddress
+      }
+    };
+  }
+  return {
+    AccountId32: {
+      network: 'Any',
+      id: decodeAddress(toAddress)
+    }
+  };
+}
+export function getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress) {
+  const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, recipientAddress);
+  return {
+    V1: {
+      parents: 0,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  };
+}
+export const NETWORK_USE_UNLIMITED_WEIGHT = ['acala', 'karura', 'statemint', 'moonriver'];

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

@@ -0,0 +1,3 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ApiPromise } from '@polkadot/api';
+export declare function getExtrinsicByXtokensPallet(tokenInfo: _ChainAsset, originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string, value: string, api: ApiPromise): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>;

package/koni/api/xcm/xTokens.js

@@ -0,0 +1,55 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { FOUR_INSTRUCTIONS_WEIGHT, getReceiverLocation, NETWORK_USE_UNLIMITED_WEIGHT, POLKADOT_UNLIMITED_WEIGHT } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _XCM_TYPE } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getSubstrateParaId, _getXcmAssetId, _getXcmAssetMultilocation, _getXcmAssetType, _getXcmTransferType, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+function getCurrencyId(tokenInfo) {
+  var _tokenInfo$metadata2;
+  if (['acala', 'karura'].includes(tokenInfo.originChain) && _isNativeToken(tokenInfo)) {
+    return _getXcmAssetMultilocation(tokenInfo);
+  } else if (['moonbeam', 'moonbase', 'moonriver'].includes(tokenInfo.originChain)) {
+    const tokenType = _getXcmAssetType(tokenInfo);
+    const assetId = _getXcmAssetId(tokenInfo);
+    return {
+      [tokenType]: assetId
+    };
+  } else if (['pioneer'].includes(tokenInfo.originChain)) {
+    var _tokenInfo$metadata;
+    return (_tokenInfo$metadata = tokenInfo.metadata) === null || _tokenInfo$metadata === void 0 ? void 0 : _tokenInfo$metadata.multilocation;
+  }
+  return (_tokenInfo$metadata2 = tokenInfo.metadata) === null || _tokenInfo$metadata2 === void 0 ? void 0 : _tokenInfo$metadata2.onChainInfo;
+}
+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
+      }
+    }
+  };
+}
+export function getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? POLKADOT_UNLIMITED_WEIGHT : FOUR_INSTRUCTIONS_WEIGHT;
+  return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, recipientAddress), weightParam);
+}

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

@@ -0,0 +1,3 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ApiPromise } from '@polkadot/api';
+export declare function getExtrinsicByXcmPalletPallet(tokenInfo: _ChainAsset, originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string, value: string, api: ApiPromise): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>;

package/koni/api/xcm/xcmPallet.js

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

package/koni/background/cron.d.ts

@@ -0,0 +1,37 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ApiMap, ServiceInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { KoniSubscription } from '@subwallet/extension-base/koni/background/subscription';
+import { _ChainState, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { Subject } from 'rxjs';
+import KoniState from './handlers/State';
+export declare class KoniCron {
+    subscriptions: KoniSubscription;
+    status: 'pending' | 'running' | 'stopped';
+    private serviceSubscription;
+    dbService: DatabaseService;
+    private state;
+    private logger;
+    constructor(state: KoniState, subscriptions: KoniSubscription, dbService: DatabaseService);
+    private cronMap;
+    private subjectMap;
+    getCron: (name: string) => any;
+    getSubjectMap: (name: string) => any;
+    addCron: (name: string, callback: (param?: any) => void, interval: number, runFirst?: boolean) => void;
+    addSubscribeCron: <T>(name: string, callback: (subject: Subject<T>) => void, interval: number) => void;
+    removeCron: (name: string) => void;
+    removeAllCrons: () => void;
+    init: () => void;
+    start: () => void;
+    stop: () => void;
+    recoverApiMap: () => void;
+    refreshNft: (address: string, apiMap: ApiMap, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>) => () => void;
+    resetNft: (newAddress: string) => void;
+    resetStakingReward: () => void;
+    refreshStakingReward: (address: string) => () => void;
+    refreshStakingRewardFastInterval: (address: string) => () => void;
+    setStakingRewardReady: () => void;
+    checkNetworkAvailable: (serviceInfo: ServiceInfo) => boolean;
+    updateChainStakingMetadata: (chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>) => () => void;
+    updateNominatorMetadata: (address: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>) => () => void;
+}