perps-sdk-ts 1.0.1

package/src/rpc/pair_info_queries.ts

@@ -0,0 +1,208 @@
+import { Contract } from 'ethers';
+import { Trade, fromBlockchain6, fromBlockchain10, fromBlockchain12, toBlockchain6, toBlockchain10 } from '../types';
+
+/**
+ * PairInfo Queries RPC
+ * Handles querying pair-related information like price impact, skew, fees, and loss protection
+ */
+export class PairInfoQueriesRPC {
+  constructor(
+    private pairInfosContract: Contract,
+    private priceAggregatorContract: Contract
+  ) {}
+
+  /**
+   * Get loss protection tier for a trade
+   * @param trade - Trade information
+   * @param isPnl - Whether calculating for PnL
+   * @returns Loss protection tier
+   */
+  async getLossProtectionTier(trade: Trade, isPnl: boolean = false): Promise<number> {
+    // Convert trade to blockchain format
+    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: trade.timestamp,
+    };
+
+    const tier = await this.pairInfosContract.lossProtectionTier(tradeStruct, isPnl);
+    return Number(tier);
+  }
+
+  /**
+   * Get price impact spread for a position
+   * @param pairIndex - Trading pair index
+   * @param isLong - True for long position
+   * @param positionSizeUsdc - Position size in USDC
+   * @param isOpen - Whether opening or closing
+   * @returns Price impact spread percentage
+   */
+  async getPriceImpactSpread(
+    pairIndex: number,
+    isLong: boolean,
+    positionSizeUsdc: number,
+    isOpen: boolean
+  ): Promise<number> {
+    const positionSize = toBlockchain6(positionSizeUsdc);
+    const spread = await this.pairInfosContract.getPriceImpactSpread(
+      pairIndex,
+      isLong,
+      positionSize,
+      isOpen
+    );
+    return fromBlockchain10(spread);
+  }
+
+  /**
+   * Get skew impact spread for a position
+   * @param pairIndex - Trading pair index
+   * @param isLong - True for long position
+   * @param positionSizeUsdc - Position size in USDC
+   * @param isOpen - Whether opening or closing
+   * @returns Skew impact spread percentage
+   */
+  async getSkewImpactSpread(
+    pairIndex: number,
+    isLong: boolean,
+    positionSizeUsdc: number,
+    isOpen: boolean
+  ): Promise<number> {
+    const positionSize = toBlockchain6(positionSizeUsdc);
+    const spread = await this.pairInfosContract.getSkewImpactSpread(
+      pairIndex,
+      isLong,
+      positionSize,
+      isOpen
+    );
+    return fromBlockchain10(spread);
+  }
+
+  /**
+   * Get price impact percentage for a position
+   * @param pairIndex - Trading pair index
+   * @param isLong - True for long position
+   * @param positionSizeUsdc - Position size in USDC
+   * @returns Price impact percentage
+   */
+  async getPriceImpactP(
+    pairIndex: number,
+    isLong: boolean,
+    positionSizeUsdc: number
+  ): Promise<number> {
+    const positionSize = toBlockchain6(positionSizeUsdc);
+    const impact = await this.pairInfosContract.getPriceImpactP(pairIndex, isLong, positionSize);
+    return fromBlockchain10(impact);
+  }
+
+  /**
+   * Get opening fee in USDC for a position
+   * @param pairIndex - Trading pair index
+   * @param positionSizeUsdc - Position size in USDC
+   * @param isLong - True for long position
+   * @returns Opening fee in USDC
+   */
+  async getOpenFeeUsdc(
+    pairIndex: number,
+    positionSizeUsdc: number,
+    isLong: boolean
+  ): Promise<number> {
+    const positionSize = toBlockchain6(positionSizeUsdc);
+    const fee = await this.pairInfosContract.getOpenFeeUsdc(pairIndex, positionSize, isLong);
+    return fromBlockchain6(fee);
+  }
+
+  /**
+   * Get opening fee percentage for a position (from PriceAggregator)
+   * @param pairIndex - Trading pair index
+   * @param positionSizeUsdc - Position size in USDC
+   * @param isLong - True for long position
+   * @returns Opening fee percentage (12 decimals)
+   */
+  async getOpenFeeP(
+    pairIndex: number,
+    positionSizeUsdc: number,
+    isLong: boolean
+  ): Promise<number> {
+    const positionSize = toBlockchain6(positionSizeUsdc);
+    const fee = await this.priceAggregatorContract.openFeeP(pairIndex, positionSize, isLong);
+    return fromBlockchain12(fee);
+  }
+
+  /**
+   * Get pair margin fee percentage
+   * @param pairIndex - Trading pair index
+   * @returns Margin fee percentage
+   */
+  async getPairMarginFeeP(pairIndex: number): Promise<number> {
+    const fee = await this.pairInfosContract.getPairMarginFeeP(pairIndex);
+    return fromBlockchain10(fee);
+  }
+
+  /**
+   * Get loss protection tier for a pair and position size
+   * @param pairIndex - Trading pair index
+   * @param positionSizeUsdc - Position size in USDC
+   * @returns Loss protection tier
+   */
+  async getLossProtectionTierForSize(
+    pairIndex: number,
+    positionSizeUsdc: number
+  ): Promise<number> {
+    const positionSize = toBlockchain6(positionSizeUsdc);
+    const tier = await this.pairInfosContract.getLossProtectionTier(pairIndex, positionSize);
+    return Number(tier);
+  }
+
+  /**
+   * Get loss protection percentage for a pair and tier
+   * @param pairIndex - Trading pair index
+   * @param tier - Loss protection tier
+   * @returns Loss protection percentage
+   */
+  async getLossProtectionP(pairIndex: number, tier: number): Promise<number> {
+    const protection = await this.pairInfosContract.getLossProtectionP(pairIndex, tier);
+    return fromBlockchain10(protection);
+  }
+
+  /**
+   * Get 1% depth above (for longs) in USDC
+   * @param pairIndex - Trading pair index
+   * @returns Depth in USDC
+   */
+  async getOnePercentDepthAboveUsdc(pairIndex: number): Promise<number> {
+    const depth = await this.pairInfosContract.onePercentDepthAboveUsdc(pairIndex);
+    return fromBlockchain6(depth);
+  }
+
+  /**
+   * Get 1% depth below (for shorts) in USDC
+   * @param pairIndex - Trading pair index
+   * @returns Depth in USDC
+   */
+  async getOnePercentDepthBelowUsdc(pairIndex: number): Promise<number> {
+    const depth = await this.pairInfosContract.onePercentDepthBelowUsdc(pairIndex);
+    return fromBlockchain6(depth);
+  }
+
+  /**
+   * Get both depth values for a pair
+   * @param pairIndex - Trading pair index
+   * @returns Object with depth above and below
+   */
+  async getDepth(pairIndex: number): Promise<{ above: number; below: number }> {
+    const [above, below] = await Promise.all([
+      this.getOnePercentDepthAboveUsdc(pairIndex),
+      this.getOnePercentDepthBelowUsdc(pairIndex),
+    ]);
+
+    return { above, below };
+  }
+}

package/src/rpc/pairs_cache.ts

@@ -0,0 +1,268 @@
+import { Contract, Provider } from 'ethers';
+import { ContractPairInfo, PairInfo, PairInfoSchema, PairsBackendReturn, fromBlockchain10, fromBlockchain6 } from '../types';
+import { API_ENDPOINTS } from '../config';
+
+/**
+ * RPC module for caching and managing trading pair information
+ */
+export class PairsCache {
+  private provider: Provider;
+  private pairStorageContract: Contract;
+  private pairsCache?: Map<number, PairInfo>;
+  private pairNameToIndexMap?: Map<string, number>;
+
+  constructor(provider: Provider, pairStorageContract: Contract) {
+    this.provider = provider;
+    this.pairStorageContract = pairStorageContract;
+  }
+
+  /**
+   * Get all trading pairs from blockchain (with caching)
+   * @param forceRefresh - Force refresh from blockchain
+   * @returns Map of pair index to PairInfo
+   */
+  async getPairsInfo(forceRefresh: boolean = false): Promise<Map<number, PairInfo>> {
+    if (this.pairsCache && !forceRefresh) {
+      return this.pairsCache;
+    }
+
+    const pairs = new Map<number, PairInfo>();
+    const pairNameToIndex = new Map<string, number>();
+
+    try {
+      // Get pairs count
+      const pairsCount = await this.pairStorageContract.pairsCount();
+      const count = Number(pairsCount);
+
+      // Fetch all pairs
+      for (let i = 0; i < count; i++) {
+        const pairData = await this.getOtherPairInfoFromIndex(i);
+       const pair = await this.getPairInfoNameFromIndex(i)
+        const pairInfo: PairInfo = {
+          from: pair.from,
+          to: pair.to,
+          spread: {
+            min: fromBlockchain10(pairData.spreadP ),
+            max: fromBlockchain10(pairData.spreadP ),
+          },
+          groupIndex: Number(pairData.groupIndex),
+          feeIndex: Number(pairData.feeIndex),
+          maxLeverage: fromBlockchain10(pairData.leverages.maxLeverage),
+          maxShortOiP: fromBlockchain10( pairData.values.maxShortOiP),
+          maxLongOiP: fromBlockchain10( pairData.values.maxLongOiP)
+        };
+
+        pairs.set(i, pairInfo);
+        pairNameToIndex.set(`${pairInfo.from}/${pairInfo.to}`, i);
+      }
+
+      this.pairsCache = pairs;
+      this.pairNameToIndexMap = pairNameToIndex;
+
+      return pairs;
+    } catch (error) {
+      console.error('Error fetching pairs info from blockchain:', error);
+      throw error;
+    }
+  }
+
+async getPairBackend(index: number): Promise<PairsBackendReturn> {
+  const [pair, group, fee] = await this.pairStorageContract.pairsBackend(index);
+
+  const mapped: PairsBackendReturn = {
+    pair: {
+      feed: {
+        maxOpenDeviationP: pair.feed.maxOpenDeviationP,
+        maxCloseDeviationP: pair.feed.maxCloseDeviationP,
+        feedId: pair.feed.feedId,
+      },
+      backupFeed: {
+        maxDeviationP: pair.backupFeed.maxDeviationP,
+        feedId: pair.backupFeed.feedId,
+      },
+      spreadP: pair.spreadP,
+      pnlSpreadP: pair.pnlSpreadP,
+      leverages: {
+        minLeverage: pair.leverages.minLeverage,
+        maxLeverage: pair.leverages.maxLeverage,
+        pnlMinLeverage: pair.leverages.pnlMinLeverage,
+        pnlMaxLeverage: pair.leverages.pnlMaxLeverage,
+      },
+      priceImpactMultiplier: pair.priceImpactMultiplier,
+      skewImpactMultiplier: pair.skewImpactMultiplier,
+      groupIndex: pair.groupIndex,
+      feeIndex: pair.feeIndex,
+      values: {
+        maxGainP: pair[9].maxGainP,
+        maxSlP: pair[9].maxSlP,
+        maxLongOiP: pair[9].maxLongOiP,
+        maxShortOiP: pair[9].maxShortOiP,
+        groupOpenInterestPercentageP: pair[9].groupOpenInterestPercentageP,
+        maxWalletOIP: pair[9].maxWalletOIP,
+        isUSDCAligned: pair[9].isUSDCAligned,
+      },
+    },
+
+    group: {
+      name: group.name,
+      maxOpenInterestP: group.maxOpenInterestP,
+      isSpreadDynamic: group.isSpreadDynamic,
+    },
+
+    fee: {
+      openFeeP: fee.openFeeP,
+      closeFeeP: fee.closeFeeP,
+      limitOrderFeeP: fee.limitOrderFeeP,
+      minLevPosUSDC: fee.minLevPosUSDC,
+      pnlFees: {
+        numTiers: fee.pnlFees.numTiers,
+        tierP: [...fee.pnlFees.tierP],
+        feesP: [...fee.pnlFees.feesP],
+      },
+    },
+  };
+
+  return mapped;
+}
+
+   getPairInfoNameFromIndex = async (index:number) :Promise<{from:string, to:string}>=>{
+    const pairData = await this.pairStorageContract.getPairData(index)
+    return {
+      from: pairData.from,
+      to: pairData.to
+    }
+   }
+
+ getOtherPairInfoFromIndex = async (index: number): Promise<ContractPairInfo> => {
+  const pairData = await this.pairStorageContract.pairs(index);
+const values = pairData[9]
+  const result: ContractPairInfo = {
+    feed: {
+      maxOpenDeviationP: pairData.feed.maxOpenDeviationP,
+      maxCloseDeviationP: pairData.feed.maxCloseDeviationP,
+      feedId: pairData.feed.feedId,
+    },
+    backupFeed: {
+      maxDeviationP: pairData.backupFeed.maxDeviationP,
+      feedId: pairData.backupFeed.feedId,
+    },
+    spreadP: pairData.spreadP,
+    pnlSpreadP: pairData.pnlSpreadP,
+    leverages: {
+      minLeverage: pairData.leverages.minLeverage,
+      maxLeverage: pairData.leverages.maxLeverage,
+      pnlMinLeverage: pairData.leverages.pnlMinLeverage,
+      pnlMaxLeverage: pairData.leverages.pnlMaxLeverage,
+    },
+    priceImpactMultiplier: pairData.priceImpactMultiplier,
+    skewImpactMultiplier: pairData.skewImpactMultiplier,
+    groupIndex: pairData.groupIndex,
+    feeIndex: pairData.feeIndex,
+    values: {
+      maxGainP: values.maxGainP,
+      maxSlP: values.maxSlP,
+      maxLongOiP: values.maxLongOiP,
+      maxShortOiP: values.maxShortOiP,
+      groupOpenInterestPercentageP: values.groupOpenInterestPercentageP,
+      maxWalletOIP: values.maxWalletOIP,
+      isUSDCAligned: values.isUSDCAligned,
+    },
+  };
+
+  return result;
+};
+
+
+  /**
+   * Get pair information from socket API
+   * @returns Pair information from API
+   */
+  async getPairInfoFromSocket(): Promise<any> {
+    try {
+      const response = await fetch(API_ENDPOINTS.SOCKET_API);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch from socket API: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('Error fetching pair info from socket API:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get pair index from pair name
+   * @param pairName - Pair name (e.g., "BTC/USD")
+   * @returns Pair index or undefined if not found
+   */
+  async getPairIndex(pairName: string): Promise<number | undefined> {
+    if (!this.pairNameToIndexMap) {
+      await this.getPairsInfo();
+    }
+    return this.pairNameToIndexMap?.get(pairName);
+  }
+
+  /**
+   * Get pair name from index
+   * @param pairIndex - Pair index
+   * @returns Pair name or undefined if not found
+   */
+  async getPairName(pairIndex: number): Promise<string | undefined> {
+    if (!this.pairsCache) {
+      await this.getPairsInfo();
+    }
+    const pair = this.pairsCache?.get(pairIndex);
+    return pair ? `${pair.from}/${pair.to}` : undefined;
+  }
+
+  /**
+   * Get all unique group indexes
+   * @returns Array of group indexes
+   */
+  async getGroupIndexes(): Promise<number[]> {
+    const pairs = await this.getPairsInfo();
+    const groupIndexes = new Set<number>();
+
+    pairs.forEach((pair) => {
+      groupIndexes.add(pair.groupIndex);
+    });
+
+    return Array.from(groupIndexes).sort((a, b) => a - b);
+  }
+
+  /**
+   * Get all pairs in a specific group
+   * @param groupIndex - Group index
+   * @returns Array of pair indexes in the group
+   */
+  async getPairsInGroup(groupIndex: number): Promise<number[]> {
+    const pairs = await this.getPairsInfo();
+    const pairsInGroup: number[] = [];
+
+    pairs.forEach((pair, index) => {
+      if (pair.groupIndex === groupIndex) {
+        pairsInGroup.push(index);
+      }
+    });
+
+    return pairsInGroup;
+  }
+
+  /**
+   * Get pair info by index
+   * @param pairIndex - Pair index
+   * @returns PairInfo or undefined
+   */
+  async getPairByIndex(pairIndex: number): Promise<PairInfo | undefined> {
+    const pairs = await this.getPairsInfo();
+    return pairs.get(pairIndex);
+  }
+
+  /**
+   * Clear the cache
+   */
+  clearCache(): void {
+    this.pairsCache = undefined;
+    this.pairNameToIndexMap = undefined;
+  }
+}

package/src/rpc/referral_operations.ts

@@ -0,0 +1,164 @@
+import { Contract, TransactionReceipt, TransactionRequest } from 'ethers';
+import { ethers } from 'ethers';
+import { ReferralTier, ReferralDiscount } from '../types';
+import { BaseSigner } from '../signers/base';
+
+/**
+ * Referral Operations RPC
+ * Handles referral program functionality including codes, tiers, and discounts
+ */
+export class ReferralOperationsRPC {
+  constructor(
+    private referralContract: Contract,
+    private signer?: BaseSigner
+  ) {}
+
+  /**
+   * Get referral information for a trader
+   * @param account - Trader address
+   * @returns Referral code and referrer address
+   */
+  async getTraderReferralInfo(account: string): Promise<{ code: string; referrer: string }> {
+    const [code, referrer] = await this.referralContract.getTraderReferralInfo(account);
+
+    return {
+      code: ethers.decodeBytes32String(code),
+      referrer,
+    };
+  }
+
+  /**
+   * Get referrer tier
+   * @param account - Referrer address
+   * @returns Tier ID
+   */
+  async getReferrerTier(account: string): Promise<number> {
+    const tier = await this.referralContract.referrerTiers(account);
+    return Number(tier);
+  }
+
+  /**
+   * Get tier information
+   * @param tierId - Tier ID
+   * @returns Tier information with fee discount and rebate percentages
+   */
+  async getTierInfo(tierId: number): Promise<ReferralTier> {
+    const tier = await this.referralContract.tiers(tierId);
+
+    return {
+      feeDiscountPct: Number(tier.feeDiscountPct),
+      refRebatePct: Number(tier.refRebatePct),
+    };
+  }
+
+  /**
+   * Calculate referral discount for a trader and fee
+   * @param account - Trader address
+   * @param fee - Original fee amount
+   * @returns Discount information
+   */
+  async getTraderReferralDiscount(account: string, fee: number): Promise<ReferralDiscount> {
+    const result = await this.referralContract.traderReferralDiscount(account, fee);
+
+    return {
+      traderDiscount: Number(result.traderDiscount),
+      referrer: result.referrer,
+      rebateShare: Number(result.rebateShare),
+    };
+  }
+
+  /**
+   * Set referral code for the caller
+   * @param code - Referral code (max 32 characters)
+   * @returns Transaction receipt
+   */
+  async setReferralCode(code: string): Promise<TransactionReceipt | null> {
+    if (!this.signer) {
+      throw new Error('Signer required for setting referral code');
+    }
+
+    // Convert string to bytes32
+    const codeBytes32 = ethers.encodeBytes32String(code);
+
+    const tx: TransactionRequest = {
+      to: await this.referralContract.getAddress(),
+      data: this.referralContract.interface.encodeFunctionData('setTraderReferralCodeByUser', [
+        codeBytes32,
+      ]),
+    };
+
+    return await this.signAndSend(tx);
+  }
+
+  /**
+   * Check if an account has a referral code set
+   * @param account - Trader address
+   * @returns True if referral code is set
+   */
+  async hasReferralCode(account: string): Promise<boolean> {
+    const { code } = await this.getTraderReferralInfo(account);
+    return code !== '' && code !== '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00';
+  }
+
+  /**
+   * Get effective fee after referral discount
+   * @param account - Trader address
+   * @param baseFee - Base fee amount
+   * @returns Effective fee after discount
+   */
+  async getEffectiveFee(account: string, baseFee: number): Promise<number> {
+    const discount = await this.getTraderReferralDiscount(account, baseFee);
+    return baseFee - discount.traderDiscount;
+  }
+
+  /**
+   * 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.referralContract.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;
+  }
+}