@zofai/zo-sdk 0.1.93 → 0.1.94

package/dist/implementations/USDZDataAPI.mjs

@@ -3,6 +3,12 @@
  * USDZ DataAPI implementation
  * Implements USDZ-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 _USDZDataAPI_instances, _a, _USDZDataAPI_getTotalVaultsValueUsd, _USDZDataAPI_getSwapImpactConfig, _USDZDataAPI_getEmaVolatilityFeeConfig, _USDZDataAPI_getMarketDynamicFieldObjectByKeySuffix, _USDZDataAPI_parseSwapImpactConfig, _USDZDataAPI_parseEmaVolatilityFeeConfig, _USDZDataAPI_computeSwapImpactFeeValue, _USDZDataAPI_computeEmaVolatilityFeeValue, _USDZDataAPI_maxEmaDivergenceRate, _USDZDataAPI_emaDivergenceRate;
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 import { BaseDataAPI } from "../abstract/index.mjs";
 import { LPToken, SECONDS_PER_EIGHT_HOUR, USDZ_TOKEN_DECIMALS } from "../consts/index.mjs";
@@ -10,6 +16,7 @@ import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from "../ut
 export class USDZDataAPI extends BaseDataAPI {
     constructor(network, provider, apiEndpoint, connectionURL) {
         super(network, provider, apiEndpoint, connectionURL, LPToken.USDZ);
+        _USDZDataAPI_instances.add(this);
     }
     async getStaked(owner) {
         let rawCredentialsData = [];
@@ -42,7 +49,7 @@ export class USDZDataAPI extends BaseDataAPI {
         const credentials = rawCredentialsData
             .filter((item) => item.data.type
             === `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.zoCore.package}::usdz::USDZ, 0x2::sui::SUI>`)
-            .map((item) => USDZDataAPI.parseCredential(item, pool));
+            .map((item) => _a.parseCredential(item, pool));
         return {
             credentials,
             amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
@@ -57,7 +64,7 @@ export class USDZDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return USDZDataAPI.parseStakePool(raw);
+        return _a.parseStakePool(raw);
     }
     /**
      * Creates vaults valuation for USDZ
@@ -139,7 +146,7 @@ export class USDZDataAPI extends BaseDataAPI {
         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 = USDZDataAPI.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 vaultValue = totalVaultAmount * oraclePrice / (10 ** this.consts.coins[vault].decimals);
@@ -150,11 +157,11 @@ export class USDZDataAPI extends BaseDataAPI {
         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 deltaSize = USDZDataAPI.calcDeltaSize(symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked());
+            const deltaSize = _a.calcDeltaSize(symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked());
             // OI context for funding fee delta
             const oiState = await this.getSymbolOiFundingState(tokenId);
             const pairedSymbol = await this.getSymbolInfo(tokenId, !(direction === 'long'));
-            const fundingFeeDelta = USDZDataAPI.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked(), marketInfo.lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState.model : undefined, pairedSymbol.openingSize);
+            const fundingFeeDelta = _a.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked(), marketInfo.lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState : undefined, pairedSymbol.openingSize);
             return fundingFeeDelta + deltaSize;
         });
         const symbolValues = await Promise.all(symbolPromises);
@@ -183,7 +190,7 @@ export class USDZDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return USDZDataAPI.parseMarketInfo(rawData);
+        return _a.parseMarketInfo(rawData);
     }
     /**
      * Gets USDZ vault information
@@ -232,7 +239,7 @@ export class USDZDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return USDZDataAPI.parsePositionConfig(rawData);
+        return _a.parsePositionConfig(rawData);
     }
     /**
      * Gets USDZ symbol configuration
@@ -247,7 +254,7 @@ export class USDZDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return USDZDataAPI.parseSymbolConfig(rawData);
+            return _a.parseSymbolConfig(rawData);
         }
         catch {
             // If the dynamic field doesn't exist, return null
@@ -268,7 +275,7 @@ export class USDZDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return USDZDataAPI.parseOiFundingState(rawData);
+            return _a.parseOiFundingState(rawData);
         }
         catch (e) {
             console.error('Error Fetching USDZ Symbol OI Funding State:', e);
@@ -289,7 +296,7 @@ export class USDZDataAPI extends BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return USDZDataAPI.parsePriceImpactConfig(rawData);
+            return _a.parsePriceImpactConfig(rawData);
         }
         catch (e) {
             // If the dynamic field doesn't exist, return null (price impact not configured for this symbol)
@@ -297,6 +304,49 @@ export class USDZDataAPI 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, _USDZDataAPI_instances, "m", _USDZDataAPI_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, _USDZDataAPI_instances, "m", _USDZDataAPI_getSwapImpactConfig).call(this);
+        const swapImpactFeeValue = swapImpactCfg?.enabled
+            ? __classPrivateFieldGet(_a, _a, "m", _USDZDataAPI_computeSwapImpactFeeValue).call(_a, swapValue, totalVaultsValue, swapImpactCfg.impactMultiplier, swapImpactCfg.maxImpactRate)
+            : 0;
+        const emaCfg = await __classPrivateFieldGet(this, _USDZDataAPI_instances, "m", _USDZDataAPI_getEmaVolatilityFeeConfig).call(this);
+        const emaVolatilityFeeValue = emaCfg?.enabled
+            ? __classPrivateFieldGet(_a, _a, "m", _USDZDataAPI_computeEmaVolatilityFeeValue).call(_a, swapValue, __classPrivateFieldGet(_a, _a, "m", _USDZDataAPI_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;
@@ -486,7 +536,7 @@ export class USDZDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return USDZDataAPI.parseRebaseFeeModel(rawData);
+        return _a.parseRebaseFeeModel(rawData);
     }
     async fundingFeeRate(indexToken, long) {
         const oiState = await this.getSymbolOiFundingState(indexToken);
@@ -499,9 +549,9 @@ export class USDZDataAPI extends BaseDataAPI {
             const lpSupplyAmount = (await this.getMarketInfo()).lpSupplyWithDecimals;
             const model = symbol.fundingFeeModel;
             const elapsed = SECONDS_PER_EIGHT_HOUR;
-            const deltaSize = USDZDataAPI.calcDeltaSize(symbol, price);
+            const deltaSize = _a.calcDeltaSize(symbol, price);
             const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
-            return USDZDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+            return _a.calcFundingFeeRate(model, pnlPerLp, elapsed);
         }
         // OI model enabled: rate based on long/short imbalance
         const longSymbol = await this.getSymbolInfo(indexToken, true);
@@ -512,7 +562,7 @@ export class USDZDataAPI extends BaseDataAPI {
         const elapsed = SECONDS_PER_EIGHT_HOUR;
         const longSize = longSymbol.openingSize;
         const shortSize = shortSymbol.openingSize;
-        const deltaRate = USDZDataAPI.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) {
@@ -523,7 +573,7 @@ export class USDZDataAPI 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 = USDZDataAPI.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;
@@ -535,13 +585,13 @@ export class USDZDataAPI 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 USDZDataAPI.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 USDZDataAPI.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({
@@ -581,44 +631,65 @@ export class USDZDataAPI 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 total = longSize + shortSize > 0 ? longSize + shortSize : 1;
-        const dailyRate = Math.min((model.multiplier * (imbalance ** model.exponent)) / total, 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) {
-                if (oiModel && typeof pairedOpeningSize === 'number') {
+                if (oiState?.enabled && oiState.model && typeof pairedOpeningSize === 'number') {
                     const longSize = symbol.long ? symbol.openingSize : pairedOpeningSize;
                     const shortSize = symbol.long ? pairedOpeningSize : symbol.openingSize;
-                    const deltaRate = USDZDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed);
+                    const deltaRate = _a.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed, oiState.maxOiLong, oiState.maxOiShort);
                     return symbol.accFundingRate + deltaRate;
                 }
-                const deltaSize = USDZDataAPI.calcDeltaSize(symbol, price);
+                const deltaSize = _a.calcDeltaSize(symbol, price);
                 const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
-                return symbol.accFundingRate + USDZDataAPI.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 = USDZDataAPI.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 = USDZDataAPI.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 = USDZDataAPI.vaultUtilization(vault);
-                return vault.accReservingRate + USDZDataAPI.calcReservingFeeRate(model, utilization, elapsed);
+                const utilization = _a.vaultUtilization(vault);
+                return vault.accReservingRate + _a.calcReservingFeeRate(model, utilization, elapsed);
             }
         }
         return vault.accReservingRate;
@@ -665,7 +736,7 @@ export class USDZDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const reservingFeeModel = USDZDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
+        const reservingFeeModel = _a.parseReservingFeeModel(reservingFeeModelRaw);
         return {
             liquidity: parseValue(vaultFields.liquidity),
             reservedAmount: parseValue(vaultFields.reserved_amount),
@@ -693,7 +764,7 @@ export class USDZDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const fundingFeeModel = USDZDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
+        const fundingFeeModel = _a.parseFundingFeeModel(fundingFeeModelRaw);
         return {
             objectId,
             openingSize: parseValue(fields.opening_size),
@@ -772,15 +843,15 @@ export class USDZDataAPI extends BaseDataAPI {
             closed: positionFields.closed,
             openTimestamp: parseValue(positionFields.open_timestamp),
         };
-        positionInfo.reservingFeeAmount = USDZDataAPI.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 = USDZDataAPI.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 = USDZDataAPI.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) {
@@ -815,6 +886,8 @@ export class USDZDataAPI 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) {
@@ -1000,9 +1073,9 @@ export class USDZDataAPI extends BaseDataAPI {
             endSkew = 1;
         }
         // Compute average dynamic spread via integral
-        const avgDynamicRate = USDZDataAPI.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 = USDZDataAPI.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;
@@ -1073,9 +1146,9 @@ export class USDZDataAPI 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 = USDZDataAPI.computeAverageSpreadRate(config, currentOiThisSide, positionSizeValue, currentOiOpposite, maxOiThisSide, maxOiOpposite);
+        const spreadRate = _a.computeAverageSpreadRate(config, currentOiThisSide, positionSizeValue, currentOiOpposite, maxOiThisSide, maxOiOpposite);
         // Apply price impact
-        const adjustedPrice = USDZDataAPI.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening);
+        const adjustedPrice = _a.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening);
         return {
             spreadRate,
             originalPrice: oraclePrice,
@@ -1191,7 +1264,7 @@ export class USDZDataAPI extends BaseDataAPI {
             accRewardPerShare: BigInt(content.acc_reward_per_share),
             lockDuration: parseValue(content.lock_duration),
         };
-        USDZDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000));
+        _a.refreshPool(pool, Math.floor(Date.now() / 1000));
         return pool;
     }
     static refreshPool(pool, timestamp) {
@@ -1209,4 +1282,84 @@ export class USDZDataAPI extends BaseDataAPI {
         pool.lastUpdatedTime = calculationEndTime;
     }
 }
+_a = USDZDataAPI, _USDZDataAPI_instances = new WeakSet(), _USDZDataAPI_getTotalVaultsValueUsd = async function _USDZDataAPI_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);
+}, _USDZDataAPI_getSwapImpactConfig = async function _USDZDataAPI_getSwapImpactConfig() {
+    const raw = await __classPrivateFieldGet(this, _USDZDataAPI_instances, "m", _USDZDataAPI_getMarketDynamicFieldObjectByKeySuffix).call(this, this.consts.zoCore.market, 'SwapImpactConfigKey');
+    if (!raw)
+        return null;
+    return __classPrivateFieldGet(_a, _a, "m", _USDZDataAPI_parseSwapImpactConfig).call(_a, raw);
+}, _USDZDataAPI_getEmaVolatilityFeeConfig = async function _USDZDataAPI_getEmaVolatilityFeeConfig() {
+    const raw = await __classPrivateFieldGet(this, _USDZDataAPI_instances, "m", _USDZDataAPI_getMarketDynamicFieldObjectByKeySuffix).call(this, this.consts.zoCore.market, 'EmaVolatilityFeeConfigKey');
+    if (!raw)
+        return null;
+    return __classPrivateFieldGet(_a, _a, "m", _USDZDataAPI_parseEmaVolatilityFeeConfig).call(_a, raw);
+}, _USDZDataAPI_getMarketDynamicFieldObjectByKeySuffix = async function _USDZDataAPI_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;
+}, _USDZDataAPI_parseSwapImpactConfig = function _USDZDataAPI_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),
+    };
+}, _USDZDataAPI_parseEmaVolatilityFeeConfig = function _USDZDataAPI_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),
+    };
+}, _USDZDataAPI_computeSwapImpactFeeValue = function _USDZDataAPI_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;
+}, _USDZDataAPI_computeEmaVolatilityFeeValue = function _USDZDataAPI_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;
+}, _USDZDataAPI_maxEmaDivergenceRate = function _USDZDataAPI_maxEmaDivergenceRate(sourceFeed, destFeed) {
+    const sourceDiv = __classPrivateFieldGet(_a, _a, "m", _USDZDataAPI_emaDivergenceRate).call(_a, sourceFeed);
+    const destDiv = __classPrivateFieldGet(_a, _a, "m", _USDZDataAPI_emaDivergenceRate).call(_a, destFeed);
+    return Math.max(sourceDiv, destDiv);
+}, _USDZDataAPI_emaDivergenceRate = function _USDZDataAPI_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=USDZDataAPI.mjs.map