@maxion-platform/ronin-market-sdk 1.0.0

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

@@ -0,0 +1,122 @@
+import {SWAP_DEFAULT_SLIPPAGE}from'../../common/constants.js';import'ethers';import'../../configs/index.js';import'../tokens/data.js';import {createMarketGatewayContract,createErc1155MarketGatewayContract}from'../../contracts/market-gateway/factory.js';import'../../types/index.js';import {generateErc721Order,generateErc1155Order}from'./generateOrderData.js';import {getSwappedAmount}from'./getSwapTokenData.js';const getSettlePrice = async (chainId, selectedTokenAddress, listingTokenAddress, amount) => {
+    const isBuyingWithListingToken = selectedTokenAddress.toLowerCase() === listingTokenAddress.toLowerCase();
+    if (isBuyingWithListingToken) {
+        return amount;
+    }
+    const swappedAmount = await getSwappedAmount(chainId, selectedTokenAddress, listingTokenAddress, amount);
+    return swappedAmount
+        ?.mul(100 + 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 = createMarketGatewayContract(chainId, provider);
+    const erc721Order = 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 = createMarketGatewayContract(chainId, provider);
+    const erc721Order = 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 = createMarketGatewayContract(chainId, provider);
+    const erc721Order = 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 = createErc1155MarketGatewayContract(chainId, provider);
+    const erc1155Order = 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 = createErc1155MarketGatewayContract(chainId, provider);
+    const erc1155Order = 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 = createErc1155MarketGatewayContract(chainId, provider);
+    const erc1155Order = generateErc1155Order(order);
+    const { signature, expectedState } = order;
+    return erc1155MarketGatewayContract.swapRONAndSettleErc1155Order({
+        expectedState,
+        settlePrice,
+        referralAddr,
+        path: tokenPaths,
+        signature,
+        account,
+        recipient,
+        deadline,
+        quantity,
+        order: erc1155Order,
+        options,
+    });
+};export{getSettlePrice,settleErc1155Order,settleErc721Order,swapRONAndSettleErc1155Order,swapRONAndSettleErc721Order,swapTokensAndSettleErc1155Order,swapTokensAndSettleErc721Order};

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

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

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

@@ -0,0 +1,153 @@
+import {getPaymentTokens}from'./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(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);
+    }
+};export{getSwapConfig,getSwapToIonConfig,getSwapToRonConfig,getSwapToUsdcConfig,getSwapToWethConfig};

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

@@ -0,0 +1,143 @@
+import {ChainId}from'../../types/index.js';var Token;
+(function (Token) {
+    Token["RON"] = "RON";
+    Token["WETH"] = "WETH";
+    Token["AXS"] = "AXS";
+    Token["SLP"] = "SLP";
+    Token["USDC"] = "USDC";
+    Token["ION"] = "ION";
+})(Token || (Token = {}));
+const paymentTokens = {
+    [ChainId.testnet]: {
+        [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',
+        },
+        [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',
+        },
+        [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',
+        },
+        [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',
+        },
+        [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',
+        },
+        [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',
+        },
+    },
+    [ChainId.mainnet]: {
+        [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',
+        },
+        [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',
+        },
+        [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',
+        },
+        [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',
+        },
+        [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',
+        },
+        [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 = {
+    [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',
+    },
+    [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',
+    },
+};export{Token,paymentTokens,wRonToken};

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

@@ -0,0 +1,7 @@
+import {paymentTokens}from'./data.js';const getPaymentTokens = (chainId) => {
+    return paymentTokens[chainId];
+};
+const getPaymentToken = (chainId, tokenAddress) => {
+    const tokens = getPaymentTokens(chainId);
+    return Object.entries(tokens).find(([, value]) => value.address.toLowerCase() === tokenAddress.toLowerCase())?.[1];
+};export{getPaymentToken,getPaymentTokens};

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

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

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

@@ -0,0 +1,22 @@
+import {unionBy}from'lodash';import {getOrdersTotalPrice}from'../order/getOrdersTotalPrice.js';import {getPaymentToken}from'./getPaymentTokens.js';import {getTokensNeedToApprove}from'./getTokensNeedToApprove.js';const getTokensNeedToApproveByOrders = async (chainId, wallet, bulkBuyOrderData, inputPaymentToken, spenderAddress) => {
+    const { account } = wallet;
+    let allTokensNeedToApprove = [];
+    const checkedTokens = {};
+    const paymentTokenData = getPaymentToken(chainId, inputPaymentToken);
+    const { totalPrice } = await 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(chainId, account, inputPaymentToken, paymentToken, totalPrice, spenderAddress);
+            allTokensNeedToApprove = [...allTokensNeedToApprove, ...tokensNeedToApprove];
+        }
+    }
+    return unionBy(allTokensNeedToApprove, 'address');
+};export{getTokensNeedToApproveByOrders};

package/dist/mjs/types/index.js

@@ -0,0 +1,10 @@
+export{ErcAssetItem,OrderKind}from'./order.js';var ChainId;
+(function (ChainId) {
+    ChainId[ChainId["mainnet"] = 2020] = "mainnet";
+    ChainId[ChainId["testnet"] = 202601] = "testnet";
+})(ChainId || (ChainId = {}));
+var SpenderContractType;
+(function (SpenderContractType) {
+    SpenderContractType["MarketGatewayContract"] = "MarketGatewayContract";
+    SpenderContractType["MarketGatewayMultiSendContract"] = "MarketGatewayMultiSendContract";
+})(SpenderContractType || (SpenderContractType = {}));export{ChainId,SpenderContractType};

package/dist/mjs/types/order.js

@@ -0,0 +1,11 @@
+var ErcAssetItem;
+(function (ErcAssetItem) {
+    ErcAssetItem[ErcAssetItem["Erc20"] = 0] = "Erc20";
+    ErcAssetItem[ErcAssetItem["Erc721"] = 1] = "Erc721";
+    ErcAssetItem[ErcAssetItem["Erc1155"] = 2] = "Erc1155";
+})(ErcAssetItem || (ErcAssetItem = {}));
+var OrderKind;
+(function (OrderKind) {
+    OrderKind[OrderKind["Offer"] = 0] = "Offer";
+    OrderKind[OrderKind["Sell"] = 1] = "Sell";
+})(OrderKind || (OrderKind = {}));export{ErcAssetItem,OrderKind};

package/dist/mjs/utils/convertPrice.js

@@ -0,0 +1,7 @@
+import {getRate}from'./mapData.js';const convertAmountToUsd = (amount, tokenSymbol, exchangeRate) => {
+    if (!exchangeRate || !amount) {
+        return 0;
+    }
+    const rate = getRate(tokenSymbol, exchangeRate);
+    return amount * rate;
+};export{convertAmountToUsd};

package/dist/mjs/utils/getSpenderContractAddress.js

@@ -0,0 +1,10 @@
+import {isEmpty}from'lodash';import {getConfig,getSpenderContractConfig}from'../configs/index.js';const getSpenderContractAddress = (chainId, spenderContract) => {
+    const config = getConfig(chainId);
+    const marketGatewayContractAddress = config.contractsAddress.marketGateway;
+    if (isEmpty(spenderContract)) {
+        return marketGatewayContractAddress;
+    }
+    const spenderAddressConfig = getSpenderContractConfig(chainId);
+    const spenderAddress = spenderAddressConfig[spenderContract];
+    return spenderAddress || marketGatewayContractAddress;
+};export{getSpenderContractAddress};

package/dist/mjs/utils/mapData.js

@@ -0,0 +1,43 @@
+import'graphql-request';import'../types/index.js';import'../queries/graphql/queries/collection.js';import {Erc}from'../queries/collection/types.js';import'../queries/graphql/queries/exchange-rate.js';import'../queries/graphql/queries/offer.js';import'../queries/offer/types.js';import'../queries/graphql/mutations/order.js';import'../queries/graphql/queries/order.js';import'../queries/token/types.js';import {OrderType}from'../queries/order/types.js';import'../queries/graphql/mutations/metadata.js';import'../queries/graphql/queries/token.js';import {OrderKind,ErcAssetItem}from'../types/order.js';const getOrderKind = (orderType) => {
+    switch (orderType) {
+        case OrderType.Offer:
+            return OrderKind.Offer;
+        default:
+            return OrderKind.Sell;
+    }
+};
+const getErcAssetItem = (ercType) => {
+    switch (ercType) {
+        case Erc.Erc20:
+            return ErcAssetItem.Erc20;
+        case Erc.Erc1155:
+            return ErcAssetItem.Erc1155;
+        case Erc.Erc721:
+            return ErcAssetItem.Erc721;
+    }
+};
+const getErcType = (ercAssetItem) => {
+    switch (ercAssetItem) {
+        case ErcAssetItem.Erc20:
+            return Erc.Erc20;
+        case ErcAssetItem.Erc1155:
+            return Erc.Erc1155;
+        case ErcAssetItem.Erc721:
+            return Erc.Erc721;
+    }
+};
+const getRate = (tokenSymbol, exchangeRate) => {
+    switch (tokenSymbol.toUpperCase()) {
+        case 'WRON':
+        case 'RON':
+            return exchangeRate.ron.usd;
+        case 'AXS':
+            return exchangeRate.axs.usd;
+        case 'SLP':
+            return exchangeRate.slp.usd;
+        case 'USDC':
+            return exchangeRate.usd.usd;
+        default:
+            return exchangeRate.eth.usd;
+    }
+};export{getErcAssetItem,getErcType,getOrderKind,getRate};

package/dist/types/actions/approve-token/index.d.ts

@@ -0,0 +1,8 @@
+import { ApproveErc20TokenParams, ApproveErc721TokenParams, ApproveErc1155TokenParams, ApproveTokenParams, ApproveWRonTokenParams } from './types';
+export * from './types';
+export declare const approveWRonToken: (params: ApproveWRonTokenParams) => Promise<import("ethers").ContractTransaction>;
+export declare const approveErc20Token: (params: ApproveErc20TokenParams) => Promise<import("ethers").ContractTransaction>;
+export declare const approveErc721Token: (params: ApproveErc721TokenParams) => Promise<import("ethers").ContractTransaction>;
+export declare const approveErc1155Token: (params: ApproveErc1155TokenParams) => Promise<import("ethers").ContractTransaction>;
+export declare const approveToken: (params: ApproveTokenParams) => Promise<import("ethers").ContractTransaction>;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/actions/approve-token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/actions/approve-token/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EACzB,kBAAkB,EAElB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,cAAc,SAAS,CAAC;AAExB,eAAO,MAAM,gBAAgB,WAAkB,sBAAsB,kDAUpE,CAAC;AAEF,eAAO,MAAM,iBAAiB,WAAkB,uBAAuB,kDAUtE,CAAC;AAEF,eAAO,MAAM,kBAAkB,WAAkB,wBAAwB,kDASxE,CAAC;AAEF,eAAO,MAAM,mBAAmB,WAAkB,yBAAyB,kDAS1E,CAAC;AAEF,eAAO,MAAM,YAAY,WAAY,kBAAkB,kDAetD,CAAC"}

package/dist/types/actions/approve-token/types.d.ts

@@ -0,0 +1,25 @@
+import { ethers } from 'ethers';
+import { ChainId, WalletClient } from '../../types';
+export declare enum ApproveTokenType {
+    Erc721 = "Erc721",
+    Erc1155 = "Erc1155",
+    Erc20 = "Erc20",
+    WRon = "WRon"
+}
+export interface ApproveTokenParams {
+    chainId: ChainId;
+    wallet: WalletClient;
+    address: string;
+    tokenType: ApproveTokenType;
+    spenderAddress?: string;
+    options?: ethers.Overrides;
+}
+export type ApproveErc20TokenParams = Omit<ApproveTokenParams, 'tokenType'>;
+export type ApproveErc721TokenParams = Omit<ApproveTokenParams, 'tokenType'>;
+export type ApproveErc1155TokenParams = Omit<ApproveTokenParams, 'tokenType'>;
+export interface ApproveWRonTokenParams {
+    chainId: ChainId;
+    wallet: WalletClient;
+    options?: ethers.Overrides;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/actions/approve-token/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/actions/approve-token/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,OAAO,EAAuB,YAAY,EAAE,MAAM,aAAa,CAAC;AAEzE,oBAAY,gBAAgB;IAC1B,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC;CAC5B;AAED,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC;AAE5E,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC;AAE7E,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC;AAE9E,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC;CAC5B"}

package/dist/types/actions/bulk-buy-token/index.d.ts

@@ -0,0 +1,4 @@
+import { BulkBuyTokenParams } from './types';
+export * from './types';
+export declare const bulkBuyToken: (params: BulkBuyTokenParams) => Promise<any>;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/actions/bulk-buy-token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/actions/bulk-buy-token/index.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,kBAAkB,EAAoB,MAAM,SAAS,CAAC;AAE/D,cAAc,SAAS,CAAC;AAwDxB,eAAO,MAAM,YAAY,WAAkB,kBAAkB,iBA0E5D,CAAC"}