@zofai/zo-sdk 0.1.92 → 0.1.94

package/dist/consts/deployments-slp-mainnet.json

@@ -1,7 +1,7 @@
 {
     "sudo_core": {
         "package": "0xc44d97a4bc4e5a33ca847b72b123172c88a6328196b71414f32c3070233604b2",
-        "upgraded_package": "0x60d75af192054ac52dce44b496f8d4c2ab27d4fd3dd0737aa69902b3170a78b7",
+        "upgraded_package": "0x133f18548e87ae085905f3dd4c9d5be9b9ceb9a9bd2d55f34a0804eb249db1ae",
         "upgrade_cap": "0x2092387c072fe18f91b57b9dde362f758259ee88d993a5faf569b4f2eb288b12",
         "admin_cap": "0x0b4183c84de542c6f9623acd521294ea7e8205a2a7a23f4fac97e964fe4da30e",
         "market": "0x4d753c2c69109cbeb806393956cfeba28d832354a37d59d9a019ee580f82893d",

package/dist/consts/deployments-usdz-mainnet.json

@@ -1,7 +1,7 @@
 {
     "zo_core": {
         "package": "0x7fd8aba1652c58b6397c799fd375e748e5053145cb7e126d303e0a1545fd1fec",
-        "upgraded_package": "0x9074c6ee5ca95af8356c676636a51a04baca03745ea5d25ce932b06a11612898",
+        "upgraded_package": "0x43779d65ae051458c5021f6bfe891a117c49b091132c6f3be2c714b02a4bcb25",
         "upgrade_cap": "0x2f67d379d3b9e256a9c4079de50f4bd336dcbda1bd90d1fcd61a9cc1dc369d69",
         "admin_cap": "0x63af8e78701327be98e0c44967389148c374f4ea7c7cf8acf64957b705ffd02d",
         "market": "0x3310c794d0bbc4b0421d2fedc74fbd5a028b09fe4d396cd5458786f4c52fa636",

package/dist/consts/deployments-zlp-mainnet.json

@@ -1,7 +1,7 @@
 {
     "zo_core": {
         "package": "0xf7fade57462e56e2eff1d7adef32e4fd285b21fd81f983f407bb7110ca766cda",
-        "upgraded_package": "0x8693f6ae1c2ea462c97bcbafa29974fd304cefc1d3aa457346594226603d8fe4",
+        "upgraded_package": "0x420dbbc3b14a2e1645a38b111dc1c381cae43f349ddf800540f8991efbce563d",
         "upgrade_cap": "0xcc96f78abe0b868afaab05954ccc6357afb5d379a21389d6eb88dda8b1f60052",
         "admin_cap": "0xbc10f6481f2b5d6185c73ee680aa90a60fe3854d9f638e00f7e00d3b6a88e2b8",
         "market": "0x35c667bd8c401036103992791a924f31df0d104256a9e2313acee5b1bcf05b7e",

package/dist/implementations/SLPDataAPI.cjs

@@ -6,6 +6,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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SLPDataAPI = void 0;
 const transactions_1 = require("@mysten/sui/transactions");
@@ -19,6 +25,7 @@ const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60; // 28800 seconds
 class SLPDataAPI extends abstract_1.BaseDataAPI {
     constructor(network, provider, apiEndpoint, connectionURL) {
         super(network, provider, apiEndpoint, connectionURL, consts_1.LPToken.SLP);
+        _SLPDataAPI_instances.add(this);
     }
     static calculateVaultReservingFee(vaultInfo, reservingFeeModel, currentTime) {
         const timeDelta = currentTime - vaultInfo.lastUpdate;
@@ -26,8 +33,8 @@ class SLPDataAPI extends abstract_1.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() {
@@ -41,8 +48,8 @@ class SLPDataAPI extends abstract_1.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 };
     }
     /**
@@ -128,27 +135,30 @@ class SLPDataAPI extends abstract_1.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] = (0, utils_2.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;
@@ -158,6 +168,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             price: slpPrice,
             supply: marketInfo.lpSupplyWithDecimals,
             apr: Number(marketInfo.apr),
+            vaultPrices,
         };
     }
     /**
@@ -204,11 +215,18 @@ class SLPDataAPI extends abstract_1.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,
         };
     }
     /**
@@ -227,7 +245,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         });
         const apr = await this.getCumulativeApr();
         return {
-            ...SLPDataAPI.parseMarketInfo(rawData),
+            ..._a.parseMarketInfo(rawData),
             apr,
         };
     }
@@ -279,7 +297,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return SLPDataAPI.parseSymbolConfig(rawData);
+            return _a.parseSymbolConfig(rawData);
         }
         catch {
             // If the dynamic field doesn't exist, return null
@@ -301,7 +319,7 @@ class SLPDataAPI extends abstract_1.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)
@@ -322,7 +340,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                     value: { dummy_field: false },
                 },
             });
-            return SLPDataAPI.parseOiFundingState(rawData);
+            return _a.parseOiFundingState(rawData);
         }
         catch (e) {
             // If the dynamic field doesn't exist, return null
@@ -330,6 +348,52 @@ class SLPDataAPI extends abstract_1.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
@@ -421,7 +485,7 @@ class SLPDataAPI extends abstract_1.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)),
@@ -438,7 +502,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        return SLPDataAPI.parseStakePool(raw);
+        return _a.parseStakePool(raw);
     }
     async getStakePoolV2() {
         const poolId = this.sharedConfig.zoStaking.pools.slp;
@@ -448,7 +512,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        return SLPDataAPI.parseStakePool(raw);
+        return _a.parseStakePool(raw);
     }
     async getStakedV2(owner) {
         let rawCredentialsData = [];
@@ -481,7 +545,7 @@ class SLPDataAPI extends abstract_1.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)),
@@ -497,7 +561,7 @@ class SLPDataAPI extends abstract_1.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);
@@ -508,9 +572,9 @@ class SLPDataAPI extends abstract_1.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;
@@ -520,7 +584,7 @@ class SLPDataAPI extends abstract_1.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);
@@ -534,7 +598,7 @@ class SLPDataAPI extends abstract_1.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) {
@@ -576,7 +640,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        return SLPDataAPI.parsePositionConfig(rawData);
+        return _a.parsePositionConfig(rawData);
     }
     async getOpenPositions(batchSize = 50, symbol = 'sui') {
         let positionDynamicFields = [];
@@ -794,26 +858,26 @@ class SLPDataAPI extends abstract_1.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;
@@ -827,23 +891,44 @@ class SLPDataAPI extends abstract_1.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;
@@ -1028,8 +1113,8 @@ class SLPDataAPI extends abstract_1.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) {
@@ -1068,8 +1153,8 @@ class SLPDataAPI extends abstract_1.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,
@@ -1095,6 +1180,8 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 exponent: (0, utils_2.parseValue)(content.model.fields.exponent),
                 max: (0, utils_2.parseValue)(content.model.fields.max),
             },
+            maxOiLong: content.max_oi_long !== null && content.max_oi_long !== undefined ? (0, utils_2.parseValue)(content.max_oi_long) : undefined,
+            maxOiShort: content.max_oi_short !== null && content.max_oi_short !== undefined ? (0, utils_2.parseValue)(content.max_oi_short) : undefined,
         };
     }
     static parsePriceImpactConfig(raw) {
@@ -1130,7 +1217,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        const reservingFeeModel = SLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
+        const reservingFeeModel = _a.parseReservingFeeModel(reservingFeeModelRaw);
         return {
             liquidity: (0, utils_2.parseValue)(vaultFields.liquidity),
             reservedAmount: (0, utils_2.parseValue)(vaultFields.reserved_amount),
@@ -1164,7 +1251,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        const fundingFeeModel = SLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
+        const fundingFeeModel = _a.parseFundingFeeModel(fundingFeeModelRaw);
         return {
             objectId,
             openingSize: (0, utils_2.parseValue)(fields.opening_size),
@@ -1212,11 +1299,11 @@ class SLPDataAPI extends abstract_1.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);
@@ -1339,10 +1426,10 @@ class SLPDataAPI extends abstract_1.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;
     }
@@ -1381,4 +1468,93 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
     }
 }
 exports.SLPDataAPI = SLPDataAPI;
+_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: (0, utils_2.parseValue)(fields.impact_multiplier),
+        maxImpactRate: (0, utils_2.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: (0, utils_2.parseValue)(fields.multiplier),
+        maxFeeRate: (0, utils_2.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.cjs.map