@maxion-platform/ronin-market-sdk 1.0.0

package/dist/cjs/types/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var order = require('./order.js');
+
+exports.ChainId = void 0;
+(function (ChainId) {
+    ChainId[ChainId["mainnet"] = 2020] = "mainnet";
+    ChainId[ChainId["testnet"] = 202601] = "testnet";
+})(exports.ChainId || (exports.ChainId = {}));
+exports.SpenderContractType = void 0;
+(function (SpenderContractType) {
+    SpenderContractType["MarketGatewayContract"] = "MarketGatewayContract";
+    SpenderContractType["MarketGatewayMultiSendContract"] = "MarketGatewayMultiSendContract";
+})(exports.SpenderContractType || (exports.SpenderContractType = {}));
+
+Object.defineProperty(exports, 'ErcAssetItem', {
+  enumerable: true,
+  get: function () { return order.ErcAssetItem; }
+});
+Object.defineProperty(exports, 'OrderKind', {
+  enumerable: true,
+  get: function () { return order.OrderKind; }
+});

package/dist/cjs/types/order.js

@@ -0,0 +1,13 @@
+'use strict';
+
+exports.ErcAssetItem = void 0;
+(function (ErcAssetItem) {
+    ErcAssetItem[ErcAssetItem["Erc20"] = 0] = "Erc20";
+    ErcAssetItem[ErcAssetItem["Erc721"] = 1] = "Erc721";
+    ErcAssetItem[ErcAssetItem["Erc1155"] = 2] = "Erc1155";
+})(exports.ErcAssetItem || (exports.ErcAssetItem = {}));
+exports.OrderKind = void 0;
+(function (OrderKind) {
+    OrderKind[OrderKind["Offer"] = 0] = "Offer";
+    OrderKind[OrderKind["Sell"] = 1] = "Sell";
+})(exports.OrderKind || (exports.OrderKind = {}));

package/dist/cjs/utils/convertPrice.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var mapData = require('./mapData.js');
+
+const convertAmountToUsd = (amount, tokenSymbol, exchangeRate) => {
+    if (!exchangeRate || !amount) {
+        return 0;
+    }
+    const rate = mapData.getRate(tokenSymbol, exchangeRate);
+    return amount * rate;
+};
+
+exports.convertAmountToUsd = convertAmountToUsd;

package/dist/cjs/utils/getSpenderContractAddress.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var lodash = require('lodash');
+var index = require('../configs/index.js');
+
+const getSpenderContractAddress = (chainId, spenderContract) => {
+    const config = index.getConfig(chainId);
+    const marketGatewayContractAddress = config.contractsAddress.marketGateway;
+    if (lodash.isEmpty(spenderContract)) {
+        return marketGatewayContractAddress;
+    }
+    const spenderAddressConfig = index.getSpenderContractConfig(chainId);
+    const spenderAddress = spenderAddressConfig[spenderContract];
+    return spenderAddress || marketGatewayContractAddress;
+};
+
+exports.getSpenderContractAddress = getSpenderContractAddress;

package/dist/cjs/utils/mapData.js

@@ -0,0 +1,65 @@
+'use strict';
+
+require('graphql-request');
+require('../types/index.js');
+require('../queries/graphql/queries/collection.js');
+var types$1 = require('../queries/collection/types.js');
+require('../queries/graphql/queries/exchange-rate.js');
+require('../queries/graphql/queries/offer.js');
+require('../queries/offer/types.js');
+require('../queries/graphql/mutations/order.js');
+require('../queries/graphql/queries/order.js');
+require('../queries/token/types.js');
+var types = require('../queries/order/types.js');
+require('../queries/graphql/mutations/metadata.js');
+require('../queries/graphql/queries/token.js');
+var order = require('../types/order.js');
+
+const getOrderKind = (orderType) => {
+    switch (orderType) {
+        case types.OrderType.Offer:
+            return order.OrderKind.Offer;
+        default:
+            return order.OrderKind.Sell;
+    }
+};
+const getErcAssetItem = (ercType) => {
+    switch (ercType) {
+        case types$1.Erc.Erc20:
+            return order.ErcAssetItem.Erc20;
+        case types$1.Erc.Erc1155:
+            return order.ErcAssetItem.Erc1155;
+        case types$1.Erc.Erc721:
+            return order.ErcAssetItem.Erc721;
+    }
+};
+const getErcType = (ercAssetItem) => {
+    switch (ercAssetItem) {
+        case order.ErcAssetItem.Erc20:
+            return types$1.Erc.Erc20;
+        case order.ErcAssetItem.Erc1155:
+            return types$1.Erc.Erc1155;
+        case order.ErcAssetItem.Erc721:
+            return types$1.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;
+    }
+};
+
+exports.getErcAssetItem = getErcAssetItem;
+exports.getErcType = getErcType;
+exports.getOrderKind = getOrderKind;
+exports.getRate = getRate;

package/dist/mjs/actions/approve-token/index.js

@@ -0,0 +1,47 @@
+import {BigNumber}from'ethers';import {getConfig}from'../../configs/index.js';import {createWRonContract,createErc20Contract,createErc721Contract,createErc1155Contract}from'../../contracts/index.js';import {ApproveTokenType}from'./types.js';const approveWRonToken = async (params) => {
+    const { chainId, wallet, options } = params;
+    const { provider, account } = wallet;
+    const approvedValue = BigNumber.from('1').shl(256).sub(1).toString();
+    const config = getConfig(chainId);
+    const marketGatewayContract = config.contractsAddress.marketGateway;
+    const wRonContract = createWRonContract(chainId, provider);
+    return wRonContract.approve(marketGatewayContract, approvedValue, { ...options, from: account });
+};
+const approveErc20Token = async (params) => {
+    const { chainId, wallet, address, spenderAddress, options } = params;
+    const { provider, account } = wallet;
+    const approvedValue = BigNumber.from('1').shl(256).sub(1).toString();
+    const config = getConfig(chainId);
+    const spender = spenderAddress || config.contractsAddress.marketGateway;
+    const erc20Contract = createErc20Contract(address, provider);
+    return erc20Contract.approve(spender, approvedValue, { ...options, from: account });
+};
+const approveErc721Token = async (params) => {
+    const { chainId, wallet, address, options } = params;
+    const { provider, account } = wallet;
+    const config = getConfig(chainId);
+    const marketGatewayContract = config.contractsAddress.marketGateway;
+    const erc721Contract = createErc721Contract(address, provider);
+    return erc721Contract.setApprovalForAll(marketGatewayContract, true, { ...options, from: account });
+};
+const approveErc1155Token = async (params) => {
+    const { chainId, wallet, address, options } = params;
+    const { provider, account } = wallet;
+    const config = getConfig(chainId);
+    const marketGatewayContract = config.contractsAddress.marketGateway;
+    const erc1155Contract = createErc1155Contract(address, provider);
+    return erc1155Contract.setApprovalForAll(marketGatewayContract, true, { ...options, from: account });
+};
+const approveToken = (params) => {
+    const { tokenType, ...otherParams } = params;
+    if (tokenType === ApproveTokenType.Erc20) {
+        return approveErc20Token(otherParams);
+    }
+    if (tokenType === ApproveTokenType.Erc721) {
+        return approveErc721Token(otherParams);
+    }
+    if (tokenType === ApproveTokenType.Erc1155) {
+        return approveErc721Token(otherParams);
+    }
+    return approveWRonToken(otherParams);
+};export{ApproveTokenType,approveErc1155Token,approveErc20Token,approveErc721Token,approveToken,approveWRonToken};

package/dist/mjs/actions/approve-token/types.js

@@ -0,0 +1,7 @@
+var ApproveTokenType;
+(function (ApproveTokenType) {
+    ApproveTokenType["Erc721"] = "Erc721";
+    ApproveTokenType["Erc1155"] = "Erc1155";
+    ApproveTokenType["Erc20"] = "Erc20";
+    ApproveTokenType["WRon"] = "WRon";
+})(ApproveTokenType || (ApproveTokenType = {}));export{ApproveTokenType};

package/dist/mjs/actions/bulk-buy-token/index.js

@@ -0,0 +1,86 @@
+import {BigNumber}from'ethers';import {SWAP_DEFAULT_SLIPPAGE,ZERO_ADDRESS}from'../../common/constants.js';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'../../queries/order/types.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import {checkIsInsufficientBalance}from'../../services/balance/checkIsInsufficientBalance.js';import'../../configs/index.js';import'../../services/tokens/data.js';import {getPaymentToken}from'../../services/tokens/getPaymentTokens.js';import {getSwapConfig}from'../../services/tokens/configs.js';import'lodash';import {getOrdersTotalPrice}from'../../services/order/getOrdersTotalPrice.js';import {generateErc721Order,generateErc1155Order}from'../../services/order/generateOrderData.js';import'ethers/lib/utils';import {bulkSettleOrders}from'../../services/order/bulkSettleOrders.js';const parseOrder = (params) => {
+    const { tokenType, order, totalPrice, quantity, referralAddr = ZERO_ADDRESS } = params;
+    const { expectedState, signature } = order;
+    if (tokenType === Erc.Erc721) {
+        const orderData = generateErc721Order(order);
+        return {
+            expectedState,
+            settlePrice: totalPrice,
+            referralAddr,
+            signature,
+            order: orderData,
+        };
+    }
+    const orderData = generateErc1155Order(order);
+    return {
+        expectedState,
+        settlePrice: totalPrice,
+        referralAddr,
+        signature,
+        order: orderData,
+        quantity: quantity.toString(),
+    };
+};
+const swapAndParseOrder = (chainId, order, totalPrice, quantity, selectedToken, deadline, tokenType) => {
+    const { paymentToken: listingToken } = order;
+    const { address } = selectedToken;
+    const swapConfig = getSwapConfig(chainId, listingToken);
+    const path = swapConfig[address].path;
+    const settlePrice = BigNumber.from(totalPrice || '0')
+        .mul(100 + SWAP_DEFAULT_SLIPPAGE)
+        .div(100)
+        .toString();
+    const parsedOrder = parseOrder({ tokenType, order, totalPrice: settlePrice, quantity });
+    return {
+        ...parsedOrder,
+        deadline,
+        path,
+    };
+};
+const bulkBuyToken = async (params) => {
+    try {
+        const { chainId, wallet, data, selectedTokenAddress, deadline, tokenType, requiredAllSuccess = false, options, } = params;
+        const selectedToken = getPaymentToken(chainId, selectedTokenAddress);
+        const { address: paymentToken } = selectedToken;
+        const { account } = wallet;
+        const { totalPriceOfEachOrder } = await getOrdersTotalPrice({
+            data,
+            chainId,
+            token: selectedToken,
+            wallet,
+        });
+        let totalSettlePrice = BigNumber.from('0');
+        const bulkBuyData = data.map(({ quantity, order }) => {
+            const { paymentToken: listingToken, hash } = order;
+            const totalPrice = totalPriceOfEachOrder[hash];
+            const isListingWithPaymentToken = listingToken.toLowerCase() === paymentToken.toLowerCase();
+            if (isListingWithPaymentToken) {
+                totalSettlePrice = totalSettlePrice.add(totalPrice);
+                return parseOrder({ tokenType, order, totalPrice, quantity: quantity.toString() });
+            }
+            const settlePrice = BigNumber.from(totalPrice || '0')
+                .mul(100 + SWAP_DEFAULT_SLIPPAGE)
+                .div(100)
+                .toString();
+            totalSettlePrice = totalSettlePrice.add(settlePrice);
+            return swapAndParseOrder(chainId, order, totalPrice, quantity.toString(), selectedToken, deadline, tokenType);
+        });
+        const isInsufficient = await checkIsInsufficientBalance(chainId, selectedTokenAddress, account, totalSettlePrice.toString());
+        if (isInsufficient) {
+            throw new Error('Insufficient balance for transaction.');
+        }
+        return bulkSettleOrders({
+            chainId,
+            wallet,
+            bulkBuyData: bulkBuyData,
+            paymentToken,
+            totalSettlePrice: totalSettlePrice.toString(),
+            tokenType,
+            requiredAllSuccess,
+            options,
+        });
+    }
+    catch (error) {
+        throw new Error(error.message || error);
+    }
+};export{bulkBuyToken};

package/dist/mjs/actions/buy-token/index.js

@@ -0,0 +1,126 @@
+import {BigNumber}from'ethers';import {formatUnits}from'ethers/lib/utils';import {SWAP_DEFAULT_SLIPPAGE,ZERO_ADDRESS}from'../../common/constants.js';import'graphql-request';import'../../types/index.js';import'../../queries/graphql/queries/collection.js';import {Erc}from'../../queries/collection/types.js';import {getExchangeRate}from'../../queries/exchange-rate/index.js';import'../../queries/graphql/queries/offer.js';import'../../queries/offer/types.js';import {getOrderByHash}from'../../queries/order/index.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import'../../queries/order/types.js';import'../../queries/token/types.js';import {checkIsInsufficientBalance}from'../../services/balance/checkIsInsufficientBalance.js';import'../../configs/index.js';import {Token}from'../../services/tokens/data.js';import {getPaymentTokens,getPaymentToken}from'../../services/tokens/getPaymentTokens.js';import {getSwapConfig}from'../../services/tokens/configs.js';import {getTokensNeedToApprove}from'../../services/tokens/getTokensNeedToApprove.js';import'lodash';import {checkIsErc721OrderValid,checkIsErc1155OrderValid}from'../../services/order/checkIsOrderValid.js';import {convertAmountToUsd}from'../../utils/convertPrice.js';import {getSwappedAmount,getLiquidityProviderFee,getLiquidityProviderFeePercent,getPriceImpactPercent}from'../../services/order/getSwapTokenData.js';import {getSettlePrice,settleErc721Order,swapRONAndSettleErc721Order,swapTokensAndSettleErc721Order,settleErc1155Order,swapRONAndSettleErc1155Order,swapTokensAndSettleErc1155Order}from'../../services/order/settleOrder.js';const buyErc721Token = async (params) => {
+    const { order, selectedTokenAddress, chainId, wallet, deadline, refAddress = ZERO_ADDRESS, recipient, options } = params;
+    if (!order) {
+        throw new Error('Order not found');
+    }
+    const { paymentToken: listingToken, currentPrice } = order;
+    const { account } = wallet;
+    const tokens = getPaymentTokens(chainId);
+    const isBuyingWithListingToken = selectedTokenAddress.toLowerCase() === listingToken.toLowerCase();
+    const isBuyingWithRonToken = selectedTokenAddress.toLowerCase() === tokens[Token.RON].address.toLowerCase();
+    const settlePrice = await getSettlePrice(chainId, selectedTokenAddress, listingToken, currentPrice);
+    if (!settlePrice) {
+        throw new Error('Can not get settle price');
+    }
+    // Check order is valid
+    const isOrderValid = await checkIsErc721OrderValid(chainId, order);
+    if (!isOrderValid) {
+        throw new Error('Invalid order');
+    }
+    // Check all tokens is approved
+    const tokensNeedToApprove = await getTokensNeedToApprove(chainId, account, selectedTokenAddress, listingToken, settlePrice);
+    const isApprovedAllToken = tokensNeedToApprove.length === 0;
+    if (!isApprovedAllToken) {
+        const tokensNameNeedToApprove = tokensNeedToApprove.map(token => token.name);
+        throw new Error(`Tokens need to approve: ${JSON.stringify(tokensNameNeedToApprove)}`);
+    }
+    // Check insufficient balance
+    const isInsufficient = await checkIsInsufficientBalance(chainId, selectedTokenAddress, account, settlePrice);
+    if (isInsufficient) {
+        throw new Error('Insufficient balance');
+    }
+    // Settle order
+    if (isBuyingWithListingToken) {
+        return settleErc721Order(chainId, wallet, order, settlePrice, refAddress, recipient, options);
+    }
+    const swapConfig = getSwapConfig(chainId, listingToken);
+    const tokenPaths = swapConfig[selectedTokenAddress]?.path;
+    if (isBuyingWithRonToken) {
+        return swapRONAndSettleErc721Order(chainId, wallet, order, settlePrice, tokenPaths, deadline, refAddress, recipient, options);
+    }
+    return swapTokensAndSettleErc721Order(chainId, wallet, order, settlePrice, tokenPaths, deadline, refAddress, recipient, options);
+};
+const buyErc1155Token = async (params) => {
+    const { order, selectedTokenAddress, chainId, wallet, quantity, deadline, refAddress = ZERO_ADDRESS, recipient, options, } = params;
+    if (!order) {
+        throw new Error('Order not found');
+    }
+    const { paymentToken: listingToken, currentPrice } = order;
+    const { account } = wallet;
+    const totalPrice = BigNumber.from(currentPrice)
+        .mul(Number(quantity || 0))
+        .toString();
+    const tokens = getPaymentTokens(chainId);
+    const isBuyingWithListingToken = selectedTokenAddress.toLowerCase() === listingToken.toLowerCase();
+    const isBuyingWithRonToken = selectedTokenAddress.toLowerCase() === tokens[Token.RON].address.toLowerCase();
+    const settlePrice = await getSettlePrice(chainId, selectedTokenAddress, listingToken, totalPrice);
+    if (!settlePrice) {
+        throw new Error('Can not get settle price');
+    }
+    // Check order is valid
+    const isOrderValid = await checkIsErc1155OrderValid(chainId, order);
+    if (!isOrderValid) {
+        throw new Error('Invalid order');
+    }
+    // Check all tokens is approved
+    const tokensNeedToApprove = await getTokensNeedToApprove(chainId, account, selectedTokenAddress, listingToken, settlePrice);
+    const isApprovedAllToken = tokensNeedToApprove.length === 0;
+    if (!isApprovedAllToken) {
+        const tokensNameNeedToApprove = tokensNeedToApprove.map(token => token.name);
+        throw new Error(`Tokens need to approve: ${JSON.stringify(tokensNameNeedToApprove)}`);
+    }
+    // Check insufficient balance
+    const isInsufficient = await checkIsInsufficientBalance(chainId, selectedTokenAddress, account, settlePrice);
+    if (isInsufficient) {
+        throw new Error('Insufficient balance');
+    }
+    // Settle order
+    if (isBuyingWithListingToken) {
+        return settleErc1155Order(chainId, wallet, order, settlePrice, quantity, refAddress, recipient, options);
+    }
+    const swapConfig = getSwapConfig(chainId, listingToken);
+    const tokenPaths = swapConfig[selectedTokenAddress]?.path;
+    if (isBuyingWithRonToken) {
+        return swapRONAndSettleErc1155Order(chainId, wallet, order, settlePrice, tokenPaths, quantity, deadline, refAddress, recipient, options);
+    }
+    return swapTokensAndSettleErc1155Order(chainId, wallet, order, currentPrice, tokenPaths, quantity, deadline, refAddress, recipient, options);
+};
+const buyToken = async (params) => {
+    const { hash, ...otherParams } = params;
+    const order = await getOrderByHash({ hash, chainId: params.chainId });
+    if (!order) {
+        throw new Error('Order not found');
+    }
+    const ercType = order.assets?.[0]?.erc;
+    if (ercType === Erc.Erc721) {
+        return buyErc721Token({ ...otherParams, order });
+    }
+    return buyErc1155Token({ quantity: 1, ...otherParams, order });
+};
+const getSwapTokenData = async (params) => {
+    const { chainId, inputTokenAddress, outputTokenAddress, amount } = params;
+    const exchangeRate = await getExchangeRate({ chainId });
+    const inputTokenData = getPaymentToken(chainId, inputTokenAddress);
+    const outputTokenData = getPaymentToken(chainId, outputTokenAddress);
+    if (!inputTokenData) {
+        throw new Error('Input token address is invalid');
+    }
+    if (!outputTokenData) {
+        throw new Error('Output token address is invalid');
+    }
+    const swappedAmount = await getSwappedAmount(chainId, inputTokenAddress, outputTokenAddress, amount);
+    const fiatValueIn = convertAmountToUsd(Number(formatUnits(BigNumber.from(amount), inputTokenData.decimals)), inputTokenData.symbol, exchangeRate);
+    const fiatValueOut = convertAmountToUsd(Number(formatUnits(BigNumber.from(swappedAmount), outputTokenData.decimals)), inputTokenData?.symbol, exchangeRate);
+    const liquidityProviderFee = getLiquidityProviderFee(chainId, inputTokenAddress, outputTokenAddress, amount);
+    const liquidityProviderFeePercent = getLiquidityProviderFeePercent(chainId, inputTokenAddress, outputTokenAddress);
+    const priceImpactPercent = await getPriceImpactPercent(chainId, inputTokenAddress, outputTokenAddress, fiatValueIn, fiatValueOut);
+    const maximumSent = await getSettlePrice(chainId, inputTokenAddress, outputTokenAddress, amount);
+    return {
+        swappedAmount: swappedAmount?.toString(),
+        maximumSent,
+        liquidityProviderFee,
+        liquidityProviderFeePercent,
+        priceImpactPercent,
+        slippageTolerance: SWAP_DEFAULT_SLIPPAGE,
+    };
+};export{buyErc1155Token,buyErc721Token,buyToken,getSwapTokenData};

package/dist/mjs/actions/gift-token/index.js

@@ -0,0 +1,27 @@
+import {BigNumber}from'ethers';import {createErc721Contract,createErc1155Contract}from'../../contracts/index.js';import {getTokenMetadata}from'../../queries/collection/index.js';import'graphql-request';import'../../types/index.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'../../queries/order/types.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import {Erc}from'../../queries/collection/types.js';const giftErc721Token = async (params) => {
+    const { tokenId, tokenAddress, receiverAddress, wallet, options } = params;
+    const { account, provider } = wallet;
+    const erc721Contract = createErc721Contract(tokenAddress, provider);
+    return erc721Contract?.['safeTransferFrom(address,address,uint256)'](account, receiverAddress, BigNumber.from(tokenId), { ...options });
+};
+const giftErc1155Token = async (params) => {
+    const { tokenId, tokenAddress, receiverAddress, quantity, wallet, options } = params;
+    const { account, provider } = wallet;
+    const erc1155Contract = createErc1155Contract(tokenAddress, provider);
+    return erc1155Contract?.safeTransferFrom(account, receiverAddress, BigNumber.from(tokenId), quantity, [], {
+        ...options,
+    });
+};
+const giftToken = async (params) => {
+    const { chainId, ...otherParams } = params;
+    const tokenMetadata = await getTokenMetadata({
+        showAttributes: false,
+        chainId,
+        tokenAddress: otherParams.tokenAddress,
+    });
+    const { erc } = tokenMetadata;
+    if (erc === Erc.Erc721) {
+        return giftErc721Token(otherParams);
+    }
+    return giftErc1155Token({ quantity: 1, ...otherParams });
+};export{giftErc1155Token,giftErc721Token,giftToken};

package/dist/mjs/actions/offer/acceptOffer.js

@@ -0,0 +1,15 @@
+import {ZERO_ADDRESS}from'../../common/constants.js';import'graphql-request';import'../../types/index.js';import'../../queries/graphql/queries/collection.js';import'../../queries/collection/types.js';import'../../queries/graphql/queries/exchange-rate.js';import {getOffer}from'../../queries/offer/index.js';import'../../queries/graphql/mutations/order.js';import'../../queries/graphql/queries/order.js';import'../../queries/token/types.js';import'../../queries/order/types.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import'ethers';import'../../configs/index.js';import'../../services/tokens/data.js';import {checkIsErc721Approved}from'../../services/tokens/checkIsTokenApproved.js';import'lodash';import'ethers/lib/utils';import {settleErc721Order}from'../../services/order/settleOrder.js';const acceptOffer = async (params) => {
+    const { hash, wallet, chainId, refAddress = ZERO_ADDRESS, recipient, options } = params;
+    const { account } = wallet;
+    const offer = await getOffer({ hash, chainId });
+    if (!offer) {
+        throw new Error('Offer not found');
+    }
+    const { assets } = offer;
+    const tokenAddress = assets?.[0]?.token?.tokenAddress;
+    const isApproved = await checkIsErc721Approved(chainId, account, tokenAddress);
+    if (!isApproved) {
+        throw new Error('Token need to be approved');
+    }
+    return settleErc721Order(chainId, wallet, offer, '0', refAddress, recipient, options);
+};export{acceptOffer};

package/dist/mjs/actions/offer/cancelOffer.js

@@ -0,0 +1,3 @@
+import {cancelOrder}from'../order/cancelOrder.js';import'ethers';import'graphql-request';import'../../types/index.js';import'../../queries/graphql/queries/collection.js';import'../../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'../../queries/order/types.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import'../../configs/index.js';import'../../services/tokens/data.js';import'lodash';import'ethers/lib/utils';const cancelOffer = (params) => {
+    return cancelOrder(params);
+};export{cancelOffer};

package/dist/mjs/actions/offer/makeOffer.js

@@ -0,0 +1,63 @@
+import {BigNumber}from'ethers';import {MARKET_FEE_PERCENTAGE}from'../../common/constants.js';import'graphql-request';import'../../types/index.js';import'../../queries/graphql/queries/collection.js';import'../../queries/collection/types.js';import'../../queries/graphql/queries/exchange-rate.js';import'../../queries/graphql/queries/offer.js';import'../../queries/offer/types.js';import {requestCreateOrder}from'../../queries/order/index.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import {OrderType}from'../../queries/order/types.js';import'../../queries/token/types.js';import {checkIsInsufficientOfferBalance}from'../../services/balance/checkIsInsufficientBalance.js';import'../../configs/index.js';import {wRonToken}from'../../services/tokens/data.js';import {checkIsWRonTokenApproved}from'../../services/tokens/checkIsTokenApproved.js';import'lodash';import {generateInputOrder}from'../../services/order/generateOrderData.js';import {getNonce}from'../../services/order/getNonce.js';import {getErc721OrderSignature}from'../../services/order/getOrderSignature.js';import'ethers/lib/utils';import {ErcAssetItem,OrderKind}from'../../types/order.js';const getInputOrder = async (chainId, account, price, duration, expectedState, assets) => {
+    const wRonAddress = wRonToken[chainId].address;
+    const nonce = await getNonce(chainId, account);
+    return generateInputOrder({
+        price: BigNumber.from(price),
+        duration,
+        paymentToken: wRonAddress,
+        orderType: OrderType.Offer,
+        expectedState,
+        nonce,
+        maker: account,
+        assets,
+    });
+};
+const getOrderSignature = (chainId, wallet, price, duration, expectedState, assets) => {
+    const { account, signer } = wallet;
+    const wRonAddress = wRonToken[chainId].address;
+    const now = new Date().getTime();
+    const startedAt = Math.ceil(now / 1000);
+    const expiredAt = startedAt + duration;
+    const dataForSigning = {
+        maker: account,
+        kind: OrderKind.Offer,
+        assets,
+        expiredAt,
+        paymentToken: wRonAddress,
+        startedAt,
+        basePrice: price,
+        endedAt: 0,
+        endedPrice: '0',
+        expectedState,
+        nonce: 0,
+        marketFeePercentage: MARKET_FEE_PERCENTAGE,
+    };
+    return getErc721OrderSignature(chainId, signer, dataForSigning);
+};
+const makeOffer = async (params) => {
+    const { tokenId, tokenAddress, price, duration, chainId, wallet } = params;
+    const { account } = wallet;
+    const assets = [
+        {
+            id: tokenId,
+            addr: tokenAddress,
+            erc: ErcAssetItem.Erc721,
+            quantity: 0,
+        },
+    ];
+    const isWRonApproved = checkIsWRonTokenApproved(chainId, account, price);
+    if (!isWRonApproved) {
+        throw new Error('WRon need to be approved');
+    }
+    const isInsufficient = await checkIsInsufficientOfferBalance(chainId, account, price);
+    if (isInsufficient) {
+        throw new Error('Insufficient balance');
+    }
+    const expectedState = '0';
+    const inputOrder = await getInputOrder(chainId, account, price, duration, expectedState, assets);
+    const signature = await getOrderSignature(chainId, wallet, price, duration, expectedState, assets);
+    if (!signature) {
+        throw new Error('Invalid signature');
+    }
+    return requestCreateOrder({ order: inputOrder, account, signature, chainId });
+};export{makeOffer};

package/dist/mjs/actions/order/cancelOrder.js

@@ -0,0 +1,32 @@
+import'ethers';import'../../configs/index.js';import'../../services/tokens/data.js';import {createMarketGatewayContract,createErc1155MarketGatewayContract}from'../../contracts/market-gateway/factory.js';import'../../types/index.js';import'graphql-request';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 {getOrderByHash}from'../../queries/order/index.js';import'../../queries/graphql/mutations/metadata.js';import'../../queries/graphql/queries/token.js';import'../../queries/order/types.js';import'../../queries/token/types.js';import'lodash';import {generateErc721Order,generateErc1155Order}from'../../services/order/generateOrderData.js';import'ethers/lib/utils';const cancelErc721Order = async (params) => {
+    const { chainId, wallet, order, options } = params;
+    const { provider } = wallet;
+    if (!order) {
+        throw new Error('Order not found');
+    }
+    const marketGatewayContract = createMarketGatewayContract(chainId, provider);
+    const erc721Order = generateErc721Order(order);
+    return marketGatewayContract.cancelOrder(erc721Order, options);
+};
+const cancelErc1155Order = async (params) => {
+    const { chainId, wallet, order, options } = params;
+    const { provider } = wallet;
+    if (!order) {
+        throw new Error('Order not found');
+    }
+    const erc1155MarketGatewayContract = createErc1155MarketGatewayContract(chainId, provider);
+    const erc1155Order = generateErc1155Order(order);
+    return erc1155MarketGatewayContract.cancelErc1155Order(erc1155Order, options);
+};
+const cancelOrder = async (params) => {
+    const { hash, ...otherParams } = params;
+    const order = await getOrderByHash({ hash, chainId: params.chainId });
+    if (!order) {
+        throw new Error('Order not found');
+    }
+    const ercType = order.assets?.[0]?.erc;
+    if (ercType === Erc.Erc721) {
+        return cancelErc721Order({ ...otherParams, order });
+    }
+    return cancelErc1155Order({ ...otherParams, order });
+};export{cancelErc1155Order,cancelErc721Order,cancelOrder};