perps-sdk-ts 1.0.1

package/dist/rpc/blended.d.ts

@@ -0,0 +1,23 @@
+import { Utilization, Skew } from '../types';
+import { AssetParametersRPC } from './asset_parameters';
+import { CategoryParametersRPC } from './category_parameters';
+import { PairsCache } from './pairs_cache';
+/**
+ * RPC module for blended calculations (25% asset + 75% category)
+ */
+export declare class BlendedRPC {
+    private assetParams;
+    private categoryParams;
+    private pairsCache;
+    constructor(assetParams: AssetParametersRPC, categoryParams: CategoryParametersRPC, pairsCache: PairsCache);
+    /**
+     * Calculate blended utilization (25% asset + 75% category)
+     * @returns Map of pair index to blended utilization
+     */
+    getBlendedUtilization(): Promise<Map<number, Utilization>>;
+    /**
+     * Calculate blended skew (25% asset + 75% category)
+     * @returns Map of pair index to blended skew
+     */
+    getBlendedSkew(): Promise<Map<number, Skew>>;
+}

package/dist/rpc/blended.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlendedRPC = void 0;
+/**
+ * RPC module for blended calculations (25% asset + 75% category)
+ */
+class BlendedRPC {
+    constructor(assetParams, categoryParams, pairsCache) {
+        this.assetParams = assetParams;
+        this.categoryParams = categoryParams;
+        this.pairsCache = pairsCache;
+    }
+    /**
+     * Calculate blended utilization (25% asset + 75% category)
+     * @returns Map of pair index to blended utilization
+     */
+    async getBlendedUtilization() {
+        const assetUtilization = await this.assetParams.getUtilization();
+        const categoryUtilization = await this.categoryParams.getUtilization();
+        const pairs = await this.pairsCache.getPairsInfo();
+        const blended = new Map();
+        for (const [pairIndex, pairInfo] of pairs) {
+            const assetUtil = assetUtilization.get(pairIndex);
+            const catUtil = categoryUtilization.get(pairInfo.groupIndex);
+            if (assetUtil && catUtil) {
+                blended.set(pairIndex, {
+                    utilizationLong: 0.25 * assetUtil.utilizationLong + 0.75 * catUtil.utilizationLong,
+                    utilizationShort: 0.25 * assetUtil.utilizationShort + 0.75 * catUtil.utilizationShort,
+                });
+            }
+        }
+        return blended;
+    }
+    /**
+     * Calculate blended skew (25% asset + 75% category)
+     * @returns Map of pair index to blended skew
+     */
+    async getBlendedSkew() {
+        const assetSkew = await this.assetParams.getAssetSkew();
+        const categorySkew = await this.categoryParams.getCategorySkew();
+        const pairs = await this.pairsCache.getPairsInfo();
+        const blended = new Map();
+        for (const [pairIndex, pairInfo] of pairs) {
+            const assetSk = assetSkew.get(pairIndex);
+            const catSk = categorySkew.get(pairInfo.groupIndex);
+            if (assetSk && catSk) {
+                blended.set(pairIndex, {
+                    skew: 0.25 * assetSk.skew + 0.75 * catSk.skew,
+                });
+            }
+        }
+        return blended;
+    }
+}
+exports.BlendedRPC = BlendedRPC;

package/dist/rpc/category_parameters.d.ts

@@ -0,0 +1,34 @@
+import { Contract, Provider } from 'ethers';
+import { OpenInterest, Utilization, Skew } from '../types';
+import { PairsCache } from './pairs_cache';
+/**
+ * RPC module for retrieving category-level parameters
+ */
+export declare class CategoryParametersRPC {
+    private provider;
+    private pairStorageContract;
+    private pairsCache;
+    constructor(provider: Provider, pairStorageContract: Contract, 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
+     */
+    getOILimits(): Promise<Map<number, OpenInterest>>;
+    /**
+     * Get current open interest per category
+     * Note: Calculated by summing pair OIs in each group
+     * @returns Map of group index to OI
+     */
+    getOI(): Promise<Map<number, OpenInterest>>;
+    /**
+     * Get utilization per category
+     * @returns Map of group index to utilization
+     */
+    getUtilization(): Promise<Map<number, Utilization>>;
+    /**
+     * Get category skew (long / total)
+     * @returns Map of group index to skew
+     */
+    getCategorySkew(): Promise<Map<number, Skew>>;
+}

package/dist/rpc/category_parameters.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryParametersRPC = void 0;
+/**
+ * RPC module for retrieving category-level parameters
+ */
+class CategoryParametersRPC {
+    constructor(provider, pairStorageContract, 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() {
+        const groupIndexes = await this.pairsCache.getGroupIndexes();
+        const limits = new Map();
+        // 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() {
+        const groupIndexes = await this.pairsCache.getGroupIndexes();
+        const oi = new Map();
+        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() {
+        const oi = await this.getOI();
+        const utilization = new Map();
+        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() {
+        const oi = await this.getOI();
+        const skew = new Map();
+        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;
+    }
+}
+exports.CategoryParametersRPC = CategoryParametersRPC;

package/dist/rpc/delegation.d.ts

@@ -0,0 +1,81 @@
+import { Contract, TransactionReceipt } 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 declare class DelegationRPC {
+    private tradingContract;
+    private signer?;
+    constructor(tradingContract: Contract, signer?: BaseSigner | undefined);
+    /**
+     * 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
+     */
+    setDelegate(delegate: string): Promise<TransactionReceipt | null>;
+    /**
+     * Remove the current delegate for the caller
+     * @returns Transaction receipt
+     */
+    removeDelegate(): Promise<TransactionReceipt | null>;
+    /**
+     * Get the delegate wallet for a given owner
+     * @param owner - Owner address to check
+     * @returns Delegate address (0x0 if none set)
+     */
+    getDelegateFor(owner: string): Promise<string>;
+    /**
+     * 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
+     */
+    delegatedAction(trader: string, callData: string, value?: bigint): Promise<TransactionReceipt | null>;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Helper method to sign and send transactions
+     */
+    private signAndSend;
+    /**
+     * Set signer for transactions
+     */
+    setSigner(signer: BaseSigner): void;
+}

package/dist/rpc/delegation.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegationRPC = void 0;
+/**
+ * Delegation RPC
+ * Handles delegation functionality for the Trading contract.
+ * Allows one address to execute trades on behalf of another.
+ */
+class DelegationRPC {
+    constructor(tradingContract, signer) {
+        this.tradingContract = tradingContract;
+        this.signer = signer;
+    }
+    /**
+     * 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) {
+        if (!this.signer) {
+            throw new Error('Signer required for delegation operations');
+        }
+        const tx = {
+            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() {
+        if (!this.signer) {
+            throw new Error('Signer required for delegation operations');
+        }
+        const tx = {
+            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) {
+        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, callData, value = 0n) {
+        if (!this.signer) {
+            throw new Error('Signer required for delegation operations');
+        }
+        const tx = {
+            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, orderType, slippageP) {
+        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, index, amount) {
+        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, index, newSl, newTp, priceUpdateData) {
+        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, index, updateType, amount, priceUpdateData) {
+        return this.tradingContract.interface.encodeFunctionData('updateMargin', [
+            pairIndex,
+            index,
+            updateType,
+            amount,
+            priceUpdateData,
+        ]);
+    }
+    /**
+     * 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.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) {
+        this.signer = signer;
+    }
+}
+exports.DelegationRPC = DelegationRPC;

package/dist/rpc/fee_parameters.d.ts

@@ -0,0 +1,46 @@
+import { Contract, Provider } from 'ethers';
+import { Fee, TradeInput } from '../types';
+import { PairsCache } from './pairs_cache';
+/**
+ * RPC module for fee calculations
+ */
+export declare class FeeParametersRPC {
+    private provider;
+    private pairInfosContract;
+    private referralContract?;
+    private pairsCache;
+    constructor(provider: Provider, pairInfosContract: Contract, pairsCache: PairsCache, referralContract?: Contract);
+    /**
+     * Get margin fee for all pairs (in basis points)
+     * @returns Map of pair index to fee
+     */
+    getMarginFee(): Promise<Map<number, Fee>>;
+    /**
+     * Get constant spread parameter for each pair
+     * @returns Map of pair index to constant spread
+     */
+    constantSpreadParameter(): Promise<Map<number, number>>;
+    /**
+     * 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
+     */
+    getOpeningFee(positionSize: number, isLong: boolean, pairIndex: number): Promise<number>;
+    /**
+     * Get opening fee for a new trade with referral
+     * @param tradeInput - Trade input parameters
+     * @param referrer - Referrer address (optional)
+     * @returns Opening fee in USDC
+     */
+    getNewTradeOpeningFee(tradeInput: TradeInput, referrer?: string): Promise<number>;
+    /**
+     * Get trade referral rebate
+     * @param trader - Trader address
+     * @param referrer - Referrer address
+     * @param openingFee - Opening fee amount
+     * @returns Rebate amount
+     */
+    getTradeReferralRebate(trader: string, referrer: string, openingFee: number): Promise<number>;
+}

package/dist/rpc/fee_parameters.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeeParametersRPC = void 0;
+const types_1 = require("../types");
+/**
+ * RPC module for fee calculations
+ */
+class FeeParametersRPC {
+    constructor(provider, pairInfosContract, pairsCache, referralContract) {
+        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() {
+        const pairs = await this.pairsCache.getPairsInfo();
+        const fees = new Map();
+        for (const [pairIndex] of pairs) {
+            try {
+                const feeP = await this.pairInfosContract.getPairMarginFeeP(pairIndex);
+                fees.set(pairIndex, {
+                    feeP: (0, types_1.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() {
+        const pairs = await this.pairsCache.getPairsInfo();
+        const spreads = new Map();
+        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, isLong, pairIndex) {
+        try {
+            const feeUsdc = await this.pairInfosContract.getOpenFeeUsdc(pairIndex, (0, types_1.toBlockchain6)(positionSize), isLong);
+            return (0, types_1.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, referrer) {
+        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, referrer, openingFee) {
+        if (!this.referralContract) {
+            return 0;
+        }
+        try {
+            const rebateP = await this.referralContract.getReferralRebateP(trader, referrer);
+            const rebatePercentage = (0, types_1.fromBlockchain10)(rebateP);
+            return openingFee * (rebatePercentage / 100);
+        }
+        catch (error) {
+            console.error('Error getting referral rebate:', error);
+            return 0;
+        }
+    }
+}
+exports.FeeParametersRPC = FeeParametersRPC;