@berachain/berajs 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/actions/index.d.cts

@@ -0,0 +1,1650 @@
+import { V as ValidatorRewardAllocation } from '../getValidatorQueuedOperatorAddress-BCYlvah3.cjs';
+export { f as GetBgtAprSimulationArgs, h as GetBgtAprSimulationResult, G as GetConvertToAssetsProps, s as GetGaugeData, c as GetHoneyVaultsBalanceResponse, m as GetMarkets, q as GetRewardVaultRewardsReturn, u as GetStakedBeraSnapshotsArgs, x as GetUserVaultsResponse, z as GetVaultHistoryArgs, k as GlobalData, I as IsBadCollateralArgs, e as IsBadCollateralResponse, O as OnChainPool, P as PoolStatus, p as RewardVaultDistributionMode, R as RewardVaultIncentive, S as StakedBeraWithdrawal, D as UserBoostsOnValidator, F as UserStakingPoolPosition, U as UserVault, J as ValidatorQueuedCommission, L as ValidatorQueuedOperatorAddress, N as ValidatorRewardAllocationRaw, Q as ValidatorRewardAllocationUpdate, T as ValidatorRewardAllocationUpdateWithExpiration, B as ValidatorWithUserBoost, W as formatValidatorRewardAllocation, j as getBgtAprSimulation, g as getConvertToAssets, l as getGlobalData, d as getHoneyVaultsBalance, n as getMarkets, a as getOnChainPool, b as getPoolPausedState, o as getRewardVaultIncentives, r as getRewardVaultRewards, t as getRewardVaults, w as getSWBeraWithdrawal, v as getStakedBeraSnapshots, C as getUserActiveValidators, E as getUserBoostsOnValidator, H as getUserStakingPositions, y as getUserVaults, K as getValidatorQueuedCommission, M as getValidatorQueuedOperatorAddress, Y as getValidatorRewardAllocation, A as getVaultHistory, i as isBadCollateralAsset, X as isSameRewardAllocation } from '../getValidatorQueuedOperatorAddress-BCYlvah3.cjs';
+import { Address, PublicClient, AbiParameter, AbiFunction, TransactionReceipt, Abi, ContractFunctionArgs, ContractFunctionName, WalletCallReceipt } from 'viem';
+import { ApolloClient, OperationVariables, FetchPolicy } from '@apollo/client';
+export { gql } from '@apollo/client';
+import { ChainId, BeraConfig } from '@berachain/config/internal';
+import { A as Aggregators, i as IAggregatorArgs, I as IRawAggregatorQuote, a as Token, P as PythLatestUpdates, b as TokenWithMetadata, T as TokenWithOrder, j as PythPriceFeedMap, k as TokenCurrentPriceMap, l as AllowanceToken, M as MinimalERC20, B as BalanceToken, m as IContractWrite } from '../dex-jD95agMv.cjs';
+export { C as CollateralRates, o as CollateralRatesArgs, n as HoneyFeeMap, r as HoneyPreviewArgs, q as HoneyPreviewMethod, t as HoneyPreviewReadResult, s as HoneyPreviewResult, p as getHoneyFees, v as getHoneyPreview, w as getPythLatestPrices } from '../dex-jD95agMv.cjs';
+import { PoolState } from '@berachain-foundation/berancer-sdk';
+export { BalancerApi } from '@berachain-foundation/berancer-sdk';
+import * as _berachain_graphql_dex_api from '@berachain/graphql/dex/api';
+import { GetPoolsQueryVariables, GetGlobalLiquidityAndSwapVolumeQuery, GetPoolEventsQuery, GqlChain, PoolHistoricalDataFragment, MinimalPoolFragment } from '@berachain/graphql/dex/api';
+import { GqlPoolEventType, GqlChain as GqlChain$1, ApiVaultFragment, ApiValidatorFragment, GetValidatorsQueryVariables, GetValidatorsQuery, ApiRewardAllocationWeightFragment, GetValidatorQuery, ApiValidatorMinimalFragment } from '@berachain/graphql/pol/api';
+import { a as ProposalErrorCodes, b as ProposalState, C as CustomProposal, G as GovernanceTopic, c as CustomProposalErrors, B as BribeBoostRewardProof, d as BribeBoostRewardItem, U as UserVaultInfo } from '../staking-BxYDlMtj.cjs';
+import { ProposalStatus, ProposalSelectionFragment, Proposal_Filter, Proposal_OrderBy, OrderDirection, ProposalWithVotesFragment, GetProposalVotesQueryVariables, GetProposalVotesQuery } from '@berachain/graphql/governance';
+import { GetPublicClientReturnType } from '@wagmi/core';
+import graymatter from 'gray-matter';
+import { GetChartDataQuery, GetGlobalDataQuery } from '@berachain/graphql/honey';
+import { EdgeConfigSchema } from '@berachain/config/internal/edge-config';
+import { p as pythWrapperAbi, h as honeyFactoryAbi } from '../pythWrapper-CBjsmmsK.cjs';
+import { I as IHoneySwapState } from '../useHoneySwapState-YfMSTWY3.cjs';
+import { Address as Address$1 } from '@berachain/config';
+import { GetValidatorBlockStatsQuery, GetValidatorByAccountQuery, GetValidatorAnalyticsQuery } from '@berachain/graphql/pol/subgraph';
+import '../aggregatorsRouter-Cny4B_MB.cjs';
+import 'react/jsx-runtime';
+import 'react';
+import 'swr';
+import '../txnEnum-Diichv9Z.cjs';
+import '../BeraError-D1HS_rbb.cjs';
+import '@sentry/nextjs';
+
+interface GetMaxDepositProps {
+    vaultAddress: Address;
+    publicClient: PublicClient;
+}
+declare function getMaxDeposit({ vaultAddress, publicClient, }: GetMaxDepositProps): Promise<string>;
+
+/**
+ * This is a wrapper around the ApolloClient that throws a BeraError if the query returns an error or no data.
+ *
+ * It's mostly a typescript helper that keeps data always defined since we use errorPolicy: "none" by default.
+ * Such setting will throw an error if the query returns an error, rather than returning an object with undefined data and an error property.
+ */
+declare class BeraApolloClient extends ApolloClient {
+    /**
+     * The URL of the endpoint. Used for error reporting only.
+     */
+    protected url: string;
+    constructor(options: ApolloClient.Options & {
+        /**
+         * The URL of the endpoint. Used for error reporting only.
+         */
+        url: string;
+    });
+    query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Omit<ApolloClient.QueryOptions<TData, TVariables>, "errorPolicy">): Promise<{
+        data: TData;
+    }>;
+}
+
+type GraphqlClient = "honey.subgraph" | "pol.subgraph" | "governance.subgraph" | "blocks.subgraph" | "bex.subgraph" | "api" | "bend.whisk";
+declare function getApolloClient(clientName: GraphqlClient, { ...args }: BeraJS.BaseFunctionArgs): BeraApolloClient;
+
+declare abstract class BaseAggregator {
+    abstract name: Aggregators;
+    abstract supportedChains: ChainId[];
+    static PATH_NOT_FOUND_REASON: string;
+    notFoundMessages: string[];
+    config: BeraConfig;
+    chainId: ChainId;
+    constructor(args?: BeraJS.BaseFunctionArgs);
+    /**
+     * Identifies the url of the last sent request. Might not have all query params.
+     * Mainly used for error reporting.
+     */
+    url: string;
+    abstract readonly type: "rest" | "graphql" | "rpc";
+    abstract getQuote(args: IAggregatorArgs): Promise<IRawAggregatorQuote | undefined> | Promise<IRawAggregatorQuote<false> | undefined>;
+    /**
+     * return wbera for native tokens to accomodate the aggregator's router logic
+     */
+    protected parseAddresses(tokenIn: string, tokenOut: string): {
+        tokenInAddress: Address;
+        tokenOutAddress: Address;
+        isTokenInNative: boolean;
+        isTokenOutNative: boolean;
+    };
+    /**
+     * Calculate input amount after fees
+     */
+    protected getAmountAfterFees(amount: string, aggregatorsFeeBps?: number): string;
+    /**
+     * Formats input data for aggregator swaps
+     */
+    protected getInputData({ tokenIn, amountIn, isNative, isPermit2Approval, permit2SpenderAddress, }: {
+        tokenIn: Address;
+        amountIn: string;
+        isNative: boolean;
+        isPermit2Approval?: boolean;
+        permit2SpenderAddress?: Address;
+    }): {
+        tokenIn: `0x${string}`;
+        amountIn: bigint;
+        isNative: boolean;
+        isPermit2Approval: boolean;
+        permit2SpenderAddress: `0x${string}`;
+    };
+    /**
+     * Calculate min amount out
+     */
+    protected getMinAmountOut(amountOut: string, slippage: number): bigint;
+    /**
+     * Check if chain is supported
+     */
+    protected checkChainSupport(): void;
+    protected fetch(url: string | URL, options?: RequestInit): Promise<Response>;
+}
+
+declare function getAllPools({ textSearch, chain, first, orderBy, orderDirection, skip, fetchPolicy, userAddress, blacklistedPoolIds, ...args }?: Partial<GetPoolsQueryVariables & {
+    fetchPolicy: FetchPolicy;
+}> & BeraJS.BaseFunctionArgs): Promise<{
+    pools: {
+        __typename?: "GqlPoolMinimal";
+        id: string;
+        name: string;
+        address: `0x${string}`;
+        factory?: `0x${string}` | null;
+        protocolVersion: number;
+        type: _berachain_graphql_dex_api.GqlPoolType;
+        tokens: Array<{
+            __typename?: "GqlPoolTokenExpanded";
+            address: `0x${string}`;
+            symbol: string;
+            name: string;
+            decimals: number;
+        }>;
+        dynamicData: {
+            __typename?: "GqlPoolDynamicData";
+            totalShares: string;
+            fees24h: string;
+            volume24h: string;
+            swapFee: string;
+            isInRecoveryMode: boolean;
+            isPaused: boolean;
+            totalLiquidity: string;
+            aprItems: Array<{
+                __typename?: "GqlPoolAprItem";
+                apr: number;
+                type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+                id: string;
+            }>;
+        };
+        userBalance?: {
+            __typename?: "GqlPoolUserBalance";
+            totalBalanceUsd: number;
+            walletBalance: any;
+            walletBalanceUsd: number;
+        } | null;
+        rewardVault?: {
+            __typename?: "GqlRewardVault";
+            isVaultWhitelisted: boolean;
+            vaultAddress: `0x${string}`;
+            stakingTokenAddress: `0x${string}`;
+            dynamicData?: {
+                __typename?: "GqlRewardVaultDynamicData";
+                activeIncentivesValueUsd: string;
+                apr?: number | null;
+                bgtCapturePercentage: string;
+                allTimeReceivedBGTAmount: string;
+            } | null;
+        } | null;
+    }[];
+    count: number;
+}>;
+
+declare function getApiPool({ poolId, account, ...args }: {
+    poolId: string;
+    account?: Address | undefined;
+} & BeraJS.BaseFunctionArgs): Promise<{
+    __typename?: "GqlPoolComposableStable";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+} | {
+    __typename?: "GqlPoolElement";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+} | {
+    __typename?: "GqlPoolFx";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+} | {
+    __typename?: "GqlPoolGyro";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+} | {
+    __typename?: "GqlPoolLiquidityBootstrapping";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+} | {
+    __typename?: "GqlPoolMetaStable";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+} | {
+    __typename?: "GqlPoolStable";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+} | {
+    __typename?: "GqlPoolWeighted";
+    id: string;
+    name: string;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    protocolVersion: number;
+    type: _berachain_graphql_dex_api.GqlPoolType;
+    createTime: number;
+    tokens: Array<{
+        __typename?: "GqlPoolTokenDetail";
+        index: number;
+        address: `0x${string}`;
+        symbol: string;
+        name: string;
+        decimals: number;
+        weight?: string | null;
+        balance: string;
+        balanceUSD: string;
+    }>;
+    dynamicData: {
+        __typename?: "GqlPoolDynamicData";
+        totalShares: string;
+        fees24h: string;
+        volume24h: string;
+        swapFee: string;
+        isInRecoveryMode: boolean;
+        isPaused: boolean;
+        totalLiquidity: string;
+        aprItems: Array<{
+            __typename?: "GqlPoolAprItem";
+            apr: number;
+            type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+            id: string;
+        }>;
+    };
+    rewardVault?: {
+        __typename?: "GqlRewardVault";
+        isVaultWhitelisted: boolean;
+        vaultAddress: `0x${string}`;
+        stakingTokenAddress: `0x${string}`;
+        dynamicData?: {
+            __typename?: "GqlRewardVaultDynamicData";
+            activeIncentivesValueUsd: string;
+            apr?: number | null;
+            bgtCapturePercentage: string;
+            allTimeReceivedBGTAmount: string;
+        } | null;
+    } | null;
+}>;
+
+declare function getGlobalLiquidityAndSwapVolume(args?: BeraJS.BaseFunctionArgs): Promise<GetGlobalLiquidityAndSwapVolumeQuery>;
+
+declare function getPoolEvents({ poolId, typeInArray, ...args }: {
+    poolId: string;
+    typeInArray: GqlPoolEventType[];
+} & BeraJS.BaseFunctionArgs): Promise<GetPoolEventsQuery>;
+
+/** @deprecated */
+type PoolDayData = {
+    date: number;
+    tvlUsd: string;
+    volumeUsd: string;
+    feesUsd: string;
+};
+interface GetPoolHistoricalDataProps {
+    poolId: string;
+    chain: GqlChain;
+}
+declare function getPoolHistoricalData({ poolId, chain, ...args }: GetPoolHistoricalDataProps & BeraJS.BaseFunctionArgs): Promise<PoolHistoricalDataFragment[] | undefined>;
+
+declare const getPoolState: (apiPool: MinimalPoolFragment) => PoolState;
+
+declare function getSubgraphPool({ poolId, ...args }: BeraJS.BaseFunctionArgs & {
+    poolId: string;
+}): Promise<{
+    __typename?: "Pool";
+    id: string;
+    name?: string | null;
+    address: `0x${string}`;
+    factory?: `0x${string}` | null;
+    swapFee: string;
+    totalShares: string;
+    totalLiquidity: string;
+    createTime: number;
+    owner?: `0x${string}` | null;
+    type?: string | null;
+    tokens?: Array<{
+        __typename?: "PoolToken";
+        address: `0x${string}`;
+        name: string;
+        decimals: number;
+        symbol: string;
+        index?: number | null;
+        weight?: string | null;
+        balance: string;
+    }> | null;
+} | null | undefined>;
+
+declare function getVaultPausedState({ publicClient, ...args }: BeraJS.BaseFunctionArgs & {
+    publicClient: PublicClient;
+}): Promise<boolean>;
+
+type CheckProposalFieldResultMinimal = ProposalErrorCodes | null;
+type CheckProposalFieldResult = ProposalErrorCodes | null | CheckProposalFieldResultMinimal[] | Record<string, CheckProposalFieldResultMinimal>;
+interface CheckProposalField {
+    (arg: {
+        fieldOrType: "address" | "hex" | "abi" | "string" | "bool" | `uint${string}` | `int${string}` | "action" | "title" | "forumLink" | "description" | "logoURI" | "url";
+        value: any;
+        required?: boolean;
+        baseUrl?: string;
+        components?: readonly (AbiParameter | readonly AbiParameter[])[];
+    }): CheckProposalFieldResultMinimal;
+    (arg: {
+        fieldOrType: "tuple[]" | "tuple";
+        value: any;
+        required?: boolean;
+        baseUrl?: string;
+        components?: readonly (AbiParameter | readonly AbiParameter[])[];
+    }): CheckProposalFieldResult;
+}
+declare const checkProposalField: CheckProposalField;
+
+declare const MOCKED_PROPOSAL_STATUSES: readonly ProposalStatus[];
+declare function computeActualStatus(proposal: ProposalSelectionFragment, 
+/**
+ * Value returned by the `state` function of the governance contract.
+ */
+proposalOnChainState?: ProposalState): ProposalStatus;
+
+declare function getAllProposals({ where, orderBy, orderDirection, offset, perPage, text, ...args }: BeraJS.BaseFunctionArgs & {
+    offset?: number;
+    where: Proposal_Filter;
+    perPage?: number;
+    orderBy?: Proposal_OrderBy;
+    orderDirection?: OrderDirection;
+    text?: string;
+}): Promise<ProposalSelectionFragment[] | undefined>;
+
+declare const getBodyErrors: (proposal: CustomProposal, currentTopic: GovernanceTopic) => CustomProposalErrors;
+
+/**
+ * Decodes the function data from a given contract address and calldata.
+ *
+ * This function attempts to decode the provided calldata using a known set of ABIs.
+ * If the call data cannot be decoded with the known ABIs, it fetches the ABI from the blockexplorer API.
+ *
+ * @param address - The contract address.
+ * @param callData - The calldata to decode, in hexadecimal format.
+ * @returns An object containing the decoded ABI item, function signature, function name, and arguments.
+ */
+declare function getDecodedFunctionData({ address, callData, chainId, publicClient, }: {
+    address: Address;
+    callData: `0x${string}`;
+    chainId?: number;
+    publicClient: PublicClient;
+}): Promise<{
+    args: never[];
+    abiItem?: undefined;
+    functionSignature?: undefined;
+    functionName?: undefined;
+} | {
+    abiItem: AbiFunction | undefined;
+    functionSignature: string | undefined;
+    functionName: string;
+    args: unknown[];
+}>;
+
+declare function getProposalDetails({ proposalId, ...args }: BeraJS.BaseFunctionArgs & {
+    proposalId: string;
+    client?: GetPublicClientReturnType;
+}): Promise<ProposalWithVotesFragment | undefined>;
+
+declare function getProposalFromTx(args: {
+    publicClient: PublicClient | GetPublicClientReturnType;
+} & ({
+    tx: TransactionReceipt;
+} | {
+    txHash: Address;
+})): Promise<ProposalWithVotesFragment | null>;
+
+declare function getProposalVotes({ variables, ...args }: BeraJS.BaseFunctionArgs & {
+    variables: GetProposalVotesQueryVariables;
+}): Promise<{
+    data: GetProposalVotesQuery;
+}>;
+
+declare const parseProposalBody: (proposal?: Pick<ProposalSelectionFragment, "description">) => graymatter.GrayMatterFile<string> & {
+    isFrontMatter: boolean;
+};
+
+declare function getChartData({ days, ...args }: BeraJS.BaseFunctionArgs & {
+    days: number;
+}): Promise<GetChartDataQuery>;
+
+/**
+ * Arguments for the getCollateralWeights function.
+ */
+interface GetCollateralWeightsArgs extends BeraJS.BaseFunctionArgs {
+    client: PublicClient;
+    collateralList: Token[];
+}
+/**
+ * Fetches the weights of collaterals from the honey factory contract.
+ * and returns a record of collateral addresses and their weights.
+ *
+ * @param {getCollateralWeightsArgs} args - The arguments for the function.
+ * @returns {Promise<Record<Address, bigint> | undefined>} A promise that resolves to a record of collateral addresses and their weights, or undefined if an error occurs.
+ */
+declare function getCollateralWeights({ client, collateralList, ...args }: GetCollateralWeightsArgs): Promise<Record<Address, bigint> | undefined>;
+
+interface GetGlobalCapLimitArgs extends BeraJS.BaseFunctionArgs {
+    client: PublicClient;
+    asset: Token;
+    amount: string;
+    isMint: boolean;
+    latestPrices: PythLatestUpdates | undefined;
+    isPythWrapperEnabled: boolean;
+}
+/**
+ * Get the global cap limit for the Honey protocol.
+ *
+ * @param {Object} args - The arguments object.
+ * @param {PublicClient} args.client - The client used to interact with the blockchain.
+ * @param {Token} args.asset - The asset that is being provided for the exchange.
+ * @param {string} args.amount - The amount of the asset.
+ *
+ * @returns {Promise<boolean | undefined>} If the exchange will trigger the global cap limit or get close to it.
+ */
+declare function getGlobalCapLimit({ client, asset, amount, isMint, isPythWrapperEnabled, latestPrices, ...args }: GetGlobalCapLimitArgs): Promise<boolean | undefined>;
+
+interface GetHoneyCollateralsArgs extends BeraJS.BaseFunctionArgs {
+    /**
+     * The public client for blockchain interactions
+     */
+    client: PublicClient;
+    /**
+     * Optional pre-fetched token data to avoid redundant contract calls
+     */
+    tokenData?: TokenWithMetadata[];
+    /**
+     * preferred collateral order coming from edge config
+     */
+    preferredCollateralOrder?: NonNullable<NonNullable<EdgeConfigSchema["honey"]>["preferredCollateralOrder"]>["mainnet"];
+}
+/**
+ * Retrieves and processes collateral tokens for the Honey factory contract.
+ * Fetches registered collateral assets from the contract, enriches them with token metadata,
+ * and applies configurable ordering overrides.
+ *
+ * @returns
+ *   - `collaterals`: Array of collateral tokens with metadata, sorted by contract order and any overrides
+ *   - `referenceCollateral`: The reference collateral token used for relative & global cap limit
+ */
+declare function getHoneyCollaterals({ client, tokenData, preferredCollateralOrder, ...args }: GetHoneyCollateralsArgs): Promise<{
+    collaterals: TokenWithOrder[];
+    referenceCollateral: TokenWithOrder;
+}>;
+
+declare function getHoneyGlobalData({ ...args }?: BeraJS.BaseFunctionArgs): Promise<GetGlobalDataQuery>;
+
+/**
+ * Gets the pause state of the Honey protocol
+ * @returns boolean
+ */
+declare function getHoneyPausedState({ client, ...args }: BeraJS.BaseFunctionArgs & {
+    client: PublicClient;
+}): Promise<boolean>;
+
+/**
+ * Gets the address of the Honey Pyth Oracle, which is called by the Honey Root Price Oracle to get the price of the collaterals
+ * @returns
+ */
+declare function getHoneyPythOracle({ pythOracle, publicClient, }: {
+    publicClient: PublicClient;
+    pythOracle: Address;
+}): Promise<`0x${string}`>;
+
+/**
+ * Gets the address of the Honey Root Price Oracle, which keeps the logic to price the collaterals
+ */
+declare function getHoneyRootPriceOracle({ publicClient, factory, ...args }: BeraJS.BaseFunctionArgs & {
+    publicClient: PublicClient;
+    factory?: Address;
+}): Promise<Address>;
+
+interface GetRelativeCapLimitArgs extends BeraJS.BaseFunctionArgs {
+    client: PublicClient;
+    asset: Address;
+    amount: string;
+    isMint: boolean;
+    referenceCollateral: TokenWithOrder;
+}
+/**
+ * Get the relative cap limit for a given asset.
+ *
+ * @param {Object} args - The arguments object.
+ * @param {PublicClient} args.client - The client used to interact with the blockchain.
+ * @param {Address} args.asset - The address of the asset to get the relative cap limit for.
+ * @param {string} args.amount - The amount of the asset to get the relative cap limit for.
+ * @param {boolean} args.isMint - Whether the transaction is a mint or a redeem.
+ *
+ * @returns {Promise<boolean | undefined>} If the asset is relatively capped.
+ */
+declare function getRelativeCapLimit({ client, asset, amount, isMint, referenceCollateral, ...args }: GetRelativeCapLimitArgs): Promise<boolean | undefined>;
+
+interface GetSwapPayloadReturn {
+    address: Address;
+    abi: Abi;
+    functionName: "mint" | "redeem";
+    params: ContractFunctionArgs<typeof pythWrapperAbi, "payable", "mint" | "redeem"> | ContractFunctionArgs<typeof honeyFactoryAbi, "nonpayable", "mint" | "redeem">;
+    value?: bigint;
+}
+declare const getSwapPayload: ({ state, account, publicClient, priceFeedMap, collateralList, isPythWrapperEnabled, ...args }: BeraJS.BaseFunctionArgs & {
+    state: Pick<IHoneySwapState, "actionType" | "fromAmount" | "collaterals" | "isBasketModeEnabled">;
+    account: Address | undefined;
+    collateralList: TokenWithMetadata[];
+    publicClient: PublicClient | undefined;
+    priceFeedMap?: PythPriceFeedMap;
+    isPythWrapperEnabled: boolean;
+}) => Promise<GetSwapPayloadReturn>;
+
+declare function isBasketModeEnabled({ client, isMint, collateralList, latestPrices, isPythWrapperEnabled, ...args }: {
+    client: PublicClient;
+    isMint: boolean;
+    collateralList: Token[];
+    latestPrices: PythLatestUpdates | undefined;
+    isPythWrapperEnabled: boolean;
+} & BeraJS.BaseFunctionArgs): Promise<boolean | undefined>;
+
+/**
+ * Gets the timestamp of a block or an estimated timestamp if the block is in the future.
+ * @returns
+ */
+declare function getBlockTimestamp({ block, currentBlock, blockTime, publicClient, }: {
+    block: number | bigint | string;
+    currentBlock: number | bigint | string;
+    blockTime: number;
+    publicClient: PublicClient;
+}): Promise<{
+    timestamp: number;
+}>;
+
+declare function getBlockTime({ defaultBlockTime, blocksSpan, ...args }?: {
+    defaultBlockTime?: number;
+    blocksSpan?: number;
+} & BeraJS.BaseFunctionArgs): Promise<number>;
+
+declare function getIncentiveFeeClaimStats({ ...args }: BeraJS.BaseFunctionArgs): Promise<{
+    sumAllClaims: number;
+    sumClaimsInLast24Hours: number;
+}>;
+
+declare function getRewardProofsByValidator({ account, validator, page, perPage, ...args }: {
+    account: Address;
+    validator: Address;
+    page?: number;
+    perPage?: number;
+} & BeraJS.BaseFunctionArgs): Promise<BribeBoostRewardProof>;
+
+/**
+ *
+ * @param address - The address of the vault
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+declare function getRewardTokenToBeraRate({ address, publicClient, }: {
+    address: Address;
+    publicClient?: PublicClient;
+}): Promise<number>;
+
+/**
+ *
+ * @param address - The address of the vault
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+declare function getRewardVault({ address, chainName, ...args }: {
+    address: Address;
+    chainName?: GqlChain$1;
+} & BeraJS.BaseFunctionArgs): Promise<ApiVaultFragment>;
+
+interface RewardVaultDurationConstants {
+    minRewardDuration: number;
+    maxRewardDuration: number;
+}
+/**
+ * Returns the minimum and maximum reward duration constants for all reward vaults.
+ */
+declare function getRewardVaultDurationConstants({ publicClient, ...baseArgs }: BeraJS.BaseFunctionArgs & {
+    publicClient: PublicClient;
+}): Promise<RewardVaultDurationConstants>;
+
+declare function getRewardVaultFromToken({ tokenAddress, publicClient, factoryAddress, ...args }: {
+    tokenAddress: Address;
+    publicClient: PublicClient;
+    factoryAddress?: Address;
+} & BeraJS.BaseFunctionArgs): Promise<`0x${string}` | null>;
+
+declare function getRewardVaultStakingToken({ address, publicClient, }: {
+    address: Address;
+    publicClient: NonNullable<PublicClient>;
+}): Promise<`0x${string}`>;
+
+/**
+ *
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+declare function getStakedBeraAPR({ window, ...args }: {
+    /**
+     * APR might vary depending on the annualized time window (day or week)
+     */
+    window: "DAY" | "WEEK";
+} & BeraJS.BaseFunctionArgs): Promise<number>;
+
+declare function getStakeWithdrawalCooldown({ publicClient, ...args }: {
+    publicClient: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<number>;
+
+interface VaultMetadata {
+    current: {
+        exchangeRate: string;
+        totalSupply: string;
+        totalAssets: string;
+        tvl: string;
+    };
+    previous: {
+        exchangeRate: string;
+        totalSupply: string;
+        totalAssets: string;
+        tvl: string;
+    };
+    totalWBeraIssued: string;
+    lockPeriod?: number;
+    totalBuyBacks: number;
+    totalBuyBacksInLast24Hours: number;
+}
+/**
+ *
+ * @param address - The address of the vault
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+declare function getSWBeraVaultMetadata({ address, publicClient, ...args }: {
+    address: Address;
+    publicClient?: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<VaultMetadata>;
+
+/**
+ * Server-side function to get user claimable incentives grouped by validator
+ */
+declare function getUserClaimableIncentives({ account, ...args }: {
+    account: Address;
+} & BeraJS.BaseFunctionArgs): Promise<BribeBoostRewardItem[] | null>;
+
+interface GetUserVaultInfoParams {
+    account: Address;
+    vaultAddress: Address;
+    publicClient: PublicClient | undefined;
+}
+declare function getUserVaultInfo({ account, vaultAddress, publicClient, }: GetUserVaultInfoParams): Promise<UserVaultInfo>;
+
+interface GetUserVaultsInfo {
+    account: string | undefined;
+    vaultAddress: Address;
+    publicClient: PublicClient | undefined;
+}
+/**
+ * Gets claimable rewards for a user's vault.
+ *
+ * It can also be used to get the claimable fees from the BGT staker
+ * @returns
+ */
+declare function getUserVaultsReward({ account, vaultAddress, publicClient, }: GetUserVaultsInfo): Promise<bigint>;
+
+declare function getVaultValidators({ address, onlyActiveValidators, ...args }: {
+    address: Address;
+    onlyActiveValidators?: boolean;
+} & BeraJS.BaseFunctionArgs): Promise<ApiValidatorFragment[]>;
+
+declare function getTokenCurrentPrices({ addressIn: _addressIn, ...args }: {
+    addressIn: string[];
+} & BeraJS.BaseFunctionArgs): Promise<TokenCurrentPriceMap>;
+
+/**
+ * Given a list of tokens, it will return the price feed ids for each token according to honey priceOracle
+ * @returns
+ */
+declare function getHoneyPythFeeds({ tokenList, publicClient, ...args }: {
+    tokenList: readonly Address$1[];
+    publicClient: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<PythPriceFeedMap>;
+
+declare function getPythUpdateFee({ client, priceFeedId, ...args }: {
+    client: PublicClient;
+    priceFeedId: Address[];
+} & BeraJS.BaseFunctionArgs): Promise<bigint>;
+
+interface GetAllowances {
+    tokens: Token[] | undefined;
+    account: `0x${string}` | undefined;
+    spender: string | undefined;
+    publicClient: PublicClient | undefined;
+}
+type GetAllowancesResponse = AllowanceToken[] | undefined;
+declare function getAllowances({ tokens, account, spender, publicClient, }: GetAllowances): Promise<GetAllowancesResponse>;
+
+interface GetTokenInformation {
+    address: Address;
+    publicClient: PublicClient;
+}
+type GetTokenInformationResponse = MinimalERC20 | undefined;
+declare function getTokenInformation({ address, publicClient, }: GetTokenInformation): Promise<GetTokenInformationResponse>;
+
+declare function getTokens({ url, ...args }?: BeraJS.BaseFunctionArgs & {
+    url?: string;
+}): Promise<TokenWithMetadata[]>;
+
+interface GetWalletBalances {
+    account: string | undefined;
+    tokenList: Token[] | undefined;
+    publicClient: PublicClient | undefined;
+}
+/**
+ * Returns the payload for the balanceOf call for a given token and account.
+ *
+ * @internal
+ * @returns
+ */
+declare function getBalanceCall({ token, account, multicallAddress, }: {
+    token: Token;
+    account: Address;
+    multicallAddress: Address;
+}): {
+    readonly address: `0x${string}`;
+    readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "aggregate";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes[]";
+            readonly name: "returnData";
+            readonly type: "bytes[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "allowFailure";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call3[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "aggregate3";
+        readonly outputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "allowFailure";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "value";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call3Value[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "aggregate3Value";
+        readonly outputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "blockAndAggregate";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getBasefee";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "basefee";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }];
+        readonly name: "getBlockHash";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getBlockNumber";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getChainId";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "chainid";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockCoinbase";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "coinbase";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockDifficulty";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "difficulty";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockGasLimit";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "gaslimit";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockTimestamp";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "timestamp";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "addr";
+            readonly type: "address";
+        }];
+        readonly name: "getEthBalance";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "balance";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getLastBlockHash";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "requireSuccess";
+            readonly type: "bool";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "tryAggregate";
+        readonly outputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "requireSuccess";
+            readonly type: "bool";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "tryBlockAndAggregate";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }];
+    readonly functionName: "getEthBalance";
+    readonly args: readonly [`0x${string}`];
+} | {
+    readonly address: Address;
+    readonly abi: readonly [{
+        readonly type: "event";
+        readonly name: "Approval";
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "event";
+        readonly name: "Transfer";
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "allowance";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "spender";
+            readonly type: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "approve";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "balanceOf";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [{
+            readonly name: "account";
+            readonly type: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "decimals";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "uint8";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "name";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "string";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "symbol";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "string";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "totalSupply";
+        readonly stateMutability: "view";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "transfer";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }, {
+        readonly type: "function";
+        readonly name: "transferFrom";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly type: "bool";
+        }];
+    }];
+    readonly functionName: "balanceOf";
+    readonly args: readonly [`0x${string}`];
+};
+/**
+ * fetch the balances of a given wallet address
+ */
+declare function getWalletBalances({ account, tokenList, publicClient, }: GetWalletBalances): Promise<BalanceToken[] | undefined>;
+
+declare function isImpersonateAccount(chainId?: number): boolean;
+declare function beraWriteContract<abi extends Abi | undefined = undefined, functionName extends abi extends Abi ? ContractFunctionName<abi> : never = abi extends Abi ? ContractFunctionName<abi> : never, params extends abi extends Abi ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName> : never = abi extends Abi ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName> : never>(args: IContractWrite<abi, functionName, params> & {
+    enableSimulateCalls?: boolean;
+    chainId?: number;
+    impersonateAccount?: boolean;
+    /**
+     * The polling interval in milliseconds to fetch the on-chain transaction status
+     * @default 1000 (1 second)
+     */
+    pollingInterval?: number;
+    /**
+     * The timeout in milliseconds to wait for the transaction to be confirmed.
+     * @default 120_000 (2 minutes)
+     */
+    txConfirmationTimeout?: number;
+}): Promise<TransactionReceipt | WalletCallReceipt<bigint, "success" | "reverted"> | undefined>;
+
+interface ActiveBoostAndCommissionChangeDelay {
+    boostDelay: number;
+    unboostDelay: number;
+    commissionChangeDelay: number;
+    rewardAllocationBlockDelay: number;
+    maxWeightPerVault: number;
+    maxNumWeightsPerRewardAllocation: number;
+    /**
+     * Percentage of the validator's commission rate that can be changed at once.
+     *
+     * @example 1 => 100%
+     */
+    maxCommissionRate: number;
+    /**
+     * The number of blocks after which a reward allocation is considered stale and will fallback
+     * to baseline reward allocation.
+     *
+     */
+    rewardAllocationInactivityBlockSpan: number;
+    /**
+     * The number of hours in advance to warn the operator that the reward allocation is expiring.
+     */
+    ui: EdgeConfigSchema["pol"]["automatedRewardAllocation"];
+}
+declare function getActiveBoostAndCommissionChangeDelay({ publicClient, ui, ...args }: BeraJS.BaseFunctionArgs & Pick<ActiveBoostAndCommissionChangeDelay, "ui"> & {
+    publicClient: PublicClient;
+}): Promise<ActiveBoostAndCommissionChangeDelay>;
+
+declare function getAllValidators({ variables, ...args }?: {
+    variables?: GetValidatorsQueryVariables;
+} & BeraJS.BaseFunctionArgs): Promise<GetValidatorsQuery | undefined>;
+
+declare function getApiEnrichedAllocation({ allocation, }: {
+    allocation: ValidatorRewardAllocation;
+}): Promise<ApiRewardAllocationWeightFragment[]>;
+
+declare function getApiValidator({ id, ...args }: {
+    /**
+     * The validator keccak256 pubkey
+     */
+    id: Address;
+} & BeraJS.BaseFunctionArgs): Promise<GetValidatorQuery>;
+
+declare function getDailyValidatorBlockStats({ pubKey, first, ...args }: BeraJS.BaseFunctionArgs & {
+    pubKey: Address;
+    first?: number;
+}): Promise<GetValidatorBlockStatsQuery | undefined>;
+
+declare function isDefaultRewardAllocation(rewardAllocation: ValidatorRewardAllocation): boolean;
+declare function getDefaultRewardAllocation({ client, ...args }: {
+    client: PublicClient;
+}): Promise<ValidatorRewardAllocation>;
+
+declare function getManagedValidatorByAccount({ account, ...args }: BeraJS.BaseFunctionArgs & {
+    account: Address;
+}): Promise<GetValidatorByAccountQuery | undefined>;
+
+/**
+ * Get the current number of BERA in the batch for a validator's staking pool
+ * The batch can contain at most 10K BERA, then the batch will be sent to the contract
+ * @param client - The public client
+ * @param valPubKey - The public key of the validator
+ * @returns The current batch number
+ */
+declare function getStakingPoolBatch({ client, valPubKey, }: {
+    client: PublicClient;
+    valPubKey: `0x${string}`;
+}): Promise<number>;
+
+declare function getValidatorAnalytics({ pubkey, dayRange, ...args }: BeraJS.BaseFunctionArgs & {
+    pubkey: Address;
+    dayRange: number;
+}): Promise<GetValidatorAnalyticsQuery | undefined>;
+
+declare function getValidatorCommission({ client, pubKey, ...args }: {
+    client: PublicClient;
+    pubKey: Address;
+} & BeraJS.BaseFunctionArgs): Promise<number | undefined | null>;
+
+declare const getValidatorEstimatedBgtPerYear: (validator: ApiValidatorMinimalFragment, totalStakedBeraAmount: number, blockTime: number) => number;
+
+declare function getValidatorOperatorAddress({ client, pubKey, ...args }: BeraJS.BaseFunctionArgs & {
+    client: PublicClient;
+    pubKey: Address;
+}): Promise<Address | undefined>;
+
+declare function getValidatorQueuedRewardAllocation({ client, pubKey, ...args }: BeraJS.BaseFunctionArgs & {
+    client: PublicClient;
+    pubKey: Address;
+}): Promise<ValidatorRewardAllocation | undefined>;
+
+declare function getValidatorReturnPerBgt(validator: Pick<ApiValidatorFragment, "dynamicData" | "rewardAllocationWeights">): number;
+declare function getValidatorBoostApy({ validator, bgtPrice, }: {
+    validator: Pick<ApiValidatorFragment, "dynamicData" | "rewardAllocationWeights">;
+    bgtPrice: number;
+}): number;
+
+export { type ActiveBoostAndCommissionChangeDelay, BaseAggregator, type GetAllowances, type GetAllowancesResponse, type GetTokenInformation, type GetTokenInformationResponse, type GetUserVaultInfoParams, type GetUserVaultsInfo, type GetWalletBalances, MOCKED_PROPOSAL_STATUSES, type PoolDayData, PythLatestUpdates, type RewardVaultDurationConstants, ValidatorRewardAllocation, type VaultMetadata, beraWriteContract, checkProposalField, computeActualStatus, getActiveBoostAndCommissionChangeDelay, getAllPools, getAllProposals, getAllValidators, getAllowances, getApiEnrichedAllocation, getApiPool, getApiValidator, getApolloClient, getBalanceCall, getBlockTime, getBlockTimestamp, getBodyErrors, getChartData, getCollateralWeights, getDailyValidatorBlockStats, getDecodedFunctionData, getDefaultRewardAllocation, getGlobalCapLimit, getGlobalLiquidityAndSwapVolume, getHoneyCollaterals, getHoneyGlobalData, getHoneyPausedState, getHoneyPythFeeds, getHoneyPythOracle, getHoneyRootPriceOracle, getIncentiveFeeClaimStats, getManagedValidatorByAccount, getMaxDeposit, getPoolEvents, getPoolHistoricalData, getPoolState, getProposalDetails, getProposalFromTx, getProposalVotes, getPythUpdateFee, getRelativeCapLimit, getRewardProofsByValidator, getRewardTokenToBeraRate, getRewardVault, getRewardVaultDurationConstants, getRewardVaultFromToken, getRewardVaultStakingToken, getSWBeraVaultMetadata, getStakeWithdrawalCooldown, getStakedBeraAPR, getStakingPoolBatch, getSubgraphPool, getSwapPayload, getTokenCurrentPrices, getTokenInformation, getTokens, getUserClaimableIncentives, getUserVaultInfo, getUserVaultsReward, getValidatorAnalytics, getValidatorBoostApy, getValidatorCommission, getValidatorEstimatedBgtPerYear, getValidatorOperatorAddress, getValidatorQueuedRewardAllocation, getValidatorReturnPerBgt, getVaultPausedState, getVaultValidators, getWalletBalances, isBasketModeEnabled, isDefaultRewardAllocation, isImpersonateAccount, parseProposalBody };