perps-sdk-ts 1.0.1

package/src/rpc/snapshot.ts

@@ -0,0 +1,210 @@
+import { Contract, Provider } from 'ethers';
+import { Snapshot, Group, PairData, PairsBackendReturn, fromBlockchain10, fromBlockchain6, fromBlockchain12 } from '../types';
+import { PairsCache } from './pairs_cache';
+import { AssetParametersRPC } from './asset_parameters';
+import { CategoryParametersRPC } from './category_parameters';
+import { FeeParametersRPC } from './fee_parameters';
+import { BlendedRPC } from './blended';
+
+/**
+ * RPC module for aggregating all market data into a snapshot
+ * Optimized to use getPairBackend() to reduce duplicate contract calls
+ */
+export class SnapshotRPC {
+  private pairsCache: PairsCache;
+  private assetParams: AssetParametersRPC;
+  private categoryParams: CategoryParametersRPC;
+  private feeParams: FeeParametersRPC;
+  private blendedParams: BlendedRPC;
+
+  constructor(
+    pairsCache: PairsCache,
+    assetParams: AssetParametersRPC,
+    categoryParams: CategoryParametersRPC,
+    feeParams: FeeParametersRPC,
+    blendedParams: BlendedRPC
+  ) {
+    this.pairsCache = pairsCache;
+    this.assetParams = assetParams;
+    this.categoryParams = categoryParams;
+    this.feeParams = feeParams;
+    this.blendedParams = blendedParams;
+  }
+
+  /**
+   * Get comprehensive market snapshot with all data
+   * Optimized to use getPairBackend() to reduce contract calls
+   * @returns Snapshot object containing all market parameters
+   */
+  async getSnapshot(): Promise<Snapshot> {
+    console.log('Fetching market snapshot (optimized)...');
+
+    // Get basic pair info first to know how many pairs exist
+    const pairs = await this.pairsCache.getPairsInfo();
+    const pairIndices = Array.from(pairs.keys());
+
+    // Fetch all pair backend data in parallel (includes pair config, group info, and fees)
+    const pairBackendPromises = pairIndices.map(idx => this.pairsCache.getPairBackend(idx));
+
+    // Fetch only the dynamic data that changes (OI, utilization, skew, depth)
+    // Note: Category-level metrics may not be available if contract methods don't exist
+    const [
+      pairBackendData,
+      assetOI,
+      assetUtilization,
+      assetSkew,
+      blendedUtilization,
+      blendedSkew,
+      depth,
+    ] = await Promise.all([
+      Promise.all(pairBackendPromises),
+      this.assetParams.getOI(),
+      this.assetParams.getUtilization(),
+      this.assetParams.getAssetSkew(),
+      this.blendedParams.getBlendedUtilization(),
+      this.blendedParams.getBlendedSkew(),
+      this.assetParams.getOnePercentDepth(),
+    ]);
+
+    // Try to get category data, but don't fail if it's not available
+    let categoryOI = new Map();
+    let categoryUtilization = new Map();
+    let categorySkew = new Map();
+
+    try {
+      categoryOI = await this.categoryParams.getOI();
+      categoryUtilization = await this.categoryParams.getUtilization();
+      categorySkew = await this.categoryParams.getCategorySkew();
+    } catch (error) {
+      console.warn('Category-level metrics not available:', error);
+    }
+
+    // Build a map of pairIndex -> backend data
+    const backendDataMap = new Map<number, PairsBackendReturn>();
+    pairIndices.forEach((idx, i) => {
+      backendDataMap.set(idx, pairBackendData[i]);
+    });
+
+    // Build a map of groupIndex -> group info (from backend data)
+    const groupInfoMap = new Map<number, { name: string; maxOpenInterestP: bigint; isSpreadDynamic: boolean }>();
+    pairBackendData.forEach(data => {
+      const groupIdx = Number(data.pair.groupIndex);
+      if (!groupInfoMap.has(groupIdx)) {
+        groupInfoMap.set(groupIdx, data.group);
+      }
+    });
+
+    // Build snapshot structure
+    const snapshot: Snapshot = {
+      groups: {},
+    };
+
+    // Group pairs by category
+    for (const [groupIndex, groupInfo] of groupInfoMap) {
+      const group: Group = {
+        groupIndex,
+        pairs: {},
+        openInterest: categoryOI.get(groupIndex),
+        utilization: categoryUtilization.get(groupIndex),
+        skew: categorySkew.get(groupIndex),
+      };
+
+      // Get all pairs in this group
+      const pairsInGroup = pairIndices.filter(idx => {
+        const backend = backendDataMap.get(idx);
+        return backend && Number(backend.pair.groupIndex) === groupIndex;
+      });
+
+      for (const pairIndex of pairsInGroup) {
+        const pairInfo = pairs.get(pairIndex);
+        const backend = backendDataMap.get(pairIndex);
+        if (!pairInfo || !backend) continue;
+
+        const pairName = `${pairInfo.from}/${pairInfo.to}`;
+
+        // Extract fee data from backend (no separate call needed)
+        const feeData = {
+          feeP: fromBlockchain12(backend.fee.openFeeP), // Using openFeeP as the main fee
+        };
+
+        const pairData: PairData = {
+          pairInfo,
+          openInterest: assetOI.get(pairIndex),
+          utilization: blendedUtilization.get(pairIndex),
+          skew: blendedSkew.get(pairIndex),
+          fee: feeData,
+          depth: {
+            onePercentDepthAboveUsdc: depth.get(pairIndex)?.above || 0,
+            onePercentDepthBelowUsdc: depth.get(pairIndex)?.below || 0,
+          },
+          spread: fromBlockchain10(backend.pair.spreadP), // Use spread from backend
+        };
+
+        group.pairs[pairName] = pairData;
+      }
+
+      snapshot.groups[`group_${groupIndex}`] = group;
+    }
+
+    console.log('Market snapshot complete (optimized)');
+    return snapshot;
+  }
+
+  /**
+   * Get snapshot for a specific group
+   * @param groupIndex - Group index
+   * @returns Group data
+   */
+  async getGroupSnapshot(groupIndex: number): Promise<Group | undefined> {
+    const snapshot = await this.getSnapshot();
+    return snapshot.groups[`group_${groupIndex}`];
+  }
+
+  /**
+   * Get snapshot for a specific pair
+   * @param pairName - Pair name (e.g., "BTC/USD")
+   * @returns Pair data
+   */
+  async getPairSnapshot(pairName: string): Promise<PairData | undefined> {
+    const snapshot = await this.getSnapshot();
+
+    // Find the pair in all groups
+    for (const group of Object.values(snapshot.groups)) {
+      if (group.pairs[pairName]) {
+        return group.pairs[pairName];
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get full backend data for a specific pair (includes all pair config, group, and fee info)
+   * This provides more detailed information than the standard snapshot
+   * @param pairIndex - Pair index
+   * @returns Complete backend data for the pair
+   */
+  async getPairFullData(pairIndex: number): Promise<PairsBackendReturn> {
+    return await this.pairsCache.getPairBackend(pairIndex);
+  }
+
+  /**
+   * Get full backend data for all pairs
+   * Useful for getting complete configuration data in one call
+   * @returns Map of pair index to full backend data
+   */
+  async getAllPairsFullData(): Promise<Map<number, PairsBackendReturn>> {
+    const pairs = await this.pairsCache.getPairsInfo();
+    const pairIndices = Array.from(pairs.keys());
+
+    const backendDataPromises = pairIndices.map(idx => this.pairsCache.getPairBackend(idx));
+    const backendData = await Promise.all(backendDataPromises);
+
+    const dataMap = new Map<number, PairsBackendReturn>();
+    pairIndices.forEach((idx, i) => {
+      dataMap.set(idx, backendData[i]);
+    });
+
+    return dataMap;
+  }
+}

package/src/rpc/trade.ts

@@ -0,0 +1,306 @@
+import { Contract, ethers, Provider, TransactionRequest } from 'ethers';
+import {
+  TradeInput,
+  TradeResponse,
+  MarginUpdateType,
+  toBlockchain6,
+  toBlockchain10,
+  fromBlockchain6,
+  fromBlockchain10,
+} from '../types';
+import { PairsCache } from './pairs_cache';
+
+/**
+ * RPC module for trading operations
+ */
+export class TradeRPC {
+  private provider: Provider;
+  private tradingContract: Contract;
+  private tradingStorageContract: Contract;
+  private pairsCache: PairsCache;
+
+  constructor(
+    provider: Provider,
+    tradingContract: Contract,
+    tradingStorageContract: Contract,
+    pairsCache: 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: TradeInput, trader:string): Promise<TransactionRequest> {
+    // 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 = toBlockchain10(tradeInput.sl);
+   console.log("sl", sl);
+   const tp = toBlockchain10(tradeInput.tp);
+    console.log("tp", tp);
+   const leverage = toBlockchain10(tradeInput.leverage);
+    console.log("leverage", leverage);
+   const openPrice = toBlockchain10(tradeInput.openPrice);
+    console.log("openPrice", openPrice);
+   // positionSizeUSDC is actually the collateral amount, not position size
+   const positionSizeUsdc = 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 = toBlockchain10(tradeInput.maxSlippageP);
+    console.log("slippageP", slippageP);
+    // const executionFee = await this.getTradeExecutionFee();
+const value = 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: TradeInput,
+    trader: string
+  ): Promise<TransactionRequest> {
+    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: number,
+    tradeIndex: number
+  ): Promise<TransactionRequest> {
+    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: number,
+    tradeIndex: number,
+    trader: string
+  ): Promise<TransactionRequest> {
+    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: number,
+    orderIndex: number
+  ): Promise<TransactionRequest> {
+    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: number,
+    tradeIndex: number,
+    marginDelta: number,
+    updateType: MarginUpdateType
+  ): Promise<TransactionRequest> {
+    const isDeposit = updateType === MarginUpdateType.DEPOSIT;
+
+    return {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('updateMargin', [
+        pairIndex,
+        tradeIndex,
+        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: number,
+    tradeIndex: number,
+    tp: number,
+    sl: number
+  ): Promise<TransactionRequest> {
+    return {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('updateTpSl', [
+        pairIndex,
+        tradeIndex,
+        toBlockchain10(tp),
+        toBlockchain10(sl),
+      ]),
+    };
+  }
+
+  /**
+   * Get trade execution fee
+   * @returns Execution fee in native token (wei)
+   */
+  async getTradeExecutionFee(): Promise<bigint> {
+    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: string, maxPairs: number = 100): Promise<TradeResponse[]> {
+    try {
+      const trades: TradeResponse[] = [];
+
+      // Check pairs concurrently for better performance
+      const pairPromises: Promise<void>[] = [];
+
+      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: fromBlockchain6(trade.initialPosToken || trade.positionSizeUSDC),
+                        openPrice: fromBlockchain10(trade.openPrice),
+                        buy: trade.buy,
+                        leverage: Number(fromBlockchain10(trade.leverage)),
+                        tp: fromBlockchain10(trade.tp),
+                        sl: 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
+   */
+  private getOrderTypeValue(orderType: string): number {
+    const orderTypes: Record<string, number> = {
+      market: 0,
+      limit: 1,
+      stop_limit: 2,
+      market_zero_fee: 3,
+    };
+    return orderTypes[orderType] || 0;
+  }
+}