@berachain/berajs 0.1.2 → 0.2.1

package/dist/errors/exports.d.ts

@@ -0,0 +1,408 @@
+import { GetPublicClientReturnType } from '@wagmi/core';
+import { PublicClient, Address, TransactionReceipt } from 'viem';
+import { B as BeraError, S as SeverityLevel, I as IBeraErrorArgs } from '../BeraError-_mQdkanr.js';
+export { R as RequestError } from '../RequestError-Dk97z8rm.js';
+import { Hex } from '@berachain-foundation/berancer-sdk';
+import '@apollo/client';
+
+/**
+ * Asserts that a value is defined.
+ * @throws An InvalidArgumentError if the value is undefined or null.
+ */
+declare function assertDefined<T>(
+/**
+ * The value to assert.
+ */
+value: T, 
+/**
+ * The property name.
+ */
+property: string): asserts value is NonNullable<T>;
+/**
+ * Asserts that a value is a PublicClient.
+ * @throws An InvalidArgumentError if the value is undefined or not a PublicClient.
+ */
+declare function assertPublicClient(
+/**
+ * The value to assert.
+ */
+value: // it's important to have both types here because it helps with typescript build performance
+PublicClient | GetPublicClientReturnType | undefined, 
+/**
+ * The property name.
+ */
+property?: string): asserts value is PublicClient;
+/**
+ * Asserts that a value is an address (20 bytes).
+ * @throws An InvalidArgumentError if the value is undefined, null, not a string, or not an address.
+ */
+declare function assertAddress(
+/**
+ * The value to assert.
+ */
+value: string | undefined | null, 
+/**
+ * The property name.
+ */
+property: string): asserts value is Address;
+/**
+ * Asserts that a value is a number greater than 0.
+ * @throws An InvalidArgumentError if the value is undefined, null, not a string or number, or not a number greater than 0.
+ */
+declare function assertAmount(
+/**
+ * The value to assert.
+ */
+value: unknown, 
+/**
+ * The property name.
+ */
+property: string): asserts value is string | number;
+
+interface EventsMap {
+    [event: string]: any;
+}
+interface DefaultEvents extends EventsMap {
+    [event: string]: (...args: any) => void;
+}
+type Unsubscribe = () => void;
+/**
+ * An interface for mixins that expose the `on` function (without the emitter
+ * bound to `this`)
+ *
+ * ```js
+ * import { createEmitter } from '~utils/createEmitter'
+ *
+ * class Ticker implements EmitterMixin<Events> {
+ *   constructor() {
+ *     this.emitter = createEmitter()
+ *   }
+ *   on(...args) {
+ *     return this.emitter.on(...args)
+ *   }
+ *   tick() {
+ *     this.emitter.emit('tick')
+ *   }
+ * }
+ * ```
+ */
+interface EmitterMixin<Events extends EventsMap = DefaultEvents> {
+    on<K extends keyof Events>(event: K, cb: Events[K]): Unsubscribe;
+}
+
+/**
+ * Context passed alongside captured exceptions.
+ * Mirrors the subset of Sentry's CaptureContext that berajs actually uses.
+ */
+interface CaptureContext {
+    level: SeverityLevel;
+    extra?: Record<string, unknown>;
+    tags?: Record<string, string | number | boolean | null | undefined>;
+    fingerprint?: string[];
+    data?: Record<string, unknown>;
+}
+interface ErrorEvent {
+    exception: BeraError;
+    timestamp: number;
+}
+/**
+ * A generic error reporter for berajs.
+ *
+ * Instead of calling Sentry.captureException directly, berajs calls
+ * `BeraMonitoring.captureException()`. Consumer apps subscribe via `.on()` and
+ * forward events to their monitoring provider (Sentry, Datadog, etc.).
+ *
+ * @example
+ * ```ts
+ * // In berajs code:
+ * import { BeraMonitoring } from "~/errors/BeraMonitoring";
+ * BeraMonitoring.captureExceptionException(error);
+ *
+ * // In app instrumentation:
+ * import { BeraMonitoring } from "@berachain/berajs/errors";
+ * BeraMonitoring.on((event) => {
+ *   if (event.type === "exception") {
+ *     Sentry.captureException(event.exception);
+ *   }
+ * });
+ * ```
+ */
+declare const BeraMonitoring: {
+    captureException: (exception: BeraError) => void;
+} & EmitterMixin<{
+    exception: (event: ErrorEvent) => void;
+}>;
+
+/**
+ * Span context passed to tracing handlers.
+ * Compatible with Sentry's StartSpanOptions (name, op, attributes).
+ */
+type SpanContext = {
+    name: string;
+    op: string;
+    attributes: Record<string, string | number | boolean | undefined>;
+};
+/**
+ * A function that wraps a callback in a tracing span.
+ * Compatible with Sentry.startSpan's signature.
+ */
+type StartSpanFn = <T>(context: SpanContext, callback: () => Promise<T>) => Promise<T>;
+/**
+ * A generic span-tracing module for berajs.
+ *
+ * Instead of calling Sentry.startSpan directly, berajs calls
+ * `BeraTracing.startSpan()`. Consumer apps subscribe via `.on("span", handler)`
+ * and forward spans to their tracing provider (Sentry, Datadog, etc.).
+ *
+ * Multiple handlers are supported and chain in registration order:
+ * the first registered handler is the outermost wrapper.
+ *
+ * @example
+ * ```ts
+ * // In berajs code:
+ * import { BeraTracing } from "~/errors/BeraTracing";
+ * const result = await BeraTracing.startSpan(
+ *   { name: "GraphQL query", op: "graphql.query", attributes: {} },
+ *   () => executeQuery(),
+ * );
+ *
+ * // In app instrumentation:
+ * import { BeraTracing } from "@berachain/berajs/errors";
+ * BeraTracing.addSpanHandler(Sentry.startSpan);
+ * ```
+ */
+declare const BeraTracing: {
+    /**
+     * Execute a callback, wrapping it in all registered span handlers.
+     *
+     * Handlers chain so each wraps the next. First registered = outermost wrapper.
+     * If no handlers are registered, the callback is executed directly.
+     */
+    startSpan<T>(context: SpanContext, callback: () => Promise<T>): Promise<T>;
+    /**
+     * Register a span tracing handler.
+     *
+     * @param _event - Must be "span". Exists for API consistency with BeraMonitoring.
+     * @param handler - A StartSpanFn, e.g. Sentry.startSpan.
+     * @returns An unsubscribe function to remove the handler.
+     */
+    addSpanHandler(handler: StartSpanFn): Unsubscribe;
+};
+
+interface MatchedError {
+    /** The error key in the errorMap (e.g. "NOT_ENOUGH_GAS_TOKEN") */
+    key: string;
+    /** The category in the errorMap (e.g. "RPC", "BEX") */
+    category: string;
+    /** The user-friendly display message */
+    errorMSG: string;
+    /** Whether the match was by exact reason (true) or keyword (false) */
+    matchedByReason: boolean;
+}
+/**
+ * Finds the matching error entry in errorMap by reason or message.
+ *
+ * ## Matching priority:
+ * 1. **Exact reason match** (preferred): checks `errorType.reasons` for an exact string match.
+ * 2. **Keyword fallback**: checks `errorType.keywords` for case-insensitive substring matches in `message`.
+ *
+ * @returns The matched error entry with key and category, or null if no match found.
+ */
+declare function findMatchingError({ reason, message, }: {
+    reason?: string | null;
+    message?: string;
+}): MatchedError | null;
+/**
+ * Resolves a user-friendly displayMessage by matching `reason` and `message` against `errorMap.ts`.
+ *
+ * This is the bridge between the automatic reason detection pipeline (parseViemError) and
+ * the user-facing error messages. Called by the BeraError constructor.
+ *
+ * ## Matching priority:
+ * 1. **Exact reason match** (preferred): checks `errorType.reasons` for an exact string match.
+ *    This is the most reliable path — contract revert reasons like "NotEnoughBalance" or "BAL#508"
+ *    are matched deterministically.
+ * 2. **Keyword fallback**: checks `errorType.keywords` for case-insensitive substring matches in `message`.
+ *    Use sparingly — keyword matching can cause false positives (e.g. "InsufficientBalance"
+ *    keyword would also match "InsufficientBalanceToPayPythFee").
+ * 3. **GENERAL_ERROR fallback**: "Something went wrong. Please try again later."
+ *
+ * To ensure new contract errors get good displayMessages, add their reason to `errorMap.ts`.
+ * The reason is auto-detected by parseViemError — you only need to map it to a message here.
+ */
+declare function getErrorMessage({ reason, message, }: {
+    reason?: string | null;
+    message?: string;
+}): string;
+
+interface IInvalidArgumentErrorArgs extends IBeraErrorArgs {
+    /**
+     * The name of the argument that is invalid.
+     */
+    property: string;
+    /**
+     * The value of the argument that is invalid.
+     */
+    value: unknown;
+    /**
+     * The expected type of the value as a string, eg. string, number, boolean, etc.
+     */
+    expected: string;
+}
+/**
+ * Error thrown when argument validation fails. (e.g. an argument is missing or invalid)
+ *
+ * Default level is "warning".
+ *
+ * @example ```ts
+ * if (!publicClient) {
+ *  throw new InvalidArgumentError({
+ *    property: "publicClient",
+ *    value: publicClient,
+ *    expected: "PublicClient",
+ *  });
+ * }
+ * if (!address || !isAddress(address)) {
+ *  throw new InvalidArgumentError({
+ *    property: "address",
+ *    value: address,
+ *    expected: "Address",
+ *  });
+ * }
+ * ```
+ *
+ */
+declare class InvalidArgumentError extends BeraError {
+    /**
+     * The name of the argument that is invalid.
+     */
+    property: string;
+    /**
+     * The value of the argument that is invalid.
+     */
+    value: unknown;
+    /**
+     * The expected value of the argument.
+     */
+    expected: string;
+    constructor(args: IInvalidArgumentErrorArgs);
+    get isMissing(): boolean;
+    /**
+     * Whether the argument is defined but invalid.
+     */
+    get isInvalid(): boolean;
+}
+
+/**
+ * The preferred way to normalize any unknown error into a BeraError.
+ *
+ * This function acts as a smart factory that picks the correct BeraError subclass:
+ *
+ * 1. If `cause` is already a `BeraError`, returns it as-is (no double-wrapping).
+ * 2. If `cause` is a viem `BaseError`, runs `parseViemError` to classify it:
+ *    - If the root cause is an `HttpRequestError` (RPC transport failure), wraps it
+ *      in a `RequestError` with the endpoint URL extracted from the error.
+ * 3. Otherwise, wraps in a new `BeraError` — which triggers the automatic reason
+ *    detection pipeline in the BeraError constructor (parseViemError → errorMap → displayMessage).
+ *
+ * **Use this instead of `new BeraError({ cause })` when you don't know the error type.**
+ * It ensures RequestErrors are correctly classified (important for Sentry filtering
+ * and fingerprinting — RequestErrors are skipped from transaction error grouping).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   // Normalizes to the right subclass, reason auto-detected
+ *   throw initBeraError({ cause: error });
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Reporting to Sentry without rethrowing
+ * catch (error) {
+ *   captureException(initBeraError({ cause: error }));
+ * }
+ * ```
+ */
+declare function initBeraError({ cause: error, level, }: {
+    cause: unknown;
+    /**
+     * The severity level of the error, only used if the error is not a BeraError.
+     */
+    level?: SeverityLevel;
+}): BeraError;
+
+interface INotFoundErrorArgs extends IBeraErrorArgs {
+    resource: string;
+    id: string;
+    chainId: number;
+}
+/**
+ * Error thrown when a resource is not found.
+ */
+declare class NotFoundError extends BeraError {
+    /**
+     * The name of the resource that was not found.
+     *
+     * @example "Reward vault"
+     */
+    resource: string;
+    /**
+     * The id of the resource that was not found.
+     *
+     * @example "0x1234567890123456789012345678901234567890"
+     */
+    id: string;
+    constructor(args: INotFoundErrorArgs);
+}
+
+/**
+ * This error is generally thrown by beraWriteContract when a transaction or simulation fails.
+ */
+declare class TransactionFailedError extends BeraError {
+    /**
+     * The hash of the transaction that failed.
+     *
+     * Null if the error is due to a simulation failure.
+     */
+    txHash: string | null;
+    /**
+     * The receipt of the transaction that failed.
+     *
+     * Null if the error is due to a simulation failure.
+     */
+    receipt: TransactionReceipt | null;
+    /**
+     * The address of the contract that was called.
+     */
+    to: Address | undefined;
+    /**
+     * The data of the transaction that failed.
+     */
+    callData: Hex | undefined;
+    /**
+     * The block number of the transaction that failed.
+     */
+    blockNumber: bigint | null;
+    /**
+     * The input of the transaction that failed.
+     */
+    input: object;
+    /**
+     * The function name of the transaction that failed.
+     */
+    functionName: string | undefined;
+    constructor(args: IBeraErrorArgs & {
+        txHash?: string;
+        receipt?: TransactionReceipt;
+        to?: Address;
+        blockNumber?: bigint;
+        functionName?: string;
+        input: object;
+    });
+}
+
+export { BeraError, BeraMonitoring, BeraTracing, type CaptureContext, type ErrorEvent, IBeraErrorArgs, type IInvalidArgumentErrorArgs, type INotFoundErrorArgs, InvalidArgumentError, type MatchedError, NotFoundError, SeverityLevel, type SpanContext, TransactionFailedError, assertAddress, assertAmount, assertDefined, assertPublicClient, findMatchingError, getErrorMessage, initBeraError };

package/dist/errors/exports.mjs

@@ -0,0 +1,2 @@
+import{a as r,b as v,c as C}from"../chunk-7WRTK7RJ.mjs";import{a as m,b as n,c as y,d as a,e as i,f as e}from"../chunk-2LL3P5PN.mjs";import{a as o,b as t,f as p,g as x,h as f}from"../chunk-AX2YQQFQ.mjs";export{p as BeraError,e as BeraMonitoring,r as BeraTracing,f as InvalidArgumentError,v as NotFoundError,x as RequestError,C as TransactionFailedError,a as assertAddress,i as assertAmount,n as assertDefined,y as assertPublicClient,o as findMatchingError,t as getErrorMessage,m as initBeraError};
+//# sourceMappingURL=exports.mjs.map

package/dist/{getValidatorQueuedOperatorAddress-Ne2zoiiV.d.ts → getValidatorQueuedOperatorAddress-Dstyaomr.d.cts}

@@ -1,8 +1,9 @@
 import { Address, PublicClient, Hex } from 'viem';
-import { GqlPoolType, GlobalDataQuery, ApiVaultFragment, GetVaultsQueryVariables, GqlChain, GqlVaultSnapshotDataRange, GetSWberaVaultSnapshotsQuery, GetVaultHistoryQueryVariables, GetVaultHistoryQuery, ApiValidatorFragment } from '@berachain/graphql/pol/api';
-import { h as TokenBalance, a as Token, P as PythLatestUpdates } from './HoneyConfigProvider-CwDFrt02.js';
-import { P as ProtocolMetadata } from './staking-F9Nx9TKD.js';
-import { GetPublicClientReturnType } from '@wagmi/core';
+import { BeraConfig, ChainId } from '@berachain/config/internal';
+import { I as IAggregatorArgs, g as IRawAggregatorQuote, b as Token, d as HoneyConfigContextReturn, B as BalanceToken, P as PythLatestUpdates } from './HoneyConfigProvider-Ca3ouozs.cjs';
+import { A as Aggregators } from './dex-C_BB0b0O.cjs';
+import { GqlPoolType, GlobalDataQuery, ApiVaultFragment, GetVaultsQueryVariables, GqlChain, GetVaultHistoryQueryVariables, GetVaultHistoryQuery, ApiValidatorFragment } from '@berachain/graphql/pol/api';
+import { P as ProtocolMetadata } from './global.d-CN6l2b9E.cjs';
 
 interface GetConvertToAssetsProps {
     sharesAmount: bigint;
@@ -14,6 +15,90 @@ declare function getConvertToAssets({ sharesAmount, vaultAddress, publicClient,
     formatted: string;
 }>;
 
+declare abstract class BaseAggregator {
+    abstract name: Aggregators;
+    /**
+     * Supported chains for the aggregator.
+     * If null, the aggregator is supported on all chains.
+     */
+    abstract supportedChains: number[] | null;
+    static PATH_NOT_FOUND_REASON: string;
+    needsAccountForQuote: boolean;
+    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 | 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.
+     *
+     * @returns Amount in wad format
+     */
+    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 | null;
+    }): {
+        tokenIn: `0x${string}`;
+        amountIn: bigint;
+        isNative: boolean;
+        isPermit2Approval: boolean;
+        permit2SpenderAddress: `0x${string}`;
+    };
+    /**
+     * Calculate min amount out
+     */
+    protected getMinAmountOut(amountOut: string, slippage: number): bigint;
+    protected parseAllowanceRequirements({ tokenIn, rawAmount, spender, }: {
+        tokenIn: Token;
+        rawAmount: string;
+        spender: Address;
+    }): {
+        token: Token;
+        amount: {
+            raw: string;
+            formatted: string;
+        };
+        spender: `0x${string}`;
+    }[];
+    /**
+     * Check if chain is supported
+     */
+    checkChainSupport({ tokenIn, tokenOut, }: {
+        tokenIn: Token;
+        tokenOut: Token;
+        honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+        underlyingToken?: Token | null;
+    }): boolean;
+    assertChainSupport({ tokenIn, tokenOut, underlyingToken, }: {
+        tokenIn: Token;
+        tokenOut: Token;
+        underlyingToken?: Token | null;
+    }): void;
+    protected fetch(url: string | URL, options?: RequestInit): Promise<Response>;
+}
+
 interface PoolStatus {
     isPoolInRecoveryMode: boolean;
     isPoolPaused: boolean;
@@ -67,7 +152,7 @@ interface GetVaultsBalancesArgs extends BeraJS.BaseFunctionArgs {
     collateralList: Token[];
     honeyFactoryAddress?: Address;
 }
-interface GetHoneyVaultsBalanceResponse extends TokenBalance {
+interface GetHoneyVaultsBalanceResponse extends BalanceToken {
     vault: Address;
 }
 declare function getHoneyVaultsBalance({ client, collateralList, honeyFactoryAddress, ...args }: GetVaultsBalancesArgs): Promise<GetHoneyVaultsBalanceResponse[]>;
@@ -269,24 +354,44 @@ interface GetGaugeData {
 }
 declare function getRewardVaults({ filter, publicClient, ...args }?: {
     filter?: GetVaultsQueryVariables;
-    publicClient?: GetPublicClientReturnType;
+    publicClient?: PublicClient | undefined;
 } & BeraJS.BaseFunctionArgs): Promise<GetGaugeData>;
 
-type GetStakedBeraSnapshotsArgs = {
-    chain?: GqlChain;
-    range?: GqlVaultSnapshotDataRange;
-} & BeraJS.BaseFunctionArgs;
+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 getStakedBeraSnapshots({ chain, range, ...args }?: GetStakedBeraSnapshotsArgs): Promise<GetSWberaVaultSnapshotsQuery["polGetSWberaVaultSnapshots"]>;
+declare function getSWBeraVaultMetadata({ address, publicClient, blockTime, ...args }: {
+    address: Address;
+    publicClient?: PublicClient;
+    blockTime: number;
+} & BeraJS.BaseFunctionArgs): Promise<VaultMetadata>;
 
 /**
  * Interface representing a staked BERA withdrawal request
  */
 interface StakedBeraWithdrawal {
+    receiptTokenAddress: Address;
     withdrawalAmount?: bigint;
     timeRemaining?: string;
     withdrawalRequestId?: bigint;
@@ -304,7 +409,12 @@ interface StakedBeraWithdrawal {
  * @param version - The version of the stake vault contract ("V1" or "V2")
  * @returns Promise resolving to an array of withdrawal request information
  */
-declare function getSWBeraWithdrawal(contractAddress: Address, accountAddress: Address, publicClient: PublicClient, version: "V1" | "V2"): Promise<StakedBeraWithdrawal[]>;
+declare function getSWBeraWithdrawal({ contractAddress, accountAddress, publicClient, version, }: {
+    contractAddress: Address;
+    accountAddress: Address;
+    publicClient: PublicClient;
+    version: "V1" | "V2";
+}): Promise<StakedBeraWithdrawal[]>;
 
 interface UserVault {
     unclaimedBgt: string;
@@ -392,7 +502,7 @@ type UserBoostsOnValidator = {
 declare function getUserBoostsOnValidator({ account, pubkey, publicClient, ...args }: {
     account: Address;
     pubkey: Address;
-    publicClient: GetPublicClientReturnType;
+    publicClient: PublicClient | undefined;
 } & BeraJS.BaseFunctionArgs): Promise<UserBoostsOnValidator>;
 
 type ValidatorWithUserBoost = ApiValidatorFragment & {
@@ -400,7 +510,7 @@ type ValidatorWithUserBoost = ApiValidatorFragment & {
 };
 declare function getUserActiveValidators({ account, publicClient, chain, ...args }: {
     account: string;
-    publicClient?: GetPublicClientReturnType;
+    publicClient?: PublicClient | undefined;
     chain?: GqlChain;
 } & BeraJS.BaseFunctionArgs): Promise<ValidatorWithUserBoost[] | undefined>;
 
@@ -437,4 +547,4 @@ declare function getValidatorQueuedOperatorAddress({ client, pubKey, ...args }:
     pubKey: Address;
 } & BeraJS.BaseFunctionArgs): Promise<ValidatorQueuedOperatorAddress | undefined>;
 
-export { getVaultHistory as A, type ValidatorWithUserBoost as B, getUserActiveValidators as C, type UserBoostsOnValidator as D, getUserBoostsOnValidator as E, type UserStakingPoolPosition as F, type GetConvertToAssetsProps as G, getUserStakingPositions as H, type IsBadCollateralArgs as I, type ValidatorQueuedCommission as J, getValidatorQueuedCommission as K, type ValidatorQueuedOperatorAddress as L, getValidatorQueuedOperatorAddress as M, type ValidatorRewardAllocationRaw as N, type OnChainPool as O, type PoolStatus as P, type ValidatorRewardAllocationUpdate as Q, type RewardVaultIncentive as R, type StakedBeraWithdrawal as S, type ValidatorRewardAllocationUpdateWithExpiration as T, type UserVault as U, type ValidatorRewardAllocation as V, formatValidatorRewardAllocation as W, isSameRewardAllocation as X, getValidatorRewardAllocation as Y, getOnChainPool as a, getPoolPausedState as b, type GetHoneyVaultsBalanceResponse as c, getHoneyVaultsBalance as d, type IsBadCollateralResponse as e, type GetBgtAprSimulationArgs as f, getConvertToAssets as g, type GetBgtAprSimulationResult as h, isBadCollateralAsset as i, getBgtAprSimulation as j, type GlobalData as k, getGlobalData as l, type GetMarkets as m, getMarkets as n, getRewardVaultIncentives as o, RewardVaultDistributionMode as p, type GetRewardVaultRewardsReturn as q, getRewardVaultRewards as r, type GetGaugeData as s, getRewardVaults as t, type GetStakedBeraSnapshotsArgs as u, getStakedBeraSnapshots as v, getSWBeraWithdrawal as w, type GetUserVaultsResponse as x, getUserVaults as y, type GetVaultHistoryArgs as z };
+export { getVaultHistory as A, BaseAggregator as B, type ValidatorWithUserBoost as C, getUserActiveValidators as D, type UserBoostsOnValidator as E, getUserBoostsOnValidator as F, type GetConvertToAssetsProps as G, type UserStakingPoolPosition as H, type IsBadCollateralArgs as I, getUserStakingPositions as J, type ValidatorQueuedCommission as K, getValidatorQueuedCommission as L, type ValidatorQueuedOperatorAddress as M, getValidatorQueuedOperatorAddress as N, type OnChainPool as O, type PoolStatus as P, type ValidatorRewardAllocationRaw as Q, type RewardVaultIncentive as R, type StakedBeraWithdrawal as S, type ValidatorRewardAllocationUpdate as T, type UserVault as U, type ValidatorRewardAllocation as V, type ValidatorRewardAllocationUpdateWithExpiration as W, formatValidatorRewardAllocation as X, isSameRewardAllocation as Y, getValidatorRewardAllocation as Z, getOnChainPool as a, getPoolPausedState as b, type GetHoneyVaultsBalanceResponse as c, getHoneyVaultsBalance as d, type IsBadCollateralResponse as e, type GetBgtAprSimulationArgs as f, getConvertToAssets as g, type GetBgtAprSimulationResult as h, isBadCollateralAsset as i, getBgtAprSimulation as j, type GlobalData as k, getGlobalData as l, type GetMarkets as m, getMarkets as n, getRewardVaultIncentives as o, RewardVaultDistributionMode as p, type GetRewardVaultRewardsReturn as q, getRewardVaultRewards as r, type GetGaugeData as s, getRewardVaults as t, type VaultMetadata as u, getSWBeraVaultMetadata as v, getSWBeraWithdrawal as w, type GetUserVaultsResponse as x, getUserVaults as y, type GetVaultHistoryArgs as z };