perps-sdk-ts 1.0.1

package/dist/rpc/trade.d.ts

@@ -0,0 +1,84 @@
+import { Contract, Provider, TransactionRequest } from 'ethers';
+import { TradeInput, TradeResponse, MarginUpdateType } from '../types';
+import { PairsCache } from './pairs_cache';
+/**
+ * RPC module for trading operations
+ */
+export declare class TradeRPC {
+    private provider;
+    private tradingContract;
+    private tradingStorageContract;
+    private pairsCache;
+    constructor(provider: Provider, tradingContract: Contract, tradingStorageContract: Contract, pairsCache: PairsCache);
+    /**
+     * Build transaction to open a trade
+     * @param tradeInput - Trade input parameters
+     * @returns Transaction request
+     */
+    buildTradeOpenTx(tradeInput: TradeInput, trader: string): Promise<TransactionRequest>;
+    /**
+     * Build transaction to open a trade via delegation
+     * @param tradeInput - Trade input parameters
+     * @param trader - Trader address
+     * @returns Transaction request
+     */
+    buildTradeOpenTxDelegate(tradeInput: TradeInput, trader: string): Promise<TransactionRequest>;
+    /**
+     * Build transaction to close a trade
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @returns Transaction request
+     */
+    buildTradeCloseTx(pairIndex: number, tradeIndex: number): Promise<TransactionRequest>;
+    /**
+     * Build transaction to close a trade via delegation
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @param trader - Trader address
+     * @returns Transaction request
+     */
+    buildTradeCloseTxDelegate(pairIndex: number, tradeIndex: number, trader: string): Promise<TransactionRequest>;
+    /**
+     * Build transaction to cancel a pending order
+     * @param pairIndex - Pair index
+     * @param orderIndex - Order index
+     * @returns Transaction request
+     */
+    buildOrderCancelTx(pairIndex: number, orderIndex: number): Promise<TransactionRequest>;
+    /**
+     * Build transaction to update trade margin
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @param marginDelta - Margin change amount (USDC)
+     * @param updateType - Deposit or withdraw
+     * @returns Transaction request
+     */
+    buildTradeMarginUpdateTx(pairIndex: number, tradeIndex: number, marginDelta: number, updateType: MarginUpdateType): Promise<TransactionRequest>;
+    /**
+     * Build transaction to update take profit and stop loss
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @param tp - Take profit price
+     * @param sl - Stop loss price
+     * @returns Transaction request
+     */
+    buildTradeTpSlUpdateTx(pairIndex: number, tradeIndex: number, tp: number, sl: number): Promise<TransactionRequest>;
+    /**
+     * Get trade execution fee
+     * @returns Execution fee in native token (wei)
+     */
+    getTradeExecutionFee(): Promise<bigint>;
+    /**
+     * Get all trades for a trader
+     * @param traderAddress - Trader address
+     * @param maxPairs - Maximum pair indices to check (default: 100)
+     * @returns Array of trades
+     */
+    getTrades(traderAddress: string, maxPairs?: number): Promise<TradeResponse[]>;
+    /**
+     * Convert order type string to numeric value
+     * @param orderType - Order type string
+     * @returns Numeric order type
+     */
+    private getOrderTypeValue;
+}

package/dist/rpc/trade.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeRPC = void 0;
+const ethers_1 = require("ethers");
+const types_1 = require("../types");
+/**
+ * RPC module for trading operations
+ */
+class TradeRPC {
+    constructor(provider, tradingContract, tradingStorageContract, pairsCache) {
+        this.provider = provider;
+        this.tradingContract = tradingContract;
+        this.tradingStorageContract = tradingStorageContract;
+        this.pairsCache = pairsCache;
+    }
+    /**
+     * Build transaction to open a trade
+     * @param tradeInput - Trade input parameters
+     * @returns Transaction request
+     */
+    async buildTradeOpenTx(tradeInput, trader) {
+        // const pairIndex = await this.pairsCache.getPairIndex(tradeInput.pair);
+        const pairIndex = 1;
+        console.log("pairIndex", pairIndex);
+        if (pairIndex === undefined) {
+            throw new Error(`Pair ${tradeInput.pair} not found`);
+        }
+        const sl = (0, types_1.toBlockchain10)(tradeInput.sl);
+        console.log("sl", sl);
+        const tp = (0, types_1.toBlockchain10)(tradeInput.tp);
+        console.log("tp", tp);
+        const leverage = (0, types_1.toBlockchain10)(tradeInput.leverage);
+        console.log("leverage", leverage);
+        const openPrice = (0, types_1.toBlockchain10)(tradeInput.openPrice);
+        console.log("openPrice", openPrice);
+        // positionSizeUSDC is actually the collateral amount, not position size
+        const positionSizeUsdc = (0, types_1.toBlockchain6)(tradeInput.collateralInTrade);
+        console.log("positionSizeUsdc", positionSizeUsdc);
+        const trade = {
+            trader,
+            pairIndex: pairIndex,
+            index: 0,
+            initialPosToken: 0,
+            positionSizeUSDC: positionSizeUsdc,
+            openPrice: openPrice,
+            buy: tradeInput.isLong,
+            leverage: leverage,
+            tp: tp,
+            sl: sl,
+            timestamp: 0,
+        };
+        console.log("trade", trade);
+        const orderType = this.getOrderTypeValue(tradeInput.orderType);
+        console.log("orderType", orderType);
+        const slippageP = (0, types_1.toBlockchain10)(tradeInput.maxSlippageP);
+        console.log("slippageP", slippageP);
+        // const executionFee = await this.getTradeExecutionFee();
+        const value = ethers_1.ethers.parseEther("0.00035");
+        console.log("execution fee (wei)", value);
+        return {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('openTrade', [
+                trade,
+                orderType,
+                slippageP,
+                // tradeInput.referrer || '0x0000000000000000000000000000000000000000',
+            ]),
+            value: value,
+        };
+    }
+    /**
+     * Build transaction to open a trade via delegation
+     * @param tradeInput - Trade input parameters
+     * @param trader - Trader address
+     * @returns Transaction request
+     */
+    async buildTradeOpenTxDelegate(tradeInput, trader) {
+        const tx = await this.buildTradeOpenTx(tradeInput, trader);
+        // Add delegation logic if needed
+        return tx;
+    }
+    /**
+     * Build transaction to close a trade
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @returns Transaction request
+     */
+    async buildTradeCloseTx(pairIndex, tradeIndex) {
+        return {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('closeTradeMarket', [
+                pairIndex,
+                tradeIndex,
+            ]),
+        };
+    }
+    /**
+     * Build transaction to close a trade via delegation
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @param trader - Trader address
+     * @returns Transaction request
+     */
+    async buildTradeCloseTxDelegate(pairIndex, tradeIndex, trader) {
+        const tx = await this.buildTradeCloseTx(pairIndex, tradeIndex);
+        // Add delegation logic if needed
+        return tx;
+    }
+    /**
+     * Build transaction to cancel a pending order
+     * @param pairIndex - Pair index
+     * @param orderIndex - Order index
+     * @returns Transaction request
+     */
+    async buildOrderCancelTx(pairIndex, orderIndex) {
+        return {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('cancelOpenOrder', [
+                pairIndex,
+                orderIndex,
+            ]),
+        };
+    }
+    /**
+     * Build transaction to update trade margin
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @param marginDelta - Margin change amount (USDC)
+     * @param updateType - Deposit or withdraw
+     * @returns Transaction request
+     */
+    async buildTradeMarginUpdateTx(pairIndex, tradeIndex, marginDelta, updateType) {
+        const isDeposit = updateType === types_1.MarginUpdateType.DEPOSIT;
+        return {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('updateMargin', [
+                pairIndex,
+                tradeIndex,
+                (0, types_1.toBlockchain6)(marginDelta),
+                isDeposit,
+            ]),
+        };
+    }
+    /**
+     * Build transaction to update take profit and stop loss
+     * @param pairIndex - Pair index
+     * @param tradeIndex - Trade index
+     * @param tp - Take profit price
+     * @param sl - Stop loss price
+     * @returns Transaction request
+     */
+    async buildTradeTpSlUpdateTx(pairIndex, tradeIndex, tp, sl) {
+        return {
+            to: await this.tradingContract.getAddress(),
+            data: this.tradingContract.interface.encodeFunctionData('updateTpSl', [
+                pairIndex,
+                tradeIndex,
+                (0, types_1.toBlockchain10)(tp),
+                (0, types_1.toBlockchain10)(sl),
+            ]),
+        };
+    }
+    /**
+     * Get trade execution fee
+     * @returns Execution fee in native token (wei)
+     */
+    async getTradeExecutionFee() {
+        try {
+            return await this.tradingContract.getExecutionFee();
+        }
+        catch (error) {
+            console.error('Error getting execution fee:', error);
+            return BigInt(0);
+        }
+    }
+    /**
+     * Get all trades for a trader
+     * @param traderAddress - Trader address
+     * @param maxPairs - Maximum pair indices to check (default: 100)
+     * @returns Array of trades
+     */
+    async getTrades(traderAddress, maxPairs = 100) {
+        try {
+            const trades = [];
+            // Check pairs concurrently for better performance
+            const pairPromises = [];
+            for (let pairIndex = 0; pairIndex < maxPairs; pairIndex++) {
+                const pairPromise = (async () => {
+                    try {
+                        // Get the count of trades for this trader on this pair
+                        const count = await this.tradingStorageContract.openTradesCount(traderAddress, pairIndex);
+                        if (count === 0n || count === 0)
+                            return;
+                        // Fetch all trades for this pair
+                        const tradePromises = [];
+                        for (let index = 0; index < Number(count); index++) {
+                            tradePromises.push(this.tradingStorageContract.openTrades(traderAddress, pairIndex, index)
+                                .then((trade) => {
+                                // Only add if the trade exists (leverage > 0)
+                                if (trade.leverage > 0) {
+                                    trades.push({
+                                        trader: trade.trader,
+                                        pairIndex: Number(trade.pairIndex),
+                                        index: Number(trade.index),
+                                        initialPosUsdc: (0, types_1.fromBlockchain6)(trade.initialPosToken || trade.positionSizeUSDC),
+                                        openPrice: (0, types_1.fromBlockchain10)(trade.openPrice),
+                                        buy: trade.buy,
+                                        leverage: Number((0, types_1.fromBlockchain10)(trade.leverage)),
+                                        tp: (0, types_1.fromBlockchain10)(trade.tp),
+                                        sl: (0, types_1.fromBlockchain10)(trade.sl),
+                                    });
+                                }
+                            })
+                                .catch(() => {
+                                // Skip if trade doesn't exist at this index
+                            }));
+                        }
+                        await Promise.all(tradePromises);
+                    }
+                    catch (err) {
+                        // Skip if no trades for this pair
+                    }
+                })();
+                pairPromises.push(pairPromise);
+            }
+            await Promise.all(pairPromises);
+            return trades;
+        }
+        catch (error) {
+            console.error('Error getting trades:', error);
+            return [];
+        }
+    }
+    /**
+     * Convert order type string to numeric value
+     * @param orderType - Order type string
+     * @returns Numeric order type
+     */
+    getOrderTypeValue(orderType) {
+        const orderTypes = {
+            market: 0,
+            limit: 1,
+            stop_limit: 2,
+            market_zero_fee: 3,
+        };
+        return orderTypes[orderType] || 0;
+    }
+}
+exports.TradeRPC = TradeRPC;

package/dist/rpc/trading_operations.d.ts

@@ -0,0 +1,103 @@
+import { Contract, TransactionReceipt } from 'ethers';
+import { Trade, TradeInfo, OpenLimitOrder, TradeInputOrderType, MarginUpdateType } from '../types';
+import { BaseSigner } from '../signers/base';
+/**
+ * Trading Operations RPC
+ * Handles all trading contract interactions including opening/closing trades,
+ * updating margins, and managing limit orders.
+ */
+export declare class TradingOperationsRPC {
+    private tradingContract;
+    private tradingStorageContract;
+    private signer?;
+    constructor(tradingContract: Contract, tradingStorageContract: Contract, signer?: BaseSigner | undefined);
+    /**
+     * Get execution fee required for trading operations
+     * @returns Execution fee in ETH
+     */
+    getExecutionFee(): Promise<number>;
+    /**
+     * Open a new trade position
+     * @param trade - Trade parameters
+     * @param orderType - Order type (MARKET, LIMIT, etc.)
+     * @param slippageP - Slippage percentage (e.g., 1 for 1%)
+     * @param executionFeeEth - Execution fee in ETH (optional, will fetch if not provided)
+     * @returns Transaction receipt
+     */
+    openTrade(trade: Omit<Trade, 'timestamp'>, orderType: TradeInputOrderType, slippageP: number, executionFeeEth?: number): Promise<TransactionReceipt | null>;
+    /**
+     * Close a trade position at market price
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @param closeAmount - Amount of collateral to close (USDC)
+     * @param executionFeeEth - Execution fee in ETH (optional)
+     * @returns Transaction receipt
+     */
+    closeTradeMarket(pairIndex: number, index: number, closeAmount: number, executionFeeEth?: number): Promise<TransactionReceipt | null>;
+    /**
+     * Update margin for an existing trade
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @param updateType - DEPOSIT or WITHDRAW
+     * @param amount - Amount to add/remove (USDC)
+     * @param priceUpdateData - Price oracle update data
+     * @returns Transaction receipt
+     */
+    updateMargin(pairIndex: number, index: number, updateType: MarginUpdateType, amount: number, priceUpdateData?: string[]): Promise<TransactionReceipt | null>;
+    /**
+     * Update take profit and stop loss for a trade
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @param newSl - New stop loss price
+     * @param newTp - New take profit price
+     * @param priceUpdateData - Price oracle update data
+     * @returns Transaction receipt
+     */
+    updateTpAndSl(pairIndex: number, index: number, newSl: number, newTp: number, priceUpdateData?: string[]): Promise<TransactionReceipt | null>;
+    /**
+     * Cancel a pending limit order
+     * @param pairIndex - Trading pair index
+     * @param index - Order index
+     * @returns Transaction receipt
+     */
+    cancelOpenLimitOrder(pairIndex: number, index: number): Promise<TransactionReceipt | null>;
+    /**
+     * Get open trade information
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @returns Trade information
+     */
+    getOpenTrade(trader: string, pairIndex: number, index: number): Promise<Trade>;
+    /**
+     * Get additional trade information
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @param index - Trade index
+     * @returns Trade info
+     */
+    getOpenTradeInfo(trader: string, pairIndex: number, index: number): Promise<TradeInfo>;
+    /**
+     * Get number of open trades for a trader on a pair
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @returns Number of open trades
+     */
+    getOpenTradesCount(trader: string, pairIndex: number): Promise<number>;
+    /**
+     * Get limit order information
+     * @param trader - Trader address
+     * @param pairIndex - Trading pair index
+     * @param index - Order index
+     * @returns Limit order information
+     */
+    getOpenLimitOrder(trader: string, pairIndex: number, index: number): Promise<OpenLimitOrder>;
+    /**
+     * Helper method to sign and send transactions
+     */
+    private signAndSend;
+    /**
+     * Set signer for transactions
+     */
+    setSigner(signer: BaseSigner): void;
+}