perps-sdk-ts 1.0.1

package/dist/rpc/pairs_cache.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairsCache = void 0;
+const types_1 = require("../types");
+const config_1 = require("../config");
+/**
+ * RPC module for caching and managing trading pair information
+ */
+class PairsCache {
+    constructor(provider, pairStorageContract) {
+        this.getPairInfoNameFromIndex = async (index) => {
+            const pairData = await this.pairStorageContract.getPairData(index);
+            return {
+                from: pairData.from,
+                to: pairData.to
+            };
+        };
+        this.getOtherPairInfoFromIndex = async (index) => {
+            const pairData = await this.pairStorageContract.pairs(index);
+            const values = pairData[9];
+            const result = {
+                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;
+        };
+        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 = false) {
+        if (this.pairsCache && !forceRefresh) {
+            return this.pairsCache;
+        }
+        const pairs = new Map();
+        const pairNameToIndex = new Map();
+        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 = {
+                    from: pair.from,
+                    to: pair.to,
+                    spread: {
+                        min: (0, types_1.fromBlockchain10)(pairData.spreadP),
+                        max: (0, types_1.fromBlockchain10)(pairData.spreadP),
+                    },
+                    groupIndex: Number(pairData.groupIndex),
+                    feeIndex: Number(pairData.feeIndex),
+                    maxLeverage: (0, types_1.fromBlockchain10)(pairData.leverages.maxLeverage),
+                    maxShortOiP: (0, types_1.fromBlockchain10)(pairData.values.maxShortOiP),
+                    maxLongOiP: (0, types_1.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) {
+        const [pair, group, fee] = await this.pairStorageContract.pairsBackend(index);
+        const mapped = {
+            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;
+    }
+    /**
+     * Get pair information from socket API
+     * @returns Pair information from API
+     */
+    async getPairInfoFromSocket() {
+        try {
+            const response = await fetch(config_1.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) {
+        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) {
+        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() {
+        const pairs = await this.getPairsInfo();
+        const groupIndexes = new Set();
+        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) {
+        const pairs = await this.getPairsInfo();
+        const pairsInGroup = [];
+        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) {
+        const pairs = await this.getPairsInfo();
+        return pairs.get(pairIndex);
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.pairsCache = undefined;
+        this.pairNameToIndexMap = undefined;
+    }
+}
+exports.PairsCache = PairsCache;

package/dist/rpc/referral_operations.d.ts

@@ -0,0 +1,67 @@
+import { Contract, TransactionReceipt } 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 declare class ReferralOperationsRPC {
+    private referralContract;
+    private signer?;
+    constructor(referralContract: Contract, signer?: BaseSigner | undefined);
+    /**
+     * Get referral information for a trader
+     * @param account - Trader address
+     * @returns Referral code and referrer address
+     */
+    getTraderReferralInfo(account: string): Promise<{
+        code: string;
+        referrer: string;
+    }>;
+    /**
+     * Get referrer tier
+     * @param account - Referrer address
+     * @returns Tier ID
+     */
+    getReferrerTier(account: string): Promise<number>;
+    /**
+     * Get tier information
+     * @param tierId - Tier ID
+     * @returns Tier information with fee discount and rebate percentages
+     */
+    getTierInfo(tierId: number): Promise<ReferralTier>;
+    /**
+     * Calculate referral discount for a trader and fee
+     * @param account - Trader address
+     * @param fee - Original fee amount
+     * @returns Discount information
+     */
+    getTraderReferralDiscount(account: string, fee: number): Promise<ReferralDiscount>;
+    /**
+     * Set referral code for the caller
+     * @param code - Referral code (max 32 characters)
+     * @returns Transaction receipt
+     */
+    setReferralCode(code: string): Promise<TransactionReceipt | null>;
+    /**
+     * Check if an account has a referral code set
+     * @param account - Trader address
+     * @returns True if referral code is set
+     */
+    hasReferralCode(account: string): Promise<boolean>;
+    /**
+     * Get effective fee after referral discount
+     * @param account - Trader address
+     * @param baseFee - Base fee amount
+     * @returns Effective fee after discount
+     */
+    getEffectiveFee(account: string, baseFee: number): Promise<number>;
+    /**
+     * Helper method to sign and send transactions
+     */
+    private signAndSend;
+    /**
+     * Set signer for transactions
+     */
+    setSigner(signer: BaseSigner): void;
+}

package/dist/rpc/referral_operations.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferralOperationsRPC = void 0;
+const ethers_1 = require("ethers");
+/**
+ * Referral Operations RPC
+ * Handles referral program functionality including codes, tiers, and discounts
+ */
+class ReferralOperationsRPC {
+    constructor(referralContract, signer) {
+        this.referralContract = referralContract;
+        this.signer = signer;
+    }
+    /**
+     * Get referral information for a trader
+     * @param account - Trader address
+     * @returns Referral code and referrer address
+     */
+    async getTraderReferralInfo(account) {
+        const [code, referrer] = await this.referralContract.getTraderReferralInfo(account);
+        return {
+            code: ethers_1.ethers.decodeBytes32String(code),
+            referrer,
+        };
+    }
+    /**
+     * Get referrer tier
+     * @param account - Referrer address
+     * @returns Tier ID
+     */
+    async getReferrerTier(account) {
+        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) {
+        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, fee) {
+        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) {
+        if (!this.signer) {
+            throw new Error('Signer required for setting referral code');
+        }
+        // Convert string to bytes32
+        const codeBytes32 = ethers_1.ethers.encodeBytes32String(code);
+        const tx = {
+            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) {
+        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, baseFee) {
+        const discount = await this.getTraderReferralDiscount(account, baseFee);
+        return baseFee - discount.traderDiscount;
+    }
+    /**
+     * Helper method to sign and send transactions
+     */
+    async signAndSend(tx) {
+        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) {
+        this.signer = signer;
+    }
+}
+exports.ReferralOperationsRPC = ReferralOperationsRPC;

package/dist/rpc/snapshot.d.ts

@@ -0,0 +1,49 @@
+import { Snapshot, Group, PairData, PairsBackendReturn } 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 declare class SnapshotRPC {
+    private pairsCache;
+    private assetParams;
+    private categoryParams;
+    private feeParams;
+    private blendedParams;
+    constructor(pairsCache: PairsCache, assetParams: AssetParametersRPC, categoryParams: CategoryParametersRPC, feeParams: FeeParametersRPC, blendedParams: BlendedRPC);
+    /**
+     * Get comprehensive market snapshot with all data
+     * Optimized to use getPairBackend() to reduce contract calls
+     * @returns Snapshot object containing all market parameters
+     */
+    getSnapshot(): Promise<Snapshot>;
+    /**
+     * Get snapshot for a specific group
+     * @param groupIndex - Group index
+     * @returns Group data
+     */
+    getGroupSnapshot(groupIndex: number): Promise<Group | undefined>;
+    /**
+     * Get snapshot for a specific pair
+     * @param pairName - Pair name (e.g., "BTC/USD")
+     * @returns Pair data
+     */
+    getPairSnapshot(pairName: string): Promise<PairData | 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
+     */
+    getPairFullData(pairIndex: number): Promise<PairsBackendReturn>;
+    /**
+     * 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
+     */
+    getAllPairsFullData(): Promise<Map<number, PairsBackendReturn>>;
+}

package/dist/rpc/snapshot.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotRPC = void 0;
+const types_1 = require("../types");
+/**
+ * RPC module for aggregating all market data into a snapshot
+ * Optimized to use getPairBackend() to reduce duplicate contract calls
+ */
+class SnapshotRPC {
+    constructor(pairsCache, assetParams, categoryParams, feeParams, blendedParams) {
+        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() {
+        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();
+        pairIndices.forEach((idx, i) => {
+            backendDataMap.set(idx, pairBackendData[i]);
+        });
+        // Build a map of groupIndex -> group info (from backend data)
+        const groupInfoMap = new Map();
+        pairBackendData.forEach(data => {
+            const groupIdx = Number(data.pair.groupIndex);
+            if (!groupInfoMap.has(groupIdx)) {
+                groupInfoMap.set(groupIdx, data.group);
+            }
+        });
+        // Build snapshot structure
+        const snapshot = {
+            groups: {},
+        };
+        // Group pairs by category
+        for (const [groupIndex, groupInfo] of groupInfoMap) {
+            const 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: (0, types_1.fromBlockchain12)(backend.fee.openFeeP), // Using openFeeP as the main fee
+                };
+                const 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: (0, types_1.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) {
+        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) {
+        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) {
+        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() {
+        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();
+        pairIndices.forEach((idx, i) => {
+            dataMap.set(idx, backendData[i]);
+        });
+        return dataMap;
+    }
+}
+exports.SnapshotRPC = SnapshotRPC;