perps-sdk-ts 1.0.1

package/src/rpc/trading_operations.ts

@@ -0,0 +1,378 @@
+import { Contract, TransactionReceipt, TransactionRequest } from 'ethers';
+import {
+  Trade,
+  TradeInfo,
+  OpenLimitOrder,
+  TradeInputOrderType,
+  MarginUpdateType,
+  toBlockchain6,
+  toBlockchain10,
+  toBlockchain18,
+  fromBlockchain6,
+  fromBlockchain10,
+  fromBlockchain18,
+} 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 class TradingOperationsRPC {
+  constructor(
+    private tradingContract: Contract,
+    private tradingStorageContract: Contract,
+    private signer?: BaseSigner
+  ) {}
+
+  /**
+   * Get execution fee required for trading operations
+   * @returns Execution fee in ETH
+   */
+  async getExecutionFee(): Promise<number> {
+    const fee = await this.tradingContract.getExecutionFee();
+    return fromBlockchain18(fee);
+  }
+
+  /**
+   * 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
+   */
+  async openTrade(
+    trade: Omit<Trade, 'timestamp'>,
+    orderType: TradeInputOrderType,
+    slippageP: number,
+    executionFeeEth?: number
+  ): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for trading operations');
+    }
+
+    // Get execution fee if not provided
+    if (!executionFeeEth) {
+      executionFeeEth = await this.getExecutionFee();
+    }
+
+    // Convert order type to number
+    const orderTypeMap: Record<TradeInputOrderType, number> = {
+      [TradeInputOrderType.MARKET]: 0,
+      [TradeInputOrderType.STOP_LIMIT]: 1,
+      [TradeInputOrderType.LIMIT]: 2,
+      [TradeInputOrderType.MARKET_ZERO_FEE]: 3,
+    };
+
+    // Prepare trade struct with blockchain values
+    const tradeStruct = {
+      trader: trade.trader,
+      pairIndex: trade.pairIndex,
+      index: trade.index,
+      initialPosToken: toBlockchain6(trade.initialPosToken),
+      positionSizeUSDC: toBlockchain6(trade.positionSizeUSDC),
+      openPrice: toBlockchain10(trade.openPrice),
+      buy: trade.buy,
+      leverage: toBlockchain10(trade.leverage),
+      tp: toBlockchain10(trade.tp),
+      sl: toBlockchain10(trade.sl),
+      timestamp: Math.floor(Date.now() / 1000),
+    };
+
+    const slippageBlockchain = toBlockchain10(slippageP);
+    const executionFeeWei = toBlockchain18(executionFeeEth);
+
+    // Create transaction
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('openTrade', [
+        tradeStruct,
+        orderTypeMap[orderType],
+        slippageBlockchain,
+      ]),
+      value: executionFeeWei,
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * 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
+   */
+  async closeTradeMarket(
+    pairIndex: number,
+    index: number,
+    closeAmount: number,
+    executionFeeEth?: number
+  ): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for trading operations');
+    }
+
+    if (!executionFeeEth) {
+      executionFeeEth = await this.getExecutionFee();
+    }
+
+    const closeAmountBlockchain = toBlockchain6(closeAmount);
+    const executionFeeWei = toBlockchain18(executionFeeEth);
+
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('closeTradeMarket', [
+        pairIndex,
+        index,
+        closeAmountBlockchain,
+      ]),
+      value: executionFeeWei,
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * 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
+   */
+  async updateMargin(
+    pairIndex: number,
+    index: number,
+    updateType: MarginUpdateType,
+    amount: number,
+    priceUpdateData: string[] = []
+  ): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for trading operations');
+    }
+
+    const amountBlockchain = toBlockchain6(amount);
+
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('updateMargin', [
+        pairIndex,
+        index,
+        updateType,
+        amountBlockchain,
+        priceUpdateData,
+      ]),
+      value: 1n, // 1 wei for price update
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * 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
+   */
+  async updateTpAndSl(
+    pairIndex: number,
+    index: number,
+    newSl: number,
+    newTp: number,
+    priceUpdateData: string[] = []
+  ): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for trading operations');
+    }
+
+    const slBlockchain = toBlockchain10(newSl);
+    const tpBlockchain = toBlockchain10(newTp);
+
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('updateTpAndSl', [
+        pairIndex,
+        index,
+        slBlockchain,
+        tpBlockchain,
+        priceUpdateData,
+      ]),
+      value: 1n, // 1 wei for price update
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * Cancel a pending limit order
+   * @param pairIndex - Trading pair index
+   * @param index - Order index
+   * @returns Transaction receipt
+   */
+  async cancelOpenLimitOrder(
+    pairIndex: number,
+    index: number
+  ): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for trading operations');
+    }
+
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('cancelOpenLimitOrder', [
+        pairIndex,
+        index,
+      ]),
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * Get open trade information
+   * @param trader - Trader address
+   * @param pairIndex - Trading pair index
+   * @param index - Trade index
+   * @returns Trade information
+   */
+  async getOpenTrade(trader: string, pairIndex: number, index: number): Promise<Trade> {
+    const result = await this.tradingStorageContract.openTrades(trader, pairIndex, index);
+
+    return {
+      trader: result.trader,
+      pairIndex: Number(result.pairIndex),
+      index: Number(result.index),
+      initialPosToken: fromBlockchain6(result.initialPosToken),
+      positionSizeUSDC: fromBlockchain6(result.positionSizeUSDC),
+      openPrice: fromBlockchain10(result.openPrice),
+      buy: result.buy,
+      leverage: fromBlockchain10(result.leverage),
+      tp: fromBlockchain10(result.tp),
+      sl: fromBlockchain10(result.sl),
+      timestamp: Number(result.timestamp),
+    };
+  }
+
+  /**
+   * Get additional trade information
+   * @param trader - Trader address
+   * @param pairIndex - Trading pair index
+   * @param index - Trade index
+   * @returns Trade info
+   */
+  async getOpenTradeInfo(
+    trader: string,
+    pairIndex: number,
+    index: number
+  ): Promise<TradeInfo> {
+    const result = await this.tradingStorageContract.openTradesInfo(trader, pairIndex, index);
+
+    return {
+      openInterestUSDC: fromBlockchain6(result.openInterestUSDC),
+      tpLastUpdated: Number(result.tpLastUpdated),
+      slLastUpdated: Number(result.slLastUpdated),
+      beingMarketClosed: result.beingMarketClosed,
+      lossProtection: Number(result.lossProtection),
+    };
+  }
+
+  /**
+   * 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
+   */
+  async getOpenTradesCount(trader: string, pairIndex: number): Promise<number> {
+    const count = await this.tradingStorageContract.openTradesCount(trader, pairIndex);
+    return Number(count);
+  }
+
+  /**
+   * Get limit order information
+   * @param trader - Trader address
+   * @param pairIndex - Trading pair index
+   * @param index - Order index
+   * @returns Limit order information
+   */
+  async getOpenLimitOrder(
+    trader: string,
+    pairIndex: number,
+    index: number
+  ): Promise<OpenLimitOrder> {
+    const result = await this.tradingStorageContract.getOpenLimitOrder(trader, pairIndex, index);
+
+    return {
+      trader: result.trader,
+      pairIndex: Number(result.pairIndex),
+      index: Number(result.index),
+      positionSize: fromBlockchain6(result.positionSize),
+      buy: result.buy,
+      leverage: fromBlockchain10(result.leverage),
+      tp: fromBlockchain10(result.tp),
+      sl: fromBlockchain10(result.sl),
+      price: fromBlockchain10(result.price),
+      slippageP: fromBlockchain10(result.slippageP),
+      block: Number(result.block),
+      executionFee: fromBlockchain18(result.executionFee),
+    };
+  }
+
+  /**
+   * Helper method to sign and send transactions
+   */
+  private async signAndSend(tx: TransactionRequest): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer not set');
+    }
+
+    const address = await this.signer.getAddress();
+    tx.from = address;
+
+    const provider = this.tradingContract.runner?.provider;
+    if (!provider) {
+      throw new Error('Provider not available');
+    }
+
+    if (!tx.chainId) {
+      const network = await provider.getNetwork();
+      tx.chainId = network.chainId;
+    }
+
+    if (tx.nonce === undefined) {
+      tx.nonce = await provider.getTransactionCount(address);
+    }
+
+    if (!tx.gasLimit) {
+      tx.gasLimit = await provider.estimateGas(tx);
+    }
+
+    if (!tx.maxFeePerGas && !tx.gasPrice) {
+      const feeData = await provider.getFeeData();
+      if (feeData.maxFeePerGas) {
+        tx.maxFeePerGas = feeData.maxFeePerGas;
+        tx.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas || feeData.maxFeePerGas;
+      } else {
+        tx.gasPrice = feeData.gasPrice || undefined;
+      }
+    }
+
+    const signedTx = await this.signer.signTransaction(tx);
+    const txResponse = await provider.broadcastTransaction(signedTx);
+    return await txResponse.wait();
+  }
+
+  /**
+   * Set signer for transactions
+   */
+  setSigner(signer: BaseSigner): void {
+    this.signer = signer;
+  }
+}

package/src/rpc/trading_parameters.ts

@@ -0,0 +1,127 @@
+import { Contract, Provider } from 'ethers';
+import { TradeInput, LossProtectionInfo, fromBlockchain10, toBlockchain6 } from '../types';
+import { PairsCache } from './pairs_cache';
+
+/**
+ * RPC module for trading-related parameters
+ */
+export class TradingParametersRPC {
+  private provider: Provider;
+  private pairInfosContract: Contract;
+  private pairsCache: PairsCache;
+
+  constructor(
+    provider: Provider,
+    pairInfosContract: Contract,
+    pairsCache: PairsCache
+  ) {
+    this.provider = provider;
+    this.pairInfosContract = pairInfosContract;
+    this.pairsCache = pairsCache;
+  }
+
+  /**
+   * Get loss protection tier for a trade
+   * @param tradeInput - Trade input parameters
+   * @returns Loss protection tier
+   */
+  async getLossProtectionTier(tradeInput: TradeInput): Promise<number> {
+    const pairIndex = await this.pairsCache.getPairIndex(tradeInput.pair);
+    if (pairIndex === undefined) {
+      throw new Error(`Pair ${tradeInput.pair} not found`);
+    }
+
+    try {
+      const tier = await this.pairInfosContract.getLossProtectionTier(
+        pairIndex,
+        toBlockchain6(tradeInput.collateralInTrade)
+      );
+      return Number(tier);
+    } catch (error) {
+      console.error('Error getting loss protection tier:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Get loss protection percentage for a tier
+   * @param tier - Loss protection tier
+   * @param pairIndex - Pair index
+   * @returns Loss protection percentage
+   */
+  async getLossProtectionPercentage(tier: number, pairIndex: number): Promise<number> {
+    try {
+      const percentage = await this.pairInfosContract.getLossProtectionP(tier, pairIndex);
+      return fromBlockchain10(percentage);
+    } catch (error) {
+      console.error('Error getting loss protection percentage:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Calculate loss protection amount
+   * @param tier - Loss protection tier
+   * @param pairIndex - Pair index
+   * @param collateral - Collateral amount
+   * @param openingFee - Opening fee amount
+   * @returns Loss protection amount
+   */
+  async getLossProtectionAmount(
+    tier: number,
+    pairIndex: number,
+    collateral: number,
+    openingFee: number
+  ): Promise<number> {
+    const percentage = await this.getLossProtectionPercentage(tier, pairIndex);
+    return openingFee * (percentage / 100);
+  }
+
+  /**
+   * Get complete loss protection info for a trade
+   * @param tradeInput - Trade input parameters
+   * @param openingFee - Opening fee amount
+   * @returns Loss protection info
+   */
+  async getLossProtectionInfo(
+    tradeInput: TradeInput,
+    openingFee: number
+  ): Promise<LossProtectionInfo> {
+    const pairIndex = await this.pairsCache.getPairIndex(tradeInput.pair);
+    if (pairIndex === undefined) {
+      throw new Error(`Pair ${tradeInput.pair} not found`);
+    }
+
+    const tier = await this.getLossProtectionTier(tradeInput);
+    const percentage = await this.getLossProtectionPercentage(tier, pairIndex);
+    const amount = await this.getLossProtectionAmount(
+      tier,
+      pairIndex,
+      tradeInput.collateralInTrade,
+      openingFee
+    );
+
+    return {
+      tier,
+      percentage,
+      amount,
+    };
+  }
+
+  /**
+   * Get referral rebate for a trader
+   * @param trader - Trader address
+   * @param referrer - Referrer address
+   * @param openingFee - Opening fee amount
+   * @returns Rebate amount
+   */
+  async getTradeReferralRebate(
+    trader: string,
+    referrer: string,
+    openingFee: number
+  ): Promise<number> {
+    // This would typically call the referral contract
+    // For now, return 0 as a placeholder
+    return 0;
+  }
+}

package/src/signers/base.ts

@@ -0,0 +1,27 @@
+import { TransactionRequest, TransactionResponse } from 'ethers';
+
+/**
+ * Abstract base class for transaction signers
+ * Implementations can use local private keys, AWS KMS, or other signing methods
+ */
+export abstract class BaseSigner {
+  /**
+   * Sign a transaction
+   * @param transaction - Transaction to sign
+   * @returns Signed transaction
+   */
+  abstract signTransaction(transaction: TransactionRequest): Promise<string>;
+
+  /**
+   * Get the Ethereum address associated with this signer
+   * @returns Ethereum address
+   */
+  abstract getAddress(): Promise<string>;
+
+  /**
+   * Sign a message
+   * @param message - Message to sign
+   * @returns Signature
+   */
+  abstract signMessage(message: string | Uint8Array): Promise<string>;
+}