@zofai/zo-sdk 0.1.92

package/dist/data.cjs

@@ -0,0 +1,919 @@
+"use strict";
+/* eslint-disable class-methods-use-this */
+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 _DataAPI_instances, _DataAPI_parseMarketInfo, _DataAPI_parseVaultInfo, _DataAPI_parseSymbolInfo, _DataAPI_parseRebaseFeeModel, _DataAPI_parseReservingFeeModel, _DataAPI_parseFundingFeeModel, _DataAPI_parsePositionConfig, _DataAPI_parsePositionInfo, _DataAPI_parseOrderInfo, _DataAPI_calcRebaseFeeRate, _DataAPI_calcReservingFeeRate, _DataAPI_calcFundingFeeRate, _DataAPI_vaultUtilization, _DataAPI_calcAccReservingFeeRate, _DataAPI_calcDeltaSize, _DataAPI_calcAccFundingFeeRate, _DataAPI_calculateSymbolFundingFee, _DataAPI_calculatePositionFundingFee, _DataAPI_calculateVaultReservingFee, _DataAPI_calculatePositionReserveFee, _DataAPI_parseStakePool, _DataAPI_parseCredential, _DataAPI_refreshPool;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataAPI = void 0;
+const utils_1 = require("@mysten/sui/utils");
+const consts_1 = require("./consts/index.cjs");
+const oracle_1 = require("./oracle.cjs");
+const utils_2 = require("./utils.cjs");
+;
+class DataAPI extends oracle_1.OracleAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, connectionURL);
+        _DataAPI_instances.add(this);
+        this.vaultInfoCache = {};
+        this.symbolInfoCache = {};
+        this.marketInfoCache = null;
+        this.positionConfigCache = {};
+        this.rebaseFeeModelCache = null;
+        this.lastUpdate = 0;
+        this.validateCache = () => {
+            super.validateCache();
+            if (this.lastUpdate + 1000 * 60 * 3 < Date.now()) {
+                this.lastUpdate = Date.now();
+                this.vaultInfoCache = {};
+                this.symbolInfoCache = {};
+                this.marketInfoCache = null;
+                this.positionConfigCache = {};
+                this.rebaseFeeModelCache = null;
+            }
+        };
+        this.valuateVaults = (tx) => {
+            const vaultsValuation = tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::create_vaults_valuation`,
+                typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+                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({
+                    // todo
+                    target: `${this.consts.zoCore.upgradedPackage}::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;
+        };
+        this.valuateSymbols = (tx) => {
+            const symbolsValuation = tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::create_symbols_valuation`,
+                typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+                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}::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;
+        };
+        this.valuate = (tx) => {
+            const vaultsValuation = this.valuateVaults(tx);
+            const symbolsValuation = this.valuateSymbols(tx);
+            return {
+                vaultsValuation,
+                symbolsValuation,
+            };
+        };
+        /**
+         * Validates the market valuation by calling the validate_market_valuation Move function
+         * @param tx Transaction object
+         * @returns An object containing handled vaults, total weight, total vaults value, and market value
+         */
+        this.validateMarketValuation = (tx) => {
+            // First, create the valuations using existing methods
+            const vaultsValuation = this.valuateVaults(tx);
+            const symbolsValuation = this.valuateSymbols(tx);
+            // Call the validate_market_valuation Move function
+            const result = tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::validate_market_valuation`,
+                typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    vaultsValuation,
+                    symbolsValuation,
+                ],
+            });
+            return result;
+        };
+        _DataAPI_parseVaultInfo.set(this, async (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 = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parseReservingFeeModel).call(this, 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,
+                },
+            };
+        });
+        _DataAPI_parseSymbolInfo.set(this, async (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 = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parseFundingFeeModel).call(this, fundingFeeModelRaw);
+            return {
+                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,
+                },
+            };
+        });
+        this.fundingFeeRate = async (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 = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcDeltaSize).call(this, symbol, price);
+            const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+            return __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcFundingFeeRate).call(this, model, pnlPerLp, elapsed);
+        };
+        this.rebaseFeeRate = async (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 = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calculateVaultReservingFee).call(this, 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 __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcRebaseFeeRate).call(this, await this.getRebaseFeeModel(), increase, (vaultValue + value) / (totalVaultValue + value), targetRatio);
+        };
+        this.reservingFeeRate = async (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 __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcReservingFeeRate).call(this, vaultInfo.reservingFeeModel, utilization, consts_1.SECONDS_PER_EIGHT_HOUR);
+        };
+        this.getProxiedHistories = async (trader, page, limit) => {
+            const params = new URLSearchParams({ trader });
+            if (page !== undefined) {
+                params.append('page', page.toString());
+            }
+            if (limit !== undefined) {
+                params.append('limit', limit.toString());
+            }
+            const url = `${this.apiEndpoint}/traderEvents?${params}`;
+            const res = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            const response = await res.json();
+            // Handle both old format (array) and new format (object with data)
+            if (Array.isArray(response)) {
+                return response;
+            }
+            return response.data?.histories || [];
+        };
+        this.getProxiedHistoriesWithPagination = async (trader, page = 1, limit = 20, 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,
+                },
+            };
+        };
+        this.getStaked = async (owner) => {
+            const rawCredentials = await this.provider.getOwnedObjects({
+                owner,
+                filter: {
+                    MoveModule: {
+                        package: this.consts.zoStaking.package,
+                        module: 'pool',
+                    },
+                },
+                options: {
+                    showType: true,
+                    showContent: true,
+                },
+            });
+            const pool = await this.getStakePool();
+            const credentials = rawCredentials.data.map((item) => __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parseCredential).call(this, item, pool));
+            return {
+                credentials,
+                amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
+                claimable: credentials.reduce((acc, cur) => acc + cur.claimable, BigInt(0)),
+            };
+        };
+        this.getStakePool = async () => {
+            const raw = await this.provider.getObject({
+                id: this.consts.zoStaking.pool,
+                options: {
+                    showContent: true,
+                },
+            });
+            return __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parseStakePool).call(this, raw);
+        };
+        this.provider = provider || (0, utils_2.createJsonRpcProvider)(network);
+        this.apiEndpoint = apiEndpoint;
+    }
+    async getPastFee(days = 7) {
+        // FIXME: Use 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');
+    }
+    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 = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calculateVaultReservingFee).call(this, 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 = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcDeltaSize).call(this, symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked());
+            const fundingFeeDelta = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calculateSymbolFundingFee).call(this, 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,
+            zlpPrice,
+            zlpSupply: marketInfo.lpSupplyWithDecimals,
+            apr: (fee / value) * 365 / days,
+        };
+    }
+    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 __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parseMarketInfo).call(this, rawData);
+    }
+    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 __classPrivateFieldGet(this, _DataAPI_parseVaultInfo, "f").call(this, rawData);
+    }
+    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 __classPrivateFieldGet(this, _DataAPI_parseSymbolInfo, "f").call(this, 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 __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parsePositionConfig).call(this, rawData);
+    }
+    async getPositionCapInfoList(owner) {
+        const positionCapInfoList = [];
+        let cursor;
+        let hasNextPage = true;
+        while (hasNextPage) {
+            /* eslint-disable-next-line no-await-in-loop -- pagination requires sequential fetches */
+            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);
+            /* eslint-disable-next-line no-await-in-loop -- batch processed in parallel via Promise.all */
+            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 __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parsePositionInfo).call(this, 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);
+    }
+    // find all open positions by positionsParent
+    async getOpenPositions(batchSize = 50, symbol = 'sui') {
+        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 } 
+            /* eslint-disable-next-line no-await-in-loop -- pagination requires sequential fetches */
+            = 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])) {
+            return [];
+        }
+        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*([^,\s]+),\s*([^>\s]+)>/);
+            if (!match)
+                return false;
+            const secondCoin = match[2].trim();
+            return secondCoin === coinModule;
+        });
+        // 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);
+            /* eslint-disable-next-line no-await-in-loop -- batch processed in parallel via Promise.all */
+            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-expect-error -- optional chain on dynamic Move content
+                    if (positionRaw?.data?.content?.fields?.value?.fields?.closed) {
+                        // skip closed positions
+                        return;
+                    }
+                    const positionInfo = await __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parsePositionInfo).call(this, 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) {
+            /* eslint-disable-next-line no-await-in-loop -- pagination requires sequential fetches */
+            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);
+            /* eslint-disable-next-line no-await-in-loop -- batch processed in parallel via Promise.all */
+            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(__classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parseOrderInfo).call(this, 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 getRebaseFeeModel() {
+        this.validateCache();
+        if (this.rebaseFeeModelCache) {
+            return this.rebaseFeeModelCache;
+        }
+        const rawData = await this.provider.getObject({
+            id: this.consts.zoCore.rebaseFeeModel,
+            options: {
+                showContent: true,
+            },
+        });
+        return __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_parseRebaseFeeModel).call(this, rawData);
+    }
+    async getReferralData(referree) {
+        const raw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.referralsParent,
+            name: {
+                type: 'address',
+                value: referree,
+            },
+        });
+        return raw;
+    }
+    async hasReferral(referree) {
+        const raw = await this.getReferralData(referree);
+        return !raw.error;
+    }
+    async getReferreeFromReferrer(referrer) {
+        const url = new URL(`${this.apiEndpoint}/executions`);
+        const data = {
+            projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+            projectSlug: `zo-${this.network}`,
+            projectOwner: 'zo',
+            sqlQuery: {
+                sql: `SELECT referralSender, timestamp from \`Referral_Added\` WHERE  referralReferrer = '${referrer}'`,
+                size: 100,
+            },
+        };
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
+        return (await res.json()).result.rows.map((e) => ({ address: e.referralSender, date: new Date(e.timestamp) }));
+    }
+    async getReferreeDetail(referree) {
+        const url = new URL(`${this.apiEndpoint}/executions`);
+        const data = {
+            projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+            projectSlug: `zo-${this.network}`,
+            projectOwner: 'zo',
+            sqlQuery: {
+                sql: `SELECT sum(volume) as volumeUsd, sum(rebate) as rebateUsd FROM \`User_Interaction\` WHERE  distinct_id = '${referree}' and  rebate != 0`,
+                size: 100,
+            },
+        };
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
+        const row = (await res.json()).result.rows[0];
+        return {
+            volumeUsd: Number.parseFloat(row.volumeUsd),
+            rebateUsd: Number.parseFloat(row.rebateUsd),
+        };
+    }
+    async getReferrerDetail(referrer) {
+        const url = new URL(`${this.apiEndpoint}/executions`);
+        const data = {
+            projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+            projectSlug: `zo-${this.network}`,
+            projectOwner: 'zo',
+            sqlQuery: {
+                sql: `SELECT sum(volume) as volumeUsd, sum(rebate) as rebateUsd FROM \`User_Interaction\` WHERE  referralReceiver = '${referrer}' and  rebate != 0`,
+                size: 100,
+            },
+        };
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
+        const row = (await res.json()).result.rows[0];
+        return {
+            volumeUsd: Number.parseFloat(row.volumeUsd),
+            rebateUsd: Number.parseFloat(row.rebateUsd),
+        };
+    }
+    async getReferralTxs(referrer) {
+        const url = new URL(`${this.apiEndpoint}/executions`);
+        const data = {
+            projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+            projectSlug: `zo-${this.network}`,
+            projectOwner: 'zo',
+            sqlQuery: {
+                sql: `SELECT distinct_id, volume, rebate, timestamp, transaction_hash FROM \`User_Interaction\` WHERE  referralReceiver = '${referrer}' and  rebate != 0 order by timestamp desc`,
+                size: 100,
+            },
+        };
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
+        const { rows } = (await res.json()).result;
+        return rows.map((e) => {
+            return {
+                referree: e.distinct_id,
+                volume: Number.parseFloat(e.volume),
+                rebate: Number.parseFloat(e.rebate),
+                date: new Date(e.timestamp),
+                tx: e.transaction_hash,
+            };
+        });
+    }
+}
+exports.DataAPI = DataAPI;
+_DataAPI_parseVaultInfo = new WeakMap(), _DataAPI_parseSymbolInfo = new WeakMap(), _DataAPI_instances = new WeakSet(), _DataAPI_parseMarketInfo = function _DataAPI_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.ZLP_TOKEN_DECIMALS),
+    };
+}, _DataAPI_parseRebaseFeeModel = function _DataAPI_parseRebaseFeeModel(raw) {
+    const { fields } = raw.data.content;
+    return {
+        base: (0, utils_2.parseValue)(fields.base),
+        multiplier: (0, utils_2.parseValue)(fields.multiplier),
+    };
+}, _DataAPI_parseReservingFeeModel = function _DataAPI_parseReservingFeeModel(raw) {
+    const { fields } = raw.data.content;
+    return {
+        multiplier: (0, utils_2.parseValue)(fields.multiplier),
+    };
+}, _DataAPI_parseFundingFeeModel = function _DataAPI_parseFundingFeeModel(raw) {
+    const { fields } = raw.data.content;
+    return {
+        multiplier: (0, utils_2.parseValue)(fields.multiplier),
+        max: (0, utils_2.parseValue)(fields.max),
+    };
+}, _DataAPI_parsePositionConfig = function _DataAPI_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),
+    };
+}, _DataAPI_parsePositionInfo = async function _DataAPI_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 = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calculatePositionReserveFee).call(this, positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000);
+    positionInfo.fundingFeeValue = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calculatePositionFundingFee).call(this, 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;
+}, _DataAPI_parseOrderInfo = function _DataAPI_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;
+}, _DataAPI_calcRebaseFeeRate = function _DataAPI_calcRebaseFeeRate(model, increase, ratio, targetRatio) {
+    if ((increase && ratio <= targetRatio) || (!increase && ratio >= targetRatio)) {
+        return model.base;
+    }
+    return model.base + model.multiplier * Math.abs(ratio - targetRatio);
+}, _DataAPI_calcReservingFeeRate = function _DataAPI_calcReservingFeeRate(model, utilization, elapsed) {
+    return model.multiplier * utilization * elapsed / consts_1.SECONDS_PER_EIGHT_HOUR;
+}, _DataAPI_calcFundingFeeRate = function _DataAPI_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;
+}, _DataAPI_vaultUtilization = function _DataAPI_vaultUtilization(vault) {
+    const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount;
+    if (supplyAmount === 0) {
+        return 0;
+    }
+    return vault.reservedAmount / supplyAmount;
+}, _DataAPI_calcAccReservingFeeRate = function _DataAPI_calcAccReservingFeeRate(vault, model, timestamp) {
+    if (vault.lastUpdate > 0) {
+        const elapsed = timestamp - vault.lastUpdate;
+        if (elapsed > 0) {
+            const utilization = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_vaultUtilization).call(this, vault);
+            return vault.accReservingRate + __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcReservingFeeRate).call(this, model, utilization, elapsed);
+        }
+    }
+    return vault.accReservingRate;
+}, _DataAPI_calcDeltaSize = function _DataAPI_calcDeltaSize(symbol, price) {
+    const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price;
+    return symbol.long ? symbol.openingSize - latestSize : latestSize - symbol.openingSize;
+}, _DataAPI_calcAccFundingFeeRate = function _DataAPI_calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp) {
+    if (symbol.lastUpdate > 0) {
+        const elapsed = timestamp - symbol.lastUpdate;
+        if (elapsed > 0) {
+            const deltaSize = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcDeltaSize).call(this, symbol, price);
+            const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
+            return symbol.accFundingRate + __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcFundingFeeRate).call(this, model, pnlPerLp, elapsed);
+        }
+    }
+    return symbol.accFundingRate;
+}, _DataAPI_calculateSymbolFundingFee = function _DataAPI_calculateSymbolFundingFee(symbol, model, price, lpSupplyAmount, timestamp) {
+    const accFundingRate = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcAccFundingFeeRate).call(this, symbol, model, price, lpSupplyAmount, timestamp);
+    return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize;
+}, _DataAPI_calculatePositionFundingFee = function _DataAPI_calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp) {
+    const accFundingRate = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcAccFundingFeeRate).call(this, symbol, model, price, lpSupplyAmount, timestamp);
+    return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
+}, _DataAPI_calculateVaultReservingFee = function _DataAPI_calculateVaultReservingFee(vault, model, timestamp) {
+    const accReservingRate = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcAccReservingFeeRate).call(this, vault, model, timestamp);
+    return vault.unrealisedReservingFeeAmount + (accReservingRate - vault.accReservingRate) * vault.reservedAmount;
+}, _DataAPI_calculatePositionReserveFee = function _DataAPI_calculatePositionReserveFee(position, vault, model, timestamp) {
+    const accReservingRate = __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_calcAccReservingFeeRate).call(this, vault, model, timestamp);
+    return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount;
+}, _DataAPI_parseStakePool = function _DataAPI_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),
+        startTime: (0, utils_2.parseValue)(content.start_time),
+        endTime: (0, utils_2.parseValue)(content.end_time),
+        accRewardPerShare: BigInt(content.acc_reward_per_share),
+        lockDuration: (0, utils_2.parseValue)(content.lock_duration),
+    };
+    __classPrivateFieldGet(this, _DataAPI_instances, "m", _DataAPI_refreshPool).call(this, pool, Math.floor(Date.now() / 1000));
+    return pool;
+}, _DataAPI_parseCredential = function _DataAPI_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),
+    };
+}, _DataAPI_refreshPool = function _DataAPI_refreshPool(pool, timestamp) {
+    if (timestamp === pool.lastUpdatedTime || timestamp < pool.startTime) {
+        return;
+    }
+    if (pool.lastUpdatedTime === pool.endTime || pool.stakedAmount === BigInt(0)) {
+        return;
+    }
+    if (timestamp > pool.endTime) {
+        timestamp = pool.endTime;
+    }
+    const rewardAmount = pool.reward * BigInt(timestamp - pool.lastUpdatedTime)
+        / BigInt(pool.endTime - pool.lastUpdatedTime);
+    pool.lastUpdatedTime = timestamp;
+    const rewardPerShare = rewardAmount * BigInt(1e18) / pool.stakedAmount;
+    pool.accRewardPerShare += rewardPerShare;
+};
+//# sourceMappingURL=data.cjs.map