perps-sdk-ts 1.0.1

package/dist/rpc/multicall.d.ts

@@ -0,0 +1,83 @@
+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 declare class MulticallRPC {
+    private multicallContract;
+    constructor(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
+     */
+    aggregate(calls: MulticallCall[]): Promise<MulticallResult>;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Execute multicall and decode results
+     * @param calls - Array of call definitions with contract and function info
+     * @returns Decoded results
+     */
+    aggregateAndDecode(calls: Array<{
+        contract: Contract;
+        functionName: string;
+        args?: any[];
+    }>): Promise<{
+        blockNumber: number;
+        results: any[];
+    }>;
+    /**
+     * 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
+     */
+    batchGetOpenTrades(tradingStorageContract: Contract, trader: string, pairIndex: number, indices: number[]): Promise<any[]>;
+    /**
+     * 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
+     */
+    batchGetOpenTradesInfo(tradingStorageContract: Contract, trader: string, pairIndex: number, indices: number[]): Promise<any[]>;
+    /**
+     * Batch read pair information
+     * @param pairStorageContract - PairStorage contract instance
+     * @param pairIndices - Array of pair indices
+     * @returns Array of decoded pair data
+     */
+    batchGetPairs(pairStorageContract: Contract, pairIndices: number[]): Promise<any[]>;
+}

package/dist/rpc/multicall.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulticallRPC = void 0;
+/**
+ * Multicall RPC
+ * Allows batching multiple contract view calls into a single request
+ */
+class MulticallRPC {
+    constructor(multicallContract) {
+        this.multicallContract = multicallContract;
+    }
+    /**
+     * 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) {
+        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, functionName, args = []) {
+        return {
+            target: contract.target,
+            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, functionName, returnData) {
+        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) {
+        // 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, trader, pairIndex, indices) {
+        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, trader, pairIndex, indices) {
+        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, pairIndices) {
+        const calls = pairIndices.map((pairIndex) => ({
+            contract: pairStorageContract,
+            functionName: 'pairs',
+            args: [pairIndex],
+        }));
+        const { results } = await this.aggregateAndDecode(calls);
+        return results;
+    }
+}
+exports.MulticallRPC = MulticallRPC;

package/dist/rpc/pair_info_queries.d.ts

@@ -0,0 +1,101 @@
+import { Contract } from 'ethers';
+import { Trade } from '../types';
+/**
+ * PairInfo Queries RPC
+ * Handles querying pair-related information like price impact, skew, fees, and loss protection
+ */
+export declare class PairInfoQueriesRPC {
+    private pairInfosContract;
+    private priceAggregatorContract;
+    constructor(pairInfosContract: Contract, priceAggregatorContract: Contract);
+    /**
+     * Get loss protection tier for a trade
+     * @param trade - Trade information
+     * @param isPnl - Whether calculating for PnL
+     * @returns Loss protection tier
+     */
+    getLossProtectionTier(trade: Trade, isPnl?: boolean): Promise<number>;
+    /**
+     * 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
+     */
+    getPriceImpactSpread(pairIndex: number, isLong: boolean, positionSizeUsdc: number, isOpen: boolean): Promise<number>;
+    /**
+     * 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
+     */
+    getSkewImpactSpread(pairIndex: number, isLong: boolean, positionSizeUsdc: number, isOpen: boolean): Promise<number>;
+    /**
+     * 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
+     */
+    getPriceImpactP(pairIndex: number, isLong: boolean, positionSizeUsdc: number): Promise<number>;
+    /**
+     * 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
+     */
+    getOpenFeeUsdc(pairIndex: number, positionSizeUsdc: number, isLong: boolean): Promise<number>;
+    /**
+     * 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)
+     */
+    getOpenFeeP(pairIndex: number, positionSizeUsdc: number, isLong: boolean): Promise<number>;
+    /**
+     * Get pair margin fee percentage
+     * @param pairIndex - Trading pair index
+     * @returns Margin fee percentage
+     */
+    getPairMarginFeeP(pairIndex: number): Promise<number>;
+    /**
+     * 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
+     */
+    getLossProtectionTierForSize(pairIndex: number, positionSizeUsdc: number): Promise<number>;
+    /**
+     * Get loss protection percentage for a pair and tier
+     * @param pairIndex - Trading pair index
+     * @param tier - Loss protection tier
+     * @returns Loss protection percentage
+     */
+    getLossProtectionP(pairIndex: number, tier: number): Promise<number>;
+    /**
+     * Get 1% depth above (for longs) in USDC
+     * @param pairIndex - Trading pair index
+     * @returns Depth in USDC
+     */
+    getOnePercentDepthAboveUsdc(pairIndex: number): Promise<number>;
+    /**
+     * Get 1% depth below (for shorts) in USDC
+     * @param pairIndex - Trading pair index
+     * @returns Depth in USDC
+     */
+    getOnePercentDepthBelowUsdc(pairIndex: number): Promise<number>;
+    /**
+     * Get both depth values for a pair
+     * @param pairIndex - Trading pair index
+     * @returns Object with depth above and below
+     */
+    getDepth(pairIndex: number): Promise<{
+        above: number;
+        below: number;
+    }>;
+}

package/dist/rpc/pair_info_queries.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairInfoQueriesRPC = void 0;
+const types_1 = require("../types");
+/**
+ * PairInfo Queries RPC
+ * Handles querying pair-related information like price impact, skew, fees, and loss protection
+ */
+class PairInfoQueriesRPC {
+    constructor(pairInfosContract, priceAggregatorContract) {
+        this.pairInfosContract = pairInfosContract;
+        this.priceAggregatorContract = priceAggregatorContract;
+    }
+    /**
+     * Get loss protection tier for a trade
+     * @param trade - Trade information
+     * @param isPnl - Whether calculating for PnL
+     * @returns Loss protection tier
+     */
+    async getLossProtectionTier(trade, isPnl = false) {
+        // Convert trade to blockchain format
+        const tradeStruct = {
+            trader: trade.trader,
+            pairIndex: trade.pairIndex,
+            index: trade.index,
+            initialPosToken: (0, types_1.toBlockchain6)(trade.initialPosToken),
+            positionSizeUSDC: (0, types_1.toBlockchain6)(trade.positionSizeUSDC),
+            openPrice: (0, types_1.toBlockchain10)(trade.openPrice),
+            buy: trade.buy,
+            leverage: (0, types_1.toBlockchain10)(trade.leverage),
+            tp: (0, types_1.toBlockchain10)(trade.tp),
+            sl: (0, types_1.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, isLong, positionSizeUsdc, isOpen) {
+        const positionSize = (0, types_1.toBlockchain6)(positionSizeUsdc);
+        const spread = await this.pairInfosContract.getPriceImpactSpread(pairIndex, isLong, positionSize, isOpen);
+        return (0, types_1.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, isLong, positionSizeUsdc, isOpen) {
+        const positionSize = (0, types_1.toBlockchain6)(positionSizeUsdc);
+        const spread = await this.pairInfosContract.getSkewImpactSpread(pairIndex, isLong, positionSize, isOpen);
+        return (0, types_1.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, isLong, positionSizeUsdc) {
+        const positionSize = (0, types_1.toBlockchain6)(positionSizeUsdc);
+        const impact = await this.pairInfosContract.getPriceImpactP(pairIndex, isLong, positionSize);
+        return (0, types_1.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, positionSizeUsdc, isLong) {
+        const positionSize = (0, types_1.toBlockchain6)(positionSizeUsdc);
+        const fee = await this.pairInfosContract.getOpenFeeUsdc(pairIndex, positionSize, isLong);
+        return (0, types_1.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, positionSizeUsdc, isLong) {
+        const positionSize = (0, types_1.toBlockchain6)(positionSizeUsdc);
+        const fee = await this.priceAggregatorContract.openFeeP(pairIndex, positionSize, isLong);
+        return (0, types_1.fromBlockchain12)(fee);
+    }
+    /**
+     * Get pair margin fee percentage
+     * @param pairIndex - Trading pair index
+     * @returns Margin fee percentage
+     */
+    async getPairMarginFeeP(pairIndex) {
+        const fee = await this.pairInfosContract.getPairMarginFeeP(pairIndex);
+        return (0, types_1.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, positionSizeUsdc) {
+        const positionSize = (0, types_1.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, tier) {
+        const protection = await this.pairInfosContract.getLossProtectionP(pairIndex, tier);
+        return (0, types_1.fromBlockchain10)(protection);
+    }
+    /**
+     * Get 1% depth above (for longs) in USDC
+     * @param pairIndex - Trading pair index
+     * @returns Depth in USDC
+     */
+    async getOnePercentDepthAboveUsdc(pairIndex) {
+        const depth = await this.pairInfosContract.onePercentDepthAboveUsdc(pairIndex);
+        return (0, types_1.fromBlockchain6)(depth);
+    }
+    /**
+     * Get 1% depth below (for shorts) in USDC
+     * @param pairIndex - Trading pair index
+     * @returns Depth in USDC
+     */
+    async getOnePercentDepthBelowUsdc(pairIndex) {
+        const depth = await this.pairInfosContract.onePercentDepthBelowUsdc(pairIndex);
+        return (0, types_1.fromBlockchain6)(depth);
+    }
+    /**
+     * Get both depth values for a pair
+     * @param pairIndex - Trading pair index
+     * @returns Object with depth above and below
+     */
+    async getDepth(pairIndex) {
+        const [above, below] = await Promise.all([
+            this.getOnePercentDepthAboveUsdc(pairIndex),
+            this.getOnePercentDepthBelowUsdc(pairIndex),
+        ]);
+        return { above, below };
+    }
+}
+exports.PairInfoQueriesRPC = PairInfoQueriesRPC;

package/dist/rpc/pairs_cache.d.ts

@@ -0,0 +1,62 @@
+import { Contract, Provider } from 'ethers';
+import { ContractPairInfo, PairInfo, PairsBackendReturn } from '../types';
+/**
+ * RPC module for caching and managing trading pair information
+ */
+export declare class PairsCache {
+    private provider;
+    private pairStorageContract;
+    private pairsCache?;
+    private pairNameToIndexMap?;
+    constructor(provider: Provider, pairStorageContract: Contract);
+    /**
+     * Get all trading pairs from blockchain (with caching)
+     * @param forceRefresh - Force refresh from blockchain
+     * @returns Map of pair index to PairInfo
+     */
+    getPairsInfo(forceRefresh?: boolean): Promise<Map<number, PairInfo>>;
+    getPairBackend(index: number): Promise<PairsBackendReturn>;
+    getPairInfoNameFromIndex: (index: number) => Promise<{
+        from: string;
+        to: string;
+    }>;
+    getOtherPairInfoFromIndex: (index: number) => Promise<ContractPairInfo>;
+    /**
+     * Get pair information from socket API
+     * @returns Pair information from API
+     */
+    getPairInfoFromSocket(): Promise<any>;
+    /**
+     * Get pair index from pair name
+     * @param pairName - Pair name (e.g., "BTC/USD")
+     * @returns Pair index or undefined if not found
+     */
+    getPairIndex(pairName: string): Promise<number | undefined>;
+    /**
+     * Get pair name from index
+     * @param pairIndex - Pair index
+     * @returns Pair name or undefined if not found
+     */
+    getPairName(pairIndex: number): Promise<string | undefined>;
+    /**
+     * Get all unique group indexes
+     * @returns Array of group indexes
+     */
+    getGroupIndexes(): Promise<number[]>;
+    /**
+     * Get all pairs in a specific group
+     * @param groupIndex - Group index
+     * @returns Array of pair indexes in the group
+     */
+    getPairsInGroup(groupIndex: number): Promise<number[]>;
+    /**
+     * Get pair info by index
+     * @param pairIndex - Pair index
+     * @returns PairInfo or undefined
+     */
+    getPairByIndex(pairIndex: number): Promise<PairInfo | undefined>;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+}