zo-sdk 0.0.50 → 0.1.0

package/dist/implementations/ZLPDataAPI.mjs

@@ -0,0 +1,720 @@
+/**
+ * ZLP DataAPI implementation
+ * Implements ZLP-specific data access methods
+ */
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { LPToken, ZLP_TOKEN_DECIMALS, SECONDS_PER_EIGHT_HOUR } from "../consts/index.mjs";
+import { BaseDataAPI } from "../abstract/index.mjs";
+import { parseSymbolKey, parseValue, suiSymbolToSymbol, joinSymbol } from "../utils.mjs";
+export class ZLPDataAPI extends BaseDataAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP);
+    }
+    getStaked(owner) {
+        throw new Error('Method not implemented.');
+    }
+    getStakePool() {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Creates vaults valuation for ZLP
+     */
+    valuateVaults(tx) {
+        const vaultsValuation = tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::create_vaults_valuation`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+            arguments: [
+                tx.object(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.package}::market::valuate_vault`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    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 ZLP
+     */
+    valuateSymbols(tx) {
+        const symbolsValuation = tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::create_symbols_valuation`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+            ],
+        });
+        for (const key of Object.keys(this.consts.zoCore.symbols)) {
+            const [direction, token] = parseSymbolKey(key);
+            const symbol = this.consts.zoCore.symbols[key];
+            tx.moveCall({
+                target: `${this.consts.zoCore.package}::market::valuate_symbol`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    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 ZLP market
+     */
+    async valuateMarket() {
+        const marketInfo = await this.getMarketInfo();
+        const days = 7;
+        const fee = await this.getPastFee(days);
+        let zlpPrice = 0;
+        let value = 0;
+        const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
+            const vaultInfo = await this.getVaultInfo(vault);
+            const reservingFeeDelta = this.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] = parseSymbolKey(symbol);
+            const symbolInfo = await this.getSymbolInfo(tokenId, direction === 'long');
+            const deltaSize = this.calcDeltaSize(symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked());
+            const fundingFeeDelta = this.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);
+        zlpPrice = value / marketInfo.lpSupplyWithDecimals;
+        return {
+            marketCap: value,
+            price: zlpPrice,
+            supply: marketInfo.lpSupplyWithDecimals,
+            apr: (fee / value) * 365 / days,
+        };
+    }
+    /**
+     * Gets ZLP 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 this.parseMarketInfo(rawData);
+    }
+    /**
+     * Gets ZLP 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 ZLP symbol information
+     */
+    async getSymbolInfo(indexToken, long) {
+        this.validateCache();
+        const symbol = 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 = 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 this.parsePositionConfig(rawData);
+    }
+    async getPositionCapInfoList(owner) {
+        const positionCapInfoList = [];
+        let cursor = undefined;
+        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(batchSize = 50, symbol = 'sui') {
+        let positionDynamicFields = [];
+        let _continue = true;
+        let cursor = undefined;
+        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;
+        }
+        // Filter by symbol if provided
+        if (symbol && this.consts.coins[symbol]) {
+            const coinModule = symbol === 'sui' ? '0x2::sui::SUI' : this.consts.coins[symbol].module;
+            positionDynamicFields = positionDynamicFields.filter(field => {
+                // Extract the second coin module from PositionName<coin1, coin2, direction>
+                const typeStr = field.name?.type;
+                if (!typeStr)
+                    return false;
+                const match = typeStr.match(/PositionName<([^,]+),\s*([^,]+),\s*([^>]+)>/);
+                if (!match)
+                    return false;
+                const secondCoin = match[2].trim();
+                return secondCoin === coinModule;
+            });
+        }
+        else {
+            return [];
+        }
+        // then we query by dynamic field names and order by time
+        const positionInfoList = [];
+        // Process in batches of 50 (or specified batchSize)
+        for (let i = 0; i < positionDynamicFields.length; i += batchSize) {
+            const batch = positionDynamicFields.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (positionDynamicField) => {
+                const positionRaw = await this.provider.getDynamicFieldObject({
+                    parentId: this.consts.zoCore.positionsParent,
+                    name: positionDynamicField.name,
+                });
+                if (positionRaw?.data?.content) {
+                    // @ts-ignore
+                    if (positionRaw?.data?.content?.fields?.value?.fields?.closed) {
+                        // skip closed positions
+                        return;
+                    }
+                    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 = undefined;
+        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 ZLP
+     */
+    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 this.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 = SECONDS_PER_EIGHT_HOUR;
+        const deltaSize = this.calcDeltaSize(symbol, price);
+        const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+        return this.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 = this.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 this.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 this.calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, 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);
+        }
+        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
+    calcFundingFeeRate(model, pnlPerRate, elapsed) {
+        const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max);
+        const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR;
+        return pnlPerRate >= 0 ? -secondsRate : secondsRate;
+    }
+    calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp) {
+        if (symbol.lastUpdate > 0) {
+            const elapsed = timestamp - symbol.lastUpdate;
+            if (elapsed > 0) {
+                const deltaSize = this.calcDeltaSize(symbol, price);
+                const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+                return symbol.accFundingRate + this.calcFundingFeeRate(model, pnlPerLp, elapsed);
+            }
+        }
+        return symbol.accFundingRate;
+    }
+    calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp) {
+        const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp);
+        return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize;
+    }
+    calculatePositionReserveFee(position, vault, model, timestamp) {
+        const accReservingRate = this.calcAccReservingFeeRate(vault, model, timestamp);
+        return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount;
+    }
+    calcAccReservingFeeRate(vault, model, timestamp) {
+        if (vault.lastUpdate > 0) {
+            const elapsed = timestamp - vault.lastUpdate;
+            if (elapsed > 0) {
+                const utilization = this.vaultUtilization(vault);
+                return vault.accReservingRate + this.calcReservingFeeRate(model, utilization, elapsed);
+            }
+        }
+        return vault.accReservingRate;
+    }
+    calcRebaseFeeRate(model, increase, ratio, targetRatio) {
+        if ((increase && ratio <= targetRatio) || (!increase && ratio >= targetRatio)) {
+            return model.base;
+        }
+        return model.base + model.multiplier * Math.abs(ratio - targetRatio);
+    }
+    vaultUtilization(vault) {
+        const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount;
+        if (supplyAmount === 0) {
+            return 0;
+        }
+        return vault.reservedAmount / supplyAmount;
+    }
+    calcReservingFeeRate(model, utilization, elapsed) {
+        return model.multiplier * utilization * elapsed / SECONDS_PER_EIGHT_HOUR;
+    }
+    calcDeltaSize(symbol, price) {
+        const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price;
+        return symbol.long ? symbol.openingSize - latestSize : latestSize - symbol.openingSize;
+    }
+    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 ** ZLP_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 = this.parseReservingFeeModel(reservingFeeModelRaw);
+        return {
+            liquidity: parseValue(vaultFields.liquidity),
+            reservedAmount: parseValue(vaultFields.reserved_amount),
+            unrealisedReservingFeeAmount: parseValue(vaultFields.unrealised_reserving_fee_amount),
+            accReservingRate: parseValue(vaultFields.acc_reserving_rate),
+            enabled: vaultFields.enabled,
+            weight: parseValue(vaultFields.weight),
+            lastUpdate: parseValue(vaultFields.last_update),
+            reservingFeeModel,
+            priceConfig: {
+                maxInterval: parseValue(vaultFields.price_config.fields.max_interval),
+                maxConfidence: parseValue(vaultFields.price_config.fields.max_confidence),
+                precision: parseValue(vaultFields.price_config.fields.precision),
+                feeder: vaultFields.price_config.fields.feeder,
+            },
+        };
+    }
+    async parseSymbolInfo(raw, long) {
+        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 = this.parseFundingFeeModel(fundingFeeModelRaw);
+        return {
+            openingSize: parseValue(fields.opening_size),
+            openingAmount: parseValue(fields.opening_amount),
+            accFundingRate: parseValue(fields.acc_funding_rate),
+            realisedPnl: parseValue(fields.realised_pnl),
+            unrealisedFundingFeeValue: parseValue(fields.unrealised_funding_fee_value),
+            openEnabled: fields.open_enabled,
+            liquidateEnabled: fields.liquidate_enabled,
+            decreaseEnabled: fields.decrease_enabled,
+            lastUpdate: parseValue(fields.last_update),
+            fundingFeeModel,
+            long,
+            priceConfig: {
+                maxInterval: parseValue(fields.price_config.fields.max_interval),
+                maxConfidence: parseValue(fields.price_config.fields.max_confidence),
+                precision: parseValue(fields.price_config.fields.precision),
+                feeder: fields.price_config.fields.feeder,
+            },
+        };
+    }
+    parsePositionConfig(raw) {
+        const positionConfigFields = raw.data.content.fields.inner.fields;
+        return {
+            decreaseFeeBps: parseValue(positionConfigFields.decrease_fee_bps),
+            liquidationBonus: parseValue(positionConfigFields.liquidation_bonus),
+            liquidationThreshold: parseValue(positionConfigFields.liquidation_threshold),
+            maxLeverage: parseValue(positionConfigFields.max_leverage),
+            minHoldingDuration: parseValue(positionConfigFields.min_holding_duration),
+            openFeeBps: parseValue(positionConfigFields.open_fee_bps),
+            maxReservedMultiplier: parseValue(positionConfigFields.max_reserved_multiplier),
+            minCollateralValue: parseValue(positionConfigFields.min_collateral_value),
+        };
+    }
+    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: suiSymbolToSymbol(dataType.split('<')[1].split(',')[0].trim(), this.consts),
+            indexToken: suiSymbolToSymbol(dataType.split(',')[1].trim(), this.consts),
+            collateralAmount: parseValue(positionFields.collateral),
+            positionAmount: parseValue(positionFields.position_amount),
+            reservedAmount: parseValue(positionFields.reserved),
+            positionSize: parseValue(positionFields.position_size),
+            lastFundingRate: parseValue(positionFields.last_funding_rate),
+            lastReservingRate: parseValue(positionFields.last_reserving_rate),
+            reservingFeeAmount: parseValue(positionFields.reserving_fee_amount),
+            fundingFeeValue: parseValue(positionFields.funding_fee_value),
+            closed: positionFields.closed,
+            openTimestamp: parseValue(positionFields.open_timestamp),
+        };
+        positionInfo.reservingFeeAmount = this.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000);
+        positionInfo.fundingFeeValue = this.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;
+    }
+    calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp) {
+        const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp);
+        return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
+    }
+    parseRebaseFeeModel(raw) {
+        const { fields } = raw.data.content;
+        return {
+            base: parseValue(fields.base),
+            multiplier: parseValue(fields.multiplier),
+        };
+    }
+    parseReservingFeeModel(raw) {
+        const content = raw.data.content.fields;
+        return {
+            multiplier: parseValue(content.multiplier),
+        };
+    }
+    parseFundingFeeModel(raw) {
+        const content = raw.data.content.fields;
+        return {
+            multiplier: parseValue(content.multiplier),
+            max: 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: suiSymbolToSymbol(dataType.split('<')[2].split(',')[0].trim(), this.consts),
+            indexToken: suiSymbolToSymbol(dataType.split(',')[1].trim(), this.consts),
+            feeToken: suiSymbolToSymbol(dataType.split(',')[3].split('>')[0].trim(), this.consts),
+            indexPrice: parseValue(fields.limited_index_price.fields.price || fields.limited_index_price),
+            collateralPriceThreshold: parseValue(fields.collateral_price_threshold),
+            feeAmount: BigInt(fields.fee),
+            long: dataType.includes('::market::LONG'),
+            orderType,
+            createdAt: 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');
+    }
+    calculateVaultReservingFee(vaultInfo, reservingFeeModel, currentTime) {
+        const timeDelta = currentTime - vaultInfo.lastUpdate;
+        const periods = Math.floor(timeDelta / SECONDS_PER_EIGHT_HOUR);
+        return vaultInfo.unrealisedReservingFeeAmount +
+            (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18;
+    }
+}
+//# sourceMappingURL=ZLPDataAPI.mjs.map