@zofai/zo-sdk 0.1.92

package/dist/implementations/ZLPDataAPI.cjs

@@ -0,0 +1,1267 @@
+"use strict";
+/* eslint-disable no-await-in-loop */
+/**
+ * ZLP DataAPI implementation
+ * Implements ZLP-specific data access methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLPDataAPI = void 0;
+const utils_1 = require("@mysten/sui/utils");
+const abstract_1 = require("../abstract/index.cjs");
+const consts_1 = require("../consts/index.cjs");
+const utils_2 = require("../utils.cjs");
+class ZLPDataAPI extends abstract_1.BaseDataAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, consts_1.LPToken.ZLP);
+    }
+    async getStaked(owner) {
+        let rawCredentialsData = [];
+        let queryNextPage = true;
+        let queryCursor;
+        const limit = 50;
+        while (queryNextPage) {
+            const { data, hasNextPage, nextCursor } = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    MoveModule: {
+                        package: this.sharedConfig.zoStaking.package,
+                        module: 'pool',
+                    },
+                },
+                options: {
+                    showType: true,
+                    showContent: true,
+                },
+                cursor: queryCursor,
+                limit,
+            });
+            queryNextPage = hasNextPage;
+            queryCursor = nextCursor;
+            if (!data)
+                break;
+            rawCredentialsData = [...rawCredentialsData, ...data];
+        }
+        const pool = await this.getStakePool();
+        // TODO: Update reward coin type once available
+        const credentials = rawCredentialsData
+            .filter((item) => item.data.type
+            === `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.zoCore.package}::zlp::ZLP, 0x2::sui::SUI>`)
+            .map((item) => ZLPDataAPI.parseCredential(item, pool));
+        return {
+            credentials,
+            amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
+            claimable: credentials.reduce((acc, cur) => acc + cur.claimable, BigInt(0)),
+        };
+    }
+    async getStakePool() {
+        const poolId = this.sharedConfig.zoStaking.pools.zlp;
+        const raw = await this.provider.getObject({
+            id: poolId,
+            options: {
+                showContent: true,
+            },
+        });
+        return ZLPDataAPI.parseStakePool(raw);
+    }
+    /**
+     * Creates vaults valuation for ZLP
+     */
+    valuateVaults(tx) {
+        const vaultsValuation = tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::create_vaults_valuation`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+            ],
+        });
+        for (const key of Object.keys(this.consts.zoCore.vaults)) {
+            const vault = this.consts.zoCore.vaults[key];
+            tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::valuate_vault`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[key].module,
+                ],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(vault.reservingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[key]),
+                    vaultsValuation,
+                ],
+            });
+        }
+        return vaultsValuation;
+    }
+    /**
+     * Creates symbols valuation for ZLP
+     */
+    valuateSymbols(tx) {
+        const symbolsValuation = tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::create_symbols_valuation`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+            ],
+        });
+        for (const key of Object.keys(this.consts.zoCore.symbols)) {
+            const [direction, token] = (0, utils_2.parseSymbolKey)(key);
+            const symbol = this.consts.zoCore.symbols[key];
+            tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::valuate_symbol`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[token].module,
+                    `${this.consts.zoCore.package}::market::${direction.toUpperCase()}`,
+                ],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(symbol.fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[token]),
+                    symbolsValuation,
+                ],
+            });
+        }
+        return symbolsValuation;
+    }
+    /**
+     * Creates both vaults and symbols valuation
+     */
+    valuate(tx) {
+        const vaultsValuation = this.valuateVaults(tx);
+        const symbolsValuation = this.valuateSymbols(tx);
+        return { vaultsValuation, symbolsValuation };
+    }
+    /**
+     * Valuates the ZLP market
+     */
+    async valuateMarket() {
+        const marketInfo = await this.getMarketInfo();
+        let zlpPrice = 0;
+        let value = 0;
+        const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
+            const vaultInfo = await this.getVaultInfo(vault);
+            const reservingFeeDelta = ZLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
+            return (reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount) * (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[vault].decimals);
+        });
+        const symbolPromises = Object.keys(this.consts.zoCore.symbols).map(async (symbol) => {
+            const [direction, tokenId] = (0, utils_2.parseSymbolKey)(symbol);
+            const symbolInfo = await this.getSymbolInfo(tokenId, direction === 'long');
+            const price = (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked();
+            const deltaSize = ZLPDataAPI.calcDeltaSize(symbolInfo, price);
+            const oiState = await this.getSymbolOiFundingState(tokenId);
+            const pairedInfo = await this.getSymbolInfo(tokenId, direction !== 'long');
+            const fundingFeeDelta = ZLPDataAPI.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, price, marketInfo.lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState.model : undefined, pairedInfo.openingSize);
+            return fundingFeeDelta + deltaSize;
+        });
+        const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), Promise.all(symbolPromises)]);
+        value = vaultValues.reduce((acc, curr) => acc + curr, 0);
+        value += symbolValues.reduce((acc, curr) => acc + curr, 0);
+        zlpPrice = value / marketInfo.lpSupplyWithDecimals;
+        return {
+            marketCap: value,
+            price: zlpPrice,
+            supply: marketInfo.lpSupplyWithDecimals,
+            apr: Number(marketInfo.apr),
+        };
+    }
+    /**
+     * Gets ZLP market information
+     */
+    async getMarketInfo() {
+        this.validateCache();
+        if (this.marketInfoCache) {
+            return this.marketInfoCache;
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.zoCore.market,
+            options: {
+                showContent: true,
+            },
+        });
+        return ZLPDataAPI.parseMarketInfo(rawData);
+    }
+    /**
+     * Gets ZLP vault information
+     */
+    async getVaultInfo(vaultToken) {
+        this.validateCache();
+        if (this.vaultInfoCache[vaultToken]) {
+            return this.vaultInfoCache[vaultToken];
+        }
+        const rawData = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.vaultsParent,
+            name: {
+                type: `${this.consts.zoCore.package}::market::VaultName<${this.consts.coins[vaultToken].module}>`,
+                value: { dummy_field: false },
+            },
+        });
+        return await this.parseVaultInfo(rawData);
+    }
+    /**
+     * Gets ZLP symbol information
+     */
+    async getSymbolInfo(indexToken, long) {
+        this.validateCache();
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        if (this.symbolInfoCache[symbol]) {
+            return this.symbolInfoCache[symbol];
+        }
+        const rawData = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.symbolsParent,
+            name: {
+                type: `${this.consts.zoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+                value: { dummy_field: false },
+            },
+        });
+        return await this.parseSymbolInfo(rawData, long);
+    }
+    async getPositionConfig(indexToken, long) {
+        this.validateCache();
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        if (this.positionConfigCache[symbol]) {
+            return this.positionConfigCache[symbol];
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.zoCore.symbols[symbol].positionConfig,
+            options: {
+                showContent: true,
+            },
+        });
+        return ZLPDataAPI.parsePositionConfig(rawData);
+    }
+    /**
+     * Gets ZLP symbol configuration
+     */
+    async getSymbolConfig(indexToken, long) {
+        this.validateCache();
+        try {
+            const rawData = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.zoCore.market,
+                name: {
+                    type: `${this.consts.zoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+                    value: { dummy_field: false },
+                },
+            });
+            return ZLPDataAPI.parseSymbolConfig(rawData);
+        }
+        catch (e) {
+            // If the dynamic field doesn't exist, return null
+            console.error('Error Fetching Symbol Config:', e);
+            return null;
+        }
+    }
+    /**
+     * Gets ZLP symbol OI funding model
+     */
+    async getSymbolOiFundingState(indexToken) {
+        this.validateCache();
+        try {
+            const rawData = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.zoCore.market,
+                name: {
+                    type: `0x6e77b426313c6a8b4a47081b141cdea1f8fa7e58e892af05f516849c05a96811::funding::FundingStateKey<${this.consts.coins[indexToken].module}>`,
+                    value: { dummy_field: false },
+                },
+            });
+            return ZLPDataAPI.parseOiFundingState(rawData);
+        }
+        catch (e) {
+            // If the dynamic field doesn't exist, return null
+            console.error('Error Fetching Symbol OI Funding State:', e);
+            return null;
+        }
+    }
+    /**
+     * Gets price impact configuration for a symbol.
+     * Price impact config applies to both long and short directions for the same index token.
+     */
+    async getPriceImpactConfig(indexToken) {
+        this.validateCache();
+        try {
+            const rawData = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.zoCore.market,
+                name: {
+                    type: `0x05248f4f39558466b1f7e55bd09072bb8a6c31b6514d42ce0b50b7f36356d204::price_impact::PriceImpactConfigKey<${this.consts.coins[indexToken].module}>`,
+                    value: { dummy_field: false },
+                },
+            });
+            return ZLPDataAPI.parsePriceImpactConfig(rawData);
+        }
+        catch (e) {
+            // If the dynamic field doesn't exist, return null (price impact not configured for this symbol)
+            console.error('Error Fetching Price Impact Config:', e);
+            return null;
+        }
+    }
+    async getPositionCapInfoList(owner) {
+        const positionCapInfoList = [];
+        let cursor;
+        let hasNextPage = true;
+        while (hasNextPage) {
+            const positionCaps = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    MoveModule: {
+                        package: this.consts.zoCore.package,
+                        module: 'market',
+                    },
+                },
+                options: {
+                    showType: true,
+                },
+                cursor,
+            });
+            for (const positionCap of positionCaps.data) {
+                if (positionCap.data?.type?.includes('PositionCap')) {
+                    positionCapInfoList.push({
+                        positionCapId: positionCap.data.objectId,
+                        symbol0: positionCap.data.type.split('<')[1].split(',')[0].trim(),
+                        symbol1: positionCap.data.type.split('<')[1].split(',')[1].split(',')[0].trim(),
+                        long: positionCap.data.type.includes('LONG'),
+                    });
+                }
+            }
+            // If we don't want to fetch all pages or there are no more pages, break the loop
+            hasNextPage = positionCaps.hasNextPage;
+            cursor = positionCaps.nextCursor;
+        }
+        return positionCapInfoList;
+    }
+    async getPositionInfoList(positionCapInfoList, owner, batchSize = 10) {
+        const positionInfoList = [];
+        // Process in batches of 10
+        for (let i = 0; i < positionCapInfoList.length; i += batchSize) {
+            const batch = positionCapInfoList.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (positionCapInfo) => {
+                try {
+                    const positionRaw = await this.provider.getDynamicFieldObject({
+                        parentId: this.consts.zoCore.positionsParent,
+                        name: {
+                            type: `${this.consts.zoCore.package}::market::PositionName<${positionCapInfo.symbol0}, ${positionCapInfo.symbol1}, ${this.consts.zoCore.package}::market::${positionCapInfo.long ? 'LONG' : 'SHORT'}>`,
+                            value: {
+                                owner,
+                                id: positionCapInfo.positionCapId,
+                            },
+                        },
+                    });
+                    positionInfoList.push(await this.parsePositionInfo(positionRaw, positionCapInfo.positionCapId));
+                }
+                catch (error) {
+                    // Position might have been deleted after force settlement
+                    console.warn(`Failed to parse position info for position cap ID ${positionCapInfo.positionCapId}: ${error}`);
+                    // Continue with next position without adding this one to the list
+                }
+            }));
+        }
+        return positionInfoList.sort((a, b) => a.openTimestamp > b.openTimestamp ? 1 : -1);
+    }
+    async getOpenPositions(batchSize = 50, symbol = 'sui') {
+        let positionDynamicFields = [];
+        let _continue = true;
+        let cursor;
+        while (_continue) {
+            // data here will be a list of dynamic fields containing name and value
+            const { data, nextCursor, hasNextPage } = await this.provider.getDynamicFields({
+                parentId: this.consts.zoCore.positionsParent,
+                cursor,
+            });
+            positionDynamicFields = positionDynamicFields.concat(data);
+            _continue = hasNextPage;
+            cursor = nextCursor;
+        }
+        // Filter by symbol if provided
+        if (!(symbol && this.consts.coins[symbol])) {
+            return [];
+        }
+        const coinModule = symbol === 'sui' ? '0x2::sui::SUI' : this.consts.coins[symbol].module;
+        positionDynamicFields = positionDynamicFields.filter((field) => {
+            // Extract the second coin module from PositionName<coin1, coin2, direction>
+            const typeStr = field.name?.type;
+            if (!typeStr)
+                return false;
+            const match = typeStr.match(/PositionName<([^,]+),([^,]+),([^>]+)>/);
+            if (!match)
+                return false;
+            const secondCoin = match[2].trim();
+            return secondCoin === coinModule;
+        });
+        // then we query by dynamic field names and order by time
+        const positionInfoList = [];
+        // Process in batches of 50 (or specified batchSize)
+        for (let i = 0; i < positionDynamicFields.length; i += batchSize) {
+            const batch = positionDynamicFields.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (positionDynamicField) => {
+                const positionRaw = await this.provider.getDynamicFieldObject({
+                    parentId: this.consts.zoCore.positionsParent,
+                    name: positionDynamicField.name,
+                });
+                if (positionRaw?.data?.content) {
+                    // @ts-expect-error: content fields type is not properly defined
+                    if (positionRaw?.data?.content?.fields?.value?.fields?.closed) {
+                        // skip closed positions
+                        return;
+                    }
+                    const positionInfo = await this.parsePositionInfo(positionRaw, positionDynamicField.objectId);
+                    if (positionInfo) {
+                        positionInfoList.push(positionInfo);
+                    }
+                }
+            }));
+        }
+        return positionInfoList
+            .filter(positionInfo => !positionInfo.closed)
+            .sort((a, b) => (a.openTimestamp > b.openTimestamp ? 1 : -1));
+    }
+    async getOrderCapInfoList(owner) {
+        const orderCapInfoList = [];
+        let cursor;
+        let hasNextPage = true;
+        while (hasNextPage) {
+            const orderCaps = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    MoveModule: {
+                        package: this.consts.zoCore.package,
+                        module: 'market',
+                    },
+                },
+                options: {
+                    showType: true,
+                    showContent: true,
+                },
+                cursor,
+            });
+            for (const orderCap of orderCaps.data) {
+                if (orderCap.data?.type?.includes('OrderCap')) {
+                    orderCapInfoList.push({
+                        orderCapId: orderCap.data.objectId,
+                        symbol0: orderCap.data.type.split('<')[1].split(',')[0].trim(),
+                        symbol1: orderCap.data.type.split('<')[1].split(',')[1].split(',')[0].trim(),
+                        long: orderCap.data.type.includes('LONG'),
+                        positionId: orderCap.data.content?.fields?.position_id,
+                    });
+                }
+            }
+            hasNextPage = orderCaps.hasNextPage;
+            cursor = orderCaps.nextCursor;
+        }
+        return orderCapInfoList;
+    }
+    async getOrderInfoList(orderCapInfoList, owner, batchSize = 10) {
+        const orderInfoList = [];
+        // Process in batches of 10
+        for (let i = 0; i < orderCapInfoList.length; i += batchSize) {
+            const batch = orderCapInfoList.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (orderCapInfo) => {
+                try {
+                    const orderRaw = await this.provider.getDynamicFieldObject({
+                        parentId: this.consts.zoCore.ordersParent,
+                        name: {
+                            // We have enforced collateral coin type to match with fee coin type so we can use symbol0 in the first slot and the last slot of the OrderName
+                            type: `${this.consts.zoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.zoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${orderCapInfo.symbol0}>`,
+                            value: {
+                                owner,
+                                id: orderCapInfo.orderCapId,
+                                position_id: {
+                                    vec: orderCapInfo.positionId ? [orderCapInfo.positionId] : [],
+                                },
+                            },
+                        },
+                    });
+                    orderInfoList.push(this.parseOrderInfo(orderRaw, orderCapInfo.orderCapId));
+                }
+                catch (error) {
+                    // Order might have been deleted
+                    console.warn(`Failed to parse order info for order cap ID ${orderCapInfo.orderCapId}: ${error}`);
+                    // Continue with next order without adding this one to the list
+                }
+            }));
+        }
+        return orderInfoList.sort((a, b) => a.createdAt > b.createdAt ? 1 : -1);
+    }
+    async hasReferral(referree) {
+        const raw = await this.getReferralData(referree);
+        return !raw.error;
+    }
+    async getReferralData(referree) {
+        const raw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.referralsParent,
+            name: {
+                type: 'address',
+                value: referree,
+            },
+        });
+        return raw;
+    }
+    /**
+     * Gets rebase fee model for ZLP
+     */
+    async getRebaseFeeModel() {
+        this.validateCache();
+        if (this.rebaseFeeModelCache) {
+            return this.rebaseFeeModelCache;
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.zoCore.rebaseFeeModel,
+            options: {
+                showContent: true,
+            },
+        });
+        const model = ZLPDataAPI.parseRebaseFeeModel(rawData);
+        const exponent = await ZLPDataAPI.getRebaseFeeExponent(this.provider, this.consts.zoCore.rebaseFeeModel, this.consts.zoCore.upgradedPackage);
+        return { ...model, exponent };
+    }
+    async fundingFeeRate(indexToken, long) {
+        const oiState = await this.getSymbolOiFundingState(indexToken);
+        if (!oiState || !oiState.enabled) {
+            const symbol = await this.getSymbolInfo(indexToken, long);
+            if (symbol.lastUpdate <= 0) {
+                return 0;
+            }
+            const price = (await this.getOraclePrice(indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked();
+            const lpSupplyAmount = (await this.getMarketInfo()).lpSupplyWithDecimals;
+            const model = symbol.fundingFeeModel;
+            const elapsed = consts_1.SECONDS_PER_EIGHT_HOUR;
+            const deltaSize = ZLPDataAPI.calcDeltaSize(symbol, price);
+            const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+            return ZLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+        }
+        const longSymbol = await this.getSymbolInfo(indexToken, true);
+        const shortSymbol = await this.getSymbolInfo(indexToken, false);
+        if (longSymbol.lastUpdate <= 0 && shortSymbol.lastUpdate <= 0) {
+            return 0;
+        }
+        const elapsed = consts_1.SECONDS_PER_EIGHT_HOUR;
+        const longSize = longSymbol.openingSize;
+        const shortSize = shortSymbol.openingSize;
+        const deltaRate = ZLPDataAPI.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed);
+        return long ? deltaRate : -deltaRate;
+    }
+    async rebaseFeeRate(collateralToken, increase, amount) {
+        let vaultValue = 0;
+        if (!increase && amount > 0) {
+            amount = -amount;
+        }
+        const value = amount * (await this.getOraclePrice(collateralToken)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[collateralToken].decimals);
+        const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
+            const vaultInfo = await this.getVaultInfo(vault);
+            const reservingFeeDelta = ZLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
+            const res = (reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount) * (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[vault].decimals);
+            if (collateralToken === vault) {
+                vaultValue = res;
+            }
+            return res;
+        });
+        const vaultValues = await Promise.all(vaultPromises);
+        const totalVaultValue = vaultValues.reduce((acc, curr) => acc + curr, 0);
+        const targetRatio = Number.parseInt(this.consts.zoCore.vaults[collateralToken].weight, 10) / Object.values(this.consts.zoCore.vaults)
+            .map(e => Number.parseInt(e.weight, 10))
+            .reduce((acc, curr) => acc + curr, 0);
+        return ZLPDataAPI.calcRebaseFeeRate(await this.getRebaseFeeModel(), increase, (vaultValue + value) / (totalVaultValue + value), targetRatio);
+    }
+    async reservingFeeRate(collateralToken, amount = 0) {
+        const vaultInfo = await this.getVaultInfo(collateralToken);
+        const vaultSupply = vaultInfo.liquidity + vaultInfo.reservedAmount + vaultInfo.unrealisedReservingFeeAmount + amount;
+        const utilization = vaultSupply ? ((vaultInfo.reservedAmount + amount) / vaultSupply) : 0;
+        return ZLPDataAPI.calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, consts_1.SECONDS_PER_EIGHT_HOUR);
+    }
+    async getHistory(trader, page, limit, orderType, symbol) {
+        const params = new URLSearchParams({
+            trader,
+            page: page.toString(),
+            limit: limit.toString(),
+        });
+        // Add filter parameters if provided
+        if (orderType && orderType !== 'all') {
+            params.append('orderType', orderType);
+        }
+        if (symbol && symbol !== 'all') {
+            params.append('symbol', symbol);
+        }
+        params.append('lpType', 'ZLP');
+        const url = `${this.apiEndpoint}/traderEvents?${params}`;
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        const response = await res.json();
+        return {
+            histories: response.data?.histories || [],
+            pagination: response.data?.pagination || {
+                total: 0,
+                page: 1,
+                limit: 20,
+                pages: 0,
+            },
+        };
+    }
+    // Private helper methods
+    static calcFundingFeeRate(model, pnlPerRate, elapsed) {
+        const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max);
+        const secondsRate = dailyRate * elapsed / consts_1.SECONDS_PER_EIGHT_HOUR;
+        return pnlPerRate >= 0 ? -secondsRate : secondsRate;
+    }
+    static calcOiFundingFeeRate(model, longSize, shortSize, elapsed) {
+        const imbalance = Math.abs(longSize - shortSize);
+        // multiplier = 0.1%, exponent = 1
+        const dailyRate = Math.min(model.multiplier * (imbalance ** model.exponent) / (longSize + shortSize > 0 ? longSize + shortSize : 1), model.max);
+        const secondsRate = dailyRate * elapsed / consts_1.SECONDS_PER_EIGHT_HOUR;
+        return longSize >= shortSize ? secondsRate : -secondsRate;
+    }
+    static calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
+        if (symbol.lastUpdate > 0) {
+            const elapsed = timestamp - symbol.lastUpdate;
+            if (elapsed > 0) {
+                // Prefer OI-based delta when model and paired side are available
+                if (oiModel && typeof pairedOpeningSize === 'number') {
+                    const longSize = symbol.long ? symbol.openingSize : pairedOpeningSize;
+                    const shortSize = symbol.long ? pairedOpeningSize : symbol.openingSize;
+                    const deltaRate = ZLPDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed);
+                    const appliedRate = symbol.long ? deltaRate : -deltaRate;
+                    return symbol.accFundingRate + appliedRate;
+                }
+                // Fallback to PnL-based funding delta
+                const deltaSize = ZLPDataAPI.calcDeltaSize(symbol, price);
+                const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+                return symbol.accFundingRate + ZLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+            }
+        }
+        return symbol.accFundingRate;
+    }
+    static calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
+        const accFundingRate = ZLPDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize);
+        return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize;
+    }
+    static calculatePositionReserveFee(position, vault, model, timestamp) {
+        const accReservingRate = ZLPDataAPI.calcAccReservingFeeRate(vault, model, timestamp);
+        return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.reservedAmount;
+    }
+    static calcAccReservingFeeRate(vault, model, timestamp) {
+        if (vault.lastUpdate > 0) {
+            const elapsed = timestamp - vault.lastUpdate;
+            if (elapsed > 0) {
+                const utilization = ZLPDataAPI.vaultUtilization(vault);
+                return vault.accReservingRate + ZLPDataAPI.calcReservingFeeRate(model, utilization, elapsed);
+            }
+        }
+        return vault.accReservingRate;
+    }
+    static calcRebaseFeeRate(model, increase, ratio, targetRatio) {
+        if ((increase && ratio <= targetRatio) || (!increase && ratio >= targetRatio)) {
+            return model.base;
+        }
+        const exponent = model.exponent ?? 1;
+        return model.base + model.multiplier * (Math.abs(ratio - targetRatio) ** exponent);
+    }
+    static vaultUtilization(vault) {
+        const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount;
+        if (supplyAmount === 0) {
+            return 0;
+        }
+        return vault.reservedAmount / supplyAmount;
+    }
+    static calcReservingFeeRate(model, utilization, elapsed) {
+        return model.multiplier * utilization * elapsed / consts_1.SECONDS_PER_EIGHT_HOUR;
+    }
+    static calcDeltaSize(symbol, price) {
+        const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price;
+        return symbol.long ? symbol.openingSize - latestSize : latestSize - symbol.openingSize;
+    }
+    static parseMarketInfo(raw) {
+        const content = raw.data.content.fields;
+        return {
+            lpSupply: content.lp_supply.fields.value,
+            positionId: content.positions.fields.id.id,
+            vaultId: content.vaults.fields.id.id,
+            symbolId: content.symbols.fields.id.id,
+            referralId: content.referrals.fields.id.id,
+            orderId: content.orders.fields.id.id,
+            rebaseFeeModel: content.rebase_fee_model,
+            lpSupplyWithDecimals: content.lp_supply.fields.value / (10 ** consts_1.ZLP_TOKEN_DECIMALS),
+        };
+    }
+    async parseVaultInfo(raw) {
+        const vaultFields = raw.data.content.fields.value.fields;
+        const reservingFeeModelAddr = vaultFields.reserving_fee_model;
+        const reservingFeeModelRaw = await this.provider.getObject({
+            id: reservingFeeModelAddr,
+            options: {
+                showContent: true,
+            },
+        });
+        const reservingFeeModel = ZLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
+        return {
+            liquidity: (0, utils_2.parseValue)(vaultFields.liquidity),
+            reservedAmount: (0, utils_2.parseValue)(vaultFields.reserved_amount),
+            unrealisedReservingFeeAmount: (0, utils_2.parseValue)(vaultFields.unrealised_reserving_fee_amount),
+            accReservingRate: (0, utils_2.parseValue)(vaultFields.acc_reserving_rate),
+            enabled: vaultFields.enabled,
+            weight: (0, utils_2.parseValue)(vaultFields.weight),
+            lastUpdate: (0, utils_2.parseValue)(vaultFields.last_update),
+            reservingFeeModel,
+            priceConfig: {
+                maxInterval: (0, utils_2.parseValue)(vaultFields.price_config.fields.max_interval),
+                maxConfidence: (0, utils_2.parseValue)(vaultFields.price_config.fields.max_confidence),
+                precision: (0, utils_2.parseValue)(vaultFields.price_config.fields.precision),
+                feeder: vaultFields.price_config.fields.feeder,
+            },
+        };
+    }
+    async parseSymbolInfo(raw, long) {
+        const { objectId } = raw.data;
+        const { fields } = raw.data.content.fields.value;
+        const fundingFeeModelAddr = fields.funding_fee_model;
+        const fundingFeeModelRaw = await this.provider.getObject({
+            id: fundingFeeModelAddr,
+            options: {
+                showContent: true,
+            },
+        });
+        const fundingFeeModel = ZLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
+        return {
+            objectId,
+            openingSize: (0, utils_2.parseValue)(fields.opening_size),
+            openingAmount: (0, utils_2.parseValue)(fields.opening_amount),
+            accFundingRate: (0, utils_2.parseValue)(fields.acc_funding_rate),
+            realisedPnl: (0, utils_2.parseValue)(fields.realised_pnl),
+            unrealisedFundingFeeValue: (0, utils_2.parseValue)(fields.unrealised_funding_fee_value),
+            openEnabled: fields.open_enabled,
+            liquidateEnabled: fields.liquidate_enabled,
+            decreaseEnabled: fields.decrease_enabled,
+            lastUpdate: (0, utils_2.parseValue)(fields.last_update),
+            fundingFeeModel,
+            long,
+            priceConfig: {
+                maxInterval: (0, utils_2.parseValue)(fields.price_config.fields.max_interval),
+                maxConfidence: (0, utils_2.parseValue)(fields.price_config.fields.max_confidence),
+                precision: (0, utils_2.parseValue)(fields.price_config.fields.precision),
+                feeder: fields.price_config.fields.feeder,
+            },
+        };
+    }
+    static parsePositionConfig(raw) {
+        const positionConfigFields = raw.data.content.fields.inner.fields;
+        return {
+            decreaseFeeBps: (0, utils_2.parseValue)(positionConfigFields.decrease_fee_bps),
+            liquidationBonus: (0, utils_2.parseValue)(positionConfigFields.liquidation_bonus),
+            liquidationThreshold: (0, utils_2.parseValue)(positionConfigFields.liquidation_threshold),
+            maxLeverage: (0, utils_2.parseValue)(positionConfigFields.max_leverage),
+            minHoldingDuration: (0, utils_2.parseValue)(positionConfigFields.min_holding_duration),
+            openFeeBps: (0, utils_2.parseValue)(positionConfigFields.open_fee_bps),
+            maxReservedMultiplier: (0, utils_2.parseValue)(positionConfigFields.max_reserved_multiplier),
+            minCollateralValue: (0, utils_2.parseValue)(positionConfigFields.min_collateral_value),
+        };
+    }
+    static parseSymbolConfig(raw) {
+        const { fields } = raw.data.content;
+        return {
+            id: fields.id.id,
+            max_opening_size: (0, utils_2.parseValue)(fields.max_opening_size),
+            max_opening_size_enabled: fields.max_opening_size_enabled,
+            max_opening_size_per_position: (0, utils_2.parseValue)(fields.max_opening_size_per_position),
+            max_opening_size_per_position_enabled: fields.max_opening_size_per_position_enabled,
+            instant_exit_fee_config: {
+                instant_exit_tier_1_duration_threshold: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_1_duration_threshold),
+                instant_exit_tier_1_fee_bps: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_bps.fields.value),
+                instant_exit_tier_1_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_enabled,
+                instant_exit_tier_2_duration_threshold: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_2_duration_threshold),
+                instant_exit_tier_2_fee_bps: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_bps.fields.value),
+                instant_exit_tier_2_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_enabled,
+                instant_exit_tier_3_duration_threshold: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_3_duration_threshold),
+                instant_exit_tier_3_fee_bps: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_bps.fields.value),
+                instant_exit_tier_3_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_enabled,
+            },
+        };
+    }
+    async parsePositionInfo(raw, id_) {
+        const { content } = raw.data;
+        const { fields } = content;
+        const positionFields = fields.value.fields;
+        const dataType = fields.name.type;
+        const positionInfo = {
+            id: id_,
+            long: dataType.includes('::market::LONG'),
+            owner: fields.name.fields.owner,
+            version: Number.parseInt(raw.data.version, 10),
+            collateralToken: (0, utils_2.suiSymbolToSymbol)(dataType.split('<')[1].split(',')[0].trim(), this.consts),
+            indexToken: (0, utils_2.suiSymbolToSymbol)(dataType.split(',')[1].trim(), this.consts),
+            collateralAmount: (0, utils_2.parseValue)(positionFields.collateral),
+            positionAmount: (0, utils_2.parseValue)(positionFields.position_amount),
+            reservedAmount: (0, utils_2.parseValue)(positionFields.reserved),
+            positionSize: (0, utils_2.parseValue)(positionFields.position_size),
+            lastFundingRate: (0, utils_2.parseValue)(positionFields.last_funding_rate),
+            lastReservingRate: (0, utils_2.parseValue)(positionFields.last_reserving_rate),
+            reservingFeeAmount: (0, utils_2.parseValue)(positionFields.reserving_fee_amount),
+            fundingFeeValue: (0, utils_2.parseValue)(positionFields.funding_fee_value),
+            closed: positionFields.closed,
+            openTimestamp: (0, utils_2.parseValue)(positionFields.open_timestamp),
+        };
+        positionInfo.reservingFeeAmount = ZLPDataAPI.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000);
+        // OI context for funding: fetch state and paired side size when enabled
+        const oiState = await this.getSymbolOiFundingState(positionInfo.indexToken);
+        const pairedSymbol = await this.getSymbolInfo(positionInfo.indexToken, !positionInfo.long);
+        positionInfo.fundingFeeValue = ZLPDataAPI.calculatePositionFundingFee(positionInfo, await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long), (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel, (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(), (await this.getMarketInfo()).lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState.model : undefined, pairedSymbol.openingSize);
+        return positionInfo;
+    }
+    static calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
+        const accFundingRate = ZLPDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize);
+        return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
+    }
+    static parseRebaseFeeModel(raw) {
+        const { fields } = raw.data.content;
+        return {
+            base: (0, utils_2.parseValue)(fields.base),
+            multiplier: (0, utils_2.parseValue)(fields.multiplier),
+        };
+    }
+    /**
+     * Fetches rebase fee exponent from chain (dynamic field RebaseFeeExponentKey).
+     * Returns 1 (linear) for backward compatibility when not set.
+     */
+    static async getRebaseFeeExponent(provider, rebaseFeeModelId, packageId) {
+        const WAD = 1e18;
+        try {
+            const raw = await provider.getDynamicFieldObject({
+                parentId: rebaseFeeModelId,
+                name: {
+                    type: `${packageId}::model::RebaseFeeExponentKey`,
+                    value: {},
+                },
+            });
+            if (raw.data?.content && 'fields' in raw.data.content) {
+                const value = raw.data.content.fields?.value;
+                if (value !== undefined) {
+                    return Number(BigInt(value)) / WAD;
+                }
+            }
+        }
+        catch {
+            // Dynamic field doesn't exist - use default WAD (linear)
+        }
+        return 1;
+    }
+    static parseReservingFeeModel(raw) {
+        const content = raw.data.content.fields;
+        return {
+            multiplier: (0, utils_2.parseValue)(content.multiplier),
+        };
+    }
+    static parseFundingFeeModel(raw) {
+        const content = raw.data.content.fields;
+        return {
+            multiplier: (0, utils_2.parseValue)(content.multiplier),
+            max: (0, utils_2.parseValue)(content.max),
+        };
+    }
+    static parseOiFundingState(raw) {
+        const content = raw.data.content.fields;
+        return {
+            id: content.id.id,
+            enabled: content.enabled,
+            last_update: (0, utils_2.parseValue)(content.last_update),
+            model: {
+                id: content.model.fields.id.id,
+                multiplier: (0, utils_2.parseValue)(content.model.fields.multiplier),
+                exponent: (0, utils_2.parseValue)(content.model.fields.exponent),
+                max: (0, utils_2.parseValue)(content.model.fields.max),
+            },
+        };
+    }
+    static parsePriceImpactConfig(raw) {
+        const content = raw.data.content.fields;
+        return {
+            id: content.id.id,
+            enabled: content.enabled,
+            baseSpreadRate: (0, utils_2.parseValue)(content.base_spread_rate),
+            maxDynamicSpreadRate: (0, utils_2.parseValue)(content.max_dynamic_spread_rate),
+            maxTotalSpreadRate: (0, utils_2.parseValue)(content.max_total_spread_rate),
+            impactExponent: (0, utils_2.parseValue)(content.impact_exponent),
+            maxOiLong: (0, utils_2.parseValue)(content.max_oi_long),
+            maxOiShort: (0, utils_2.parseValue)(content.max_oi_short),
+            referenceSize: (0, utils_2.parseValue)(content.reference_size),
+        };
+    }
+    /**
+     * Computes the spread rate based on OI skew between long and short sides using point evaluation.
+     * This is the offchain equivalent of price_impact::compute_spread_rate in the Move contract.
+     *
+     * NOTE: This method uses point evaluation at the final state. For large trades,
+     * use computeAverageSpreadRate() instead, which integrates over the trade path
+     * for more accurate pricing.
+     *
+     * @param config - Price impact configuration for the symbol
+     * @param currentOiThisSide - Current OI on the side being traded (in value terms)
+     * @param newPositionSize - Size of the new position in value terms
+     * @param currentOiOpposite - Current OI on the opposite side (in value terms)
+     * @param maxOiThisSide - Maximum OI for this side (from config or SymbolConfig)
+     * @param maxOiOpposite - Maximum OI for opposite side (from config or SymbolConfig)
+     * @returns Total spread rate to apply (as a decimal, e.g., 0.001 = 0.1%)
+     */
+    static computeSpreadRate(config, currentOiThisSide, newPositionSize, currentOiOpposite, maxOiThisSide, maxOiOpposite) {
+        // If not enabled, return zero spread
+        if (!config.enabled) {
+            return 0;
+        }
+        // If maxOiThisSide is zero, return base spread only (cannot compute utilization)
+        if (maxOiThisSide === 0) {
+            return config.baseSpreadRate;
+        }
+        // Calculate this side utilization: (current_oi + new_position) / max_oi
+        const totalOiThis = currentOiThisSide + newPositionSize;
+        const thisUtil = Math.min(totalOiThis / maxOiThisSide, 1);
+        // Calculate opposite side utilization: current_oi / max_oi
+        let oppositeUtil = 0;
+        if (maxOiOpposite > 0) {
+            oppositeUtil = Math.min(currentOiOpposite / maxOiOpposite, 1);
+        }
+        // Calculate skew_ratio = this_util - opposite_util, clamped to [0, 1]
+        // Positive when this side is more utilized (crowded), which increases spread
+        let skewRatio = thisUtil - oppositeUtil;
+        if (skewRatio < 0) {
+            skewRatio = 0; // No penalty when opposite side is more crowded
+        }
+        else if (skewRatio > 1) {
+            skewRatio = 1; // Cap at 1.0
+        }
+        // Calculate dynamic_spread = max_dynamic * (skew_ratio ^ exponent)
+        // For fractional exponents, use linear interpolation
+        const exponent = config.impactExponent;
+        const exponentInt = Math.floor(exponent);
+        const exponentFrac = exponent - exponentInt;
+        // Compute base^exponent_int
+        let ratioPowered = skewRatio ** exponentInt;
+        // For fractional exponent, interpolate: result = base^n + frac * (base^(n+1) - base^n)
+        if (exponentFrac > 0) {
+            const ratioPoweredNext = skewRatio ** (exponentInt + 1);
+            const diff = ratioPoweredNext - ratioPowered;
+            if (diff >= 0) {
+                ratioPowered += exponentFrac * diff;
+            }
+        }
+        // dynamic_spread = max_dynamic_spread * final_ratio
+        const dynamicSpread = config.maxDynamicSpreadRate * ratioPowered;
+        // total_spread = base_spread + dynamic_spread
+        let totalSpread = config.baseSpreadRate + dynamicSpread;
+        // Cap at max_total_spread
+        if (totalSpread > config.maxTotalSpreadRate) {
+            totalSpread = config.maxTotalSpreadRate;
+        }
+        return totalSpread;
+    }
+    /**
+     * Computes the size factor multiplier based on position size.
+     * Formula: size_factor = 1 + min(1, position_size / reference_size)
+     *
+     * @param positionSize - Size of the new position
+     * @param referenceSize - Reference size for scaling (0 = disabled)
+     * @returns Size factor multiplier (1.0 to 2.0)
+     */
+    static computeSizeFactor(positionSize, referenceSize) {
+        // If reference_size is zero, size scaling is disabled
+        if (referenceSize === 0) {
+            return 1;
+        }
+        // Compute position_size / reference_size, capped at 1
+        const ratio = Math.min(positionSize / referenceSize, 1);
+        // Return 1 + capped_ratio
+        return 1 + ratio;
+    }
+    /**
+     * Computes the average value of max_dynamic * s^n over the interval [s1, s2].
+     * Uses the integral formula: average = max_dynamic * (s2^(n+1) - s1^(n+1)) / ((n+1) * (s2 - s1))
+     *
+     * @param maxDynamic - Maximum dynamic spread rate
+     * @param s1 - Start skew ratio
+     * @param s2 - End skew ratio
+     * @param exponent - Impact exponent
+     * @returns Average dynamic spread rate
+     */
+    static computeIntegralAverage(maxDynamic, s1, s2, exponent) {
+        // If s1 == s2, return point evaluation
+        if (s1 === s2) {
+            return maxDynamic * (s1 ** exponent);
+        }
+        // Compute n + 1
+        const nPlus1 = exponent + 1;
+        // Compute s2^(n+1) and s1^(n+1)
+        const s2Pow = s2 ** nPlus1;
+        const s1Pow = s1 ** nPlus1;
+        // Compute numerator: s2^(n+1) - s1^(n+1)
+        const numerator = Math.abs(s2Pow - s1Pow);
+        // Compute denominator: (n+1) * (s2 - s1)
+        const sDiff = Math.abs(s2 - s1);
+        const denominator = nPlus1 * sDiff;
+        // Avoid division by zero
+        if (denominator === 0) {
+            return 0;
+        }
+        // Compute average ratio and multiply by max_dynamic
+        return maxDynamic * (numerator / denominator);
+    }
+    /**
+     * Computes the average spread rate over the trade path with size scaling.
+     * This is the offchain equivalent of price_impact::compute_average_spread_rate in the Move contract.
+     *
+     * This function integrates the spread over the utilization change rather than
+     * using the final-state spread, and applies a size-based multiplier to the
+     * dynamic spread component.
+     *
+     * @param config - Price impact configuration for the symbol
+     * @param currentOiThisSide - Current OI on the side being traded (in value terms)
+     * @param newPositionSize - Size of the new position in value terms
+     * @param currentOiOpposite - Current OI on the opposite side (in value terms)
+     * @param maxOiThisSide - Maximum OI for this side (from config or SymbolConfig)
+     * @param maxOiOpposite - Maximum OI for opposite side (from config or SymbolConfig)
+     * @returns Total spread rate to apply (as a decimal, e.g., 0.001 = 0.1%)
+     */
+    static computeAverageSpreadRate(config, currentOiThisSide, newPositionSize, currentOiOpposite, maxOiThisSide, maxOiOpposite) {
+        // If not enabled, return zero spread
+        if (!config.enabled) {
+            return 0;
+        }
+        // If maxOiThisSide is zero, return base spread only (cannot compute utilization)
+        if (maxOiThisSide === 0) {
+            return config.baseSpreadRate;
+        }
+        // Calculate opposite side utilization (constant throughout the trade)
+        let oppositeUtil = 0;
+        if (maxOiOpposite > 0) {
+            oppositeUtil = Math.min(currentOiOpposite / maxOiOpposite, 1);
+        }
+        // Calculate start utilization: current_oi / max_oi
+        const startUtil = Math.min(currentOiThisSide / maxOiThisSide, 1);
+        // Calculate end utilization: (current_oi + new_position) / max_oi
+        const totalOiThis = currentOiThisSide + newPositionSize;
+        const endUtil = Math.min(totalOiThis / maxOiThisSide, 1);
+        // Calculate start skew: max(0, min(1, start_util - opposite_util))
+        let startSkew = startUtil - oppositeUtil;
+        if (startSkew < 0) {
+            startSkew = 0;
+        }
+        else if (startSkew > 1) {
+            startSkew = 1;
+        }
+        // Calculate end skew: max(0, min(1, end_util - opposite_util))
+        let endSkew = endUtil - oppositeUtil;
+        if (endSkew < 0) {
+            endSkew = 0;
+        }
+        else if (endSkew > 1) {
+            endSkew = 1;
+        }
+        // Compute average dynamic spread via integral
+        const avgDynamicRate = ZLPDataAPI.computeIntegralAverage(config.maxDynamicSpreadRate, startSkew, endSkew, config.impactExponent);
+        // Apply size scaling factor to dynamic spread
+        const sizeFactor = ZLPDataAPI.computeSizeFactor(newPositionSize, config.referenceSize);
+        const scaledDynamicRate = avgDynamicRate * sizeFactor;
+        // total_spread = base_spread + scaled_dynamic
+        let totalSpread = config.baseSpreadRate + scaledDynamicRate;
+        // Cap at max_total_spread
+        if (totalSpread > config.maxTotalSpreadRate) {
+            totalSpread = config.maxTotalSpreadRate;
+        }
+        return totalSpread;
+    }
+    /**
+     * Applies price impact to a price.
+     * This is the offchain equivalent of price_impact::apply_price_impact in the Move contract.
+     *
+     * Direction logic:
+     * - Open Long: price INCREASES (pay more)
+     * - Open Short: price DECREASES (receive less)
+     * - Close Long: price DECREASES (receive less)
+     * - Close Short: price INCREASES (pay more)
+     *
+     * @param originalPrice - The original price
+     * @param spreadRate - The spread rate to apply (as a decimal, e.g., 0.001 = 0.1%)
+     * @param isLong - Whether this is a long position
+     * @param isOpening - Whether this is opening (true) or closing (false)
+     * @returns Adjusted price with spread applied
+     */
+    static applyPriceImpact(originalPrice, spreadRate, isLong, isOpening) {
+        // If spread is zero, return original price
+        if (spreadRate === 0) {
+            return originalPrice;
+        }
+        // Determine if we should increase or decrease price
+        // Open Long or Close Short -> increase price
+        // Open Short or Close Long -> decrease price
+        const increasePrice = (isLong && isOpening) || (!isLong && !isOpening);
+        // Calculate spread amount: price * spread_rate
+        const spreadAmount = originalPrice * spreadRate;
+        // Apply spread
+        if (increasePrice) {
+            return originalPrice + spreadAmount;
+        }
+        // Ensure we don't go negative
+        const adjusted = originalPrice - spreadAmount;
+        return Math.max(adjusted, 0);
+    }
+    /**
+     * Convenience method to compute the estimated execution price with price impact.
+     * Fetches the required data and computes the adjusted price.
+     *
+     * @param indexToken - The index token symbol (e.g., 'sui', 'btc')
+     * @param isLong - Whether this is a long position
+     * @param isOpening - Whether this is opening or closing
+     * @param positionSizeValue - Size of the position in value terms (USD)
+     * @returns Object containing spread rate and adjusted price, or null if price impact not configured
+     */
+    async estimatePriceImpact(indexToken, isLong, isOpening, positionSizeValue) {
+        const config = await this.getPriceImpactConfig(indexToken);
+        if (!config) {
+            return null;
+        }
+        // Get current OI for both sides
+        const longSymbol = await this.getSymbolInfo(indexToken, true);
+        const shortSymbol = await this.getSymbolInfo(indexToken, false);
+        // Get oracle price
+        const oraclePrice = (await this.getOraclePrice(indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked();
+        // Determine which side is "this" side and which is "opposite"
+        const currentOiThisSide = isLong ? longSymbol.openingSize : shortSymbol.openingSize;
+        const currentOiOpposite = isLong ? shortSymbol.openingSize : longSymbol.openingSize;
+        const maxOiThisSide = isLong ? config.maxOiLong : config.maxOiShort;
+        const maxOiOpposite = isLong ? config.maxOiShort : config.maxOiLong;
+        // Compute average spread rate (uses integration for better accuracy on large trades)
+        const spreadRate = ZLPDataAPI.computeAverageSpreadRate(config, currentOiThisSide, positionSizeValue, currentOiOpposite, maxOiThisSide, maxOiOpposite);
+        // Apply price impact
+        const adjustedPrice = ZLPDataAPI.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening);
+        return {
+            spreadRate,
+            originalPrice: oraclePrice,
+            adjustedPrice,
+        };
+    }
+    parseOrderInfo(raw, capId) {
+        const { content } = raw.data;
+        const { fields } = content.fields.value;
+        // Extract tokens from dataType
+        const dataType = content?.type;
+        let orderType;
+        if (content.fields.value?.type.includes('OpenPositionOrder')) {
+            orderType = 'OPEN_POSITION';
+        }
+        else if (content.fields.value?.type.includes('OpenMarketOrder')) {
+            orderType = 'OPEN_MARKET';
+        }
+        else if (content.fields.value?.type.includes('DecreasePositionOrder')) {
+            orderType = 'DECREASE_POSITION';
+        }
+        else {
+            orderType = 'DECREASE_MARKET';
+        }
+        const ret = {
+            id: content.fields.id.id,
+            capId,
+            executed: fields.executed,
+            owner: content.fields.name.fields.owner,
+            collateralToken: (0, utils_2.suiSymbolToSymbol)(dataType.split('<')[2].split(',')[0].trim(), this.consts),
+            indexToken: (0, utils_2.suiSymbolToSymbol)(dataType.split(',')[1].trim(), this.consts),
+            feeToken: (0, utils_2.suiSymbolToSymbol)(dataType.split(',')[3].split('>')[0].trim(), this.consts),
+            // Use index_price for open orders, limited_index_price for decrease orders
+            indexPrice: orderType === 'OPEN_MARKET'
+                ? (0, utils_2.parseValue)(fields.index_price)
+                : (0, utils_2.parseValue)(fields.limited_index_price?.fields?.price || fields.limited_index_price),
+            collateralPriceThreshold: fields.collateral_price_threshold ? (0, utils_2.parseValue)(fields.collateral_price_threshold) : 0,
+            // New index price threshold
+            indexPriceThreshold: fields.index_price_threshold ? (0, utils_2.parseValue)(fields.index_price_threshold) : undefined,
+            feeAmount: BigInt(fields.fee),
+            long: dataType.includes('::market::LONG'),
+            orderType,
+            createdAt: (0, utils_2.parseValue)(fields.created_at),
+            v11Order: !fields.limited_index_price?.fields?.price,
+            // New: referrer and scard fields
+            referrer: fields.referrer,
+            scardId: (fields.scard_id?.fields?.some?.fields?.id
+                || fields.scard_id?.fields?.value?.fields?.id
+                || fields.scard_id?.fields?.id
+                || fields.scard_id?.id),
+            scardRebateRate: (() => {
+                const inner = fields.scard_rebate_rate?.fields?.some ?? fields.scard_rebate_rate?.fields?.value;
+                return inner ? (0, utils_2.parseValue)(inner) : undefined;
+            })(),
+        };
+        if (orderType === 'OPEN_POSITION' || orderType === 'OPEN_MARKET') {
+            ret.openOrder = {
+                reserveAmount: BigInt(fields.reserve_amount),
+                collateralAmount: BigInt(fields.collateral),
+                openAmount: BigInt(fields.open_amount),
+                // New: position_config from OpenMarketOrder
+                positionConfig: fields.position_config?.fields
+                    ? {
+                        decreaseFeeBps: (0, utils_2.parseValue)(fields.position_config.fields.decrease_fee_bps),
+                        liquidationBonus: (0, utils_2.parseValue)(fields.position_config.fields.liquidation_bonus),
+                        liquidationThreshold: (0, utils_2.parseValue)(fields.position_config.fields.liquidation_threshold),
+                        maxLeverage: (0, utils_2.parseValue)(fields.position_config.fields.max_leverage),
+                        minHoldingDuration: (0, utils_2.parseValue)(fields.position_config.fields.min_holding_duration),
+                        openFeeBps: (0, utils_2.parseValue)(fields.position_config.fields.open_fee_bps),
+                        maxReservedMultiplier: (0, utils_2.parseValue)(fields.position_config.fields.max_reserved_multiplier),
+                        minCollateralValue: (0, utils_2.parseValue)(fields.position_config.fields.min_collateral_value),
+                    }
+                    : undefined,
+            };
+        }
+        else if (orderType === 'DECREASE_POSITION' || orderType === 'DECREASE_MARKET') {
+            ret.decreaseOrder = {
+                decreaseAmount: BigInt(fields.decrease_amount),
+                takeProfit: fields.take_profit,
+            };
+        }
+        return ret;
+    }
+    static calculateVaultReservingFee(vaultInfo, reservingFeeModel, currentTime) {
+        const timeDelta = currentTime - vaultInfo.lastUpdate;
+        const periods = Math.floor(timeDelta / consts_1.SECONDS_PER_EIGHT_HOUR);
+        return vaultInfo.unrealisedReservingFeeAmount
+            + (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18;
+    }
+    static parseCredential(raw, pool) {
+        const stakedAmount = BigInt(raw.data.content.fields.stake);
+        const accRewardPerShare = BigInt(raw.data.content.fields.acc_reward_per_share);
+        return {
+            id: raw.data.objectId,
+            lockUntil: (0, utils_2.parseValue)(raw.data.content.fields.lock_until),
+            amount: stakedAmount,
+            accRewardPerShare,
+            claimable: ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount)
+                / BigInt(1e18),
+        };
+    }
+    static parseStakePool(raw) {
+        const content = raw.data.content.fields;
+        const pool = {
+            id: content.id.id,
+            enabled: content.enabled,
+            lastUpdatedTime: (0, utils_2.parseValue)(content.last_updated_time),
+            stakedAmount: BigInt(content.staked_amount),
+            reward: BigInt(content.reward_vault),
+            startTime: (0, utils_2.parseValue)(content.start_time),
+            endTime: (0, utils_2.parseValue)(content.end_time),
+            rewardRate: BigInt(content.reward_rate),
+            accRewardPerShare: BigInt(content.acc_reward_per_share),
+            lockDuration: (0, utils_2.parseValue)(content.lock_duration),
+        };
+        ZLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000));
+        return pool;
+    }
+    static refreshPool(pool, timestamp) {
+        if (timestamp <= pool.lastUpdatedTime || timestamp < pool.startTime) {
+            return;
+        }
+        const applicableEndTime = Math.max(pool.endTime, pool.lastUpdatedTime);
+        const calculationEndTime = Math.min(timestamp, applicableEndTime);
+        if (calculationEndTime > pool.lastUpdatedTime && pool.stakedAmount > BigInt(0) && pool.rewardRate > BigInt(0)) {
+            const timeDiff = BigInt(calculationEndTime - pool.lastUpdatedTime);
+            const rewardAmount = timeDiff * pool.rewardRate;
+            const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount;
+            pool.accRewardPerShare += rewardPerShare;
+        }
+        pool.lastUpdatedTime = calculationEndTime;
+    }
+}
+exports.ZLPDataAPI = ZLPDataAPI;
+//# sourceMappingURL=ZLPDataAPI.cjs.map