Order book

Functionality to interact with an order book contract

Place limit buy

To place a limit buy order. We use KuruSdk.GTC.placeLimit()

placeLimitBuy.ts

import { ethers } from "ethers";
import * as KuruSdk from "../../src";
import * as KuruConfig from "../config.json";
import { parseEvents } from "../parseEvents.ts"
 
const { rpcUrl } = KuruConfig;
const marketAddress = <your_market_address>; // market address
 
const privateKey = process.env.PRIVATE_KEY as string;
 
const price = 135.50; // Price in quoteAsset (ex:USDC)
const size = 10; // Size in baseAsset (ex:MON)
 
(async () => {
    const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
    const signer = new ethers.Wallet(privateKey, provider);
 
    const marketParams = await KuruSdk.ParamFetcher.getMarketParams( 
        provider, 
        marketAddress
    );
 
    try { 
        const receipt = await KuruSdk.GTC.placeLimit(   
            signer,   
            marketAddress,   
            marketParams,   
            {   
                price,   
                size,   
                isBuy: true,   
                postOnly: true
            }   
        );   
        console.log("Transaction hash:", receipt.transactionHash); 
        const { newOrderIds } = await parseEvents(receipt)  
        console.log("OrderIds:", newOrderIds)  
    } catch (error) {
        console.error("Error placing limit buy order:", error);
    }
})();

Cancel order

To cancel orders using the Kuru SDK. We use KuruSdk.OrderCanceler.cancelOrders()

import { ethers, BigNumber } from "ethers";
import * as KuruSdk from "../../src";
 
const { rpcUrl } = KuruConfig;
const marketAddress = <your_market_address>; // Market address
 
const privateKey = process.env.PRIVATE_KEY as string;
 
const orderIds = <listOfOrderIds>; // List of order ids to cancel
 
(async () => {
	const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
    const signer = new ethers.Wallet(privateKey, provider);
 
    try {
        const txReceipt = await KuruSdk.OrderCanceler.cancelOrders( 
            signer, 
            marketAddress,  
            orderIds.map(orderId => BigNumber.from(parseInt(orderId)))  
        );
 
        console.log("Transaction hash:", txReceipt.transactionHash);
    } catch (err: any) {
        console.error("Error:", err);
    }
})();

Market buy order

To perform a market buy. We use KuruSdk.IOC.placeMarket()

import { ethers, BigNumber } from "ethers";
import * as KuruSdk from "../../src";
 
const { rpcUrl } = KuruConfig;
const marketAddress = <your_market_address>; // Market address
 
const privateKey = process.env.PRIVATE_KEY as string;
 
const size = 100; // Size in quoteAsset (ex:USDC)
const minAmountOut = 10; // Minimum amount of baseAsset to receive (ex:MON)
 
(async () => {
    const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
    const signer = new ethers.Wallet(privateKey, provider);
 
    try {
        const marketParams = await KuruSdk.ParamFetcher.getMarketParams(
            provider,
            marketAddress
        );
 
        const receipt = await KuruSdk.IOC.placeMarket(signer, marketAddress, marketParams, {    
            approveTokens: true,    
            size,    
            isBuy: true,    
            minAmountOut,    
            isMargin: false,    
            fillOrKill: true,    
        });    
        console.log("Transaction hash:", receipt.transactionHash);
    } catch (error) {
        console.error("Error placing market buy order:", error);
    }
})();

Estimate buy

To estimate the baseAsset received for a buy order with X amount of quoteAsset. We use KuruSdk.CostEstimator.estimateMarketBuy()

import { ethers } from "ethers";
import * as KuruSdk from "../../src";
 
const { rpcUrl } = KuruConfig;
const marketAddress = <your_market_address>; // Market address
 
const amount = 100; // Amount of quoteAsset to spend (ex:USDC)
 
(async () => {
    const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
 
    const marketParams = await KuruSdk.ParamFetcher.getMarketParams(provider, marketAddress);
 
	try {   
		const estimate = await KuruSdk.CostEstimator.estimateMarketBuy( 
			provider,   
			marketAddress,  
			marketParams,   
			amount  
		);  
		console.log(estimate); 
	} catch (error) {
		console.error("Error estimating market buy:", error);
	}
})();

Estimate base for sell

To estimate the required baseAsset for a sell order to get X amount of quoteAsset. We use KuruSdk.CostEstimator.estimateRequiredBaseForSell()

import { ethers } from "ethers";
import * as KuruSdk from "../../src";
import orderbookAbi from "../../abi/OrderBook.json";
 
const { rpcUrl } = KuruConfig;
const marketAddress = <your_market_address>; // Market address
 
(async () => {
    const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
 
    const marketParams = await KuruSdk.ParamFetcher.getMarketParams(provider, marketAddress);
 
    const orderbook = new ethers.Contract(marketAddress, orderbookAbi.abi, provider);   
    const l2Book = await orderbook.getL2Book(); 
    const vaultParams = await orderbook.getVaultParams();   
    
 
	try {   
		const estimate = await KuruSdk.CostEstimator.estimateRequiredBaseForSell(   
			provider,   
			marketAddress,  
			marketParams,   
			amount, 
			l2Book, 
			vaultParams 
		);  
		console.log(estimate);  
	} catch (error) {
		console.error("Error estimating required base for sell:", error);
	}
})();