@subwallet/extension-base 0.8.4-0 → 1.0.2-1

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/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createXcmExtrinsic = void 0;
+var _polkadotXcm = require("@subwallet/extension-base/koni/api/xcm/polkadotXcm");
+var _xcmPallet = require("@subwallet/extension-base/koni/api/xcm/xcmPallet");
+var _xTokens = require("@subwallet/extension-base/koni/api/xcm/xTokens");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const createXcmExtrinsic = async _ref => {
+  let {
+    chainInfoMap,
+    destinationTokenInfo,
+    originTokenInfo,
+    recipient,
+    sendingValue,
+    substrateApi
+  } = _ref;
+  const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+  const destinationChainInfo = chainInfoMap[destinationTokenInfo.originChain];
+  const chainApi = await substrateApi.isReady;
+  const api = chainApi.api;
+  let extrinsic;
+  if (_constants._XCM_CHAIN_GROUP.polkadotXcm.includes(originTokenInfo.originChain)) {
+    extrinsic = (0, _polkadotXcm.getExtrinsicByPolkadotXcmPallet)(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
+  } else if (_constants._XCM_CHAIN_GROUP.xcmPallet.includes(originTokenInfo.originChain)) {
+    extrinsic = (0, _xcmPallet.getExtrinsicByXcmPalletPallet)(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
+  } else {
+    extrinsic = (0, _xTokens.getExtrinsicByXtokensPallet)(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
+  }
+  console.log('XCM extrinsic: ', extrinsic.toHex());
+  return extrinsic;
+};
+exports.createXcmExtrinsic = createXcmExtrinsic;

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

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtrinsicByPolkadotXcmPallet = getExtrinsicByPolkadotXcmPallet;
+var _utils = require("@subwallet/extension-base/koni/api/xcm/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getDestinationChainLocation(destinationChainInfo) {
+  if ((0, _utils2._isSubstrateParaChain)(destinationChainInfo)) {
+    return {
+      V1: {
+        parents: 1,
+        interior: {
+          X1: {
+            Parachain: (0, _utils2._getSubstrateParaId)(destinationChainInfo)
+          }
+        }
+      }
+    };
+  }
+  return {
+    // to relaychain by default
+    V1: {
+      parents: 1,
+      interior: 'Here'
+    }
+  };
+}
+function getAssetLocation(tokenInfo, sendingValue) {
+  const multilocation = (0, _utils2._getXcmAssetMultilocation)(tokenInfo);
+  return {
+    V1: [{
+      id: multilocation,
+      fun: {
+        Fungible: sendingValue
+      }
+    }]
+  };
+}
+function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = _utils.NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
+  const beneficiary = (0, _utils.getBeneficiary)(originChainInfo, destinationChainInfo, recipientAddress);
+  const destination = getDestinationChainLocation(destinationChainInfo);
+  const assetLocation = getAssetLocation(tokenInfo, value);
+  let method = 'limitedReserveTransferAssets';
+  if (['astar', 'shiden'].includes(originChainInfo.slug)) {
+    method = 'limitedReserveWithdrawAssets';
+  } else if ((0, _utils2._isSubstrateRelayChain)(destinationChainInfo)) {
+    method = 'limitedTeleportAssets';
+  }
+  return api.tx.polkadotXcm[method](destination, beneficiary, assetLocation, 0,
+  // FeeAssetItem
+  weightParam);
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.POLKADOT_UNLIMITED_WEIGHT = exports.POLKADOT_LIMITED_WEIGHT = exports.NETWORK_USE_UNLIMITED_WEIGHT = exports.FOUR_INSTRUCTIONS_WEIGHT = void 0;
+exports.getBeneficiary = getBeneficiary;
+exports.getReceiverLocation = getReceiverLocation;
+var _chainList = require("@subwallet/chain-list");
+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 FOUR_INSTRUCTIONS_WEIGHT = {
+  Limited: 5000000000
+};
+exports.FOUR_INSTRUCTIONS_WEIGHT = FOUR_INSTRUCTIONS_WEIGHT;
+const POLKADOT_LIMITED_WEIGHT = 1000000000;
+exports.POLKADOT_LIMITED_WEIGHT = POLKADOT_LIMITED_WEIGHT;
+const POLKADOT_UNLIMITED_WEIGHT = 'Unlimited';
+
+// get multilocation for destination chain from a parachain
+exports.POLKADOT_UNLIMITED_WEIGHT = POLKADOT_UNLIMITED_WEIGHT;
+function getReceiverLocation(originChainInfo, destinationChainInfo, toAddress) {
+  // @ts-ignore
+  if (destinationChainInfo.slug === _chainList.COMMON_CHAIN_SLUGS.ASTAR_EVM || destinationChainInfo.slug === 'astarEvm') {
+    const ss58Address = (0, _utilCrypto.evmToAddress)(toAddress, (0, _utils._getChainSubstrateAddressPrefix)(destinationChainInfo));
+    return {
+      AccountId32: {
+        network: 'Any',
+        id: (0, _utilCrypto.decodeAddress)(ss58Address)
+      }
+    };
+  }
+  if ((0, _utils._isChainEvmCompatible)(destinationChainInfo)) {
+    return {
+      AccountKey20: {
+        network: 'Any',
+        key: toAddress
+      }
+    };
+  }
+  return {
+    AccountId32: {
+      network: 'Any',
+      id: (0, _utilCrypto.decodeAddress)(toAddress)
+    }
+  };
+}
+function getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress) {
+  const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, recipientAddress);
+  return {
+    V1: {
+      parents: 0,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  };
+}
+const NETWORK_USE_UNLIMITED_WEIGHT = ['acala', 'karura', 'statemint', 'moonriver'];
+exports.NETWORK_USE_UNLIMITED_WEIGHT = NETWORK_USE_UNLIMITED_WEIGHT;

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

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtrinsicByXtokensPallet = getExtrinsicByXtokensPallet;
+var _utils = require("@subwallet/extension-base/koni/api/xcm/utils");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getCurrencyId(tokenInfo) {
+  if (['acala', 'karura'].includes(tokenInfo.originChain) && (0, _utils2._isNativeToken)(tokenInfo)) {
+    return (0, _utils2._getXcmAssetMultilocation)(tokenInfo);
+  } else if (['moonbeam', 'moonbase', 'moonriver'].includes(tokenInfo.originChain)) {
+    const tokenType = (0, _utils2._getXcmAssetType)(tokenInfo);
+    const assetId = (0, _utils2._getXcmAssetId)(tokenInfo);
+    return {
+      [tokenType]: assetId
+    };
+  } else if (['pioneer'].includes(tokenInfo.originChain)) {
+    return (0, _utils2._getXcmAssetMultilocation)(tokenInfo);
+  }
+  return (0, _utils2._getTokenOnChainInfo)(tokenInfo);
+}
+function getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, toAddress) {
+  const xcmType = (0, _utils2._getXcmTransferType)(originChainInfo, destinationChainInfo);
+  const paraId = (0, _utils2._getSubstrateParaId)(destinationChainInfo);
+  const receiverLocation = (0, _utils.getReceiverLocation)(originChainInfo, destinationChainInfo, toAddress);
+  if (xcmType === _constants._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
+      }
+    }
+  };
+}
+function getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = _utils.NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
+  return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, recipientAddress), weightParam);
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtrinsicByXcmPalletPallet = getExtrinsicByXcmPalletPallet;
+var _utils = require("@subwallet/extension-base/koni/api/xcm/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getDestinationChainLocation(destinationChainInfo) {
+  return {
+    V1: {
+      parents: 0,
+      interior: {
+        X1: {
+          Parachain: (0, _utils2._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
+function getExtrinsicByXcmPalletPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = _utils.NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
+  const destination = getDestinationChainLocation(destinationChainInfo);
+  const beneficiary = (0, _utils.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);
+}