@kehtus/proportion-sdk 0.1.0

package/dist/account.d.ts

@@ -0,0 +1,55 @@
+import type { Address, Chain, Hash, PublicClient, WalletClient } from "viem";
+import { AccountState, type AccountDetails } from "./types.js";
+type RawCheckpoint = {
+    accountValue: bigint | number;
+    timestamp: bigint | number;
+    profitable: boolean;
+};
+export declare function normalizeCheckpoints(rawCheckpoints: readonly RawCheckpoint[], totalCheckpoints: number, checkpointIndex: number): Array<{
+    accountValue: bigint;
+    timestamp: number;
+    profitable: boolean;
+}>;
+export declare class AccountModule {
+    private publicClient;
+    private walletClient;
+    private chain;
+    constructor(publicClient: PublicClient, walletClient: WalletClient | undefined, chain: Chain);
+    getDetails(account: Address): Promise<AccountDetails>;
+    getState(account: Address): Promise<AccountState>;
+    getTrailingFloor(account: Address): Promise<bigint>;
+    getDailyFloor(account: Address): Promise<bigint>;
+    canWithdrawProfit(account: Address): Promise<boolean>;
+    isSubscriptionActive(account: Address): Promise<boolean>;
+    getCheckpoints(account: Address): Promise<Array<{
+        accountValue: bigint;
+        timestamp: number;
+        profitable: boolean;
+    }>>;
+    getPendingWithdrawal(account: Address): Promise<{
+        profit: bigint;
+        requestedAt: number;
+    }>;
+    getAccountConfig(account: Address): Promise<{
+        usdc: Address;
+        vault: Address;
+        subscriptionFeeMultiplier: number;
+    }>;
+    private requireWallet;
+    private write;
+    setApiWallet(account: Address, wallet: Address): Promise<Hash>;
+    requestWithdrawProfit(account: Address): Promise<Hash>;
+    cancelSubscription(account: Address): Promise<Hash>;
+    cancelStuckWithdrawal(account: Address): Promise<Hash>;
+    checkpoint(account: Address): Promise<Hash>;
+    initiateClose(account: Address): Promise<Hash>;
+    initiateCloseForPerp(account: Address, perpIndex: number): Promise<Hash>;
+    initiateCloseAdmin(account: Address): Promise<Hash>;
+    closeAndReturn(account: Address): Promise<Hash>;
+    finalizeReturn(account: Address): Promise<Hash>;
+    claimWithdrawal(account: Address): Promise<Hash>;
+    claimSubscriptionFee(account: Address): Promise<Hash>;
+    rescueStuckFunds(account: Address): Promise<Hash>;
+    setRiskEngineWallet(account: Address, wallet: Address): Promise<Hash>;
+}
+export {};

package/dist/account.js

@@ -0,0 +1,290 @@
+import { fundedAccountAbi } from "./abi/fundedAccount.js";
+export function normalizeCheckpoints(rawCheckpoints, totalCheckpoints, checkpointIndex) {
+    if (totalCheckpoints <= 0)
+        return [];
+    const count = Math.min(totalCheckpoints, rawCheckpoints.length);
+    const start = count === rawCheckpoints.length ? checkpointIndex % count : 0;
+    return Array.from({ length: count }, (_, offset) => rawCheckpoints[(start + offset) % count]).map((cp) => ({
+        accountValue: BigInt(cp.accountValue),
+        timestamp: Number(cp.timestamp),
+        profitable: cp.profitable,
+    }));
+}
+export class AccountModule {
+    publicClient;
+    walletClient;
+    chain;
+    constructor(publicClient, walletClient, chain) {
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.chain = chain;
+    }
+    // ── READS ───────────────────────────────────────────
+    async getDetails(account) {
+        const contract = { address: account, abi: fundedAccountAbi };
+        const results = await this.publicClient.multicall({
+            contracts: [
+                { ...contract, functionName: "state" },
+                { ...contract, functionName: "owner" },
+                { ...contract, functionName: "builder" },
+                { ...contract, functionName: "accountSize" },
+                { ...contract, functionName: "drawdownBps" },
+                { ...contract, functionName: "dailyDrawdownEnabled" },
+                { ...contract, functionName: "subscriptionFeeMultiplier" },
+                { ...contract, functionName: "highWaterMark" },
+                { ...contract, functionName: "dayStartValue" },
+                { ...contract, functionName: "activatedAt" },
+                { ...contract, functionName: "subscriptionPaidUntil" },
+                { ...contract, functionName: "subscriptionCancelled" },
+                { ...contract, functionName: "pendingSubscriptionFee" },
+                { ...contract, functionName: "apiWallet" },
+                { ...contract, functionName: "riskEngineWallet" },
+                { ...contract, functionName: "builderRiskEngineWallet" },
+                { ...contract, functionName: "checkpointIndex" },
+                { ...contract, functionName: "profitableDaysCount" },
+                { ...contract, functionName: "totalCheckpoints" },
+                { ...contract, functionName: "lastCheckpointDay" },
+                { ...contract, functionName: "closingInitiatedAt" },
+                { ...contract, functionName: "returnInitiatedAt" },
+                { ...contract, functionName: "pendingWithdrawal" },
+                { ...contract, functionName: "getTrailingFloor" },
+                { ...contract, functionName: "getDailyFloor" },
+                { ...contract, functionName: "getSubscriptionFee" },
+                { ...contract, functionName: "isSubscriptionActive" },
+                { ...contract, functionName: "canWithdrawProfit" },
+                { ...contract, functionName: "getAllCheckpoints" },
+            ],
+        });
+        const checkpointIndex = results[16].result;
+        const totalCp = results[18].result;
+        const [profit, requestedAt] = results[22].result;
+        const rawCheckpoints = results[28].result;
+        const checkpoints = normalizeCheckpoints(rawCheckpoints, totalCp, checkpointIndex);
+        return {
+            address: account,
+            state: results[0].result,
+            owner: results[1].result,
+            builder: results[2].result,
+            accountSize: results[3].result,
+            drawdownBps: results[4].result,
+            dailyDrawdownEnabled: results[5].result,
+            subscriptionFeeMultiplier: results[6].result,
+            highWaterMark: results[7].result,
+            dayStartValue: results[8].result,
+            activatedAt: results[9].result,
+            subscriptionPaidUntil: results[10].result,
+            subscriptionCancelled: results[11].result,
+            pendingSubscriptionFee: results[12].result,
+            apiWallet: results[13].result,
+            riskEngineWallet: results[14].result,
+            builderRiskEngineWallet: results[15].result,
+            checkpointIndex,
+            profitableDaysCount: results[17].result,
+            totalCheckpoints: totalCp,
+            lastCheckpointDay: results[19].result,
+            closingInitiatedAt: Number(results[20].result),
+            returnInitiatedAt: Number(results[21].result),
+            pendingWithdrawal: { profit, requestedAt: Number(requestedAt) },
+            trailingFloor: results[23].result,
+            dailyFloor: results[24].result,
+            subscriptionFee: results[25].result,
+            isSubscriptionActive: results[26].result,
+            canWithdrawProfit: results[27].result,
+            checkpoints,
+        };
+    }
+    async getState(account) {
+        const raw = await this.publicClient.readContract({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "state",
+        });
+        return raw;
+    }
+    async getTrailingFloor(account) {
+        return this.publicClient.readContract({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "getTrailingFloor",
+        });
+    }
+    async getDailyFloor(account) {
+        return this.publicClient.readContract({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "getDailyFloor",
+        });
+    }
+    async canWithdrawProfit(account) {
+        return this.publicClient.readContract({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "canWithdrawProfit",
+        });
+    }
+    async isSubscriptionActive(account) {
+        return this.publicClient.readContract({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "isSubscriptionActive",
+        });
+    }
+    async getCheckpoints(account) {
+        const [all, total, checkpointIndex] = await Promise.all([
+            this.publicClient.readContract({
+                address: account,
+                abi: fundedAccountAbi,
+                functionName: "getAllCheckpoints",
+            }),
+            this.publicClient.readContract({
+                address: account,
+                abi: fundedAccountAbi,
+                functionName: "totalCheckpoints",
+            }),
+            this.publicClient.readContract({
+                address: account,
+                abi: fundedAccountAbi,
+                functionName: "checkpointIndex",
+            }),
+        ]);
+        return normalizeCheckpoints(all, Number(total), Number(checkpointIndex));
+    }
+    async getPendingWithdrawal(account) {
+        const result = await this.publicClient.readContract({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "pendingWithdrawal",
+        });
+        return { profit: result[0], requestedAt: Number(result[1]) };
+    }
+    async getAccountConfig(account) {
+        const contract = { address: account, abi: fundedAccountAbi };
+        const results = await this.publicClient.multicall({
+            contracts: [
+                { ...contract, functionName: "usdc" },
+                { ...contract, functionName: "vault" },
+                { ...contract, functionName: "subscriptionFeeMultiplier" },
+            ],
+        });
+        return {
+            usdc: results[0].result,
+            vault: results[1].result,
+            subscriptionFeeMultiplier: results[2].result,
+        };
+    }
+    // ── WRITES ──────────────────────────────────────────
+    requireWallet() {
+        if (!this.walletClient)
+            throw new Error("WalletClient required for write operations");
+        return this.walletClient;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async write(params) {
+        const wallet = this.requireWallet();
+        return wallet.writeContract({ chain: this.chain, ...params });
+    }
+    // ── OWNER WRITES ────────────────────────────────────
+    async setApiWallet(account, wallet) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "setApiWallet",
+            args: [wallet],
+        });
+    }
+    async requestWithdrawProfit(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "requestWithdrawProfit",
+        });
+    }
+    async cancelSubscription(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "cancelSubscription",
+        });
+    }
+    async cancelStuckWithdrawal(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "cancelStuckWithdrawal",
+        });
+    }
+    // ── PERMISSIONLESS WRITES ───────────────────────────
+    async checkpoint(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "checkpoint",
+        });
+    }
+    async initiateClose(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "initiateClose",
+        });
+    }
+    async initiateCloseForPerp(account, perpIndex) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "initiateClose",
+            args: [perpIndex],
+        });
+    }
+    async initiateCloseAdmin(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "initiateCloseAdmin",
+        });
+    }
+    async closeAndReturn(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "closeAndReturn",
+        });
+    }
+    async finalizeReturn(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "finalizeReturn",
+        });
+    }
+    async claimWithdrawal(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "claimWithdrawal",
+        });
+    }
+    async claimSubscriptionFee(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "claimSubscriptionFee",
+        });
+    }
+    async rescueStuckFunds(account) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "rescueStuckFunds",
+        });
+    }
+    // ── RISK ENGINE WRITES ──────────────────────────────
+    async setRiskEngineWallet(account, wallet) {
+        return this.write({
+            address: account,
+            abi: fundedAccountAbi,
+            functionName: "setRiskEngineWallet",
+            args: [wallet],
+        });
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,48 @@
+export declare const CHAIN_ID = 999;
+export declare const hyperEvm: {
+    readonly id: 999;
+    readonly name: "HyperEVM";
+    readonly nativeCurrency: {
+        readonly name: "HYPE";
+        readonly symbol: "HYPE";
+        readonly decimals: 18;
+    };
+    readonly rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
+        };
+    };
+    readonly contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        };
+    };
+};
+export declare const ADDRESSES: {
+    readonly MAIN_VAULT: "0x4478888dA8d22E275344C1A24BDEbcf2bfE2dc45";
+    readonly FACTORY: "0xb7cE604a000CCFCe7c7DAfFBaefD26c33C86CE7A";
+    readonly USDC: "0xb88339CB7199b77E23DB6E890353E22632Ba630f";
+};
+export declare const BPS = 10000n;
+export declare const MIN_DRAWDOWN_BPS = 500;
+export declare const MAX_DRAWDOWN_BPS = 2500;
+export declare const DAILY_DD_DISCOUNT_BPS = 2000n;
+export declare const PROTOCOL_FEE_BPS = 1000n;
+export declare const OWNER_PROFIT_BPS = 8000n;
+export declare const PROTOCOL_PROFIT_BPS = 700n;
+export declare const BUILDER_LEVERAGE = 10n;
+export declare const MAX_UTILIZATION_BPS = 8000n;
+export declare const MAX_SINGLE_ACCOUNT_BPS = 1000n;
+export declare const HYPE_FOR_GAS = 1000000000000000n;
+export declare const USDC_DECIMALS = 6;
+export declare const ACCOUNT_VALUE_DECIMALS = 8;
+export declare const DECIMALS_MULTIPLIER = 100n;
+export declare const SUBSCRIPTION_PERIOD: number;
+export declare const WITHDRAWAL_TIMEOUT: number;
+export declare const BRIDGE_DELAY = 30;
+export declare const CLOSING_TIMEOUT: number;
+export declare const CHECKPOINT_INTERVAL = 86400;
+export declare const TRADING_DAYS_REQUIRED = 7;
+export declare const PROFITABLE_DAYS_REQUIRED = 3;
+export declare const MIN_PROFIT_BPS = 50;
+export declare const MAX_LEVERAGE = 5;

package/dist/constants.js

@@ -0,0 +1,42 @@
+export const CHAIN_ID = 999;
+export const hyperEvm = {
+    id: 999,
+    name: "HyperEVM",
+    nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
+    rpcUrls: { default: { http: ["https://rpc.hyperliquid.xyz/evm"] } },
+    contracts: {
+        multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" },
+    },
+};
+export const ADDRESSES = {
+    MAIN_VAULT: "0x4478888dA8d22E275344C1A24BDEbcf2bfE2dc45",
+    FACTORY: "0xb7cE604a000CCFCe7c7DAfFBaefD26c33C86CE7A",
+    USDC: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+};
+// BPS
+export const BPS = 10000n;
+export const MIN_DRAWDOWN_BPS = 500;
+export const MAX_DRAWDOWN_BPS = 2500;
+export const DAILY_DD_DISCOUNT_BPS = 2000n;
+export const PROTOCOL_FEE_BPS = 1000n;
+export const OWNER_PROFIT_BPS = 8000n;
+export const PROTOCOL_PROFIT_BPS = 700n;
+export const BUILDER_LEVERAGE = 10n;
+export const MAX_UTILIZATION_BPS = 8000n;
+export const MAX_SINGLE_ACCOUNT_BPS = 1000n;
+export const HYPE_FOR_GAS = 1000000000000000n; // 0.001 ether
+// Decimals
+export const USDC_DECIMALS = 6;
+export const ACCOUNT_VALUE_DECIMALS = 8;
+export const DECIMALS_MULTIPLIER = 100n; // 6→8 dec
+// Time (seconds)
+export const SUBSCRIPTION_PERIOD = 30 * 86400;
+export const WITHDRAWAL_TIMEOUT = 7 * 86400;
+export const BRIDGE_DELAY = 30;
+export const CLOSING_TIMEOUT = 3 * 86400;
+export const CHECKPOINT_INTERVAL = 86400;
+// Trading rules
+export const TRADING_DAYS_REQUIRED = 7;
+export const PROFITABLE_DAYS_REQUIRED = 3;
+export const MIN_PROFIT_BPS = 50;
+export const MAX_LEVERAGE = 5;

package/dist/factory.d.ts

@@ -0,0 +1,23 @@
+import type { Address, PublicClient } from "viem";
+export declare class FactoryModule {
+    private publicClient;
+    private factoryAddress;
+    constructor(publicClient: PublicClient, factoryAddress: Address);
+    private isOutOfBoundsError;
+    private accountExistsAt;
+    predictAddress(owner: Address, builder: Address): Promise<Address>;
+    getAccountAt(index: bigint): Promise<Address>;
+    getAccountIndex(account: Address): Promise<bigint>;
+    hasAccount(account: Address): Promise<boolean>;
+    findAccountIndex(account: Address): Promise<bigint | null>;
+    getTraderBuilderNonce(owner: Address, builder: Address): Promise<bigint>;
+    getAccountsCount(maxScan?: bigint): Promise<bigint>;
+    getAccounts(offset: bigint, limit: bigint): Promise<Address[]>;
+    getConfig(): Promise<{
+        implementation: Address;
+        owner: Address;
+        pendingOwner: Address;
+        usdc: Address;
+        vault: Address;
+    }>;
+}

package/dist/factory.js

@@ -0,0 +1,139 @@
+import { factoryAbi } from "./abi/factory.js";
+export class FactoryModule {
+    publicClient;
+    factoryAddress;
+    constructor(publicClient, factoryAddress) {
+        this.publicClient = publicClient;
+        this.factoryAddress = factoryAddress;
+    }
+    isOutOfBoundsError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return /out of bounds|execution reverted|returned no data|position out of bounds/i.test(message);
+    }
+    async accountExistsAt(index) {
+        try {
+            await this.getAccountAt(index);
+            return true;
+        }
+        catch (error) {
+            if (this.isOutOfBoundsError(error))
+                return false;
+            throw error;
+        }
+    }
+    async predictAddress(owner, builder) {
+        return this.publicClient.readContract({
+            address: this.factoryAddress,
+            abi: factoryAbi,
+            functionName: "predictFundedAccountAddress",
+            args: [owner, builder],
+        });
+    }
+    async getAccountAt(index) {
+        return this.publicClient.readContract({
+            address: this.factoryAddress,
+            abi: factoryAbi,
+            functionName: "allAccounts",
+            args: [index],
+        });
+    }
+    async getAccountIndex(account) {
+        return this.publicClient.readContract({
+            address: this.factoryAddress,
+            abi: factoryAbi,
+            functionName: "allAccountsIndex",
+            args: [account],
+        });
+    }
+    async hasAccount(account) {
+        try {
+            const index = await this.getAccountIndex(account);
+            const candidate = await this.getAccountAt(index);
+            return candidate.toLowerCase() === account.toLowerCase();
+        }
+        catch {
+            return false;
+        }
+    }
+    async findAccountIndex(account) {
+        const index = await this.getAccountIndex(account);
+        const candidate = await this.getAccountAt(index).catch(() => null);
+        if (!candidate || candidate.toLowerCase() !== account.toLowerCase())
+            return null;
+        return index;
+    }
+    async getTraderBuilderNonce(owner, builder) {
+        return this.publicClient.readContract({
+            address: this.factoryAddress,
+            abi: factoryAbi,
+            functionName: "traderBuilderNonce",
+            args: [owner, builder],
+        });
+    }
+    async getAccountsCount(maxScan = 10000n) {
+        if (!(await this.accountExistsAt(0n)))
+            return 0n;
+        let lo = 0n;
+        let hi = 1n;
+        while (hi < maxScan && await this.accountExistsAt(hi)) {
+            lo = hi;
+            hi *= 2n;
+        }
+        if (hi >= maxScan && await this.accountExistsAt(hi)) {
+            throw new Error(`Factory account count exceeds scan limit ${maxScan}`);
+        }
+        while (lo + 1n < hi) {
+            const mid = (lo + hi) / 2n;
+            if (await this.accountExistsAt(mid)) {
+                lo = mid;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        return lo + 1n;
+    }
+    async getAccounts(offset, limit) {
+        if (limit <= 0n)
+            return [];
+        const contracts = [];
+        for (let i = 0n; i < limit; i++) {
+            contracts.push({
+                address: this.factoryAddress,
+                abi: factoryAbi,
+                functionName: "allAccounts",
+                args: [offset + i],
+            });
+        }
+        const results = await this.publicClient.multicall({
+            contracts,
+            allowFailure: true,
+        });
+        const accounts = [];
+        for (const result of results) {
+            if (result.status !== "success")
+                break;
+            accounts.push(result.result);
+        }
+        return accounts;
+    }
+    async getConfig() {
+        const contract = { address: this.factoryAddress, abi: factoryAbi };
+        const results = await this.publicClient.multicall({
+            contracts: [
+                { ...contract, functionName: "implementation" },
+                { ...contract, functionName: "owner" },
+                { ...contract, functionName: "pendingOwner" },
+                { ...contract, functionName: "usdc" },
+                { ...contract, functionName: "vault" },
+            ],
+        });
+        return {
+            implementation: results[0].result,
+            owner: results[1].result,
+            pendingOwner: results[2].result,
+            usdc: results[3].result,
+            vault: results[4].result,
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { ProportionSDK } from "./sdk.js";
+export { VaultModule } from "./vault.js";
+export { AccountModule } from "./account.js";
+export { FactoryModule } from "./factory.js";
+export { IndexerModule } from "./indexer.js";
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./utils.js";
+export { mainVaultAbi } from "./abi/mainVault.js";
+export { fundedAccountAbi } from "./abi/fundedAccount.js";
+export { factoryAbi } from "./abi/factory.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+// Main
+export { ProportionSDK } from "./sdk.js";
+// Modules
+export { VaultModule } from "./vault.js";
+export { AccountModule } from "./account.js";
+export { FactoryModule } from "./factory.js";
+export { IndexerModule } from "./indexer.js";
+// Core
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./utils.js";
+export { mainVaultAbi } from "./abi/mainVault.js";
+export { fundedAccountAbi } from "./abi/fundedAccount.js";
+export { factoryAbi } from "./abi/factory.js";

package/dist/indexer.d.ts

@@ -0,0 +1,57 @@
+import type { GqlAccount, GqlAccountEvent, GqlAllowedPerp, GqlBuilder, GqlCheckpoint, GqlConfigChange, GqlFactoryConfig, GqlDelegate, GqlDeposit, GqlLiquidityProviderDayData, GqlLP, GqlMainVaultConfig, GqlProfitWithdrawal, GqlProtocolConfig, GqlSubscriptionPayment, GqlVault, GqlVaultDayData, GqlWithdrawal, ConfigChangeFilters, IndexerAccountStateLabel, Pagination, Unsubscribe, WebSocketConstructor } from "./types.js";
+export declare class IndexerModule {
+    private graphqlUrl;
+    private graphqlWsUrl?;
+    private transports;
+    private ws;
+    private wsId;
+    private subscriptions;
+    private reconnectTimer;
+    private reconnectDelay;
+    constructor(graphqlUrl: string, graphqlWsUrl?: string | undefined, transports?: {
+        fetchFn?: typeof fetch;
+        webSocketCtor?: WebSocketConstructor;
+    });
+    private static readonly PAGE_SIZE;
+    private static readonly VAULT_FIELDS;
+    private static readonly ACCOUNT_FIELDS;
+    private static readonly MAIN_VAULT_CONFIG_FIELDS;
+    private static readonly FACTORY_CONFIG_FIELDS;
+    private static readonly CONFIG_CHANGE_FIELDS;
+    private static readonly VAULT_DAY_DATA_FIELDS;
+    private static readonly LP_DAY_DATA_FIELDS;
+    private resolveVaultAddress;
+    private resolveFactoryAddress;
+    private query;
+    getVault(vaultAddress?: string): Promise<GqlVault | null>;
+    getLP(address: string): Promise<GqlLP | null>;
+    getLPDeposits(address: string, p?: Pagination): Promise<GqlDeposit[]>;
+    getLPWithdrawals(address: string, p?: Pagination): Promise<GqlWithdrawal[]>;
+    getBuilder(address: string, vaultAddress?: string): Promise<GqlBuilder | null>;
+    getDelegates(builder: string, vaultAddress?: string): Promise<GqlDelegate[]>;
+    getAccount(address: string): Promise<GqlAccount | null>;
+    getAccountsByOwner(owner: string): Promise<GqlAccount[]>;
+    getAccountsByBuilder(builder: string, vaultAddress?: string): Promise<GqlAccount[]>;
+    getAccountsByState(state: IndexerAccountStateLabel): Promise<GqlAccount[]>;
+    getAccountsByStates(states: IndexerAccountStateLabel[]): Promise<GqlAccount[]>;
+    getAccountsUpdatedSince(since: string): Promise<GqlAccount[]>;
+    getCheckpoints(account: string, p?: Pagination): Promise<GqlCheckpoint[]>;
+    getWithdrawals(account: string, p?: Pagination): Promise<GqlProfitWithdrawal[]>;
+    getSubscriptionPayments(account: string, p?: Pagination): Promise<GqlSubscriptionPayment[]>;
+    getEvents(account: string, p?: Pagination): Promise<GqlAccountEvent[]>;
+    getEventsByType(type: string, limit?: number): Promise<GqlAccountEvent[]>;
+    getProtocolConfig(): Promise<GqlProtocolConfig | null>;
+    getMainVaultConfig(vaultAddress?: string): Promise<GqlMainVaultConfig | null>;
+    getFactoryConfig(factoryAddress?: string): Promise<GqlFactoryConfig | null>;
+    getConfigChanges(filters?: ConfigChangeFilters): Promise<GqlConfigChange[]>;
+    getVaultDayData(vaultAddress?: string, p?: Pagination): Promise<GqlVaultDayData[]>;
+    getLPDayData(address: string, p?: Pagination): Promise<GqlLiquidityProviderDayData[]>;
+    getAllowedPerps(vaultAddress?: string): Promise<GqlAllowedPerp[]>;
+    private ensureWs;
+    private subscribe;
+    subscribeActiveAccounts(cb: (accounts: GqlAccount[]) => void): Unsubscribe;
+    subscribeAccount(address: string, cb: (account: GqlAccount) => void): Unsubscribe;
+    subscribeAccountEvents(address: string, cb: (events: GqlAccountEvent[]) => void): Unsubscribe;
+    subscribeStateChanges(cb: (accounts: GqlAccount[]) => void): Unsubscribe;
+    disconnect(): void;
+}