@zofai/zo-sdk 0.1.92

package/dist/implementations/SLPDataAPI.mjs

@@ -0,0 +1,1380 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @stylistic/indent-binary-ops */
+/* eslint-disable @stylistic/indent */
+/**
+ * SLP DataAPI implementation
+ * Implements SLP-specific data access methods for Sudo SDK
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { BaseDataAPI } from "../abstract/index.mjs";
+import { Rate, SymbolsValuation, VaultsValuation } from "../bcs.mjs";
+import { LPToken, SLP_TOKEN_DECIMALS } from "../consts/index.mjs";
+import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from "../utils.mjs";
+let aprResponse = {};
+const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60; // 28800 seconds
+export class SLPDataAPI extends BaseDataAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, LPToken.SLP);
+    }
+    static calculateVaultReservingFee(vaultInfo, reservingFeeModel, currentTime) {
+        const timeDelta = currentTime - vaultInfo.lastUpdate;
+        const periods = Math.floor(timeDelta / SECONDS_PER_EIGHT_HOUR);
+        return vaultInfo.unrealisedReservingFeeAmount
+            + (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18;
+    }
+    static calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
+        const accFundingRate = SLPDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, symbol.long, oiModel, pairedOpeningSize);
+        return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize;
+    }
+    async getRebaseFeeModel() {
+        this.validateCache();
+        if (this.rebaseFeeModelCache) {
+            return this.rebaseFeeModelCache;
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.sudoCore.rebaseFeeModel,
+            options: {
+                showContent: true,
+            },
+        });
+        const model = SLPDataAPI.parseRebaseFeeModel(rawData);
+        const exponent = await SLPDataAPI.getRebaseFeeExponent(this.provider, this.consts.sudoCore.rebaseFeeModel, this.consts.sudoCore.upgradedPackage);
+        return { ...model, exponent };
+    }
+    /**
+     * Creates vaults valuation for SLP using Sudo SDK approach
+     */
+    valuateVaults(tx) {
+        if (!this.consts.sudoCore) {
+            throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP');
+        }
+        const vaultsValuation = tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::create_vaults_valuation`,
+            typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+            ],
+        });
+        for (const key of Object.keys(this.consts.sudoCore.vaults)) {
+            const vault = this.consts.sudoCore.vaults[key];
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::valuate_vault_v1_1`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[key].module,
+                ],
+                arguments: [
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(vault.reservingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[key]),
+                    vaultsValuation,
+                ],
+            });
+        }
+        return vaultsValuation;
+    }
+    /**
+     * Creates symbols valuation for SLP using Sudo SDK approach
+     */
+    valuateSymbols(tx) {
+        if (!this.consts.sudoCore) {
+            throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP');
+        }
+        const symbolsValuation = tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::create_symbols_valuation`,
+            typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+            ],
+        });
+        for (const key of Object.keys(this.consts.sudoCore.symbols)) {
+            const [direction, token] = parseSymbolKey(key);
+            const symbol = this.consts.sudoCore.symbols[key];
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::valuate_symbol_v1_1`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[token].module,
+                    `${this.consts.sudoCore.package}::market::${direction.toUpperCase()}`,
+                ],
+                arguments: [
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(symbol.fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[token]),
+                    symbolsValuation,
+                ],
+            });
+        }
+        return symbolsValuation;
+    }
+    /**
+     * Creates both vaults and symbols valuation for SLP
+     */
+    valuate(tx) {
+        const vaultsValuation = this.valuateVaults(tx);
+        const symbolsValuation = this.valuateSymbols(tx);
+        return { vaultsValuation, symbolsValuation };
+    }
+    /**
+     * Valuates the SLP market using Sudo SDK's approach
+     */
+    async valuateMarket() {
+        const marketInfo = await this.getMarketInfo();
+        let slpPrice = 0;
+        let value = 0;
+        const vaultPromises = Object.keys(this.consts.sudoCore.vaults).map(async (vault) => {
+            const vaultInfo = await this.getVaultInfo(vault);
+            const reservingFeeDelta = SLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
+            const totalVaultAmount = reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount;
+            const oraclePrice = (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked();
+            const { decimals } = this.consts.coins[vault];
+            const vaultValue = totalVaultAmount * oraclePrice / (10 ** decimals);
+            return vaultValue;
+        });
+        const symbolPromises = Object.keys(this.consts.sudoCore.symbols).map(async (symbol) => {
+            const [direction, tokenId] = parseSymbolKey(symbol);
+            const symbolInfo = await this.getSymbolInfo(tokenId, direction === 'long');
+            const price = (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked();
+            const deltaSize = SLPDataAPI.calcDeltaSize(symbolInfo, price, direction === 'long');
+            const oiState = await this.getSymbolOiFundingState(tokenId);
+            const pairedInfo = await this.getSymbolInfo(tokenId, direction !== 'long');
+            const fundingFeeDelta = SLPDataAPI.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, price, marketInfo.lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState.model : undefined, pairedInfo.openingSize);
+            const symbolValue = fundingFeeDelta + deltaSize;
+            return symbolValue;
+        });
+        const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), Promise.all(symbolPromises)]);
+        const totalVaultValue = vaultValues.reduce((acc, curr) => acc + curr, 0);
+        const totalSymbolValue = symbolValues.reduce((acc, curr) => acc + curr, 0);
+        value = totalVaultValue + totalSymbolValue;
+        slpPrice = value / marketInfo.lpSupplyWithDecimals;
+        return {
+            marketCap: value,
+            price: slpPrice,
+            supply: marketInfo.lpSupplyWithDecimals,
+            apr: Number(marketInfo.apr),
+        };
+    }
+    /**
+     * Valuates market using simulation (Sudo SDK specific)
+     */
+    async simValuate(sender) {
+        const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
+        this.valuate(tx);
+        const res = await this.provider.devInspectTransactionBlock({
+            transactionBlock: tx,
+            sender,
+        });
+        const symbolsValuationOffset = Object.keys(this.consts.sudoCore.symbols).length + 1;
+        const vaultsValuation = VaultsValuation.parse(new Uint8Array(res.results[(res.results?.length || 0) - symbolsValuationOffset - 1].mutableReferenceOutputs[1][1]));
+        const symbolsValuation = SymbolsValuation.parse(new Uint8Array(res.results[(res.results?.length || 0) - 1]
+            .mutableReferenceOutputs[1][1]));
+        const result = Number(BigInt(vaultsValuation.value)
+            + BigInt(symbolsValuation.value.value)
+                * BigInt(symbolsValuation.value.is_positive ? 1 : -1)) / 1e18;
+        return result;
+    }
+    /**
+     * Valuates only vaults (Sudo SDK specific)
+     */
+    async simValuateVaults(sender) {
+        const tx = await this.initOracleTxb(Object.keys(this.consts.sudoCore.vaults));
+        this.valuateVaults(tx);
+        const res = await this.provider.devInspectTransactionBlock({
+            transactionBlock: tx,
+            sender,
+        });
+        const vaultsValuation = VaultsValuation.parse(new Uint8Array(res.results[(res.results?.length || 0) - 1]
+            .mutableReferenceOutputs[1][1]));
+        const result = Number(BigInt(vaultsValuation.value)) / 1e18;
+        return result;
+    }
+    /**
+     * Valuates market with vaults only
+     */
+    async valuateMarketWithVaultsOnly() {
+        if (!this.consts.sudoCore) {
+            throw new Error('Sudo Core configuration not found');
+        }
+        const marketInfo = await this.getMarketInfo();
+        const value = await this.simValuateVaults(this.consts.sudoCore.adminCap);
+        const slpPrice = value / marketInfo.lpSupplyWithDecimals;
+        return {
+            marketCap: value,
+            price: slpPrice,
+            supply: marketInfo.lpSupplyWithDecimals,
+            apr: Number(marketInfo.apr),
+        };
+    }
+    /**
+     * Gets SLP market information
+     */
+    async getMarketInfo() {
+        this.validateCache();
+        if (this.marketInfoCache) {
+            return this.marketInfoCache;
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.sudoCore.market,
+            options: {
+                showContent: true,
+            },
+        });
+        const apr = await this.getCumulativeApr();
+        return {
+            ...SLPDataAPI.parseMarketInfo(rawData),
+            apr,
+        };
+    }
+    /**
+     * Gets SLP vault information
+     */
+    async getVaultInfo(vaultToken) {
+        this.validateCache();
+        if (this.vaultInfoCache[vaultToken]) {
+            return this.vaultInfoCache[vaultToken];
+        }
+        const rawData = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.sudoCore.vaultsParent,
+            name: {
+                type: `${this.consts.sudoCore.package}::market::VaultName<${this.consts.coins[vaultToken].module}>`,
+                value: { dummy_field: false },
+            },
+        });
+        return await this.parseVaultInfo(rawData);
+    }
+    /**
+     * Gets SLP symbol information
+     */
+    async getSymbolInfo(indexToken, long) {
+        this.validateCache();
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        if (this.symbolInfoCache[symbol]) {
+            return this.symbolInfoCache[symbol];
+        }
+        const rawData = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.sudoCore.symbolsParent,
+            name: {
+                type: `${this.consts.sudoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+                value: { dummy_field: false },
+            },
+        });
+        return await this.parseSymbolInfo(rawData, long);
+    }
+    /**
+     * Gets SLP symbol configuration
+     */
+    async getSymbolConfig(indexToken, long) {
+        this.validateCache();
+        try {
+            const rawData = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.sudoCore.market,
+                name: {
+                    type: `${this.consts.sudoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+                    value: { dummy_field: false },
+                },
+            });
+            return SLPDataAPI.parseSymbolConfig(rawData);
+        }
+        catch {
+            // If the dynamic field doesn't exist, return null
+            console.error('Symbol Config Not Found');
+            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.sudoCore.market,
+                name: {
+                    type: `0x699769d16326684d94039c23d8568fe8f438854bc69e681328647d6682425a7b::price_impact::PriceImpactConfigKey<${this.consts.coins[indexToken].module}>`,
+                    value: { dummy_field: false },
+                },
+            });
+            return SLPDataAPI.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;
+        }
+    }
+    /**
+     * Gets SLP symbol OI funding state (global per symbol)
+     */
+    async getSymbolOiFundingState(indexToken) {
+        this.validateCache();
+        try {
+            const rawData = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.sudoCore.market,
+                name: {
+                    type: `0x719955743d23874522250584b34d19462b41eed2816334adb5744308217f378a::funding::FundingStateKey<${this.consts.coins[indexToken].module}>`,
+                    value: { dummy_field: false },
+                },
+            });
+            return SLPDataAPI.parseOiFundingState(rawData);
+        }
+        catch (e) {
+            // If the dynamic field doesn't exist, return null
+            console.error('Error Fetching SLP Symbol OI Funding State:', e);
+            return null;
+        }
+    }
+    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.sudoCore.positionsParent,
+                        name: {
+                            type: `${this.consts.sudoCore.package}::market::PositionName<${positionCapInfo.symbol0}, ${positionCapInfo.symbol1}, ${this.consts.sudoCore.package}::market::${positionCapInfo.long ? 'LONG' : 'SHORT'}>`,
+                            value: {
+                                owner,
+                                id: positionCapInfo.positionCapId,
+                            },
+                        },
+                    });
+                    if (positionRaw?.data?.content) {
+                        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);
+    }
+    /**
+     * Gets user history for SLP
+     */
+    async getHistory(trader, page, limit, orderType, symbol) {
+        const params = new URLSearchParams({
+            trader,
+            page: page.toString(),
+            limit: limit.toString(),
+        });
+        if (orderType) {
+            params.append('orderType', orderType);
+        }
+        if (symbol) {
+            params.append('symbol', symbol);
+        }
+        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,
+            },
+        };
+    }
+    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.consts.sudoStaking.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();
+        const credentials = rawCredentialsData.map((item) => SLPDataAPI.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)),
+        };
+    }
+    /**
+     * Legacy method: Get stake pool from sudo_staking
+     */
+    async getStakePool() {
+        const raw = await this.provider.getObject({
+            id: this.consts.sudoStaking.pool,
+            options: {
+                showContent: true,
+            },
+        });
+        return SLPDataAPI.parseStakePool(raw);
+    }
+    async getStakePoolV2() {
+        const poolId = this.sharedConfig.zoStaking.pools.slp;
+        const raw = await this.provider.getObject({
+            id: poolId,
+            options: {
+                showContent: true,
+            },
+        });
+        return SLPDataAPI.parseStakePool(raw);
+    }
+    async getStakedV2(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.getStakePoolV2();
+        const credentials = rawCredentialsData
+            .filter((item) => item.data.type
+            === `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.sudoCore.package}::slp::SLP, ${this.consts.sudoCore.package}::slp::SLP>`)
+            .map((item) => SLPDataAPI.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 fundingFeeRate(indexToken, long) {
+        const oiState = await this.getSymbolOiFundingState(indexToken);
+        if (oiState && oiState.enabled) {
+            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 = SECONDS_PER_EIGHT_HOUR;
+            const deltaRate = SLPDataAPI.calcOiFundingFeeRate(oiState.model, longSymbol.openingSize, shortSymbol.openingSize, elapsed);
+            return long ? deltaRate : -deltaRate;
+        }
+        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 = SECONDS_PER_EIGHT_HOUR;
+        const deltaSize = SLPDataAPI.calcDeltaSize(symbol, price, symbol.long);
+        const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+        return SLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+    }
+    async rebaseFeeRate(collateralToken, increase, amount, _sender) {
+        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.sudoCore.vaults).map(async (vault) => {
+            const vaultInfo = await this.getVaultInfo(vault);
+            const reservingFeeDelta = SLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
+            const totalVaultAmount = reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount;
+            const oraclePrice = (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked();
+            const res = totalVaultAmount * oraclePrice / (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.sudoCore.vaults[collateralToken].weight, 10) / Object.values(this.consts.sudoCore.vaults)
+            .map(e => Number.parseInt(e.weight, 10))
+            .reduce((acc, curr) => acc + curr, 0);
+        return SLPDataAPI.calcRebaseFeeRate(await this.getRebaseFeeModel(), increase, (vaultValue + value) / (totalVaultValue + value), targetRatio);
+    }
+    async reservingFeeRate(collateralToken, amount, sender) {
+        if (!sender) {
+            throw new Error('Sender address is required for reservingFeeRate calculation');
+        }
+        const vaultInfo = await this.getVaultInfo(collateralToken);
+        const vaultSupply = vaultInfo.liquidity
+            + vaultInfo.reservedAmount
+            + vaultInfo.unrealisedReservingFeeAmount
+            + amount;
+        const utilization = vaultSupply
+            ? Number.parseInt((((vaultInfo.reservedAmount + amount) / vaultSupply) * 1e18).toFixed(0), 10)
+            : 0;
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::model::compute_reserving_fee_rate`,
+            arguments: [
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.pure.u128(utilization),
+                tx.pure.u64(8 * 3600),
+            ],
+        });
+        const res = await this.provider.devInspectTransactionBlock({
+            transactionBlock: tx,
+            sender,
+        });
+        const de = Rate.parse(new Uint8Array(res.results.at(-1).returnValues[0][0]));
+        return Number(BigInt(de)) / 1e18;
+    }
+    async getPositionConfig(indexToken, long) {
+        this.validateCache();
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        if (this.positionConfigCache[symbol]) {
+            return this.positionConfigCache[symbol];
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.sudoCore.symbols[symbol].positionConfig,
+            options: {
+                showContent: true,
+            },
+        });
+        return SLPDataAPI.parsePositionConfig(rawData);
+    }
+    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.sudoCore.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 = [];
+        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.sudoCore.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 getPositionCapInfoList(owner) {
+        let cursor;
+        let hasNextPage = true;
+        const positionCapInfoList = [];
+        while (hasNextPage) {
+            const positionCaps = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    StructType: `${this.consts.sudoCore.package}::market::PositionCap`,
+                },
+                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'),
+                    });
+                }
+            }
+            hasNextPage = positionCaps.hasNextPage;
+            cursor = positionCaps.nextCursor;
+        }
+        return positionCapInfoList;
+    }
+    async getOrderCapInfoList(owner) {
+        let cursor;
+        let hasNextPage = true;
+        const orderCapInfoList = [];
+        while (hasNextPage) {
+            const orderCaps = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    StructType: `${this.consts.sudoCore.package}::market::OrderCap`,
+                },
+                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 hasReferral(referree) {
+        const raw = await this.getReferralData(referree);
+        return !raw.error;
+    }
+    async getReferralData(referree) {
+        const raw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.sudoCore.referralsParent,
+            name: {
+                type: 'address',
+                value: referree,
+            },
+        });
+        return raw;
+    }
+    /**
+     * Gets user orders for SLP
+     */
+    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 {
+                    let orderRaw = await this.provider.getDynamicFieldObject({
+                        parentId: this.consts.sudoCore.ordersParent,
+                        name: {
+                            type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${orderCapInfo.symbol0}>`,
+                            value: {
+                                owner,
+                                id: orderCapInfo.orderCapId,
+                                position_id: {
+                                    vec: orderCapInfo.positionId ? [orderCapInfo.positionId] : [],
+                                },
+                            },
+                        },
+                    });
+                    if (orderRaw?.error?.code === 'dynamicFieldNotFound') {
+                        orderRaw = await this.provider.getDynamicFieldObject({
+                            parentId: this.consts.sudoCore.ordersParent,
+                            name: {
+                                type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins.sui.module}>`,
+                                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 getCumulativeApr() {
+        const refetchDate = new Date(Date.now() - 3600000);
+        // fetch new every hour
+        if (!aprResponse?.generatedAt
+            || (aprResponse?.generatedAt
+                && refetchDate > new Date(aprResponse?.generatedAt))) {
+            try {
+                const url = `${this.apiEndpoint}/cumulativeApr`;
+                const res = await fetch(url, {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+                const data = await res.json();
+                // eslint-disable-next-line require-atomic-updates
+                aprResponse = { ...data };
+                return data.cumulativeApr;
+            }
+            catch {
+                console.error('Failed to get cumulative APR');
+            }
+            return 0;
+        }
+        return aprResponse.apr;
+    }
+    // Private helper methods
+    static calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
+        const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, position.long, oiModel, pairedOpeningSize);
+        return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
+    }
+    static calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, isLong, oiModel, pairedOpeningSize) {
+        if (symbol.lastUpdate > 0) {
+            const elapsed = timestamp - symbol.lastUpdate;
+            if (elapsed > 0) {
+                // Prefer OI-based delta when OI model and paired side are available
+                if (oiModel && typeof pairedOpeningSize === 'number') {
+                    const longSize = isLong ? symbol.openingSize : pairedOpeningSize;
+                    const shortSize = isLong ? pairedOpeningSize : symbol.openingSize;
+                    const deltaRate = SLPDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed);
+                    const appliedRate = isLong ? deltaRate : -deltaRate;
+                    return symbol.accFundingRate + appliedRate;
+                }
+                // Fallback to PnL-based funding delta
+                const deltaSize = this.calcDeltaSize(symbol, price, isLong);
+                const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+                return symbol.accFundingRate + SLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+            }
+        }
+        return symbol.accFundingRate;
+    }
+    static calcDeltaSize(symbol, price, isLong) {
+        const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price;
+        return isLong ? symbol.openingSize - latestSize : latestSize - symbol.openingSize;
+    }
+    static calcFundingFeeRate(model, pnlPerRate, elapsed) {
+        const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max);
+        const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR;
+        return pnlPerRate >= 0 ? -secondsRate : secondsRate;
+    }
+    static calcOiFundingFeeRate(model, longSize, shortSize, elapsed) {
+        const imbalance = Math.abs(longSize - shortSize);
+        const denom = longSize + shortSize > 0 ? longSize + shortSize : 1;
+        const dailyRate = Math.min((model.multiplier * (imbalance ** model.exponent)) / denom, model.max);
+        const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR;
+        return longSize >= shortSize ? secondsRate : -secondsRate;
+    }
+    static calculatePositionReserveFee(position, vault, model, timestamp) {
+        const accReservingRate = SLPDataAPI.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 = SLPDataAPI.vaultUtilization(vault);
+                return vault.accReservingRate + SLPDataAPI.calcReservingFeeRate(model, utilization, elapsed);
+            }
+        }
+        return vault.accReservingRate;
+    }
+    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 / SECONDS_PER_EIGHT_HOUR;
+    }
+    static parsePositionConfig(raw) {
+        const positionConfigFields = raw.data.content.fields.inner.fields;
+        return {
+            decreaseFeeBps: parseValue(positionConfigFields.decrease_fee_bps),
+            liquidationBonus: parseValue(positionConfigFields.liquidation_bonus),
+            liquidationThreshold: parseValue(positionConfigFields.liquidation_threshold),
+            maxLeverage: parseValue(positionConfigFields.max_leverage),
+            minHoldingDuration: parseValue(positionConfigFields.min_holding_duration),
+            openFeeBps: parseValue(positionConfigFields.open_fee_bps),
+            maxReservedMultiplier: parseValue(positionConfigFields.max_reserved_multiplier),
+            minCollateralValue: parseValue(positionConfigFields.min_collateral_value),
+        };
+    }
+    static parseSymbolConfig(raw) {
+        const { fields } = raw.data.content;
+        return {
+            id: fields.id.id,
+            max_opening_size: parseValue(fields.max_opening_size),
+            max_opening_size_enabled: fields.max_opening_size_enabled,
+            max_opening_size_per_position: 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: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_1_duration_threshold),
+                instant_exit_tier_1_fee_bps: 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: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_2_duration_threshold),
+                instant_exit_tier_2_fee_bps: 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: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_3_duration_threshold),
+                instant_exit_tier_3_fee_bps: 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,
+            },
+        };
+    }
+    static parseRebaseFeeModel(raw) {
+        const { fields } = raw.data.content;
+        return {
+            base: parseValue(fields.base),
+            multiplier: parseValue(fields.multiplier),
+        };
+    }
+    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);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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.
+     */
+    static computeSpreadRate(config, currentOiThisSide, newPositionSize, currentOiOpposite, maxOiThisSide, maxOiOpposite) {
+        if (!config.enabled) {
+            return 0;
+        }
+        if (maxOiThisSide === 0) {
+            return config.baseSpreadRate;
+        }
+        const totalOiThis = currentOiThisSide + newPositionSize;
+        const thisUtil = Math.min(totalOiThis / maxOiThisSide, 1);
+        let oppositeUtil = 0;
+        if (maxOiOpposite > 0) {
+            oppositeUtil = Math.min(currentOiOpposite / maxOiOpposite, 1);
+        }
+        let skewRatio = thisUtil - oppositeUtil;
+        if (skewRatio < 0) {
+            skewRatio = 0;
+        }
+        else if (skewRatio > 1) {
+            skewRatio = 1;
+        }
+        const exponent = config.impactExponent;
+        const exponentInt = Math.floor(exponent);
+        const exponentFrac = exponent - exponentInt;
+        let ratioPowered = skewRatio ** exponentInt;
+        if (exponentFrac > 0) {
+            const ratioPoweredNext = skewRatio ** (exponentInt + 1);
+            const diff = ratioPoweredNext - ratioPowered;
+            if (diff >= 0) {
+                ratioPowered += exponentFrac * diff;
+            }
+        }
+        const dynamicSpread = config.maxDynamicSpreadRate * ratioPowered;
+        let totalSpread = config.baseSpreadRate + dynamicSpread;
+        if (totalSpread > config.maxTotalSpreadRate) {
+            totalSpread = config.maxTotalSpreadRate;
+        }
+        return totalSpread;
+    }
+    static computeSizeFactor(positionSize, referenceSize) {
+        if (referenceSize === 0) {
+            return 1;
+        }
+        const ratio = Math.min(positionSize / referenceSize, 1);
+        return 1 + ratio;
+    }
+    static computeIntegralAverage(maxDynamic, s1, s2, exponent) {
+        if (s1 === s2) {
+            return maxDynamic * (s1 ** exponent);
+        }
+        const nPlus1 = exponent + 1;
+        const s2Pow = s2 ** nPlus1;
+        const s1Pow = s1 ** nPlus1;
+        const numerator = Math.abs(s2Pow - s1Pow);
+        const sDiff = Math.abs(s2 - s1);
+        const denominator = nPlus1 * sDiff;
+        if (denominator === 0) {
+            return 0;
+        }
+        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.
+     */
+    static computeAverageSpreadRate(config, currentOiThisSide, newPositionSize, currentOiOpposite, maxOiThisSide, maxOiOpposite) {
+        if (!config.enabled) {
+            return 0;
+        }
+        if (maxOiThisSide === 0) {
+            return config.baseSpreadRate;
+        }
+        let oppositeUtil = 0;
+        if (maxOiOpposite > 0) {
+            oppositeUtil = Math.min(currentOiOpposite / maxOiOpposite, 1);
+        }
+        const startUtil = Math.min(currentOiThisSide / maxOiThisSide, 1);
+        const totalOiThis = currentOiThisSide + newPositionSize;
+        const endUtil = Math.min(totalOiThis / maxOiThisSide, 1);
+        let startSkew = startUtil - oppositeUtil;
+        if (startSkew < 0) {
+            startSkew = 0;
+        }
+        else if (startSkew > 1) {
+            startSkew = 1;
+        }
+        let endSkew = endUtil - oppositeUtil;
+        if (endSkew < 0) {
+            endSkew = 0;
+        }
+        else if (endSkew > 1) {
+            endSkew = 1;
+        }
+        const avgDynamicRate = SLPDataAPI.computeIntegralAverage(config.maxDynamicSpreadRate, startSkew, endSkew, config.impactExponent);
+        const sizeFactor = SLPDataAPI.computeSizeFactor(newPositionSize, config.referenceSize);
+        const scaledDynamicRate = avgDynamicRate * sizeFactor;
+        let totalSpread = config.baseSpreadRate + scaledDynamicRate;
+        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.
+     */
+    static applyPriceImpact(originalPrice, spreadRate, isLong, isOpening) {
+        if (spreadRate === 0) {
+            return originalPrice;
+        }
+        const increasePrice = (isLong && isOpening) || (!isLong && !isOpening);
+        const spreadAmount = originalPrice * spreadRate;
+        if (increasePrice) {
+            return originalPrice + spreadAmount;
+        }
+        const adjusted = originalPrice - spreadAmount;
+        return Math.max(adjusted, 0);
+    }
+    /**
+     * Convenience method to compute the estimated execution price with price impact.
+     */
+    async estimatePriceImpact(indexToken, isLong, isOpening, positionSizeValue) {
+        const config = await this.getPriceImpactConfig(indexToken);
+        if (!config) {
+            return null;
+        }
+        const longSymbol = await this.getSymbolInfo(indexToken, true);
+        const shortSymbol = await this.getSymbolInfo(indexToken, false);
+        const oraclePrice = (await this.getOraclePrice(indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked();
+        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;
+        const spreadRate = SLPDataAPI.computeAverageSpreadRate(config, currentOiThisSide, positionSizeValue, currentOiOpposite, maxOiThisSide, maxOiOpposite);
+        const adjustedPrice = SLPDataAPI.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening);
+        return {
+            spreadRate,
+            originalPrice: oraclePrice,
+            adjustedPrice,
+        };
+    }
+    static parseFundingFeeModel(raw) {
+        const { fields } = raw.data.content;
+        return {
+            multiplier: parseValue(fields.multiplier),
+            max: parseValue(fields.max),
+        };
+    }
+    static parseOiFundingState(raw) {
+        const content = raw.data.content.fields;
+        return {
+            id: content.id.id,
+            enabled: content.enabled,
+            last_update: parseValue(content.last_update),
+            model: {
+                id: content.model.fields.id.id,
+                multiplier: parseValue(content.model.fields.multiplier),
+                exponent: parseValue(content.model.fields.exponent),
+                max: parseValue(content.model.fields.max),
+            },
+        };
+    }
+    static parsePriceImpactConfig(raw) {
+        const content = raw.data.content.fields;
+        return {
+            id: content.id.id,
+            enabled: content.enabled,
+            baseSpreadRate: parseValue(content.base_spread_rate),
+            maxDynamicSpreadRate: parseValue(content.max_dynamic_spread_rate),
+            maxTotalSpreadRate: parseValue(content.max_total_spread_rate),
+            impactExponent: parseValue(content.impact_exponent),
+            maxOiLong: parseValue(content.max_oi_long),
+            maxOiShort: parseValue(content.max_oi_short),
+            referenceSize: parseValue(content.reference_size),
+        };
+    }
+    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,
+            lpSupplyWithDecimals: content.lp_supply.fields.value / 10 ** SLP_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 = SLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
+        return {
+            liquidity: parseValue(vaultFields.liquidity),
+            reservedAmount: parseValue(vaultFields.reserved_amount),
+            unrealisedReservingFeeAmount: parseValue(vaultFields.unrealised_reserving_fee_amount),
+            accReservingRate: parseValue(vaultFields.acc_reserving_rate),
+            enabled: vaultFields.enabled,
+            weight: parseValue(vaultFields.weight),
+            lastUpdate: parseValue(vaultFields.last_update),
+            reservingFeeModel,
+            priceConfig: {
+                maxInterval: parseValue(vaultFields.price_config.fields.max_interval),
+                maxConfidence: parseValue(vaultFields.price_config.fields.max_confidence),
+                precision: parseValue(vaultFields.price_config.fields.precision),
+                feeder: vaultFields.price_config.fields.feeder,
+            },
+        };
+    }
+    static parseReservingFeeModel(raw) {
+        const content = raw.data.content.fields;
+        return {
+            multiplier: parseValue(content.multiplier),
+        };
+    }
+    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 = SLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
+        return {
+            objectId,
+            openingSize: parseValue(fields.opening_size),
+            openingAmount: parseValue(fields.opening_amount),
+            accFundingRate: parseValue(fields.acc_funding_rate),
+            realisedPnl: parseValue(fields.realised_pnl),
+            unrealisedFundingFeeValue: parseValue(fields.unrealised_funding_fee_value),
+            openEnabled: fields.open_enabled,
+            liquidateEnabled: fields.liquidate_enabled,
+            decreaseEnabled: fields.decrease_enabled,
+            lastUpdate: parseValue(fields.last_update),
+            fundingFeeModel,
+            long,
+            priceConfig: {
+                maxInterval: parseValue(fields.price_config.fields.max_interval),
+                maxConfidence: parseValue(fields.price_config.fields.max_confidence),
+                precision: parseValue(fields.price_config.fields.precision),
+                feeder: fields.price_config.fields.feeder,
+            },
+        };
+    }
+    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: suiSymbolToSymbol(dataType.split('<')[1].split(',')[0].trim(), this.consts),
+            indexToken: suiSymbolToSymbol(dataType.split(',')[1].trim(), this.consts),
+            collateralAmount: parseValue(positionFields.collateral),
+            positionAmount: parseValue(positionFields.position_amount),
+            reservedAmount: parseValue(positionFields.reserved),
+            positionSize: parseValue(positionFields.position_size),
+            lastFundingRate: parseValue(positionFields.last_funding_rate),
+            lastReservingRate: parseValue(positionFields.last_reserving_rate),
+            reservingFeeAmount: parseValue(positionFields.reserving_fee_amount),
+            fundingFeeValue: parseValue(positionFields.funding_fee_value),
+            closed: positionFields.closed,
+            openTimestamp: parseValue(positionFields.open_timestamp),
+            protocol: 'sudo',
+        };
+        if (!positionFields.closed) {
+            try {
+                positionInfo.reservingFeeAmount = SLPDataAPI.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 = SLPDataAPI.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);
+            }
+            catch (e) {
+                console.error(e);
+                positionInfo.reservingFeeAmount = 0;
+                positionInfo.fundingFeeValue = 0;
+            }
+        }
+        return positionInfo;
+    }
+    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 orderVersion = content.fields.value?.type.includes('V2')
+            ? 'V2'
+            : 'V1_1';
+        const ret = {
+            id: content.fields.id.id,
+            capId,
+            executed: fields.executed,
+            owner: content.fields.name.fields.owner,
+            collateralToken: suiSymbolToSymbol(dataType.split('<')[2].split(',')[0].trim(), this.consts),
+            indexToken: suiSymbolToSymbol(dataType.split(',')[1].trim(), this.consts),
+            feeToken: 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'
+                ? parseValue(fields.index_price)
+                : parseValue(fields.limited_index_price?.fields?.price || fields.limited_index_price),
+            collateralPriceThreshold: fields.collateral_price_threshold ? parseValue(fields.collateral_price_threshold) : 0,
+            // New index price threshold
+            indexPriceThreshold: fields.index_price_threshold ? parseValue(fields.index_price_threshold) : undefined,
+            feeAmount: BigInt(fields.fee),
+            long: dataType.includes('::market::LONG'),
+            orderType,
+            orderVersion,
+            createdAt: 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 ? 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: parseValue(fields.position_config.fields.decrease_fee_bps),
+                        liquidationBonus: parseValue(fields.position_config.fields.liquidation_bonus),
+                        liquidationThreshold: parseValue(fields.position_config.fields.liquidation_threshold),
+                        maxLeverage: parseValue(fields.position_config.fields.max_leverage),
+                        minHoldingDuration: parseValue(fields.position_config.fields.min_holding_duration),
+                        openFeeBps: parseValue(fields.position_config.fields.open_fee_bps),
+                        maxReservedMultiplier: parseValue(fields.position_config.fields.max_reserved_multiplier),
+                        minCollateralValue: 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 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: 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;
+        // Check if this is the new version with reward_vault and reward_rate
+        const isNewVersion = content.reward_vault !== undefined && content.reward_rate !== undefined;
+        const pool = {
+            id: content.id.id,
+            enabled: content.enabled,
+            lastUpdatedTime: parseValue(content.last_updated_time),
+            stakedAmount: BigInt(content.staked_amount),
+            // Support both old 'reward' and new 'reward_vault' field names
+            reward: BigInt(content.reward_vault || content.reward),
+            startTime: parseValue(content.start_time),
+            endTime: parseValue(content.end_time),
+            accRewardPerShare: BigInt(content.acc_reward_per_share),
+            lockDuration: parseValue(content.lock_duration),
+            // Add rewardRate if available (new version)
+            ...(isNewVersion && { rewardRate: BigInt(content.reward_rate) }),
+        };
+        // Use appropriate refresh method based on version
+        if (isNewVersion) {
+            SLPDataAPI.refreshPoolV2(pool, Math.floor(Date.now() / 1000));
+        }
+        else {
+            SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000));
+        }
+        return pool;
+    }
+    // Legacy refresh method for backward compatibility
+    static refreshPool(pool, timestamp) {
+        if (timestamp === pool.lastUpdatedTime || timestamp < pool.startTime) {
+            return;
+        }
+        if (pool.lastUpdatedTime === pool.endTime
+            || pool.stakedAmount === BigInt(0)) {
+            return;
+        }
+        if (timestamp > pool.endTime) {
+            timestamp = pool.endTime;
+        }
+        const rewardAmount = (pool.reward * BigInt(timestamp - pool.lastUpdatedTime))
+            / BigInt(pool.endTime - pool.lastUpdatedTime);
+        pool.lastUpdatedTime = timestamp;
+        const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount;
+        pool.accRewardPerShare += rewardPerShare;
+    }
+    // New refresh method matching SLP implementation
+    static refreshPoolV2(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 && 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;
+    }
+}
+//# sourceMappingURL=SLPDataAPI.mjs.map