@zofai/zo-sdk 0.1.92 → 0.1.94

package/dist/implementations/SLPDataAPI.mjs

@@ -5,6 +5,12 @@
  * SLP DataAPI implementation
  * Implements SLP-specific data access methods for Sudo SDK
  */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SLPDataAPI_instances, _a, _SLPDataAPI_getTotalVaultsValueUsd, _SLPDataAPI_getSwapImpactConfig, _SLPDataAPI_getEmaVolatilityFeeConfig, _SLPDataAPI_getMarketDynamicFieldObjectByKeySuffix, _SLPDataAPI_parseSwapImpactConfig, _SLPDataAPI_parseEmaVolatilityFeeConfig, _SLPDataAPI_computeSwapImpactFeeValue, _SLPDataAPI_computeEmaVolatilityFeeValue, _SLPDataAPI_maxEmaDivergenceRate, _SLPDataAPI_emaDivergenceRate;
 import { Transaction } from "@mysten/sui/transactions";
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 import { BaseDataAPI } from "../abstract/index.mjs";
@@ -16,6 +22,7 @@ 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);
+        _SLPDataAPI_instances.add(this);
     }
     static calculateVaultReservingFee(vaultInfo, reservingFeeModel, currentTime) {
         const timeDelta = currentTime - vaultInfo.lastUpdate;
@@ -23,8 +30,8 @@ export class SLPDataAPI extends BaseDataAPI {
         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);
+    static calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp, oiState, pairedOpeningSize) {
+        const accFundingRate = _a.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, symbol.long, oiState, pairedOpeningSize);
         return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize;
     }
     async getRebaseFeeModel() {
@@ -38,8 +45,8 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const model = SLPDataAPI.parseRebaseFeeModel(rawData);
-        const exponent = await SLPDataAPI.getRebaseFeeExponent(this.provider, this.consts.sudoCore.rebaseFeeModel, this.consts.sudoCore.upgradedPackage);
+        const model = _a.parseRebaseFeeModel(rawData);
+        const exponent = await _a.getRebaseFeeExponent(this.provider, this.consts.sudoCore.rebaseFeeModel, this.consts.sudoCore.upgradedPackage);
         return { ...model, exponent };
     }
     /**
@@ -125,27 +132,30 @@ export class SLPDataAPI extends BaseDataAPI {
         const marketInfo = await this.getMarketInfo();
         let slpPrice = 0;
         let value = 0;
-        const vaultPromises = Object.keys(this.consts.sudoCore.vaults).map(async (vault) => {
+        const vaultKeys = Object.keys(this.consts.sudoCore.vaults);
+        const vaultData = await Promise.all(vaultKeys.map(async (vault) => {
             const vaultInfo = await this.getVaultInfo(vault);
-            const reservingFeeDelta = SLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
+            const reservingFeeDelta = _a.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;
-        });
+            return { vault, oraclePrice, vaultValue };
+        }));
+        const vaultPrices = Object.fromEntries(vaultData.map(d => [d.vault, d.oraclePrice]));
+        const vaultValues = vaultData.map(d => d.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 deltaSize = _a.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 fundingFeeDelta = _a.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, price, marketInfo.lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState : undefined, pairedInfo.openingSize);
             const symbolValue = fundingFeeDelta + deltaSize;
             return symbolValue;
         });
-        const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), Promise.all(symbolPromises)]);
+        const symbolValues = await Promise.all(symbolPromises);
         const totalVaultValue = vaultValues.reduce((acc, curr) => acc + curr, 0);
         const totalSymbolValue = symbolValues.reduce((acc, curr) => acc + curr, 0);
         value = totalVaultValue + totalSymbolValue;
@@ -155,6 +165,7 @@ export class SLPDataAPI extends BaseDataAPI {
             price: slpPrice,
             supply: marketInfo.lpSupplyWithDecimals,
             apr: Number(marketInfo.apr),
+            vaultPrices,
         };
     }
     /**
@@ -201,11 +212,18 @@ export class SLPDataAPI extends BaseDataAPI {
         const marketInfo = await this.getMarketInfo();
         const value = await this.simValuateVaults(this.consts.sudoCore.adminCap);
         const slpPrice = value / marketInfo.lpSupplyWithDecimals;
+        const vaultKeys = Object.keys(this.consts.sudoCore.vaults);
+        const vaultPricesEntries = await Promise.all(vaultKeys.map(async (vault) => {
+            const oraclePrice = (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked();
+            return [vault, oraclePrice];
+        }));
+        const vaultPrices = Object.fromEntries(vaultPricesEntries);
         return {
             marketCap: value,
             price: slpPrice,
             supply: marketInfo.lpSupplyWithDecimals,
             apr: Number(marketInfo.apr),
+            vaultPrices,
         };
     }
     /**
@@ -224,7 +242,7 @@ export class SLPDataAPI extends BaseDataAPI {
         });
         const apr = await this.getCumulativeApr();
         return {
-            ...SLPDataAPI.parseMarketInfo(rawData),
+            ..._a.parseMarketInfo(rawData),
             apr,
         };
     }
@@ -276,7 +294,7 @@ export class SLPDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return SLPDataAPI.parseSymbolConfig(rawData);
+            return _a.parseSymbolConfig(rawData);
         }
         catch {
             // If the dynamic field doesn't exist, return null
@@ -298,7 +316,7 @@ export class SLPDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return SLPDataAPI.parsePriceImpactConfig(rawData);
+            return _a.parsePriceImpactConfig(rawData);
         }
         catch (e) {
             // If the dynamic field doesn't exist, return null (price impact not configured for this symbol)
@@ -319,7 +337,7 @@ export class SLPDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return SLPDataAPI.parseOiFundingState(rawData);
+            return _a.parseOiFundingState(rawData);
         }
         catch (e) {
             // If the dynamic field doesn't exist, return null
@@ -327,6 +345,52 @@ export class SLPDataAPI extends BaseDataAPI {
             return null;
         }
     }
+    async calculateSwapFeeBreakdown(fromToken, toToken, fromAmount) {
+        if (!this.consts.sudoCore) {
+            throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP');
+        }
+        const timestamp = Date.now() / 1000;
+        const fromDecimals = this.consts.coins[fromToken]?.decimals;
+        const toDecimals = this.consts.coins[toToken]?.decimals;
+        if (fromDecimals === undefined || toDecimals === undefined) {
+            throw new Error(`Unknown token decimals for swap: ${fromToken} -> ${toToken}`);
+        }
+        const fromFeed = await this.getOraclePrice(fromToken);
+        const toFeed = await this.getOraclePrice(toToken);
+        const fromPrice = fromFeed.getPriceUnchecked().getPriceAsNumberUnchecked();
+        const toPrice = toFeed.getPriceUnchecked().getPriceAsNumberUnchecked();
+        const swapValue = (fromAmount * fromPrice) / (10 ** fromDecimals);
+        const totalVaultsValue = await __classPrivateFieldGet(this, _SLPDataAPI_instances, "m", _SLPDataAPI_getTotalVaultsValueUsd).call(this, timestamp);
+        const rebaseFeeInRate = await this.rebaseFeeRate(fromToken, true, fromAmount);
+        const rebaseFeeInValue = swapValue * rebaseFeeInRate;
+        const estimatedToAmount = toPrice !== 0
+            ? (swapValue * (10 ** toDecimals)) / toPrice
+            : 0;
+        const rebaseFeeOutRate = await this.rebaseFeeRate(toToken, false, estimatedToAmount);
+        const rebaseFeeOutValue = swapValue * rebaseFeeOutRate;
+        const swapImpactCfg = await __classPrivateFieldGet(this, _SLPDataAPI_instances, "m", _SLPDataAPI_getSwapImpactConfig).call(this);
+        const swapImpactFeeValue = swapImpactCfg?.enabled
+            ? __classPrivateFieldGet(_a, _a, "m", _SLPDataAPI_computeSwapImpactFeeValue).call(_a, swapValue, totalVaultsValue, swapImpactCfg.impactMultiplier, swapImpactCfg.maxImpactRate)
+            : 0;
+        const emaCfg = await __classPrivateFieldGet(this, _SLPDataAPI_instances, "m", _SLPDataAPI_getEmaVolatilityFeeConfig).call(this);
+        const emaVolatilityFeeValue = emaCfg?.enabled
+            ? __classPrivateFieldGet(_a, _a, "m", _SLPDataAPI_computeEmaVolatilityFeeValue).call(_a, swapValue, __classPrivateFieldGet(_a, _a, "m", _SLPDataAPI_maxEmaDivergenceRate).call(_a, fromFeed, toFeed), emaCfg.multiplier, emaCfg.maxFeeRate)
+            : 0;
+        const totalFeeValue = rebaseFeeInValue + rebaseFeeOutValue + swapImpactFeeValue + emaVolatilityFeeValue;
+        const totalFeeRate = swapValue !== 0 ? totalFeeValue / swapValue : 0;
+        return {
+            swapValue,
+            totalVaultsValue,
+            rebaseFeeInRate,
+            rebaseFeeOutRate,
+            rebaseFeeInValue,
+            rebaseFeeOutValue,
+            swapImpactFeeValue,
+            emaVolatilityFeeValue,
+            totalFeeValue,
+            totalFeeRate,
+        };
+    }
     async getPositionInfoList(positionCapInfoList, owner, batchSize = 10) {
         const positionInfoList = [];
         // Process in batches of 10
@@ -418,7 +482,7 @@ export class SLPDataAPI extends BaseDataAPI {
             rawCredentialsData = [...rawCredentialsData, ...data];
         }
         const pool = await this.getStakePool();
-        const credentials = rawCredentialsData.map((item) => SLPDataAPI.parseCredential(item, pool));
+        const credentials = rawCredentialsData.map((item) => _a.parseCredential(item, pool));
         return {
             credentials,
             amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
@@ -435,7 +499,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return SLPDataAPI.parseStakePool(raw);
+        return _a.parseStakePool(raw);
     }
     async getStakePoolV2() {
         const poolId = this.sharedConfig.zoStaking.pools.slp;
@@ -445,7 +509,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return SLPDataAPI.parseStakePool(raw);
+        return _a.parseStakePool(raw);
     }
     async getStakedV2(owner) {
         let rawCredentialsData = [];
@@ -478,7 +542,7 @@ export class SLPDataAPI extends BaseDataAPI {
         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));
+            .map((item) => _a.parseCredential(item, pool));
         return {
             credentials,
             amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
@@ -494,7 +558,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 return 0;
             }
             const elapsed = SECONDS_PER_EIGHT_HOUR;
-            const deltaRate = SLPDataAPI.calcOiFundingFeeRate(oiState.model, longSymbol.openingSize, shortSymbol.openingSize, elapsed);
+            const deltaRate = _a.calcOiFundingFeeRate(oiState.model, longSymbol.openingSize, shortSymbol.openingSize, elapsed, oiState.maxOiLong, oiState.maxOiShort);
             return long ? deltaRate : -deltaRate;
         }
         const symbol = await this.getSymbolInfo(indexToken, long);
@@ -505,9 +569,9 @@ export class SLPDataAPI extends BaseDataAPI {
         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 deltaSize = _a.calcDeltaSize(symbol, price, symbol.long);
         const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
-        return SLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+        return _a.calcFundingFeeRate(model, pnlPerLp, elapsed);
     }
     async rebaseFeeRate(collateralToken, increase, amount, _sender) {
         let vaultValue = 0;
@@ -517,7 +581,7 @@ export class SLPDataAPI extends BaseDataAPI {
         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 reservingFeeDelta = _a.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);
@@ -531,7 +595,7 @@ export class SLPDataAPI extends BaseDataAPI {
         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);
+        return _a.calcRebaseFeeRate(await this.getRebaseFeeModel(), increase, (vaultValue + value) / (totalVaultValue + value), targetRatio);
     }
     async reservingFeeRate(collateralToken, amount, sender) {
         if (!sender) {
@@ -573,7 +637,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return SLPDataAPI.parsePositionConfig(rawData);
+        return _a.parsePositionConfig(rawData);
     }
     async getOpenPositions(batchSize = 50, symbol = 'sui') {
         let positionDynamicFields = [];
@@ -791,26 +855,26 @@ export class SLPDataAPI extends BaseDataAPI {
         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);
+    static calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp, oiState, pairedOpeningSize) {
+        const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, position.long, oiState, pairedOpeningSize);
         return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
     }
-    static calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, isLong, oiModel, pairedOpeningSize) {
+    static calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, isLong, oiState, 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') {
+                // Prefer OI-based delta when OI state and paired side are available
+                if (oiState?.enabled && oiState.model && typeof pairedOpeningSize === 'number') {
                     const longSize = isLong ? symbol.openingSize : pairedOpeningSize;
                     const shortSize = isLong ? pairedOpeningSize : symbol.openingSize;
-                    const deltaRate = SLPDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed);
+                    const deltaRate = _a.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed, oiState.maxOiLong, oiState.maxOiShort);
                     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 + _a.calcFundingFeeRate(model, pnlPerLp, elapsed);
             }
         }
         return symbol.accFundingRate;
@@ -824,23 +888,44 @@ export class SLPDataAPI extends BaseDataAPI {
         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;
+    /**
+     * OI funding rate matching Move compute_oi_funding_rate_capped.
+     * When both maxOiLong and maxOiShort are set and > 0, uses normalized skew (oi/cap);
+     * otherwise falls back to (long - short) / total.
+     */
+    static calcOiFundingFeeRate(model, oiLong, oiShort, elapsed, maxOiLong, maxOiShort) {
+        let skew;
+        if (maxOiLong && maxOiShort && maxOiLong > 0 && maxOiShort > 0) {
+            const normLong = Math.min(oiLong / maxOiLong, 1);
+            const normShort = Math.min(oiShort / maxOiShort, 1);
+            skew = normLong - normShort;
+        }
+        else {
+            const total = oiLong + oiShort;
+            if (total === 0)
+                return 0;
+            skew = (oiLong - oiShort) / total;
+        }
+        if (skew === 0)
+            return 0;
+        const skewIsPositive = skew > 0;
+        const skewAbs = Math.abs(skew);
+        const exponentInt = Math.floor(model.exponent);
+        const skewPow = skewAbs ** exponentInt;
+        const dailyRate = Math.min(model.multiplier * skewPow, model.max);
+        const secondsRate = (dailyRate * elapsed) / SECONDS_PER_EIGHT_HOUR;
+        return skewIsPositive ? secondsRate : -secondsRate;
     }
     static calculatePositionReserveFee(position, vault, model, timestamp) {
-        const accReservingRate = SLPDataAPI.calcAccReservingFeeRate(vault, model, timestamp);
+        const accReservingRate = _a.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);
+                const utilization = _a.vaultUtilization(vault);
+                return vault.accReservingRate + _a.calcReservingFeeRate(model, utilization, elapsed);
             }
         }
         return vault.accReservingRate;
@@ -1025,8 +1110,8 @@ export class SLPDataAPI extends BaseDataAPI {
         else if (endSkew > 1) {
             endSkew = 1;
         }
-        const avgDynamicRate = SLPDataAPI.computeIntegralAverage(config.maxDynamicSpreadRate, startSkew, endSkew, config.impactExponent);
-        const sizeFactor = SLPDataAPI.computeSizeFactor(newPositionSize, config.referenceSize);
+        const avgDynamicRate = _a.computeIntegralAverage(config.maxDynamicSpreadRate, startSkew, endSkew, config.impactExponent);
+        const sizeFactor = _a.computeSizeFactor(newPositionSize, config.referenceSize);
         const scaledDynamicRate = avgDynamicRate * sizeFactor;
         let totalSpread = config.baseSpreadRate + scaledDynamicRate;
         if (totalSpread > config.maxTotalSpreadRate) {
@@ -1065,8 +1150,8 @@ export class SLPDataAPI extends BaseDataAPI {
         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);
+        const spreadRate = _a.computeAverageSpreadRate(config, currentOiThisSide, positionSizeValue, currentOiOpposite, maxOiThisSide, maxOiOpposite);
+        const adjustedPrice = _a.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening);
         return {
             spreadRate,
             originalPrice: oraclePrice,
@@ -1092,6 +1177,8 @@ export class SLPDataAPI extends BaseDataAPI {
                 exponent: parseValue(content.model.fields.exponent),
                 max: parseValue(content.model.fields.max),
             },
+            maxOiLong: content.max_oi_long !== null && content.max_oi_long !== undefined ? parseValue(content.max_oi_long) : undefined,
+            maxOiShort: content.max_oi_short !== null && content.max_oi_short !== undefined ? parseValue(content.max_oi_short) : undefined,
         };
     }
     static parsePriceImpactConfig(raw) {
@@ -1127,7 +1214,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const reservingFeeModel = SLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
+        const reservingFeeModel = _a.parseReservingFeeModel(reservingFeeModelRaw);
         return {
             liquidity: parseValue(vaultFields.liquidity),
             reservedAmount: parseValue(vaultFields.reserved_amount),
@@ -1161,7 +1248,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const fundingFeeModel = SLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
+        const fundingFeeModel = _a.parseFundingFeeModel(fundingFeeModelRaw);
         return {
             objectId,
             openingSize: parseValue(fields.opening_size),
@@ -1209,11 +1296,11 @@ export class SLPDataAPI extends BaseDataAPI {
         };
         if (!positionFields.closed) {
             try {
-                positionInfo.reservingFeeAmount = SLPDataAPI.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000);
+                positionInfo.reservingFeeAmount = _a.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);
+                positionInfo.fundingFeeValue = _a.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 : undefined, pairedSymbol.openingSize);
             }
             catch (e) {
                 console.error(e);
@@ -1336,10 +1423,10 @@ export class SLPDataAPI extends BaseDataAPI {
         };
         // Use appropriate refresh method based on version
         if (isNewVersion) {
-            SLPDataAPI.refreshPoolV2(pool, Math.floor(Date.now() / 1000));
+            _a.refreshPoolV2(pool, Math.floor(Date.now() / 1000));
         }
         else {
-            SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000));
+            _a.refreshPool(pool, Math.floor(Date.now() / 1000));
         }
         return pool;
     }
@@ -1377,4 +1464,93 @@ export class SLPDataAPI extends BaseDataAPI {
         pool.lastUpdatedTime = calculationEndTime;
     }
 }
+_a = SLPDataAPI, _SLPDataAPI_instances = new WeakSet(), _SLPDataAPI_getTotalVaultsValueUsd = async function _SLPDataAPI_getTotalVaultsValueUsd(timestamp) {
+    if (!this.consts.sudoCore) {
+        return 0;
+    }
+    const vaultKeys = Object.keys(this.consts.sudoCore.vaults);
+    const vaultValues = await Promise.all(vaultKeys.map(async (vault) => {
+        const vaultInfo = await this.getVaultInfo(vault);
+        const reservingFeeDelta = _a.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, timestamp);
+        const totalVaultAmount = reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount;
+        const oraclePrice = (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked();
+        const { decimals } = this.consts.coins[vault];
+        return totalVaultAmount * oraclePrice / (10 ** decimals);
+    }));
+    return vaultValues.reduce((acc, curr) => acc + curr, 0);
+}, _SLPDataAPI_getSwapImpactConfig = async function _SLPDataAPI_getSwapImpactConfig() {
+    if (!this.consts.sudoCore) {
+        return null;
+    }
+    const raw = await __classPrivateFieldGet(this, _SLPDataAPI_instances, "m", _SLPDataAPI_getMarketDynamicFieldObjectByKeySuffix).call(this, this.consts.sudoCore.market, 'SwapImpactConfigKey');
+    if (!raw)
+        return null;
+    return __classPrivateFieldGet(_a, _a, "m", _SLPDataAPI_parseSwapImpactConfig).call(_a, raw);
+}, _SLPDataAPI_getEmaVolatilityFeeConfig = async function _SLPDataAPI_getEmaVolatilityFeeConfig() {
+    if (!this.consts.sudoCore) {
+        return null;
+    }
+    const raw = await __classPrivateFieldGet(this, _SLPDataAPI_instances, "m", _SLPDataAPI_getMarketDynamicFieldObjectByKeySuffix).call(this, this.consts.sudoCore.market, 'EmaVolatilityFeeConfigKey');
+    if (!raw)
+        return null;
+    return __classPrivateFieldGet(_a, _a, "m", _SLPDataAPI_parseEmaVolatilityFeeConfig).call(_a, raw);
+}, _SLPDataAPI_getMarketDynamicFieldObjectByKeySuffix = async function _SLPDataAPI_getMarketDynamicFieldObjectByKeySuffix(parentId, keyTypeSuffix) {
+    let cursor;
+    let hasNextPage = true;
+    while (hasNextPage) {
+        const page = await this.provider.getDynamicFields({ parentId, cursor });
+        for (const field of page.data) {
+            const type = field.name?.type;
+            if (typeof type === 'string' && type.endsWith(`::${keyTypeSuffix}`)) {
+                return await this.provider.getDynamicFieldObject({
+                    parentId,
+                    name: field.name,
+                });
+            }
+        }
+        hasNextPage = page.hasNextPage;
+        cursor = page.nextCursor;
+    }
+    return null;
+}, _SLPDataAPI_parseSwapImpactConfig = function _SLPDataAPI_parseSwapImpactConfig(raw) {
+    const { fields } = raw.data.content;
+    return {
+        id: fields.id.id,
+        enabled: fields.enabled,
+        impactMultiplier: parseValue(fields.impact_multiplier),
+        maxImpactRate: parseValue(fields.max_impact_rate),
+    };
+}, _SLPDataAPI_parseEmaVolatilityFeeConfig = function _SLPDataAPI_parseEmaVolatilityFeeConfig(raw) {
+    const { fields } = raw.data.content;
+    return {
+        id: fields.id.id,
+        enabled: fields.enabled,
+        multiplier: parseValue(fields.multiplier),
+        maxFeeRate: parseValue(fields.max_fee_rate),
+    };
+}, _SLPDataAPI_computeSwapImpactFeeValue = function _SLPDataAPI_computeSwapImpactFeeValue(swapValue, totalVaultsValue, impactMultiplier, maxImpactRate) {
+    if (swapValue <= 0 || totalVaultsValue <= 0)
+        return 0;
+    const utilization = swapValue / totalVaultsValue;
+    const rawImpactRate = impactMultiplier * utilization;
+    const impactRate = Math.min(rawImpactRate, maxImpactRate);
+    return swapValue * impactRate;
+}, _SLPDataAPI_computeEmaVolatilityFeeValue = function _SLPDataAPI_computeEmaVolatilityFeeValue(swapValue, maxDiv, multiplier, maxFeeRate) {
+    if (swapValue <= 0 || maxDiv <= 0)
+        return 0;
+    const rawFeeRate = multiplier * maxDiv;
+    const feeRate = Math.min(rawFeeRate, maxFeeRate);
+    return swapValue * feeRate;
+}, _SLPDataAPI_maxEmaDivergenceRate = function _SLPDataAPI_maxEmaDivergenceRate(sourceFeed, destFeed) {
+    const sourceDiv = __classPrivateFieldGet(_a, _a, "m", _SLPDataAPI_emaDivergenceRate).call(_a, sourceFeed);
+    const destDiv = __classPrivateFieldGet(_a, _a, "m", _SLPDataAPI_emaDivergenceRate).call(_a, destFeed);
+    return Math.max(sourceDiv, destDiv);
+}, _SLPDataAPI_emaDivergenceRate = function _SLPDataAPI_emaDivergenceRate(priceFeed) {
+    const price = priceFeed.getPriceUnchecked().getPriceAsNumberUnchecked();
+    const ema = priceFeed.getEmaPriceUnchecked().getPriceAsNumberUnchecked();
+    const denom = Math.abs(price);
+    if (denom === 0)
+        return 0;
+    return Math.abs(price - ema) / denom;
+};
 //# sourceMappingURL=SLPDataAPI.mjs.map