@maxion-platform/ronin-market-sdk 1.0.0

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

@@ -0,0 +1,64 @@
+'use strict';
+
+var ethers = require('ethers');
+var index = require('../../configs/index.js');
+var index$1 = require('../../contracts/index.js');
+var types = require('./types.js');
+
+const approveWRonToken = async (params) => {
+    const { chainId, wallet, options } = params;
+    const { provider, account } = wallet;
+    const approvedValue = ethers.BigNumber.from('1').shl(256).sub(1).toString();
+    const config = index.getConfig(chainId);
+    const marketGatewayContract = config.contractsAddress.marketGateway;
+    const wRonContract = index$1.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 = ethers.BigNumber.from('1').shl(256).sub(1).toString();
+    const config = index.getConfig(chainId);
+    const spender = spenderAddress || config.contractsAddress.marketGateway;
+    const erc20Contract = index$1.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 = index.getConfig(chainId);
+    const marketGatewayContract = config.contractsAddress.marketGateway;
+    const erc721Contract = index$1.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 = index.getConfig(chainId);
+    const marketGatewayContract = config.contractsAddress.marketGateway;
+    const erc1155Contract = index$1.createErc1155Contract(address, provider);
+    return erc1155Contract.setApprovalForAll(marketGatewayContract, true, { ...options, from: account });
+};
+const approveToken = (params) => {
+    const { tokenType, ...otherParams } = params;
+    if (tokenType === types.ApproveTokenType.Erc20) {
+        return approveErc20Token(otherParams);
+    }
+    if (tokenType === types.ApproveTokenType.Erc721) {
+        return approveErc721Token(otherParams);
+    }
+    if (tokenType === types.ApproveTokenType.Erc1155) {
+        return approveErc721Token(otherParams);
+    }
+    return approveWRonToken(otherParams);
+};
+
+Object.defineProperty(exports, 'ApproveTokenType', {
+  enumerable: true,
+  get: function () { return types.ApproveTokenType; }
+});
+exports.approveErc1155Token = approveErc1155Token;
+exports.approveErc20Token = approveErc20Token;
+exports.approveErc721Token = approveErc721Token;
+exports.approveToken = approveToken;
+exports.approveWRonToken = approveWRonToken;

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

@@ -0,0 +1,9 @@
+'use strict';
+
+exports.ApproveTokenType = void 0;
+(function (ApproveTokenType) {
+    ApproveTokenType["Erc721"] = "Erc721";
+    ApproveTokenType["Erc1155"] = "Erc1155";
+    ApproveTokenType["Erc20"] = "Erc20";
+    ApproveTokenType["WRon"] = "WRon";
+})(exports.ApproveTokenType || (exports.ApproveTokenType = {}));

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

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

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

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

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

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

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

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

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

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

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

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

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

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