perps-sdk-ts 1.0.1

package/dist/feed/feed_client.d.ts

@@ -0,0 +1,68 @@
+import { PriceFeedResponse } from "../types";
+/**
+ * Callback function type for price updates
+ */
+export type PriceUpdateCallback = (priceData: PriceFeedResponse) => void;
+/**
+ * WebSocket client for real-time price feeds from Pyth Network
+ */
+export declare class FeedClient {
+    private url;
+    private ws?;
+    private callbacks;
+    private onError?;
+    private onClose?;
+    private pairFeedMap;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    constructor(url?: string, onError?: (error: Error) => void, onClose?: () => void);
+    /**
+     * Register a callback for a specific price feed
+     */
+    registerPriceFeedCallback(feedId: string, callback: PriceUpdateCallback): void;
+    /**
+     * Unregister a callback for a specific price feed
+     */
+    unregisterPriceFeedCallback(feedId: string, callback: PriceUpdateCallback): void;
+    /**
+     * Load pair to feed ID mappings
+     */
+    loadPairFeeds(pairFeeds: Map<string, string>): void;
+    /**
+     * Get feed ID for a trading pair
+     */
+    getFeedIdForPair(pairName: string): string | undefined;
+    /**
+     * Connect to WebSocket and listen for price updates
+     */
+    listenForPriceUpdates(): Promise<void>;
+    /**
+     * Subscribe to specific price feeds
+     */
+    private subscribeToPriceFeeds;
+    /**
+     * Unsubscribe from specific price feeds
+     */
+    private unsubscribeFromPriceFeeds;
+    /**
+     * Handle incoming price update
+     */
+    private handlePriceUpdate;
+    /**
+     * Attempt to reconnect to WebSocket
+     */
+    private attemptReconnect;
+    /**
+     * Get latest prices via HTTP
+     */
+    getLatestPriceUpdates(feedIds: string[]): Promise<any>;
+    /**
+     * Close the WebSocket connection
+     */
+    close(): void;
+    /**
+     * Check if WebSocket is connected
+     */
+    isConnected(): boolean;
+}

package/dist/feed/feed_client.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const types_1 = require("../types");
+const config_1 = require("../config");
+/**
+ * Normalize feed ID: remove 0x prefix and lowercase
+ * Pyth WebSocket sends IDs WITHOUT 0x prefix
+ */
+function normalizeFeedId(feedId) {
+    let normalized = feedId.toLowerCase();
+    if (normalized.startsWith('0x')) {
+        normalized = normalized.slice(2);
+    }
+    return normalized;
+}
+/**
+ * WebSocket client for real-time price feeds from Pyth Network
+ */
+class FeedClient {
+    constructor(url = config_1.API_ENDPOINTS.PYTH_WS, onError, onClose) {
+        this.callbacks = new Map();
+        this.pairFeedMap = new Map();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;
+        this.url = url;
+        this.onError = onError;
+        this.onClose = onClose;
+    }
+    /**
+     * Register a callback for a specific price feed
+     */
+    registerPriceFeedCallback(feedId, callback) {
+        const id = normalizeFeedId(feedId);
+        if (!this.callbacks.has(id)) {
+            this.callbacks.set(id, []);
+        }
+        this.callbacks.get(id).push(callback);
+        if (this.callbacks.get(id).length === 1 && this.isConnected()) {
+            this.subscribeToPriceFeeds([id]);
+        }
+    }
+    /**
+     * Unregister a callback for a specific price feed
+     */
+    unregisterPriceFeedCallback(feedId, callback) {
+        const id = normalizeFeedId(feedId);
+        const cbs = this.callbacks.get(id);
+        if (!cbs)
+            return;
+        const idx = cbs.indexOf(callback);
+        if (idx > -1)
+            cbs.splice(idx, 1);
+        if (cbs.length === 0 && this.isConnected()) {
+            this.unsubscribeFromPriceFeeds([id]);
+            this.callbacks.delete(id);
+        }
+    }
+    /**
+     * Load pair to feed ID mappings
+     */
+    loadPairFeeds(pairFeeds) {
+        this.pairFeedMap = pairFeeds;
+    }
+    /**
+     * Get feed ID for a trading pair
+     */
+    getFeedIdForPair(pairName) {
+        return this.pairFeedMap.get(pairName);
+    }
+    /**
+     * Connect to WebSocket and listen for price updates
+     */
+    async listenForPriceUpdates() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new ws_1.default(this.url);
+                this.ws.on("open", () => {
+                    console.log("WebSocket connected to Pyth Network");
+                    this.reconnectAttempts = 0;
+                    const feedIds = Array.from(this.callbacks.keys());
+                    if (feedIds.length > 0) {
+                        this.subscribeToPriceFeeds(feedIds);
+                    }
+                    resolve();
+                });
+                this.ws.on("message", (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        if (message.type !== "price_update") {
+                            console.log("Received non-update message:", message);
+                        }
+                        if (message.type === "price_update") {
+                            this.handlePriceUpdate(message);
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error parsing WebSocket message:", error);
+                    }
+                });
+                this.ws.on("error", (error) => {
+                    console.error("WebSocket error:", error);
+                    if (this.onError) {
+                        this.onError(error);
+                    }
+                    reject(error);
+                });
+                this.ws.on("close", () => {
+                    console.log("WebSocket connection closed");
+                    if (this.onClose) {
+                        this.onClose();
+                    }
+                    this.attemptReconnect();
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Subscribe to specific price feeds
+     */
+    subscribeToPriceFeeds(feedIds) {
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN)
+            return;
+        // Feed IDs should already be normalized, but ensure they are
+        const ids = feedIds.map(id => normalizeFeedId(id));
+        this.ws.send(JSON.stringify({ type: "subscribe", ids }));
+        console.log("Subscribed to Pyth feeds:", ids);
+    }
+    /**
+     * Unsubscribe from specific price feeds
+     */
+    unsubscribeFromPriceFeeds(feedIds) {
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN)
+            return;
+        const ids = feedIds.map(id => normalizeFeedId(id));
+        this.ws.send(JSON.stringify({ type: "unsubscribe", ids }));
+        console.log("Unsubscribed from Pyth feeds:", ids);
+    }
+    /**
+     * Handle incoming price update
+     */
+    handlePriceUpdate(message) {
+        try {
+            if (message.price_feed) {
+                const priceUpdate = message.price_feed;
+                // ⭐ KEY FIX: Normalize the incoming feed ID (Pyth sends without 0x)
+                const feedId = normalizeFeedId(priceUpdate.id);
+                const priceFeed = {
+                    id: feedId,
+                    price: {
+                        price: priceUpdate.price.price,
+                        conf: priceUpdate.price.conf,
+                        expo: priceUpdate.price.expo,
+                        publishTime: priceUpdate.price.publish_time,
+                    },
+                    emaPrice: {
+                        price: priceUpdate.ema_price.price,
+                        conf: priceUpdate.ema_price.conf,
+                        expo: priceUpdate.ema_price.expo,
+                        publishTime: priceUpdate.ema_price.publish_time,
+                    },
+                };
+                const validatedPriceFeed = types_1.PriceFeedResponseSchema.parse(priceFeed);
+                // Trigger callbacks
+                const callbacks = this.callbacks.get(validatedPriceFeed.id);
+                if (callbacks && callbacks.length > 0) {
+                    console.log(`✅ Triggering ${callbacks.length} callback(s) for ${validatedPriceFeed.id}`);
+                    callbacks.forEach((callback) => {
+                        try {
+                            callback(validatedPriceFeed);
+                        }
+                        catch (error) {
+                            console.error("Error in price update callback:", error instanceof Error ? error.message : String(error));
+                        }
+                    });
+                }
+                else {
+                    console.warn(`⚠️ No callbacks registered for feed: ${validatedPriceFeed.id}`);
+                    console.log(`Registered feeds: [${Array.from(this.callbacks.keys()).join(", ")}]`);
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error processing price update:", error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Attempt to reconnect to WebSocket
+     */
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error("Max reconnection attempts reached");
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        console.log(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        setTimeout(() => {
+            this.listenForPriceUpdates().catch((error) => {
+                console.error("Reconnection failed:", error);
+            });
+        }, delay);
+    }
+    /**
+     * Get latest prices via HTTP
+     */
+    async getLatestPriceUpdates(feedIds) {
+        const url = `${config_1.API_ENDPOINTS.PYTH_HTTP}?ids[]=${feedIds.join("&ids[]=")}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch prices: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Close the WebSocket connection
+     */
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = undefined;
+        }
+    }
+    /**
+     * Check if WebSocket is connected
+     */
+    isConnected() {
+        return this.ws !== undefined && this.ws.readyState === ws_1.default.OPEN;
+    }
+}
+exports.FeedClient = FeedClient;

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Avantis Trader SDK - TypeScript
+ *
+ * A comprehensive SDK for interacting with the Avantis decentralized
+ * leveraged trading platform.
+ */
+export { TraderClient } from './client';
+export { BaseSigner } from './signers/base';
+export { LocalSigner } from './signers/local';
+export { KMSSigner } from './signers/kms';
+export { FeedClient, PriceUpdateCallback } from './feed/feed_client';
+export { PairsCache } from './rpc/pairs_cache';
+export { AssetParametersRPC } from './rpc/asset_parameters';
+export { CategoryParametersRPC } from './rpc/category_parameters';
+export { FeeParametersRPC } from './rpc/fee_parameters';
+export { TradingParametersRPC } from './rpc/trading_parameters';
+export { BlendedRPC } from './rpc/blended';
+export { TradeRPC } from './rpc/trade';
+export { SnapshotRPC } from './rpc/snapshot';
+export { TradingOperationsRPC } from './rpc/trading_operations';
+export { DelegationRPC } from './rpc/delegation';
+export { PairInfoQueriesRPC } from './rpc/pair_info_queries';
+export { ReferralOperationsRPC } from './rpc/referral_operations';
+export { MulticallRPC, type MulticallCall, type MulticallResult } from './rpc/multicall';
+export { TradeInputOrderType, MarginUpdateType, type Spread, type PairInfo, type TradeInput, type TradeResponse, type Price, type EmaPrice, type PriceFeedResponse, type OpenInterest, type OpenInterestLimits, type Utilization, type Skew, type Fee, type Depth, type LossProtectionInfo, type PairData, type Group, type Snapshot, type Trade, type TradeInfo, type OpenLimitOrder, type ReferralTier, type ReferralDiscount, type ContractCallOptions, type TransactionReceipt, type PairsBackendReturn, type ContractPairInfo, type PairStruct, type GroupStruct, type FeeStruct, type FeedStruct, type BackupFeedStruct, type LeverageStruct, type ValuesStruct, type PnlFeesStruct, fromBlockchain10, fromBlockchain6, toBlockchain10, toBlockchain6, fromBlockchain12, toBlockchain12, fromBlockchain18, toBlockchain18, } from './types';
+export { CONTRACTS, API_ENDPOINTS, type ContractAddresses, type NetworkConfig, getContractAddress, setContractAddresses, } from './config';
+export { isTupleType, isArrayType, processOutputTypes, decoder, hexToNumber, numberToHex, isValidAddress, toChecksumAddress, sleep, retryWithBackoff, } from './utils';
+export { publicKeyIntToEthAddress, derEncodedPublicKeyToEthAddress, getSigRS, getSigV, getSigRSV, signatureToHex, } from './crypto/spki';

package/dist/index.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Avantis Trader SDK - TypeScript
+ *
+ * A comprehensive SDK for interacting with the Avantis decentralized
+ * leveraged trading platform.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatureToHex = exports.getSigRSV = exports.getSigV = exports.getSigRS = exports.derEncodedPublicKeyToEthAddress = exports.publicKeyIntToEthAddress = exports.retryWithBackoff = exports.sleep = exports.toChecksumAddress = exports.isValidAddress = exports.numberToHex = exports.hexToNumber = exports.decoder = exports.processOutputTypes = exports.isArrayType = exports.isTupleType = exports.setContractAddresses = exports.getContractAddress = exports.API_ENDPOINTS = exports.CONTRACTS = exports.toBlockchain18 = exports.fromBlockchain18 = exports.toBlockchain12 = exports.fromBlockchain12 = exports.toBlockchain6 = exports.toBlockchain10 = exports.fromBlockchain6 = exports.fromBlockchain10 = exports.MarginUpdateType = exports.TradeInputOrderType = exports.MulticallRPC = exports.ReferralOperationsRPC = exports.PairInfoQueriesRPC = exports.DelegationRPC = exports.TradingOperationsRPC = exports.SnapshotRPC = exports.TradeRPC = exports.BlendedRPC = exports.TradingParametersRPC = exports.FeeParametersRPC = exports.CategoryParametersRPC = exports.AssetParametersRPC = exports.PairsCache = exports.FeedClient = exports.KMSSigner = exports.LocalSigner = exports.BaseSigner = exports.TraderClient = void 0;
+// Main client
+var client_1 = require("./client");
+Object.defineProperty(exports, "TraderClient", { enumerable: true, get: function () { return client_1.TraderClient; } });
+// Signers
+var base_1 = require("./signers/base");
+Object.defineProperty(exports, "BaseSigner", { enumerable: true, get: function () { return base_1.BaseSigner; } });
+var local_1 = require("./signers/local");
+Object.defineProperty(exports, "LocalSigner", { enumerable: true, get: function () { return local_1.LocalSigner; } });
+var kms_1 = require("./signers/kms");
+Object.defineProperty(exports, "KMSSigner", { enumerable: true, get: function () { return kms_1.KMSSigner; } });
+// Feed client
+var feed_client_1 = require("./feed/feed_client");
+Object.defineProperty(exports, "FeedClient", { enumerable: true, get: function () { return feed_client_1.FeedClient; } });
+// RPC modules
+var pairs_cache_1 = require("./rpc/pairs_cache");
+Object.defineProperty(exports, "PairsCache", { enumerable: true, get: function () { return pairs_cache_1.PairsCache; } });
+var asset_parameters_1 = require("./rpc/asset_parameters");
+Object.defineProperty(exports, "AssetParametersRPC", { enumerable: true, get: function () { return asset_parameters_1.AssetParametersRPC; } });
+var category_parameters_1 = require("./rpc/category_parameters");
+Object.defineProperty(exports, "CategoryParametersRPC", { enumerable: true, get: function () { return category_parameters_1.CategoryParametersRPC; } });
+var fee_parameters_1 = require("./rpc/fee_parameters");
+Object.defineProperty(exports, "FeeParametersRPC", { enumerable: true, get: function () { return fee_parameters_1.FeeParametersRPC; } });
+var trading_parameters_1 = require("./rpc/trading_parameters");
+Object.defineProperty(exports, "TradingParametersRPC", { enumerable: true, get: function () { return trading_parameters_1.TradingParametersRPC; } });
+var blended_1 = require("./rpc/blended");
+Object.defineProperty(exports, "BlendedRPC", { enumerable: true, get: function () { return blended_1.BlendedRPC; } });
+var trade_1 = require("./rpc/trade");
+Object.defineProperty(exports, "TradeRPC", { enumerable: true, get: function () { return trade_1.TradeRPC; } });
+var snapshot_1 = require("./rpc/snapshot");
+Object.defineProperty(exports, "SnapshotRPC", { enumerable: true, get: function () { return snapshot_1.SnapshotRPC; } });
+var trading_operations_1 = require("./rpc/trading_operations");
+Object.defineProperty(exports, "TradingOperationsRPC", { enumerable: true, get: function () { return trading_operations_1.TradingOperationsRPC; } });
+var delegation_1 = require("./rpc/delegation");
+Object.defineProperty(exports, "DelegationRPC", { enumerable: true, get: function () { return delegation_1.DelegationRPC; } });
+var pair_info_queries_1 = require("./rpc/pair_info_queries");
+Object.defineProperty(exports, "PairInfoQueriesRPC", { enumerable: true, get: function () { return pair_info_queries_1.PairInfoQueriesRPC; } });
+var referral_operations_1 = require("./rpc/referral_operations");
+Object.defineProperty(exports, "ReferralOperationsRPC", { enumerable: true, get: function () { return referral_operations_1.ReferralOperationsRPC; } });
+var multicall_1 = require("./rpc/multicall");
+Object.defineProperty(exports, "MulticallRPC", { enumerable: true, get: function () { return multicall_1.MulticallRPC; } });
+// Types and enums
+var types_1 = require("./types");
+Object.defineProperty(exports, "TradeInputOrderType", { enumerable: true, get: function () { return types_1.TradeInputOrderType; } });
+Object.defineProperty(exports, "MarginUpdateType", { enumerable: true, get: function () { return types_1.MarginUpdateType; } });
+Object.defineProperty(exports, "fromBlockchain10", { enumerable: true, get: function () { return types_1.fromBlockchain10; } });
+Object.defineProperty(exports, "fromBlockchain6", { enumerable: true, get: function () { return types_1.fromBlockchain6; } });
+Object.defineProperty(exports, "toBlockchain10", { enumerable: true, get: function () { return types_1.toBlockchain10; } });
+Object.defineProperty(exports, "toBlockchain6", { enumerable: true, get: function () { return types_1.toBlockchain6; } });
+Object.defineProperty(exports, "fromBlockchain12", { enumerable: true, get: function () { return types_1.fromBlockchain12; } });
+Object.defineProperty(exports, "toBlockchain12", { enumerable: true, get: function () { return types_1.toBlockchain12; } });
+Object.defineProperty(exports, "fromBlockchain18", { enumerable: true, get: function () { return types_1.fromBlockchain18; } });
+Object.defineProperty(exports, "toBlockchain18", { enumerable: true, get: function () { return types_1.toBlockchain18; } });
+// Configuration
+var config_1 = require("./config");
+Object.defineProperty(exports, "CONTRACTS", { enumerable: true, get: function () { return config_1.CONTRACTS; } });
+Object.defineProperty(exports, "API_ENDPOINTS", { enumerable: true, get: function () { return config_1.API_ENDPOINTS; } });
+Object.defineProperty(exports, "getContractAddress", { enumerable: true, get: function () { return config_1.getContractAddress; } });
+Object.defineProperty(exports, "setContractAddresses", { enumerable: true, get: function () { return config_1.setContractAddresses; } });
+// Utilities
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "isTupleType", { enumerable: true, get: function () { return utils_1.isTupleType; } });
+Object.defineProperty(exports, "isArrayType", { enumerable: true, get: function () { return utils_1.isArrayType; } });
+Object.defineProperty(exports, "processOutputTypes", { enumerable: true, get: function () { return utils_1.processOutputTypes; } });
+Object.defineProperty(exports, "decoder", { enumerable: true, get: function () { return utils_1.decoder; } });
+Object.defineProperty(exports, "hexToNumber", { enumerable: true, get: function () { return utils_1.hexToNumber; } });
+Object.defineProperty(exports, "numberToHex", { enumerable: true, get: function () { return utils_1.numberToHex; } });
+Object.defineProperty(exports, "isValidAddress", { enumerable: true, get: function () { return utils_1.isValidAddress; } });
+Object.defineProperty(exports, "toChecksumAddress", { enumerable: true, get: function () { return utils_1.toChecksumAddress; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
+Object.defineProperty(exports, "retryWithBackoff", { enumerable: true, get: function () { return utils_1.retryWithBackoff; } });
+// Crypto utilities (for advanced usage)
+var spki_1 = require("./crypto/spki");
+Object.defineProperty(exports, "publicKeyIntToEthAddress", { enumerable: true, get: function () { return spki_1.publicKeyIntToEthAddress; } });
+Object.defineProperty(exports, "derEncodedPublicKeyToEthAddress", { enumerable: true, get: function () { return spki_1.derEncodedPublicKeyToEthAddress; } });
+Object.defineProperty(exports, "getSigRS", { enumerable: true, get: function () { return spki_1.getSigRS; } });
+Object.defineProperty(exports, "getSigV", { enumerable: true, get: function () { return spki_1.getSigV; } });
+Object.defineProperty(exports, "getSigRSV", { enumerable: true, get: function () { return spki_1.getSigRSV; } });
+Object.defineProperty(exports, "signatureToHex", { enumerable: true, get: function () { return spki_1.signatureToHex; } });

package/dist/rpc/asset_parameters.d.ts

@@ -0,0 +1,62 @@
+import { Contract, Provider } from 'ethers';
+import { OpenInterest, OpenInterestLimits, Utilization, Skew, TradeInput } from '../types';
+import { PairsCache } from './pairs_cache';
+/**
+ * RPC module for retrieving asset-level parameters
+ */
+export declare class AssetParametersRPC {
+    private provider;
+    private pairStorageContract;
+    private pairInfosContract;
+    private tradingStorageContract;
+    private pairsCache;
+    constructor(provider: Provider, pairStorageContract: Contract, pairInfosContract: Contract, pairsCache: PairsCache, tradingStorageContract: Contract);
+    /**
+     * Get open interest limits for all pairs
+     * @returns Map of pair index to OI limits
+     */
+    getOILimits(): Promise<Map<number, OpenInterestLimits>>;
+    /**
+     * Get current open interest for all pairs
+     * @returns Map of pair index to OI
+     */
+    getOI(): Promise<Map<number, OpenInterest>>;
+    /**
+     * Get utilization for all pairs
+     * @returns Map of pair index to utilization
+     */
+    getUtilization(): Promise<Map<number, Utilization>>;
+    /**
+     * Get asset skew (long / total) for all pairs
+     * @returns Map of pair index to skew
+     */
+    getAssetSkew(): Promise<Map<number, Skew>>;
+    /**
+     * Get price impact spread for opening a position
+     * @param positionSize - Position size in USDC
+     * @param isLong - True for long, false for short
+     * @param pairIndex - Pair index
+     * @returns Price impact spread percentage
+     */
+    getPriceImpactSpread(positionSize: number, isLong: boolean, pairIndex: number): Promise<number>;
+    /**
+     * Get skew impact spread
+     * @param pairIndex - Pair index
+     * @returns Skew impact spread
+     */
+    getSkewImpactSpread(pairIndex: number): Promise<number>;
+    /**
+     * Get opening price impact spread for a trade
+     * @param tradeInput - Trade input parameters
+     * @returns Opening price impact spread
+     */
+    getOpeningPriceImpactSpread(tradeInput: TradeInput): Promise<number>;
+    /**
+     * Get one percent depth (liquidity depth)
+     * @returns Map of pair index to depth
+     */
+    getOnePercentDepth(): Promise<Map<number, {
+        above: number;
+        below: number;
+    }>>;
+}

package/dist/rpc/asset_parameters.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetParametersRPC = void 0;
+const types_1 = require("../types");
+/**
+ * RPC module for retrieving asset-level parameters
+ */
+class AssetParametersRPC {
+    constructor(provider, pairStorageContract, pairInfosContract, pairsCache, tradingStorageContract) {
+        this.provider = provider;
+        this.pairStorageContract = pairStorageContract;
+        this.pairInfosContract = pairInfosContract;
+        this.tradingStorageContract = tradingStorageContract;
+        this.pairsCache = pairsCache;
+    }
+    /**
+     * Get open interest limits for all pairs
+     * @returns Map of pair index to OI limits
+     */
+    async getOILimits() {
+        const pairs = await this.pairsCache.getPairsInfo();
+        const limits = new Map();
+        for (const [pairIndex, pairInfo] of pairs) {
+            limits.set(pairIndex, {
+                pairIndex,
+                maxLong: pairInfo.maxLongOiP,
+                maxShort: pairInfo.maxShortOiP,
+            });
+        }
+        return limits;
+    }
+    /**
+     * Get current open interest for all pairs
+     * @returns Map of pair index to OI
+     */
+    async getOI() {
+        const pairs = await this.pairsCache.getPairsInfo();
+        const oi = new Map();
+        for (const [pairIndex] of pairs) {
+            try {
+                // Use TradingStorage contract which has openInterestUSDC method
+                const pairOILong = await this.tradingStorageContract.openInterestUSDC(pairIndex, 0); // 0 = long
+                const pairOIShort = await this.tradingStorageContract.openInterestUSDC(pairIndex, 1); // 1 = short
+                const limits = await this.getOILimits();
+                const maxOI = limits.get(pairIndex)?.maxLong || 0;
+                oi.set(pairIndex, {
+                    long: (0, types_1.fromBlockchain6)(pairOILong),
+                    short: (0, types_1.fromBlockchain6)(pairOIShort),
+                    max: maxOI,
+                });
+            }
+            catch (error) {
+                console.error(`Error getting OI for pair ${pairIndex}:`, error);
+                // Set default values on error
+                oi.set(pairIndex, {
+                    long: 0,
+                    short: 0,
+                    max: 0,
+                });
+            }
+        }
+        return oi;
+    }
+    /**
+     * Get utilization for all pairs
+     * @returns Map of pair index to utilization
+     */
+    async getUtilization() {
+        const oi = await this.getOI();
+        const utilization = new Map();
+        for (const [pairIndex, 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(pairIndex, {
+                utilizationLong,
+                utilizationShort,
+            });
+        }
+        return utilization;
+    }
+    /**
+     * Get asset skew (long / total) for all pairs
+     * @returns Map of pair index to skew
+     */
+    async getAssetSkew() {
+        const oi = await this.getOI();
+        const skew = new Map();
+        for (const [pairIndex, oiData] of oi) {
+            const total = oiData.long + oiData.short;
+            const skewValue = total > 0 ? oiData.long / total : 0.5;
+            skew.set(pairIndex, { skew: skewValue });
+        }
+        return skew;
+    }
+    /**
+     * Get price impact spread for opening a position
+     * @param positionSize - Position size in USDC
+     * @param isLong - True for long, false for short
+     * @param pairIndex - Pair index
+     * @returns Price impact spread percentage
+     */
+    async getPriceImpactSpread(positionSize, isLong, pairIndex) {
+        try {
+            const result = await this.pairInfosContract.getPriceImpactP(pairIndex, isLong, BigInt(Math.floor(positionSize * 1e6)));
+            return (0, types_1.fromBlockchain10)(result);
+        }
+        catch (error) {
+            console.error('Error getting price impact spread:', error);
+            return 0;
+        }
+    }
+    /**
+     * Get skew impact spread
+     * @param pairIndex - Pair index
+     * @returns Skew impact spread
+     */
+    async getSkewImpactSpread(pairIndex) {
+        try {
+            const skewMap = await this.getAssetSkew();
+            const skew = skewMap.get(pairIndex);
+            if (!skew)
+                return 0;
+            // Simple skew impact calculation (can be customized)
+            const deviation = Math.abs(skew.skew - 0.5);
+            return deviation * 100; // Convert to basis points
+        }
+        catch (error) {
+            console.error('Error getting skew impact spread:', error);
+            return 0;
+        }
+    }
+    /**
+     * Get opening price impact spread for a trade
+     * @param tradeInput - Trade input parameters
+     * @returns Opening price impact spread
+     */
+    async getOpeningPriceImpactSpread(tradeInput) {
+        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;
+        return await this.getPriceImpactSpread(positionSize, tradeInput.isLong, pairIndex);
+    }
+    /**
+     * Get one percent depth (liquidity depth)
+     * @returns Map of pair index to depth
+     */
+    async getOnePercentDepth() {
+        const pairs = await this.pairsCache.getPairsInfo();
+        const depth = new Map();
+        for (const [pairIndex] of pairs) {
+            try {
+                const depthAbove = await this.pairInfosContract.onePercentDepthAboveUsdc(pairIndex);
+                const depthBelow = await this.pairInfosContract.onePercentDepthBelowUsdc(pairIndex);
+                depth.set(pairIndex, {
+                    above: (0, types_1.fromBlockchain6)(depthAbove),
+                    below: (0, types_1.fromBlockchain6)(depthBelow),
+                });
+            }
+            catch (error) {
+                // If method doesn't exist, set default values
+                depth.set(pairIndex, { above: 0, below: 0 });
+            }
+        }
+        return depth;
+    }
+}
+exports.AssetParametersRPC = AssetParametersRPC;