@zofai/zo-sdk 0.1.92 → 0.1.94

package/dist/implementations/ZLPDataAPI.mjs

@@ -3,6 +3,12 @@
  * ZLP DataAPI implementation
  * Implements ZLP-specific data access methods
  */
+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 _ZLPDataAPI_instances, _a, _ZLPDataAPI_getTotalVaultsValueUsd, _ZLPDataAPI_getSwapImpactConfig, _ZLPDataAPI_getEmaVolatilityFeeConfig, _ZLPDataAPI_getMarketDynamicFieldObjectByKeySuffix, _ZLPDataAPI_parseSwapImpactConfig, _ZLPDataAPI_parseEmaVolatilityFeeConfig, _ZLPDataAPI_computeSwapImpactFeeValue, _ZLPDataAPI_computeEmaVolatilityFeeValue, _ZLPDataAPI_maxEmaDivergenceRate, _ZLPDataAPI_emaDivergenceRate;
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 import { BaseDataAPI } from "../abstract/index.mjs";
 import { LPToken, SECONDS_PER_EIGHT_HOUR, ZLP_TOKEN_DECIMALS } from "../consts/index.mjs";
@@ -10,6 +16,7 @@ import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from "../ut
 export class ZLPDataAPI extends BaseDataAPI {
     constructor(network, provider, apiEndpoint, connectionURL) {
         super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP);
+        _ZLPDataAPI_instances.add(this);
     }
     async getStaked(owner) {
         let rawCredentialsData = [];
@@ -43,7 +50,7 @@ export class ZLPDataAPI extends BaseDataAPI {
         const credentials = rawCredentialsData
             .filter((item) => item.data.type
             === `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.zoCore.package}::zlp::ZLP, 0x2::sui::SUI>`)
-            .map((item) => ZLPDataAPI.parseCredential(item, pool));
+            .map((item) => _a.parseCredential(item, pool));
         return {
             credentials,
             amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
@@ -58,7 +65,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return ZLPDataAPI.parseStakePool(raw);
+        return _a.parseStakePool(raw);
     }
     /**
      * Creates vaults valuation for ZLP
@@ -137,22 +144,28 @@ export class ZLPDataAPI extends BaseDataAPI {
         const marketInfo = await this.getMarketInfo();
         let zlpPrice = 0;
         let value = 0;
-        const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
+        const vaultKeys = Object.keys(this.consts.zoCore.vaults);
+        const vaultData = await Promise.all(vaultKeys.map(async (vault) => {
             const vaultInfo = await this.getVaultInfo(vault);
-            const reservingFeeDelta = ZLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
-            return (reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount) * (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[vault].decimals);
-        });
+            const 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 vaultValue = totalVaultAmount * oraclePrice / (10 ** this.consts.coins[vault].decimals);
+            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.zoCore.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 = ZLPDataAPI.calcDeltaSize(symbolInfo, price);
+            const deltaSize = _a.calcDeltaSize(symbolInfo, price);
             const oiState = await this.getSymbolOiFundingState(tokenId);
             const pairedInfo = await this.getSymbolInfo(tokenId, direction !== 'long');
-            const fundingFeeDelta = ZLPDataAPI.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, price, marketInfo.lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState.model : undefined, pairedInfo.openingSize);
+            const fundingFeeDelta = _a.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, price, marketInfo.lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState : undefined, pairedInfo.openingSize);
             return fundingFeeDelta + deltaSize;
         });
-        const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), Promise.all(symbolPromises)]);
+        const symbolValues = await Promise.all(symbolPromises);
         value = vaultValues.reduce((acc, curr) => acc + curr, 0);
         value += symbolValues.reduce((acc, curr) => acc + curr, 0);
         zlpPrice = value / marketInfo.lpSupplyWithDecimals;
@@ -161,6 +174,7 @@ export class ZLPDataAPI extends BaseDataAPI {
             price: zlpPrice,
             supply: marketInfo.lpSupplyWithDecimals,
             apr: Number(marketInfo.apr),
+            vaultPrices,
         };
     }
     /**
@@ -177,7 +191,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return ZLPDataAPI.parseMarketInfo(rawData);
+        return _a.parseMarketInfo(rawData);
     }
     /**
      * Gets ZLP vault information
@@ -226,7 +240,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return ZLPDataAPI.parsePositionConfig(rawData);
+        return _a.parsePositionConfig(rawData);
     }
     /**
      * Gets ZLP symbol configuration
@@ -241,7 +255,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return ZLPDataAPI.parseSymbolConfig(rawData);
+            return _a.parseSymbolConfig(rawData);
         }
         catch (e) {
             // If the dynamic field doesn't exist, return null
@@ -262,7 +276,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return ZLPDataAPI.parseOiFundingState(rawData);
+            return _a.parseOiFundingState(rawData);
         }
         catch (e) {
             // If the dynamic field doesn't exist, return null
@@ -284,7 +298,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return ZLPDataAPI.parsePriceImpactConfig(rawData);
+            return _a.parsePriceImpactConfig(rawData);
         }
         catch (e) {
             // If the dynamic field doesn't exist, return null (price impact not configured for this symbol)
@@ -292,6 +306,50 @@ export class ZLPDataAPI extends BaseDataAPI {
             return null;
         }
     }
+    async calculateSwapFeeBreakdown(fromToken, toToken, fromAmount) {
+        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, _ZLPDataAPI_instances, "m", _ZLPDataAPI_getTotalVaultsValueUsd).call(this, timestamp);
+        const rebaseFeeInRate = await this.rebaseFeeRate(fromToken, true, fromAmount);
+        const rebaseFeeInValue = swapValue * rebaseFeeInRate;
+        // Estimate out-amount by notional value (ignoring price impact / spread / fees).
+        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, _ZLPDataAPI_instances, "m", _ZLPDataAPI_getSwapImpactConfig).call(this);
+        const swapImpactFeeValue = swapImpactCfg?.enabled
+            ? __classPrivateFieldGet(_a, _a, "m", _ZLPDataAPI_computeSwapImpactFeeValue).call(_a, swapValue, totalVaultsValue, swapImpactCfg.impactMultiplier, swapImpactCfg.maxImpactRate)
+            : 0;
+        const emaCfg = await __classPrivateFieldGet(this, _ZLPDataAPI_instances, "m", _ZLPDataAPI_getEmaVolatilityFeeConfig).call(this);
+        const emaVolatilityFeeValue = emaCfg?.enabled
+            ? __classPrivateFieldGet(_a, _a, "m", _ZLPDataAPI_computeEmaVolatilityFeeValue).call(_a, swapValue, __classPrivateFieldGet(_a, _a, "m", _ZLPDataAPI_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 getPositionCapInfoList(owner) {
         const positionCapInfoList = [];
         let cursor;
@@ -506,8 +564,8 @@ export class ZLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const model = ZLPDataAPI.parseRebaseFeeModel(rawData);
-        const exponent = await ZLPDataAPI.getRebaseFeeExponent(this.provider, this.consts.zoCore.rebaseFeeModel, this.consts.zoCore.upgradedPackage);
+        const model = _a.parseRebaseFeeModel(rawData);
+        const exponent = await _a.getRebaseFeeExponent(this.provider, this.consts.zoCore.rebaseFeeModel, this.consts.zoCore.upgradedPackage);
         return { ...model, exponent };
     }
     async fundingFeeRate(indexToken, long) {
@@ -521,9 +579,9 @@ export class ZLPDataAPI extends BaseDataAPI {
             const lpSupplyAmount = (await this.getMarketInfo()).lpSupplyWithDecimals;
             const model = symbol.fundingFeeModel;
             const elapsed = SECONDS_PER_EIGHT_HOUR;
-            const deltaSize = ZLPDataAPI.calcDeltaSize(symbol, price);
+            const deltaSize = _a.calcDeltaSize(symbol, price);
             const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
-            return ZLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+            return _a.calcFundingFeeRate(model, pnlPerLp, elapsed);
         }
         const longSymbol = await this.getSymbolInfo(indexToken, true);
         const shortSymbol = await this.getSymbolInfo(indexToken, false);
@@ -533,7 +591,7 @@ export class ZLPDataAPI extends BaseDataAPI {
         const elapsed = SECONDS_PER_EIGHT_HOUR;
         const longSize = longSymbol.openingSize;
         const shortSize = shortSymbol.openingSize;
-        const deltaRate = ZLPDataAPI.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed);
+        const deltaRate = _a.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed, oiState.maxOiLong, oiState.maxOiShort);
         return long ? deltaRate : -deltaRate;
     }
     async rebaseFeeRate(collateralToken, increase, amount) {
@@ -544,7 +602,7 @@ export class ZLPDataAPI extends BaseDataAPI {
         const value = amount * (await this.getOraclePrice(collateralToken)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[collateralToken].decimals);
         const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
             const vaultInfo = await this.getVaultInfo(vault);
-            const reservingFeeDelta = ZLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
+            const reservingFeeDelta = _a.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000);
             const res = (reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount) * (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[vault].decimals);
             if (collateralToken === vault) {
                 vaultValue = res;
@@ -556,13 +614,13 @@ export class ZLPDataAPI extends BaseDataAPI {
         const targetRatio = Number.parseInt(this.consts.zoCore.vaults[collateralToken].weight, 10) / Object.values(this.consts.zoCore.vaults)
             .map(e => Number.parseInt(e.weight, 10))
             .reduce((acc, curr) => acc + curr, 0);
-        return ZLPDataAPI.calcRebaseFeeRate(await this.getRebaseFeeModel(), increase, (vaultValue + value) / (totalVaultValue + value), targetRatio);
+        return _a.calcRebaseFeeRate(await this.getRebaseFeeModel(), increase, (vaultValue + value) / (totalVaultValue + value), targetRatio);
     }
     async reservingFeeRate(collateralToken, amount = 0) {
         const vaultInfo = await this.getVaultInfo(collateralToken);
         const vaultSupply = vaultInfo.liquidity + vaultInfo.reservedAmount + vaultInfo.unrealisedReservingFeeAmount + amount;
         const utilization = vaultSupply ? ((vaultInfo.reservedAmount + amount) / vaultSupply) : 0;
-        return ZLPDataAPI.calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, SECONDS_PER_EIGHT_HOUR);
+        return _a.calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, SECONDS_PER_EIGHT_HOUR);
     }
     async getHistory(trader, page, limit, orderType, symbol) {
         const params = new URLSearchParams({
@@ -602,47 +660,68 @@ export class ZLPDataAPI 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);
-        // multiplier = 0.1%, exponent = 1
-        const dailyRate = Math.min(model.multiplier * (imbalance ** model.exponent) / (longSize + shortSize > 0 ? longSize + shortSize : 1), model.max);
-        const secondsRate = dailyRate * elapsed / 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 calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
+    static calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiState, pairedOpeningSize) {
         if (symbol.lastUpdate > 0) {
             const elapsed = timestamp - symbol.lastUpdate;
             if (elapsed > 0) {
-                // Prefer OI-based delta when model and paired side are available
-                if (oiModel && typeof pairedOpeningSize === 'number') {
+                // Prefer OI-based delta when state and paired side are available
+                if (oiState?.enabled && oiState.model && typeof pairedOpeningSize === 'number') {
                     const longSize = symbol.long ? symbol.openingSize : pairedOpeningSize;
                     const shortSize = symbol.long ? pairedOpeningSize : symbol.openingSize;
-                    const deltaRate = ZLPDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed);
+                    const deltaRate = _a.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed, oiState.maxOiLong, oiState.maxOiShort);
                     const appliedRate = symbol.long ? deltaRate : -deltaRate;
                     return symbol.accFundingRate + appliedRate;
                 }
                 // Fallback to PnL-based funding delta
-                const deltaSize = ZLPDataAPI.calcDeltaSize(symbol, price);
+                const deltaSize = _a.calcDeltaSize(symbol, price);
                 const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
-                return symbol.accFundingRate + ZLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+                return symbol.accFundingRate + _a.calcFundingFeeRate(model, pnlPerLp, elapsed);
             }
         }
         return symbol.accFundingRate;
     }
-    static calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
-        const accFundingRate = ZLPDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize);
+    static calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp, oiState, pairedOpeningSize) {
+        const accFundingRate = _a.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiState, pairedOpeningSize);
         return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize;
     }
     static calculatePositionReserveFee(position, vault, model, timestamp) {
-        const accReservingRate = ZLPDataAPI.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 = ZLPDataAPI.vaultUtilization(vault);
-                return vault.accReservingRate + ZLPDataAPI.calcReservingFeeRate(model, utilization, elapsed);
+                const utilization = _a.vaultUtilization(vault);
+                return vault.accReservingRate + _a.calcReservingFeeRate(model, utilization, elapsed);
             }
         }
         return vault.accReservingRate;
@@ -690,7 +769,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const reservingFeeModel = ZLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
+        const reservingFeeModel = _a.parseReservingFeeModel(reservingFeeModelRaw);
         return {
             liquidity: parseValue(vaultFields.liquidity),
             reservedAmount: parseValue(vaultFields.reserved_amount),
@@ -718,7 +797,7 @@ export class ZLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const fundingFeeModel = ZLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
+        const fundingFeeModel = _a.parseFundingFeeModel(fundingFeeModelRaw);
         return {
             objectId,
             openingSize: parseValue(fields.opening_size),
@@ -797,15 +876,15 @@ export class ZLPDataAPI extends BaseDataAPI {
             closed: positionFields.closed,
             openTimestamp: parseValue(positionFields.open_timestamp),
         };
-        positionInfo.reservingFeeAmount = ZLPDataAPI.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 = ZLPDataAPI.calculatePositionFundingFee(positionInfo, await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long), (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel, (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(), (await this.getMarketInfo()).lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState.model : undefined, pairedSymbol.openingSize);
+        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);
         return positionInfo;
     }
-    static calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize) {
-        const accFundingRate = ZLPDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiModel, pairedOpeningSize);
+    static calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp, oiState, pairedOpeningSize) {
+        const accFundingRate = _a.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, oiState, pairedOpeningSize);
         return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
     }
     static parseRebaseFeeModel(raw) {
@@ -866,6 +945,8 @@ export class ZLPDataAPI 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) {
@@ -1051,9 +1132,9 @@ export class ZLPDataAPI extends BaseDataAPI {
             endSkew = 1;
         }
         // Compute average dynamic spread via integral
-        const avgDynamicRate = ZLPDataAPI.computeIntegralAverage(config.maxDynamicSpreadRate, startSkew, endSkew, config.impactExponent);
+        const avgDynamicRate = _a.computeIntegralAverage(config.maxDynamicSpreadRate, startSkew, endSkew, config.impactExponent);
         // Apply size scaling factor to dynamic spread
-        const sizeFactor = ZLPDataAPI.computeSizeFactor(newPositionSize, config.referenceSize);
+        const sizeFactor = _a.computeSizeFactor(newPositionSize, config.referenceSize);
         const scaledDynamicRate = avgDynamicRate * sizeFactor;
         // total_spread = base_spread + scaled_dynamic
         let totalSpread = config.baseSpreadRate + scaledDynamicRate;
@@ -1124,9 +1205,9 @@ export class ZLPDataAPI extends BaseDataAPI {
         const maxOiThisSide = isLong ? config.maxOiLong : config.maxOiShort;
         const maxOiOpposite = isLong ? config.maxOiShort : config.maxOiLong;
         // Compute average spread rate (uses integration for better accuracy on large trades)
-        const spreadRate = ZLPDataAPI.computeAverageSpreadRate(config, currentOiThisSide, positionSizeValue, currentOiOpposite, maxOiThisSide, maxOiOpposite);
+        const spreadRate = _a.computeAverageSpreadRate(config, currentOiThisSide, positionSizeValue, currentOiOpposite, maxOiThisSide, maxOiOpposite);
         // Apply price impact
-        const adjustedPrice = ZLPDataAPI.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening);
+        const adjustedPrice = _a.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening);
         return {
             spreadRate,
             originalPrice: oraclePrice,
@@ -1242,7 +1323,7 @@ export class ZLPDataAPI extends BaseDataAPI {
             accRewardPerShare: BigInt(content.acc_reward_per_share),
             lockDuration: parseValue(content.lock_duration),
         };
-        ZLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000));
+        _a.refreshPool(pool, Math.floor(Date.now() / 1000));
         return pool;
     }
     static refreshPool(pool, timestamp) {
@@ -1260,4 +1341,84 @@ export class ZLPDataAPI extends BaseDataAPI {
         pool.lastUpdatedTime = calculationEndTime;
     }
 }
+_a = ZLPDataAPI, _ZLPDataAPI_instances = new WeakSet(), _ZLPDataAPI_getTotalVaultsValueUsd = async function _ZLPDataAPI_getTotalVaultsValueUsd(timestamp) {
+    const vaultKeys = Object.keys(this.consts.zoCore.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);
+}, _ZLPDataAPI_getSwapImpactConfig = async function _ZLPDataAPI_getSwapImpactConfig() {
+    const raw = await __classPrivateFieldGet(this, _ZLPDataAPI_instances, "m", _ZLPDataAPI_getMarketDynamicFieldObjectByKeySuffix).call(this, this.consts.zoCore.market, 'SwapImpactConfigKey');
+    if (!raw)
+        return null;
+    return __classPrivateFieldGet(_a, _a, "m", _ZLPDataAPI_parseSwapImpactConfig).call(_a, raw);
+}, _ZLPDataAPI_getEmaVolatilityFeeConfig = async function _ZLPDataAPI_getEmaVolatilityFeeConfig() {
+    const raw = await __classPrivateFieldGet(this, _ZLPDataAPI_instances, "m", _ZLPDataAPI_getMarketDynamicFieldObjectByKeySuffix).call(this, this.consts.zoCore.market, 'EmaVolatilityFeeConfigKey');
+    if (!raw)
+        return null;
+    return __classPrivateFieldGet(_a, _a, "m", _ZLPDataAPI_parseEmaVolatilityFeeConfig).call(_a, raw);
+}, _ZLPDataAPI_getMarketDynamicFieldObjectByKeySuffix = async function _ZLPDataAPI_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;
+}, _ZLPDataAPI_parseSwapImpactConfig = function _ZLPDataAPI_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),
+    };
+}, _ZLPDataAPI_parseEmaVolatilityFeeConfig = function _ZLPDataAPI_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),
+    };
+}, _ZLPDataAPI_computeSwapImpactFeeValue = function _ZLPDataAPI_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;
+}, _ZLPDataAPI_computeEmaVolatilityFeeValue = function _ZLPDataAPI_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;
+}, _ZLPDataAPI_maxEmaDivergenceRate = function _ZLPDataAPI_maxEmaDivergenceRate(sourceFeed, destFeed) {
+    const sourceDiv = __classPrivateFieldGet(_a, _a, "m", _ZLPDataAPI_emaDivergenceRate).call(_a, sourceFeed);
+    const destDiv = __classPrivateFieldGet(_a, _a, "m", _ZLPDataAPI_emaDivergenceRate).call(_a, destFeed);
+    return Math.max(sourceDiv, destDiv);
+}, _ZLPDataAPI_emaDivergenceRate = function _ZLPDataAPI_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=ZLPDataAPI.mjs.map