@tokemak/queries 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,2753 @@
+import * as viem from 'viem';
+import { Address } from 'viem';
+import * as _tokemak_tokenlist from '@tokemak/tokenlist';
+import { INetwork, IToken, IProtocol } from '@tokemak/tokenlist';
+import * as abitype from 'abitype';
+import { Config } from '@wagmi/core';
+import { SupportedChainIds } from '@tokemak/config';
+import { Config as Config$1 } from 'wagmi';
+import { systemRegistryAbi } from '@tokemak/abis';
+import { ExtractAbiFunctionNames } from '@tokemak/utils';
+
+declare const getEthPrice: () => Promise<number | undefined>;
+
+declare const getTokePrice: () => Promise<number | undefined>;
+
+type PriceSource = "alchemy" | "coingecko" | "defillama";
+interface GetTokenPriceConfig$1 {
+    chainId?: number;
+    tokenAddress: Address;
+    includedSources?: PriceSource[];
+    excludedSources?: PriceSource[];
+}
+declare const getTokenPrice: ({ chainId, tokenAddress, includedSources, excludedSources, }: GetTokenPriceConfig$1) => Promise<number | undefined>;
+
+type DestinationVault = {
+    exchangeName: string;
+    [key: string]: any;
+};
+declare function getExchangeNames(destinationVaults: DestinationVault[]): string[];
+
+declare function getPoolStats<T extends {
+    vaultAddress: string;
+}>(destinationsWithTokens: T[], vaultAddress: string): T | null;
+
+declare const modifyAutopoolName: (name: string) => string;
+
+interface BaseDataEntry {
+    timestamp: string;
+    date: Date;
+}
+declare function fillMissingDates<T extends BaseDataEntry>(data: T[]): T[];
+
+declare function nestedArrayToObject<PrimaryKey extends PropertyKey, SecondaryKey extends PropertyKey, Value>(primaryKeys: readonly PrimaryKey[], secondaryKeys: readonly (readonly SecondaryKey[])[], // Adjusted to accept readonly arrays
+values: readonly (readonly Value[])[]): Record<PrimaryKey, Record<SecondaryKey, Value | undefined>>;
+
+declare function arraysToObject<K extends PropertyKey, V>(keys: readonly K[], values: readonly V[]): Record<K, V>;
+
+declare function mergeArraysWithKey<T extends Record<string, any>, U>(objectsArray: readonly T[], arraysArray: readonly (readonly U[])[], key: string): (T & Record<string, U[]>)[];
+
+declare function mergeArrays<T extends Record<string, any>, U extends Record<string, any>>(objectsArray: readonly T[], objectsToMergeArray: readonly U[]): (T & U)[];
+
+declare function getTimestampDaysFromStart(startTimestamp: number, days: number): number;
+
+declare const formatDateRange: (dateRange: Date[], type?: "date" | "time") => {
+    unlockPeriodDateRange: string;
+    unlockPeriodStartFullDate: string;
+    unlockRenewalFullDate: string;
+    unlockPeriodStartDate?: undefined;
+    unlockRenewalDate?: undefined;
+} | {
+    unlockPeriodDateRange: string;
+    unlockPeriodStartFullDate: string;
+    unlockRenewalFullDate: string;
+    unlockPeriodStartDate: string;
+    unlockRenewalDate: string;
+};
+
+declare function mergeStringArrays(keys: string[], values: string[]): {
+    [key: string]: string;
+};
+
+interface GetChainsOptions$1 {
+    includeTestnet?: boolean;
+}
+/**
+ * Returns the appropriate array of chains
+ * based on environment + 'includeTestnet' logic.
+ */
+declare function getChainsForEnv({ includeTestnet, }: GetChainsOptions$1): INetwork[];
+
+/**
+ * A generic helper to:
+ * 1) Accept an array of "chain" objects (each must have `chainId`).
+ * 2) Accept an async function (`fetchFn`) that returns a Promise for each chain.
+ * 3) Returns a dictionary keyed by chain ID (Record<number, T>) of the resolved results.
+ */
+declare function fetchChainDataMap<ChainType extends INetwork, ResultType>(chains: ChainType[], fetchFn: (chain: ChainType) => Promise<ResultType>): Promise<Record<number, ResultType>>;
+
+/**
+ * Raw pool data from the subgraph. Adjust field types if needed.
+ */
+interface PoolRewardsBalanceDayData {
+    id: string;
+    timestamp: string;
+    balance: bigint | number;
+    balanceUSD: bigint | number;
+    earned: bigint | number;
+    earnedUSD: bigint | number;
+}
+/**
+ * The shape of each aggregated daily record returned by this helper.
+ */
+interface AggregatedDayData {
+    id: string;
+    formattedDate: string;
+    timestamp: string;
+    balance: number;
+    balanceUSD: number;
+    earned: number;
+    earnedUSD: number;
+}
+/**
+ * Aggregates an array of day-data into unique timestamps. Also filters
+ * out days where `earned = 0`.
+ */
+declare function aggregateSTokeRewardsDayData(dayDatas: PoolRewardsBalanceDayData[]): AggregatedDayData[];
+
+interface GetChainsOptions {
+    includeTestnet?: boolean;
+}
+/**
+ * Returns the appropriate array of chains
+ * based on environment + 'includeTestnet' logic.
+ */
+declare function getSTokeChainsForEnv({ includeTestnet, }: GetChainsOptions): INetwork[];
+
+declare const ETH_BASE_ASSETS: string[];
+declare const USD_BASE_ASSETS: string[];
+declare enum AutopoolCategory {
+    ETH = "eth",
+    USD = "usd",
+    CRYPTO = "crypto"
+}
+declare const getAutopoolCategory: (baseAsset: string) => AutopoolCategory;
+
+declare const BASE_ASSETS: readonly [{
+    readonly symbol: "ETH";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "PXETH";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "USDC";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "DOLA";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "S";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}];
+declare const PRICED_TOKENS: readonly [{
+    readonly symbol: "ETH";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "PXETH";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "USDC";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "DOLA";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "S";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "TOKE";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}];
+type BaseAsset = (typeof BASE_ASSETS)[number]["symbol"];
+declare const WRAPPED_TOKENS: readonly [{
+    readonly symbol: "WETH";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}, {
+    readonly symbol: "WS";
+    readonly address: abitype.Address;
+    readonly chainId: number;
+    readonly decimals: number;
+    readonly logoURI: string;
+    readonly name: string;
+    readonly audits?: string;
+    readonly extensions?: {
+        bridgeMainnetAdapter?: abitype.Address;
+        bridgeInfo?: {
+            [chainId: number]: {
+                tokenAddress: abitype.Address;
+            };
+        };
+        rebasing?: boolean;
+        parentAsset?: string;
+    };
+}];
+type TokenSymbol = (typeof PRICED_TOKENS)[number]["symbol"] | (typeof BASE_ASSETS)[number]["symbol"] | (typeof WRAPPED_TOKENS)[number]["symbol"];
+type TokenPrices = {
+    [K in TokenSymbol]: number;
+};
+declare const getTokenPrices: () => Promise<TokenPrices>;
+
+type Currencies = TokenPrices & {
+    baseAsset: number;
+    USD: number;
+};
+type ExtraReward = IToken & {
+    apr: number;
+};
+declare const getChainAutopools: (wagmiConfig: Config, { chainId, prices, }: {
+    chainId: SupportedChainIds;
+    prices: TokenPrices;
+}) => Promise<{
+    symbol: string;
+    logoURI?: string | undefined;
+    description?: string;
+    type?: "Tokemak" | "Ecosystem" | undefined;
+    tvl: number;
+    totalAssets: {
+        denom: number;
+        ETH: number;
+        WETH: number;
+        USDC: number;
+        DOLA: number;
+        PXETH: number;
+        S: number;
+        TOKE: number;
+        WS: number;
+        baseAsset: number;
+        USD: number;
+    };
+    destinations: {
+        debtValueHeldByVaultUsd: number;
+        debtValueHeldByVaultEth: number;
+        compositeReturn: number;
+        debtValueHeldByVaultAllocation: number;
+        underlyingTokens: {
+            valueUsd: number;
+            value: number;
+            address: viem.Address;
+            chainId: number;
+            decimals: number;
+            logoURI: string;
+            name: string;
+            symbol: string;
+            audits?: string;
+            extensions?: {
+                bridgeMainnetAdapter?: viem.Address;
+                bridgeInfo?: {
+                    [chainId: number]: {
+                        tokenAddress: viem.Address;
+                    };
+                };
+                rebasing?: boolean;
+                parentAsset?: string;
+            };
+        }[];
+        poolName: string;
+        exchange: IProtocol | undefined;
+        vaultAddress: `0x${string}`;
+        exchangeName: string;
+        totalSupply: bigint;
+        lastSnapshotTimestamp: bigint;
+        feeApr: bigint;
+        lastDebtReportTime: bigint;
+        minDebtValue: bigint;
+        maxDebtValue: bigint;
+        debtValueHeldByVault: bigint;
+        queuedForRemoval: boolean;
+        statsIncomplete: boolean;
+        isShutdown: boolean;
+        shutdownStatus: number;
+        autoPoolOwnsShares: bigint;
+        actualLPTotalSupply: bigint;
+        dexPool: `0x${string}`;
+        lpTokenAddress: `0x${string}`;
+        lpTokenSymbol: string;
+        lpTokenName: string;
+        statsSafeLPTotalSupply: bigint;
+        statsIncentiveCredits: number;
+        rewardsTokens: readonly {
+            tokenAddress: `0x${string}`;
+        }[];
+        underlyingTokenSymbols: readonly {
+            symbol: string;
+        }[];
+        lstStatsData: readonly {
+            lastSnapshotTimestamp: bigint;
+            baseApr: bigint;
+            discount: bigint;
+            discountHistory: readonly [number, number, number, number, number, number, number, number, number, number];
+            discountTimestampByPercent: number;
+        }[];
+        underlyingTokenValueHeld: readonly {
+            valueHeldInEth: bigint;
+        }[];
+        reservesInEth: readonly bigint[];
+        statsPeriodFinishForRewards: readonly number[];
+        statsAnnualizedRewardAmounts: readonly bigint[];
+    }[];
+    exchanges: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        logoURI: string;
+        name: string;
+        audits?: string;
+        type: "DEX" | "Lending Market" | "Protocol" | "Portfolio Tracker";
+    }[];
+    timestamp: number;
+    isNew: boolean;
+    extraRewarders: {
+        __typename?: "Rewarder";
+        id: any;
+        currentApy?: any | null;
+        rewardToken?: {
+            __typename?: "RefToken";
+            symbol?: string | null;
+            id: any;
+        } | null;
+    }[] | null | undefined;
+    createdAt: Date;
+    baseAsset: {
+        price: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    };
+    denomination: {
+        price: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    };
+    useDenomination: boolean;
+    UIBaseAsset: IToken;
+    UITokens: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    }[];
+    UIExchanges: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        logoURI: string;
+        name: string;
+        audits?: string;
+        type: "DEX" | "Lending Market" | "Protocol" | "Portfolio Tracker";
+    }[];
+    tokens: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    }[];
+    chain: _tokemak_tokenlist.INetwork | undefined;
+    apr: {
+        base: any;
+        boosted: number;
+        extraAprs: ExtraReward[];
+        combined: any;
+        hasBoostedApr: boolean;
+        hasExtraAprs: boolean;
+    };
+    dailyEarnings: {
+        combined: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+        base: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+    };
+    navPerShare: {
+        denom: number;
+        ETH: number;
+        WETH: number;
+        USDC: number;
+        DOLA: number;
+        PXETH: number;
+        S: number;
+        TOKE: number;
+        WS: number;
+        baseAsset: number;
+        USD: number;
+    };
+    idle: {
+        allocation: number;
+        token: IToken;
+        denom: number;
+        ETH: number;
+        WETH: number;
+        USDC: number;
+        DOLA: number;
+        PXETH: number;
+        S: number;
+        TOKE: number;
+        WS: number;
+        baseAsset: number;
+        USD: number;
+    };
+    category: AutopoolCategory;
+    poolAddress: `0x${string}`;
+    name: string;
+    vaultType: `0x${string}`;
+    streamingFeeBps: bigint;
+    periodicFeeBps: bigint;
+    feeHighMarkEnabled: boolean;
+    feeSettingsIncomplete: boolean;
+    isShutdown: boolean;
+    shutdownStatus: number;
+    rewarder: `0x${string}`;
+    strategy: `0x${string}`;
+    totalSupply: bigint;
+    totalIdle: bigint;
+    totalDebt: bigint;
+}[]>;
+
+declare const convertBaseAssetToTokenPrices: (baseAssetValue: number, baseAssetPrice: number, prices: TokenPrices) => Currencies;
+
+declare const convertBaseAssetToTokenPricesAndDenom: (baseAsset: number, baseAssetPrice: number, denomPrice: number, prices: TokenPrices) => {
+    denom: number;
+    ETH: number;
+    WETH: number;
+    USDC: number;
+    DOLA: number;
+    PXETH: number;
+    S: number;
+    TOKE: number;
+    WS: number;
+    baseAsset: number;
+    USD: number;
+};
+
+declare const getAutopoolInfo: (symbol: string) => _tokemak_tokenlist.IAutopool | undefined;
+
+/**
+ * Generic function to find the closest entry in an array based on a numeric property
+ * @param data - Array of objects to search through
+ * @param targetValue - The target value to find the closest match for
+ * @param propertyKey - The property key to compare against (e.g., 'timestamp', 'date')
+ * @param maxDifference - Maximum allowed difference (default: Infinity)
+ * @param getValue - Optional function to extract the value from the object (default: direct property access)
+ * @returns The closest entry or null if no entry is within the tolerance
+ */
+declare function findClosestEntry<T extends Record<string, any>>(data: T[], targetValue: number, propertyKey: keyof T, maxDifference?: number, getValue?: (item: T) => number): T | null;
+/**
+ * Specialized function to find the closest entry by timestamp
+ * @param data - Array of objects with timestamp property
+ * @param targetTimestamp - The target timestamp to find the closest match for
+ * @param maxDifferenceInSeconds - Maximum allowed difference in seconds (default: 12 hours)
+ * @returns The closest entry or null if no entry is within the tolerance
+ */
+declare function findClosestTimestampEntry<T extends {
+    timestamp: number;
+}>(data: T[], targetTimestamp: number, maxDifferenceInSeconds?: number): T | null;
+/**
+ * Specialized function to find the closest entry by date
+ * @param data - Array of objects with date property
+ * @param targetDate - The target date to find the closest match for
+ * @param maxDifferenceInMs - Maximum allowed difference in milliseconds (default: 24 hours)
+ * @returns The closest entry or null if no entry is within the tolerance
+ */
+declare function findClosestDateEntry<T extends {
+    date: Date;
+}>(data: T[], targetDate: Date, maxDifferenceInMs?: number): T | null;
+
+/**
+ * Generic pagination helper for GraphQL queries
+ *
+ * @template T - The type of the query function
+ * @template R - The return type of the query function
+ * @template K - The key of the array property to paginate
+ * @param queryFn - The GraphQL query function to paginate
+ * @param arrayKey - The key of the array property to collect from the query result
+ * @param options - Pagination options
+ * @returns Promise with all paginated results combined
+ */
+declare function paginateQuery<T extends (variables?: any) => Promise<any>, R extends Awaited<ReturnType<T>>, K extends keyof R>(queryFn: T, arrayKey: K, options?: {
+    first?: number;
+    maxPages?: number;
+    onPage?: (page: R[K], pageNumber: number) => void;
+}): Promise<R[K]>;
+
+declare const getAutopools: (wagmiConfig: Config$1, { prices, includeTestnet, }: {
+    prices: TokenPrices;
+    includeTestnet?: boolean;
+}) => Promise<{
+    symbol: string;
+    logoURI?: string | undefined;
+    description?: string;
+    type?: "Tokemak" | "Ecosystem" | undefined;
+    tvl: number;
+    totalAssets: {
+        denom: number;
+        ETH: number;
+        WETH: number;
+        USDC: number;
+        DOLA: number;
+        PXETH: number;
+        S: number;
+        TOKE: number;
+        WS: number;
+        baseAsset: number;
+        USD: number;
+    };
+    destinations: {
+        debtValueHeldByVaultUsd: number;
+        debtValueHeldByVaultEth: number;
+        compositeReturn: number;
+        debtValueHeldByVaultAllocation: number;
+        underlyingTokens: {
+            valueUsd: number;
+            value: number;
+            address: viem.Address;
+            chainId: number;
+            decimals: number;
+            logoURI: string;
+            name: string;
+            symbol: string;
+            audits?: string;
+            extensions?: {
+                bridgeMainnetAdapter?: viem.Address;
+                bridgeInfo?: {
+                    [chainId: number]: {
+                        tokenAddress: viem.Address;
+                    };
+                };
+                rebasing?: boolean;
+                parentAsset?: string;
+            };
+        }[];
+        poolName: string;
+        exchange: _tokemak_tokenlist.IProtocol | undefined;
+        vaultAddress: `0x${string}`;
+        exchangeName: string;
+        totalSupply: bigint;
+        lastSnapshotTimestamp: bigint;
+        feeApr: bigint;
+        lastDebtReportTime: bigint;
+        minDebtValue: bigint;
+        maxDebtValue: bigint;
+        debtValueHeldByVault: bigint;
+        queuedForRemoval: boolean;
+        statsIncomplete: boolean;
+        isShutdown: boolean;
+        shutdownStatus: number;
+        autoPoolOwnsShares: bigint;
+        actualLPTotalSupply: bigint;
+        dexPool: `0x${string}`;
+        lpTokenAddress: `0x${string}`;
+        lpTokenSymbol: string;
+        lpTokenName: string;
+        statsSafeLPTotalSupply: bigint;
+        statsIncentiveCredits: number;
+        rewardsTokens: readonly {
+            tokenAddress: `0x${string}`;
+        }[];
+        underlyingTokenSymbols: readonly {
+            symbol: string;
+        }[];
+        lstStatsData: readonly {
+            lastSnapshotTimestamp: bigint;
+            baseApr: bigint;
+            discount: bigint;
+            discountHistory: readonly [number, number, number, number, number, number, number, number, number, number];
+            discountTimestampByPercent: number;
+        }[];
+        underlyingTokenValueHeld: readonly {
+            valueHeldInEth: bigint;
+        }[];
+        reservesInEth: readonly bigint[];
+        statsPeriodFinishForRewards: readonly number[];
+        statsAnnualizedRewardAmounts: readonly bigint[];
+    }[];
+    exchanges: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        logoURI: string;
+        name: string;
+        audits?: string;
+        type: "DEX" | "Lending Market" | "Protocol" | "Portfolio Tracker";
+    }[];
+    timestamp: number;
+    isNew: boolean;
+    extraRewarders: {
+        __typename?: "Rewarder";
+        id: any;
+        currentApy?: any | null;
+        rewardToken?: {
+            __typename?: "RefToken";
+            symbol?: string | null;
+            id: any;
+        } | null;
+    }[] | null | undefined;
+    createdAt: Date;
+    baseAsset: {
+        price: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    };
+    denomination: {
+        price: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    };
+    useDenomination: boolean;
+    UIBaseAsset: _tokemak_tokenlist.IToken;
+    UITokens: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    }[];
+    UIExchanges: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        logoURI: string;
+        name: string;
+        audits?: string;
+        type: "DEX" | "Lending Market" | "Protocol" | "Portfolio Tracker";
+    }[];
+    tokens: {
+        valueUsd: number;
+        value: number;
+        allocation: number;
+        address: viem.Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: viem.Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: viem.Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    }[];
+    chain: _tokemak_tokenlist.INetwork | undefined;
+    apr: {
+        base: any;
+        boosted: number;
+        extraAprs: ExtraReward[];
+        combined: any;
+        hasBoostedApr: boolean;
+        hasExtraAprs: boolean;
+    };
+    dailyEarnings: {
+        combined: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+        base: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+    };
+    navPerShare: {
+        denom: number;
+        ETH: number;
+        WETH: number;
+        USDC: number;
+        DOLA: number;
+        PXETH: number;
+        S: number;
+        TOKE: number;
+        WS: number;
+        baseAsset: number;
+        USD: number;
+    };
+    idle: {
+        allocation: number;
+        token: _tokemak_tokenlist.IToken;
+        denom: number;
+        ETH: number;
+        WETH: number;
+        USDC: number;
+        DOLA: number;
+        PXETH: number;
+        S: number;
+        TOKE: number;
+        WS: number;
+        baseAsset: number;
+        USD: number;
+    };
+    category: AutopoolCategory;
+    poolAddress: `0x${string}`;
+    name: string;
+    vaultType: `0x${string}`;
+    streamingFeeBps: bigint;
+    periodicFeeBps: bigint;
+    feeHighMarkEnabled: boolean;
+    feeSettingsIncomplete: boolean;
+    isShutdown: boolean;
+    shutdownStatus: number;
+    rewarder: `0x${string}`;
+    strategy: `0x${string}`;
+    totalSupply: bigint;
+    totalIdle: bigint;
+    totalDebt: bigint;
+}[] | undefined>;
+type IAutopools = Awaited<ReturnType<typeof getAutopools>>;
+type IAutopool = NonNullable<IAutopools>[number];
+
+declare const getAutopoolRebalances: (id: Address, chainId?: SupportedChainIds) => Promise<{
+    ix: number;
+    __typename?: "AutopoolRebalance";
+    autopool: any;
+    timestamp: any;
+    logIndex: any;
+    transactionHash: any;
+    blockNumber: any;
+    tokenOutAmount: any;
+    tokenOutValueInEth: any;
+    tokenOutValueBaseAsset: any;
+    tokenOutValueDenominatedIn: any;
+    tokenInAmount: any;
+    tokenInValueInEth: any;
+    tokenInValueBaseAsset: any;
+    tokenInValueDenominatedIn: any;
+    destinationOutName: string;
+    destinationOutAddress: any;
+    destinationOutExchangeName: string;
+    destinationInName: string;
+    destinationInAddress: any;
+    destinationInExchangeName: string;
+    tokenOut: {
+        __typename?: "RefToken";
+        id: any;
+        symbol?: string | null;
+    };
+    tokenIn: {
+        __typename?: "RefToken";
+        id: any;
+        symbol?: string | null;
+    };
+    destinationOutUnderlyingTokens: Array<{
+        __typename?: "RefToken";
+        id: any;
+        symbol?: string | null;
+    }>;
+    destinationInUnderlyingTokens: Array<{
+        __typename?: "RefToken";
+        id: any;
+        symbol?: string | null;
+    }>;
+}[]>;
+
+declare const getAutopoolsRebalances: (chainId?: SupportedChainIds) => Promise<{
+    __typename?: "Rebalance";
+    autopool: any;
+    blockNumber: any;
+    hash: string;
+    id: string;
+    ix: any;
+    timestamp: any;
+    outData?: {
+        __typename?: "RebalanceInOut";
+        id: string;
+        exchangeName: string;
+        ethValue: any;
+        destination: any;
+        underlyer: {
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        };
+        tokens: Array<{
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        }>;
+    } | null;
+    inData?: {
+        __typename?: "RebalanceInOut";
+        ethValue: any;
+        exchangeName: string;
+        id: string;
+        destination: any;
+        underlyer: {
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        };
+        tokens: Array<{
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        }>;
+    } | null;
+}[]>;
+
+declare const getAutopoolsHistory: (autopools: IAutopools, days: number, includeTestnet?: boolean) => Promise<{
+    [key: string]: (Omit<{
+        __typename?: "AutopoolDayData";
+        totalSupply: any;
+        nav: any;
+        date: string;
+        timestamp: any;
+        id: string;
+        vault: {
+            __typename?: "Autopool";
+            id: any;
+            registered: boolean;
+        };
+    }, "date"> & {
+        date: Date;
+        baseAsset: IToken;
+    })[];
+} | undefined>;
+type IAutopoolsHistory = Awaited<ReturnType<typeof getAutopoolsHistory>>;
+
+type VaultAddedMapping = {
+    [key: string]: Pick<VaultAddedMapping, "vault" | "blockTimestamp">;
+};
+
+interface CurveLP {
+    apr: number;
+    baseApy: number;
+    crvApy: number;
+    crvBoost: number;
+    curveTvl: number;
+    cvxApy: number;
+    timestamp: string;
+    totalSupply: bigint;
+}
+
+interface UserActivity {
+    data: string;
+    [key: string]: any;
+}
+
+interface QuoteAndPriceBaseConfig {
+    sellToken: Address;
+    buyToken: Address;
+    sellAmount?: bigint;
+    buyAmount?: bigint;
+    slippagePercentage?: number;
+    gasPrice?: number;
+    enableSlippageProtection?: boolean;
+    priceImpactProtectionPercentage?: number;
+    shouldSellEntireBalance?: boolean;
+}
+interface QuoteAndPriceBaseResult {
+    allowanceTarget: string;
+    auxiliaryChainData: Record<string, unknown>;
+    buyAmount: bigint;
+    buyTokenAddress: Address;
+    buyTokenToEthRate: string;
+    chainId: number;
+    estimatedGas: string;
+    estimatedPriceImpact: string;
+    expectedSlippage: string | null;
+    fees: {
+        zeroExFee: string | null;
+    };
+    gas: string;
+    gasPrice: string;
+    grossBuyAmount: string;
+    grossPrice: string;
+    grossSellAmount: string;
+    minimumProtocolFee: string;
+    price: string;
+    protocolFee: string;
+    sellAmount: bigint;
+    sellTokenAddress: Address;
+    sellTokenToEthRate: string;
+    sources: {
+        name: string;
+        proportion: string;
+    }[];
+    value: string;
+}
+interface FillData {
+    router: string;
+    gasUsed: number;
+    path: string;
+    routerVersion: number;
+}
+interface Order {
+    fill: {
+        input: string;
+        output: string;
+        adjustedOutput: string;
+        gas: number;
+        fillData: FillData;
+    };
+    adjustedOutput: string;
+    gas: number;
+    input: string;
+    output: string;
+    makerAmount: string;
+    makerToken: string;
+    source: string;
+    takerAmount: string;
+    takerToken: string;
+    type: number;
+}
+interface QuoteResult extends QuoteAndPriceBaseResult {
+    data: `0x${string}`;
+    decodedUniqueId: string;
+    guaranteedPrice: string;
+    orders: Order[];
+    to: Address;
+}
+
+type SendParam = {
+    dstEid: number;
+    to: `0x${string}`;
+    amountLD: bigint;
+    minAmountLD: bigint;
+    extraOptions: any;
+    composeMsg: `0x${string}`;
+    oftCmd: `0x${string}`;
+};
+
+interface TransactionRequest {
+    from: Address;
+    to: Address;
+    data: `0x${string}`;
+    value: `0x${string}` | string;
+    gasPrice: string;
+    gas?: string;
+}
+interface Token {
+    address: Address;
+    chainId: number;
+    symbol: string;
+    decimals: number;
+    name: string;
+    coinKey: string;
+    logoURI: string;
+    priceUSD: string;
+}
+interface GasCost {
+    type: string;
+    price: string;
+    estimate: string;
+    limit: string;
+    amount: string;
+    amountUSD: string;
+    token: Token;
+}
+interface StepEstimate {
+    tool: string;
+    fromAmount: string;
+    toAmount: string;
+    toAmountMin: string;
+    approvalAddress: Address;
+    executionDuration: number;
+    feeCosts: any[];
+    gasCosts: GasCost[];
+}
+interface Step {
+    id: string;
+    type: string;
+    action: {
+        fromChainId: number;
+        fromAmount: string;
+        fromToken: Token;
+        toChainId: number;
+        toToken: Token;
+        slippage: number;
+        fromAddress: Address;
+        toAddress: Address;
+    };
+    estimate: StepEstimate;
+    tool: string;
+    toolDetails: {
+        key: string;
+        name: string;
+        logoURI: string;
+    };
+}
+interface Fill {
+    from: Address;
+    to: Address;
+    source: string;
+    proportionBps: string;
+}
+interface Route {
+    fills: Fill[];
+    tokens: {
+        address: Address;
+        symbol: string;
+    }[];
+}
+interface TokenMetadata {
+    buyToken: {
+        buyTaxBps: string;
+        sellTaxBps: string;
+    };
+    sellToken: {
+        buyTaxBps: string;
+        sellTaxBps: string;
+    };
+}
+interface Issues {
+    allowance?: {
+        actual: string;
+        spender: Address;
+    };
+    balance?: {
+        token: Address;
+        actual: string;
+        expected: string;
+    };
+    simulationIncomplete: boolean;
+    invalidSourcesPassed: string[];
+}
+interface ZeroExQuoteDetails {
+    blockNumber: string;
+    buyAmount: string;
+    buyToken: Address;
+    fees?: {
+        integratorFee: null | string;
+        zeroExFee: null | string;
+        gasFee: null | string;
+    };
+    issues: Issues;
+    liquidityAvailable: boolean;
+    minBuyAmount: string;
+    route: Route;
+    sellAmount: string;
+    sellToken: Address;
+    tokenMetadata: TokenMetadata;
+    totalNetworkFee: string;
+    transaction: TransactionRequest;
+    zid: `0x${string}`;
+}
+interface LifiQuoteDetails {
+    type: string;
+    id: string;
+    tool: string;
+    toolDetails: {
+        key: string;
+        name: string;
+        logoURI: string;
+    };
+    action: {
+        fromToken: Token;
+        fromAmount: string;
+        toToken: Token;
+        fromChainId: number;
+        toChainId: number;
+        slippage: number;
+        fromAddress: Address;
+        toAddress: Address;
+    };
+    estimate: {
+        tool: string;
+        approvalAddress: Address;
+        toAmountMin: string;
+        toAmount: string;
+        fromAmount: string;
+        feeCosts: any[];
+        gasCosts: GasCost[];
+        executionDuration: number;
+        fromAmountUSD: string;
+        toAmountUSD: string;
+    };
+    includedSteps: Step[];
+    integrator: string;
+    transactionRequest: TransactionRequest & {
+        chainId: number;
+        gasLimit: string;
+    };
+}
+interface SwapQuoteResponse {
+    aggregatorName: string;
+    asyncSwapper: Address;
+    buyAmount: string;
+    minBuyAmount: string;
+    tx: TransactionRequest;
+    fullQuoteDetails: ZeroExQuoteDetails | LifiQuoteDetails;
+    expiration: number;
+}
+
+interface minAmountWithdrawnBaseConfig {
+    address: Address | undefined;
+    slippage: number | undefined;
+    chainId: number | undefined;
+    decimals: number | undefined;
+    amount: bigint;
+    isSwap: boolean | undefined;
+    buyToken: Address | undefined;
+    sellToken: Address | undefined;
+    disabled?: boolean;
+    autopool: Address | undefined;
+}
+interface minAmountDepositedBaseConfig {
+    address: Address | undefined;
+    chainId: number | undefined;
+    decimals: number | undefined;
+    amount: bigint;
+    slippage: number | undefined;
+    isSwap: boolean | undefined;
+    disabled?: boolean;
+}
+interface minAmountWithdrawnFunctionConfig extends minAmountWithdrawnBaseConfig {
+    config: Config$1;
+    user: Address | undefined;
+}
+interface minAmountDepositedFunctionConfig extends minAmountDepositedBaseConfig {
+    config: Config$1;
+}
+
+declare const getCurveLP: () => Promise<CurveLP | undefined>;
+
+declare const getSushiLP: (wagmiConfig: Config, { ethPrice }: {
+    ethPrice: number;
+}) => Promise<{
+    tvl: number;
+    lpReserve: bigint;
+    totalSupply: bigint;
+    reserves: readonly [bigint, bigint, number];
+    apr: any;
+    weeklyTokeEmissions: any;
+    valueOf1LP: number;
+} | undefined>;
+type ISushiLP = Awaited<ReturnType<typeof getSushiLP>>;
+
+type UserActivityTotalsType = {
+    [key: string]: {
+        totalDeposits: bigint;
+        totalStakes: bigint;
+        totalWithdrawals: bigint;
+        totalUnstakes: bigint;
+        chainId: SupportedChainIds;
+    };
+};
+declare const getChainUserActivity: (address?: Address, chainId?: SupportedChainIds) => Promise<{
+    events: {
+        timestamp: number;
+        shareChange: string;
+        assetChange: string;
+        vaultAddress: string;
+    }[];
+    totals: UserActivityTotalsType;
+} | undefined>;
+
+type IUserReward = {
+    payload: {
+        wallet: Address;
+        cycle: bigint;
+        amount: bigint;
+        chainId: bigint;
+    };
+    signature: {
+        v: number;
+        r: `0x${string}`;
+        s: `0x${string}`;
+        msg: string;
+    };
+    summary?: {
+        [key: string]: any;
+    };
+    breakdown?: {
+        [key: string]: any;
+    };
+};
+declare const getRewardsPayloadV1: (cycleHash: string, account: Address, rewardsV1Url: string) => Promise<IUserReward | null>;
+
+declare const getUserAutoEthRewards: (wagmiConfig: Config, rewardsV1Url: string, rewardsHash: Address, address: Address, ethPrice: number, chainId: number) => Promise<{
+    currentUserRewardsUsd: string;
+    currentUserAPR?: number | undefined;
+    currentUserRewards?: number | undefined;
+    lastWeekUserRewards?: number | undefined;
+}>;
+
+declare const getUserRewardsV1: (wagmiConfig: Config, { address, rewardsCycleIndex, rewardsV1, rewardsV1Url, rewardsV1Hash, chainId, }: {
+    address: Address;
+    rewardsCycleIndex: bigint;
+    rewardsV1: Address;
+    rewardsV1Url: string;
+    rewardsV1Hash: Address;
+    chainId: number;
+}) => Promise<{
+    claimable: bigint;
+    rewardsPayload: IUserReward | null;
+    latestClaimablePayload: IUserReward;
+} | {
+    rewardsPayload: IUserReward | null;
+    latestClaimablePayload: null;
+    claimable?: undefined;
+} | undefined>;
+
+declare const getUserV1: (wagmiConfig: Config, { currentCycleIndex, address, chainId, }: {
+    currentCycleIndex: bigint;
+    address: Address;
+    chainId: number;
+}) => Promise<{
+    stakedToke: bigint;
+    claimableToke: bigint | undefined;
+    claimableEth: bigint | undefined;
+    claimableAutoEth: bigint;
+    tokeRewardsPayload: IUserReward | null | undefined;
+    ethRewardsPayload: IUserReward | null | undefined;
+    missedTokeRewardsPayload: IUserReward | null;
+    autoEthGuardedRewardsPayload: IUserReward | null;
+    claimableMissedToke: bigint;
+} | undefined>;
+
+declare const getUserActivity: ({ address, includeTestnet, }: {
+    address: Address;
+    includeTestnet?: boolean;
+}) => Promise<{
+    events: NonNullable<Awaited<ReturnType<typeof getChainUserActivity>>>["events"];
+    totals: {
+        [x: string]: {
+            totalDeposits: bigint;
+            totalWithdrawals: bigint;
+            chainId: SupportedChainIds;
+        };
+    };
+}>;
+type IUserActivity = Awaited<ReturnType<typeof getUserActivity>>;
+
+interface UserDayDataEntry {
+    id: string;
+    date: Date;
+    vaultAddress: Address;
+    baseAsset: IToken;
+    timestamp: string;
+    shares: string;
+    rewardsClaimed: string;
+    nav: {
+        ETH: number;
+        USD: number;
+        PXETH: number;
+        USDC: number;
+    };
+}
+interface EnhancedUserHistoryEntry {
+    date: Date;
+    timestamp: string;
+    autopools: UserDayDataEntry[];
+    nav: {
+        ETH: number;
+        USD: number;
+        PXETH: number;
+        USDC: number;
+    };
+    formattedDate: string;
+    events: any[];
+    differential: number;
+}
+declare const getUserAutopoolsHistory: (address: Address, autopoolsHistory: IAutopoolsHistory, events: Awaited<ReturnType<typeof getUserActivity>>["events"] | undefined, includeTestnet?: boolean) => Promise<EnhancedUserHistoryEntry[]>;
+
+declare const getUserSushiLP: (wagmiConfig: Config, { sushiLP, currentCycleIndex, address, cycleRolloverBlockNumber, chainId, }: {
+    sushiLP: ISushiLP;
+    currentCycleIndex: bigint;
+    address: Address;
+    cycleRolloverBlockNumber: bigint;
+    chainId: number;
+}) => Promise<{
+    sushiLPBalance: bigint | undefined;
+    tSushiLPBalance: bigint | undefined;
+    tSushiLPRequested: readonly [bigint, bigint] | undefined;
+    shareOftSushiLP: number;
+    tSushiLPUsd: number;
+    balanceExcludingWithdrawal: bigint;
+    hasAddedTSushi: boolean;
+    hasRequestedUnlock: boolean;
+    hasUnlockableBalance: boolean;
+    withdrawalAmount: bigint;
+    hasBalanceExcludingWithdrawal: boolean;
+} | undefined>;
+
+declare const getUserCurveLP: (wagmiConfig: Config$1, { curveLP, address, chainId, }: {
+    curveLP: CurveLP;
+    address: Address;
+    chainId: number;
+}) => Promise<{
+    curveLPBalance: bigint | undefined;
+    convexLPBalance: bigint | undefined;
+    shareOfCurve: number;
+    shareOfConvex: number;
+    curveLPUsd: number;
+    convexLPUsd: number;
+} | undefined>;
+
+declare const getMutlipleAutopoolRebalances: (ids: Address[], chainId?: SupportedChainIds) => Promise<{
+    __typename?: "Rebalance";
+    autopool: any;
+    blockNumber: any;
+    hash: string;
+    id: string;
+    ix: any;
+    timestamp: any;
+    outData?: {
+        __typename?: "RebalanceInOut";
+        id: string;
+        exchangeName: string;
+        ethValue: any;
+        destination: any;
+        underlyer: {
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        };
+        tokens: Array<{
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        }>;
+    } | null;
+    inData?: {
+        __typename?: "RebalanceInOut";
+        ethValue: any;
+        exchangeName: string;
+        id: string;
+        destination: any;
+        underlyer: {
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        };
+        tokens: Array<{
+            __typename?: "RefToken";
+            decimals: any;
+            id: any;
+            name?: string | null;
+            symbol?: string | null;
+        }>;
+    } | null;
+}[]>;
+
+declare const getAutopoolDayData: (address: Address, chainId?: SupportedChainIds, startTimestamp?: number) => Promise<{
+    navPerShare: number;
+    rewarderApy: number;
+    baseApy: any;
+    combinedApy: any;
+    date: Date;
+    __typename?: "AutopoolDayData";
+    totalSupply: any;
+    nav: any;
+    timestamp: any;
+    id: string;
+    autopoolApy?: any | null;
+    autopoolDay7MAApy?: any | null;
+    autopoolDay30MAApy?: any | null;
+    rewarderDay7MAApy?: any | null;
+    rewarderDay30MAApy?: any | null;
+    baseAsset: {
+        __typename?: "Token";
+        id: any;
+        decimals: any;
+    };
+    vault: {
+        __typename?: "Autopool";
+        id: any;
+        registered: boolean;
+    };
+}[]>;
+
+declare const systemRegistryFunctionNames: string[];
+declare const getSystemConfig: (wagmiConfig: Config, { systemRegistry }: {
+    systemRegistry: Address;
+}) => Promise<{
+    asyncSwapperRegistry: void | `0x${string}` | undefined;
+    autopoolRouter: void | `0x${string}` | undefined;
+    autopoolRegistry: void | `0x${string}` | undefined;
+    swapRouter: void | `0x${string}` | undefined;
+} | undefined>;
+
+declare const getUserAutopools: ({ address, includeTestnet, autopools, userActivity, prices, config, }: {
+    address: Address;
+    includeTestnet?: boolean;
+    autopools: IAutopools;
+    userActivity: IUserActivity;
+    prices: TokenPrices;
+    config: Config$1;
+}) => Promise<{
+    nav: TokenPrices & {
+        USD: number;
+    };
+    idle: {
+        allocation: number;
+        ETH: number;
+        WETH: number;
+        USDC: number;
+        DOLA: number;
+        PXETH: number;
+        S: number;
+        TOKE: number;
+        WS: number;
+        USD: number;
+        token: IToken;
+        baseAsset: number;
+    }[];
+    supplied: TokenPrices & {
+        USD: number;
+    };
+    returns: TokenPrices & {
+        USD: number;
+    };
+    categories: {
+        usd: {
+            nav: TokenPrices & {
+                USD: number;
+            };
+            supplied: TokenPrices & {
+                USD: number;
+            };
+            returns: TokenPrices & {
+                USD: number;
+            };
+            idle: {
+                allocation: number;
+                ETH: number;
+                WETH: number;
+                USDC: number;
+                DOLA: number;
+                PXETH: number;
+                S: number;
+                TOKE: number;
+                WS: number;
+                USD: number;
+            };
+            avgDailyReturns: TokenPrices & {
+                USD: number;
+            };
+            apr: number;
+            totalDeposits: number;
+            totalWithdrawals: number;
+        };
+        eth: {
+            nav: TokenPrices & {
+                USD: number;
+            };
+            supplied: TokenPrices & {
+                USD: number;
+            };
+            returns: TokenPrices & {
+                USD: number;
+            };
+            idle: {
+                allocation: number;
+                ETH: number;
+                WETH: number;
+                USDC: number;
+                DOLA: number;
+                PXETH: number;
+                S: number;
+                TOKE: number;
+                WS: number;
+                USD: number;
+            };
+            avgDailyReturns: TokenPrices & {
+                USD: number;
+            };
+            apr: number;
+            totalDeposits: number;
+            totalWithdrawals: number;
+        };
+        crypto: {
+            nav: TokenPrices & {
+                USD: number;
+            };
+            supplied: TokenPrices & {
+                USD: number;
+            };
+            returns: TokenPrices & {
+                USD: number;
+            };
+            idle: {
+                allocation: number;
+                ETH: number;
+                WETH: number;
+                USDC: number;
+                DOLA: number;
+                PXETH: number;
+                S: number;
+                TOKE: number;
+                WS: number;
+                USD: number;
+            };
+            avgDailyReturns: TokenPrices & {
+                USD: number;
+            };
+            apr: number;
+            totalDeposits: number;
+            totalWithdrawals: number;
+        };
+    };
+    exchanges: {
+        allocation: number;
+        valueUsd: number;
+        value: number;
+        logoURI: string;
+        name: string;
+        audits?: string;
+        type: "DEX" | "Lending Market" | "Protocol" | "Portfolio Tracker";
+    }[];
+    tokens: {
+        allocation: number;
+        valueUsd: number;
+        value: number;
+        address: Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    }[];
+    pools: {
+        debtValueHeldByVaultAllocation: number;
+        debtValueHeldByVaultUsd: number;
+        debtValueHeldByVaultEth: number;
+        compositeReturn: number;
+        underlyingTokens: {
+            valueUsd: number;
+            value: number;
+            address: Address;
+            chainId: number;
+            decimals: number;
+            logoURI: string;
+            name: string;
+            symbol: string;
+            audits?: string;
+            extensions?: {
+                bridgeMainnetAdapter?: Address;
+                bridgeInfo?: {
+                    [chainId: number]: {
+                        tokenAddress: Address;
+                    };
+                };
+                rebasing?: boolean;
+                parentAsset?: string;
+            };
+        }[];
+        poolName: string;
+        exchange: _tokemak_tokenlist.IProtocol | undefined;
+        vaultAddress: `0x${string}`;
+        exchangeName: string;
+        totalSupply: bigint;
+        lastSnapshotTimestamp: bigint;
+        feeApr: bigint;
+        lastDebtReportTime: bigint;
+        minDebtValue: bigint;
+        maxDebtValue: bigint;
+        debtValueHeldByVault: bigint;
+        queuedForRemoval: boolean;
+        statsIncomplete: boolean;
+        isShutdown: boolean;
+        shutdownStatus: number;
+        autoPoolOwnsShares: bigint;
+        actualLPTotalSupply: bigint;
+        dexPool: `0x${string}`;
+        lpTokenAddress: `0x${string}`;
+        lpTokenSymbol: string;
+        lpTokenName: string;
+        statsSafeLPTotalSupply: bigint;
+        statsIncentiveCredits: number;
+        rewardsTokens: readonly {
+            tokenAddress: `0x${string}`;
+        }[];
+        underlyingTokenSymbols: readonly {
+            symbol: string;
+        }[];
+        lstStatsData: readonly {
+            lastSnapshotTimestamp: bigint;
+            baseApr: bigint;
+            discount: bigint;
+            discountHistory: readonly [number, number, number, number, number, number, number, number, number, number];
+            discountTimestampByPercent: number;
+        }[];
+        underlyingTokenValueHeld: readonly {
+            valueHeldInEth: bigint;
+        }[];
+        reservesInEth: readonly bigint[];
+        statsPeriodFinishForRewards: readonly number[];
+        statsAnnualizedRewardAmounts: readonly bigint[];
+    }[];
+    autopools: ({
+        name: string;
+        symbol: string;
+        poolAddress: `0x${string}`;
+        shares: number;
+        nav: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+        returns: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+        supplied: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+        idle: {
+            denom: number;
+            ETH: number;
+            WETH: number;
+            USDC: number;
+            DOLA: number;
+            PXETH: number;
+            S: number;
+            TOKE: number;
+            WS: number;
+            baseAsset: number;
+            USD: number;
+        };
+        totalDeposits: number;
+        totalWithdrawals: number;
+        staked: {
+            balance: bigint;
+            shares: number;
+            nav: Currencies;
+        };
+        unstaked: {
+            balance: bigint;
+            shares: number;
+            nav: Currencies;
+        };
+        useDenomination: boolean;
+        blendedApr: number;
+        rewardsClaimed: any;
+        lastDeposit: string | undefined;
+        baseAsset: IToken;
+        denomination: {
+            price: number;
+            address: Address;
+            chainId: number;
+            decimals: number;
+            logoURI: string;
+            name: string;
+            symbol: string;
+            audits?: string;
+            extensions?: {
+                bridgeMainnetAdapter?: Address;
+                bridgeInfo?: {
+                    [chainId: number]: {
+                        tokenAddress: Address;
+                    };
+                };
+                rebasing?: boolean;
+                parentAsset?: string;
+            };
+        };
+        category: AutopoolCategory;
+    } | undefined)[];
+    avgDailyReturnsUsd: number;
+    useDenomination: boolean;
+    denominatedToken: IToken;
+    weightedApr: number;
+    lowestApr: number;
+    highestApr: number;
+    hasMultipleBaseAssets: boolean;
+} | undefined>;
+type IUserAutopools = NonNullable<Awaited<ReturnType<typeof getUserAutopools>>>;
+type IUserAutopool = IUserAutopools["autopools"][number];
+
+declare const getChainUserAutopools: ({ address, chainId, }: {
+    address: Address;
+    chainId?: SupportedChainIds;
+}) => Promise<{
+    __typename?: "UserVault";
+    vaultAddress: any;
+    totalShares: any;
+    walletShares: any;
+    stakedShares: any;
+    rewardsClaimed: any;
+}[]>;
+
+declare const getUserAutopool: (wagmiConfig: Config, { address, autopool, }: {
+    address?: Address;
+    autopool?: IAutopool;
+}) => Promise<{
+    staked: {
+        balance: bigint;
+        shares: number;
+        nav: number;
+        navUsd: number;
+    };
+    unstaked: {
+        balance: bigint;
+        shares: number;
+        nav: number;
+        navUsd: number;
+    };
+    pastRewarderBalances: {
+        rewarderContract: `0x${string}`;
+        balance: bigint;
+        shares: number;
+        nav: number;
+        navUsd: number;
+    }[];
+    totalShares: number;
+    totalNav: number;
+    totalNavUsd: number;
+    totalNavDenominated: number;
+    useDenomination: boolean;
+    denomination: {
+        price: number;
+        address: Address;
+        chainId: number;
+        decimals: number;
+        logoURI: string;
+        name: string;
+        symbol: string;
+        audits?: string;
+        extensions?: {
+            bridgeMainnetAdapter?: Address;
+            bridgeInfo?: {
+                [chainId: number]: {
+                    tokenAddress: Address;
+                };
+            };
+            rebasing?: boolean;
+            parentAsset?: string;
+        };
+    };
+} | {
+    staked: {
+        balance: bigint;
+        shares: number;
+        nav: number;
+        navUsd: number;
+    };
+    unstaked: {
+        balance: bigint;
+        shares: number;
+        nav: number;
+        navUsd: number;
+    };
+    totalNavDenominated: number;
+    totalShares: number;
+    totalNav: number;
+    totalNavUsd: number;
+    pastRewarderBalances?: undefined;
+    useDenomination?: undefined;
+    denomination?: undefined;
+} | undefined>;
+
+type TokenBalances = Record<string, bigint | null>;
+declare const getUserTokenBalances: ({ address, apiKey, chainId, }: {
+    address: Address;
+    apiKey: string;
+    chainId: number;
+}) => Promise<TokenBalances>;
+
+declare const getTokenList: () => Promise<IToken[]>;
+
+declare const getTopAutopoolHolders: (autopoolAddress: Address, chainId?: SupportedChainIds) => Promise<{
+    __typename?: "Holder";
+    sharesHeld: any;
+    user: any;
+    lastUpdated: any;
+}[]>;
+type ITopAutopoolHolders = Awaited<ReturnType<typeof getTopAutopoolHolders>>;
+type ITopAutopoolHolder = ITopAutopoolHolders[number];
+
+declare const getAllowance: (wagmiConfig: Config, { token, address, spender, }: {
+    token: Address;
+    address: Address;
+    spender: Address;
+}) => Promise<bigint | undefined>;
+
+type rewardsData = {
+    chainId: number | SupportedChainIds;
+    autopools: {
+        [autopool: `0x${string}`]: {
+            formattedBalance: number;
+            balanceUsd: string;
+            symbol: string;
+            logoURI: string;
+            address: `0x${string}`;
+            amount: bigint;
+        };
+    };
+    rewards: {
+        [tokenAddress: `0x${string}`]: bigint;
+    };
+    rewardsUsd: number;
+};
+declare const getUserAutopoolsRewards: (wagmiConfig: Config$1, { address, tokenPrices, includeTestnet, }: {
+    address: Address;
+    tokenPrices: TokenPrices;
+    includeTestnet?: boolean;
+}) => Promise<{
+    chains: {
+        [k: string]: {
+            autopools: {
+                [autopool: `0x${string}`]: {
+                    [tokenAddress: `0x${string}`]: bigint;
+                };
+            };
+            rewards: {
+                [tokenSymbol: string]: {
+                    amount: bigint;
+                    USD: number;
+                    formattedAmount: number;
+                    decimals?: number;
+                    logoURI?: string;
+                };
+            };
+        };
+    };
+    rewardsByToken: {
+        [tokenSymbol: string]: {
+            amount: bigint;
+            USD: number;
+            formattedAmount: number;
+            logoURI?: string;
+        };
+    };
+    totalRewardsUSD: number;
+} | undefined>;
+
+declare const getAmountWithdrawn: ({ address, slippage, user, chainId, amount, decimals, buyToken, isSwap, config, sellToken, autopool, }: minAmountWithdrawnFunctionConfig) => Promise<{
+    minAmount: string;
+    dynamicSwap: {
+        standardPreviewRedeem: boolean;
+        dynamicSwapsResults: {
+            fromToken: Address;
+            toToken: Address;
+            target: Address;
+            data: Address;
+        }[] | undefined;
+        previewRedeem: bigint;
+    };
+    quote: SwapQuoteResponse | undefined;
+    convertedAssets: bigint | undefined;
+    dynamicSwapsResults?: undefined;
+    standardPreviewRedeem?: undefined;
+} | {
+    minAmount: string;
+    dynamicSwapsResults: never[];
+    standardPreviewRedeem: boolean;
+    dynamicSwap: undefined;
+    quote: undefined;
+    convertedAssets?: undefined;
+} | undefined>;
+
+declare const getAmountDeposited: ({ address, chainId, amount, isSwap, slippage, config, }: minAmountDepositedFunctionConfig) => Promise<number | undefined>;
+
+declare const getBridgeFee: (wagmiConfig: Config, { sourceAddress, destAddress, sourceChainId, destChainId, amount, from, }: {
+    amount: bigint;
+    from: Address;
+    sourceAddress: Address;
+    destChainId: number;
+    destAddress: Address;
+    sourceChainId: number;
+}) => Promise<{
+    feeQuote: {
+        nativeFee: bigint;
+        lzTokenFee: bigint;
+    };
+    sendParams: SendParam;
+} | undefined>;
+
+declare enum MessageStatus {
+    INFLIGHT = "INFLIGHT",
+    DELIVERED = "DELIVERED",
+    FAILED = "FAILED",
+    PAYLOAD_STORED = "PAYLOAD_STORED",
+    BLOCKED = "BLOCKED",
+    CONFIRMING = "CONFIRMING"
+}
+type LayerzeroStatus = {
+    status: {
+        name: MessageStatus;
+        message: string;
+    };
+};
+type GetLayerzeroStatusConfig = {
+    txHash: string;
+};
+declare const getLayerzeroStatus: ({ txHash, }: GetLayerzeroStatusConfig) => Promise<LayerzeroStatus | undefined>;
+declare const waitForMessageReceived: ({ txHash, interval, timeout, }: {
+    txHash: string;
+    interval?: number;
+    timeout?: number;
+}) => Promise<LayerzeroStatus>;
+
+declare const getUserSToke: (wagmiConfig: Config$1, { address, tokePrice, includeTestnet, }: {
+    address: Address;
+    tokePrice: number;
+    includeTestnet?: boolean;
+}) => Promise<{
+    chains: {
+        [x: number]: {
+            balance: bigint;
+            balanceUSD: string;
+            balanceExcludingWithdrawal: string;
+            balanceExcludingWithdrawalUsd: string;
+            hasBalanceExcludingWithdrawal: boolean;
+            timeLeftBeforeUnlockRequestAvailable: string;
+            timeLeftBeforeUnlockRequestUnavailable: string;
+            withdrawalAmount: bigint;
+            withdrawalAmountUsd: string;
+            hasUnlockableBalance: boolean;
+            isUnlockRequestAvailable: boolean;
+            hasRequestedUnlock: boolean;
+            hasAddedLockedToke: boolean;
+            addedLockedToke: bigint;
+            unlockPeriodDateRange: string;
+            unlockPeriodStartFullDate: string;
+            unlockRenewalFullDate: string;
+            unlockPeriodStartDate: string | undefined;
+            unlockRenewalDate: string | undefined;
+            lockDurationInMonths: number;
+            boost: number;
+            points: number;
+            totalActiveCredits: number;
+            totalCredits: number;
+        } | undefined;
+    };
+    totalBalance: number;
+    totalBalanceUsd: string;
+    hasBalance: boolean;
+} | undefined>;
+
+declare const getSToke: (wagmiConfig: Config$1, { tokePrice, includeTestnet, }: {
+    tokePrice: number;
+    includeTestnet?: boolean;
+}) => Promise<{
+    totalSupply: string;
+    tvl: string;
+    rawTVL: number;
+    chains: {
+        [x: number]: {
+            rawTotalSupply: bigint | undefined;
+            totalSupply: string;
+            tvl: string;
+            rawTVL: number;
+            currentCycle: bigint | undefined;
+            chain: _tokemak_tokenlist.INetwork | undefined;
+            timeBeforeNextCycle: string;
+        } | undefined;
+    };
+}>;
+type IStoke = Awaited<ReturnType<typeof getSToke>>;
+
+type ChainSTokeType = Awaited<ReturnType<typeof getChainSToke>>;
+declare const getChainSToke: (wagmiConfig: Config, { tokePrice, chainId, }: {
+    tokePrice: number;
+    chainId: number;
+}) => Promise<{
+    rawTotalSupply: bigint | undefined;
+    totalSupply: string;
+    tvl: string;
+    rawTVL: number;
+    currentCycle: bigint | undefined;
+    chain: _tokemak_tokenlist.INetwork | undefined;
+    timeBeforeNextCycle: string;
+} | undefined>;
+
+declare const getChainUserSToke: (wagmiConfig: Config$1, { address, tokePrice, chainId, }: {
+    address: Address;
+    tokePrice: number;
+    chainId: number;
+}) => Promise<{
+    balance: bigint;
+    balanceUSD: string;
+    balanceExcludingWithdrawal: string;
+    balanceExcludingWithdrawalUsd: string;
+    hasBalanceExcludingWithdrawal: boolean;
+    timeLeftBeforeUnlockRequestAvailable: string;
+    timeLeftBeforeUnlockRequestUnavailable: string;
+    withdrawalAmount: bigint;
+    withdrawalAmountUsd: string;
+    hasUnlockableBalance: boolean;
+    isUnlockRequestAvailable: boolean;
+    hasRequestedUnlock: boolean;
+    hasAddedLockedToke: boolean;
+    addedLockedToke: bigint;
+    unlockPeriodDateRange: string;
+    unlockPeriodStartFullDate: string;
+    unlockRenewalFullDate: string;
+    unlockPeriodStartDate: string | undefined;
+    unlockRenewalDate: string | undefined;
+    lockDurationInMonths: number;
+    boost: number;
+    points: number;
+    totalActiveCredits: number;
+    totalCredits: number;
+} | undefined>;
+
+declare const getChainCycleRolloverBlockNumber: (wagmiConfig: Config, { stoke, chainId, }: {
+    stoke: Address;
+    chainId: number;
+}) => Promise<bigint | undefined>;
+
+declare const getChainSTokeVotes: ({ chainId, includeTestnet, }: {
+    chainId: SupportedChainIds;
+    includeTestnet?: boolean;
+}) => Promise<{
+    rawData: {
+        globalVoted: bigint;
+        globalNotVoted: bigint;
+        globalSystemVotes: bigint;
+    };
+    totalSystemVotesNum: number;
+    totalSystemVotes: string;
+    autopoolVotes: {
+        [k: string]: {
+            rawVotes: string;
+            formattedVotes: string;
+        };
+    };
+}>;
+
+type ChainSTokeVotes = Awaited<ReturnType<typeof getChainSTokeVotes>>;
+type STokeVotes = Awaited<ReturnType<typeof getSTokeVotes>>;
+declare const getSTokeVotes: ({ includeTestnet, }: {
+    includeTestnet?: boolean;
+}) => Promise<Record<number, {
+    rawData: {
+        globalVoted: bigint;
+        globalNotVoted: bigint;
+        globalSystemVotes: bigint;
+    };
+    totalSystemVotesNum: number;
+    totalSystemVotes: string;
+    autopoolVotes: {
+        [k: string]: {
+            rawVotes: string;
+            formattedVotes: string;
+        };
+    };
+}> | undefined>;
+
+type ChainSTokeRewardsType = Awaited<ReturnType<typeof getChainSTokeRewards>>;
+declare const getChainSTokeRewards: ({ chainId, }: {
+    chainId: SupportedChainIds;
+}) => Promise<{
+    autopools: Record<string, {
+        balance: number;
+        balanceUSD: number;
+        currentAprPerCredit: number;
+    }>;
+    totalEarnings: number;
+    totalEarningsUsd: number;
+    historicalRewards: AggregatedDayData[];
+    aprRange: number[];
+} | null>;
+
+interface UserAutopoolsVotes {
+    [autopool: string]: {
+        weight: number;
+        percentWeight: number;
+        votes: number;
+    };
+}
+declare const getChainUserSTokeVotes: ({ address, chainId, stokeVotes, stokeRewards, }: {
+    address: Address;
+    chainId?: SupportedChainIds;
+    stokeVotes: ChainSTokeVotes | undefined;
+    stokeRewards: ChainSTokeRewardsType | undefined;
+}) => Promise<{
+    rawVoteData: {
+        __typename?: "UserVote";
+        id: string;
+        weights: Array<any>;
+        pools: Array<any>;
+    };
+    stakedToke: number;
+    totalVotes: number;
+    weightedAprPerCredits: number;
+    autopools: UserAutopoolsVotes;
+    evenlySpread: boolean;
+} | {
+    rawVoteData?: undefined;
+    stakedToke?: undefined;
+    totalVotes?: undefined;
+    weightedAprPerCredits?: undefined;
+    autopools?: undefined;
+    evenlySpread?: undefined;
+}>;
+
+declare const getSTokeRewards: ({ includeTestnet, }: {
+    includeTestnet?: boolean;
+}) => Promise<{
+    chains: {
+        [x: number]: {
+            autopools: Record<string, {
+                balance: number;
+                balanceUSD: number;
+                currentAprPerCredit: number;
+            }>;
+            totalEarnings: number;
+            totalEarningsUsd: number;
+            historicalRewards: AggregatedDayData[];
+            aprRange: number[];
+        } | null;
+    };
+    totalEarnings: number;
+    totalEarningsUsd: number;
+    historicalRewards: AggregatedDayData[];
+}>;
+type IStokeRewards = Awaited<ReturnType<typeof getSTokeRewards>>;
+
+type UserSTokeVotes = Awaited<ReturnType<typeof getChainUserSTokeVotes>>;
+declare const getUserSTokeVotes: ({ address, includeTestnet, stokeVotes, stokeRewards, }: {
+    address: Address | undefined;
+    includeTestnet?: boolean;
+    stokeVotes: STokeVotes | undefined;
+    stokeRewards: IStokeRewards | undefined;
+}) => Promise<Record<number, {
+    rawVoteData: {
+        __typename?: "UserVote";
+        id: string;
+        weights: Array<any>;
+        pools: Array<any>;
+    };
+    stakedToke: number;
+    totalVotes: number;
+    weightedAprPerCredits: number;
+    autopools: UserAutopoolsVotes;
+    evenlySpread: boolean;
+} | {
+    rawVoteData?: undefined;
+    stakedToke?: undefined;
+    totalVotes?: undefined;
+    weightedAprPerCredits?: undefined;
+    autopools?: undefined;
+    evenlySpread?: undefined;
+}> | undefined>;
+
+declare const getChainUserSTokeRewards: (wagmiConfig: Config$1, { address, chainId, tokePrice, }: {
+    address: Address;
+    chainId: number;
+    tokePrice: number;
+}) => Promise<{
+    claimable: bigint;
+    rewardsPayload: IUserReward | null;
+    latestClaimablePayload: IUserReward;
+    claimableUsd: number;
+    claimableNum: number;
+    hasClaimable: boolean;
+    pendingRewards: number;
+    pendingRewardsUsd: number;
+    totalRewardsReceived: number;
+    totalRewardsReceivedUsd: number;
+} | {
+    rewardsPayload: IUserReward | null;
+    latestClaimablePayload: null;
+    claimable?: undefined;
+    claimableUsd: number;
+    claimableNum: number;
+    hasClaimable: boolean;
+    pendingRewards: number;
+    pendingRewardsUsd: number;
+    totalRewardsReceived: number;
+    totalRewardsReceivedUsd: number;
+}>;
+
+declare const getCurrentCycleId: (wagmiConfig: Config$1, { stoke, chainId, }: {
+    stoke: Address;
+    chainId: number;
+}) => Promise<bigint>;
+
+declare const getAutopilotRouter: (wagmiConfig: Config, { chainId }: {
+    chainId: number;
+}) => Promise<void | `0x${string}`>;
+
+declare const getAddressFromSystemRegistry: (wagmiConfig: Config, { chainId, functionName, }: {
+    functionName: ExtractAbiFunctionNames<typeof systemRegistryAbi>;
+    chainId: number;
+}) => Promise<void | `0x${string}`>;
+
+interface SwapQuoteParams {
+    chainId: number;
+    slippageBps: number;
+    sellToken: Address | undefined;
+    buyToken: Address | undefined;
+    sellAmount: bigint;
+    includeSources?: string;
+    excludeSources?: string;
+    timeoutMS?: number;
+    sellAll?: boolean;
+}
+declare const getSwapQuote: (config: Config$1, { chainId, ...params }: SwapQuoteParams) => Promise<SwapQuoteResponse | undefined>;
+
+declare const getDynamicSwap: ({ address, amount, chainId, config, slippage, user, }: {
+    address: Address;
+    amount: bigint;
+    chainId: number;
+    config: any;
+    slippage: number;
+    user: Address | undefined;
+}) => Promise<{
+    standardPreviewRedeem: boolean;
+    dynamicSwapsResults: {
+        fromToken: Address;
+        toToken: Address;
+        target: Address;
+        data: Address;
+    }[] | undefined;
+    previewRedeem: bigint;
+}>;
+
+interface GetTokenPriceConfig {
+    chainId?: number;
+}
+type AutopoolAddress = string;
+type DestinationAddress = string;
+type GenStratAprs = Record<AutopoolAddress, Record<DestinationAddress, {
+    name: string;
+    apr: number;
+}>>;
+declare const getGenStratAprs: ({ chainId, }: GetTokenPriceConfig) => Promise<GenStratAprs | undefined>;
+
+declare const getDefillamaPrice: (tokenAddress: string) => Promise<number>;
+
+declare const getSubgraphStatus: (includeTestnet?: boolean) => Promise<{
+    isOutOfSync: boolean;
+    errorMessage: string;
+}>;
+
+declare const getPoolsAndDestinations: (wagmiConfig: Config, { chainId }: {
+    chainId: SupportedChainIds;
+}) => Promise<({
+    poolAddress: `0x${string}`;
+    name: string;
+    symbol: string;
+    vaultType: `0x${string}`;
+    baseAsset: `0x${string}`;
+    streamingFeeBps: bigint;
+    periodicFeeBps: bigint;
+    feeHighMarkEnabled: boolean;
+    feeSettingsIncomplete: boolean;
+    isShutdown: boolean;
+    shutdownStatus: number;
+    rewarder: `0x${string}`;
+    strategy: `0x${string}`;
+    totalSupply: bigint;
+    totalAssets: bigint;
+    totalIdle: bigint;
+    totalDebt: bigint;
+    navPerShare: bigint;
+} & Record<string, {
+    vaultAddress: `0x${string}`;
+    exchangeName: string;
+    totalSupply: bigint;
+    lastSnapshotTimestamp: bigint;
+    feeApr: bigint;
+    lastDebtReportTime: bigint;
+    minDebtValue: bigint;
+    maxDebtValue: bigint;
+    debtValueHeldByVault: bigint;
+    queuedForRemoval: boolean;
+    statsIncomplete: boolean;
+    isShutdown: boolean;
+    shutdownStatus: number;
+    autoPoolOwnsShares: bigint;
+    actualLPTotalSupply: bigint;
+    dexPool: `0x${string}`;
+    lpTokenAddress: `0x${string}`;
+    lpTokenSymbol: string;
+    lpTokenName: string;
+    statsSafeLPTotalSupply: bigint;
+    statsIncentiveCredits: number;
+    compositeReturn: bigint;
+    rewardsTokens: readonly {
+        tokenAddress: `0x${string}`;
+    }[];
+    underlyingTokens: readonly {
+        tokenAddress: `0x${string}`;
+    }[];
+    underlyingTokenSymbols: readonly {
+        symbol: string;
+    }[];
+    lstStatsData: readonly {
+        lastSnapshotTimestamp: bigint;
+        baseApr: bigint;
+        discount: bigint;
+        discountHistory: readonly [number, number, number, number, number, number, number, number, number, number];
+        discountTimestampByPercent: number;
+    }[];
+    underlyingTokenValueHeld: readonly {
+        valueHeldInEth: bigint;
+    }[];
+    reservesInEth: readonly bigint[];
+    statsPeriodFinishForRewards: readonly number[];
+    statsAnnualizedRewardAmounts: readonly bigint[];
+}[]>)[] | undefined>;
+
+declare const getChainSubgraphStatus: (chain: INetwork) => Promise<{
+    chainId: number;
+    chainName: string;
+    timestamp: number;
+    isSynced: boolean;
+    syncDelay: number;
+    error: null;
+} | {
+    chainId: number;
+    timestamp: number;
+    error: string;
+    chainName?: undefined;
+    isSynced?: undefined;
+    syncDelay?: undefined;
+}>;
+
+declare const getCycleV1: (wagmiConfig: Config, { currentBlockNumber, chainId, }: {
+    currentBlockNumber: BigInt;
+    chainId: number;
+}) => Promise<{
+    currentCycleIndex: bigint;
+    cycleRolloverBlockNumber: bigint | BigInt;
+    timeBeforeNextCycle: string;
+} | undefined>;
+
+declare const getProtocolStats: (autopools: IAutopools | undefined, stoke: IStoke | undefined, sushiLP: ISushiLP | undefined) => Promise<{
+    autopools: {
+        tvl: string;
+        tvlNum: number;
+        categories: {
+            [k: string]: {
+                tvl: string;
+                supply: string;
+            };
+        };
+    };
+    stoke: {
+        tvl: string;
+        totalSupply: string;
+    };
+    sushiLP: {
+        tvl: string;
+        totalSupply: number | bigint;
+    };
+    tvl: string;
+    totalDestinations: number;
+} | null>;
+
+declare const BATCH_SIZE = 500;
+type IRebalance = {
+    timestamp: number;
+    blockNumber: number;
+    chainId: number;
+    valueInUsd: number;
+};
+type RawRebalance = {
+    timestamp: number;
+    blockNumber: number;
+    tokenOutValueInEth: string;
+    tokenOutValueBaseAsset: string;
+};
+declare const fetchChainRebalances: (chainId: number) => Promise<RawRebalance[]>;
+declare const processRebalance: (rebalance: RawRebalance, chainId: number, wagmiConfig: Config$1) => Promise<IRebalance>;
+declare const processRebalancesInBatches: (rebalances: RawRebalance[], chainId: number, wagmiConfig: Config$1) => Promise<IRebalance[]>;
+declare const calculateRebalanceStats: (rebalances: IRebalance[]) => {
+    totalRebalances: number;
+    totalRebalanceVolume: number;
+    rebalances: IRebalance[];
+};
+declare const getRebalanceStats: (wagmiConfig: Config$1, { includeTestnet, }: {
+    includeTestnet?: boolean;
+}) => Promise<{
+    totalRebalances: number;
+    totalRebalanceVolume: number;
+    rebalances: IRebalance[];
+}>;
+
+declare const getEthPriceAtBlock: (wagmiConfig: Config, blockNumber: bigint, chainId: SupportedChainIds) => Promise<bigint>;
+
+declare const updateRebalanceStats: (wagmiConfig: Config$1, { currentRebalances, includeTestnet, }: {
+    currentRebalances: IRebalance[];
+    includeTestnet?: boolean;
+}) => Promise<{
+    totalRebalances: number;
+    totalRebalanceVolume: number;
+    rebalances: IRebalance[];
+}>;
+
+export { AggregatedDayData, AutopoolCategory, BASE_ASSETS, BATCH_SIZE, BaseAsset, BaseDataEntry, ChainSTokeRewardsType, ChainSTokeType, ChainSTokeVotes, Currencies, CurveLP, ETH_BASE_ASSETS, EnhancedUserHistoryEntry, ExtraReward, FillData, GetLayerzeroStatusConfig, IAutopool, IAutopools, IAutopoolsHistory, IRebalance, IStoke, IStokeRewards, ISushiLP, ITopAutopoolHolder, ITopAutopoolHolders, IUserActivity, IUserAutopool, IUserAutopools, IUserReward, LayerzeroStatus, MessageStatus, Order, PRICED_TOKENS, PoolRewardsBalanceDayData, QuoteAndPriceBaseConfig, QuoteAndPriceBaseResult, QuoteResult, RawRebalance, STokeVotes, SendParam, SwapQuoteParams, SwapQuoteResponse, TokenPrices, USD_BASE_ASSETS, UserActivity, UserAutopoolsVotes, UserDayDataEntry, UserSTokeVotes, VaultAddedMapping, aggregateSTokeRewardsDayData, arraysToObject, calculateRebalanceStats, convertBaseAssetToTokenPrices, convertBaseAssetToTokenPricesAndDenom, fetchChainDataMap, fetchChainRebalances, fillMissingDates, findClosestDateEntry, findClosestEntry, findClosestTimestampEntry, formatDateRange, getAddressFromSystemRegistry, getAllowance, getAmountDeposited, getAmountWithdrawn, getAutopilotRouter, getAutopoolCategory, getAutopoolDayData, getAutopoolInfo, getAutopoolRebalances, getAutopools, getAutopoolsHistory, getAutopoolsRebalances, getBridgeFee, getChainAutopools, getChainCycleRolloverBlockNumber, getChainSToke, getChainSTokeRewards, getChainSubgraphStatus, getChainUserActivity, getChainUserAutopools, getChainUserSToke, getChainUserSTokeRewards, getChainUserSTokeVotes, getChainsForEnv, getCurrentCycleId, getCurveLP, getCycleV1, getDefillamaPrice, getDynamicSwap, getEthPrice, getEthPriceAtBlock, getExchangeNames, getGenStratAprs, getLayerzeroStatus, getMutlipleAutopoolRebalances, getPoolStats, getPoolsAndDestinations, getProtocolStats, getRebalanceStats, getRewardsPayloadV1, getSToke, getSTokeChainsForEnv, getSTokeRewards, getSTokeVotes, getSubgraphStatus, getSushiLP, getSwapQuote, getSystemConfig, getTimestampDaysFromStart, getTokePrice, getTokenList, getTokenPrice, getTokenPrices, getTopAutopoolHolders, getUserActivity, getUserAutoEthRewards, getUserAutopool, getUserAutopools, getUserAutopoolsHistory, getUserAutopoolsRewards, getUserCurveLP, getUserRewardsV1, getUserSToke, getUserSTokeVotes, getUserSushiLP, getUserTokenBalances, getUserV1, mergeArrays, mergeArraysWithKey, mergeStringArrays, minAmountDepositedBaseConfig, minAmountDepositedFunctionConfig, minAmountWithdrawnBaseConfig, minAmountWithdrawnFunctionConfig, modifyAutopoolName, nestedArrayToObject, paginateQuery, processRebalance, processRebalancesInBatches, rewardsData, systemRegistryFunctionNames, updateRebalanceStats, waitForMessageReceived };