@maxion-platform/ronin-market-sdk 1.0.0

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

@@ -0,0 +1,153 @@
+'use strict';
+
+var ethers = require('ethers');
+var constants = require('../../common/constants.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');
+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');
+require('../../configs/index.js');
+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 = require('../../services/order/getOrderSignature.js');
+require('ethers/lib/utils');
+var mapData = require('../../utils/mapData.js');
+var order = require('../../types/order.js');
+var types$1 = require('../../queries/collection/types.js');
+
+const generateErc721Order = (data) => {
+    const { price, duration, orderType, assets, paymentToken, maker, expectedState } = data;
+    const orderKind = mapData.getOrderKind(orderType);
+    const now = new Date().getTime();
+    const startedAt = Math.ceil(now / 1000);
+    const expiredAt = startedAt + duration;
+    const result = {
+        maker,
+        kind: orderKind,
+        assets,
+        expiredAt,
+        paymentToken,
+        startedAt,
+        basePrice: price.toString(),
+        endedAt: 0,
+        endedPrice: '0',
+        expectedState,
+        nonce: 0,
+        marketFeePercentage: constants.MARKET_FEE_PERCENTAGE,
+    };
+    return result;
+};
+const generateErc1155Order = (data) => {
+    const { price, duration, orderType, assets, paymentToken, maker, expectedState } = data;
+    const orderKind = mapData.getOrderKind(orderType);
+    const now = new Date().getTime();
+    const startedAt = Math.ceil(now / 1000);
+    const expiredAt = startedAt + duration;
+    const result = {
+        maker,
+        kind: orderKind,
+        asset: assets[0],
+        expiredAt,
+        paymentToken,
+        startedAt,
+        unitPrice: price.toString(),
+        endedAt: 0,
+        endedUnitPrice: '0',
+        expectedState,
+        nonce: 0,
+    };
+    return result;
+};
+const createErc721Order = async (params) => {
+    const { chainId, wallet, tokenAddress, tokenId, paymentToken, price, duration } = params;
+    const { signer, account } = wallet;
+    const isApproved = checkIsTokenApproved.checkIsErc721Approved(chainId, account, tokenAddress);
+    const assets = [
+        {
+            id: tokenId,
+            addr: tokenAddress,
+            erc: order.ErcAssetItem.Erc721,
+            quantity: 0,
+        },
+    ];
+    if (!isApproved) {
+        throw new Error('This Erc721 tokens to be approved');
+    }
+    const nonce = await getNonce.getNonce(chainId, account);
+    const expectedState = '0';
+    const auctionData = {
+        price: ethers.BigNumber.from(price),
+        duration,
+        paymentToken,
+        orderType: types.OrderType.Sell,
+        expectedState,
+        nonce,
+        maker: account,
+        assets,
+    };
+    const inputOrder = generateOrderData.generateInputOrder(auctionData);
+    const dataForSigning = generateErc721Order(auctionData);
+    const signature = await getOrderSignature.getErc721OrderSignature(chainId, signer, dataForSigning);
+    if (!signature) {
+        throw new Error('Invalid signature');
+    }
+    return index.requestCreateOrder({ order: inputOrder, signature, account, chainId });
+};
+const createErc1155Order = async (params) => {
+    const { chainId, wallet, tokenAddress, tokenId, paymentToken, price, duration, quantity } = params;
+    const { signer, account } = wallet;
+    const isApproved = checkIsTokenApproved.checkIsErc1155Approved(chainId, account, tokenAddress);
+    const assets = [
+        {
+            id: tokenId,
+            addr: tokenAddress,
+            erc: order.ErcAssetItem.Erc1155,
+            quantity,
+        },
+    ];
+    if (!isApproved) {
+        throw new Error('This Erc1155 needs to be approved');
+    }
+    const nonce = await getNonce.getNonce(chainId, account);
+    const expectedState = '0';
+    const auctionData = {
+        price: ethers.BigNumber.from(price),
+        duration,
+        paymentToken,
+        orderType: types.OrderType.Sell,
+        expectedState,
+        nonce,
+        maker: account,
+        assets,
+    };
+    const inputOrder = generateOrderData.generateInputOrder(auctionData);
+    const dataForSigning = generateErc1155Order(auctionData);
+    const signature = await getOrderSignature.getErc1155OrderSignature(chainId, signer, dataForSigning);
+    if (!signature) {
+        throw new Error('Invalid signature');
+    }
+    return index.requestCreateOrder({ order: inputOrder, signature, account, chainId });
+};
+const createOrder = async (params) => {
+    const { chainId, tokenAddress } = params;
+    const tokenMetadata = await index$1.getTokenMetadata({ showAttributes: false, chainId: chainId, tokenAddress: tokenAddress });
+    const { erc } = tokenMetadata;
+    if (erc === types$1.Erc.Erc721) {
+        return createErc721Order(params);
+    }
+    return createErc1155Order({ quantity: 1, ...params });
+};
+
+exports.createErc1155Order = createErc1155Order;
+exports.createErc721Order = createErc721Order;
+exports.createOrder = createOrder;

package/dist/cjs/actions/ron-wrapper/index.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var utils = require('ethers/lib/utils');
+var index = require('../../contracts/index.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');
+require('lodash');
+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');
+
+const wrapRon = async (params) => {
+    const { chainId, wallet, amount, options } = params;
+    const { account, provider } = wallet;
+    const wRonContract = index.createWRonContract(chainId, provider);
+    const ron = getPaymentTokens.getPaymentTokens(chainId)[data.Token.RON];
+    const formattedAmount = utils.parseUnits(amount, ron.unit).toString();
+    const isInsufficientBalance = await checkIsInsufficientBalance.checkIsInsufficientBalance(chainId, ron.address, account, formattedAmount);
+    if (isInsufficientBalance) {
+        throw new Error('Insufficient balance');
+    }
+    return wRonContract.deposit({ value: formattedAmount, ...options });
+};
+const unwrapRon = async (params) => {
+    const { chainId, wallet, amount, options } = params;
+    const { account, provider } = wallet;
+    const wRonContract = index.createWRonContract(chainId, provider);
+    const wRonUnit = data.wRonToken[chainId].unit;
+    const formattedAmount = utils.parseUnits(amount, wRonUnit).toString();
+    const isInsufficientBalance = await checkIsInsufficientBalance.checkIsInsufficientOfferBalance(chainId, account, formattedAmount);
+    if (isInsufficientBalance) {
+        throw new Error('Insufficient balance');
+    }
+    return wRonContract.withdraw(formattedAmount, { ...options });
+};
+
+exports.unwrapRon = unwrapRon;
+exports.wrapRon = wrapRon;

package/dist/cjs/common/constants.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const MARKET_FEE_PERCENTAGE = 425;
+const SWAP_DEFAULT_SLIPPAGE = 1; // 1%
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const Erc1155OrderAbiTypes = {
+    Asset: [
+        {
+            name: 'erc',
+            type: 'uint8',
+        },
+        {
+            name: 'addr',
+            type: 'address',
+        },
+        {
+            name: 'id',
+            type: 'uint256',
+        },
+        {
+            name: 'quantity',
+            type: 'uint256',
+        },
+    ],
+    ERC1155Order: [
+        {
+            name: 'maker',
+            type: 'address',
+        },
+        {
+            name: 'kind',
+            type: 'uint8',
+        },
+        {
+            name: 'asset',
+            type: 'Asset',
+        },
+        {
+            name: 'expiredAt',
+            type: 'uint256',
+        },
+        {
+            name: 'paymentToken',
+            type: 'address',
+        },
+        {
+            name: 'startedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'unitPrice',
+            type: 'uint256',
+        },
+        {
+            name: 'endedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'endedUnitPrice',
+            type: 'uint256',
+        },
+        {
+            name: 'expectedState',
+            type: 'uint256',
+        },
+        {
+            name: 'nonce',
+            type: 'uint256',
+        },
+    ],
+};
+const OrderAbiTypes = {
+    Asset: [
+        {
+            name: 'erc',
+            type: 'uint8',
+        },
+        {
+            name: 'addr',
+            type: 'address',
+        },
+        {
+            name: 'id',
+            type: 'uint256',
+        },
+        {
+            name: 'quantity',
+            type: 'uint256',
+        },
+    ],
+    Order: [
+        {
+            name: 'maker',
+            type: 'address',
+        },
+        {
+            name: 'kind',
+            type: 'uint8',
+        },
+        {
+            name: 'assets',
+            type: 'Asset[]',
+        },
+        {
+            name: 'expiredAt',
+            type: 'uint256',
+        },
+        {
+            name: 'paymentToken',
+            type: 'address',
+        },
+        {
+            name: 'startedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'basePrice',
+            type: 'uint256',
+        },
+        {
+            name: 'endedAt',
+            type: 'uint256',
+        },
+        {
+            name: 'endedPrice',
+            type: 'uint256',
+        },
+        {
+            name: 'expectedState',
+            type: 'uint256',
+        },
+        {
+            name: 'nonce',
+            type: 'uint256',
+        },
+        {
+            name: 'marketFeePercentage',
+            type: 'uint256',
+        },
+    ],
+};
+
+exports.Erc1155OrderAbiTypes = Erc1155OrderAbiTypes;
+exports.MARKET_FEE_PERCENTAGE = MARKET_FEE_PERCENTAGE;
+exports.OrderAbiTypes = OrderAbiTypes;
+exports.SWAP_DEFAULT_SLIPPAGE = SWAP_DEFAULT_SLIPPAGE;
+exports.ZERO_ADDRESS = ZERO_ADDRESS;

package/dist/cjs/configs/index.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var index = require('../types/index.js');
+
+const mainnetConfig = {
+    rpcEndpoint: 'https://api.roninchain.com/rpc',
+    chainId: 2020,
+    chainName: 'Mainnet',
+    contractsAddress: {
+        katana: '0x7d0556d55ca1a92708681e2e231733ebd922597d',
+        marketGateway: '0x3b3adf1422f84254b7fbb0e7ca62bd0865133fe3',
+        marketGatewayMultisend: '0x21a0a1c081dc2f3e48dc391786f53035f85ce0bc',
+        multiCall: '0xc76d0d0d3aa608190f78db02bf2f5aef374fc0b9',
+        collectionOffer: '0x3ef234bc2a04d86f6041e419458d9acbd077f2c1',
+        royaltyRegistry: '0x5afa3e25a620c66bb401e916680316ec80cba676',
+    },
+    marketGatewayDomain: {
+        name: 'MarketGateway',
+        version: '1',
+        chainId: 2020,
+        verifyingContract: '0x3b3adf1422f84254b7fbb0e7ca62bd0865133fe3',
+    },
+    collectionOfferDomain: {
+        name: 'CollectionOffer',
+        version: '1',
+        chainId: 2020,
+        verifyingContract: '0x3ef234bc2a04d86f6041e419458d9acbd077f2c1',
+    },
+    rnsAddress: '0x67c409dab0ee741a1b1be874bd1333234cfdbf44',
+};
+const testnetConfig = {
+    rpcEndpoint: 'https://saigon-testnet.roninchain.com/rpc',
+    chainId: 202601,
+    chainName: 'Saigon Testnet',
+    contractsAddress: {
+        katana: '0xDa44546C0715ae78D454fE8B84f0235081584Fe0',
+        marketGateway: '0x2488a13a4d635b0bacf7ef59911e54efeaf573eb',
+        marketGatewayMultisend: '0x5079b2672284570d3f56b7244f5da109c782f940',
+        multiCall: '0x31c9ef8a631e2489e69833df3b2cb4bf0dc413bc',
+        collectionOffer: '0x600d33dbf78a97c1b6a02efbebcbd7f83a04acc5',
+        royaltyRegistry: '0x7249a5d0375800189bba9dc38e7d8f613fe1c57d',
+    },
+    marketGatewayDomain: {
+        name: 'MarketGateway',
+        version: '1',
+        chainId: 202601,
+        verifyingContract: '0x2488a13a4d635b0bacf7ef59911e54efeaf573eb',
+    },
+    collectionOfferDomain: {
+        name: 'CollectionOffer',
+        version: '1',
+        chainId: 202601,
+        verifyingContract: '0x600d33dbf78a97c1b6a02efbebcbd7f83a04acc5',
+    },
+    rnsAddress: '0xf0c99c9677eda0d13291c093b27e6512e4acdf83',
+};
+const spenderContractMainnetConfig = {
+    [index.SpenderContractType.MarketGatewayContract]: mainnetConfig.contractsAddress.marketGateway,
+    [index.SpenderContractType.MarketGatewayMultiSendContract]: mainnetConfig.contractsAddress.marketGatewayMultisend,
+};
+const spenderContractTestnetConfig = {
+    [index.SpenderContractType.MarketGatewayContract]: testnetConfig.contractsAddress.marketGateway,
+    [index.SpenderContractType.MarketGatewayMultiSendContract]: testnetConfig.contractsAddress.marketGatewayMultisend,
+};
+const getConfig = (chainId) => {
+    if (chainId === index.ChainId.testnet) {
+        return testnetConfig;
+    }
+    return mainnetConfig;
+};
+const getSpenderContractConfig = (chainId) => {
+    if (chainId === index.ChainId.testnet) {
+        return spenderContractTestnetConfig;
+    }
+    return spenderContractMainnetConfig;
+};
+
+exports.getConfig = getConfig;
+exports.getSpenderContractConfig = getSpenderContractConfig;
+exports.mainnetConfig = mainnetConfig;
+exports.spenderContractMainnetConfig = spenderContractMainnetConfig;
+exports.spenderContractTestnetConfig = spenderContractTestnetConfig;
+exports.testnetConfig = testnetConfig;

package/dist/cjs/contracts/BaseContract.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var ethers = require('ethers');
+var index = require('../configs/index.js');
+var multicall = require('./abis/multicall.json.js');
+
+class BaseContract extends ethers.BaseContract {
+    async sendMultiCallRequest(encodedFunctions, chainId) {
+        try {
+            const multiCallInterface = new ethers.ethers.utils.Interface(multicall.default);
+            const data = multiCallInterface.encodeFunctionData('aggregate', [encodedFunctions]);
+            const config = index.getConfig(chainId);
+            const readProvider = new ethers.ethers.providers.StaticJsonRpcProvider(config.rpcEndpoint, chainId);
+            const response = await readProvider.call({ to: config.contractsAddress.multiCall, data });
+            return multiCallInterface.decodeFunctionResult('aggregate', response)._returnData;
+        }
+        catch (error) {
+            throw new Error(error.message || error);
+        }
+    }
+}
+
+exports.BaseContract = BaseContract;

package/dist/cjs/contracts/KatanaContract.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var BaseContract = require('./BaseContract.js');
+
+class KatanaContract extends BaseContract.BaseContract {
+    async getAmountsInMultiCall(data, chainId) {
+        try {
+            const encodedRequests = data.reduce((returnedData, currentValue) => {
+                const { amount, path } = currentValue;
+                const encodedData = this.interface.encodeFunctionData('getAmountsIn', [amount, path]);
+                return [...returnedData, [this.address, encodedData]];
+            }, []);
+            const results = await this.sendMultiCallRequest(encodedRequests, chainId);
+            return data.map((_, index) => {
+                const decodedData = this.interface.decodeFunctionResult('getAmountsIn', results[index]);
+                return decodedData[0][0];
+            });
+        }
+        catch (error) {
+            throw new Error(error.message || error);
+        }
+    }
+}
+
+exports.KatanaContract = KatanaContract;