@berachain/berajs 0.2.8-beta.9 → 0.2.10

package/dist/chunk-QBBOWFMH.mjs

@@ -0,0 +1,4129 @@
+import {
+  fetchBeep,
+  fetchRailwayBackend
+} from "./chunk-P5WXXULM.mjs";
+import {
+  getApolloClient
+} from "./chunk-3JJLQ2JX.mjs";
+import {
+  pythAbi
+} from "./chunk-CDK4YV3D.mjs";
+import {
+  NotFoundError,
+  TransactionFailedError
+} from "./chunk-AUOPN6NK.mjs";
+import {
+  BeraMonitoring,
+  initBeraError
+} from "./chunk-7YVNSDXG.mjs";
+import {
+  assertAddress,
+  assertDefined,
+  assertPublicClient
+} from "./chunk-GY6B3PD5.mjs";
+import {
+  CAP_LIMIT_BUFFER,
+  DEFAULT_METAMASK_GAS_LIMIT,
+  bignumber_js_default,
+  formatTimeLeft,
+  getPythDefaultUpdateFee,
+  getSafeNumber,
+  getTestClient,
+  msToSeconds,
+  seconds,
+  yearsInSeconds
+} from "./chunk-E7YFXBBQ.mjs";
+import {
+  beraFetch,
+  beraFetchJson,
+  getErrorResponse
+} from "./chunk-Y6THHG77.mjs";
+import {
+  beraToken,
+  getHoneyToken,
+  isToken
+} from "./chunk-IXIBY5FP.mjs";
+import {
+  parseBaseArgs
+} from "./chunk-DQRH5VE3.mjs";
+import {
+  RequestError
+} from "./chunk-ZLTMIFCZ.mjs";
+import {
+  BeraError,
+  InvalidArgumentError,
+  commonAbiErrors,
+  parseDecodedError,
+  parseViemError
+} from "./chunk-KHXJDYA4.mjs";
+
+// src/actions/bend/getConvertToAssets.ts
+import { formatEther } from "viem";
+import { metaMorphoV11Abi as metaMorphoAbi } from "@berachain/abis/bend-metamorpho/metaMorphoV11";
+async function getConvertToAssets({
+  sharesAmount,
+  vaultAddress,
+  publicClient
+}) {
+  const convertToAssets = await publicClient.readContract({
+    address: vaultAddress,
+    abi: metaMorphoAbi,
+    functionName: "convertToAssets",
+    args: [sharesAmount]
+  });
+  return { raw: convertToAssets, formatted: formatEther(convertToAssets) };
+}
+
+// src/actions/dex/aggregators/base.ts
+import { formatUnits, isAddress, zeroAddress } from "viem";
+var BaseAggregator = class _BaseAggregator {
+  static PATH_NOT_FOUND_REASON = "NO_SWAP_PATHS";
+  needsAccountForQuote = false;
+  notFoundMessages = [];
+  config;
+  chainId;
+  constructor(args = {}) {
+    const { config, chainId } = parseBaseArgs(args);
+    this.config = config;
+    this.chainId = chainId;
+  }
+  /**
+   * Identifies the url of the last sent request. Might not have all query params.
+   * Mainly used for error reporting.
+   */
+  url = "";
+  /**
+   * return wbera for native tokens to accomodate the aggregator's router logic
+   */
+  parseAddresses(tokenIn, tokenOut) {
+    if (!isAddress(tokenIn) || !isAddress(tokenOut)) {
+      throw new BeraError({
+        message: `Invalid address: ${tokenIn} or ${tokenOut}`,
+        level: "error"
+      });
+    }
+    return {
+      tokenInAddress: isToken(tokenIn, "BERA") ? this.config.tokens.wbera : tokenIn,
+      tokenOutAddress: isToken(tokenOut, "BERA") ? this.config.tokens.wbera : tokenOut,
+      isTokenInNative: isToken(tokenIn, "BERA"),
+      isTokenOutNative: isToken(tokenOut, "BERA")
+    };
+  }
+  /**
+   * Calculate input amount after fees.
+   *
+   * @returns Amount in wad format
+   */
+  getAmountAfterFees(amount, aggregatorsFeeBps) {
+    if (aggregatorsFeeBps === void 0) {
+      throw new BeraError({
+        message: "aggregatorsFeeBps is required",
+        level: "error"
+      });
+    }
+    const fees = new bignumber_js_default(amount).times(aggregatorsFeeBps).dividedBy(1e4).toFixed(0, bignumber_js_default.ROUND_DOWN);
+    return new bignumber_js_default(amount).minus(fees).toFixed(0, bignumber_js_default.ROUND_DOWN);
+  }
+  /**
+   * Formats input data for aggregator swaps
+   */
+  getInputData({
+    tokenIn,
+    amountIn,
+    isNative,
+    isPermit2Approval = false,
+    permit2SpenderAddress
+  }) {
+    return {
+      tokenIn,
+      amountIn: BigInt(amountIn),
+      isNative,
+      isPermit2Approval,
+      permit2SpenderAddress: permit2SpenderAddress ?? zeroAddress
+    };
+  }
+  /**
+   * Calculate min amount out
+   */
+  getMinAmountOut(amountOut, slippage) {
+    if (slippage === void 0) {
+      throw new BeraError({
+        message: "slippage is required",
+        level: "error"
+      });
+    }
+    const minAmountOut = new bignumber_js_default(amountOut).times(1 - slippage / 100);
+    if (minAmountOut.isNaN() || minAmountOut.isZero()) {
+      return 0n;
+    }
+    return BigInt(minAmountOut.toFixed(0));
+  }
+  parseAllowanceRequirements({
+    tokenIn,
+    rawAmount,
+    spender
+  }) {
+    return isToken(tokenIn, "BERA") ? [] : [
+      {
+        token: tokenIn,
+        amount: {
+          raw: rawAmount,
+          formatted: formatUnits(BigInt(rawAmount), tokenIn.decimals)
+        },
+        spender
+      }
+    ];
+  }
+  /**
+   * Check if chain is supported
+   */
+  checkChainSupport({
+    tokenIn,
+    tokenOut
+  }) {
+    if (this.supportedChains === null) {
+      return true;
+    }
+    return this.supportedChains.includes(tokenIn.chainId) && this.supportedChains.includes(tokenOut.chainId);
+  }
+  assertChainSupport({
+    tokenIn,
+    tokenOut,
+    underlyingToken
+  }) {
+    if (!this.checkChainSupport({ tokenIn, tokenOut, underlyingToken })) {
+      throw new BeraError({
+        message: `${this.name} does not support tokens chain ID: ${tokenIn.chainId} and ${tokenOut.chainId}`,
+        level: "error"
+      });
+    }
+  }
+  async fetch(url, options) {
+    try {
+      return await beraFetch(
+        { url, name: this.name, type: this.type },
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          ...options
+        }
+      );
+    } catch (err) {
+      const error = initBeraError({ cause: err });
+      if (this.notFoundMessages.some((message) => error.message.includes(message))) {
+        error.reason = _BaseAggregator.PATH_NOT_FOUND_REASON;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/actions/dex/b-sdk.ts
+import {
+  API_CHAIN_NAMES,
+  BALANCER_QUERIES,
+  BALANCER_RELAYER,
+  BalancerApi,
+  CHAINS,
+  COMPOSABLE_STABLE_POOL_FACTORY,
+  NATIVE_ASSETS,
+  Token,
+  VAULT,
+  WEIGHTED_POOL_FACTORY_BALANCER_V2
+} from "@berachain-foundation/berancer-sdk";
+import { zeroAddress as zeroAddress2 } from "viem";
+import { berachain, berachainBepolia } from "viem/chains";
+import { chainConfigs } from "@berachain/config/internal";
+for (const chain of Object.keys(chainConfigs)) {
+  const { config, chainId } = parseBaseArgs({
+    chainId: Number(chain)
+  });
+  API_CHAIN_NAMES[chainId] = config.bex.chainName;
+  CHAINS[chainId] = chainId === berachain.id ? berachain : berachainBepolia;
+  BALANCER_RELAYER[chainId] = config.bex.relayer;
+  VAULT[chainId] = config.bex.vault;
+  BALANCER_QUERIES[chainId] = config.bex.queries;
+  WEIGHTED_POOL_FACTORY_BALANCER_V2[chainId] = zeroAddress2;
+  COMPOSABLE_STABLE_POOL_FACTORY[chainId] = zeroAddress2;
+  const nativeToken = new Token(
+    chainId,
+    zeroAddress2,
+    beraToken.decimals,
+    beraToken.name,
+    beraToken.symbol,
+    config.tokens.wbera
+  );
+  NATIVE_ASSETS[chainId] = nativeToken;
+}
+
+// src/actions/dex/getAllPools.ts
+import {
+  GetPools
+} from "@berachain/graphql/dex/api";
+import {
+  GqlPoolOrderBy,
+  GqlPoolOrderDirection
+} from "@berachain/graphql/pol/api";
+async function getAllPools({
+  textSearch,
+  chain,
+  first,
+  orderBy,
+  orderDirection,
+  skip,
+  fetchPolicy,
+  userAddress,
+  blacklistedPoolIds,
+  ...args
+} = {}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const pools = await bexApiGraphqlClient.query({
+    query: GetPools,
+    variables: {
+      textSearch,
+      chain: chain ?? config.bex.chainName,
+      first,
+      orderBy: orderBy ?? GqlPoolOrderBy.TotalLiquidity,
+      orderDirection: orderDirection ?? GqlPoolOrderDirection.Desc,
+      skip,
+      userAddress,
+      blacklistedPoolIds
+    },
+    fetchPolicy
+  });
+  return {
+    pools: pools.data.poolGetPools ?? [],
+    count: pools.data.count ?? 0
+  };
+}
+
+// src/actions/dex/getApiPool.ts
+import {
+  GetPool
+} from "@berachain/graphql/dex/api";
+async function getApiPool({
+  poolId,
+  account,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const pool = await bexApiGraphqlClient.query({
+    query: GetPool,
+    variables: {
+      id: poolId,
+      userAddress: account,
+      chain: config.bex.chainName
+    },
+    fetchPolicy: "no-cache"
+    // If we cache it seems to return an empty response
+  });
+  const data = pool.data.poolGetPool;
+  if (!data) {
+    throw new Error(`Pool not found for id: ${poolId} and user ${account}`);
+  }
+  return data;
+}
+
+// src/actions/dex/getGlobalLiquidityAndSwapVolume.ts
+import {
+  GetGlobalLiquidityAndSwapVolume
+} from "@berachain/graphql/dex/api";
+async function getGlobalLiquidityAndSwapVolume(args = {}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const response = await bexApiGraphqlClient.query({
+    query: GetGlobalLiquidityAndSwapVolume,
+    variables: {
+      chain: config.bex.chainName
+    }
+  });
+  return response.data;
+}
+
+// src/actions/dex/getPoolPausedState.ts
+import { weightedPoolV4Abi_V2 } from "@berachain-foundation/berancer-sdk";
+async function getPoolPausedState({
+  publicClient,
+  poolAddress
+}) {
+  const abi = weightedPoolV4Abi_V2;
+  const results = await publicClient.multicall({
+    contracts: [
+      {
+        address: poolAddress,
+        abi,
+        functionName: "inRecoveryMode"
+      },
+      {
+        address: poolAddress,
+        abi,
+        functionName: "getPausedState"
+      }
+    ],
+    allowFailure: false
+    // NOTE: this disallows partial failures of the multicall
+  });
+  return {
+    isPoolInRecoveryMode: results[0],
+    isPoolPaused: results[1][0]
+  };
+}
+
+// src/actions/dex/getOnChainPool.ts
+import {
+  stablePoolAbi_V3,
+  vaultV2Abi,
+  weightedPoolFactoryAbi_V3,
+  weightedPoolV4Abi_V2 as weightedPoolV4Abi_V22
+} from "@berachain-foundation/berancer-sdk";
+import {
+  erc20Abi,
+  formatEther as formatEther2,
+  formatUnits as formatUnits2,
+  isAddress as isAddress2,
+  isHex
+} from "viem";
+import { GqlPoolType } from "@berachain/graphql/pol/api";
+async function getOnChainPool({
+  poolId,
+  publicClient,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const address = poolId.slice(0, 42);
+  if (!isAddress2(address) || !isHex(poolId)) {
+    throw new InvalidArgumentError({
+      property: "poolId",
+      value: poolId,
+      expected: "Hex"
+    });
+  }
+  try {
+    const [
+      name,
+      poolTokens,
+      totalSupply,
+      swapFee,
+      _version,
+      _decimals,
+      isComposableStable,
+      isWeighted,
+      poolPausedState
+    ] = await Promise.all([
+      publicClient.readContract({
+        address,
+        abi: erc20Abi,
+        functionName: "name"
+      }),
+      publicClient.readContract({
+        address: config.bex.vault,
+        abi: vaultV2Abi,
+        functionName: "getPoolTokens",
+        args: [poolId]
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc20Abi,
+        functionName: "totalSupply"
+      }),
+      publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V22,
+        functionName: "getSwapFeePercentage"
+      }),
+      publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V22,
+        functionName: "version"
+      }),
+      publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V22,
+        functionName: "decimals"
+      }),
+      publicClient.readContract({
+        address: config.bex.factories.composableStable,
+        abi: weightedPoolFactoryAbi_V3,
+        functionName: "isPoolFromFactory",
+        args: [address]
+      }),
+      publicClient.readContract({
+        address: config.bex.factories.weighted,
+        abi: weightedPoolFactoryAbi_V3,
+        functionName: "isPoolFromFactory",
+        args: [address]
+      }),
+      getPoolPausedState({ publicClient, poolAddress: address })
+    ]);
+    const decimals = Number(_decimals);
+    const version = JSON.parse(_version);
+    let virtualSupply;
+    let weights;
+    let amplificationParameter;
+    if (isComposableStable) {
+      [virtualSupply, amplificationParameter] = await Promise.all([
+        publicClient.readContract({
+          address,
+          abi: [
+            {
+              type: "function",
+              name: "getActualSupply",
+              stateMutability: "view",
+              inputs: [],
+              outputs: [
+                {
+                  type: "uint256"
+                }
+              ]
+            }
+          ],
+          functionName: "getActualSupply"
+        }),
+        // NOTE: it is possible to pull this from the subgraph, but not using GqlPoolBase, we'd have to query a specific pool type.
+        publicClient.readContract({
+          address,
+          abi: stablePoolAbi_V3,
+          functionName: "getAmplificationParameter"
+        })
+      ]);
+    } else if (version.name === "WeightedPool") {
+      weights = await publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V22,
+        functionName: "getNormalizedWeights"
+      });
+    }
+    if (!isComposableStable && !isWeighted) {
+      throw new Error(`Pool ${address} is not a valid BEX pool`);
+    }
+    return {
+      name,
+      address,
+      id: poolId,
+      poolTokens: [
+        poolTokens[0],
+        poolTokens[1].map(String),
+        Number(poolTokens[2])
+      ],
+      totalSupply: formatUnits2(virtualSupply ?? totalSupply, decimals),
+      swapFee: formatEther2(swapFee),
+      decimals,
+      weights: weights?.map((weight) => formatEther2(weight)),
+      version,
+      factory: isComposableStable ? config.bex.factories.composableStable : config.bex.factories.weighted,
+      type: isComposableStable ? GqlPoolType.Stable : GqlPoolType.Weighted,
+      amplificationParameter: amplificationParameter ? [
+        // raw value
+        Number(amplificationParameter[0]),
+        // is updating
+        amplificationParameter[1],
+        // precision factor
+        Number(amplificationParameter[2])
+      ] : void 0,
+      pausedState: poolPausedState
+    };
+  } catch (e) {
+    throw initBeraError({ cause: e });
+  }
+}
+
+// src/actions/dex/getPoolEvents.ts
+import {
+  GetPoolEvents
+} from "@berachain/graphql/dex/api";
+async function getPoolEvents({
+  poolId,
+  typeInArray,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const response = await bexApiGraphqlClient.query({
+    query: GetPoolEvents,
+    variables: {
+      poolId,
+      typeIn: typeInArray,
+      chain: config.bex.chainName
+    }
+  });
+  return response.data;
+}
+
+// src/actions/dex/getPoolHistoricalData.ts
+import { isHex as isHex2 } from "viem";
+import {
+  GetPoolHistoricalData
+} from "@berachain/graphql/dex/api";
+async function getPoolHistoricalData({
+  poolId,
+  chain,
+  ...args
+}) {
+  if (!poolId || !isHex2(poolId))
+    throw new InvalidArgumentError({
+      property: "poolId",
+      value: poolId,
+      expected: "hex string"
+    });
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const { data } = await bexApiGraphqlClient.query({
+    query: GetPoolHistoricalData,
+    variables: { poolId, chain }
+  });
+  return data.poolGetSnapshots;
+}
+
+// src/actions/honey/getChartData.ts
+async function getChartData({
+  days
+}) {
+  if (typeof window === "undefined") {
+    throw new BeraError({
+      message: "getChartData is browser-only; call from a Client Component / SWR hook",
+      level: "error"
+    });
+  }
+  const params = new URLSearchParams({ interval: "day", first: String(days) });
+  const honeySnapshots = await beraFetchJson({
+    url: `/api/honey/snapshots?${params}`,
+    name: "honey-snapshots",
+    type: "rest"
+  });
+  return { honeySnapshots };
+}
+
+// src/actions/honey/getCollateralWeights.ts
+import { honeyFactoryAbi } from "@berachain/abis/honey/honeyFactory";
+async function getCollateralWeights({
+  client,
+  collateralList,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const collateralWeights = await client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi,
+      functionName: "getWeights"
+    });
+    const weightsWithAddress = collateralList.reduce(
+      (agg, key, idx) => Object.assign(agg, { [key.address]: collateralWeights[idx] }),
+      {}
+    );
+    return weightsWithAddress;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}
+
+// src/actions/tokens/getTokenInformation.ts
+import { erc20Abi as erc20Abi2 } from "viem";
+async function getTokenInformation({
+  address,
+  publicClient,
+  chainId
+}) {
+  try {
+    assertPublicClient(publicClient);
+    const [decimals, name, symbol] = await Promise.all([
+      publicClient.readContract({
+        address,
+        abi: erc20Abi2,
+        functionName: "decimals"
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc20Abi2,
+        functionName: "name"
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc20Abi2,
+        functionName: "symbol"
+      })
+    ]);
+    return {
+      address,
+      decimals,
+      name,
+      symbol,
+      chainId
+    };
+  } catch (e) {
+    throw initBeraError({ cause: e });
+  }
+}
+
+// src/actions/honey/getHoneyCollaterals.ts
+import { honeyFactoryAbi as honeyFactoryAbi2 } from "@berachain/abis/honey/honeyFactory";
+async function getHoneyCollaterals({
+  client,
+  tokenData,
+  preferredCollateralOrder,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const [amountOfCollaterals, referenceCollateralAddress] = await Promise.all([
+    client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi2,
+      functionName: "numRegisteredAssets"
+    }),
+    client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi2,
+      functionName: "referenceCollateral"
+    })
+  ]);
+  const promiseList = [];
+  for (let i = 0; i < amountOfCollaterals; i++) {
+    promiseList.push(
+      client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi2,
+        functionName: "registeredAssets",
+        args: [BigInt(i)]
+      })
+    );
+  }
+  const collaterals = await Promise.all(promiseList);
+  const collateralsTokens = await Promise.all(
+    collaterals.map((coll) => {
+      const token = tokenData?.find((token2) => isToken(token2, coll));
+      if (token) {
+        return token;
+      }
+      return getTokenInformation({
+        address: coll,
+        chainId: config.chainId,
+        publicClient: client
+      });
+    })
+  );
+  const collateralTokens = collateralsTokens.filter((coll) => !!coll).sort((a, b) => {
+    return collaterals.indexOf(a.address) - collaterals.indexOf(b.address);
+  }).map((coll, idx) => ({
+    ...coll,
+    order: idx
+  }));
+  if (preferredCollateralOrder?.length) {
+    const newCollateralOrder = [];
+    for (const override of preferredCollateralOrder) {
+      const newFirstCollateral = collateralTokens.find(
+        (coll) => isToken(coll.address, override.address)
+      );
+      if (newFirstCollateral) {
+        newCollateralOrder.push(newFirstCollateral);
+        collateralTokens.splice(
+          collateralTokens.indexOf(newFirstCollateral),
+          1
+        );
+      }
+    }
+    collateralTokens.unshift(...newCollateralOrder);
+  }
+  const referenceCollateral = collateralTokens.find(
+    (coll) => isToken(coll, referenceCollateralAddress)
+  );
+  if (!collateralTokens) {
+    throw new Error("Collateral tokens not found");
+  }
+  if (!referenceCollateral) {
+    throw new Error("Reference collateral address not found");
+  }
+  return {
+    collaterals: collateralTokens,
+    referenceCollateral
+  };
+}
+
+// src/actions/honey/isBadCollateralAsset.ts
+import { parseUnits } from "viem";
+import { honeyFactoryAbi as honeyFactoryAbi3 } from "@berachain/abis/honey/honeyFactory";
+import { honeyFactoryReaderAbi } from "@berachain/abis/honey/honeyFactoryReader";
+async function isBadCollateralAsset({
+  client,
+  collateral,
+  latestPrices,
+  isPythWrapperEnabled,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const isBadCollateralCall = client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi3,
+      functionName: "isBadCollateralAsset",
+      args: [collateral.address]
+    });
+    let isPeggedCall = client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi3,
+      functionName: "isPegged",
+      args: [collateral.address]
+    });
+    if (isPythWrapperEnabled && latestPrices) {
+      const prices = latestPrices.prices.map((price) => parseUnits(price, 18));
+      isPeggedCall = client.readContract({
+        address: config.honey.reader,
+        abi: honeyFactoryReaderAbi,
+        functionName: "isPeggedWithPrice",
+        args: [collateral.address, prices[0]]
+      });
+    }
+    const [badCollateralResult, isPeggedResult] = await Promise.all([
+      isBadCollateralCall,
+      isPeggedCall
+    ]);
+    return {
+      isBlacklisted: badCollateralResult,
+      isDepegged: !isPeggedResult
+      // invert the result to get the correct value
+    };
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}
+
+// src/actions/honey/getGlobalCapLimit.ts
+import { parseEther as parseEther2 } from "viem";
+import { honeyFactoryAbi as honeyFactoryAbi5 } from "@berachain/abis/honey/honeyFactory";
+
+// src/actions/honey/getSharesWithoutFees.ts
+import { parseEther } from "viem";
+import { collateralVaultAbi } from "@berachain/abis/honey/collateralVault";
+import { honeyFactoryAbi as honeyFactoryAbi4 } from "@berachain/abis/honey/honeyFactory";
+async function getSharesWithoutFees({
+  client,
+  asset,
+  amount,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const [vault, fees] = await Promise.all([
+      client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi4,
+        functionName: "vaults",
+        args: [asset]
+      }),
+      client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi4,
+        functionName: "collectedFees",
+        args: [config.honey.factory, asset]
+      })
+    ]);
+    const balance = await client.readContract({
+      address: vault,
+      abi: collateralVaultAbi,
+      functionName: "balanceOf",
+      args: [config.honey.factory]
+    });
+    return balance + parseEther(amount ?? "0") - fees;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}
+
+// src/actions/honey/getGlobalCapLimit.ts
+var ONE_HUNDRED_PERCENT = parseEther2("1");
+async function getGlobalCapLimit({
+  client,
+  asset,
+  amount,
+  isMint,
+  isPythWrapperEnabled,
+  latestPrices,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const globalCap = await client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi5,
+      functionName: "globalCap"
+    });
+    if (globalCap >= ONE_HUNDRED_PERCENT) {
+      return false;
+    }
+    const [{ collaterals: registeredAssets }, weights] = await Promise.all([
+      getHoneyCollaterals({
+        client
+      }),
+      getWeights({ client, asset, amount, latestPrices, isPythWrapperEnabled })
+    ]);
+    if (!weights) {
+      return void 0;
+    }
+    for (const idx in weights) {
+      if (isMint && isToken(registeredAssets[idx], asset) || !isMint && isToken(registeredAssets[idx], asset)) {
+        const weight = weights[idx];
+        if (weight > globalCap - CAP_LIMIT_BUFFER) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}
+async function getWeights({
+  client,
+  asset,
+  amount,
+  latestPrices,
+  isPythWrapperEnabled
+}) {
+  const { collaterals: registeredAssets } = await getHoneyCollaterals({
+    client
+  });
+  let sum = 0n;
+  const weights = [];
+  for (const singleAsset of registeredAssets) {
+    const isBad = await isBadCollateralAsset({
+      client,
+      collateral: asset,
+      latestPrices,
+      isPythWrapperEnabled
+    });
+    if (isBad?.isBlacklisted || isBad?.isDepegged) {
+      continue;
+    }
+    const share = await getSharesWithoutFees({
+      client,
+      asset: singleAsset.address,
+      amount: isToken(singleAsset, asset) ? amount : "0"
+    });
+    if (!share) {
+      continue;
+    }
+    sum += share;
+    weights.push(share);
+  }
+  if (sum === 0n) {
+    return weights;
+  }
+  for (const idx in registeredAssets) {
+    weights[idx] = parseEther2(weights[idx].toString()) / sum;
+  }
+  return weights;
+}
+
+// src/actions/honey/getHoney24hVolume.ts
+async function getHoney24hVolume() {
+  if (typeof window === "undefined") {
+    throw new BeraError({
+      message: "getHoney24hVolume is browser-only; call from a Client Component / SWR hook",
+      level: "error"
+    });
+  }
+  const params = new URLSearchParams({ interval: "hour", first: "24" });
+  const snapshots = await beraFetchJson({
+    url: `/api/honey/snapshots?${params}`,
+    name: "honey-snapshots",
+    type: "rest"
+  });
+  return snapshots.reduce(
+    (acc, curr) => new bignumber_js_default(curr.totalVolume).plus(acc),
+    new bignumber_js_default(0)
+  );
+}
+
+// src/actions/honey/getHoneyPreview.ts
+import { parseUnits as parseUnits2 } from "viem";
+import { honeyFactoryReaderAbi as honeyFactoryReaderAbi2 } from "@berachain/abis/honey/honeyFactoryReader";
+var HoneyPreviewMethod = /* @__PURE__ */ ((HoneyPreviewMethod2) => {
+  HoneyPreviewMethod2["Mint"] = "previewMintHoney";
+  HoneyPreviewMethod2["MintWithPrice"] = "previewMintHoneyWithPrices";
+  HoneyPreviewMethod2["RequiredCollateral"] = "previewMintCollaterals";
+  HoneyPreviewMethod2["RequiredCollateralWithPrice"] = "previewMintCollateralsWithPrices";
+  HoneyPreviewMethod2["Redeem"] = "previewRedeemCollaterals";
+  HoneyPreviewMethod2["RedeemWithPrice"] = "previewRedeemCollateralsWithPrices";
+  HoneyPreviewMethod2["HoneyToRedeem"] = "previewRedeemHoney";
+  HoneyPreviewMethod2["HoneyToRedeemWithPrice"] = "previewRedeemHoneyWithPrices";
+  return HoneyPreviewMethod2;
+})(HoneyPreviewMethod || {});
+async function getHoneyPreview({
+  client,
+  collateral,
+  collateralList,
+  amount,
+  method,
+  latestPrices,
+  isPythWrapperEnabled,
+  ...baseArgs
+}) {
+  const { config } = parseBaseArgs(baseArgs);
+  try {
+    const isAmountHoney = method === "previewMintHoney" /* Mint */ || method === "previewRedeemHoney" /* HoneyToRedeem */ || method === "previewMintHoneyWithPrices" /* MintWithPrice */ || method === "previewRedeemHoneyWithPrices" /* HoneyToRedeemWithPrice */;
+    const formattedAmount = parseUnits2(
+      amount,
+      isAmountHoney ? collateral.decimals : 18
+    );
+    let formattedResult;
+    let args = [collateral.address, formattedAmount];
+    if (isPythWrapperEnabled && latestPrices) {
+      const prices = latestPrices.prices.map((price) => parseUnits2(price, 18));
+      args = [collateral.address, formattedAmount, prices];
+    }
+    if (isAmountHoney) {
+      const result = await client.readContract({
+        address: config.honey.reader,
+        abi: honeyFactoryReaderAbi2,
+        functionName: method,
+        args
+      });
+      formattedResult = {
+        collaterals: result[0],
+        honey: result[1]
+      };
+    } else {
+      const result = await client.readContract({
+        address: config.honey.reader,
+        abi: honeyFactoryReaderAbi2,
+        functionName: method,
+        args
+      });
+      formattedResult = {
+        collaterals: result,
+        honey: formattedAmount
+      };
+    }
+    const amountsWithAddress = collateralList.reduce(
+      (agg, key) => {
+        const idx = key.order;
+        if (key.address === collateral.address && formattedResult.collaterals[idx] === BigInt(0)) {
+          return Object.assign(agg, {
+            [key.address]: formattedResult.collaterals[0]
+          });
+        }
+        return Object.assign(agg, {
+          [key.address]: formattedResult.collaterals[idx]
+        });
+      },
+      {}
+    );
+    if (amountsWithAddress[collateral.address] === BigInt(0)) {
+      amountsWithAddress[collateral.address] = formattedResult.collaterals[0];
+    }
+    return {
+      collaterals: amountsWithAddress,
+      honey: formattedResult.honey
+    };
+  } catch (e) {
+    console.log("error", e);
+    throw e;
+  }
+}
+
+// src/actions/honey/getHoneyVaultsBalance.ts
+import { formatUnits as formatUnits3 } from "viem";
+import { collateralVaultAbi as collateralVaultAbi2 } from "@berachain/abis/honey/collateralVault";
+import { honeyFactoryAbi as honeyFactoryAbi6 } from "@berachain/abis/honey/honeyFactory";
+async function getHoneyVaultsBalance({
+  client,
+  collateralList,
+  honeyFactoryAddress,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const factory = honeyFactoryAddress ?? config.honey.factory;
+  const vaults = await Promise.all(
+    collateralList.map(async (coll) => {
+      const vault = await client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi6,
+        functionName: "vaults",
+        args: [coll.address]
+      });
+      const [
+        shares,
+        // this is most likely 0 since we're sending fees to PolFeeCollector
+        // here for future proofing
+        feeShares,
+        // if balance is held in a custodian, we need to return the custodian address
+        [isCustodian, custodianAddress]
+      ] = await Promise.all([
+        client.readContract({
+          address: vault,
+          abi: collateralVaultAbi2,
+          functionName: "balanceOf",
+          args: [factory]
+        }),
+        client.readContract({
+          address: factory,
+          abi: honeyFactoryAbi6,
+          functionName: "collectedAssetFees",
+          args: [coll.address]
+        }),
+        client.readContract({
+          address: vault,
+          abi: collateralVaultAbi2,
+          functionName: "custodyInfo"
+        })
+      ]);
+      const balance = await client.readContract({
+        address: vault,
+        abi: collateralVaultAbi2,
+        functionName: "convertToAssets",
+        args: [shares - feeShares]
+      });
+      return {
+        ...coll,
+        balance: {
+          raw: balance.toString(),
+          formatted: formatUnits3(balance, coll.decimals)
+        },
+        vault: isCustodian ? custodianAddress : vault
+      };
+    })
+  );
+  return vaults;
+}
+
+// src/actions/honey/getPythLatestPrices.ts
+import { HermesClient } from "@pythnetwork/hermes-client";
+import { formatUnits as formatUnits4 } from "viem";
+
+// src/utils/polyfillAbortSignalAny.ts
+function polyfillAbortSignalAny() {
+  if (typeof AbortSignal === "undefined") return;
+  if (typeof AbortSignal.any === "function") return;
+  AbortSignal.any = (signals) => {
+    const controller = new AbortController();
+    for (const signal of signals) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+        return controller.signal;
+      }
+    }
+    const listeners = [];
+    const cleanup = () => {
+      for (let i = 0; i < signals.length; i++) {
+        signals[i].removeEventListener("abort", listeners[i]);
+      }
+    };
+    for (const signal of signals) {
+      const onAbort = () => {
+        if (!controller.signal.aborted) controller.abort(signal.reason);
+        cleanup();
+      };
+      listeners.push(onAbort);
+      signal.addEventListener("abort", onAbort);
+    }
+    return controller.signal;
+  };
+}
+
+// src/actions/honey/getPythLatestPrices.ts
+var pythEndpoint = "https://hermes.pyth.network";
+polyfillAbortSignalAny();
+async function getPythLatestPrices({
+  priceFeedId
+}) {
+  const hermesClient = new HermesClient(pythEndpoint, {});
+  const updates = await hermesClient.getLatestPriceUpdates(priceFeedId, {
+    encoding: "hex",
+    parsed: true
+  });
+  return {
+    calldata: updates.binary.data.map((d) => `0x${d}`),
+    prices: updates.parsed?.flatMap(
+      (p) => formatUnits4(BigInt(p.price.price), p.price.expo * -1)
+    ) ?? []
+  };
+}
+
+// src/actions/honey/getRelativeCapLimit.ts
+import { parseEther as parseEther3 } from "viem";
+import { honeyFactoryAbi as honeyFactoryAbi7 } from "@berachain/abis/honey/honeyFactory";
+async function getRelativeCapLimit({
+  client,
+  asset,
+  amount,
+  isMint,
+  referenceCollateral,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  if (asset === referenceCollateral.address) {
+    return false;
+  }
+  try {
+    const [assetRelativeCap] = await Promise.all([
+      client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi7,
+        functionName: "relativeCap",
+        args: [asset]
+      })
+    ]);
+    const [assetBalance, referenceCollateralBalance] = await Promise.all([
+      getSharesWithoutFees({
+        client,
+        asset,
+        amount: isMint ? amount : void 0
+      }),
+      getSharesWithoutFees({
+        client,
+        asset: referenceCollateral.address,
+        amount: isMint ? void 0 : amount
+      })
+    ]);
+    if (referenceCollateralBalance === 0n) {
+      return assetBalance !== 0n;
+    }
+    const weight = parseEther3((assetBalance ?? 0n).toString()) / (referenceCollateralBalance ?? 0n);
+    if (weight >= assetRelativeCap - CAP_LIMIT_BUFFER) {
+      return true;
+    }
+    return false;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}
+
+// src/actions/pyth/getUpdateFee.ts
+async function getPythUpdateFee({
+  client,
+  priceFeedId,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const result = await client.readContract({
+      address: config.external.pyth,
+      abi: pythAbi,
+      functionName: "getUpdateFee",
+      args: [priceFeedId]
+    });
+    return result;
+  } catch (e) {
+    console.error("getPythUpdateFee", e);
+    throw e;
+  }
+}
+
+// src/actions/honey/getSwapPayload.ts
+import {
+  parseUnits as parseUnits3
+} from "viem";
+import { honeyFactoryAbi as honeyFactoryAbi8 } from "@berachain/abis/honey/honeyFactory";
+import { honeyFactoryPythWrapperAbi as pythWrapperAbi } from "@berachain/abis/honey/honeyFactoryPythWrapper";
+var getSwapPayload = async ({
+  state,
+  publicClient,
+  priceFeedMap,
+  collateralList,
+  isPythWrapperEnabled,
+  ...args
+}) => {
+  const { config } = parseBaseArgs(args);
+  const honeyToken = getHoneyToken(args);
+  const { actionType, fromAmount, collaterals, isBasketModeEnabled: isBasketModeEnabled2 } = state;
+  const destinationContractAddress = isPythWrapperEnabled ? config.honey.pythWrapper : config.honey.factory;
+  const pairMainAddress = collateralList.map((coll) => coll.address);
+  if (fromAmount[0] && !!pairMainAddress.length) {
+    const isMint = actionType === "mint";
+    if (isPythWrapperEnabled && publicClient && priceFeedMap) {
+      const latestPrices = await getPythLatestPrices({
+        priceFeedId: Object.values(priceFeedMap)
+      });
+      const calldata = latestPrices.calldata;
+      let pythUpdateFee = 0n;
+      try {
+        pythUpdateFee = await getPythUpdateFee({
+          client: publicClient,
+          priceFeedId: calldata
+        });
+      } catch {
+        pythUpdateFee = getPythDefaultUpdateFee(collaterals.length);
+      }
+      return ({ account }) => {
+        const pythPayload = [
+          calldata,
+          collaterals[0]?.address,
+          parseUnits3(
+            fromAmount[0],
+            (isMint ? collaterals[0]?.decimals : honeyToken?.decimals) ?? 18
+          ),
+          account,
+          !!isBasketModeEnabled2
+        ];
+        return {
+          address: destinationContractAddress,
+          abi: pythWrapperAbi,
+          functionName: isMint ? "mint" : "redeem",
+          params: pythPayload,
+          value: pythUpdateFee
+        };
+      };
+    }
+    return ({ account }) => {
+      const defaultPayload = [
+        collaterals[0]?.address,
+        parseUnits3(
+          fromAmount[0],
+          (isMint ? collaterals[0]?.decimals : honeyToken?.decimals) ?? 18
+        ),
+        account,
+        !!isBasketModeEnabled2
+      ];
+      return {
+        value: 0n,
+        address: destinationContractAddress,
+        abi: honeyFactoryAbi8,
+        functionName: isMint ? "mint" : "redeem",
+        params: defaultPayload
+      };
+    };
+  }
+  throw new Error("Something went wrong while creating the Honey swap payload");
+};
+
+// src/actions/honey/isBasketModeEnabled.ts
+import { parseUnits as parseUnits4 } from "viem";
+import { honeyFactoryAbi as honeyFactoryAbi9 } from "@berachain/abis/honey/honeyFactory";
+import { honeyFactoryReaderAbi as honeyFactoryReaderAbi3 } from "@berachain/abis/honey/honeyFactoryReader";
+async function isBasketModeEnabled({
+  client,
+  isMint,
+  collateralList,
+  latestPrices,
+  isPythWrapperEnabled,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  if (isPythWrapperEnabled && latestPrices) {
+    if (collateralList.length === 0) return void 0;
+    const prices = latestPrices.prices.map((price) => parseUnits4(price, 18));
+    const isActive2 = await client.readContract({
+      address: config.honey.reader,
+      abi: honeyFactoryReaderAbi3,
+      functionName: "isBasketModeEnabledWithPrices",
+      args: [isMint, prices]
+    });
+    return isActive2;
+  }
+  const isActive = await client.readContract({
+    address: config.honey.factory,
+    abi: honeyFactoryAbi9,
+    functionName: "isBasketModeEnabled",
+    args: [isMint]
+  });
+  return isActive;
+}
+
+// src/actions/misc/getBlockTimestamp.ts
+async function getBlockTimestamp({
+  block,
+  currentBlock,
+  blockTime,
+  publicClient
+}) {
+  assertDefined(block, "block");
+  assertPublicClient(publicClient);
+  if (currentBlock > block) {
+    const blockData = await publicClient.getBlock({
+      blockNumber: BigInt(block),
+      includeTransactions: false
+    });
+    return {
+      timestamp: Number(blockData.timestamp)
+    };
+  }
+  const ts = msToSeconds(Date.now()) + blockTime * (Number(block) - Number(currentBlock));
+  return {
+    timestamp: ts
+  };
+}
+
+// src/actions/pol/getAutoclaimedIncentives.ts
+async function getAutoclaimedIncentives({
+  account,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    return await beraFetchJson(
+      {
+        url: `${config.pol.bribeBoostApi}/api/v1/wallets/${account.toLowerCase()}/autoclaimed`,
+        name: "pol-autoclaimed-incentives",
+        type: "rest"
+      },
+      { cache: "no-store" }
+    );
+  } catch (error) {
+    if (error instanceof RequestError && error.statusCode === 404) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/actions/pol/getAutoclaimedIncentivesTxHash.ts
+async function getAutoclaimedIncentivesTxHash({
+  account,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    return await beraFetchJson(
+      {
+        url: `${config.pol.bribeBoostApi}/api/v1/wallets/${account.toLowerCase()}/autoclaimed/txhash`,
+        name: "pol-autoclaimed-incentives-txhash",
+        type: "rest"
+      },
+      { cache: "no-store" }
+    );
+  } catch (error) {
+    if (error instanceof RequestError && error.statusCode === 404) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/actions/pol/getRewardVaultRewards.ts
+import { formatUnits as formatUnits5 } from "viem";
+import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
+var RewardVaultDistributionMode = /* @__PURE__ */ ((RewardVaultDistributionMode2) => {
+  RewardVaultDistributionMode2["Duration"] = "duration";
+  RewardVaultDistributionMode2["TargetRate"] = "targetRate";
+  RewardVaultDistributionMode2["TargetApr"] = "targetApr";
+  return RewardVaultDistributionMode2;
+})(RewardVaultDistributionMode || {});
+async function getRewardVaultRewards(address, publicClient) {
+  const [
+    rewardsDuration,
+    manager,
+    rewardRate,
+    periodFinish,
+    targetRewardsPerSecond,
+    minRewardDurationForTargetRate
+  ] = await Promise.all([
+    publicClient.readContract({
+      address,
+      abi: rewardVaultAbi,
+      functionName: "rewardsDuration"
+    }),
+    publicClient.readContract({
+      address,
+      abi: rewardVaultAbi,
+      functionName: "rewardVaultManager"
+    }),
+    publicClient.readContract({
+      address,
+      abi: rewardVaultAbi,
+      functionName: "rewardRate"
+    }),
+    publicClient.readContract({
+      address,
+      abi: rewardVaultAbi,
+      functionName: "periodFinish"
+    }),
+    publicClient.readContract({
+      address,
+      abi: rewardVaultAbi,
+      functionName: "targetRewardsPerSecond"
+    }),
+    publicClient.readContract({
+      address,
+      abi: rewardVaultAbi,
+      functionName: "minRewardDurationForTargetRate"
+    })
+  ]);
+  const availableRewards = rewardRate * (periodFinish - BigInt(msToSeconds(Date.now()))) / 10n ** 18n;
+  return {
+    rewardsDuration: Number(rewardsDuration),
+    mode: targetRewardsPerSecond === 0n ? "duration" /* Duration */ : "targetRate" /* TargetRate */,
+    manager,
+    // 36 decimals for the reward rate
+    rewardRate: formatUnits5(rewardRate, 36),
+    periodFinish: Number(periodFinish),
+    // 36 decimals for the reward rate
+    availableRewards: formatUnits5(availableRewards, 18),
+    minRewardDurationForTargetRate: Number(minRewardDurationForTargetRate),
+    targetRewardsPerSecond: formatUnits5(targetRewardsPerSecond, 36)
+  };
+}
+
+// src/actions/pol/getBgtAprSimulation.ts
+function _getApr(tvl, bgtPrice, rewardRate) {
+  return tvl ? rewardRate * bgtPrice * yearsInSeconds(1) / tvl : null;
+}
+function _getRewardRate(apr, bgtPrice, tvl) {
+  return tvl ? apr * tvl / (bgtPrice * yearsInSeconds(1)) : 0;
+}
+function getBgtAprSimulation({
+  availableRewards,
+  periodFinish,
+  tvl,
+  bgtPrice,
+  MIN_REWARD_DURATION,
+  MAX_REWARD_DURATION,
+  ...args
+}) {
+  const currentTime = msToSeconds(Date.now());
+  if (currentTime > periodFinish) {
+    return {
+      apr: 0,
+      duration: 0,
+      rewardRate: 0,
+      targetRate: null,
+      periodFinish: 0,
+      mode: null
+    };
+  }
+  if (args.mode === "targetRate" || args.mode === "targetApr") {
+    let rewardRate;
+    const {
+      minRewardDurationForTargetRate: _providedMinRewardDurationForTargetRate,
+      currentDuration
+    } = args;
+    if (args.mode === "targetRate") {
+      rewardRate = args.rewardRate;
+    } else {
+      rewardRate = _getRewardRate(args.apr, bgtPrice, tvl);
+    }
+    if (rewardRate === 0) {
+      const newDuration = Math.min(currentDuration, MAX_REWARD_DURATION);
+      const rewardRate2 = availableRewards ? availableRewards / newDuration : 0;
+      return {
+        apr: _getApr(tvl, bgtPrice, rewardRate2),
+        // When switching to duration mode, the current duration will be used if it's in the allowed range.
+        // Current duration on chain can never be lower than MIN_REWARD_DURATION, so we just check the max.
+        duration: newDuration,
+        rewardRate: rewardRate2,
+        targetRate: null,
+        periodFinish: newDuration + currentTime,
+        mode: "duration" /* Duration */
+      };
+    }
+    const minRewardDurationForTargetRate = (
+      // minRewardDurationForTargetRate might be zero the first time the target rate is set.
+      // If it's not set, we use the max reward duration.
+      _providedMinRewardDurationForTargetRate || MIN_REWARD_DURATION
+    );
+    const duration2 = availableRewards ? availableRewards / rewardRate : 0;
+    if (duration2 < minRewardDurationForTargetRate) {
+      const rewardRate2 = availableRewards ? availableRewards / minRewardDurationForTargetRate : 0;
+      return {
+        apr: _getApr(tvl, bgtPrice, rewardRate2),
+        duration: minRewardDurationForTargetRate,
+        rewardRate: rewardRate2,
+        targetRate: rewardRate2.toString(),
+        periodFinish: minRewardDurationForTargetRate + currentTime,
+        mode: null
+      };
+    }
+    return {
+      apr: _getApr(tvl, bgtPrice, rewardRate),
+      duration: duration2,
+      rewardRate,
+      targetRate: rewardRate.toString(),
+      periodFinish: duration2 + currentTime,
+      mode: null
+    };
+  }
+  const { duration } = args;
+  const newRewardRate = availableRewards / duration;
+  const apr = _getApr(tvl, bgtPrice, newRewardRate);
+  return {
+    apr,
+    mode: null,
+    targetRate: null,
+    duration,
+    rewardRate: newRewardRate,
+    periodFinish: duration + currentTime
+  };
+}
+
+// src/actions/pol/getEarnedStakedBeraVault.ts
+async function getEarnedStakedBeraVault({
+  address,
+  account,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  if (!config.beep) {
+    return fetchRailwayBackend(
+      "/vaults/{vault}/earnings/{owner}",
+      { path: { vault: address, owner: account } },
+      args
+    );
+  }
+  return fetchBeep(
+    "/v0/stake/{vault}/earnings/{owner}",
+    { path: { vault: address, owner: account } },
+    args
+  );
+}
+
+// src/actions/pol/getRewardVaults.ts
+import { formatUnits as formatUnits6 } from "viem";
+import { rewardVaultAbi as rewardVaultAbi2 } from "@berachain/abis/pol/rewards/rewardVault";
+import {
+  GetVaults
+} from "@berachain/graphql/pol/api";
+async function getRewardVaults({
+  filter,
+  publicClient,
+  ...args
+} = {}) {
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const res = await bexApiGraphqlClient.query({
+    query: GetVaults,
+    variables: filter
+  });
+  const incentives = await Promise.allSettled(
+    res.data.polGetRewardVaults.vaults.map(async (vault) => {
+      if (!publicClient) return void 0;
+      return Promise.allSettled(
+        vault.activeIncentives.map(
+          (incentive) => publicClient.readContract({
+            abi: rewardVaultAbi2,
+            address: vault.address,
+            functionName: "incentives",
+            args: [incentive.tokenAddress]
+          })
+        )
+      );
+    })
+  );
+  const vaults = res.data.polGetRewardVaults.vaults.map((vault, index) => {
+    let totalIncentiveInUsdc = 0;
+    const incentivesArray = vault.activeIncentives.map((apiIncentive, incIdx) => {
+      const tokenPrice = Number(apiIncentive.remainingAmountUsd) && Number(apiIncentive.remainingAmount) ? Number(apiIncentive.remainingAmountUsd) / Number(apiIncentive.remainingAmount) : 0;
+      const remainingAmount = incentives[index]?.status === "fulfilled" && incentives[index]?.value?.[incIdx]?.status === "fulfilled" ? formatUnits6(
+        BigInt(incentives[index].value[incIdx].value[2]),
+        apiIncentive.token.decimals
+      ) : apiIncentive.remainingAmount;
+      totalIncentiveInUsdc += Number(remainingAmount) * Number(tokenPrice);
+      return {
+        ...apiIncentive,
+        remainingAmount
+      };
+    });
+    return {
+      ...vault,
+      dynamicData: {
+        ...vault.dynamicData,
+        allTimeRewards: vault.dynamicData?.allTimeRewards ?? "0",
+        rewardCapturePercentage: vault.dynamicData?.rewardCapturePercentage ?? 0,
+        activeIncentivesValueUsd: totalIncentiveInUsdc.toString(),
+        activeIncentivesRateUsd: vault.dynamicData?.activeIncentivesRateUsd ?? "0",
+        rewardCapturePerBlock: vault.dynamicData?.rewardCapturePerBlock ?? 0
+      },
+      activeIncentives: incentivesArray
+    };
+  });
+  return {
+    pagination: res.data.polGetRewardVaults.pagination,
+    gaugeList: vaults
+  };
+}
+
+// src/actions/pol/getBGTGlobalInfo.ts
+import {
+  GlobalData
+} from "@berachain/graphql/pol/api";
+async function getBGTGlobalInfo(args = {}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const apiRes = await bexApiGraphqlClient.query({
+    query: GlobalData,
+    variables: {
+      chain: config.bex.chainName
+    }
+  });
+  const data = apiRes.data;
+  return {
+    ...data.polGetGlobalInfo,
+    top3EmittingValidators: apiRes.data.top3EmittingValidators.validators,
+    allValidatorsCount: apiRes.data.allValidatorsCount.pagination.totalCount
+  };
+}
+
+// src/actions/pol/getBgtTokenTotalBoosts.ts
+import { formatEther as formatEther3 } from "viem";
+import { bgtAbi } from "@berachain/abis/pol/bgt";
+async function getBgtTokenTotalBoosts({
+  publicClient,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  assertPublicClient(publicClient);
+  try {
+    const result = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi,
+      functionName: "totalBoosts",
+      args: []
+    });
+    return formatEther3(result);
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getBgtTokenTotalSupply.ts
+import { erc20Abi as erc20Abi3, formatEther as formatEther4 } from "viem";
+async function getBgtTokenTotalSupply({
+  publicClient,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  assertPublicClient(publicClient);
+  try {
+    const result = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: erc20Abi3,
+      functionName: "totalSupply",
+      args: []
+    });
+    return formatEther4(result ?? 0n);
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getGlobalCuttingBoard.ts
+import {
+  GqlRewardVaultOrderBy,
+  GqlRewardVaultOrderDirection
+} from "@berachain/graphql/pol/api";
+async function getGlobalCuttingBoard(threshold) {
+  const { gaugeList } = await getRewardVaults({
+    filter: {
+      // TODO sort by bgt capture percentage
+      orderBy: GqlRewardVaultOrderBy.Apr,
+      orderDirection: GqlRewardVaultOrderDirection.Desc,
+      pageSize: threshold,
+      where: {
+        includeNonWhitelisted: false
+      }
+    }
+  });
+  return gaugeList;
+}
+
+// src/actions/pol/getGlobalData.ts
+async function getGlobalData(publicClient) {
+  const [
+    globalDataRes,
+    globalCuttingBoardRes,
+    bgtTotalSupplyRes,
+    bgtTotalBoostsRes
+  ] = await Promise.allSettled([
+    getBGTGlobalInfo(),
+    getGlobalCuttingBoard(300),
+    getBgtTokenTotalSupply({
+      publicClient
+    }),
+    getBgtTokenTotalBoosts({
+      publicClient
+    })
+  ]);
+  if (globalDataRes.status === "rejected") {
+    BeraMonitoring.captureException(
+      initBeraError({ cause: globalDataRes.reason, level: "warning" })
+    );
+  }
+  if (globalCuttingBoardRes.status === "rejected") {
+    BeraMonitoring.captureException(
+      initBeraError({ cause: globalCuttingBoardRes.reason, level: "warning" })
+    );
+  }
+  if (bgtTotalSupplyRes.status === "rejected") {
+    BeraMonitoring.captureException(
+      initBeraError({ cause: bgtTotalSupplyRes.reason, level: "warning" })
+    );
+  }
+  if (bgtTotalBoostsRes.status === "rejected") {
+    BeraMonitoring.captureException(
+      initBeraError({ cause: bgtTotalBoostsRes.reason, level: "warning" })
+    );
+  }
+  return {
+    bgtTotalSupply: bgtTotalSupplyRes.status === "fulfilled" ? bgtTotalSupplyRes.value : void 0,
+    globalCuttingBoard: globalCuttingBoardRes.status === "fulfilled" ? globalCuttingBoardRes.value : [],
+    bgtTotalBoosts: bgtTotalBoostsRes.status === "fulfilled" ? bgtTotalBoostsRes.value : void 0,
+    ...globalDataRes.status === "fulfilled" ? globalDataRes.value : {}
+  };
+}
+
+// src/actions/pol/getIncentiveFeeClaimStats.ts
+async function getIncentiveFeeClaimStats() {
+  if (typeof window === "undefined") {
+    throw new BeraError({
+      message: "getIncentiveFeeClaimStats is browser-only; call from a Client Component / SWR hook",
+      level: "error"
+    });
+  }
+  return beraFetchJson({
+    url: "/api/pol/incentive-fee-claims",
+    name: "pol-incentive-fee-claims",
+    type: "rest"
+  });
+}
+
+// src/actions/pol/getMarkets.ts
+async function getMarkets(args = {}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const markets = await fetch(config.lists.rewardVaultList);
+    const temp = await markets.json();
+    if (!temp.protocols) {
+      throw new Error("Missing protocols in market list");
+    }
+    return {
+      marketList: temp.protocols,
+      marketDictionary: temp.protocols.reduce(
+        (acc, item) => {
+          acc[item.name] = item;
+          return acc;
+        },
+        {}
+      )
+    };
+  } catch (error) {
+    console.error("Error fetching validator information", error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getRewardProofsByValidator.ts
+async function getRewardProofsByValidator({
+  account,
+  validator,
+  page = 1,
+  perPage = 1e3,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const result = await fetch(
+    `${config.pol.bribeBoostApi}/api/v1/wallets/${account.toLowerCase()}/proofs/validator/${validator.toLowerCase()}?page=${page}&per_page=${perPage}`,
+    {
+      cache: "no-store"
+    }
+  );
+  if (!result.ok) {
+    const error = await getErrorResponse(result);
+    throw new BeraError({
+      message: "Failed to fetch proofs on server",
+      cause: {
+        error,
+        result,
+        account,
+        validator
+      },
+      reason: error?.reason
+    });
+  }
+  const data = await result.json();
+  return data;
+}
+
+// src/actions/pol/getRewardTokenToBeraRate.ts
+import { formatUnits as formatUnits7, parseUnits as parseUnits5 } from "viem";
+import { wberaStakerVaultAbi as stakeBeraVaultAbi } from "@berachain/abis/pol/wberaStakerVault";
+async function getRewardTokenToBeraRate({
+  address,
+  publicClient
+}) {
+  assertPublicClient(publicClient);
+  return publicClient.readContract({
+    address,
+    abi: stakeBeraVaultAbi,
+    functionName: "previewRedeem",
+    args: [parseUnits5("1", 18)]
+  }).then((rate) => Number(formatUnits7(rate, 18))).catch(() => 0);
+}
+
+// src/actions/pol/getRewardVault.ts
+import {
+  GetRewardVault
+} from "@berachain/graphql/pol/api";
+async function getRewardVault({
+  address,
+  chainName,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const resolvedChainName = chainName ?? config.bex.chainName;
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const { data } = await bexApiGraphqlClient.query({
+    query: GetRewardVault,
+    variables: {
+      vaultId: address,
+      chain: resolvedChainName
+    }
+  });
+  if (!data?.rewardVault) {
+    throw new NotFoundError({
+      resource: "Reward vault",
+      id: address,
+      chainId: config.chainId
+    });
+  }
+  return data.rewardVault;
+}
+
+// src/actions/pol/getRewardVaultIncentives.ts
+import { isSameAddress } from "@berachain-foundation/berancer-sdk";
+import {
+  erc20Abi as erc20Abi4,
+  formatUnits as formatUnits8
+} from "viem";
+import { rewardVaultAbi as rewardVaultAbi3 } from "@berachain/abis/pol/rewards/rewardVault";
+function multicallResult(result, fallback) {
+  return result.status === "success" ? result.result : fallback;
+}
+async function getRewardVaultIncentives({
+  address,
+  stakingToken,
+  publicClient
+}) {
+  const whitelistedTokens = await publicClient.readContract({
+    address,
+    abi: rewardVaultAbi3,
+    functionName: "getWhitelistedTokens"
+  });
+  const hasStakingTokenAsIncentiveToken = whitelistedTokens.findIndex(
+    (token) => isSameAddress(stakingToken, token)
+  ) !== -1;
+  const totalSupply = hasStakingTokenAsIncentiveToken ? await publicClient.readContract({
+    address,
+    abi: rewardVaultAbi3,
+    functionName: "totalSupply"
+  }) : 0n;
+  const incentives = await Promise.allSettled(
+    whitelistedTokens.map(async (token) => {
+      const [incentiveInfo, decimals, name, symbol, totalBalance] = await publicClient.multicall({
+        allowFailure: true,
+        contracts: [
+          {
+            address,
+            abi: rewardVaultAbi3,
+            functionName: "incentives",
+            args: [token]
+          },
+          {
+            address: token,
+            abi: erc20Abi4,
+            functionName: "decimals"
+          },
+          {
+            address: token,
+            abi: erc20Abi4,
+            functionName: "name"
+          },
+          {
+            address: token,
+            abi: erc20Abi4,
+            functionName: "symbol"
+          },
+          {
+            address: token,
+            abi: erc20Abi4,
+            functionName: "balanceOf",
+            args: [address]
+          }
+        ]
+      });
+      if (incentiveInfo.status === "failure") {
+        throw new BeraError({
+          cause: incentiveInfo.error,
+          message: "Failed to get incentive info. This is not possible.",
+          level: "error",
+          extra: {
+            token,
+            address
+          }
+        });
+      }
+      const [minIncentiveRate, incentiveRate, remainingAmount, manager] = incentiveInfo.result;
+      const decimalsResult = multicallResult(decimals, 18);
+      return {
+        token,
+        manager,
+        minIncentiveRate: formatUnits8(minIncentiveRate, decimalsResult),
+        incentiveRate: formatUnits8(incentiveRate, decimalsResult),
+        remainingAmount: formatUnits8(remainingAmount, decimalsResult),
+        name: multicallResult(name, void 0),
+        symbol: multicallResult(symbol, void 0),
+        decimals: decimalsResult,
+        pendingAmount: isSameAddress(stakingToken, token) ? formatUnits8(
+          multicallResult(totalBalance, 0n) - totalSupply - remainingAmount,
+          decimalsResult
+        ) : formatUnits8(
+          multicallResult(totalBalance, 0n) - remainingAmount,
+          decimalsResult
+        )
+      };
+    })
+  );
+  incentives.forEach((result, index) => {
+    if (result.status === "rejected") {
+      BeraMonitoring.captureException(
+        new BeraError({
+          reason: result.reason,
+          message: "Incorrect incentives token received.",
+          level: "error",
+          extra: {
+            token: whitelistedTokens[index],
+            address,
+            error: result.reason
+          }
+        })
+      );
+    }
+  });
+  return incentives.map((result) => result.status === "fulfilled" ? result.value : null).filter((incentive) => incentive !== null);
+}
+
+// src/actions/pol/getRewardVaultStakingToken.ts
+import { rewardVaultAbi as rewardVaultAbi4 } from "@berachain/abis/pol/rewards/rewardVault";
+async function getRewardVaultStakingToken({
+  address,
+  publicClient
+}) {
+  const vaultAddress = await publicClient.readContract({
+    address,
+    abi: rewardVaultAbi4,
+    functionName: "stakeToken"
+  });
+  return vaultAddress;
+}
+
+// src/actions/pol/getStakedBeraAPR.ts
+import {
+  GetSWberaVaultMetadata,
+  GqlSWberaVaultMetadataResolution
+} from "@berachain/graphql/pol/api";
+function getResolution(window2) {
+  if (window2 === "DAY") {
+    return GqlSWberaVaultMetadataResolution.OneDay;
+  }
+  return GqlSWberaVaultMetadataResolution.SevenDays;
+}
+async function getStakedBeraAPR({
+  window: window2,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  try {
+    const data = await bexApiGraphqlClient.query({
+      query: GetSWberaVaultMetadata,
+      variables: {
+        chain: config.bex.chainName,
+        resolution: getResolution(window2 ?? "DAY")
+      }
+    });
+    const { apr } = data.data.polGetSWberaVaultMetadata;
+    return Number(apr);
+  } catch (error) {
+    console.error("Failed to get SW Bera APR", error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getStakedBeraSnapshots.ts
+import {
+  GetSWberaVaultSnapshots,
+  GqlVaultSnapshotDataRange
+} from "@berachain/graphql/pol/api";
+async function getStakedBeraSnapshots({
+  chain,
+  range = GqlVaultSnapshotDataRange.ThirtyDays,
+  ...args
+} = {}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  try {
+    const data = await bexApiGraphqlClient.query({
+      query: GetSWberaVaultSnapshots,
+      variables: {
+        chain: chain ?? config.bex.chainName,
+        range
+      }
+    });
+    return data.data.polGetSWberaVaultSnapshots;
+  } catch (error) {
+    console.error("Failed to get SW Bera Snapshots", error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getStakeWithdrawalCooldown.ts
+import { wberaStakerVaultAbi as stakeBeraVaultAbi2 } from "@berachain/abis/pol/wberaStakerVault";
+async function getStakeWithdrawalCooldown({
+  publicClient,
+  address
+}) {
+  const lockPeriod = await publicClient.readContract({
+    address,
+    abi: stakeBeraVaultAbi2,
+    functionName: "WITHDRAWAL_COOLDOWN"
+  });
+  return Number(lockPeriod);
+}
+
+// src/actions/pol/getSWBeraVaultMetadata.ts
+import { erc20Abi as erc20Abi5, erc4626Abi } from "viem";
+async function getSWBeraVaultMetadata({
+  address,
+  underlyingAsset,
+  publicClient,
+  blockTime
+}) {
+  assertPublicClient(publicClient);
+  const hoursWindow = 26;
+  try {
+    const currentBlock = await publicClient.getBlock({ blockTag: "latest" });
+    const blocksPerWindow = Math.floor(hoursWindow * 60 * 60 / blockTime);
+    const blockWindowAgo = currentBlock.number - BigInt(blocksPerWindow);
+    const [
+      curretTotalAssets,
+      currentTotalSupply,
+      currentOneShareWorth,
+      currentTVL,
+      totalAssets24HoursAgo,
+      totalSupply24HoursAgo,
+      oneShareWorthWindowAgo,
+      tvl24HoursAgo,
+      underlyingTotalSupply,
+      lockPeriod,
+      incentiveFeeClaimStats
+    ] = await Promise.all([
+      publicClient.readContract({
+        address,
+        abi: erc4626Abi,
+        functionName: "totalAssets"
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc4626Abi,
+        functionName: "totalSupply"
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc4626Abi,
+        functionName: "previewRedeem",
+        args: [10n ** 18n],
+        blockNumber: currentBlock.number
+      }),
+      publicClient.readContract({
+        address: underlyingAsset,
+        abi: erc20Abi5,
+        functionName: "balanceOf",
+        args: [address]
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc4626Abi,
+        functionName: "totalAssets",
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc20Abi5,
+        functionName: "totalSupply",
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc4626Abi,
+        functionName: "previewRedeem",
+        args: [10n ** 18n],
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address: underlyingAsset,
+        abi: erc20Abi5,
+        functionName: "balanceOf",
+        args: [address],
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address: underlyingAsset,
+        abi: erc20Abi5,
+        functionName: "totalSupply"
+      }),
+      getStakeWithdrawalCooldown({
+        publicClient,
+        address
+      }),
+      getIncentiveFeeClaimStats()
+    ]);
+    const exchangeRateWindowAgo = new bignumber_js_default(
+      oneShareWorthWindowAgo.toString()
+    );
+    const currentExchangeRate = new bignumber_js_default(currentOneShareWorth.toString());
+    return {
+      address,
+      current: {
+        exchangeRate: currentExchangeRate.toString(),
+        totalSupply: new bignumber_js_default(currentTotalSupply.toString()).dividedBy(1e18).toString(),
+        totalAssets: new bignumber_js_default(curretTotalAssets.toString()).dividedBy(1e18).toString(),
+        tvl: new bignumber_js_default(currentTVL.toString()).dividedBy(1e18).toString()
+      },
+      previous: {
+        exchangeRate: exchangeRateWindowAgo.toString(),
+        totalSupply: new bignumber_js_default(totalSupply24HoursAgo.toString()).dividedBy(1e18).toString(),
+        totalAssets: new bignumber_js_default(totalAssets24HoursAgo.toString()).dividedBy(1e18).toString(),
+        tvl: new bignumber_js_default(tvl24HoursAgo.toString()).dividedBy(1e18).toString()
+      },
+      totalWBeraIssued: new bignumber_js_default(underlyingTotalSupply.toString()).dividedBy(1e18).toString(),
+      lockPeriod,
+      totalBuyBacks: incentiveFeeClaimStats.sumAllClaims,
+      totalBuyBacksInLast24Hours: incentiveFeeClaimStats.sumClaimsInLast24Hours
+    };
+  } catch (error) {
+    console.error("Failed to get SW Bera Vault Metadata", error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getSWBeraWithdrawal.ts
+import { wberaStakerVaultAbi as stakeBeraVaultAbi3 } from "@berachain/abis/pol/wberaStakerVault";
+function getTimeUntil(targetTime) {
+  const currentTime = Date.now();
+  const timeDiff = targetTime * 1e3 - currentTime;
+  if (timeDiff <= 0) {
+    return;
+  }
+  const totalSeconds = msToSeconds(timeDiff);
+  return formatTimeLeft(totalSeconds, true, true);
+}
+async function getSWBeraWithdrawal({
+  contractAddress,
+  accountAddress,
+  publicClient,
+  version
+}) {
+  const withdrawalRequests = [];
+  function withdrawalRequestV1Helper(withdrawalRequest, lockPeriod) {
+    const [assets, _shares, timestamp] = withdrawalRequest;
+    const withdrawalAmount = assets;
+    const readyTime = Number(timestamp) + Number(lockPeriod);
+    const currentTime = msToSeconds(Date.now());
+    const timeLeft = readyTime - currentTime;
+    if (withdrawalAmount > 0) {
+      const timeRemaining = getTimeUntil(timeLeft <= 0 ? 0 : readyTime);
+      withdrawalRequests.push({
+        receiptTokenAddress: contractAddress,
+        withdrawalAmount,
+        timeRemaining
+      });
+    }
+  }
+  switch (version) {
+    case "V1": {
+      const [withdrawalRequest, lockPeriod] = await Promise.all([
+        publicClient.readContract({
+          address: contractAddress,
+          abi: stakeBeraVaultAbi3,
+          functionName: "withdrawalRequests",
+          args: [accountAddress]
+        }),
+        getStakeWithdrawalCooldown({
+          publicClient,
+          address: contractAddress
+        })
+      ]);
+      withdrawalRequestV1Helper(withdrawalRequest, lockPeriod);
+      return withdrawalRequests;
+    }
+    case "V2": {
+      const [withdrawalRequestIds, lockPeriod] = await Promise.all([
+        publicClient.readContract({
+          address: contractAddress,
+          abi: stakeBeraVaultAbi3,
+          functionName: "getERC721WithdrawalRequestIds",
+          args: [accountAddress]
+        }),
+        getStakeWithdrawalCooldown({
+          publicClient,
+          address: contractAddress
+        })
+      ]);
+      if (isToken(contractAddress, "SWBERA")) {
+        const withdrawalRequestV1 = await publicClient.readContract({
+          address: contractAddress,
+          abi: stakeBeraVaultAbi3,
+          functionName: "withdrawalRequests",
+          args: [accountAddress]
+        });
+        withdrawalRequestV1Helper(withdrawalRequestV1, lockPeriod);
+      }
+      const withdrawalResults = await Promise.all(
+        withdrawalRequestIds.map(
+          async (withdrawalRequestId) => {
+            const withdrawalRequest = await publicClient.readContract({
+              address: contractAddress,
+              abi: stakeBeraVaultAbi3,
+              functionName: "getERC721WithdrawalRequest",
+              args: [withdrawalRequestId]
+            });
+            const { assets, requestTime: timestamp } = withdrawalRequest;
+            if (!assets || !timestamp)
+              throw new Error("Invalid withdrawal request");
+            const withdrawalAmount = assets;
+            const readyTime = Number(timestamp) + Number(lockPeriod);
+            const currentTime = msToSeconds(Date.now());
+            const timeLeft = readyTime - currentTime;
+            if (withdrawalAmount > 0) {
+              const timeRemaining = getTimeUntil(timeLeft <= 0 ? 0 : readyTime);
+              return {
+                withdrawalAmount,
+                timeRemaining,
+                withdrawalRequestId,
+                receiptTokenAddress: contractAddress
+              };
+            }
+            return null;
+          }
+        )
+      );
+      const filteredRequests = withdrawalResults.filter(
+        (request) => request !== null
+      );
+      withdrawalRequests.push(...filteredRequests);
+      return withdrawalRequests;
+    }
+  }
+}
+
+// src/actions/pol/getTotalStakedAmount.ts
+import { wberaStakerVaultAbi as stakeBeraVaultAbi4 } from "@berachain/abis/pol/wberaStakerVault";
+async function getTotalStakedAmount({
+  vaultAddresses,
+  publicClient
+}) {
+  assertPublicClient(publicClient);
+  try {
+    const totalAssets = await Promise.all(
+      vaultAddresses.map(async (address) => {
+        return publicClient.readContract({
+          address,
+          abi: stakeBeraVaultAbi4,
+          functionName: "totalAssets"
+        });
+      })
+    );
+    const stakedAmount = vaultAddresses.reduce(
+      (acc, address, index) => {
+        acc[address] = totalAssets[index];
+        return acc;
+      },
+      {}
+    );
+    return stakedAmount;
+  } catch (error) {
+    console.error("Failed to get total staked amount", error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getUserClaimableIncentives.ts
+async function getUserClaimableIncentives({
+  account,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const result = await fetch(
+    `${config.pol.bribeBoostApi}/api/v1/wallets/${account.toLowerCase()}/rewards/aggregation`,
+    {
+      cache: "no-store"
+    }
+  );
+  if (!result.ok) {
+    const error = await getErrorResponse(result);
+    throw new BeraError({
+      message: "Failed to fetch incentives on server",
+      cause: { error, result, account },
+      reason: error?.error
+    });
+  }
+  return result.json();
+}
+
+// src/actions/pol/getUserVaultsReward.ts
+import { rewardVaultAbi as rewardVaultAbi5 } from "@berachain/abis/pol/rewards/rewardVault";
+async function getUserVaultsReward({
+  account,
+  vaultAddress,
+  publicClient
+}) {
+  if (!publicClient) throw new Error("Missing public client");
+  if (!account) throw new Error("Missing user account");
+  if (!vaultAddress) throw new Error("Missing vault address");
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: rewardVaultAbi5,
+    functionName: "earned",
+    args: [account]
+  });
+}
+
+// src/actions/pol/getUserVaultInfo.ts
+import { formatEther as formatEther5 } from "viem";
+
+// src/actions/pol/getUserVaultsBalance.ts
+import { rewardVaultAbi as rewardVaultAbi6 } from "@berachain/abis/pol/rewards/rewardVault";
+async function getUserVaultsBalance({
+  account,
+  vaultAddress,
+  publicClient
+}) {
+  assertPublicClient(publicClient);
+  assertAddress(account, "account");
+  assertAddress(vaultAddress, "vaultAddress");
+  try {
+    const [balance, delegated] = await Promise.all([
+      publicClient.readContract({
+        address: vaultAddress,
+        abi: rewardVaultAbi6,
+        functionName: "balanceOf",
+        args: [account]
+      }),
+      publicClient.readContract({
+        address: vaultAddress,
+        abi: rewardVaultAbi6,
+        functionName: "getTotalDelegateStaked",
+        args: [account]
+      })
+    ]);
+    return { balance, delegated };
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getVaultsSupply.ts
+import { rewardVaultAbi as rewardVaultAbi7 } from "@berachain/abis/pol/rewards/rewardVault";
+async function getVaultsSupply({
+  vaultAddress,
+  publicClient
+}) {
+  if (!publicClient) throw new Error("Missing public client");
+  if (!vaultAddress) throw new Error("Missing vault address");
+  try {
+    const result = await publicClient.readContract({
+      address: vaultAddress,
+      abi: rewardVaultAbi7,
+      functionName: "totalSupply",
+      args: []
+    });
+    return result;
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getUserVaultInfo.ts
+async function getUserVaultInfo({
+  account,
+  vaultAddress,
+  publicClient
+}) {
+  const [userBalance, userReward, totalSupply] = await Promise.all([
+    getUserVaultsBalance({
+      account,
+      vaultAddress,
+      publicClient
+    }),
+    getUserVaultsReward({
+      account,
+      vaultAddress,
+      publicClient
+    }),
+    getVaultsSupply({
+      vaultAddress,
+      publicClient
+    })
+  ]);
+  const withdrawableBalance = userBalance.balance - userBalance.delegated;
+  const percentage = totalSupply > 0n ? Number(
+    Number.parseFloat(formatEther5(userBalance.balance)) / Number.parseFloat(formatEther5(totalSupply))
+  ).toString() : "0";
+  return {
+    balance: userBalance.balance,
+    delegatedBalance: userBalance.delegated,
+    withdrawableBalance,
+    rewards: formatEther5(userReward),
+    percentage
+  };
+}
+
+// src/actions/pol/getUserVaults.ts
+import { formatUnits as formatUnits9 } from "viem";
+import { rewardVaultAbi as rewardVaultAbi8 } from "@berachain/abis/pol/rewards/rewardVault";
+import {
+  GetUserVaults
+} from "@berachain/graphql/pol/api";
+async function getUserVaults({
+  account,
+  publicClient,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const res = await bexApiGraphqlClient.query({
+    query: GetUserVaults,
+    variables: {
+      userId: account,
+      chain: config.bex.chainName
+    }
+  });
+  const deposits = res.data?.userVaultDeposits?.deposits;
+  if (!deposits) {
+    return {
+      totalBgtRewards: "0",
+      vaults: [],
+      totalStakedValue: 0
+    };
+  }
+  const [earnedResult, balanceResult] = await Promise.all([
+    // Fetch pending BGT rewards for each vault
+    publicClient.multicall({
+      allowFailure: false,
+      contracts: deposits.map(
+        (deposit) => ({
+          address: deposit.vaultAddress,
+          abi: rewardVaultAbi8,
+          functionName: "earned",
+          args: [account]
+        })
+      )
+    }),
+    // Fetch user balance of each vault
+    publicClient.multicall({
+      allowFailure: false,
+      contracts: deposits.map(
+        (deposit) => ({
+          address: deposit.vaultAddress,
+          abi: rewardVaultAbi8,
+          functionName: "balanceOf",
+          args: [account]
+        })
+      )
+    })
+  ]);
+  const { userVaults, total } = deposits.reduce(
+    (acc, deposit, index) => {
+      const item = earnedResult[index];
+      const balanceItem = balanceResult[index];
+      acc.total += item;
+      if (!deposit.vault) {
+        BeraMonitoring.captureException(
+          new BeraError({
+            message: "Deposit data from API is missing vault",
+            level: "error",
+            extra: {
+              deposit
+            }
+          })
+        );
+        console.error("Deposit data from API is missing vault", deposit);
+        return acc;
+      }
+      if (item > 0n || balanceItem > 0n) {
+        const stakingTokenPrice = deposit.vault.dynamicData?.tvl && // If staked amount is 0, we don't want to divide by 0
+        Number(deposit.vault.stakingTokenAmount) !== 0 ? Number(deposit.vault.dynamicData?.tvl ?? 0) / Number(deposit.vault.stakingTokenAmount) : null;
+        acc.userVaults.push({
+          ...deposit,
+          vault: deposit.vault,
+          unclaimedBgt: formatUnits9(item, 18),
+          formattedBalance: formatUnits9(
+            balanceItem,
+            deposit.vault.stakingToken.decimals
+          ),
+          stakingTokenPrice
+        });
+      }
+      return acc;
+    },
+    {
+      userVaults: [],
+      total: 0n
+    }
+  );
+  const sortedUserVaults = [...userVaults].sort((a, b) => {
+    if (a.vault.isVaultWhitelisted && !b.vault.isVaultWhitelisted) {
+      return -1;
+    }
+    if (!a.vault.isVaultWhitelisted && b.vault.isVaultWhitelisted) {
+      return 1;
+    }
+    const aUnclaimed = Number.parseFloat(a.unclaimedBgt);
+    const bUnclaimed = Number.parseFloat(b.unclaimedBgt);
+    return bUnclaimed - aUnclaimed;
+  });
+  const totalStakedValue = sortedUserVaults.reduce((acc, vault) => {
+    const tvl = Number(vault.vault.dynamicData?.tvl ?? 0);
+    if (tvl === 0) {
+      return acc;
+    }
+    const stakingTokenAmount = Number.parseFloat(
+      vault.vault.stakingTokenAmount
+    );
+    const stakingTokenPrice = tvl / stakingTokenAmount;
+    return acc + stakingTokenPrice * Number(vault.formattedBalance);
+  }, 0);
+  return {
+    totalStakedValue,
+    totalBgtRewards: formatUnits9(total, 18),
+    vaults: sortedUserVaults
+  };
+}
+
+// src/actions/pol/getVaultHistory.ts
+import {
+  GetVaultHistory
+} from "@berachain/graphql/pol/api";
+async function getVaultHistory({
+  vault,
+  chain,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const result = await bexApiGraphqlClient.query({
+    query: GetVaultHistory,
+    variables: {
+      ...args,
+      vaultId: vault,
+      chain: chain ?? config.bex.chainName
+    }
+  });
+  return result.data.polGetRewardVaultSnapshots;
+}
+
+// src/actions/pol/getVaultValidators.ts
+import {
+  GetVaultValidators
+} from "@berachain/graphql/pol/api";
+async function getVaultValidators({
+  address,
+  onlyActiveValidators,
+  ...args
+}) {
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const result = await bexApiGraphqlClient.query({
+    query: GetVaultValidators,
+    variables: { vaultId: address, isActive: onlyActiveValidators }
+  });
+  return result.data.validators.validators ?? [];
+}
+
+// src/actions/prices/getTokenCurrentPrices.ts
+import { getAddress, zeroAddress as zeroAddress3 } from "viem";
+import {
+  GetTokenCurrentPrices
+} from "@berachain/graphql/dex/api";
+async function getTokenCurrentPrices({
+  addressIn: _addressIn,
+  ...args
+}) {
+  const { config, chainId } = parseBaseArgs(args);
+  const addressIn = _addressIn.map((a) => a.toLowerCase()).filter((addr, idx, arr) => addr && arr.indexOf(addr) === idx);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const { data } = await bexApiGraphqlClient.query({
+    query: GetTokenCurrentPrices,
+    variables: {
+      chains: [config.bex.chainName],
+      addressIn
+    }
+  });
+  return data.tokenGetCurrentPrices.reduce(
+    (map, tokenInformation) => {
+      if (!tokenInformation.price || !tokenInformation.address) {
+        return map;
+      }
+      const formattedAddress = tokenInformation.address;
+      map[getAddress(formattedAddress)] = {
+        price: getSafeNumber(tokenInformation.price.toString()),
+        updatedAt: tokenInformation.updatedAt,
+        chainId
+      };
+      map[formattedAddress.toLowerCase()] = {
+        price: getSafeNumber(tokenInformation.price.toString()),
+        updatedAt: tokenInformation.updatedAt,
+        chainId
+      };
+      if (isToken(formattedAddress, "WBERA")) {
+        map[zeroAddress3] = {
+          price: getSafeNumber(tokenInformation.price.toString()),
+          updatedAt: tokenInformation.updatedAt,
+          chainId
+        };
+        map[config.tokens.bgt.toLowerCase()] = {
+          price: getSafeNumber(tokenInformation.price.toString()),
+          updatedAt: tokenInformation.updatedAt,
+          chainId
+        };
+        map[config.tokens.bgt] = {
+          price: getSafeNumber(tokenInformation.price.toString()),
+          updatedAt: tokenInformation.updatedAt,
+          chainId
+        };
+      }
+      return map;
+    },
+    {}
+  );
+}
+
+// src/actions/tokens/getAllowances.ts
+import { getPublicClient } from "@wagmi/core";
+import {
+  erc20Abi as erc20Abi6,
+  formatUnits as formatUnits10
+} from "viem";
+async function getAllowances({
+  items: itemsList,
+  account,
+  config
+}) {
+  assertDefined(itemsList, "items");
+  assertDefined(config, "config");
+  assertDefined(account, "account");
+  const tokensByChainId = Object.groupBy(
+    itemsList,
+    (item) => item.token.chainId
+  );
+  const res = await Promise.allSettled(
+    Object.entries(tokensByChainId).map(async ([chainId, items]) => {
+      if (!items) return [];
+      const publicClient = getPublicClient(config, {
+        chainId: Number(chainId)
+      });
+      assertPublicClient(publicClient, `publicClient ${chainId}`);
+      const result = await publicClient.multicall({
+        contracts: items.map(
+          (item) => ({
+            address: item.token.address,
+            abi: erc20Abi6,
+            functionName: "allowance",
+            args: [account, item.spender]
+          })
+        )
+      });
+      const allowances = result.map((item, index) => {
+        const token = items[index];
+        if (item.error) {
+          return void 0;
+        }
+        const resultAllowanceToken = {
+          token: token.token,
+          spender: token.spender,
+          amount: token.amount,
+          allowance: {
+            raw: item.result.toString(),
+            formatted: formatUnits10(item.result, token.token.decimals)
+          },
+          needsApproval: item.result < BigInt(token.amount.raw)
+        };
+        return resultAllowanceToken;
+      });
+      return allowances.filter((i) => Boolean(i));
+    })
+  );
+  return res.flatMap(
+    (result) => result.status === "fulfilled" ? result.value : void 0
+  ).filter((i) => Boolean(i));
+}
+
+// src/actions/transactions/beraWriteContract.ts
+import {
+  getPublicClient as getPublicClient2,
+  getWalletClient,
+  switchChain
+} from "@wagmi/core";
+import {
+  BaseError,
+  createWalletClient,
+  decodeErrorResult,
+  HttpRequestError,
+  http
+} from "viem";
+import { ChainId, defaultChainId } from "@berachain/config/internal";
+
+// src/errors/getRevertReason.ts
+import {
+  AbiFunctionSignatureNotFoundError,
+  decodeFunctionData
+} from "viem";
+async function getRevertReason({
+  publicClient,
+  abi: providedAbi,
+  ...params
+}) {
+  const abi = [...commonAbiErrors, ...providedAbi ?? []];
+  let blockNumber;
+  let to;
+  let account;
+  let value;
+  let data;
+  let functionName;
+  let args;
+  if ("txHash" in params) {
+    const tx = await publicClient.getTransaction({
+      hash: params.txHash
+    });
+    if (!tx.to)
+      throw new InvalidArgumentError({
+        property: "tx",
+        value: tx,
+        expected: "Transaction",
+        message: "Trying to get revert reason for a contract creation"
+      });
+    data = tx.input;
+    to = tx.to;
+    account = tx.from;
+    value = tx.value;
+    blockNumber = tx.blockNumber;
+  } else {
+    blockNumber = params.blockNumber;
+    to = params.to;
+    account = params.account;
+    value = params.value;
+    if ("data" in params) {
+      data = params.data;
+    } else if ("functionName" in params && "args" in params) {
+      functionName = params.functionName;
+      args = params.args;
+    } else if (!value) {
+      throw new InvalidArgumentError({
+        property: "dataOrFunctionNameAndArgs",
+        value: params,
+        expected: "Hex or FunctionName and Args"
+      });
+    }
+  }
+  try {
+    if (!abi) {
+      if (data) {
+        await publicClient.call({
+          data,
+          to,
+          account,
+          blockNumber,
+          value
+        });
+      } else {
+        throw new Error("Data is required if abi is not provided");
+      }
+    }
+    if ("functionName" in params && "args" in params && params.functionName) {
+      functionName = params.functionName;
+      args = params.args;
+    } else if (data) {
+      if (!abi) {
+        const res = await publicClient.call({
+          data,
+          to,
+          account,
+          blockNumber,
+          value
+        });
+        throw new Error(
+          `Getting revert reason for successful simulation. Data: ${data}`,
+          { cause: res }
+        );
+      }
+      try {
+        const decoded = decodeFunctionData({
+          abi,
+          data
+        });
+        functionName = decoded.functionName;
+        args = decoded.args;
+      } catch (e) {
+        if (e instanceof AbiFunctionSignatureNotFoundError) {
+          await publicClient.call({
+            data,
+            to,
+            account,
+            blockNumber,
+            value
+          });
+        }
+        throw new Error("Data is required if abi is not provided");
+      }
+    } else {
+      throw new Error("No data or function name and args provided");
+    }
+    if (abi && functionName) {
+      await publicClient.simulateContract({
+        functionName,
+        args,
+        abi,
+        address: to,
+        account,
+        blockNumber
+      });
+      throw new TransactionFailedError({
+        message: `Getting revert reason for successful simulation`,
+        functionName,
+        to,
+        txHash: "txHash" in params ? params.txHash : void 0,
+        input: params
+      });
+    }
+    throw new Error("No data or function name and args provided");
+  } catch (error) {
+    if (error instanceof Error) {
+      return parseViemError({ error, abi, revertIfUnknown: true });
+    }
+    throw error;
+  }
+}
+
+// src/actions/transactions/beraWriteContract.ts
+var defaultPollingInterval = seconds(1);
+var increaseByPercentage = (value, percentage) => {
+  return value * (100n + BigInt(percentage)) / 100n;
+};
+function parseNonce({
+  nonceResult,
+  onWarning
+}) {
+  if (nonceResult.status === "fulfilled") {
+    if (nonceResult.value && nonceResult.value > Number.MAX_SAFE_INTEGER) {
+      onWarning?.(
+        new BeraError({
+          message: "Nonce is too large. No nonce will be provided to avoid IntegerOutOfRangeError.",
+          cause: nonceResult.value,
+          level: "debug"
+        })
+      );
+      return void 0;
+    }
+    return nonceResult.value;
+  }
+  return void 0;
+}
+function isImpersonateAccount(chainId = defaultChainId) {
+  return chainId === ChainId.BEPOLIA ? process.env.NEXT_PUBLIC_80069_ANVIL_IMPERSONATE_ACCOUNT === "true" : process.env.NEXT_PUBLIC_80094_ANVIL_IMPERSONATE_ACCOUNT === "true";
+}
+async function beraWriteContract(args) {
+  if (process.env.NODE_ENV === "development" && !args.contractName && // let's avoid this for eip5972 calls
+  args.address && !("calls" in args || args.calls)) {
+    console.warn(
+      "beraWriteContract: Contract name is required. Either update the contract mapping in devrel or provide a contract name in ContractName enum",
+      "This is a development error and will be thrown in development mode only."
+    );
+    throw new InvalidArgumentError({
+      property: "contractName",
+      value: args.contractName,
+      expected: "ContractName",
+      displayMessage: `[DEV] Contract name is required as it's not mapped in the devrel's contract mapping ${args.address}`,
+      level: "error"
+    });
+  }
+  const {
+    address,
+    calls,
+    value,
+    gasLimit,
+    onLoading,
+    onSuccess,
+    onWarning,
+    onError,
+    onSubmission,
+    wagmiConfig,
+    walletClient: _walletClient,
+    account: argsAccount,
+    txConfirmationTimeout = 12e4,
+    chainId = defaultChainId,
+    impersonateAccount = isImpersonateAccount(chainId),
+    errorsAbi: _errorsAbi = [],
+    pollingInterval = defaultPollingInterval,
+    ...rest
+  } = args;
+  onLoading?.(args);
+  const data = "data" in rest ? rest.data : void 0;
+  const globalAbi = [
+    ...commonAbiErrors,
+    ..._errorsAbi,
+    ..."abi" in rest && rest.abi && Array.isArray(rest.abi) ? rest.abi : []
+  ];
+  let walletClient = _walletClient;
+  if (!wagmiConfig) {
+    onError?.(
+      new InvalidArgumentError({
+        property: "wagmiConfig",
+        value: wagmiConfig,
+        expected: "Config"
+      }),
+      args
+    );
+    return;
+  }
+  const isLocalAccount = walletClient?.account?.type === "local";
+  if (!isLocalAccount) {
+    try {
+      await switchChain(wagmiConfig, { chainId });
+    } catch (e) {
+      const error = e;
+      onError?.(
+        new BeraError({
+          cause: error,
+          displayMessage: "There was an error switching to the chain."
+        }),
+        args
+      );
+      return;
+    }
+  }
+  if (!walletClient) {
+    try {
+      walletClient = await getWalletClient(wagmiConfig, { chainId });
+    } catch (e) {
+      onError?.(
+        new BeraError({
+          cause: e,
+          displayMessage: "There was an error connecting to the wallet."
+        }),
+        args
+      );
+      return;
+    }
+  }
+  if (!walletClient) {
+    onError?.(
+      new InvalidArgumentError({
+        displayMessage: "There was an error connecting to the wallet.",
+        property: "walletClient",
+        value: walletClient,
+        expected: "WalletClient"
+      }),
+      args
+    );
+    return;
+  }
+  const account = argsAccount || walletClient.account;
+  if (!account) {
+    onError?.(
+      new InvalidArgumentError({
+        property: "account",
+        value: account,
+        expected: "Account"
+      }),
+      args
+    );
+    return;
+  }
+  const accountAddress = typeof account === "string" ? account : account.address;
+  const publicClient = getPublicClient2(wagmiConfig, {
+    chainId
+  });
+  try {
+    assertPublicClient(publicClient);
+  } catch (error) {
+    onError?.(error, args);
+    return;
+  }
+  if (impersonateAccount) {
+    const testClient = getTestClient(chainId);
+    await testClient.impersonateAccount({
+      address: accountAddress
+    });
+    walletClient = createWalletClient({
+      transport: http(testClient.transport.url),
+      account,
+      chain: walletClient.chain
+    });
+  }
+  let txHash;
+  const input = {
+    calls: "calls" in rest ? rest.calls : void 0,
+    params: "params" in rest ? rest.params : void 0,
+    value,
+    data: "data" in rest ? rest.data : void 0
+  };
+  try {
+    const noncePromise = publicClient.getTransactionCount({
+      address: accountAddress,
+      /**
+       * We won't use pending any more because if someone previously send a txn with a higher nonce, this won't be executed
+       * unless all the previous nonces are executed.
+       *
+       * This will lead to a UX issue where the user thinks the txn was not sent because it's pending forever.
+       *
+       * The only case where pending is needed is if chain is halted or the user is sending multiple transactions at the same time.
+       * However, it's less likely to happen.
+       *
+       * A lot of waitForTransactionReceipt were timing out, and maybe it was related to that.
+       */
+      blockTag: "latest"
+    }).catch(() => void 0);
+    const sharedTxProperties = {
+      account: accountAddress,
+      to: address,
+      address,
+      chainId,
+      value
+    };
+    if (calls) {
+      const parsedCalls = calls.map((call) => {
+        if ("abi" in call && Array.isArray(globalAbi)) {
+          globalAbi.push(...call.abi);
+        }
+        if ("data" in call) {
+          return {
+            to: call.address,
+            data: call.data,
+            value: call.value ?? 0n
+          };
+        }
+        if ("abi" in call && "functionName" in call) {
+          const params = "params" in call ? call.params : void 0;
+          return {
+            to: call.address,
+            abi: call.abi,
+            functionName: call.functionName,
+            args: params,
+            value: call.value ?? 0n
+          };
+        }
+        return {
+          to: call.address,
+          value: call.value ?? 0n
+        };
+      });
+      if (args.enableSimulateCalls) {
+        const res = await publicClient.simulateCalls({
+          calls: parsedCalls,
+          account
+        });
+        const failedCallIndex = res.results.findIndex(
+          (result) => result.status === "failure"
+        );
+        if (failedCallIndex !== -1) {
+          if (res.block.number === null) {
+            throw new InvalidArgumentError({
+              property: "blockNumber",
+              value: res.block.number,
+              expected: "bigint",
+              message: "Block number is null"
+            });
+          }
+          const failedCall = res.results[failedCallIndex];
+          const { reason: decodedReason } = failedCall.data && failedCall.data !== "0x" ? {
+            reason: parseDecodedError(
+              decodeErrorResult({
+                data: failedCall.data,
+                abi: globalAbi
+              })
+            )
+          } : parseViemError({
+            error: failedCall.error,
+            revertIfUnknown: false,
+            abi: globalAbi
+          });
+          onError?.(
+            new TransactionFailedError({
+              cause: failedCall.error,
+              txHash,
+              chainId,
+              reason: decodedReason,
+              abi: globalAbi,
+              input,
+              blockNumber: res.block.number
+            }),
+            args
+          );
+          return;
+        }
+      }
+      if (process.env.NODE_ENV === "test") {
+        throw new InvalidArgumentError({
+          displayMessage: "Batch calls are not supported in test environment",
+          expected: "not test",
+          property: "NODE_ENV",
+          value: process.env.NODE_ENV,
+          level: "fatal"
+        });
+      }
+      const request = await walletClient.sendCalls({
+        calls: parsedCalls,
+        account,
+        // This is needed to ensure that the transaction is atomic
+        // If this was not set, we might have a list of receipts instead of a single one
+        forceAtomic: true
+      });
+      onSubmission?.({ id: request.id }, args);
+      const callStatus = await walletClient.waitForCallsStatus({
+        id: request.id,
+        pollingInterval,
+        timeout: txConfirmationTimeout
+      });
+      if (callStatus.status === "success") {
+        const receipt = callStatus.receipts?.[0];
+        if (!receipt) {
+          throw new BeraError({
+            message: "Call status is success but no receipt was found",
+            cause: callStatus,
+            level: "error",
+            reason: "CALL_STATUS_SUCCESS_BUT_NO_RECEIPT"
+          });
+        }
+        onSuccess?.(receipt, args);
+        return receipt;
+      }
+      console.error("wallet_sendCalls: Call failed", callStatus);
+      throw new TransactionFailedError({
+        cause: callStatus,
+        level: "error",
+        input,
+        txHash,
+        abi: globalAbi,
+        chainId
+      });
+    }
+    if (data) {
+      const [simulationResult, estimatedGas, nonceResult] = await Promise.allSettled([
+        publicClient.call({
+          ...sharedTxProperties,
+          data
+        }),
+        gasLimit ?? publicClient.estimateGas({
+          ...sharedTxProperties,
+          data
+        }),
+        noncePromise
+      ]);
+      if (simulationResult.status === "rejected") {
+        throw simulationResult.reason;
+      }
+      const gas = estimatedGas.status === "fulfilled" ? increaseByPercentage(estimatedGas.value, 10) : DEFAULT_METAMASK_GAS_LIMIT;
+      txHash = await walletClient.sendTransaction({
+        data,
+        to: address,
+        account,
+        gas,
+        chainId,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            onWarning?.(e, args);
+          }
+        }),
+        value
+      });
+      onSubmission?.({ txHash }, args);
+    } else if ("abi" in rest && "functionName" in rest) {
+      const { abi, functionName } = rest;
+      const params = "params" in rest ? rest.params : void 0;
+      const [simulationResult, gasEstimateResult, nonceResult] = await Promise.allSettled([
+        // @ts-expect-error nested type issues. Be careful when changing this.
+        publicClient.simulateContract({
+          ...sharedTxProperties,
+          abi: globalAbi,
+          functionName,
+          args: params,
+          account
+        }),
+        // Only estimate gas if no gasLimit is provided
+        gasLimit ?? // @ts-expect-error nested type issues. Be careful when changing this.
+        publicClient.estimateContractGas({
+          ...sharedTxProperties,
+          abi: globalAbi,
+          functionName,
+          args: params
+        }),
+        noncePromise
+      ]);
+      if (simulationResult.status === "rejected") {
+        throw simulationResult.reason;
+      }
+      const estimatedGas = gasLimit ?? (gasEstimateResult.status === "fulfilled" ? increaseByPercentage(gasEstimateResult.value, 10) : DEFAULT_METAMASK_GAS_LIMIT);
+      txHash = await walletClient.writeContract({
+        ...simulationResult.value.request,
+        chainId,
+        gas: estimatedGas,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            onWarning?.(e, args);
+          }
+        })
+      });
+      onSubmission?.({ txHash }, args);
+    } else {
+      const [nonceResult] = await Promise.allSettled([noncePromise]);
+      txHash = await walletClient.sendTransaction({
+        chainId,
+        to: address,
+        value,
+        account,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            onWarning?.(e, args);
+          }
+        })
+      });
+      onSubmission?.({ txHash }, args);
+    }
+    if (process.env.NODE_ENV === "test") {
+      const testClient = getTestClient(chainId);
+      await testClient.mine({ blocks: 1 });
+    }
+    const confirmationReceipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      pollingInterval,
+      timeout: txConfirmationTimeout,
+      confirmations: 1
+    });
+    if (confirmationReceipt.status === "success") {
+      onSuccess?.(confirmationReceipt, args);
+    } else {
+      const revertReason = await getRevertReason({
+        publicClient,
+        blockNumber: confirmationReceipt.blockNumber,
+        to: address,
+        account: accountAddress,
+        abi: globalAbi,
+        args: "params" in rest ? rest.params : void 0,
+        functionName: "functionName" in rest ? rest.functionName : void 0,
+        value,
+        data
+      });
+      if (process.env.NODE_ENV === "test") {
+        console.error("beraWriteContract: Revert reason", revertReason);
+      }
+      onError?.(
+        new TransactionFailedError({
+          reason: revertReason.reason,
+          txHash,
+          receipt: confirmationReceipt,
+          to: address,
+          functionName: "functionName" in rest ? rest.functionName : void 0,
+          input,
+          chainId,
+          abi: globalAbi,
+          blockNumber: confirmationReceipt.blockNumber
+        }),
+        args
+      );
+    }
+    return confirmationReceipt;
+  } catch (e) {
+    if (e instanceof BeraError) {
+      onError?.(e, args);
+    } else if (e instanceof Error) {
+      const viemError = parseViemError({
+        error: e,
+        revertIfUnknown: false,
+        abi: globalAbi
+      });
+      if (viemError && viemError.rootCause instanceof BaseError && "url" in viemError.rootCause) {
+        onError?.(
+          new RequestError({
+            cause: viemError.rootCause,
+            response: void 0,
+            endpoint: {
+              url: viemError.rootCause.url,
+              type: "rpc"
+            },
+            statusCode: viemError.rootCause instanceof HttpRequestError ? viemError.rootCause.status : void 0
+          }),
+          args
+        );
+        return;
+      }
+      onError?.(
+        new TransactionFailedError({
+          cause: e,
+          to: address,
+          txHash,
+          chainId,
+          abi: globalAbi,
+          functionName: "functionName" in rest ? rest.functionName : void 0,
+          input
+        }),
+        args
+      );
+    } else {
+      onError?.(
+        new TransactionFailedError({
+          cause: e,
+          txHash,
+          to: address,
+          chainId,
+          functionName: "functionName" in rest ? rest.functionName : void 0,
+          input,
+          abi: globalAbi
+        }),
+        args
+      );
+    }
+  }
+}
+
+// src/actions/validators/getAllValidators.ts
+import {
+  GetValidators
+} from "@berachain/graphql/pol/api";
+async function getAllValidators({
+  variables = {},
+  ...args
+} = {}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const result = await bexApiGraphqlClient.query({
+    query: GetValidators,
+    variables: {
+      chain: config.bex.chainName,
+      ...variables
+    }
+  });
+  return result.data;
+}
+
+// src/actions/validators/getApiEnrichedAllocation.ts
+import { isAddressEqual } from "viem";
+async function getApiEnrichedAllocation({
+  allocation
+}) {
+  const vaults = await getRewardVaults({
+    filter: {
+      where: {
+        vaultAddressIn: allocation.weights.map((weight) => weight.receiver)
+      }
+    }
+  });
+  const startBlock = allocation?.start.blockNumber ?? 0;
+  return allocation?.weights.map(
+    (allocation2) => {
+      return {
+        percentage: allocation2.percentage,
+        receiver: allocation2.receiver,
+        startBlock,
+        receivingVault: vaults?.gaugeList.find(
+          (vault) => isAddressEqual(vault.address, allocation2.receiver)
+        )
+      };
+    }
+  );
+}
+
+// src/actions/validators/getApiValidator.ts
+import {
+  GetValidator
+} from "@berachain/graphql/pol/api";
+async function getApiValidator({
+  id,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const results = await bexApiGraphqlClient.query({
+    query: GetValidator,
+    variables: {
+      id,
+      chain: config.bex.chainName
+    }
+  });
+  return results.data;
+}
+
+// src/actions/validators/getDailyValidatorBlockStats.ts
+async function getDailyValidatorBlockStats({
+  pubKey,
+  first = 1
+}) {
+  if (typeof window === "undefined") {
+    throw new BeraError({
+      message: "getDailyValidatorBlockStats is browser-only; for RSC use @berachain/berajs/actions/server",
+      level: "error"
+    });
+  }
+  const params = new URLSearchParams({
+    pubkey: pubKey,
+    first: String(first)
+  });
+  return beraFetchJson({
+    url: `/api/pol/validator-block-stats?${params}`,
+    name: "pol-validator-block-stats",
+    type: "rest"
+  });
+}
+
+// src/actions/validators/getValidatorRewardAllocation.ts
+import { beraChefAbi } from "@berachain/abis/pol/rewards/beraChef";
+function formatValidatorRewardAllocation(raw, startTs) {
+  return {
+    start: {
+      blockNumber: Number(raw.startBlock),
+      timestamp: raw.startBlock !== 0n ? startTs : 0
+    },
+    weights: raw.weights.map((weight) => ({
+      receiver: weight.receiver,
+      percentage: Number(weight.percentageNumerator) / 1e4
+    }))
+  };
+}
+function isSameRewardAllocation(a, b) {
+  return a.start.blockNumber === b.start.blockNumber && a.weights.every(
+    (weight, index) => weight.percentage === b.weights[index].percentage
+  );
+}
+async function getValidatorRewardAllocation({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const [rawActiveRewardAllocation, rawSetRewardAllocation] = await Promise.all([
+      client.readContract({
+        address: config.pol.beraChef,
+        abi: beraChefAbi,
+        functionName: "getActiveRewardAllocation",
+        args: [pubKey]
+      }),
+      client.readContract({
+        address: config.pol.beraChef,
+        abi: beraChefAbi,
+        functionName: "getSetActiveRewardAllocation",
+        args: [pubKey]
+      })
+    ]);
+    const [lastRaUpdateActive, lastRaUpdateSet] = await Promise.all([
+      rawActiveRewardAllocation.startBlock !== 0n ? client.getBlock({
+        blockNumber: BigInt(rawActiveRewardAllocation.startBlock)
+      }) : { timestamp: 0 },
+      rawSetRewardAllocation.startBlock !== 0n ? client.getBlock({
+        blockNumber: BigInt(rawSetRewardAllocation.startBlock)
+      }) : { timestamp: 0 }
+    ]);
+    const activeRewardAllocation = formatValidatorRewardAllocation(
+      rawActiveRewardAllocation,
+      Number(lastRaUpdateActive.timestamp)
+    );
+    const setRewardAllocation = formatValidatorRewardAllocation(
+      rawSetRewardAllocation,
+      Number(lastRaUpdateSet.timestamp)
+    );
+    let isBaseline = false;
+    if (setRewardAllocation.start.blockNumber === 0) {
+      isBaseline = true;
+    } else {
+      isBaseline = !isSameRewardAllocation(
+        setRewardAllocation,
+        activeRewardAllocation
+      );
+    }
+    return {
+      activeRewardAllocation,
+      setRewardAllocation,
+      isBaseline,
+      isNeverSet: setRewardAllocation?.start.blockNumber === 0
+    };
+  } catch (e) {
+    console.log("getValidatorRewardAllocation:", e);
+    throw e;
+  }
+}
+
+// src/actions/validators/getDefaultRewardAllocation.ts
+import { beraChefAbi as beraChefAbi2 } from "@berachain/abis/pol/rewards/beraChef";
+function isDefaultRewardAllocation(rewardAllocation) {
+  return rewardAllocation.start.blockNumber === 0;
+}
+async function getDefaultRewardAllocation({
+  client,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const rawDefaultRewardAllocation = await client.readContract({
+    address: config.pol.beraChef,
+    abi: beraChefAbi2,
+    functionName: "getDefaultRewardAllocation",
+    args: []
+  });
+  return formatValidatorRewardAllocation(
+    { ...rawDefaultRewardAllocation, startBlock: 0n },
+    0
+  );
+}
+
+// src/actions/validators/getStakingPoolBatch.ts
+async function getStakingPoolBatch({
+  client,
+  valPubKey
+}) {
+  return 5614;
+}
+
+// src/actions/validators/getUserBoostsOnValidator.ts
+import { formatEther as formatEther6 } from "viem";
+import { bgtAbi as bgtAbi2 } from "@berachain/abis/pol/bgt";
+async function getUserBoostsOnValidator({
+  account,
+  pubkey,
+  publicClient,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  if (!account) {
+    throw new Error("account is required");
+  }
+  if (!publicClient) {
+    throw new Error("publicClient is required");
+  }
+  const [activeBoostAmount, queuedBoostAmount, queuedDropBoostAmount] = await Promise.all([
+    publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi2,
+      functionName: "boosted",
+      args: [account, pubkey]
+    }),
+    publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi2,
+      functionName: "boostedQueue",
+      args: [account, pubkey]
+    }),
+    publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi2,
+      functionName: "dropBoostQueue",
+      args: [account, pubkey]
+    })
+  ]);
+  const droppableBoostAmount = activeBoostAmount - queuedDropBoostAmount[1];
+  return {
+    pubkey,
+    droppableBoostAmount: formatEther6(droppableBoostAmount),
+    activeBoostAmount: formatEther6(activeBoostAmount),
+    queuedBoostAmount: formatEther6(queuedBoostAmount[1]),
+    queuedDropBoostAmount: formatEther6(queuedDropBoostAmount[1]),
+    queuedBoostStartBlock: queuedBoostAmount[0],
+    queuedDropBoostStartBlock: queuedDropBoostAmount[0],
+    hasPendingBoosts: queuedBoostAmount[1] > 0n || queuedDropBoostAmount[1] > 0n,
+    hasActiveBoosts: activeBoostAmount > 0n,
+    hasDroppableBoosts: droppableBoostAmount > 0n
+  };
+}
+
+// src/actions/validators/getUserActiveValidators.ts
+import { formatEther as formatEther7, parseEther as parseEther4 } from "viem";
+
+// src/actions/validators/getUserBoosts.ts
+import {
+  GetUserValidatorInformation
+} from "@berachain/graphql/pol/api";
+async function getUserBoosts({
+  account,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const apiClient = getApolloClient("api", args);
+  return apiClient.query({
+    query: GetUserValidatorInformation,
+    variables: {
+      address: account.toLowerCase(),
+      chain: config.bex.chainName
+    }
+  });
+}
+
+// src/actions/validators/getUserActiveValidators.ts
+async function getUserActiveValidators({
+  account,
+  publicClient,
+  chain,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const resolvedChain = chain ?? config.bex.chainName;
+  const userBoosts = await getUserBoosts({ account });
+  const [validatorInfoList, onChainBoosts] = await Promise.all([
+    getAllValidators({
+      variables: {
+        chain: resolvedChain,
+        where: {
+          idIn: userBoosts.data.polGetValidatorBoosts.boosts.map(
+            (t) => t.validatorId
+          )
+        }
+      }
+    }),
+    Promise.all(
+      userBoosts.data.polGetValidatorBoosts.boosts.filter(
+        (t) => (
+          // there's an edge case here where api doesn't return the pubkey
+          // because the user might have boosted a pubkey that doesn't exist
+          // api doesn't return the pubkey in this case, but we're choosing to filter them out
+          !!t.validator
+        )
+      ).map(
+        (t) => getUserBoostsOnValidator({
+          account,
+          pubkey: t.validator.pubkey,
+          publicClient
+        })
+      )
+    )
+  ]);
+  return validatorInfoList?.validators.validators.map((validator) => {
+    const userDeposited = onChainBoosts.find(
+      (data) => data.pubkey.toLowerCase() === validator.pubkey.toLowerCase()
+    );
+    if (!userDeposited) {
+      throw new Error("User deposited not found");
+    }
+    const droppableBoostAmount = parseEther4(userDeposited?.activeBoostAmount ?? "0") - parseEther4(userDeposited?.queuedDropBoostAmount);
+    return {
+      ...validator,
+      userBoosts: {
+        pubkey: userDeposited.pubkey,
+        activeBoostAmount: userDeposited?.activeBoostAmount,
+        queuedBoostAmount: userDeposited?.queuedBoostAmount,
+        queuedBoostStartBlock: Number(userDeposited?.queuedBoostStartBlock),
+        queuedDropBoostAmount: userDeposited?.queuedDropBoostAmount,
+        queuedDropBoostStartBlock: Number(
+          userDeposited?.queuedDropBoostStartBlock
+        ),
+        droppableBoostAmount: formatEther7(droppableBoostAmount),
+        hasPendingBoosts: Number(userDeposited?.queuedBoostAmount) > 0 || Number(userDeposited?.queuedDropBoostAmount) > 0,
+        hasActiveBoosts: Number(userDeposited?.activeBoostAmount) > 0,
+        hasDroppableBoosts: droppableBoostAmount > 0n
+      }
+    };
+  });
+}
+
+// src/actions/validators/getUserStakingPositions.ts
+var snowTestWalletPositions = [
+  {
+    validatorAddress: "0x8f51e63d9921a461be29e73dca1c2385e1adc5943fbb36ded4ba96025ee8a783184d1118da08171f6ea831153c878a6d",
+    earning: 0.045,
+    staked: {
+      amount: 16114000000000000000n,
+      formattedAmount: "161.14"
+    },
+    rewards: {
+      amount: 15214000000000000000n,
+      formattedAmount: "152.14"
+    }
+  },
+  {
+    staked: {
+      amount: 141514000000000000000n,
+      formattedAmount: "1415.14"
+    },
+    validatorAddress: "0x97b21253b17f4e814fe7505c15c18e68c85ab2477274ad370a762df50e3eb4cb1a48451e089bc22e158d7448549a8ab9",
+    earning: 0.045,
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      stake: [
+        {
+          amount: 16159000000000000000n,
+          formattedAmount: "161.59"
+        }
+      ],
+      unstake: [
+        {
+          amount: 16159000000000000000n,
+          formattedAmount: "161.59",
+          timestamp: msToSeconds(Date.now() - 72e6)
+        }
+      ]
+    }
+  },
+  {
+    staked: {
+      amount: 141514000000000000000n,
+      formattedAmount: "1415.14"
+    },
+    validatorAddress: "0xa2705d6b27891f3f5651f26547d1bb79e256f95f249d1ad717cef087d77d38b037e5d6dbaa2538930fd0731ec9b02f3a",
+    earning: 0.145,
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      unstake: [
+        {
+          amount: 16159000000000000000n,
+          formattedAmount: "161.59",
+          timestamp: msToSeconds(Date.now() - 72e6)
+        }
+      ]
+    }
+  },
+  {
+    staked: {
+      amount: 141514000000000000000n,
+      formattedAmount: "1415.14"
+    },
+    validatorAddress: "0xa2705d6b27891f3f5651f26547d1bb79e256f95f249d1ad717cef087d77d38b037e5d6dbaa2538930fd0731ec9b02f3a",
+    earning: 0.145,
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      unstake: [
+        {
+          amount: 16159000000000000000n,
+          formattedAmount: "161.59",
+          timestamp: msToSeconds(Date.now() - 72e6)
+        }
+      ]
+    }
+  },
+  {
+    staked: {
+      amount: 141514000000000000000n,
+      formattedAmount: "1415.14"
+    },
+    validatorAddress: "0xa2705d6b27891f3f5651f26547d1bb79e256f95f249d1ad717cef087d77d38b037e5d6dbaa2538930fd0731ec9b02f3a",
+    earning: 0.145,
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      unstake: [
+        {
+          amount: 16159000000000000000n,
+          formattedAmount: "161.59",
+          timestamp: msToSeconds(Date.now() - 72e6)
+        }
+      ]
+    }
+  },
+  {
+    staked: {
+      amount: 141514000000000000000n,
+      formattedAmount: "1415.14"
+    },
+    validatorAddress: "0xa2705d6b27891f3f5651f26547d1bb79e256f95f249d1ad717cef087d77d38b037e5d6dbaa2538930fd0731ec9b02f3a",
+    earning: 0.145,
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      unstake: [
+        {
+          amount: 16159000000000000000n,
+          formattedAmount: "161.59",
+          timestamp: msToSeconds(Date.now() - 72e6)
+        }
+      ]
+    }
+  },
+  {
+    staked: {
+      amount: 141514000000000000000n,
+      formattedAmount: "1415.14"
+    },
+    validatorAddress: "0xa2705d6b27891f3f5651f26547d1bb79e256f95f249d1ad717cef087d77d38b037e5d6dbaa2538930fd0731ec9b02f3a",
+    earning: 0.145,
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      unstake: [
+        {
+          amount: 16159000000000000000n,
+          formattedAmount: "161.59",
+          timestamp: msToSeconds(Date.now() - 72e6)
+        }
+      ]
+    }
+  },
+  {
+    staked: {
+      amount: 241514000000000000000n,
+      formattedAmount: "2415.14"
+    },
+    validatorAddress: "0xa4e4b63514f54d61da5197359f11ff1fc2930788ba2ffdd30c2fc059cbe0221020197bf9446b16ac347f36c7517a8686",
+    earning: 0.145,
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      unstake: [
+        {
+          amount: 1159000000000000000n,
+          formattedAmount: "11.59",
+          timestamp: msToSeconds(Date.now() - 36e6)
+        }
+      ]
+    }
+  },
+  {
+    validatorAddress: "0xb0511ec039591e98bd4e183ba70b85572214a7ad8ca1a43e96ad3495d3821054927bc542e5482ec9733e35b7ef0b1f03",
+    earning: 0.045,
+    staked: {
+      amount: 141514000000000000000n,
+      formattedAmount: "1415.14"
+    },
+    rewards: {
+      amount: 15414000000000000000n,
+      formattedAmount: "154.14"
+    },
+    queueData: {
+      stake: [
+        {
+          amount: 1159000000000000000n,
+          formattedAmount: "11.59"
+        }
+      ]
+    }
+  }
+];
+async function getUserStakingPositions(account) {
+  await new Promise((resolve) => setTimeout(resolve, 2e3));
+  if (account === "0x4C368fFE3650379d6318C8d4630bc51f8Ad12bB6") {
+    return snowTestWalletPositions;
+  }
+  return [];
+}
+
+// src/actions/validators/getValidatorAnalytics.ts
+async function getValidatorAnalytics({
+  pubkey,
+  dayRange
+}) {
+  if (typeof window === "undefined") {
+    throw new BeraError({
+      message: "getValidatorAnalytics is browser-only; call from a Client Component / SWR hook",
+      level: "error"
+    });
+  }
+  const params = new URLSearchParams({
+    pubkey,
+    dayRange: String(dayRange)
+  });
+  return beraFetchJson({
+    url: `/api/pol/validator-analytics?${params}`,
+    name: "pol-validator-analytics",
+    type: "rest"
+  });
+}
+
+// src/actions/validators/getValidatorCommission.ts
+import { beraChefAbi as beraChefAbi3 } from "@berachain/abis/pol/rewards/beraChef";
+async function getValidatorCommission({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const result = await client.readContract({
+    address: config.pol.beraChef,
+    abi: beraChefAbi3,
+    functionName: "getValCommissionOnIncentiveTokens",
+    args: [pubKey]
+  });
+  return Number(result ?? 0n) / 1e4;
+}
+
+// src/actions/validators/getValidatorEstimatedBgtPerYear.ts
+var getValidatorEstimatedBgtPerYear = (validator, totalStakedBeraAmount, blockTime) => {
+  if (!totalStakedBeraAmount || !validator) return 0;
+  const estimatedBlocksPerYear = yearsInSeconds(1) / blockTime;
+  const estimatedValidatorBlocksPerYear = totalStakedBeraAmount ? estimatedBlocksPerYear * (Number(validator.dynamicData?.stakedBeraAmount) / totalStakedBeraAmount) : 0;
+  return estimatedValidatorBlocksPerYear * Number.parseFloat(validator.dynamicData?.rewardRate ?? "0");
+};
+
+// src/actions/validators/getValidatorOperatorAddress.ts
+import { beaconDepositAbi } from "@berachain/abis/pol/beaconDeposit";
+async function getValidatorOperatorAddress({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const result = await client.readContract({
+      address: config.depositContract,
+      abi: beaconDepositAbi,
+      functionName: "getOperator",
+      args: [pubKey]
+    });
+    return result;
+  } catch (e) {
+    console.log("getValidatorOperatorAddress:", e);
+    throw e;
+  }
+}
+
+// src/actions/validators/getValidatorQueuedCommission.ts
+import { beraChefAbi as beraChefAbi4 } from "@berachain/abis/pol/rewards/beraChef";
+async function getValidatorQueuedCommission({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  const result = await client.readContract({
+    address: config.pol.beraChef,
+    abi: beraChefAbi4,
+    functionName: "getValQueuedCommissionOnIncentiveTokens",
+    args: [pubKey]
+  });
+  return {
+    blockNumberLast: result.blockNumberLast,
+    commissionRate: Number(result.commissionRate) / 1e4
+  };
+}
+
+// src/actions/validators/getValidatorQueuedOperatorAddress.ts
+import { beaconDepositAbi as beaconDepositAbi2 } from "@berachain/abis/pol/beaconDeposit";
+async function getValidatorQueuedOperatorAddress({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const result = await client.readContract({
+      address: config.depositContract,
+      abi: beaconDepositAbi2,
+      functionName: "queuedOperator",
+      args: [pubKey]
+    });
+    return result;
+  } catch (e) {
+    console.log("getValidatorQueuedOperatorAddress:", e);
+    throw e;
+  }
+}
+
+// src/actions/validators/getValidatorQueuedRewardAllocation.ts
+import { beraChefAbi as beraChefAbi5 } from "@berachain/abis/pol/rewards/beraChef";
+async function getValidatorQueuedRewardAllocation({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const result = await client.readContract({
+      address: config.pol.beraChef,
+      abi: beraChefAbi5,
+      functionName: "getQueuedRewardAllocation",
+      args: [pubKey]
+    });
+    return formatValidatorRewardAllocation(result, 0);
+  } catch (e) {
+    console.log("getValidatorQueuedRewardAllocation:", e);
+    throw e;
+  }
+}
+
+export {
+  getConvertToAssets,
+  BaseAggregator,
+  BalancerApi,
+  getAllPools,
+  getApiPool,
+  getGlobalLiquidityAndSwapVolume,
+  getPoolPausedState,
+  getOnChainPool,
+  getPoolEvents,
+  getPoolHistoricalData,
+  getChartData,
+  getCollateralWeights,
+  getTokenInformation,
+  getHoneyCollaterals,
+  isBadCollateralAsset,
+  getGlobalCapLimit,
+  getHoney24hVolume,
+  HoneyPreviewMethod,
+  getHoneyPreview,
+  getHoneyVaultsBalance,
+  getPythLatestPrices,
+  getRelativeCapLimit,
+  getPythUpdateFee,
+  getSwapPayload,
+  isBasketModeEnabled,
+  getBlockTimestamp,
+  getAutoclaimedIncentives,
+  getAutoclaimedIncentivesTxHash,
+  RewardVaultDistributionMode,
+  getRewardVaultRewards,
+  getBgtAprSimulation,
+  getEarnedStakedBeraVault,
+  getRewardVaults,
+  getGlobalData,
+  getIncentiveFeeClaimStats,
+  getMarkets,
+  getRewardProofsByValidator,
+  getRewardTokenToBeraRate,
+  getRewardVault,
+  getRewardVaultIncentives,
+  getRewardVaultStakingToken,
+  getStakedBeraAPR,
+  getStakedBeraSnapshots,
+  getStakeWithdrawalCooldown,
+  getSWBeraVaultMetadata,
+  getSWBeraWithdrawal,
+  getTotalStakedAmount,
+  getUserClaimableIncentives,
+  getUserVaultsReward,
+  getUserVaultInfo,
+  getUserVaults,
+  getVaultHistory,
+  getVaultValidators,
+  getTokenCurrentPrices,
+  getAllowances,
+  isImpersonateAccount,
+  beraWriteContract,
+  getAllValidators,
+  getApiEnrichedAllocation,
+  getApiValidator,
+  getDailyValidatorBlockStats,
+  formatValidatorRewardAllocation,
+  isSameRewardAllocation,
+  getValidatorRewardAllocation,
+  isDefaultRewardAllocation,
+  getDefaultRewardAllocation,
+  getStakingPoolBatch,
+  getUserBoostsOnValidator,
+  getUserActiveValidators,
+  getUserStakingPositions,
+  getValidatorAnalytics,
+  getValidatorCommission,
+  getValidatorEstimatedBgtPerYear,
+  getValidatorOperatorAddress,
+  getValidatorQueuedCommission,
+  getValidatorQueuedOperatorAddress,
+  getValidatorQueuedRewardAllocation
+};