@berachain/berajs 0.2.8-beta.3 → 0.2.8-beta.4

package/dist/chunk-A7P3JVU7.cjs

@@ -0,0 +1,4694 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkMXWPP6MScjs = require('./chunk-MXWPP6MS.cjs');
+
+
+
+
+var _chunk4HDIUUSVcjs = require('./chunk-4HDIUUSV.cjs');
+
+
+
+
+
+
+var _chunk7ONKBHXYcjs = require('./chunk-7ONKBHXY.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk3LXVARBJcjs = require('./chunk-3LXVARBJ.cjs');
+
+
+
+
+
+var _chunkHCC4FJTDcjs = require('./chunk-HCC4FJTD.cjs');
+
+
+
+
+
+
+
+var _chunkQISQSMCVcjs = require('./chunk-QISQSMCV.cjs');
+
+// src/actions/bend/getConvertToAssets.ts
+var _viem = require('viem');
+var _metaMorphoV11 = require('@berachain/abis/bend-metamorpho/metaMorphoV11');
+async function getConvertToAssets({
+  sharesAmount,
+  vaultAddress,
+  publicClient
+}) {
+  const convertToAssets = await publicClient.readContract({
+    address: vaultAddress,
+    abi: _metaMorphoV11.metaMorphoV11Abi,
+    functionName: "convertToAssets",
+    args: [sharesAmount]
+  });
+  return { raw: convertToAssets, formatted: _viem.formatEther.call(void 0, convertToAssets) };
+}
+
+// src/actions/clients/BeraApolloClient.ts
+
+
+
+var _client = require('@apollo/client');
+var _internal = require('@berachain/config/internal');
+var BeraApolloClient = class extends _client.ApolloClient {
+  /**
+   * The URL of the endpoint. Used for error reporting only.
+   */
+  
+  constructor(options) {
+    super(options);
+    this.url = options.url;
+  }
+  async query(options) {
+    const queryName = getQueryName(options.query);
+    const endpoint = {
+      url: this.url,
+      type: "graphql"
+    };
+    const tags = {
+      "operation.type": "query",
+      "operation.source.url": endpoint.url,
+      "operation.source.type": endpoint.type,
+      "operation.source.queryName": queryName
+    };
+    try {
+      const executeQuery = () => super.query(
+        options
+      );
+      const res = await _chunk4HDIUUSVcjs.BeraTracing.startSpan(
+        {
+          name: `GraphQL ${queryName}`,
+          op: "BeraApolloClient.query",
+          attributes: tags
+        },
+        executeQuery
+      );
+      if (res.error || res.data === void 0) {
+        throw new (0, _chunkQISQSMCVcjs.BeraError)({
+          level: "fatal",
+          tags,
+          message: "Bera Apollo Client: No data returned from query, but error should be thrown since errorPolicy is none"
+        });
+      }
+      return { data: res.data };
+    } catch (error) {
+      !_internal.appConfig.env.isProduction && console.error("BeraApolloClient error", error);
+      if (_client.ServerError.is(error)) {
+        throw new (0, _chunkQISQSMCVcjs.RequestError)({
+          // reason: error,
+          response: error.response,
+          cause: error,
+          statusCode: error.statusCode,
+          endpoint,
+          tags
+        });
+      }
+      if (error instanceof TypeError) {
+        throw new (0, _chunkQISQSMCVcjs.RequestError)({
+          level: "fatal",
+          reason: "TypeError",
+          response: error,
+          cause: error,
+          endpoint,
+          tags
+        });
+      }
+      throw new (0, _chunkQISQSMCVcjs.RequestError)({
+        response: error,
+        tags,
+        cause: error,
+        endpoint
+      });
+    }
+  }
+};
+function getQueryName(queryDefinition) {
+  const likelyNode = queryDefinition.definitions.find(
+    (def) => def.kind === "OperationDefinition"
+  );
+  return _optionalChain([likelyNode, 'optionalAccess', _ => _.name, 'optionalAccess', _2 => _2.value]);
+}
+
+// src/actions/clients/getApolloClient.ts
+
+var _http = require('@apollo/client/link/http');
+var _config = require('@berachain/config');
+
+var _api = require('@berachain/graphql/dex/api'); var _api2 = _interopRequireDefault(_api);
+
+function applyStellateClientName(url) {
+  if (!_internal.currentDapp) {
+    return url;
+  }
+  const headers = typeof url === "string" ? void 0 : url.headers;
+  return {
+    uri: _config.getUriFromLink.call(void 0, url),
+    headers: {
+      ...headers,
+      "x-graphql-client-name": `berachain.${_internal.currentDapp}.${process.env.NEXT_RUNTIME || "browser"}`,
+      "x-graphql-client-version": `${process.env.VERCEL_TARGET_ENV}.${process.env.VERCEL_GIT_COMMIT_SHA}`
+    }
+  };
+}
+function getClient(endpoint, {
+  ssrMode,
+  inMemoryCacheOptions
+} = {}) {
+  const url = _config.getUriFromLink.call(void 0, endpoint);
+  const headers = typeof endpoint === "string" ? void 0 : endpoint.headers;
+  return new BeraApolloClient({
+    url,
+    link: new (0, _http.HttpLink)({
+      uri: url,
+      headers
+    }),
+    defaultOptions: {
+      query: {
+        // With the default none error policy, an error causes the promise to reject.
+        errorPolicy: "none",
+        fetchPolicy: "no-cache"
+      }
+    },
+    cache: new (0, _client.InMemoryCache)(inMemoryCacheOptions),
+    ssrMode
+  });
+}
+function getApolloClient(clientName, { ...args }) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  switch (clientName) {
+    case "api":
+      return getClient(applyStellateClientName(config.api), {
+        inMemoryCacheOptions: {
+          possibleTypes: _api2.default.possibleTypes
+        }
+      });
+    case "bend.whisk":
+      if (!config.bend.whiskApi) {
+        throw new (0, _chunkQISQSMCVcjs.BeraError)({
+          message: "Bend whisk API is not configured on this chain",
+          level: "error"
+        });
+      }
+      return getClient(config.bend.whiskApi);
+    case "honey.subgraph":
+      return getClient(config.honey.subgraph);
+    case "pol.subgraph":
+      return getClient(config.pol.subgraph);
+    case "pol.fees":
+      return getClient(config.pol.feesSubgraph);
+    case "governance.subgraph":
+      return getClient(config.governance.subgraph);
+    case "bex.subgraph":
+      return getClient(config.bex.subgraph);
+  }
+}
+
+// src/actions/dex/aggregators/base.ts
+
+var BaseAggregator = (_class = class _BaseAggregator {
+  static __initStatic() {this.PATH_NOT_FOUND_REASON = "NO_SWAP_PATHS"}
+  __init() {this.needsAccountForQuote = false}
+  __init2() {this.notFoundMessages = []}
+  
+  
+  constructor(args = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    const { config, chainId } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, 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.
+   */
+  __init3() {this.url = ""}
+  /**
+   * return wbera for native tokens to accomodate the aggregator's router logic
+   */
+  parseAddresses(tokenIn, tokenOut) {
+    if (!_viem.isAddress.call(void 0, tokenIn) || !_viem.isAddress.call(void 0, tokenOut)) {
+      throw new (0, _chunkQISQSMCVcjs.BeraError)({
+        message: `Invalid address: ${tokenIn} or ${tokenOut}`,
+        level: "error"
+      });
+    }
+    return {
+      tokenInAddress: _chunkHCC4FJTDcjs.isToken.call(void 0, tokenIn, "BERA") ? this.config.tokens.wbera : tokenIn,
+      tokenOutAddress: _chunkHCC4FJTDcjs.isToken.call(void 0, tokenOut, "BERA") ? this.config.tokens.wbera : tokenOut,
+      isTokenInNative: _chunkHCC4FJTDcjs.isToken.call(void 0, tokenIn, "BERA"),
+      isTokenOutNative: _chunkHCC4FJTDcjs.isToken.call(void 0, tokenOut, "BERA")
+    };
+  }
+  /**
+   * Calculate input amount after fees.
+   *
+   * @returns Amount in wad format
+   */
+  getAmountAfterFees(amount, aggregatorsFeeBps) {
+    if (aggregatorsFeeBps === void 0) {
+      throw new (0, _chunkQISQSMCVcjs.BeraError)({
+        message: "aggregatorsFeeBps is required",
+        level: "error"
+      });
+    }
+    const fees = new (0, _chunk3LXVARBJcjs.bignumber_js_default)(amount).times(aggregatorsFeeBps).dividedBy(1e4).toFixed(0, _chunk3LXVARBJcjs.bignumber_js_default.ROUND_DOWN);
+    return new (0, _chunk3LXVARBJcjs.bignumber_js_default)(amount).minus(fees).toFixed(0, _chunk3LXVARBJcjs.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: _nullishCoalesce(permit2SpenderAddress, () => ( _viem.zeroAddress))
+    };
+  }
+  /**
+   * Calculate min amount out
+   */
+  getMinAmountOut(amountOut, slippage) {
+    if (slippage === void 0) {
+      throw new (0, _chunkQISQSMCVcjs.BeraError)({
+        message: "slippage is required",
+        level: "error"
+      });
+    }
+    const minAmountOut = new (0, _chunk3LXVARBJcjs.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 _chunkHCC4FJTDcjs.isToken.call(void 0, tokenIn, "BERA") ? [] : [
+      {
+        token: tokenIn,
+        amount: {
+          raw: rawAmount,
+          formatted: _viem.formatUnits.call(void 0, 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 (0, _chunkQISQSMCVcjs.BeraError)({
+        message: `${this.name} does not support tokens chain ID: ${tokenIn.chainId} and ${tokenOut.chainId}`,
+        level: "error"
+      });
+    }
+  }
+  async fetch(url, options) {
+    try {
+      const response = await _chunk3LXVARBJcjs.beraFetch.call(void 0, 
+        { url, name: this.name, type: this.type },
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          ...options
+        }
+      );
+      return response;
+    } catch (err) {
+      const error = _chunk7ONKBHXYcjs.initBeraError.call(void 0, { cause: err });
+      if (this.notFoundMessages.some((message) => error.message.includes(message))) {
+        error.reason = _BaseAggregator.PATH_NOT_FOUND_REASON;
+      }
+      throw error;
+    }
+  }
+}, _class.__initStatic(), _class);
+
+// src/actions/dex/b-sdk.ts
+
+
+
+
+
+
+
+
+
+
+
+var _berancersdk = require('@berachain-foundation/berancer-sdk');
+
+var _chains = require('viem/chains');
+
+for (const chain of Object.keys(_internal.chainConfigs)) {
+  const { config, chainId } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, {
+    chainId: Number(chain)
+  });
+  _berancersdk.API_CHAIN_NAMES[chainId] = config.bex.chainName;
+  _berancersdk.CHAINS[chainId] = chainId === _chains.berachain.id ? _chains.berachain : _chains.berachainBepolia;
+  _berancersdk.BALANCER_RELAYER[chainId] = config.bex.relayer;
+  _berancersdk.VAULT[chainId] = config.bex.vault;
+  _berancersdk.BALANCER_QUERIES[chainId] = config.bex.queries;
+  _berancersdk.WEIGHTED_POOL_FACTORY_BALANCER_V2[chainId] = _viem.zeroAddress;
+  _berancersdk.COMPOSABLE_STABLE_POOL_FACTORY[chainId] = _viem.zeroAddress;
+  const nativeToken = new (0, _berancersdk.Token)(
+    chainId,
+    _viem.zeroAddress,
+    _chunkHCC4FJTDcjs.beraToken.decimals,
+    _chunkHCC4FJTDcjs.beraToken.name,
+    _chunkHCC4FJTDcjs.beraToken.symbol,
+    config.tokens.wbera
+  );
+  _berancersdk.NATIVE_ASSETS[chainId] = nativeToken;
+}
+
+// src/actions/dex/getAllPools.ts
+
+
+
+
+
+
+var _api3 = require('@berachain/graphql/pol/api');
+async function getAllPools({
+  textSearch,
+  chain,
+  first,
+  orderBy,
+  orderDirection,
+  skip,
+  fetchPolicy,
+  userAddress,
+  blacklistedPoolIds,
+  ...args
+} = {}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const pools = await bexApiGraphqlClient.query({
+    query: _api.GetPools,
+    variables: {
+      textSearch,
+      chain: _nullishCoalesce(chain, () => ( config.bex.chainName)),
+      first,
+      orderBy: _nullishCoalesce(orderBy, () => ( _api3.GqlPoolOrderBy.TotalLiquidity)),
+      orderDirection: _nullishCoalesce(orderDirection, () => ( _api3.GqlPoolOrderDirection.Desc)),
+      skip,
+      userAddress,
+      blacklistedPoolIds
+    },
+    fetchPolicy
+  });
+  return {
+    pools: _nullishCoalesce(pools.data.poolGetPools, () => ( [])),
+    count: _nullishCoalesce(pools.data.count, () => ( 0))
+  };
+}
+
+// src/actions/dex/getApiPool.ts
+
+
+
+async function getApiPool({
+  poolId,
+  account,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const pool = await bexApiGraphqlClient.query({
+    query: _api.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
+
+
+
+async function getGlobalLiquidityAndSwapVolume(args = {}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const response = await bexApiGraphqlClient.query({
+    query: _api.GetGlobalLiquidityAndSwapVolume,
+    variables: {
+      chain: config.bex.chainName
+    }
+  });
+  return response.data;
+}
+
+// src/actions/dex/getPoolPausedState.ts
+
+async function getPoolPausedState({
+  publicClient,
+  poolAddress
+}) {
+  const abi = _berancersdk.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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async function getOnChainPool({
+  poolId,
+  publicClient,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const address = poolId.slice(0, 42);
+  if (!_viem.isAddress.call(void 0, address) || !_viem.isHex.call(void 0, poolId)) {
+    throw new (0, _chunkQISQSMCVcjs.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: _viem.erc20Abi,
+        functionName: "name"
+      }),
+      publicClient.readContract({
+        address: config.bex.vault,
+        abi: _berancersdk.vaultV2Abi,
+        functionName: "getPoolTokens",
+        args: [poolId]
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc20Abi,
+        functionName: "totalSupply"
+      }),
+      publicClient.readContract({
+        address,
+        abi: _berancersdk.weightedPoolV4Abi_V2,
+        functionName: "getSwapFeePercentage"
+      }),
+      publicClient.readContract({
+        address,
+        abi: _berancersdk.weightedPoolV4Abi_V2,
+        functionName: "version"
+      }),
+      publicClient.readContract({
+        address,
+        abi: _berancersdk.weightedPoolV4Abi_V2,
+        functionName: "decimals"
+      }),
+      publicClient.readContract({
+        address: config.bex.factories.composableStable,
+        abi: _berancersdk.weightedPoolFactoryAbi_V3,
+        functionName: "isPoolFromFactory",
+        args: [address]
+      }),
+      publicClient.readContract({
+        address: config.bex.factories.weighted,
+        abi: _berancersdk.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: _berancersdk.stablePoolAbi_V3,
+          functionName: "getAmplificationParameter"
+        })
+      ]);
+    } else if (version.name === "WeightedPool") {
+      weights = await publicClient.readContract({
+        address,
+        abi: _berancersdk.weightedPoolV4Abi_V2,
+        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: _viem.formatUnits.call(void 0, _nullishCoalesce(virtualSupply, () => ( totalSupply)), decimals),
+      swapFee: _viem.formatEther.call(void 0, swapFee),
+      decimals,
+      weights: _optionalChain([weights, 'optionalAccess', _3 => _3.map, 'call', _4 => _4((weight) => _viem.formatEther.call(void 0, weight))]),
+      version,
+      factory: isComposableStable ? config.bex.factories.composableStable : config.bex.factories.weighted,
+      type: isComposableStable ? _api3.GqlPoolType.Stable : _api3.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 _chunk7ONKBHXYcjs.initBeraError.call(void 0, { cause: e });
+  }
+}
+
+// src/actions/dex/getPoolEvents.ts
+
+
+
+async function getPoolEvents({
+  poolId,
+  typeInArray,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const response = await bexApiGraphqlClient.query({
+    query: _api.GetPoolEvents,
+    variables: {
+      poolId,
+      typeIn: typeInArray,
+      chain: config.bex.chainName
+    }
+  });
+  return response.data;
+}
+
+// src/actions/dex/getPoolHistoricalData.ts
+
+
+
+
+async function getPoolHistoricalData({
+  poolId,
+  chain,
+  ...args
+}) {
+  if (!poolId || !_viem.isHex.call(void 0, poolId))
+    throw new (0, _chunkQISQSMCVcjs.InvalidArgumentError)({
+      property: "poolId",
+      value: poolId,
+      expected: "hex string"
+    });
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const { data } = await bexApiGraphqlClient.query({
+    query: _api.GetPoolHistoricalData,
+    variables: { poolId, chain }
+  });
+  return data.poolGetSnapshots;
+}
+
+// src/actions/governance/checkProposalField.ts
+
+var checkProposalField = ({
+  fieldOrType,
+  value,
+  required = true,
+  baseUrl,
+  components
+}) => {
+  const notRequiredAbiTypes = ["bool", "string"];
+  if (!notRequiredAbiTypes.includes(fieldOrType) && required && (value === void 0 || value === null || value === "")) {
+    return "Required" /* REQUIRED */;
+  }
+  if (fieldOrType.startsWith("uint") || fieldOrType.startsWith("int")) {
+    if (typeof value !== "string") {
+      return "Invalid amount" /* INVALID_AMOUNT */;
+    }
+    try {
+      const valueBN = BigInt(value);
+      if (fieldOrType.startsWith("uint")) {
+        if (valueBN < 0n) {
+          return "Negative amount" /* NEGATIVE_AMOUNT */;
+        }
+      }
+    } catch (e2) {
+      return "Invalid amount" /* INVALID_AMOUNT */;
+    }
+    return null;
+  }
+  switch (fieldOrType) {
+    case "string":
+      if (value !== void 0 && typeof value !== "string") {
+        return "Invalid amount" /* INVALID_AMOUNT */;
+      }
+      return null;
+    case "bool":
+      if (typeof value !== "boolean") {
+        return "Invalid amount" /* INVALID_AMOUNT */;
+      }
+      return null;
+    case "title":
+      if (value.length === 0) {
+        return "Required" /* REQUIRED */;
+      }
+      return null;
+    case "description":
+      if (value.length === 0) {
+        return "Required" /* REQUIRED */;
+      }
+      return null;
+    case "forumLink":
+      if (value.length === 0) {
+        return "Required" /* REQUIRED */;
+      }
+      if (!URL.canParse(value)) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      const base = new URL(baseUrl);
+      if (!value.startsWith(base.toString())) {
+        return "Must be a berachain forum link" /* INVALID_BASEPATH */;
+      }
+      return null;
+    case "address":
+      if (!_viem.isAddress.call(void 0, value, { strict: true })) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      return null;
+    case "hex":
+      if (!_viem.isHex.call(void 0, value, { strict: true })) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      return null;
+    case "abi":
+      try {
+        JSON.parse(value);
+      } catch (e3) {
+        return "Invalid ABI" /* INVALID_ABI */;
+      }
+      return null;
+    case "action":
+      if (!_viem.isAddress.call(void 0, value, { strict: true })) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      return null;
+    case "tuple":
+      if (typeof value === "object" && Array.isArray(components)) {
+        const errors = {};
+        for (const component of components) {
+          errors[component.name] = checkProposalField({
+            fieldOrType: component.type,
+            value: value[component.name],
+            components: component.components
+          });
+        }
+        if (Object.values(errors).every((v) => v === null)) {
+          return null;
+        }
+        return errors;
+      }
+      return null;
+    case "tuple[]":
+      if (Array.isArray(value)) {
+        const errors = value.map(
+          (v) => checkProposalField({
+            fieldOrType: "tuple",
+            value: v,
+            components
+          })
+        );
+        if (errors.every((v) => v === null)) {
+          return null;
+        }
+        return errors;
+      }
+      return null;
+    case "logoURI": {
+      if (value === void 0 || value === "") {
+        return null;
+      }
+      if (URL.canParse(value) && new URL(value).protocol === "https:") {
+        return null;
+      }
+      return "Must be HTTPS or IPFS" /* MUST_BE_HTTPS_OR_IPFS */;
+    }
+    case "url": {
+      if (value === void 0 || value === "") {
+        return null;
+      }
+      if (URL.canParse(value) && new URL(value).protocol === "https:") {
+        return null;
+      }
+      return "Must be HTTPS" /* MUST_BE_HTTPS */;
+    }
+    default:
+      console.error(`Invalid field or type: ${fieldOrType}`);
+      return null;
+  }
+};
+
+// src/actions/governance/computeActualStatus.ts
+
+
+var _governance = require('@berachain/graphql/governance');
+var GOVERNANCE_ACCELERATE_PROPOSAL = false;
+var MOCKED_PROPOSAL_STATUSES = [
+  _governance.ProposalStatus.Active,
+  _governance.ProposalStatus.PendingQueue,
+  _governance.ProposalStatus.PendingExecution,
+  _governance.ProposalStatus.Defeated,
+  _governance.ProposalStatus.QuorumNotReached
+];
+function computeActualStatus(proposal, proposalOnChainState) {
+  const timestampInSeconds = Date.now() / 1e3;
+  if (proposalOnChainState !== void 0) {
+    if (proposal.status === _governance.ProposalStatus.CanceledByGuardian) {
+      return _governance.ProposalStatus.CanceledByGuardian;
+    }
+    if (proposalOnChainState === 2 /* Canceled */) {
+      if (Number(proposal.voteStartAt) < timestampInSeconds)
+        return _governance.ProposalStatus.CanceledByUser;
+      return _governance.ProposalStatus.CanceledByGuardian;
+    }
+    if (proposalOnChainState === 3 /* Defeated */) {
+      if (!proposal.pollResult) {
+        return _governance.ProposalStatus.QuorumNotReached;
+      }
+      if (
+        // Quorum might be null if no votes were cast.
+        !proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)
+      ) {
+        return _governance.ProposalStatus.QuorumNotReached;
+      }
+      return _governance.ProposalStatus.Defeated;
+    }
+    if (proposalOnChainState === 4 /* Succeeded */) {
+      return _governance.ProposalStatus.PendingQueue;
+    }
+    if (proposalOnChainState === 5 /* Queued */) {
+      if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+        return _governance.ProposalStatus.PendingExecution;
+      }
+      return _governance.ProposalStatus.InQueue;
+    }
+    if (proposalOnChainState === 6 /* Expired */) {
+      console.warn("Unexpected expired state on proposal id: ", proposal.id);
+      return _governance.ProposalStatus.Defeated;
+    }
+  }
+  if (proposal.status === _governance.ProposalStatus.InQueue) {
+    if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+      return _governance.ProposalStatus.PendingExecution;
+    }
+  }
+  if (GOVERNANCE_ACCELERATE_PROPOSAL && proposalOnChainState === 1 /* Active */ && proposal.quorum && BigInt(proposal.quorum) < BigInt(proposal.pollResult.totalTowardsQuorum) && Number(proposal.pollResult.forPercentage) > Number(proposal.pollResult.againstPercentage)) {
+    return _governance.ProposalStatus.PendingQueue;
+  }
+  if (proposal.status === _governance.ProposalStatus.Pending) {
+    if (Number(proposal.voteStartAt) < timestampInSeconds && Number(proposal.voteEndAt) > timestampInSeconds) {
+      return _governance.ProposalStatus.Active;
+    }
+    if (Number(proposal.voteEndAt) < timestampInSeconds) {
+      if (!proposal.pollResult) {
+        return _governance.ProposalStatus.QuorumNotReached;
+      }
+      if (!proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)) {
+        return _governance.ProposalStatus.QuorumNotReached;
+      }
+      if (_optionalChain([proposal, 'access', _5 => _5.pollResult, 'optionalAccess', _6 => _6.against]) > _optionalChain([proposal, 'access', _7 => _7.pollResult, 'optionalAccess', _8 => _8.for])) {
+        return _governance.ProposalStatus.Defeated;
+      }
+      return _governance.ProposalStatus.PendingQueue;
+    }
+    return _governance.ProposalStatus.Pending;
+  }
+  if (proposal.status === _governance.ProposalStatus.Active && Number(proposal.voteEndAt) < timestampInSeconds) {
+    if (!proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)) {
+      return _governance.ProposalStatus.QuorumNotReached;
+    }
+    if (BigInt(_nullishCoalesce(_optionalChain([proposal, 'access', _9 => _9.pollResult, 'optionalAccess', _10 => _10.against]), () => ( 0n))) > BigInt(_nullishCoalesce(_optionalChain([proposal, 'access', _11 => _11.pollResult, 'optionalAccess', _12 => _12.for]), () => ( 0n)))) {
+      return _governance.ProposalStatus.Defeated;
+    }
+    return _governance.ProposalStatus.PendingQueue;
+  }
+  if (proposal.status === _governance.ProposalStatus.InQueue) {
+    if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+      return _governance.ProposalStatus.PendingExecution;
+    }
+  }
+  return proposal.status;
+}
+
+// src/actions/governance/getAllProposals.ts
+
+
+
+
+async function getAllProposals({
+  where,
+  orderBy,
+  orderDirection,
+  offset = 0,
+  perPage = 20,
+  text,
+  ...args
+}) {
+  try {
+    if (perPage > 1e3) {
+      throw new Error("perPage must be less than 1000");
+    }
+    const governanceClient = getApolloClient("governance.subgraph", args);
+    const [response] = await Promise.all([
+      text ? governanceClient.query({
+        query: _governance.SearchProposals,
+        variables: {
+          offset,
+          limit: perPage,
+          where,
+          text
+        }
+      }) : governanceClient.query(
+        {
+          query: _governance.GetProposals,
+          variables: {
+            offset,
+            limit: perPage,
+            where,
+            orderBy,
+            orderDirection
+          }
+        }
+      )
+    ]);
+    return response.data.proposals.map((p) => ({
+      ...p,
+      status: computeActualStatus(p)
+    }));
+  } catch (e) {
+    console.error("getAllProposals:", e);
+    throw e;
+  }
+}
+
+// src/actions/governance/getBodyErrors.ts
+var getBodyErrors = (proposal, currentTopic) => {
+  const e = {};
+  e.title = checkProposalField({
+    fieldOrType: "title",
+    value: proposal.title
+  });
+  e.description = checkProposalField({
+    fieldOrType: "description",
+    value: proposal.description
+  });
+  e.forumLink = checkProposalField({
+    fieldOrType: "forumLink",
+    value: proposal.forumLink,
+    baseUrl: currentTopic.forumLink
+  });
+  return e;
+};
+
+// src/actions/governance/getProposalDetails.ts
+
+
+
+async function getProposalDetails({
+  proposalId,
+  ...args
+}) {
+  const governanceClient = getApolloClient("governance.subgraph", args);
+  const res = await governanceClient.query({
+    query: _governance.GetProposal,
+    variables: {
+      id: proposalId
+    }
+  });
+  if (!res.data.proposal) {
+    return void 0;
+  }
+  return {
+    ...res.data.proposal,
+    status: computeActualStatus(res.data.proposal)
+  };
+}
+
+// src/actions/governance/parseProposalBody.ts
+var _graymatter = require('gray-matter'); var _graymatter2 = _interopRequireDefault(_graymatter);
+var parseLegacyBody = (s) => {
+  const pattern = /#(?:([\w-]+)# )?(.+)\n([\s\S]*)/;
+  const match = s.match(pattern);
+  if (match) {
+    const type = match[1] || null;
+    const title = match[2];
+    const content = match[3].replace("\n", "<br />");
+    return {
+      type,
+      title,
+      content
+    };
+  }
+  throw new Error("Invalid proposal body");
+};
+var parseProposalBody = (proposal) => {
+  if (!proposal) {
+    return {
+      isFrontMatter: false,
+      data: { title: "Loading..." },
+      content: "",
+      matter: "",
+      language: "",
+      orig: "",
+      stringify: () => ""
+    };
+  }
+  const body = _nullishCoalesce(_optionalChain([proposal, 'optionalAccess', _13 => _13.description]), () => ( ""));
+  if (_graymatter2.default.test(body)) {
+    return { ..._graymatter2.default.call(void 0, body), isFrontMatter: true };
+  }
+  try {
+    const legacyBody = parseLegacyBody(body);
+    return {
+      isFrontMatter: false,
+      data: { title: legacyBody.title },
+      content: legacyBody.content,
+      matter: "",
+      language: "",
+      orig: body,
+      stringify: () => body
+    };
+  } catch (e4) {
+    return {
+      isFrontMatter: false,
+      data: {
+        title: _optionalChain([proposal, 'optionalAccess', _14 => _14.description, 'optionalAccess', _15 => _15.split, 'call', _16 => _16("\n"), 'access', _17 => _17[0], 'access', _18 => _18.slice, 'call', _19 => _19(0, 100)])
+      },
+      content: body,
+      matter: "",
+      language: "",
+      orig: body,
+      stringify: () => body
+    };
+  }
+};
+
+// src/actions/governance/getProposalFromTx.ts
+
+
+
+var _berachainGovernance = require('@berachain/abis/gov/berachainGovernance');
+
+
+
+async function getProposalFromTx(args) {
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, args.publicClient);
+  let tx;
+  if ("tx" in args) {
+    tx = args.tx;
+  } else {
+    tx = await args.publicClient.getTransactionReceipt({ hash: args.txHash });
+  }
+  const creationEvent = _optionalChain([tx, 'optionalAccess', _20 => _20.logs]) ? _optionalChain([_viem.parseEventLogs.call(void 0, {
+    abi: _berachainGovernance.berachainGovernanceAbi,
+    logs: tx.logs,
+    eventName: "ProposalCreated"
+  }), 'optionalAccess', _21 => _21.at, 'call', _22 => _22(0)]) : void 0;
+  if (!tx || !creationEvent) {
+    return null;
+  }
+  const block = await args.publicClient.getBlock({
+    blockNumber: tx.blockNumber
+  });
+  const fm = parseProposalBody({
+    description: _optionalChain([creationEvent, 'optionalAccess', _23 => _23.args, 'access', _24 => _24.description])
+  });
+  return {
+    id: String(creationEvent.args.proposalId),
+    proposalId: String(_optionalChain([creationEvent, 'optionalAccess', _25 => _25.args, 'access', _26 => _26.proposalId])),
+    createdAt: block.timestamp.toString(),
+    title: fm.data.title,
+    createdAtBlock: block.timestamp.toString(),
+    voteStartAt: String(_optionalChain([creationEvent, 'optionalAccess', _27 => _27.args, 'access', _28 => _28.voteStart])),
+    voteEndAt: String(_optionalChain([creationEvent, 'optionalAccess', _29 => _29.args, 'access', _30 => _30.voteEnd])),
+    proposer: _optionalChain([creationEvent, 'optionalAccess', _31 => _31.args, 'access', _32 => _32.proposer]),
+    description: fm.content,
+    unverifiedForumLink: fm.data.forumLink,
+    pollResult: {
+      for: "0",
+      forVotersCount: 0,
+      forPercentage: "0",
+      against: "0",
+      againstVotersCount: 0,
+      againstPercentage: "0",
+      abstain: "0",
+      abstainVotersCount: 0,
+      abstainPercentage: "0",
+      total: "0",
+      totalVotersCount: 0,
+      totalTowardsQuorum: "0"
+    },
+    status: _governance.ProposalStatus.Pending,
+    quorum: null,
+    topics: fm.data.topics,
+    votes: [],
+    executableCalls: _optionalChain([creationEvent, 'optionalAccess', _33 => _33.args, 'access', _34 => _34.targets, 'access', _35 => _35.map, 'call', _36 => _36(
+      (target, index) => ({
+        __typename: "ExecutableCall",
+        id: `${tx.transactionHash}-${index}`,
+        target,
+        value: String(_optionalChain([creationEvent, 'optionalAccess', _37 => _37.args, 'access', _38 => _38.values, 'access', _39 => _39[index]])),
+        calldata: _optionalChain([creationEvent, 'optionalAccess', _40 => _40.args, 'access', _41 => _41.calldatas, 'access', _42 => _42[index]])
+      })
+    )]),
+    timelock: void 0
+  };
+}
+
+// src/actions/governance/getProposalVotes.ts
+
+
+
+async function getProposalVotes({
+  variables,
+  ...args
+}) {
+  const governanceClient = getApolloClient("governance.subgraph", args);
+  return governanceClient.query({
+    query: _governance.GetProposalVotes,
+    variables
+  });
+}
+
+// src/actions/honey/getChartData.ts
+
+
+
+var _honey = require('@berachain/graphql/honey');
+async function getChartData({
+  days: days2,
+  ...args
+}) {
+  const client = getApolloClient("honey.subgraph", args);
+  const res = await client.query(
+    {
+      query: _honey.GetChartData,
+      variables: {
+        interval: _honey.Aggregation_Interval.Day,
+        first: days2
+      }
+    }
+  );
+  return res.data;
+}
+
+// src/actions/honey/getCollateralWeights.ts
+var _honeyFactory = require('@berachain/abis/honey/honeyFactory');
+async function getCollateralWeights({
+  client,
+  collateralList,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const collateralWeights = await client.readContract({
+      address: config.honey.factory,
+      abi: _honeyFactory.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
+
+async function getTokenInformation({
+  address,
+  publicClient,
+  chainId
+}) {
+  try {
+    if (!publicClient) {
+      throw new Error("Public client not found");
+    }
+    const [decimals, name, symbol] = await Promise.all([
+      publicClient.readContract({
+        address,
+        abi: _viem.erc20Abi,
+        functionName: "decimals"
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc20Abi,
+        functionName: "name"
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc20Abi,
+        functionName: "symbol"
+      })
+    ]);
+    const token = {
+      address,
+      decimals,
+      name,
+      symbol,
+      chainId
+    };
+    if (typeof token.decimals !== "number" || typeof token.name !== "string" || typeof token.symbol !== "string")
+      throw new Error(`Invalid ERC20 token. Address: ${address}`);
+    return token;
+  } catch (e) {
+    console.error(e);
+    throw _chunk7ONKBHXYcjs.initBeraError.call(void 0, { cause: e });
+  }
+}
+
+// src/actions/honey/getHoneyCollaterals.ts
+
+async function getHoneyCollaterals({
+  client,
+  tokenData,
+  preferredCollateralOrder,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const [amountOfCollaterals, referenceCollateralAddress] = await Promise.all([
+    client.readContract({
+      address: config.honey.factory,
+      abi: _honeyFactory.honeyFactoryAbi,
+      functionName: "numRegisteredAssets"
+    }),
+    client.readContract({
+      address: config.honey.factory,
+      abi: _honeyFactory.honeyFactoryAbi,
+      functionName: "referenceCollateral"
+    })
+  ]);
+  const promiseList = [];
+  for (let i = 0; i < amountOfCollaterals; i++) {
+    promiseList.push(
+      client.readContract({
+        address: config.honey.factory,
+        abi: _honeyFactory.honeyFactoryAbi,
+        functionName: "registeredAssets",
+        args: [BigInt(i)]
+      })
+    );
+  }
+  const collaterals = await Promise.all(promiseList);
+  const collateralsTokens = await Promise.all(
+    collaterals.map((coll) => {
+      const token = _optionalChain([tokenData, 'optionalAccess', _43 => _43.find, 'call', _44 => _44((token2) => _chunkHCC4FJTDcjs.isToken.call(void 0, 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 (_optionalChain([preferredCollateralOrder, 'optionalAccess', _45 => _45.length])) {
+    const newCollateralOrder = [];
+    for (const override of preferredCollateralOrder) {
+      const newFirstCollateral = collateralTokens.find(
+        (coll) => _chunkHCC4FJTDcjs.isToken.call(void 0, coll.address, override.address)
+      );
+      if (newFirstCollateral) {
+        newCollateralOrder.push(newFirstCollateral);
+        collateralTokens.splice(
+          collateralTokens.indexOf(newFirstCollateral),
+          1
+        );
+      }
+    }
+    collateralTokens.unshift(...newCollateralOrder);
+  }
+  const referenceCollateral = collateralTokens.find(
+    (coll) => _chunkHCC4FJTDcjs.isToken.call(void 0, 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
+
+
+var _honeyFactoryReader = require('@berachain/abis/honey/honeyFactoryReader');
+async function isBadCollateralAsset({
+  client,
+  collateral,
+  latestPrices,
+  isPythWrapperEnabled,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const isBadCollateralCall = client.readContract({
+      address: config.honey.factory,
+      abi: _honeyFactory.honeyFactoryAbi,
+      functionName: "isBadCollateralAsset",
+      args: [collateral.address]
+    });
+    let isPeggedCall = client.readContract({
+      address: config.honey.factory,
+      abi: _honeyFactory.honeyFactoryAbi,
+      functionName: "isPegged",
+      args: [collateral.address]
+    });
+    if (isPythWrapperEnabled && latestPrices) {
+      const prices = latestPrices.prices.map((price) => _viem.parseUnits.call(void 0, price, 18));
+      isPeggedCall = client.readContract({
+        address: config.honey.reader,
+        abi: _honeyFactoryReader.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
+
+
+
+// src/actions/honey/getSharesWithoutFees.ts
+
+var _collateralVault = require('@berachain/abis/honey/collateralVault');
+
+async function getSharesWithoutFees({
+  client,
+  asset,
+  amount,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const [vault, fees] = await Promise.all([
+      client.readContract({
+        address: config.honey.factory,
+        abi: _honeyFactory.honeyFactoryAbi,
+        functionName: "vaults",
+        args: [asset]
+      }),
+      client.readContract({
+        address: config.honey.factory,
+        abi: _honeyFactory.honeyFactoryAbi,
+        functionName: "collectedFees",
+        args: [config.honey.factory, asset]
+      })
+    ]);
+    const balance = await client.readContract({
+      address: vault,
+      abi: _collateralVault.collateralVaultAbi,
+      functionName: "balanceOf",
+      args: [config.honey.factory]
+    });
+    return balance + _viem.parseEther.call(void 0, _nullishCoalesce(amount, () => ( "0"))) - fees;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}
+
+// src/actions/honey/getGlobalCapLimit.ts
+var ONE_HUNDRED_PERCENT = _viem.parseEther.call(void 0, "1");
+async function getGlobalCapLimit({
+  client,
+  asset,
+  amount,
+  isMint,
+  isPythWrapperEnabled,
+  latestPrices,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const globalCap = await client.readContract({
+      address: config.honey.factory,
+      abi: _honeyFactory.honeyFactoryAbi,
+      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 && _chunkHCC4FJTDcjs.isToken.call(void 0, registeredAssets[idx], asset) || !isMint && _chunkHCC4FJTDcjs.isToken.call(void 0, registeredAssets[idx], asset)) {
+        const weight = weights[idx];
+        if (weight > globalCap - _chunk3LXVARBJcjs.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 (_optionalChain([isBad, 'optionalAccess', _46 => _46.isBlacklisted]) || _optionalChain([isBad, 'optionalAccess', _47 => _47.isDepegged])) {
+      continue;
+    }
+    const share = await getSharesWithoutFees({
+      client,
+      asset: singleAsset.address,
+      amount: _chunkHCC4FJTDcjs.isToken.call(void 0, singleAsset, asset) ? amount : "0"
+    });
+    if (!share) {
+      continue;
+    }
+    sum += share;
+    weights.push(share);
+  }
+  if (sum === 0n) {
+    return weights;
+  }
+  for (const idx in registeredAssets) {
+    weights[idx] = _viem.parseEther.call(void 0, weights[idx].toString()) / sum;
+  }
+  return weights;
+}
+
+// src/actions/honey/getHoneyGlobalData.ts
+
+
+
+async function getHoneyGlobalData({
+  ...args
+} = {}) {
+  const client = getApolloClient("honey.subgraph", args);
+  const result = await client.query({
+    query: _honey.GetGlobalData
+  });
+  return result.data;
+}
+
+// src/actions/honey/getHoneyPreview.ts
+
+
+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 } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, baseArgs);
+  try {
+    const isAmountHoney = method === "previewMintHoney" /* Mint */ || method === "previewRedeemHoney" /* HoneyToRedeem */ || method === "previewMintHoneyWithPrices" /* MintWithPrice */ || method === "previewRedeemHoneyWithPrices" /* HoneyToRedeemWithPrice */;
+    const formattedAmount = _viem.parseUnits.call(void 0, 
+      amount,
+      isAmountHoney ? collateral.decimals : 18
+    );
+    let formattedResult;
+    let args = [collateral.address, formattedAmount];
+    if (isPythWrapperEnabled && latestPrices) {
+      const prices = latestPrices.prices.map((price) => _viem.parseUnits.call(void 0, price, 18));
+      args = [collateral.address, formattedAmount, prices];
+    }
+    if (isAmountHoney) {
+      const result = await client.readContract({
+        address: config.honey.reader,
+        abi: _honeyFactoryReader.honeyFactoryReaderAbi,
+        functionName: method,
+        args
+      });
+      formattedResult = {
+        collaterals: result[0],
+        honey: result[1]
+      };
+    } else {
+      const result = await client.readContract({
+        address: config.honey.reader,
+        abi: _honeyFactoryReader.honeyFactoryReaderAbi,
+        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
+
+
+
+async function getHoneyVaultsBalance({
+  client,
+  collateralList,
+  honeyFactoryAddress,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const factory = _nullishCoalesce(honeyFactoryAddress, () => ( config.honey.factory));
+  const vaults = await Promise.all(
+    collateralList.map(async (coll) => {
+      const vault = await client.readContract({
+        address: config.honey.factory,
+        abi: _honeyFactory.honeyFactoryAbi,
+        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: _collateralVault.collateralVaultAbi,
+          functionName: "balanceOf",
+          args: [factory]
+        }),
+        client.readContract({
+          address: factory,
+          abi: _honeyFactory.honeyFactoryAbi,
+          functionName: "collectedAssetFees",
+          args: [coll.address]
+        }),
+        client.readContract({
+          address: vault,
+          abi: _collateralVault.collateralVaultAbi,
+          functionName: "custodyInfo"
+        })
+      ]);
+      const balance = await client.readContract({
+        address: vault,
+        abi: _collateralVault.collateralVaultAbi,
+        functionName: "convertToAssets",
+        args: [shares - feeShares]
+      });
+      return {
+        ...coll,
+        balance: {
+          raw: balance.toString(),
+          formatted: _viem.formatUnits.call(void 0, balance, coll.decimals)
+        },
+        vault: isCustodian ? custodianAddress : vault
+      };
+    })
+  );
+  return vaults;
+}
+
+// src/actions/honey/getPythLatestPrices.ts
+var _hermesclient = require('@pythnetwork/hermes-client');
+
+var pythEndpoint = "https://hermes.pyth.network";
+async function getPythLatestPrices({
+  priceFeedId
+}) {
+  const hermesClient = new (0, _hermesclient.HermesClient)(pythEndpoint, {});
+  const updates = await hermesClient.getLatestPriceUpdates(priceFeedId, {
+    encoding: "hex",
+    parsed: true
+  });
+  return {
+    calldata: updates.binary.data.map((d) => `0x${d}`),
+    prices: _nullishCoalesce(_optionalChain([updates, 'access', _48 => _48.parsed, 'optionalAccess', _49 => _49.flatMap, 'call', _50 => _50(
+      (p) => _viem.formatUnits.call(void 0, BigInt(p.price.price), p.price.expo * -1)
+    )]), () => ( []))
+  };
+}
+
+// src/actions/honey/getRelativeCapLimit.ts
+
+
+async function getRelativeCapLimit({
+  client,
+  asset,
+  amount,
+  isMint,
+  referenceCollateral,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  if (asset === referenceCollateral.address) {
+    return false;
+  }
+  try {
+    const [assetRelativeCap] = await Promise.all([
+      client.readContract({
+        address: config.honey.factory,
+        abi: _honeyFactory.honeyFactoryAbi,
+        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 = _viem.parseEther.call(void 0, (_nullishCoalesce(assetBalance, () => ( 0n))).toString()) / (_nullishCoalesce(referenceCollateralBalance, () => ( 0n)));
+    if (weight >= assetRelativeCap - _chunk3LXVARBJcjs.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 } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const result = await client.readContract({
+      address: config.external.pyth,
+      abi: _chunkMXWPP6MScjs.pythAbi,
+      functionName: "getUpdateFee",
+      args: [priceFeedId]
+    });
+    return result;
+  } catch (e) {
+    console.error("getPythUpdateFee", e);
+    throw e;
+  }
+}
+
+// src/actions/honey/getSwapPayload.ts
+
+
+
+
+var _honeyFactoryPythWrapper = require('@berachain/abis/honey/honeyFactoryPythWrapper');
+var getSwapPayload = async ({
+  state,
+  publicClient,
+  priceFeedMap,
+  collateralList,
+  isPythWrapperEnabled,
+  ...args
+}) => {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const honeyToken = _chunkHCC4FJTDcjs.getHoneyToken.call(void 0, 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 (e5) {
+        pythUpdateFee = _chunk3LXVARBJcjs.getPythDefaultUpdateFee.call(void 0, collaterals.length);
+      }
+      return ({ account }) => {
+        const pythPayload = [
+          calldata,
+          _optionalChain([collaterals, 'access', _51 => _51[0], 'optionalAccess', _52 => _52.address]),
+          _viem.parseUnits.call(void 0, 
+            fromAmount[0],
+            _nullishCoalesce((isMint ? _optionalChain([collaterals, 'access', _53 => _53[0], 'optionalAccess', _54 => _54.decimals]) : _optionalChain([honeyToken, 'optionalAccess', _55 => _55.decimals])), () => ( 18))
+          ),
+          account,
+          !!isBasketModeEnabled2
+        ];
+        return {
+          address: destinationContractAddress,
+          abi: _honeyFactoryPythWrapper.honeyFactoryPythWrapperAbi,
+          functionName: isMint ? "mint" : "redeem",
+          params: pythPayload,
+          value: pythUpdateFee
+        };
+      };
+    }
+    return ({ account }) => {
+      const defaultPayload = [
+        _optionalChain([collaterals, 'access', _56 => _56[0], 'optionalAccess', _57 => _57.address]),
+        _viem.parseUnits.call(void 0, 
+          fromAmount[0],
+          _nullishCoalesce((isMint ? _optionalChain([collaterals, 'access', _58 => _58[0], 'optionalAccess', _59 => _59.decimals]) : _optionalChain([honeyToken, 'optionalAccess', _60 => _60.decimals])), () => ( 18))
+        ),
+        account,
+        !!isBasketModeEnabled2
+      ];
+      return {
+        value: 0n,
+        address: destinationContractAddress,
+        abi: _honeyFactory.honeyFactoryAbi,
+        functionName: isMint ? "mint" : "redeem",
+        params: defaultPayload
+      };
+    };
+  }
+  throw new Error("Something went wrong while creating the Honey swap payload");
+};
+
+// src/actions/honey/isBasketModeEnabled.ts
+
+
+
+async function isBasketModeEnabled({
+  client,
+  isMint,
+  collateralList,
+  latestPrices,
+  isPythWrapperEnabled,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  if (isPythWrapperEnabled && latestPrices) {
+    if (collateralList.length === 0) return void 0;
+    const prices = latestPrices.prices.map((price) => _viem.parseUnits.call(void 0, price, 18));
+    const isActive2 = await client.readContract({
+      address: config.honey.reader,
+      abi: _honeyFactoryReader.honeyFactoryReaderAbi,
+      functionName: "isBasketModeEnabledWithPrices",
+      args: [isMint, prices]
+    });
+    return isActive2;
+  }
+  const isActive = await client.readContract({
+    address: config.honey.factory,
+    abi: _honeyFactory.honeyFactoryAbi,
+    functionName: "isBasketModeEnabled",
+    args: [isMint]
+  });
+  return isActive;
+}
+
+// src/actions/misc/getBlockTimestamp.ts
+async function getBlockTimestamp({
+  block,
+  currentBlock,
+  blockTime,
+  publicClient
+}) {
+  _chunk7ONKBHXYcjs.assertDefined.call(void 0, block, "block");
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient);
+  if (currentBlock > block) {
+    const blockData = await publicClient.getBlock({
+      blockNumber: BigInt(block),
+      includeTransactions: false
+    });
+    return {
+      timestamp: Number(blockData.timestamp)
+    };
+  }
+  const ts = _chunk3LXVARBJcjs.msToSeconds.call(void 0, Date.now()) + blockTime * (Number(block) - Number(currentBlock));
+  return {
+    timestamp: ts
+  };
+}
+
+// src/actions/pol/getRewardVaultRewards.ts
+
+var _rewardVault = require('@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: _rewardVault.rewardVaultAbi,
+      functionName: "rewardsDuration"
+    }),
+    publicClient.readContract({
+      address,
+      abi: _rewardVault.rewardVaultAbi,
+      functionName: "rewardVaultManager"
+    }),
+    publicClient.readContract({
+      address,
+      abi: _rewardVault.rewardVaultAbi,
+      functionName: "rewardRate"
+    }),
+    publicClient.readContract({
+      address,
+      abi: _rewardVault.rewardVaultAbi,
+      functionName: "periodFinish"
+    }),
+    publicClient.readContract({
+      address,
+      abi: _rewardVault.rewardVaultAbi,
+      functionName: "targetRewardsPerSecond"
+    }),
+    publicClient.readContract({
+      address,
+      abi: _rewardVault.rewardVaultAbi,
+      functionName: "minRewardDurationForTargetRate"
+    })
+  ]);
+  const availableRewards = rewardRate * (periodFinish - BigInt(_chunk3LXVARBJcjs.msToSeconds.call(void 0, Date.now()))) / 10n ** 18n;
+  return {
+    rewardsDuration: Number(rewardsDuration),
+    mode: targetRewardsPerSecond === 0n ? "duration" /* Duration */ : "targetRate" /* TargetRate */,
+    manager,
+    // 36 decimals for the reward rate
+    rewardRate: _viem.formatUnits.call(void 0, rewardRate, 36),
+    periodFinish: Number(periodFinish),
+    // 36 decimals for the reward rate
+    availableRewards: _viem.formatUnits.call(void 0, availableRewards, 18),
+    minRewardDurationForTargetRate: Number(minRewardDurationForTargetRate),
+    targetRewardsPerSecond: _viem.formatUnits.call(void 0, targetRewardsPerSecond, 36)
+  };
+}
+
+// src/actions/pol/getBgtAprSimulation.ts
+function _getApr(tvl, bgtPrice, rewardRate) {
+  return tvl ? rewardRate * bgtPrice * _chunk3LXVARBJcjs.yearsInSeconds.call(void 0, 1) / tvl : null;
+}
+function _getRewardRate(apr, bgtPrice, tvl) {
+  return tvl ? apr * tvl / (bgtPrice * _chunk3LXVARBJcjs.yearsInSeconds.call(void 0, 1)) : 0;
+}
+function getBgtAprSimulation({
+  availableRewards,
+  periodFinish,
+  tvl,
+  bgtPrice,
+  MIN_REWARD_DURATION,
+  MAX_REWARD_DURATION,
+  ...args
+}) {
+  const currentTime = _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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 } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const url = `${config.staking}/vaults/${address}/earnings/${account}`;
+  return _chunk3LXVARBJcjs.beraFetchJson.call(void 0, { url, type: "rest" });
+}
+
+// src/actions/pol/getRewardVaults.ts
+
+
+
+
+
+async function getRewardVaults({
+  filter,
+  publicClient,
+  ...args
+} = {}) {
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const res = await bexApiGraphqlClient.query({
+    query: _api3.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: _rewardVault.rewardVaultAbi,
+            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 = _optionalChain([incentives, 'access', _61 => _61[index], 'optionalAccess', _62 => _62.status]) === "fulfilled" && _optionalChain([incentives, 'access', _63 => _63[index], 'optionalAccess', _64 => _64.value, 'optionalAccess', _65 => _65[incIdx], 'optionalAccess', _66 => _66.status]) === "fulfilled" ? _viem.formatUnits.call(void 0, 
+        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,
+        allTimeReceivedBGTAmount: _nullishCoalesce(_optionalChain([vault, 'access', _67 => _67.dynamicData, 'optionalAccess', _68 => _68.allTimeReceivedBGTAmount]), () => ( "0")),
+        bgtCapturePercentage: _nullishCoalesce(_optionalChain([vault, 'access', _69 => _69.dynamicData, 'optionalAccess', _70 => _70.bgtCapturePercentage]), () => ( "0")),
+        activeIncentivesValueUsd: totalIncentiveInUsdc.toString(),
+        activeIncentivesRateUsd: _nullishCoalesce(_optionalChain([vault, 'access', _71 => _71.dynamicData, 'optionalAccess', _72 => _72.activeIncentivesRateUsd]), () => ( "0")),
+        bgtCapturePerBlock: _nullishCoalesce(_optionalChain([vault, 'access', _73 => _73.dynamicData, 'optionalAccess', _74 => _74.bgtCapturePerBlock]), () => ( "0"))
+      },
+      activeIncentives: incentivesArray
+    };
+  });
+  return {
+    pagination: res.data.polGetRewardVaults.pagination,
+    gaugeList: vaults
+  };
+}
+
+// src/actions/pol/getBGTGlobalInfo.ts
+
+
+
+async function getBGTGlobalInfo(args = {}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const apiRes = await bexApiGraphqlClient.query({
+    query: _api3.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
+
+var _bgt = require('@berachain/abis/pol/bgt');
+async function getBgtTokenTotalBoosts({
+  publicClient,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient);
+  try {
+    const result = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: _bgt.bgtAbi,
+      functionName: "totalBoosts",
+      args: []
+    });
+    return _viem.formatEther.call(void 0, result);
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getBgtTokenTotalSupply.ts
+
+async function getBgtTokenTotalSupply({
+  publicClient,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient);
+  try {
+    const result = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: _viem.erc20Abi,
+      functionName: "totalSupply",
+      args: []
+    });
+    return _viem.formatEther.call(void 0, _nullishCoalesce(result, () => ( 0n)));
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getGlobalCuttingBoard.ts
+
+
+
+
+async function getGlobalCuttingBoard(threshold) {
+  const { gaugeList } = await getRewardVaults({
+    filter: {
+      // TODO sort by bgt capture percentage
+      orderBy: _api3.GqlRewardVaultOrderBy.Apr,
+      orderDirection: _api3.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") {
+    _chunk7ONKBHXYcjs.BeraMonitoring.captureException(
+      _chunk7ONKBHXYcjs.initBeraError.call(void 0, { cause: globalDataRes.reason, level: "warning" })
+    );
+  }
+  if (globalCuttingBoardRes.status === "rejected") {
+    _chunk7ONKBHXYcjs.BeraMonitoring.captureException(
+      _chunk7ONKBHXYcjs.initBeraError.call(void 0, { cause: globalCuttingBoardRes.reason, level: "warning" })
+    );
+  }
+  if (bgtTotalSupplyRes.status === "rejected") {
+    _chunk7ONKBHXYcjs.BeraMonitoring.captureException(
+      _chunk7ONKBHXYcjs.initBeraError.call(void 0, { cause: bgtTotalSupplyRes.reason, level: "warning" })
+    );
+  }
+  if (bgtTotalBoostsRes.status === "rejected") {
+    _chunk7ONKBHXYcjs.BeraMonitoring.captureException(
+      _chunk7ONKBHXYcjs.initBeraError.call(void 0, { 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
+
+
+var _fees = require('@berachain/graphql/pol/fees');
+async function getIncentiveFeeClaimStats({
+  ...args
+}) {
+  const bgtClient = getApolloClient("pol.fees", args);
+  const { data } = await bgtClient.query({
+    query: _fees.GetIncentiveFeeClaimStats
+  });
+  if (data.incentiveFeeClaims.length > 0) {
+    const sumAllClaims = _optionalChain([data, 'optionalAccess', _75 => _75.incentiveFeeClaims, 'access', _76 => _76.reduce, 'call', _77 => _77(
+      (acc, curr) => acc + Number(curr.payoutAmount),
+      3e4
+      // this is due to a bug in the subgraph, where the first claim of 50_000 was counted as 20_000, once hunter pushed the fix we can upgrade it.
+    )]);
+    const claimsInLast24Hours = _optionalChain([data, 'optionalAccess', _78 => _78.incentiveFeeClaims, 'access', _79 => _79.filter, 'call', _80 => _80(
+      (claim) => Number(claim.timestamp) / 1e3 > Date.now() - _chunk3LXVARBJcjs.days.call(void 0, 1)
+    )]);
+    const sumClaimsInLast24Hours = claimsInLast24Hours.reduce(
+      (acc, curr) => acc + Number(curr.payoutAmount),
+      0
+    );
+    return {
+      sumAllClaims,
+      sumClaimsInLast24Hours
+    };
+  }
+  return {
+    sumAllClaims: 0,
+    sumClaimsInLast24Hours: 0
+  };
+}
+
+// src/actions/pol/getMarkets.ts
+async function getMarkets(args = {}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, 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 } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, 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 _chunk3LXVARBJcjs.getErrorResponse.call(void 0, result);
+    throw new (0, _chunkQISQSMCVcjs.BeraError)({
+      message: "Failed to fetch proofs on server",
+      cause: {
+        error,
+        result,
+        account,
+        validator
+      },
+      reason: _optionalChain([error, 'optionalAccess', _81 => _81.reason])
+    });
+  }
+  const data = await result.json();
+  return data;
+}
+
+// src/actions/pol/getRewardTokenToBeraRate.ts
+
+var _wberaStakerVault = require('@berachain/abis/pol/wberaStakerVault');
+async function getRewardTokenToBeraRate({
+  address,
+  publicClient
+}) {
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient);
+  return publicClient.readContract({
+    address,
+    abi: _wberaStakerVault.wberaStakerVaultAbi,
+    functionName: "previewRedeem",
+    args: [_viem.parseUnits.call(void 0, "1", 18)]
+  }).then((rate) => Number(_viem.formatUnits.call(void 0, rate, 18))).catch(() => 0);
+}
+
+// src/actions/pol/getRewardVault.ts
+
+
+
+async function getRewardVault({
+  address,
+  chainName,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const resolvedChainName = _nullishCoalesce(chainName, () => ( config.bex.chainName));
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const { data } = await bexApiGraphqlClient.query({
+    query: _api3.GetRewardVault,
+    variables: {
+      vaultId: address,
+      chain: resolvedChainName
+    }
+  });
+  if (!_optionalChain([data, 'optionalAccess', _82 => _82.rewardVault])) {
+    throw new (0, _chunk4HDIUUSVcjs.NotFoundError)({
+      resource: "Reward vault",
+      id: address,
+      chainId: config.chainId
+    });
+  }
+  return data.rewardVault;
+}
+
+// src/actions/pol/getRewardVaultIncentives.ts
+
+
+
+
+
+
+function multicallResult(result, fallback) {
+  return result.status === "success" ? result.result : fallback;
+}
+async function getRewardVaultIncentives({
+  address,
+  stakingToken,
+  publicClient
+}) {
+  const whitelistedTokens = await publicClient.readContract({
+    address,
+    abi: _rewardVault.rewardVaultAbi,
+    functionName: "getWhitelistedTokens"
+  });
+  const hasStakingTokenAsIncentiveToken = whitelistedTokens.findIndex(
+    (token) => _berancersdk.isSameAddress.call(void 0, stakingToken, token)
+  ) !== -1;
+  const totalSupply = hasStakingTokenAsIncentiveToken ? await publicClient.readContract({
+    address,
+    abi: _rewardVault.rewardVaultAbi,
+    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: _rewardVault.rewardVaultAbi,
+            functionName: "incentives",
+            args: [token]
+          },
+          {
+            address: token,
+            abi: _viem.erc20Abi,
+            functionName: "decimals"
+          },
+          {
+            address: token,
+            abi: _viem.erc20Abi,
+            functionName: "name"
+          },
+          {
+            address: token,
+            abi: _viem.erc20Abi,
+            functionName: "symbol"
+          },
+          {
+            address: token,
+            abi: _viem.erc20Abi,
+            functionName: "balanceOf",
+            args: [address]
+          }
+        ]
+      });
+      if (incentiveInfo.status === "failure") {
+        throw new (0, _chunkQISQSMCVcjs.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: _viem.formatUnits.call(void 0, minIncentiveRate, decimalsResult),
+        incentiveRate: _viem.formatUnits.call(void 0, incentiveRate, decimalsResult),
+        remainingAmount: _viem.formatUnits.call(void 0, remainingAmount, decimalsResult),
+        name: multicallResult(name, void 0),
+        symbol: multicallResult(symbol, void 0),
+        decimals: decimalsResult,
+        pendingAmount: _berancersdk.isSameAddress.call(void 0, stakingToken, token) ? _viem.formatUnits.call(void 0, 
+          (_nullishCoalesce(totalBalance.result, () => ( 0n))) - totalSupply - remainingAmount,
+          decimalsResult
+        ) : _viem.formatUnits.call(void 0, 
+          (_nullishCoalesce(totalBalance.result, () => ( 0n))) - remainingAmount,
+          decimalsResult
+        )
+      };
+    })
+  );
+  incentives.forEach((result, index) => {
+    if (result.status === "rejected") {
+      _chunk7ONKBHXYcjs.BeraMonitoring.captureException(
+        new (0, _chunkQISQSMCVcjs.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
+
+async function getRewardVaultStakingToken({
+  address,
+  publicClient
+}) {
+  const vaultAddress = await publicClient.readContract({
+    address,
+    abi: _rewardVault.rewardVaultAbi,
+    functionName: "stakeToken"
+  });
+  return vaultAddress;
+}
+
+// src/actions/pol/getStakedBeraAPR.ts
+
+
+
+
+function getResolution(window) {
+  if (window === "DAY") {
+    return _api3.GqlSWberaVaultMetadataResolution.OneDay;
+  }
+  return _api3.GqlSWberaVaultMetadataResolution.SevenDays;
+}
+async function getStakedBeraAPR({
+  window,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  try {
+    const data = await bexApiGraphqlClient.query({
+      query: _api3.GetSWberaVaultMetadata,
+      variables: {
+        chain: config.bex.chainName,
+        resolution: getResolution(_nullishCoalesce(window, () => ( "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
+
+
+
+
+async function getStakedBeraSnapshots({
+  chain,
+  range = _api3.GqlVaultSnapshotDataRange.ThirtyDays,
+  ...args
+} = {}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  try {
+    const data = await bexApiGraphqlClient.query({
+      query: _api3.GetSWberaVaultSnapshots,
+      variables: {
+        chain: _nullishCoalesce(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
+
+async function getStakeWithdrawalCooldown({
+  publicClient,
+  address
+}) {
+  const lockPeriod = await publicClient.readContract({
+    address,
+    abi: _wberaStakerVault.wberaStakerVaultAbi,
+    functionName: "WITHDRAWAL_COOLDOWN"
+  });
+  return Number(lockPeriod);
+}
+
+// src/actions/pol/getSWBeraVaultMetadata.ts
+
+async function getSWBeraVaultMetadata({
+  address,
+  underlyingAsset,
+  publicClient,
+  blockTime
+}) {
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, 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: _viem.erc4626Abi,
+        functionName: "totalAssets"
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc4626Abi,
+        functionName: "totalSupply"
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc4626Abi,
+        functionName: "previewRedeem",
+        args: [10n ** 18n],
+        blockNumber: currentBlock.number
+      }),
+      publicClient.readContract({
+        address: underlyingAsset,
+        abi: _viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [address]
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc4626Abi,
+        functionName: "totalAssets",
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc20Abi,
+        functionName: "totalSupply",
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address,
+        abi: _viem.erc4626Abi,
+        functionName: "previewRedeem",
+        args: [10n ** 18n],
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address: underlyingAsset,
+        abi: _viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [address],
+        blockNumber: blockWindowAgo
+      }),
+      publicClient.readContract({
+        address: underlyingAsset,
+        abi: _viem.erc20Abi,
+        functionName: "totalSupply"
+      }),
+      getStakeWithdrawalCooldown({
+        publicClient,
+        address
+      }),
+      getIncentiveFeeClaimStats({})
+    ]);
+    const exchangeRateWindowAgo = new (0, _chunk3LXVARBJcjs.bignumber_js_default)(
+      oneShareWorthWindowAgo.toString()
+    );
+    const currentExchangeRate = new (0, _chunk3LXVARBJcjs.bignumber_js_default)(currentOneShareWorth.toString());
+    return {
+      address,
+      current: {
+        exchangeRate: currentExchangeRate.toString(),
+        totalSupply: new (0, _chunk3LXVARBJcjs.bignumber_js_default)(currentTotalSupply.toString()).dividedBy(1e18).toString(),
+        totalAssets: new (0, _chunk3LXVARBJcjs.bignumber_js_default)(curretTotalAssets.toString()).dividedBy(1e18).toString(),
+        tvl: new (0, _chunk3LXVARBJcjs.bignumber_js_default)(currentTVL.toString()).dividedBy(1e18).toString()
+      },
+      previous: {
+        exchangeRate: exchangeRateWindowAgo.toString(),
+        totalSupply: new (0, _chunk3LXVARBJcjs.bignumber_js_default)(totalSupply24HoursAgo.toString()).dividedBy(1e18).toString(),
+        totalAssets: new (0, _chunk3LXVARBJcjs.bignumber_js_default)(totalAssets24HoursAgo.toString()).dividedBy(1e18).toString(),
+        tvl: new (0, _chunk3LXVARBJcjs.bignumber_js_default)(tvl24HoursAgo.toString()).dividedBy(1e18).toString()
+      },
+      totalWBeraIssued: new (0, _chunk3LXVARBJcjs.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
+
+function getTimeUntil(targetTime) {
+  const currentTime = Date.now();
+  const timeDiff = targetTime * 1e3 - currentTime;
+  if (timeDiff <= 0) {
+    return;
+  }
+  const totalSeconds = _chunk3LXVARBJcjs.msToSeconds.call(void 0, timeDiff);
+  return _chunk3LXVARBJcjs.formatTimeLeft.call(void 0, 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 = _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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: _wberaStakerVault.wberaStakerVaultAbi,
+          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: _wberaStakerVault.wberaStakerVaultAbi,
+          functionName: "getERC721WithdrawalRequestIds",
+          args: [accountAddress]
+        }),
+        getStakeWithdrawalCooldown({
+          publicClient,
+          address: contractAddress
+        })
+      ]);
+      if (_chunkHCC4FJTDcjs.isToken.call(void 0, contractAddress, "SWBERA")) {
+        const withdrawalRequestV1 = await publicClient.readContract({
+          address: contractAddress,
+          abi: _wberaStakerVault.wberaStakerVaultAbi,
+          functionName: "withdrawalRequests",
+          args: [accountAddress]
+        });
+        withdrawalRequestV1Helper(withdrawalRequestV1, lockPeriod);
+      }
+      const withdrawalResults = await Promise.all(
+        withdrawalRequestIds.map(
+          async (withdrawalRequestId) => {
+            const withdrawalRequest = await publicClient.readContract({
+              address: contractAddress,
+              abi: _wberaStakerVault.wberaStakerVaultAbi,
+              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 = _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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
+
+async function getTotalStakedAmount({
+  vaultAddresses,
+  publicClient
+}) {
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient);
+  try {
+    const totalAssets = await Promise.all(
+      vaultAddresses.map(async (address) => {
+        return publicClient.readContract({
+          address,
+          abi: _wberaStakerVault.wberaStakerVaultAbi,
+          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 } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const result = await fetch(
+    `${config.pol.bribeBoostApi}/api/v1/wallets/${account.toLowerCase()}/rewards/aggregation`,
+    {
+      cache: "no-store"
+    }
+  );
+  if (!result.ok) {
+    const error = await _chunk3LXVARBJcjs.getErrorResponse.call(void 0, result);
+    throw new (0, _chunkQISQSMCVcjs.BeraError)({
+      message: "Failed to fetch incentives on server",
+      cause: { error, result, account },
+      reason: _optionalChain([error, 'optionalAccess', _83 => _83.error])
+    });
+  }
+  return result.json();
+}
+
+// src/actions/pol/getUserVaultsReward.ts
+
+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: _rewardVault.rewardVaultAbi,
+    functionName: "earned",
+    args: [account]
+  });
+}
+
+// src/actions/pol/getUserVaultInfo.ts
+
+
+// src/actions/pol/getUserVaultsBalance.ts
+
+async function getUserVaultsBalance({
+  account,
+  vaultAddress,
+  publicClient
+}) {
+  _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient);
+  _chunk7ONKBHXYcjs.assertAddress.call(void 0, account, "account");
+  _chunk7ONKBHXYcjs.assertAddress.call(void 0, vaultAddress, "vaultAddress");
+  try {
+    const [balance, delegated] = await Promise.all([
+      publicClient.readContract({
+        address: vaultAddress,
+        abi: _rewardVault.rewardVaultAbi,
+        functionName: "balanceOf",
+        args: [account]
+      }),
+      publicClient.readContract({
+        address: vaultAddress,
+        abi: _rewardVault.rewardVaultAbi,
+        functionName: "getTotalDelegateStaked",
+        args: [account]
+      })
+    ]);
+    return { balance, delegated };
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/actions/pol/getVaultsSupply.ts
+
+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: _rewardVault.rewardVaultAbi,
+      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(_viem.formatEther.call(void 0, userBalance.balance)) / Number.parseFloat(_viem.formatEther.call(void 0, totalSupply))
+  ).toString() : "0";
+  return {
+    balance: userBalance.balance,
+    delegatedBalance: userBalance.delegated,
+    withdrawableBalance,
+    rewards: _viem.formatEther.call(void 0, userReward),
+    percentage
+  };
+}
+
+// src/actions/pol/getUserVaults.ts
+
+
+
+
+
+async function getUserVaults({
+  account,
+  publicClient,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const res = await bexApiGraphqlClient.query({
+    query: _api3.GetUserVaults,
+    variables: {
+      userId: account,
+      chain: config.bex.chainName
+    }
+  });
+  const deposits = _optionalChain([res, 'access', _84 => _84.data, 'optionalAccess', _85 => _85.userVaultDeposits, 'optionalAccess', _86 => _86.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: _rewardVault.rewardVaultAbi,
+          functionName: "earned",
+          args: [account]
+        })
+      )
+    }),
+    // Fetch user balance of each vault
+    publicClient.multicall({
+      allowFailure: false,
+      contracts: deposits.map(
+        (deposit) => ({
+          address: deposit.vaultAddress,
+          abi: _rewardVault.rewardVaultAbi,
+          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) {
+        _chunk7ONKBHXYcjs.BeraMonitoring.captureException(
+          new (0, _chunkQISQSMCVcjs.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 = _optionalChain([deposit, 'access', _87 => _87.vault, 'access', _88 => _88.dynamicData, 'optionalAccess', _89 => _89.tvl]) && // If staked amount is 0, we don't want to divide by 0
+        Number(deposit.vault.stakingTokenAmount) !== 0 ? Number(_nullishCoalesce(_optionalChain([deposit, 'access', _90 => _90.vault, 'access', _91 => _91.dynamicData, 'optionalAccess', _92 => _92.tvl]), () => ( 0))) / Number(deposit.vault.stakingTokenAmount) : null;
+        acc.userVaults.push({
+          ...deposit,
+          vault: deposit.vault,
+          unclaimedBgt: _viem.formatUnits.call(void 0, item, 18),
+          formattedBalance: _viem.formatUnits.call(void 0, 
+            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(_nullishCoalesce(_optionalChain([vault, 'access', _93 => _93.vault, 'access', _94 => _94.dynamicData, 'optionalAccess', _95 => _95.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: _viem.formatUnits.call(void 0, total, 18),
+    vaults: sortedUserVaults
+  };
+}
+
+// src/actions/pol/getVaultHistory.ts
+
+
+
+async function getVaultHistory({
+  vault,
+  chain,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const result = await bexApiGraphqlClient.query({
+    query: _api3.GetVaultHistory,
+    variables: {
+      ...args,
+      vaultId: vault,
+      chain: _nullishCoalesce(chain, () => ( config.bex.chainName))
+    }
+  });
+  return result.data.polGetRewardVaultSnapshots;
+}
+
+// src/actions/pol/getVaultValidators.ts
+
+
+
+async function getVaultValidators({
+  address,
+  onlyActiveValidators,
+  ...args
+}) {
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const result = await bexApiGraphqlClient.query({
+    query: _api3.GetVaultValidators,
+    variables: { vaultId: address, isActive: onlyActiveValidators }
+  });
+  return _nullishCoalesce(result.data.validators.validators, () => ( []));
+}
+
+// src/actions/prices/getTokenCurrentPrices.ts
+
+
+
+
+async function getTokenCurrentPrices({
+  addressIn: _addressIn,
+  ...args
+}) {
+  const { config, chainId } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, 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: _api.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[_viem.getAddress.call(void 0, formattedAddress)] = {
+        price: _chunk3LXVARBJcjs.getSafeNumber.call(void 0, tokenInformation.price.toString()),
+        updatedAt: tokenInformation.updatedAt,
+        chainId
+      };
+      map[formattedAddress.toLowerCase()] = {
+        price: _chunk3LXVARBJcjs.getSafeNumber.call(void 0, tokenInformation.price.toString()),
+        updatedAt: tokenInformation.updatedAt,
+        chainId
+      };
+      if (_chunkHCC4FJTDcjs.isToken.call(void 0, formattedAddress, "WBERA")) {
+        map[_viem.zeroAddress] = {
+          price: _chunk3LXVARBJcjs.getSafeNumber.call(void 0, tokenInformation.price.toString()),
+          updatedAt: tokenInformation.updatedAt,
+          chainId
+        };
+        map[config.tokens.bgt.toLowerCase()] = {
+          price: _chunk3LXVARBJcjs.getSafeNumber.call(void 0, tokenInformation.price.toString()),
+          updatedAt: tokenInformation.updatedAt,
+          chainId
+        };
+        map[config.tokens.bgt] = {
+          price: _chunk3LXVARBJcjs.getSafeNumber.call(void 0, tokenInformation.price.toString()),
+          updatedAt: tokenInformation.updatedAt,
+          chainId
+        };
+      }
+      return map;
+    },
+    {}
+  );
+}
+
+// src/actions/tokens/getAllowances.ts
+var _core = require('@wagmi/core');
+
+
+
+
+async function getAllowances({
+  items: itemsList,
+  account,
+  config
+}) {
+  _chunk7ONKBHXYcjs.assertDefined.call(void 0, itemsList, "items");
+  _chunk7ONKBHXYcjs.assertDefined.call(void 0, config, "config");
+  _chunk7ONKBHXYcjs.assertDefined.call(void 0, 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 = _core.getPublicClient.call(void 0, config, {
+        chainId: Number(chainId)
+      });
+      _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient, `publicClient ${chainId}`);
+      const result = await publicClient.multicall({
+        contracts: items.map(
+          (item) => ({
+            address: item.token.address,
+            abi: _viem.erc20Abi,
+            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: _viem.formatUnits.call(void 0, 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// src/errors/getRevertReason.ts
+
+
+
+
+async function getRevertReason({
+  publicClient,
+  abi: providedAbi,
+  ...params
+}) {
+  const abi = [..._chunkQISQSMCVcjs.commonAbiErrors, ..._nullishCoalesce(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 (0, _chunkQISQSMCVcjs.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 (0, _chunkQISQSMCVcjs.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 = _viem.decodeFunctionData.call(void 0, {
+          abi,
+          data
+        });
+        functionName = decoded.functionName;
+        args = decoded.args;
+      } catch (e) {
+        if (e instanceof _viem.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 (0, _chunk4HDIUUSVcjs.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 _chunkQISQSMCVcjs.parseViemError.call(void 0, { error, abi, revertIfUnknown: true });
+    }
+    throw error;
+  }
+}
+
+// src/actions/transactions/beraWriteContract.ts
+var defaultPollingInterval = _chunk3LXVARBJcjs.seconds.call(void 0, 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) {
+      _optionalChain([onWarning, 'optionalCall', _96 => _96(
+        new (0, _chunkQISQSMCVcjs.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 = _internal.defaultChainId) {
+  return chainId === _internal.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 (0, _chunkQISQSMCVcjs.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 = _internal.defaultChainId,
+    impersonateAccount = isImpersonateAccount(chainId),
+    errorsAbi: _errorsAbi = [],
+    pollingInterval = defaultPollingInterval,
+    ...rest
+  } = args;
+  _optionalChain([onLoading, 'optionalCall', _97 => _97(args)]);
+  const data = "data" in rest ? rest.data : void 0;
+  const globalAbi = [
+    ..._chunkQISQSMCVcjs.commonAbiErrors,
+    ..._errorsAbi,
+    ..."abi" in rest && rest.abi && Array.isArray(rest.abi) ? rest.abi : []
+  ];
+  let walletClient = _walletClient;
+  if (!wagmiConfig) {
+    _optionalChain([onError, 'optionalCall', _98 => _98(
+      new (0, _chunkQISQSMCVcjs.InvalidArgumentError)({
+        property: "wagmiConfig",
+        value: wagmiConfig,
+        expected: "Config"
+      }),
+      args
+    )]);
+    return;
+  }
+  const isLocalAccount = _optionalChain([walletClient, 'optionalAccess', _99 => _99.account, 'optionalAccess', _100 => _100.type]) === "local";
+  if (!isLocalAccount) {
+    try {
+      await _core.switchChain.call(void 0, wagmiConfig, { chainId });
+    } catch (e) {
+      const error = e;
+      _optionalChain([onError, 'optionalCall', _101 => _101(
+        new (0, _chunkQISQSMCVcjs.BeraError)({
+          cause: error,
+          displayMessage: "There was an error switching to the chain."
+        }),
+        args
+      )]);
+      return;
+    }
+  }
+  if (!walletClient) {
+    try {
+      walletClient = await _core.getWalletClient.call(void 0, wagmiConfig, { chainId });
+    } catch (e) {
+      _optionalChain([onError, 'optionalCall', _102 => _102(
+        new (0, _chunkQISQSMCVcjs.BeraError)({
+          cause: e,
+          displayMessage: "There was an error connecting to the wallet."
+        }),
+        args
+      )]);
+      return;
+    }
+  }
+  if (!walletClient) {
+    _optionalChain([onError, 'optionalCall', _103 => _103(
+      new (0, _chunkQISQSMCVcjs.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) {
+    _optionalChain([onError, 'optionalCall', _104 => _104(
+      new (0, _chunkQISQSMCVcjs.InvalidArgumentError)({
+        property: "account",
+        value: account,
+        expected: "Account"
+      }),
+      args
+    )]);
+    return;
+  }
+  const accountAddress = typeof account === "string" ? account : account.address;
+  const publicClient = _core.getPublicClient.call(void 0, wagmiConfig, {
+    chainId
+  });
+  try {
+    _chunk7ONKBHXYcjs.assertPublicClient.call(void 0, publicClient);
+  } catch (error) {
+    _optionalChain([onError, 'optionalCall', _105 => _105(error, args)]);
+    return;
+  }
+  if (impersonateAccount) {
+    const testClient = _chunk3LXVARBJcjs.getTestClient.call(void 0, chainId);
+    await testClient.impersonateAccount({
+      address: accountAddress
+    });
+    walletClient = _viem.createWalletClient.call(void 0, {
+      transport: _viem.http.call(void 0, 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: _nullishCoalesce(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: _nullishCoalesce(call.value, () => ( 0n))
+          };
+        }
+        return {
+          to: call.address,
+          value: _nullishCoalesce(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 (0, _chunkQISQSMCVcjs.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: _chunkQISQSMCVcjs.parseDecodedError.call(void 0, 
+              _viem.decodeErrorResult.call(void 0, {
+                data: failedCall.data,
+                abi: globalAbi
+              })
+            )
+          } : _chunkQISQSMCVcjs.parseViemError.call(void 0, {
+            error: failedCall.error,
+            revertIfUnknown: false,
+            abi: globalAbi
+          });
+          _optionalChain([onError, 'optionalCall', _106 => _106(
+            new (0, _chunk4HDIUUSVcjs.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 (0, _chunkQISQSMCVcjs.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
+      });
+      _optionalChain([onSubmission, 'optionalCall', _107 => _107({ id: request.id }, args)]);
+      const callStatus = await walletClient.waitForCallsStatus({
+        id: request.id,
+        pollingInterval,
+        timeout: txConfirmationTimeout
+      });
+      if (callStatus.status === "success") {
+        const receipt = _optionalChain([callStatus, 'access', _108 => _108.receipts, 'optionalAccess', _109 => _109[0]]);
+        if (!receipt) {
+          throw new (0, _chunkQISQSMCVcjs.BeraError)({
+            message: "Call status is success but no receipt was found",
+            cause: callStatus,
+            level: "error",
+            reason: "CALL_STATUS_SUCCESS_BUT_NO_RECEIPT"
+          });
+        }
+        _optionalChain([onSuccess, 'optionalCall', _110 => _110(receipt, args)]);
+        return receipt;
+      }
+      console.error("wallet_sendCalls: Call failed", callStatus);
+      throw new (0, _chunk4HDIUUSVcjs.TransactionFailedError)({
+        cause: callStatus,
+        level: "error",
+        input,
+        txHash,
+        abi: globalAbi,
+        chainId
+      });
+    }
+    if (data) {
+      const [simulationResult, estimatedGas, nonceResult] = await Promise.allSettled([
+        publicClient.call({
+          ...sharedTxProperties,
+          data
+        }),
+        _nullishCoalesce(gasLimit, () => ( publicClient.estimateGas({
+          ...sharedTxProperties,
+          data
+        }))),
+        noncePromise
+      ]);
+      if (simulationResult.status === "rejected") {
+        throw simulationResult.reason;
+      }
+      const gas = estimatedGas.status === "fulfilled" ? increaseByPercentage(estimatedGas.value, 10) : _chunk3LXVARBJcjs.DEFAULT_METAMASK_GAS_LIMIT;
+      txHash = await walletClient.sendTransaction({
+        data,
+        to: address,
+        account,
+        gas,
+        chainId,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            _optionalChain([onWarning, 'optionalCall', _111 => _111(e, args)]);
+          }
+        }),
+        value
+      });
+      _optionalChain([onSubmission, 'optionalCall', _112 => _112({ 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
+        _nullishCoalesce(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 = _nullishCoalesce(gasLimit, () => ( (gasEstimateResult.status === "fulfilled" ? increaseByPercentage(gasEstimateResult.value, 10) : _chunk3LXVARBJcjs.DEFAULT_METAMASK_GAS_LIMIT)));
+      txHash = await walletClient.writeContract({
+        ...simulationResult.value.request,
+        chainId,
+        gas: estimatedGas,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            _optionalChain([onWarning, 'optionalCall', _113 => _113(e, args)]);
+          }
+        })
+      });
+      _optionalChain([onSubmission, 'optionalCall', _114 => _114({ txHash }, args)]);
+    } else {
+      const [nonceResult] = await Promise.allSettled([noncePromise]);
+      txHash = await walletClient.sendTransaction({
+        chainId,
+        to: address,
+        value,
+        account,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            _optionalChain([onWarning, 'optionalCall', _115 => _115(e, args)]);
+          }
+        })
+      });
+      _optionalChain([onSubmission, 'optionalCall', _116 => _116({ txHash }, args)]);
+    }
+    if (process.env.NODE_ENV === "test") {
+      const testClient = _chunk3LXVARBJcjs.getTestClient.call(void 0, chainId);
+      await testClient.mine({ blocks: 1 });
+    }
+    const confirmationReceipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      pollingInterval,
+      timeout: txConfirmationTimeout,
+      confirmations: 1
+    });
+    if (confirmationReceipt.status === "success") {
+      _optionalChain([onSuccess, 'optionalCall', _117 => _117(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);
+      }
+      _optionalChain([onError, 'optionalCall', _118 => _118(
+        new (0, _chunk4HDIUUSVcjs.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 _chunkQISQSMCVcjs.BeraError) {
+      _optionalChain([onError, 'optionalCall', _119 => _119(e, args)]);
+    } else if (e instanceof Error) {
+      const viemError = _chunkQISQSMCVcjs.parseViemError.call(void 0, {
+        error: e,
+        revertIfUnknown: false,
+        abi: globalAbi
+      });
+      if (viemError && viemError.rootCause instanceof _viem.BaseError && "url" in viemError.rootCause) {
+        _optionalChain([onError, 'optionalCall', _120 => _120(
+          new (0, _chunkQISQSMCVcjs.RequestError)({
+            cause: viemError.rootCause,
+            response: void 0,
+            endpoint: {
+              url: viemError.rootCause.url,
+              type: "rpc"
+            },
+            statusCode: viemError.rootCause instanceof _viem.HttpRequestError ? viemError.rootCause.status : void 0
+          }),
+          args
+        )]);
+        return;
+      }
+      _optionalChain([onError, 'optionalCall', _121 => _121(
+        new (0, _chunk4HDIUUSVcjs.TransactionFailedError)({
+          cause: e,
+          to: address,
+          txHash,
+          chainId,
+          abi: globalAbi,
+          functionName: "functionName" in rest ? rest.functionName : void 0,
+          input
+        }),
+        args
+      )]);
+    } else {
+      _optionalChain([onError, 'optionalCall', _122 => _122(
+        new (0, _chunk4HDIUUSVcjs.TransactionFailedError)({
+          cause: e,
+          txHash,
+          to: address,
+          chainId,
+          functionName: "functionName" in rest ? rest.functionName : void 0,
+          input,
+          abi: globalAbi
+        }),
+        args
+      )]);
+    }
+  }
+}
+
+// src/actions/validators/getAllValidators.ts
+
+
+
+async function getAllValidators({
+  variables = {},
+  ...args
+} = {}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const result = await bexApiGraphqlClient.query({
+    query: _api3.GetValidators,
+    variables: {
+      chain: config.bex.chainName,
+      ...variables
+    }
+  });
+  return result.data;
+}
+
+// src/actions/validators/getApiEnrichedAllocation.ts
+
+async function getApiEnrichedAllocation({
+  allocation
+}) {
+  const vaults = await getRewardVaults({
+    filter: {
+      where: {
+        vaultAddressIn: allocation.weights.map((weight) => weight.receiver)
+      }
+    }
+  });
+  const startBlock = _nullishCoalesce(_optionalChain([allocation, 'optionalAccess', _123 => _123.start, 'access', _124 => _124.blockNumber]), () => ( 0));
+  return _optionalChain([allocation, 'optionalAccess', _125 => _125.weights, 'access', _126 => _126.map, 'call', _127 => _127(
+    (allocation2) => {
+      return {
+        percentage: allocation2.percentage,
+        receiver: allocation2.receiver,
+        startBlock,
+        receivingVault: _optionalChain([vaults, 'optionalAccess', _128 => _128.gaugeList, 'access', _129 => _129.find, 'call', _130 => _130(
+          (vault) => _viem.isAddressEqual.call(void 0, vault.address, allocation2.receiver)
+        )])
+      };
+    }
+  )]);
+}
+
+// src/actions/validators/getApiValidator.ts
+
+
+
+async function getApiValidator({
+  id,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const results = await bexApiGraphqlClient.query({
+    query: _api3.GetValidator,
+    variables: {
+      id,
+      chain: config.bex.chainName
+    }
+  });
+  return results.data;
+}
+
+// src/actions/validators/getDailyValidatorBlockStats.ts
+
+
+var _subgraph = require('@berachain/graphql/pol/subgraph');
+async function getDailyValidatorBlockStats({
+  pubKey,
+  first = 1,
+  ...args
+}) {
+  const bgtClient = getApolloClient("pol.subgraph", args);
+  try {
+    const result = await bgtClient.query({
+      query: _subgraph.GetValidatorBlockStats,
+      variables: {
+        pubKey,
+        first
+      }
+    });
+    return result.data;
+  } catch (e) {
+    console.error("GetValidatorBlockStats:", e);
+    throw e;
+  }
+}
+
+// src/actions/validators/getValidatorRewardAllocation.ts
+var _beraChef = require('@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 } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const [rawActiveRewardAllocation, rawSetRewardAllocation] = await Promise.all([
+      client.readContract({
+        address: config.pol.beraChef,
+        abi: _beraChef.beraChefAbi,
+        functionName: "getActiveRewardAllocation",
+        args: [pubKey]
+      }),
+      client.readContract({
+        address: config.pol.beraChef,
+        abi: _beraChef.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: _optionalChain([setRewardAllocation, 'optionalAccess', _131 => _131.start, 'access', _132 => _132.blockNumber]) === 0
+    };
+  } catch (e) {
+    console.log("getValidatorRewardAllocation:", e);
+    throw e;
+  }
+}
+
+// src/actions/validators/getDefaultRewardAllocation.ts
+
+function isDefaultRewardAllocation(rewardAllocation) {
+  return rewardAllocation.start.blockNumber === 0;
+}
+async function getDefaultRewardAllocation({
+  client,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const rawDefaultRewardAllocation = await client.readContract({
+    address: config.pol.beraChef,
+    abi: _beraChef.beraChefAbi,
+    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
+
+
+async function getUserBoostsOnValidator({
+  account,
+  pubkey,
+  publicClient,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, 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: _bgt.bgtAbi,
+      functionName: "boosted",
+      args: [account, pubkey]
+    }),
+    publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: _bgt.bgtAbi,
+      functionName: "boostedQueue",
+      args: [account, pubkey]
+    }),
+    publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: _bgt.bgtAbi,
+      functionName: "dropBoostQueue",
+      args: [account, pubkey]
+    })
+  ]);
+  const droppableBoostAmount = activeBoostAmount - queuedDropBoostAmount[1];
+  return {
+    pubkey,
+    droppableBoostAmount: _viem.formatEther.call(void 0, droppableBoostAmount),
+    activeBoostAmount: _viem.formatEther.call(void 0, activeBoostAmount),
+    queuedBoostAmount: _viem.formatEther.call(void 0, queuedBoostAmount[1]),
+    queuedDropBoostAmount: _viem.formatEther.call(void 0, 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
+
+
+// src/actions/validators/getUserBoosts.ts
+
+
+
+async function getUserBoosts({
+  account,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const apiClient = getApolloClient("api", args);
+  return apiClient.query({
+    query: _api3.GetUserValidatorInformation,
+    variables: {
+      address: account.toLowerCase(),
+      chain: config.bex.chainName
+    }
+  });
+}
+
+// src/actions/validators/getUserActiveValidators.ts
+async function getUserActiveValidators({
+  account,
+  publicClient,
+  chain,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const resolvedChain = _nullishCoalesce(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 _optionalChain([validatorInfoList, 'optionalAccess', _133 => _133.validators, 'access', _134 => _134.validators, 'access', _135 => _135.map, 'call', _136 => _136((validator) => {
+    const userDeposited = onChainBoosts.find(
+      (data) => data.pubkey.toLowerCase() === validator.pubkey.toLowerCase()
+    );
+    if (!userDeposited) {
+      throw new Error("User deposited not found");
+    }
+    const droppableBoostAmount = _viem.parseEther.call(void 0, _nullishCoalesce(_optionalChain([userDeposited, 'optionalAccess', _137 => _137.activeBoostAmount]), () => ( "0"))) - _viem.parseEther.call(void 0, _optionalChain([userDeposited, 'optionalAccess', _138 => _138.queuedDropBoostAmount]));
+    return {
+      ...validator,
+      userBoosts: {
+        pubkey: userDeposited.pubkey,
+        activeBoostAmount: _optionalChain([userDeposited, 'optionalAccess', _139 => _139.activeBoostAmount]),
+        queuedBoostAmount: _optionalChain([userDeposited, 'optionalAccess', _140 => _140.queuedBoostAmount]),
+        queuedBoostStartBlock: Number(_optionalChain([userDeposited, 'optionalAccess', _141 => _141.queuedBoostStartBlock])),
+        queuedDropBoostAmount: _optionalChain([userDeposited, 'optionalAccess', _142 => _142.queuedDropBoostAmount]),
+        queuedDropBoostStartBlock: Number(
+          _optionalChain([userDeposited, 'optionalAccess', _143 => _143.queuedDropBoostStartBlock])
+        ),
+        droppableBoostAmount: _viem.formatEther.call(void 0, droppableBoostAmount),
+        hasPendingBoosts: Number(_optionalChain([userDeposited, 'optionalAccess', _144 => _144.queuedBoostAmount])) > 0 || Number(_optionalChain([userDeposited, 'optionalAccess', _145 => _145.queuedDropBoostAmount])) > 0,
+        hasActiveBoosts: Number(_optionalChain([userDeposited, 'optionalAccess', _146 => _146.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: _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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: _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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: _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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: _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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: _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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: _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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: _chunk3LXVARBJcjs.msToSeconds.call(void 0, 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,
+  ...args
+}) {
+  const bgtClient = getApolloClient("pol.subgraph", args);
+  const result = await bgtClient.query({
+    query: _subgraph.GetValidatorAnalytics,
+    variables: {
+      pubKey: pubkey,
+      timestamp: _chunk3LXVARBJcjs.calculateTimestampFromDays.call(void 0, dayRange).toString()
+    }
+  });
+  return result.data;
+}
+
+// src/actions/validators/getValidatorCommission.ts
+
+async function getValidatorCommission({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const result = await client.readContract({
+    address: config.pol.beraChef,
+    abi: _beraChef.beraChefAbi,
+    functionName: "getValCommissionOnIncentiveTokens",
+    args: [pubKey]
+  });
+  return Number(_nullishCoalesce(result, () => ( 0n))) / 1e4;
+}
+
+// src/actions/validators/getValidatorEstimatedBgtPerYear.ts
+var getValidatorEstimatedBgtPerYear = (validator, totalStakedBeraAmount, blockTime) => {
+  if (!totalStakedBeraAmount || !validator) return 0;
+  const estimatedBlocksPerYear = _chunk3LXVARBJcjs.yearsInSeconds.call(void 0, 1) / blockTime;
+  const estimatedValidatorBlocksPerYear = totalStakedBeraAmount ? estimatedBlocksPerYear * (Number(_optionalChain([validator, 'access', _147 => _147.dynamicData, 'optionalAccess', _148 => _148.stakedBeraAmount])) / totalStakedBeraAmount) : 0;
+  return estimatedValidatorBlocksPerYear * Number.parseFloat(_nullishCoalesce(_optionalChain([validator, 'access', _149 => _149.dynamicData, 'optionalAccess', _150 => _150.rewardRate]), () => ( "0")));
+};
+
+// src/actions/validators/getValidatorOperatorAddress.ts
+var _beaconDeposit = require('@berachain/abis/pol/beaconDeposit');
+async function getValidatorOperatorAddress({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const result = await client.readContract({
+      address: config.depositContract,
+      abi: _beaconDeposit.beaconDepositAbi,
+      functionName: "getOperator",
+      args: [pubKey]
+    });
+    return result;
+  } catch (e) {
+    console.log("getValidatorOperatorAddress:", e);
+    throw e;
+  }
+}
+
+// src/actions/validators/getValidatorQueuedCommission.ts
+
+async function getValidatorQueuedCommission({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  const result = await client.readContract({
+    address: config.pol.beraChef,
+    abi: _beraChef.beraChefAbi,
+    functionName: "getValQueuedCommissionOnIncentiveTokens",
+    args: [pubKey]
+  });
+  return {
+    blockNumberLast: result.blockNumberLast,
+    commissionRate: Number(result.commissionRate) / 1e4
+  };
+}
+
+// src/actions/validators/getValidatorQueuedOperatorAddress.ts
+
+async function getValidatorQueuedOperatorAddress({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const result = await client.readContract({
+      address: config.depositContract,
+      abi: _beaconDeposit.beaconDepositAbi,
+      functionName: "queuedOperator",
+      args: [pubKey]
+    });
+    return result;
+  } catch (e) {
+    console.log("getValidatorQueuedOperatorAddress:", e);
+    throw e;
+  }
+}
+
+// src/actions/validators/getValidatorQueuedRewardAllocation.ts
+
+async function getValidatorQueuedRewardAllocation({
+  client,
+  pubKey,
+  ...args
+}) {
+  const { config } = _chunkHCC4FJTDcjs.parseBaseArgs.call(void 0, args);
+  try {
+    const result = await client.readContract({
+      address: config.pol.beraChef,
+      abi: _beraChef.beraChefAbi,
+      functionName: "getQueuedRewardAllocation",
+      args: [pubKey]
+    });
+    return formatValidatorRewardAllocation(result, 0);
+  } catch (e) {
+    console.log("getValidatorQueuedRewardAllocation:", e);
+    throw e;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.getConvertToAssets = getConvertToAssets; exports.BeraApolloClient = BeraApolloClient; exports.getApolloClient = getApolloClient; exports.gql = _client.gql; exports.BaseAggregator = BaseAggregator; exports.BalancerApi = _berancersdk.BalancerApi; exports.getAllPools = getAllPools; exports.getApiPool = getApiPool; exports.getGlobalLiquidityAndSwapVolume = getGlobalLiquidityAndSwapVolume; exports.getPoolPausedState = getPoolPausedState; exports.getOnChainPool = getOnChainPool; exports.getPoolEvents = getPoolEvents; exports.getPoolHistoricalData = getPoolHistoricalData; exports.checkProposalField = checkProposalField; exports.MOCKED_PROPOSAL_STATUSES = MOCKED_PROPOSAL_STATUSES; exports.computeActualStatus = computeActualStatus; exports.getAllProposals = getAllProposals; exports.getBodyErrors = getBodyErrors; exports.getProposalDetails = getProposalDetails; exports.parseProposalBody = parseProposalBody; exports.getProposalFromTx = getProposalFromTx; exports.getProposalVotes = getProposalVotes; exports.getChartData = getChartData; exports.getCollateralWeights = getCollateralWeights; exports.getTokenInformation = getTokenInformation; exports.getHoneyCollaterals = getHoneyCollaterals; exports.isBadCollateralAsset = isBadCollateralAsset; exports.getGlobalCapLimit = getGlobalCapLimit; exports.getHoneyGlobalData = getHoneyGlobalData; exports.HoneyPreviewMethod = HoneyPreviewMethod; exports.getHoneyPreview = getHoneyPreview; exports.getHoneyVaultsBalance = getHoneyVaultsBalance; exports.getPythLatestPrices = getPythLatestPrices; exports.getRelativeCapLimit = getRelativeCapLimit; exports.getPythUpdateFee = getPythUpdateFee; exports.getSwapPayload = getSwapPayload; exports.isBasketModeEnabled = isBasketModeEnabled; exports.getBlockTimestamp = getBlockTimestamp; exports.RewardVaultDistributionMode = RewardVaultDistributionMode; exports.getRewardVaultRewards = getRewardVaultRewards; exports.getBgtAprSimulation = getBgtAprSimulation; exports.getEarnedStakedBeraVault = getEarnedStakedBeraVault; exports.getRewardVaults = getRewardVaults; exports.getGlobalData = getGlobalData; exports.getIncentiveFeeClaimStats = getIncentiveFeeClaimStats; exports.getMarkets = getMarkets; exports.getRewardProofsByValidator = getRewardProofsByValidator; exports.getRewardTokenToBeraRate = getRewardTokenToBeraRate; exports.getRewardVault = getRewardVault; exports.getRewardVaultIncentives = getRewardVaultIncentives; exports.getRewardVaultStakingToken = getRewardVaultStakingToken; exports.getStakedBeraAPR = getStakedBeraAPR; exports.getStakedBeraSnapshots = getStakedBeraSnapshots; exports.getStakeWithdrawalCooldown = getStakeWithdrawalCooldown; exports.getSWBeraVaultMetadata = getSWBeraVaultMetadata; exports.getSWBeraWithdrawal = getSWBeraWithdrawal; exports.getTotalStakedAmount = getTotalStakedAmount; exports.getUserClaimableIncentives = getUserClaimableIncentives; exports.getUserVaultsReward = getUserVaultsReward; exports.getUserVaultInfo = getUserVaultInfo; exports.getUserVaults = getUserVaults; exports.getVaultHistory = getVaultHistory; exports.getVaultValidators = getVaultValidators; exports.getTokenCurrentPrices = getTokenCurrentPrices; exports.getAllowances = getAllowances; exports.isImpersonateAccount = isImpersonateAccount; exports.beraWriteContract = beraWriteContract; exports.getAllValidators = getAllValidators; exports.getApiEnrichedAllocation = getApiEnrichedAllocation; exports.getApiValidator = getApiValidator; exports.getDailyValidatorBlockStats = getDailyValidatorBlockStats; exports.formatValidatorRewardAllocation = formatValidatorRewardAllocation; exports.isSameRewardAllocation = isSameRewardAllocation; exports.getValidatorRewardAllocation = getValidatorRewardAllocation; exports.isDefaultRewardAllocation = isDefaultRewardAllocation; exports.getDefaultRewardAllocation = getDefaultRewardAllocation; exports.getStakingPoolBatch = getStakingPoolBatch; exports.getUserBoostsOnValidator = getUserBoostsOnValidator; exports.getUserActiveValidators = getUserActiveValidators; exports.getUserStakingPositions = getUserStakingPositions; exports.getValidatorAnalytics = getValidatorAnalytics; exports.getValidatorCommission = getValidatorCommission; exports.getValidatorEstimatedBgtPerYear = getValidatorEstimatedBgtPerYear; exports.getValidatorOperatorAddress = getValidatorOperatorAddress; exports.getValidatorQueuedCommission = getValidatorQueuedCommission; exports.getValidatorQueuedOperatorAddress = getValidatorQueuedOperatorAddress; exports.getValidatorQueuedRewardAllocation = getValidatorQueuedRewardAllocation;
+//# sourceMappingURL=chunk-A7P3JVU7.cjs.map