perps-sdk-ts 1.0.1

package/src/rpc/category_parameters.ts

@@ -0,0 +1,128 @@
+import { Contract, Provider } from 'ethers';
+import { OpenInterest, Utilization, Skew, fromBlockchain6 } from '../types';
+import { PairsCache } from './pairs_cache';
+
+/**
+ * RPC module for retrieving category-level parameters
+ */
+export class CategoryParametersRPC {
+  private provider: Provider;
+  private pairStorageContract: Contract;
+  private pairsCache: PairsCache;
+
+  constructor(
+    provider: Provider,
+    pairStorageContract: Contract,
+    pairsCache: PairsCache
+  ) {
+    this.provider = provider;
+    this.pairStorageContract = pairStorageContract;
+    this.pairsCache = pairsCache;
+  }
+
+  /**
+   * Get open interest limits per category
+   * Note: Group OI limits are calculated from pair backend data
+   * @returns Map of group index to OI limits
+   */
+  async getOILimits(): Promise<Map<number, OpenInterest>> {
+    const groupIndexes = await this.pairsCache.getGroupIndexes();
+    const limits = new Map<number, OpenInterest>();
+
+    // Get limits from pair backend data which includes group info
+    for (const groupIndex of groupIndexes) {
+      try {
+        // Get first pair in this group to get group max OI
+        const pairsInGroup = await this.pairsCache.getPairsInGroup(groupIndex);
+        if (pairsInGroup.length > 0) {
+          const backendData = await this.pairsCache.getPairBackend(pairsInGroup[0]);
+          const maxOI = Number(backendData.group.maxOpenInterestP) / 1e10; // Convert from 10 decimals to number
+
+          limits.set(groupIndex, {
+            long: maxOI,
+            short: maxOI,
+            max: maxOI,
+          });
+        }
+      } catch (error) {
+        console.error(`Error getting OI limits for group ${groupIndex}:`, error);
+      }
+    }
+
+    return limits;
+  }
+
+  /**
+   * Get current open interest per category
+   * Note: Calculated by summing pair OIs in each group
+   * @returns Map of group index to OI
+   */
+  async getOI(): Promise<Map<number, OpenInterest>> {
+    const groupIndexes = await this.pairsCache.getGroupIndexes();
+    const oi = new Map<number, OpenInterest>();
+    const limits = await this.getOILimits();
+
+    for (const groupIndex of groupIndexes) {
+      try {
+        // Sum up OI from all pairs in this group
+        const pairsInGroup = await this.pairsCache.getPairsInGroup(groupIndex);
+        let totalLongOI = 0;
+        let totalShortOI = 0;
+
+        // This would require asset params to get individual pair OI
+        // For now, return default values
+        // TODO: Properly calculate by summing pair OIs
+        const maxOI = limits.get(groupIndex)?.max || 0;
+
+        oi.set(groupIndex, {
+          long: totalLongOI,
+          short: totalShortOI,
+          max: maxOI,
+        });
+      } catch (error) {
+        console.error(`Error getting OI for group ${groupIndex}:`, error);
+      }
+    }
+
+    return oi;
+  }
+
+  /**
+   * Get utilization per category
+   * @returns Map of group index to utilization
+   */
+  async getUtilization(): Promise<Map<number, Utilization>> {
+    const oi = await this.getOI();
+    const utilization = new Map<number, Utilization>();
+
+    for (const [groupIndex, oiData] of oi) {
+      const utilizationLong = oiData.max > 0 ? (oiData.long / oiData.max) * 100 : 0;
+      const utilizationShort = oiData.max > 0 ? (oiData.short / oiData.max) * 100 : 0;
+
+      utilization.set(groupIndex, {
+        utilizationLong,
+        utilizationShort,
+      });
+    }
+
+    return utilization;
+  }
+
+  /**
+   * Get category skew (long / total)
+   * @returns Map of group index to skew
+   */
+  async getCategorySkew(): Promise<Map<number, Skew>> {
+    const oi = await this.getOI();
+    const skew = new Map<number, Skew>();
+
+    for (const [groupIndex, oiData] of oi) {
+      const total = oiData.long + oiData.short;
+      const skewValue = total > 0 ? oiData.long / total : 0.5;
+
+      skew.set(groupIndex, { skew: skewValue });
+    }
+
+    return skew;
+  }
+}

package/src/rpc/delegation.ts

@@ -0,0 +1,225 @@
+import { Contract, TransactionReceipt, TransactionRequest } from 'ethers';
+import { BaseSigner } from '../signers/base';
+
+/**
+ * Delegation RPC
+ * Handles delegation functionality for the Trading contract.
+ * Allows one address to execute trades on behalf of another.
+ */
+export class DelegationRPC {
+  constructor(
+    private tradingContract: Contract,
+    private signer?: BaseSigner
+  ) {}
+
+  /**
+   * Set a delegate wallet that can perform trade actions on behalf of caller
+   * @param delegate - Address to authorize as delegate (use 0x0 to revoke)
+   * @returns Transaction receipt
+   */
+  async setDelegate(delegate: string): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for delegation operations');
+    }
+
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('setDelegate', [delegate]),
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * Remove the current delegate for the caller
+   * @returns Transaction receipt
+   */
+  async removeDelegate(): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for delegation operations');
+    }
+
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('removeDelegate'),
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * Get the delegate wallet for a given owner
+   * @param owner - Owner address to check
+   * @returns Delegate address (0x0 if none set)
+   */
+  async getDelegateFor(owner: string): Promise<string> {
+    return await this.tradingContract.delegations(owner);
+  }
+
+  /**
+   * Execute a delegated action on behalf of a trader
+   * @param trader - Address of the trader to act on behalf of
+   * @param callData - ABI-encoded function data for the action
+   * @param value - ETH value to send (for execution fees)
+   * @returns Transaction receipt
+   */
+  async delegatedAction(
+    trader: string,
+    callData: string,
+    value: bigint = 0n
+  ): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for delegation operations');
+    }
+
+    const tx: TransactionRequest = {
+      to: await this.tradingContract.getAddress(),
+      data: this.tradingContract.interface.encodeFunctionData('delegatedAction', [
+        trader,
+        callData,
+      ]),
+      value,
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * Helper: Create call data for openTrade to be used with delegatedAction
+   * @param tradeStruct - Trade struct with blockchain values
+   * @param orderType - Order type (0-3)
+   * @param slippageP - Slippage percentage in blockchain units
+   * @returns Encoded call data
+   */
+  encodeOpenTrade(
+    tradeStruct: any,
+    orderType: number,
+    slippageP: bigint
+  ): string {
+    return this.tradingContract.interface.encodeFunctionData('openTrade', [
+      tradeStruct,
+      orderType,
+      slippageP,
+    ]);
+  }
+
+  /**
+   * Helper: Create call data for closeTradeMarket to be used with delegatedAction
+   * @param pairIndex - Trading pair index
+   * @param index - Trade index
+   * @param amount - Amount to close in blockchain units
+   * @returns Encoded call data
+   */
+  encodeCloseTradeMarket(
+    pairIndex: number,
+    index: number,
+    amount: bigint
+  ): string {
+    return this.tradingContract.interface.encodeFunctionData('closeTradeMarket', [
+      pairIndex,
+      index,
+      amount,
+    ]);
+  }
+
+  /**
+   * Helper: Create call data for updateTpAndSl to be used with delegatedAction
+   * @param pairIndex - Trading pair index
+   * @param index - Trade index
+   * @param newSl - New stop loss in blockchain units
+   * @param newTp - New take profit in blockchain units
+   * @param priceUpdateData - Price update data
+   * @returns Encoded call data
+   */
+  encodeUpdateTpAndSl(
+    pairIndex: number,
+    index: number,
+    newSl: bigint,
+    newTp: bigint,
+    priceUpdateData: string[]
+  ): string {
+    return this.tradingContract.interface.encodeFunctionData('updateTpAndSl', [
+      pairIndex,
+      index,
+      newSl,
+      newTp,
+      priceUpdateData,
+    ]);
+  }
+
+  /**
+   * Helper: Create call data for updateMargin to be used with delegatedAction
+   * @param pairIndex - Trading pair index
+   * @param index - Trade index
+   * @param updateType - 0 for DEPOSIT, 1 for WITHDRAW
+   * @param amount - Amount in blockchain units
+   * @param priceUpdateData - Price update data
+   * @returns Encoded call data
+   */
+  encodeUpdateMargin(
+    pairIndex: number,
+    index: number,
+    updateType: number,
+    amount: bigint,
+    priceUpdateData: string[]
+  ): string {
+    return this.tradingContract.interface.encodeFunctionData('updateMargin', [
+      pairIndex,
+      index,
+      updateType,
+      amount,
+      priceUpdateData,
+    ]);
+  }
+
+  /**
+   * 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/fee_parameters.ts

@@ -0,0 +1,150 @@
+import { Contract, Provider } from 'ethers';
+import { Fee, TradeInput, fromBlockchain10, toBlockchain6 } from '../types';
+import { PairsCache } from './pairs_cache';
+
+/**
+ * RPC module for fee calculations
+ */
+export class FeeParametersRPC {
+  private provider: Provider;
+  private pairInfosContract: Contract;
+  private referralContract?: Contract;
+  private pairsCache: PairsCache;
+
+  constructor(
+    provider: Provider,
+    pairInfosContract: Contract,
+    pairsCache: PairsCache,
+    referralContract?: Contract
+  ) {
+    this.provider = provider;
+    this.pairInfosContract = pairInfosContract;
+    this.pairsCache = pairsCache;
+    this.referralContract = referralContract;
+  }
+
+  /**
+   * Get margin fee for all pairs (in basis points)
+   * @returns Map of pair index to fee
+   */
+  async getMarginFee(): Promise<Map<number, Fee>> {
+    const pairs = await this.pairsCache.getPairsInfo();
+    const fees = new Map<number, Fee>();
+
+    for (const [pairIndex] of pairs) {
+      try {
+        const feeP = await this.pairInfosContract.getPairMarginFeeP(pairIndex);
+        fees.set(pairIndex, {
+          feeP: fromBlockchain10(feeP),
+        });
+      } catch (error) {
+        console.error(`Error getting margin fee for pair ${pairIndex}:`, error);
+        fees.set(pairIndex, { feeP: 0 });
+      }
+    }
+
+    return fees;
+  }
+
+  /**
+   * Get constant spread parameter for each pair
+   * @returns Map of pair index to constant spread
+   */
+  async constantSpreadParameter(): Promise<Map<number, number>> {
+    const pairs = await this.pairsCache.getPairsInfo();
+    const spreads = new Map<number, number>();
+
+    for (const [pairIndex, pairInfo] of pairs) {
+      // Use the min spread as the constant spread
+      spreads.set(pairIndex, pairInfo.spread.min);
+    }
+
+    return spreads;
+  }
+
+  /**
+   * Get opening fee for a position
+   * @param positionSize - Position size in USDC
+   * @param isLong - True for long, false for short
+   * @param pairIndex - Pair index
+   * @returns Opening fee in USDC
+   */
+  async getOpeningFee(
+    positionSize: number,
+    isLong: boolean,
+    pairIndex: number
+  ): Promise<number> {
+    try {
+      const feeUsdc = await this.pairInfosContract.getOpenFeeUsdc(
+        pairIndex,
+        toBlockchain6(positionSize),
+        isLong
+      );
+      return fromBlockchain10(feeUsdc);
+    } catch (error) {
+      console.error('Error getting opening fee:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Get opening fee for a new trade with referral
+   * @param tradeInput - Trade input parameters
+   * @param referrer - Referrer address (optional)
+   * @returns Opening fee in USDC
+   */
+  async getNewTradeOpeningFee(
+    tradeInput: TradeInput,
+    referrer?: string
+  ): Promise<number> {
+    const pairIndex = await this.pairsCache.getPairIndex(tradeInput.pair);
+    if (pairIndex === undefined) {
+      throw new Error(`Pair ${tradeInput.pair} not found`);
+    }
+
+    const positionSize = tradeInput.collateralInTrade * tradeInput.leverage;
+    let fee = await this.getOpeningFee(positionSize, tradeInput.isLong, pairIndex);
+
+    // Apply referral discount if applicable
+    if (referrer && this.referralContract) {
+      try {
+        const rebate = await this.getTradeReferralRebate(
+          tradeInput.referrer || referrer,
+          referrer,
+          fee
+        );
+        fee -= rebate;
+      } catch (error) {
+        console.error('Error getting referral rebate:', error);
+      }
+    }
+
+    return fee;
+  }
+
+  /**
+   * Get trade referral rebate
+   * @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> {
+    if (!this.referralContract) {
+      return 0;
+    }
+
+    try {
+      const rebateP = await this.referralContract.getReferralRebateP(trader, referrer);
+      const rebatePercentage = fromBlockchain10(rebateP);
+      return openingFee * (rebatePercentage / 100);
+    } catch (error) {
+      console.error('Error getting referral rebate:', error);
+      return 0;
+    }
+  }
+}

package/src/rpc/multicall.ts

@@ -0,0 +1,164 @@
+import { Contract } from 'ethers';
+
+/**
+ * Call structure for multicall
+ */
+export interface MulticallCall {
+  target: string;
+  callData: string;
+}
+
+/**
+ * Result structure from multicall
+ */
+export interface MulticallResult {
+  blockNumber: number;
+  returnData: string[];
+}
+
+/**
+ * Multicall RPC
+ * Allows batching multiple contract view calls into a single request
+ */
+export class MulticallRPC {
+  constructor(private multicallContract: Contract) {}
+
+  /**
+   * Execute multiple calls in a single transaction
+   * @param calls - Array of calls to execute
+   * @returns Block number and return data from each call
+   */
+  async aggregate(calls: MulticallCall[]): Promise<MulticallResult> {
+    const result = await this.multicallContract.aggregate(calls);
+
+    return {
+      blockNumber: Number(result.blockNumber || result[0]),
+      returnData: Array.isArray(result.returnData) ? result.returnData : result[1],
+    };
+  }
+
+  /**
+   * Helper: Create call data for a contract function
+   * @param contract - Contract instance
+   * @param functionName - Function name
+   * @param args - Function arguments
+   * @returns Call data object
+   */
+  createCall(contract: Contract, functionName: string, args: any[] = []): MulticallCall {
+    return {
+      target: contract.target as string,
+      callData: contract.interface.encodeFunctionData(functionName, args),
+    };
+  }
+
+  /**
+   * Helper: Decode return data from a multicall result
+   * @param contract - Contract instance used for decoding
+   * @param functionName - Function name that was called
+   * @param returnData - Raw return data from multicall
+   * @returns Decoded result
+   */
+  decodeResult(contract: Contract, functionName: string, returnData: string): any {
+    return contract.interface.decodeFunctionResult(functionName, returnData);
+  }
+
+  /**
+   * Execute multicall and decode results
+   * @param calls - Array of call definitions with contract and function info
+   * @returns Decoded results
+   */
+  async aggregateAndDecode(
+    calls: Array<{
+      contract: Contract;
+      functionName: string;
+      args?: any[];
+    }>
+  ): Promise<{
+    blockNumber: number;
+    results: any[];
+  }> {
+    // Create multicall calls
+    const multicallCalls = calls.map((call) =>
+      this.createCall(call.contract, call.functionName, call.args || [])
+    );
+
+    // Execute multicall
+    const { blockNumber, returnData } = await this.aggregate(multicallCalls);
+
+    // Decode results
+    const results = returnData.map((data, index) => {
+      const call = calls[index];
+      return this.decodeResult(call.contract, call.functionName, data);
+    });
+
+    return {
+      blockNumber,
+      results,
+    };
+  }
+
+  /**
+   * Batch read multiple open trades
+   * @param tradingStorageContract - TradingStorage contract instance
+   * @param trader - Trader address
+   * @param pairIndex - Pair index
+   * @param indices - Array of trade indices
+   * @returns Array of decoded trade data
+   */
+  async batchGetOpenTrades(
+    tradingStorageContract: Contract,
+    trader: string,
+    pairIndex: number,
+    indices: number[]
+  ): Promise<any[]> {
+    const calls = indices.map((index) => ({
+      contract: tradingStorageContract,
+      functionName: 'openTrades',
+      args: [trader, pairIndex, index],
+    }));
+
+    const { results } = await this.aggregateAndDecode(calls);
+    return results;
+  }
+
+  /**
+   * Batch read multiple trade infos
+   * @param tradingStorageContract - TradingStorage contract instance
+   * @param trader - Trader address
+   * @param pairIndex - Pair index
+   * @param indices - Array of trade indices
+   * @returns Array of decoded trade info data
+   */
+  async batchGetOpenTradesInfo(
+    tradingStorageContract: Contract,
+    trader: string,
+    pairIndex: number,
+    indices: number[]
+  ): Promise<any[]> {
+    const calls = indices.map((index) => ({
+      contract: tradingStorageContract,
+      functionName: 'openTradesInfo',
+      args: [trader, pairIndex, index],
+    }));
+
+    const { results } = await this.aggregateAndDecode(calls);
+    return results;
+  }
+
+  /**
+   * Batch read pair information
+   * @param pairStorageContract - PairStorage contract instance
+   * @param pairIndices - Array of pair indices
+   * @returns Array of decoded pair data
+   */
+  async batchGetPairs(pairStorageContract: Contract, pairIndices: number[]): Promise<any[]> {
+    const calls = pairIndices.map((pairIndex) => ({
+      contract: pairStorageContract,
+      functionName: 'pairs',
+      args: [pairIndex],
+    }));
+
+    const { results } = await this.aggregateAndDecode(calls);
+    return results;
+  }
+}