@maxion-platform/ronin-market-sdk 1.0.0

package/dist/cjs/services/order/getOrdersTotalPrice.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var ethers = require('ethers');
+var lodash = require('lodash');
+var index = require('../../contracts/index.js');
+var configs = require('../tokens/configs.js');
+var data = require('../tokens/data.js');
+
+const getOrdersTotalPrice = async (params) => {
+    const { data: data$1, chainId, wallet, token } = params;
+    const { provider } = wallet;
+    const { address } = token || data.paymentTokens?.[chainId].RON;
+    const katanaContract = index.createKatanaContract(chainId, provider);
+    const ordersNeedToSwap = data$1.filter(orderData => orderData.order.paymentToken !== address);
+    const ordersDontNeedToSwap = data$1.filter(orderData => orderData.order.paymentToken === address);
+    const totalPriceOfEachOrder = {};
+    let totalPrice = ordersDontNeedToSwap.reduce((total, { quantity, order }) => {
+        const { currentPrice, hash } = order;
+        const orderTotalPrice = ethers.BigNumber.from(currentPrice).mul(quantity);
+        totalPriceOfEachOrder[hash] = orderTotalPrice.toString();
+        return total.add(orderTotalPrice);
+    }, ethers.BigNumber.from(0));
+    const ordersNeedToSwapAmounts = ordersNeedToSwap.map(({ quantity, order }) => {
+        const { paymentToken, currentPrice } = order;
+        const swapConfig = configs.getSwapConfig(chainId, paymentToken);
+        const path = swapConfig[address].path;
+        const orderTotalPrice = ethers.BigNumber.from(currentPrice).mul(quantity);
+        return { amount: orderTotalPrice.toString(), path };
+    });
+    if (!lodash.isEmpty(ordersNeedToSwap)) {
+        const swappedValues = await katanaContract.getAmountsInMultiCall(ordersNeedToSwapAmounts, chainId);
+        const totalSwappedValues = ordersNeedToSwap.reduce((total, { order }, currentIndex) => {
+            const { hash } = order;
+            const price = swappedValues[currentIndex];
+            totalPriceOfEachOrder[hash] = price.toString();
+            return total.add(price);
+        }, ethers.BigNumber.from(0));
+        totalPrice = totalPrice.add(totalSwappedValues);
+    }
+    return {
+        totalPrice: totalPrice.toString(),
+        totalPriceOfEachOrder,
+    };
+};
+
+exports.getOrdersTotalPrice = getOrdersTotalPrice;

package/dist/cjs/services/order/getSwapTokenData.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var utils = require('ethers/lib/utils');
+var index = require('../../contracts/index.js');
+require('../../configs/index.js');
+require('../tokens/data.js');
+var getPaymentTokens = require('../tokens/getPaymentTokens.js');
+var configs = require('../tokens/configs.js');
+require('lodash');
+require('ethers');
+
+const getLiquidityProviderFeePercent = (chainId, inputTokenAddress, outputTokenAddress) => {
+    const swapConfig = configs.getSwapConfig(chainId, outputTokenAddress)[inputTokenAddress];
+    return swapConfig?.lpFeePercent;
+};
+const getPriceImpactPercent = async (chainId, inputTokenAddress, outputTokenAddress, fiatValueIn, fiatValueOut) => {
+    const liquidityProviderPercent = getLiquidityProviderFeePercent(chainId, inputTokenAddress, outputTokenAddress);
+    return (1 - fiatValueIn / fiatValueOut) * 100 - liquidityProviderPercent;
+};
+const getLiquidityProviderFee = (chainId, inputTokenAddress, outputTokenAddress, amountIn) => {
+    const inputTokenData = getPaymentTokens.getPaymentToken(chainId, inputTokenAddress);
+    const formattedAmountIn = utils.formatUnits(amountIn, inputTokenData?.decimals);
+    const liquidityProviderPercent = getLiquidityProviderFeePercent(chainId, inputTokenAddress, outputTokenAddress);
+    return {
+        value: (Number(formattedAmountIn) * liquidityProviderPercent) / 100,
+        symbol: inputTokenData?.symbol,
+    };
+};
+const getSwappedAmount = async (chainId, inputTokenAddress, outputTokenAddress, amount) => {
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const katanaContract = index.createKatanaContract(chainId);
+    const swapConfig = configs.getSwapConfig(chainId, outputTokenAddress);
+    const path = swapConfig[inputTokenAddress]?.path;
+    const response = await katanaContract.connect(readProvider).getAmountsIn(amount, path);
+    return response?.[0];
+};
+
+exports.getLiquidityProviderFee = getLiquidityProviderFee;
+exports.getLiquidityProviderFeePercent = getLiquidityProviderFeePercent;
+exports.getPriceImpactPercent = getPriceImpactPercent;
+exports.getSwappedAmount = getSwappedAmount;

package/dist/cjs/services/order/settleOrder.js

@@ -0,0 +1,141 @@
+'use strict';
+
+var constants = require('../../common/constants.js');
+require('ethers');
+require('../../configs/index.js');
+require('../tokens/data.js');
+var factory = require('../../contracts/market-gateway/factory.js');
+require('../../types/index.js');
+var generateOrderData = require('./generateOrderData.js');
+var getSwapTokenData = require('./getSwapTokenData.js');
+
+const getSettlePrice = async (chainId, selectedTokenAddress, listingTokenAddress, amount) => {
+    const isBuyingWithListingToken = selectedTokenAddress.toLowerCase() === listingTokenAddress.toLowerCase();
+    if (isBuyingWithListingToken) {
+        return amount;
+    }
+    const swappedAmount = await getSwapTokenData.getSwappedAmount(chainId, selectedTokenAddress, listingTokenAddress, amount);
+    return swappedAmount
+        ?.mul(100 + constants.SWAP_DEFAULT_SLIPPAGE)
+        .div(100)
+        .toString();
+};
+// Erc721
+const settleErc721Order = (chainId, wallet, order, settlePrice, referralAddr, recipient, options) => {
+    const { provider, account } = wallet;
+    const { signature, expectedState } = order;
+    const marketGatewayContract = factory.createMarketGatewayContract(chainId, provider);
+    const erc721Order = generateOrderData.generateErc721Order(order);
+    return marketGatewayContract.settleOrder({
+        expectedState,
+        settlePrice,
+        account,
+        signature,
+        chainId,
+        referralAddr,
+        recipient,
+        order: erc721Order,
+        options,
+    });
+};
+const swapTokensAndSettleErc721Order = (chainId, wallet, order, settlePrice, tokenPaths, deadline, referralAddr, recipient, options) => {
+    const { provider, account } = wallet;
+    const marketGatewayContract = factory.createMarketGatewayContract(chainId, provider);
+    const erc721Order = generateOrderData.generateErc721Order(order);
+    const { signature, expectedState } = order;
+    return marketGatewayContract.swapTokensAndSettleOrder({
+        expectedState,
+        settlePrice,
+        path: tokenPaths,
+        signature,
+        account,
+        referralAddr,
+        recipient,
+        deadline,
+        order: erc721Order,
+        options,
+    });
+};
+const swapRONAndSettleErc721Order = (chainId, wallet, order, settlePrice, tokenPaths, deadline, referralAddr, recipient, options) => {
+    const { provider, account } = wallet;
+    const marketGatewayContract = factory.createMarketGatewayContract(chainId, provider);
+    const erc721Order = generateOrderData.generateErc721Order(order);
+    const { signature, expectedState } = order;
+    return marketGatewayContract.swapRONAndSettleOrder({
+        expectedState,
+        settlePrice,
+        referralAddr,
+        recipient,
+        path: tokenPaths,
+        signature,
+        account,
+        deadline,
+        order: erc721Order,
+        options,
+    });
+};
+// Erc1155
+const settleErc1155Order = (chainId, wallet, order, settlePrice, quantity, referralAddr, recipient, options) => {
+    const { provider, account } = wallet;
+    const erc1155MarketGatewayContract = factory.createErc1155MarketGatewayContract(chainId, provider);
+    const erc1155Order = generateOrderData.generateErc1155Order(order);
+    const { signature, expectedState } = order;
+    return erc1155MarketGatewayContract.settleErc1155Order({
+        expectedState,
+        settlePrice,
+        account,
+        signature,
+        chainId,
+        referralAddr,
+        recipient,
+        quantity,
+        order: erc1155Order,
+        options,
+    });
+};
+const swapTokensAndSettleErc1155Order = (chainId, wallet, order, settlePrice, tokenPaths, quantity, deadline, referralAddr, recipient, options) => {
+    const { provider, account } = wallet;
+    const erc1155MarketGatewayContract = factory.createErc1155MarketGatewayContract(chainId, provider);
+    const erc1155Order = generateOrderData.generateErc1155Order(order);
+    const { signature, expectedState } = order;
+    return erc1155MarketGatewayContract.swapTokensAndSettleErc1155Order({
+        expectedState,
+        settlePrice,
+        path: tokenPaths,
+        signature,
+        account,
+        referralAddr,
+        recipient,
+        deadline,
+        quantity,
+        order: erc1155Order,
+        options,
+    });
+};
+const swapRONAndSettleErc1155Order = (chainId, wallet, order, settlePrice, tokenPaths, quantity, deadline, referralAddr, recipient, options) => {
+    const { provider, account } = wallet;
+    const erc1155MarketGatewayContract = factory.createErc1155MarketGatewayContract(chainId, provider);
+    const erc1155Order = generateOrderData.generateErc1155Order(order);
+    const { signature, expectedState } = order;
+    return erc1155MarketGatewayContract.swapRONAndSettleErc1155Order({
+        expectedState,
+        settlePrice,
+        referralAddr,
+        path: tokenPaths,
+        signature,
+        account,
+        recipient,
+        deadline,
+        quantity,
+        order: erc1155Order,
+        options,
+    });
+};
+
+exports.getSettlePrice = getSettlePrice;
+exports.settleErc1155Order = settleErc1155Order;
+exports.settleErc721Order = settleErc721Order;
+exports.swapRONAndSettleErc1155Order = swapRONAndSettleErc1155Order;
+exports.swapRONAndSettleErc721Order = swapRONAndSettleErc721Order;
+exports.swapTokensAndSettleErc1155Order = swapTokensAndSettleErc1155Order;
+exports.swapTokensAndSettleErc721Order = swapTokensAndSettleErc721Order;

package/dist/cjs/services/tokens/checkIsTokenApproved.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var index$1 = require('../../configs/index.js');
+var index = require('../../contracts/index.js');
+var data = require('./data.js');
+var getPaymentTokens = require('./getPaymentTokens.js');
+
+const checkIsErc721Approved = (chainId, account, address) => {
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const config = index$1.getConfig(chainId);
+    const erc721Contract = index.createErc721Contract(address);
+    const marketGatewayContractAddress = config.contractsAddress.marketGateway;
+    return erc721Contract.connect(readProvider).isApprovedForAll(account, marketGatewayContractAddress);
+};
+const checkIsErc1155Approved = (chainId, account, address) => {
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const config = index$1.getConfig(chainId);
+    const erc1155Contract = index.createErc1155Contract(address);
+    const marketGatewayContractAddress = config.contractsAddress.marketGateway;
+    return erc1155Contract.connect(readProvider).isApprovedForAll(account, marketGatewayContractAddress);
+};
+const checkIsErc20Approved = async (chainId, account, address, amount, spenderAddress) => {
+    const config = index$1.getConfig(chainId);
+    const spender = spenderAddress || config.contractsAddress.marketGateway;
+    const tokens = getPaymentTokens.getPaymentTokens(chainId);
+    const isRon = tokens[data.Token.RON].address.toLowerCase() === address.toLowerCase();
+    if (isRon) {
+        return true;
+    }
+    const erc20Contract = index.createErc20Contract(address);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const response = await erc20Contract.connect(readProvider).allowance(account, spender);
+    return response.gte(amount);
+};
+const checkIsWRonTokenApproved = async (chainId, account, amount) => {
+    const config = index$1.getConfig(chainId);
+    const marketGatewayContractAddress = config.contractsAddress.marketGateway;
+    const wRonContract = index.createWRonContract(chainId);
+    const readProvider = index.createReadOnlyProvider(chainId);
+    const response = await wRonContract.connect(readProvider).allowance(account, marketGatewayContractAddress);
+    return response.gte(amount);
+};
+
+exports.checkIsErc1155Approved = checkIsErc1155Approved;
+exports.checkIsErc20Approved = checkIsErc20Approved;
+exports.checkIsErc721Approved = checkIsErc721Approved;
+exports.checkIsWRonTokenApproved = checkIsWRonTokenApproved;

package/dist/cjs/services/tokens/configs.js

@@ -0,0 +1,163 @@
+'use strict';
+
+var getPaymentTokens = require('./getPaymentTokens.js');
+
+const getSwapToRonConfig = (tokens) => {
+    return {
+        [tokens.AXS.address]: {
+            route: [tokens.AXS.symbol, tokens.RON.symbol].join(' > '),
+            path: [tokens.AXS.address, tokens.RON.address],
+            tokens: [tokens.AXS, tokens.RON],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+        [tokens.SLP.address]: {
+            route: [tokens.SLP.symbol, tokens.RON.symbol].join(' > '),
+            path: [tokens.SLP.address, tokens.RON.address],
+            tokens: [tokens.SLP, tokens.RON],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+        [tokens.USDC.address]: {
+            route: [tokens.USDC.symbol, tokens.RON.symbol].join(' > '),
+            path: [tokens.USDC.address, tokens.RON.address],
+            tokens: [tokens.USDC, tokens.RON],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+        [tokens.WETH.address]: {
+            route: [tokens.WETH.symbol, tokens.RON.symbol].join(' > '),
+            path: [tokens.WETH.address, tokens.RON.address],
+            tokens: [tokens.WETH, tokens.RON],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+        [tokens.ION.address]: {
+            route: [tokens.ION.symbol, tokens.USDC.symbol, tokens.RON.symbol].join(' > '),
+            path: [tokens.ION.address, tokens.USDC.address, tokens.RON.address],
+            tokens: [tokens.ION, tokens.USDC, tokens.RON],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+    };
+};
+const getSwapToUsdcConfig = (tokens) => {
+    return {
+        [tokens.AXS.address]: {
+            route: [tokens.AXS.symbol, tokens.RON.symbol, tokens.USDC.symbol].join(' > '),
+            path: [tokens.AXS.address, tokens.RON.address, tokens.USDC.address],
+            tokens: [tokens.AXS, tokens.RON, tokens.USDC],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.SLP.address]: {
+            route: [tokens.SLP.symbol, tokens.RON.symbol, tokens.USDC.symbol].join(' > '),
+            path: [tokens.SLP.address, tokens.RON.address, tokens.USDC.address],
+            tokens: [tokens.SLP, tokens.RON, tokens.USDC],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.RON.address]: {
+            route: [tokens.RON.symbol, tokens.USDC.symbol].join(' > '),
+            path: [tokens.RON.address, tokens.USDC.address],
+            tokens: [tokens.RON, tokens.USDC],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+        [tokens.WETH.address]: {
+            route: [tokens.WETH.symbol, tokens.RON.symbol, tokens.USDC.symbol].join(' > '),
+            path: [tokens.WETH.address, tokens.RON.address, tokens.USDC.address],
+            tokens: [tokens.WETH, tokens.RON, tokens.USDC],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.ION.address]: {
+            route: [tokens.ION.symbol, tokens.USDC.symbol].join(' > '),
+            path: [tokens.ION.address, tokens.USDC.address],
+            tokens: [tokens.ION, tokens.USDC],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+    };
+};
+const getSwapToWethConfig = (tokens) => {
+    return {
+        [tokens.AXS.address]: {
+            route: [tokens.AXS.symbol, tokens.RON.symbol, tokens.WETH.symbol].join(' > '),
+            path: [tokens.AXS.address, tokens.RON.address, tokens.WETH.address],
+            tokens: [tokens.AXS, tokens.RON, tokens.WETH],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.SLP.address]: {
+            route: [tokens.SLP.symbol, tokens.RON.symbol, tokens.WETH.symbol].join(' > '),
+            path: [tokens.SLP.address, tokens.RON.address, tokens.WETH.address],
+            tokens: [tokens.SLP, tokens.RON, tokens.WETH],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.RON.address]: {
+            route: [tokens.RON.symbol, tokens.WETH.symbol].join(' > '),
+            path: [tokens.RON.address, tokens.WETH.address],
+            tokens: [tokens.RON, tokens.WETH],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+        [tokens.USDC.address]: {
+            route: [tokens.USDC.symbol, tokens.RON.symbol, tokens.WETH.symbol].join(' > '),
+            path: [tokens.USDC.address, tokens.RON.address, tokens.WETH.address],
+            tokens: [tokens.USDC, tokens.RON, tokens.WETH],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.ION.address]: {
+            route: [tokens.ION.symbol, tokens.USDC.symbol, tokens.WETH.symbol].join(' > '),
+            path: [tokens.ION.address, tokens.USDC.address, tokens.WETH.address],
+            tokens: [tokens.ION, tokens.USDC, tokens.WETH],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+    };
+};
+const getSwapToIonConfig = (tokens) => {
+    return {
+        [tokens.AXS.address]: {
+            route: [tokens.AXS.symbol, tokens.USDC.symbol, tokens.ION.symbol].join(' > '),
+            path: [tokens.AXS.address, tokens.USDC.address, tokens.ION.address],
+            tokens: [tokens.AXS, tokens.USDC, tokens.ION],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.SLP.address]: {
+            route: [tokens.SLP.symbol, tokens.USDC.symbol, tokens.ION.symbol].join(' > '),
+            path: [tokens.SLP.address, tokens.USDC.address, tokens.ION.address],
+            tokens: [tokens.SLP, tokens.USDC, tokens.ION],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.RON.address]: {
+            route: [tokens.RON.symbol, tokens.USDC.symbol, tokens.ION.symbol].join(' > '),
+            path: [tokens.RON.address, tokens.USDC.address, tokens.ION.address],
+            tokens: [tokens.RON, tokens.USDC, tokens.ION],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.WETH.address]: {
+            route: [tokens.WETH.symbol, tokens.USDC.symbol, tokens.ION.symbol].join(' > '),
+            path: [tokens.WETH.address, tokens.USDC.address, tokens.ION.address],
+            tokens: [tokens.WETH, tokens.USDC, tokens.ION],
+            lpFeePercent: 1 - (1 - 0.3) * (1 - 0.3),
+        },
+        [tokens.USDC.address]: {
+            route: [tokens.USDC.symbol, tokens.ION.symbol].join(' > '),
+            path: [tokens.USDC.address, tokens.ION.address],
+            tokens: [tokens.USDC, tokens.ION],
+            lpFeePercent: 1 - (1 - 0.3),
+        },
+    };
+};
+const getSwapConfig = (chainId, toToken) => {
+    const tokens = getPaymentTokens.getPaymentTokens(chainId);
+    const validTokens = [tokens.USDC.address, tokens.WETH.address, tokens.RON.address, tokens.ION.address];
+    if (!validTokens.includes(toToken)) {
+        throw new Error('Token must be USDC, ION, WETH or RON');
+    }
+    switch (toToken) {
+        case tokens.USDC.address:
+            return getSwapToUsdcConfig(tokens);
+        case tokens.WETH.address:
+            return getSwapToWethConfig(tokens);
+        case tokens.ION.address:
+            return getSwapToIonConfig(tokens);
+        default:
+            return getSwapToRonConfig(tokens);
+    }
+};
+
+exports.getSwapConfig = getSwapConfig;
+exports.getSwapToIonConfig = getSwapToIonConfig;
+exports.getSwapToRonConfig = getSwapToRonConfig;
+exports.getSwapToUsdcConfig = getSwapToUsdcConfig;
+exports.getSwapToWethConfig = getSwapToWethConfig;

package/dist/cjs/services/tokens/data.js

@@ -0,0 +1,150 @@
+'use strict';
+
+var index = require('../../types/index.js');
+
+exports.Token = void 0;
+(function (Token) {
+    Token["RON"] = "RON";
+    Token["WETH"] = "WETH";
+    Token["AXS"] = "AXS";
+    Token["SLP"] = "SLP";
+    Token["USDC"] = "USDC";
+    Token["ION"] = "ION";
+})(exports.Token || (exports.Token = {}));
+const paymentTokens = {
+    [index.ChainId.testnet]: {
+        [exports.Token.RON]: {
+            chainId: 202601,
+            address: '0xa959726154953bae111746e265e6d754f48570e6',
+            decimals: 18,
+            symbol: 'RON',
+            name: 'Ronin',
+            unit: 'ether',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2021/ron/logo-transparent.png',
+        },
+        [exports.Token.WETH]: {
+            chainId: 202601,
+            address: '0x29c6f8349a028e1bdfc68bfa08bdee7bc5d47e16',
+            decimals: 18,
+            symbol: 'WETH',
+            name: 'Ronin Wrapped Ethereum',
+            unit: 'ether',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2021/erc20/0x29c6f8349a028e1bdfc68bfa08bdee7bc5d47e16/logo-transparent.png',
+        },
+        [exports.Token.AXS]: {
+            chainId: 202601,
+            address: '0x3c4e17b9056272ce1b49f6900d8cfd6171a1869d',
+            decimals: 18,
+            symbol: 'AXS',
+            name: 'Axie Infinity Shard',
+            unit: 'ether',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2021/erc20/0x3c4e17b9056272ce1b49f6900d8cfd6171a1869d/logo-transparent.png',
+        },
+        [exports.Token.SLP]: {
+            chainId: 202601,
+            address: '0x82f5483623d636bc3deba8ae67e1751b6cf2bad2',
+            decimals: 0,
+            symbol: 'SLP',
+            name: 'Smooth Love Potion',
+            unit: 'wei',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2021/erc20/0x82f5483623d636bc3deba8ae67e1751b6cf2bad2/logo-transparent.png',
+        },
+        [exports.Token.USDC]: {
+            chainId: 202601,
+            address: '0x067fbff8990c58ab90bae3c97241c5d736053f77',
+            decimals: 6,
+            symbol: 'USDC',
+            name: 'USDC',
+            unit: 'mwei',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2021/erc20/0x067fbff8990c58ab90bae3c97241c5d736053f77/logo-transparent.png',
+        },
+        [exports.Token.ION]: {
+            chainId: 202601,
+            address: '0xcC5da0dA34dE144d4a3766F4Dd15C727E75B6116',
+            decimals: 6,
+            symbol: 'ION',
+            name: 'ION',
+            unit: 'mwei',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2020/erc20/0x44f4ee8df6333f655e5486a400b2f93b220f6ee1/logo-transparent.png',
+        },
+    },
+    [index.ChainId.mainnet]: {
+        [exports.Token.RON]: {
+            chainId: 2020,
+            address: '0xe514d9deb7966c8be0ca922de8a064264ea6bcd4',
+            decimals: 18,
+            symbol: 'RON',
+            name: 'Ronin',
+            unit: 'ether',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2020/ron/logo-transparent.png',
+        },
+        [exports.Token.WETH]: {
+            chainId: 2020,
+            address: '0xc99a6a985ed2cac1ef41640596c5a5f9f4e19ef5',
+            decimals: 18,
+            symbol: 'WETH',
+            name: 'Ronin Wrapped Ethereum',
+            unit: 'ether',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2020/erc20/0xc99a6a985ed2cac1ef41640596c5a5f9f4e19ef5/logo-transparent.png',
+        },
+        [exports.Token.AXS]: {
+            chainId: 2020,
+            address: '0x97a9107c1793bc407d6f527b77e7fff4d812bece',
+            decimals: 18,
+            symbol: 'AXS',
+            name: 'Axie Infinity Shard',
+            unit: 'ether',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2020/erc20/0x97a9107c1793bc407d6f527b77e7fff4d812bece/logo-transparent.png',
+        },
+        [exports.Token.SLP]: {
+            chainId: 2020,
+            address: '0xa8754b9fa15fc18bb59458815510e40a12cd2014',
+            decimals: 0,
+            symbol: 'SLP',
+            name: 'Smooth Love Potion',
+            unit: 'wei',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2020/erc20/0xa8754b9fa15fc18bb59458815510e40a12cd2014/logo-transparent.png',
+        },
+        [exports.Token.USDC]: {
+            chainId: 2020,
+            address: '0x0b7007c13325c48911f73a2dad5fa5dcbf808adc',
+            decimals: 6,
+            symbol: 'USDC',
+            name: 'USD//C',
+            unit: 'mwei',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2020/erc20/0x0b7007c13325c48911f73a2dad5fa5dcbf808adc/logo-transparent.png',
+        },
+        [exports.Token.ION]: {
+            chainId: 2020,
+            address: '0x44f4ee8df6333f655e5486a400b2f93b220f6ee1',
+            decimals: 6,
+            symbol: 'ION',
+            name: 'ION',
+            unit: 'mwei',
+            imageUrl: 'https://cdn.skymavis.com/ronin/2020/erc20/0x44f4ee8df6333f655e5486a400b2f93b220f6ee1/logo-transparent.png',
+        },
+    },
+};
+const wRonToken = {
+    [index.ChainId.testnet]: {
+        chainId: 202601,
+        address: '0xa959726154953bae111746e265e6d754f48570e6',
+        decimals: 18,
+        symbol: 'WRON',
+        name: 'Wrapped Ronin',
+        unit: 'ether',
+        imageUrl: 'https://cdn.skymavis.com/ronin/2021/erc20/0xa959726154953bae111746e265e6d754f48570e6/logo-transparent.png',
+    },
+    [index.ChainId.mainnet]: {
+        chainId: 2020,
+        address: '0xe514d9deb7966c8be0ca922de8a064264ea6bcd4',
+        decimals: 18,
+        symbol: 'WRON',
+        name: 'Wrapped Ronin',
+        unit: 'ether',
+        imageUrl: 'https://cdn.skymavis.com/ronin/2020/erc20/0xe514d9deb7966c8be0ca922de8a064264ea6bcd4/logo-transparent.png',
+    },
+};
+
+exports.paymentTokens = paymentTokens;
+exports.wRonToken = wRonToken;

package/dist/cjs/services/tokens/getPaymentTokens.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var data = require('./data.js');
+
+const getPaymentTokens = (chainId) => {
+    return data.paymentTokens[chainId];
+};
+const getPaymentToken = (chainId, tokenAddress) => {
+    const tokens = getPaymentTokens(chainId);
+    return Object.entries(tokens).find(([, value]) => value.address.toLowerCase() === tokenAddress.toLowerCase())?.[1];
+};
+
+exports.getPaymentToken = getPaymentToken;
+exports.getPaymentTokens = getPaymentTokens;

package/dist/cjs/services/tokens/getTokensNeedToApprove.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var checkIsTokenApproved = require('./checkIsTokenApproved.js');
+var configs = require('./configs.js');
+var getPaymentTokens = require('./getPaymentTokens.js');
+
+const getTokensNeedToApprove = async (chainId, account, inputTokenAddress, outputTokenAddress, amount, spenderAddress) => {
+    if (inputTokenAddress.toLowerCase() === outputTokenAddress.toLowerCase()) {
+        const isAllowed = await checkIsTokenApproved.checkIsErc20Approved(chainId, account, inputTokenAddress, amount, spenderAddress);
+        const paymentToken = getPaymentTokens.getPaymentToken(chainId, inputTokenAddress);
+        return isAllowed ? [] : [paymentToken];
+    }
+    const swapConfig = configs.getSwapConfig(chainId, outputTokenAddress);
+    const tokens = swapConfig[inputTokenAddress]?.tokens || [];
+    const tokensNeedToApprove = await tokens.reduce(async (results, currentToken) => {
+        const isAllowed = await checkIsTokenApproved.checkIsErc20Approved(chainId, account, currentToken.address, amount, spenderAddress);
+        const tokensData = await results;
+        if (!isAllowed) {
+            return [...tokensData, currentToken];
+        }
+        return results;
+    }, Promise.resolve([]));
+    return tokensNeedToApprove;
+};
+
+exports.getTokensNeedToApprove = getTokensNeedToApprove;

package/dist/cjs/services/tokens/getTokensNeedToApproveByOrders.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var lodash = require('lodash');
+var getOrdersTotalPrice = require('../order/getOrdersTotalPrice.js');
+var getPaymentTokens = require('./getPaymentTokens.js');
+var getTokensNeedToApprove = require('./getTokensNeedToApprove.js');
+
+const getTokensNeedToApproveByOrders = async (chainId, wallet, bulkBuyOrderData, inputPaymentToken, spenderAddress) => {
+    const { account } = wallet;
+    let allTokensNeedToApprove = [];
+    const checkedTokens = {};
+    const paymentTokenData = getPaymentTokens.getPaymentToken(chainId, inputPaymentToken);
+    const { totalPrice } = await getOrdersTotalPrice.getOrdersTotalPrice({
+        data: bulkBuyOrderData,
+        token: paymentTokenData,
+        chainId,
+        wallet,
+    });
+    for (const data of bulkBuyOrderData) {
+        const { order } = data;
+        const { paymentToken } = order;
+        if (!checkedTokens[paymentToken]) {
+            checkedTokens[paymentToken] = true;
+            const tokensNeedToApprove = await getTokensNeedToApprove.getTokensNeedToApprove(chainId, account, inputPaymentToken, paymentToken, totalPrice, spenderAddress);
+            allTokensNeedToApprove = [...allTokensNeedToApprove, ...tokensNeedToApprove];
+        }
+    }
+    return lodash.unionBy(allTokensNeedToApprove, 'address');
+};
+
+exports.getTokensNeedToApproveByOrders = getTokensNeedToApproveByOrders;