zo-sdk 0.1.21 → 0.1.23

package/dist/implementations/ZBTCVCDataAPI.cjs

@@ -0,0 +1,824 @@
+"use strict";
+/* eslint-disable no-await-in-loop */
+/**
+ * ZBTCVC DataAPI implementation
+ * Implements ZBTCVC-specific data access methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZBTCVCDataAPI = void 0;
+const utils_1 = require("@mysten/sui/utils");
+const abstract_1 = require("../abstract/index.cjs");
+const consts_1 = require("../consts/index.cjs");
+const utils_2 = require("../utils.cjs");
+class ZBTCVCDataAPI extends abstract_1.BaseDataAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, consts_1.LPToken.ZBTCVC);
+    }
+    async getStaked(owner) {
+        let rawCredentialsData = [];
+        let queryNextPage = true;
+        let queryCursor;
+        const limit = 50;
+        while (queryNextPage) {
+            const { data, hasNextPage, nextCursor } = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    MoveModule: {
+                        package: this.consts.zoStaking.package,
+                        module: 'pool',
+                    },
+                },
+                options: {
+                    showType: true,
+                    showContent: true,
+                },
+                cursor: queryCursor,
+                limit,
+            });
+            queryNextPage = hasNextPage;
+            queryCursor = nextCursor;
+            if (!data)
+                break;
+            rawCredentialsData = [...rawCredentialsData, ...data];
+        }
+        const pool = await this.getStakePool();
+        const credentials = rawCredentialsData.map((item) => ZBTCVCDataAPI.parseCredential(item, pool));
+        return {
+            credentials,
+            amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
+            claimable: credentials.reduce((acc, cur) => acc + cur.claimable, BigInt(0)),
+        };
+    }
+    async getStakePool() {
+        const raw = await this.provider.getObject({
+            id: this.consts.zoStaking.pools[0],
+            options: {
+                showContent: true,
+            },
+        });
+        return ZBTCVCDataAPI.parseStakePool(raw);
+    }
+    /**
+     * Creates vaults valuation for ZBTCVC
+     */
+    valuateVaults(tx) {
+        const vaultsValuation = tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::create_vaults_valuation`,
+            typeArguments: [`${this.consts.zoCore.package}::zbtcvc::ZBTCVC`],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+            ],
+        });
+        for (const key of Object.keys(this.consts.zoCore.vaults)) {
+            const vault = this.consts.zoCore.vaults[key];
+            tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::valuate_vault`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                    this.consts.coins[key].module,
+                ],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(vault.reservingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[key]),
+                    vaultsValuation,
+                ],
+            });
+        }
+        return vaultsValuation;
+    }
+    /**
+     * Creates symbols valuation for ZBTCVC
+     */
+    valuateSymbols(tx) {
+        const symbolsValuation = tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::create_symbols_valuation`,
+            typeArguments: [`${this.consts.zoCore.package}::zbtcvc::ZBTCVC`],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+            ],
+        });
+        for (const key of Object.keys(this.consts.zoCore.symbols)) {
+            const [direction, token] = (0, utils_2.parseSymbolKey)(key);
+            const symbol = this.consts.zoCore.symbols[key];
+            tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::valuate_symbol`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                    this.consts.coins[token].module,
+                    `${this.consts.zoCore.package}::market::${direction.toUpperCase()}`,
+                ],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(symbol.fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[token]),
+                    symbolsValuation,
+                ],
+            });
+        }
+        return symbolsValuation;
+    }
+    /**
+     * Creates both vaults and symbols valuation
+     */
+    valuate(tx) {
+        const vaultsValuation = this.valuateVaults(tx);
+        const symbolsValuation = this.valuateSymbols(tx);
+        return { vaultsValuation, symbolsValuation };
+    }
+    /**
+     * Valuates the ZBTCVC market
+     */
+    async valuateMarket() {
+        const marketInfo = await this.getMarketInfo();
+        const days = 7;
+        const fee = await this.getPastFee(days);
+        let zbtcvcPrice = 0;
+        let value = 0;
+        const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
+            const vaultInfo = await this.getVaultInfo(vault);
+            const reservingFeeDelta = ZBTCVCDataAPI.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 symbolPromises = Object.keys(this.consts.zoCore.symbols).map(async (symbol) => {
+            const [direction, tokenId] = (0, utils_2.parseSymbolKey)(symbol);
+            const symbolInfo = await this.getSymbolInfo(tokenId, direction === 'long');
+            const deltaSize = ZBTCVCDataAPI.calcDeltaSize(symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked());
+            const fundingFeeDelta = ZBTCVCDataAPI.calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked(), marketInfo.lpSupplyWithDecimals, Date.now() / 1000);
+            return fundingFeeDelta + deltaSize;
+        });
+        const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), Promise.all(symbolPromises)]);
+        value = vaultValues.reduce((acc, curr) => acc + curr, 0);
+        value += symbolValues.reduce((acc, curr) => acc + curr, 0);
+        zbtcvcPrice = value / marketInfo.lpSupplyWithDecimals;
+        return {
+            marketCap: value,
+            price: zbtcvcPrice,
+            supply: marketInfo.lpSupplyWithDecimals,
+            apr: (fee / value) * 365 / days,
+        };
+    }
+    /**
+     * Gets ZBTCVC market information
+     */
+    async getMarketInfo() {
+        this.validateCache();
+        if (this.marketInfoCache) {
+            return this.marketInfoCache;
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.zoCore.market,
+            options: {
+                showContent: true,
+            },
+        });
+        return ZBTCVCDataAPI.parseMarketInfo(rawData);
+    }
+    /**
+     * Gets ZBTCVC vault information
+     */
+    async getVaultInfo(vaultToken) {
+        this.validateCache();
+        if (this.vaultInfoCache[vaultToken]) {
+            return this.vaultInfoCache[vaultToken];
+        }
+        const rawData = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.vaultsParent,
+            name: {
+                type: `${this.consts.zoCore.package}::market::VaultName<${this.consts.coins[vaultToken].module}>`,
+                value: { dummy_field: false },
+            },
+        });
+        return await this.parseVaultInfo(rawData);
+    }
+    /**
+     * Gets ZBTCVC symbol information
+     */
+    async getSymbolInfo(indexToken, long) {
+        this.validateCache();
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        if (this.symbolInfoCache[symbol]) {
+            return this.symbolInfoCache[symbol];
+        }
+        const rawData = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.symbolsParent,
+            name: {
+                type: `${this.consts.zoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+                value: { dummy_field: false },
+            },
+        });
+        return await this.parseSymbolInfo(rawData, long);
+    }
+    async getPositionConfig(indexToken, long) {
+        this.validateCache();
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        if (this.positionConfigCache[symbol]) {
+            return this.positionConfigCache[symbol];
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.zoCore.symbols[symbol].positionConfig,
+            options: {
+                showContent: true,
+            },
+        });
+        return ZBTCVCDataAPI.parsePositionConfig(rawData);
+    }
+    /**
+     * Gets ZBTCVC symbol configuration
+     */
+    async getSymbolConfig(indexToken, long) {
+        this.validateCache();
+        try {
+            const rawData = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.zoCore.market,
+                name: {
+                    type: `${this.consts.zoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+                    value: { dummy_field: false },
+                },
+            });
+            return ZBTCVCDataAPI.parseSymbolConfig(rawData);
+        }
+        catch {
+            // If the dynamic field doesn't exist, return null
+            console.error('Symbol Config Not Found');
+            return null;
+        }
+    }
+    async getPositionCapInfoList(owner) {
+        const positionCapInfoList = [];
+        let cursor;
+        let hasNextPage = true;
+        while (hasNextPage) {
+            const positionCaps = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    MoveModule: {
+                        package: this.consts.zoCore.package,
+                        module: 'market',
+                    },
+                },
+                options: {
+                    showType: true,
+                },
+                cursor,
+            });
+            for (const positionCap of positionCaps.data) {
+                if (positionCap.data?.type?.includes('PositionCap')) {
+                    positionCapInfoList.push({
+                        positionCapId: positionCap.data.objectId,
+                        symbol0: positionCap.data.type.split('<')[1].split(',')[0].trim(),
+                        symbol1: positionCap.data.type.split('<')[1].split(',')[1].split(',')[0].trim(),
+                        long: positionCap.data.type.includes('LONG'),
+                    });
+                }
+            }
+            // If we don't want to fetch all pages or there are no more pages, break the loop
+            hasNextPage = positionCaps.hasNextPage;
+            cursor = positionCaps.nextCursor;
+        }
+        return positionCapInfoList;
+    }
+    async getPositionInfoList(positionCapInfoList, owner, batchSize = 10) {
+        const positionInfoList = [];
+        // Process in batches of 10
+        for (let i = 0; i < positionCapInfoList.length; i += batchSize) {
+            const batch = positionCapInfoList.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (positionCapInfo) => {
+                try {
+                    const positionRaw = await this.provider.getDynamicFieldObject({
+                        parentId: this.consts.zoCore.positionsParent,
+                        name: {
+                            type: `${this.consts.zoCore.package}::market::PositionName<${positionCapInfo.symbol0}, ${positionCapInfo.symbol1}, ${this.consts.zoCore.package}::market::${positionCapInfo.long ? 'LONG' : 'SHORT'}>`,
+                            value: {
+                                owner,
+                                id: positionCapInfo.positionCapId,
+                            },
+                        },
+                    });
+                    positionInfoList.push(await this.parsePositionInfo(positionRaw, positionCapInfo.positionCapId));
+                }
+                catch (error) {
+                    // Position might have been deleted after force settlement
+                    console.warn(`Failed to parse position info for position cap ID ${positionCapInfo.positionCapId}: ${error}`);
+                    // Continue with next position without adding this one to the list
+                }
+            }));
+        }
+        return positionInfoList.sort((a, b) => a.openTimestamp > b.openTimestamp ? 1 : -1);
+    }
+    async getOpenPositions() {
+        let positionDynamicFields = [];
+        let _continue = true;
+        let cursor;
+        while (_continue) {
+            // data here will be a list of dynamic fields containing name and value
+            const { data, nextCursor, hasNextPage } = await this.provider.getDynamicFields({
+                parentId: this.consts.zoCore.positionsParent,
+                cursor,
+            });
+            positionDynamicFields = positionDynamicFields.concat(data);
+            _continue = hasNextPage;
+            cursor = nextCursor;
+        }
+        // then we query by dynamic field names and order by time
+        const positionInfoList = [];
+        await Promise.all(positionDynamicFields.map(async (positionDynamicField) => {
+            const positionRaw = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.zoCore.positionsParent,
+                name: positionDynamicField.name,
+            });
+            if (positionRaw?.data?.content) {
+                const positionInfo = await this.parsePositionInfo(positionRaw, positionDynamicField.objectId);
+                if (positionInfo) {
+                    positionInfoList.push(positionInfo);
+                }
+            }
+        }));
+        return positionInfoList
+            .filter(positionInfo => !positionInfo.closed)
+            .sort((a, b) => (a.openTimestamp > b.openTimestamp ? 1 : -1));
+    }
+    async getOrderCapInfoList(owner) {
+        const orderCapInfoList = [];
+        let cursor;
+        let hasNextPage = true;
+        while (hasNextPage) {
+            const orderCaps = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    MoveModule: {
+                        package: this.consts.zoCore.package,
+                        module: 'market',
+                    },
+                },
+                options: {
+                    showType: true,
+                    showContent: true,
+                },
+                cursor,
+            });
+            for (const orderCap of orderCaps.data) {
+                if (orderCap.data?.type?.includes('OrderCap')) {
+                    orderCapInfoList.push({
+                        orderCapId: orderCap.data.objectId,
+                        symbol0: orderCap.data.type.split('<')[1].split(',')[0].trim(),
+                        symbol1: orderCap.data.type.split('<')[1].split(',')[1].split(',')[0].trim(),
+                        long: orderCap.data.type.includes('LONG'),
+                        positionId: orderCap.data.content?.fields?.position_id,
+                    });
+                }
+            }
+            hasNextPage = orderCaps.hasNextPage;
+            cursor = orderCaps.nextCursor;
+        }
+        return orderCapInfoList;
+    }
+    async getOrderInfoList(orderCapInfoList, owner, batchSize = 10) {
+        const orderInfoList = [];
+        // Process in batches of 10
+        for (let i = 0; i < orderCapInfoList.length; i += batchSize) {
+            const batch = orderCapInfoList.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (orderCapInfo) => {
+                try {
+                    const orderRaw = await this.provider.getDynamicFieldObject({
+                        parentId: this.consts.zoCore.ordersParent,
+                        name: {
+                            // We have enforced collateral coin type to match with fee coin type so we can use symbol0 in the first slot and the last slot of the OrderName
+                            type: `${this.consts.zoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.zoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${orderCapInfo.symbol0}>`,
+                            value: {
+                                owner,
+                                id: orderCapInfo.orderCapId,
+                                position_id: {
+                                    vec: orderCapInfo.positionId ? [orderCapInfo.positionId] : [],
+                                },
+                            },
+                        },
+                    });
+                    orderInfoList.push(this.parseOrderInfo(orderRaw, orderCapInfo.orderCapId));
+                }
+                catch (error) {
+                    // Order might have been deleted
+                    console.warn(`Failed to parse order info for order cap ID ${orderCapInfo.orderCapId}: ${error}`);
+                    // Continue with next order without adding this one to the list
+                }
+            }));
+        }
+        return orderInfoList.sort((a, b) => a.createdAt > b.createdAt ? 1 : -1);
+    }
+    async hasReferral(referree) {
+        const raw = await this.getReferralData(referree);
+        return !raw.error;
+    }
+    async getReferralData(referree) {
+        const raw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.referralsParent,
+            name: {
+                type: 'address',
+                value: referree,
+            },
+        });
+        return raw;
+    }
+    /**
+     * Gets rebase fee model for ZBTCVC
+     */
+    async getRebaseFeeModel() {
+        this.validateCache();
+        if (this.rebaseFeeModelCache) {
+            return this.rebaseFeeModelCache;
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.zoCore.rebaseFeeModel,
+            options: {
+                showContent: true,
+            },
+        });
+        return ZBTCVCDataAPI.parseRebaseFeeModel(rawData);
+    }
+    async fundingFeeRate(indexToken, long) {
+        const symbol = await this.getSymbolInfo(indexToken, long);
+        if (symbol.lastUpdate <= 0) {
+            return 0;
+        }
+        const price = (await this.getOraclePrice(indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked();
+        const lpSupplyAmount = (await this.getMarketInfo()).lpSupplyWithDecimals;
+        const model = symbol.fundingFeeModel;
+        const elapsed = consts_1.SECONDS_PER_EIGHT_HOUR;
+        const deltaSize = ZBTCVCDataAPI.calcDeltaSize(symbol, price);
+        const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+        return ZBTCVCDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+    }
+    async rebaseFeeRate(collateralToken, increase, amount) {
+        let vaultValue = 0;
+        if (!increase && amount > 0) {
+            amount = -amount;
+        }
+        const value = amount * (await this.getOraclePrice(collateralToken)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[collateralToken].decimals);
+        const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
+            const vaultInfo = await this.getVaultInfo(vault);
+            const reservingFeeDelta = ZBTCVCDataAPI.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;
+            }
+            return res;
+        });
+        const vaultValues = await Promise.all(vaultPromises);
+        const totalVaultValue = vaultValues.reduce((acc, curr) => acc + curr, 0);
+        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 ZBTCVCDataAPI.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 ZBTCVCDataAPI.calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, consts_1.SECONDS_PER_EIGHT_HOUR);
+    }
+    async getHistory(trader, page, limit, orderType, symbol) {
+        const params = new URLSearchParams({
+            trader,
+            page: page.toString(),
+            limit: limit.toString(),
+        });
+        // Add filter parameters if provided
+        if (orderType && orderType !== 'all') {
+            params.append('orderType', orderType);
+        }
+        if (symbol && symbol !== 'all') {
+            params.append('symbol', symbol);
+        }
+        params.append('lpType', 'ZBTCVC');
+        const url = `${this.apiEndpoint}/traderEvents?${params}`;
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        const response = await res.json();
+        return {
+            histories: response.data?.histories || [],
+            pagination: response.data?.pagination || {
+                total: 0,
+                page: 1,
+                limit: 20,
+                pages: 0,
+            },
+        };
+    }
+    // Private helper methods
+    static calcFundingFeeRate(model, pnlPerRate, elapsed) {
+        const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max);
+        const secondsRate = dailyRate * elapsed / consts_1.SECONDS_PER_EIGHT_HOUR;
+        return pnlPerRate >= 0 ? -secondsRate : secondsRate;
+    }
+    static calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp) {
+        if (symbol.lastUpdate > 0) {
+            const elapsed = timestamp - symbol.lastUpdate;
+            if (elapsed > 0) {
+                const deltaSize = ZBTCVCDataAPI.calcDeltaSize(symbol, price);
+                const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+                return symbol.accFundingRate + ZBTCVCDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
+            }
+        }
+        return symbol.accFundingRate;
+    }
+    static calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp) {
+        const accFundingRate = ZBTCVCDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp);
+        return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize;
+    }
+    static calculatePositionReserveFee(position, vault, model, timestamp) {
+        const accReservingRate = ZBTCVCDataAPI.calcAccReservingFeeRate(vault, model, timestamp);
+        return position.reservingFeeAmount + (accReservingRate - vault.accReservingRate) * position.collateralAmount;
+    }
+    static calcAccReservingFeeRate(vault, model, timestamp) {
+        if (vault.lastUpdate > 0) {
+            const elapsed = timestamp - vault.lastUpdate;
+            if (elapsed > 0) {
+                const utilization = ZBTCVCDataAPI.vaultUtilization(vault);
+                return vault.accReservingRate + ZBTCVCDataAPI.calcReservingFeeRate(model, utilization, elapsed);
+            }
+        }
+        return vault.accReservingRate;
+    }
+    static calcRebaseFeeRate(model, increase, ratio, targetRatio) {
+        if ((increase && ratio <= targetRatio) || (!increase && ratio >= targetRatio)) {
+            return model.base;
+        }
+        return model.base + model.multiplier * Math.abs(ratio - targetRatio);
+    }
+    static vaultUtilization(vault) {
+        const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount;
+        if (supplyAmount === 0) {
+            return 0;
+        }
+        return vault.reservedAmount / supplyAmount;
+    }
+    static calcReservingFeeRate(model, utilization, elapsed) {
+        return model.multiplier * utilization * elapsed / consts_1.SECONDS_PER_EIGHT_HOUR;
+    }
+    static calcDeltaSize(symbol, price) {
+        const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price;
+        return symbol.long ? symbol.openingSize - latestSize : latestSize - symbol.openingSize;
+    }
+    static parseMarketInfo(raw) {
+        const content = raw.data.content.fields;
+        return {
+            lpSupply: content.lp_supply.fields.value,
+            positionId: content.positions.fields.id.id,
+            vaultId: content.vaults.fields.id.id,
+            symbolId: content.symbols.fields.id.id,
+            referralId: content.referrals.fields.id.id,
+            orderId: content.orders.fields.id.id,
+            rebaseFeeModel: content.rebase_fee_model,
+            lpSupplyWithDecimals: content.lp_supply.fields.value / (10 ** consts_1.ZBTCVC_TOKEN_DECIMALS),
+        };
+    }
+    async parseVaultInfo(raw) {
+        const vaultFields = raw.data.content.fields.value.fields;
+        const reservingFeeModelAddr = vaultFields.reserving_fee_model;
+        const reservingFeeModelRaw = await this.provider.getObject({
+            id: reservingFeeModelAddr,
+            options: {
+                showContent: true,
+            },
+        });
+        const reservingFeeModel = ZBTCVCDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
+        return {
+            liquidity: (0, utils_2.parseValue)(vaultFields.liquidity),
+            reservedAmount: (0, utils_2.parseValue)(vaultFields.reserved_amount),
+            unrealisedReservingFeeAmount: (0, utils_2.parseValue)(vaultFields.unrealised_reserving_fee_amount),
+            accReservingRate: (0, utils_2.parseValue)(vaultFields.acc_reserving_rate),
+            enabled: vaultFields.enabled,
+            weight: (0, utils_2.parseValue)(vaultFields.weight),
+            lastUpdate: (0, utils_2.parseValue)(vaultFields.last_update),
+            reservingFeeModel,
+            priceConfig: {
+                maxInterval: (0, utils_2.parseValue)(vaultFields.price_config.fields.max_interval),
+                maxConfidence: (0, utils_2.parseValue)(vaultFields.price_config.fields.max_confidence),
+                precision: (0, utils_2.parseValue)(vaultFields.price_config.fields.precision),
+                feeder: vaultFields.price_config.fields.feeder,
+            },
+        };
+    }
+    async parseSymbolInfo(raw, long) {
+        const { objectId } = raw.data;
+        const { fields } = raw.data.content.fields.value;
+        const fundingFeeModelAddr = fields.funding_fee_model;
+        const fundingFeeModelRaw = await this.provider.getObject({
+            id: fundingFeeModelAddr,
+            options: {
+                showContent: true,
+            },
+        });
+        const fundingFeeModel = ZBTCVCDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
+        return {
+            objectId,
+            openingSize: (0, utils_2.parseValue)(fields.opening_size),
+            openingAmount: (0, utils_2.parseValue)(fields.opening_amount),
+            accFundingRate: (0, utils_2.parseValue)(fields.acc_funding_rate),
+            realisedPnl: (0, utils_2.parseValue)(fields.realised_pnl),
+            unrealisedFundingFeeValue: (0, utils_2.parseValue)(fields.unrealised_funding_fee_value),
+            openEnabled: fields.open_enabled,
+            liquidateEnabled: fields.liquidate_enabled,
+            decreaseEnabled: fields.decrease_enabled,
+            lastUpdate: (0, utils_2.parseValue)(fields.last_update),
+            fundingFeeModel,
+            long,
+            priceConfig: {
+                maxInterval: (0, utils_2.parseValue)(fields.price_config.fields.max_interval),
+                maxConfidence: (0, utils_2.parseValue)(fields.price_config.fields.max_confidence),
+                precision: (0, utils_2.parseValue)(fields.price_config.fields.precision),
+                feeder: fields.price_config.fields.feeder,
+            },
+        };
+    }
+    static parsePositionConfig(raw) {
+        const positionConfigFields = raw.data.content.fields.inner.fields;
+        return {
+            decreaseFeeBps: (0, utils_2.parseValue)(positionConfigFields.decrease_fee_bps),
+            liquidationBonus: (0, utils_2.parseValue)(positionConfigFields.liquidation_bonus),
+            liquidationThreshold: (0, utils_2.parseValue)(positionConfigFields.liquidation_threshold),
+            maxLeverage: (0, utils_2.parseValue)(positionConfigFields.max_leverage),
+            minHoldingDuration: (0, utils_2.parseValue)(positionConfigFields.min_holding_duration),
+            openFeeBps: (0, utils_2.parseValue)(positionConfigFields.open_fee_bps),
+            maxReservedMultiplier: (0, utils_2.parseValue)(positionConfigFields.max_reserved_multiplier),
+            minCollateralValue: (0, utils_2.parseValue)(positionConfigFields.min_collateral_value),
+        };
+    }
+    static parseSymbolConfig(raw) {
+        const { fields } = raw.data.content;
+        return {
+            id: fields.id.id,
+            max_opening_size: (0, utils_2.parseValue)(fields.max_opening_size),
+            max_opening_size_enabled: fields.max_opening_size_enabled,
+            max_opening_size_per_position: (0, utils_2.parseValue)(fields.max_opening_size_per_position),
+            max_opening_size_per_position_enabled: fields.max_opening_size_per_position_enabled,
+            instant_exit_fee_config: {
+                instant_exit_tier_1_duration_threshold: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_1_duration_threshold),
+                instant_exit_tier_1_fee_bps: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_bps.fields.value),
+                instant_exit_tier_1_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_enabled,
+                instant_exit_tier_2_duration_threshold: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_2_duration_threshold),
+                instant_exit_tier_2_fee_bps: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_bps.fields.value),
+                instant_exit_tier_2_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_enabled,
+                instant_exit_tier_3_duration_threshold: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_3_duration_threshold),
+                instant_exit_tier_3_fee_bps: (0, utils_2.parseValue)(fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_bps.fields.value),
+                instant_exit_tier_3_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_enabled,
+            },
+        };
+    }
+    async parsePositionInfo(raw, id_) {
+        const { content } = raw.data;
+        const { fields } = content;
+        const positionFields = fields.value.fields;
+        const dataType = fields.name.type;
+        const positionInfo = {
+            id: id_,
+            long: dataType.includes('::market::LONG'),
+            owner: fields.name.fields.owner,
+            version: Number.parseInt(raw.data.version, 10),
+            collateralToken: (0, utils_2.suiSymbolToSymbol)(dataType.split('<')[1].split(',')[0].trim(), this.consts),
+            indexToken: (0, utils_2.suiSymbolToSymbol)(dataType.split(',')[1].trim(), this.consts),
+            collateralAmount: (0, utils_2.parseValue)(positionFields.collateral),
+            positionAmount: (0, utils_2.parseValue)(positionFields.position_amount),
+            reservedAmount: (0, utils_2.parseValue)(positionFields.reserved),
+            positionSize: (0, utils_2.parseValue)(positionFields.position_size),
+            lastFundingRate: (0, utils_2.parseValue)(positionFields.last_funding_rate),
+            lastReservingRate: (0, utils_2.parseValue)(positionFields.last_reserving_rate),
+            reservingFeeAmount: (0, utils_2.parseValue)(positionFields.reserving_fee_amount),
+            fundingFeeValue: (0, utils_2.parseValue)(positionFields.funding_fee_value),
+            closed: positionFields.closed,
+            openTimestamp: (0, utils_2.parseValue)(positionFields.open_timestamp),
+        };
+        positionInfo.reservingFeeAmount = ZBTCVCDataAPI.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000);
+        positionInfo.fundingFeeValue = ZBTCVCDataAPI.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);
+        return positionInfo;
+    }
+    static calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp) {
+        const accFundingRate = ZBTCVCDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp);
+        return position.fundingFeeValue + (accFundingRate - symbol.accFundingRate) * position.positionSize;
+    }
+    static parseRebaseFeeModel(raw) {
+        const { fields } = raw.data.content;
+        return {
+            base: (0, utils_2.parseValue)(fields.base),
+            multiplier: (0, utils_2.parseValue)(fields.multiplier),
+        };
+    }
+    static parseReservingFeeModel(raw) {
+        const content = raw.data.content.fields;
+        return {
+            multiplier: (0, utils_2.parseValue)(content.multiplier),
+        };
+    }
+    static parseFundingFeeModel(raw) {
+        const content = raw.data.content.fields;
+        return {
+            multiplier: (0, utils_2.parseValue)(content.multiplier),
+            max: (0, utils_2.parseValue)(content.max),
+        };
+    }
+    parseOrderInfo(raw, capId) {
+        const { content } = raw.data;
+        const { fields } = content.fields.value;
+        // Extract tokens from dataType
+        const dataType = content.type;
+        const orderType = content.fields.value.type.includes('OpenPositionOrder') ? 'OPEN_POSITION' : 'DECREASE_POSITION';
+        const ret = {
+            id: content.fields.id.id,
+            capId,
+            executed: fields.executed,
+            owner: content.fields.name.fields.owner,
+            collateralToken: (0, utils_2.suiSymbolToSymbol)(dataType.split('<')[2].split(',')[0].trim(), this.consts),
+            indexToken: (0, utils_2.suiSymbolToSymbol)(dataType.split(',')[1].trim(), this.consts),
+            feeToken: (0, utils_2.suiSymbolToSymbol)(dataType.split(',')[3].split('>')[0].trim(), this.consts),
+            indexPrice: (0, utils_2.parseValue)(fields.limited_index_price.fields.price || fields.limited_index_price),
+            collateralPriceThreshold: (0, utils_2.parseValue)(fields.collateral_price_threshold),
+            feeAmount: BigInt(fields.fee),
+            long: dataType.includes('::market::LONG'),
+            orderType,
+            createdAt: (0, utils_2.parseValue)(fields.created_at),
+            v11Order: !fields.limited_index_price.fields.price,
+        };
+        if (orderType === 'OPEN_POSITION') {
+            ret.openOrder = {
+                reserveAmount: BigInt(fields.reserve_amount),
+                collateralAmount: BigInt(fields.collateral),
+                openAmount: BigInt(fields.open_amount),
+            };
+        }
+        else {
+            ret.decreaseOrder = {
+                decreaseAmount: BigInt(fields.decrease_amount),
+                takeProfit: fields.take_profit,
+            };
+        }
+        return ret;
+    }
+    async getPastFee(days = 7) {
+        // TODO: Check with Sentio data
+        const url = `${this.apiEndpoint}/histories/proxy/fee?days=${days}`;
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        return Number.parseFloat(await res.text() || '0');
+    }
+    static calculateVaultReservingFee(vaultInfo, reservingFeeModel, currentTime) {
+        const timeDelta = currentTime - vaultInfo.lastUpdate;
+        const periods = Math.floor(timeDelta / consts_1.SECONDS_PER_EIGHT_HOUR);
+        return vaultInfo.unrealisedReservingFeeAmount
+            + (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18;
+    }
+    static parseCredential(raw, pool) {
+        const stakedAmount = BigInt(raw.data.content.fields.stake);
+        const accRewardPerShare = BigInt(raw.data.content.fields.acc_reward_per_share);
+        return {
+            id: raw.data.objectId,
+            lockUntil: (0, utils_2.parseValue)(raw.data.content.fields.lock_until),
+            amount: stakedAmount,
+            accRewardPerShare,
+            claimable: ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount)
+                / BigInt(1e18),
+        };
+    }
+    static parseStakePool(raw) {
+        const content = raw.data.content.fields;
+        const pool = {
+            id: content.id.id,
+            enabled: content.enabled,
+            lastUpdatedTime: (0, utils_2.parseValue)(content.last_updated_time),
+            stakedAmount: BigInt(content.staked_amount),
+            reward: BigInt(content.reward_vault),
+            startTime: (0, utils_2.parseValue)(content.start_time),
+            endTime: (0, utils_2.parseValue)(content.end_time),
+            rewardRate: BigInt(content.reward_rate),
+            accRewardPerShare: BigInt(content.acc_reward_per_share),
+            lockDuration: (0, utils_2.parseValue)(content.lock_duration),
+        };
+        ZBTCVCDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000));
+        return pool;
+    }
+    static refreshPool(pool, timestamp) {
+        if (timestamp <= pool.lastUpdatedTime || timestamp < pool.startTime) {
+            return;
+        }
+        const applicableEndTime = Math.max(pool.endTime, pool.lastUpdatedTime);
+        const calculationEndTime = Math.min(timestamp, applicableEndTime);
+        if (calculationEndTime > pool.lastUpdatedTime && pool.stakedAmount > BigInt(0) && pool.rewardRate > BigInt(0)) {
+            const timeDiff = BigInt(calculationEndTime - pool.lastUpdatedTime);
+            const rewardAmount = timeDiff * pool.rewardRate;
+            const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount;
+            pool.accRewardPerShare += rewardPerShare;
+        }
+        pool.lastUpdatedTime = calculationEndTime;
+    }
+}
+exports.ZBTCVCDataAPI = ZBTCVCDataAPI;
+//# sourceMappingURL=ZBTCVCDataAPI.cjs.map