zo-sdk 0.0.4 → 0.0.6

package/dist/data.js

@@ -0,0 +1,753 @@
+"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");
+const oracle_1 = require("./oracle");
+const utils_2 = require("./utils");
+;
+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.package}::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.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;
+        };
+        this.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(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.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;
+        };
+        this.valuate = (tx) => {
+            const vaultsValuation = this.valuateVaults(tx);
+            const symbolsValuation = this.valuateSymbols(tx);
+            return {
+                vaultsValuation,
+                symbolsValuation,
+            };
+        };
+        _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) => {
+            const url = `${this.apiEndpoint}/traderEvents?trader=${trader}`;
+            const res = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            const historyInfoList = await res.json();
+            return historyInfoList;
+        };
+        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 positionCaps = await this.provider.getOwnedObjects({
+            owner,
+            filter: {
+                MoveModule: {
+                    package: this.consts.zoCore.package,
+                    module: 'market',
+                },
+            },
+            options: {
+                showType: true,
+            },
+        });
+        const positionCapInfoList = [];
+        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'),
+                });
+            }
+        }
+        return positionCapInfoList;
+    }
+    async getPositionInfoList(positionCapInfoList, owner) {
+        const positionInfoList = [];
+        await Promise.all(positionCapInfoList.map(async (positionCapInfo) => {
+            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));
+        }));
+        return positionInfoList.sort((a, b) => a.openTimestamp > b.openTimestamp ? 1 : -1);
+    }
+    async getOrderCapInfoList(owner) {
+        const orderCaps = await this.provider.getOwnedObjects({
+            owner,
+            filter: {
+                MoveModule: {
+                    package: this.consts.zoCore.package,
+                    module: 'market',
+                },
+            },
+            options: {
+                showType: true,
+                showContent: true,
+            },
+        });
+        const orderCapInfoList = [];
+        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,
+                });
+            }
+        }
+        return orderCapInfoList;
+    }
+    async getOrderInfoList(orderCapInfoList, owner) {
+        const orderInfoList = [];
+        await Promise.all(orderCapInfoList.map(async (orderCapInfo) => {
+            const orderRaw = await this.provider.getDynamicFieldObject({
+                parentId: this.consts.zoCore.ordersParent,
+                name: {
+                    type: `${this.consts.zoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.zoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins.sui.module}>`,
+                    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));
+        }));
+        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 - symbol.accFundingRate) * 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 - vault.accReservingRate) * 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.js.map