@berachain/berajs 0.2.12 → 0.3.0

package/src/actions/dex/aggregators/base.ts

@@ -8,6 +8,7 @@ import type { HoneyConfigContextReturn } from "../../../contexts/HoneyConfigProv
 import type { Aggregators } from "../../../enum/dex";
 import { BeraError } from "../../../errors/BeraError";
 import { initBeraError } from "../../../errors/initBeraError";
+import { RequestError } from "../../../errors/RequestError";
 import type {
   IAggregatorArgs,
   IRawAggregatorQuote,
@@ -24,11 +25,33 @@ export abstract class BaseAggregator {
    * If null, the aggregator is supported on all chains.
    */
   abstract supportedChains: number[] | null;
-  static PATH_NOT_FOUND_REASON = "NO_SWAP_PATHS";
+  static PATH_NOT_FOUND_REASON = RequestError.REASON_MAP.NO_SWAP_PATHS;
 
   needsAccountForQuote: boolean = false;
   notFoundMessages: string[] = [];
 
+  /**
+   * Whether this aggregator can handle a BERA↔WBERA pair.
+   *
+   * Most aggregators normalize native BERA → WBERA before routing (see
+   * `parseAddresses`), so a BERA↔WBERA pair collapses to WBERA↔WBERA and the
+   * external router rejects it as "same token" (e.g. Enso 400, HUB-9FQ). For
+   * those, `getUnsupportedReason` rejects the pair up-front so no request fires.
+   * Only the dedicated wrap/unwrap aggregator sets this `true`.
+   */
+  supportsBeraWrap: boolean = false;
+
+  /**
+   * Whether this aggregator can bridge — route a pair whose tokens live on
+   * different chains (`tokenIn.chainId !== tokenOut.chainId`).
+   *
+   * Most aggregators only route within a single chain; handed a cross-chain
+   * pair they would 400 or, worse, quote garbage against the wrong chain.
+   * `getUnsupportedReason` rejects such pairs up-front unless this is `true`.
+   * Only bridging aggregators (Enso via LayerZero) set it.
+   */
+  supportsBridging: boolean = false;
+
   config: BeraConfig;
 
   chainId: ChainId;
@@ -47,9 +70,7 @@ export abstract class BaseAggregator {
 
   abstract getQuote(
     args: IAggregatorArgs,
-  ):
-    | Promise<IRawAggregatorQuote | undefined>
-    | Promise<IRawAggregatorQuote | undefined>;
+  ): Promise<IRawAggregatorQuote | undefined>;
 
   /**
    * return wbera for native tokens to accomodate the aggregator's router logic
@@ -171,9 +192,12 @@ export abstract class BaseAggregator {
   }
 
   /**
-   * Check if chain is supported
+   * Returns a human-readable reason this aggregator can't route the pair, or
+   * `null` if it can. Callers gate on `=== null`; `assertChainSupport` throws
+   * the reason so users get an accurate message (not a misleading "does not
+   * support chain ID" for what is actually a same-token pair).
    */
-  checkChainSupport({
+  getUnsupportedReason({
     tokenIn,
     tokenOut,
   }: {
@@ -183,31 +207,66 @@ export abstract class BaseAggregator {
     honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
     // needed in ERC4626 aggregator
     underlyingToken?: Token | null;
-  }): boolean {
-    if (this.supportedChains === null) {
-      return true;
+    // needed in haiku aggregator (reward-vault staking opt-out)
+    rewardVault?: Address;
+  }): string | null {
+    if (isToken(tokenIn, tokenOut)) {
+      // same token route don't make sense (we're not arbitraging here), so we don't support it
+      return `${this.name} cannot route between the same token (${tokenIn.symbol}).`;
+    }
+
+    // Reject pairs that collapse to the same token once native BERA is
+    // normalized to WBERA (e.g. BERA↔WBERA), unless this aggregator explicitly
+    // handles wrapping. Otherwise the router 400s on identical tokens (HUB-9FQ).
+    if (!this.supportsBeraWrap) {
+      const wbera = this.config.tokens.wbera;
+      function normalize(token: Token) {
+        return (isToken(token, "BERA") ? wbera : token.address).toLowerCase();
+      }
+      if (normalize(tokenIn) === normalize(tokenOut)) {
+        return `${this.name} cannot route between BERA and WBERA — use wrap/unwrap instead.`;
+      }
     }
 
-    return (
-      this.supportedChains.includes(tokenIn.chainId) &&
-      this.supportedChains.includes(tokenOut.chainId)
-    );
+    // Reject cross-chain pairs unless this aggregator can bridge. Making the
+    // rejection explicit (rather than relying on `supportedChains`) lets the
+    // swap-page fan-out be handed multichain pairs safely.
+    if (tokenIn.chainId !== tokenOut.chainId && !this.supportsBridging) {
+      return `${this.name} cannot route across chains (${tokenIn.chainId} → ${tokenOut.chainId}).`;
+    }
+
+    if (
+      this.supportedChains !== null &&
+      (!this.supportedChains.includes(tokenIn.chainId) ||
+        !this.supportedChains.includes(tokenOut.chainId))
+    ) {
+      return `${this.name} does not support tokens chain ID: ${tokenIn.chainId} and ${tokenOut.chainId}`;
+    }
+
+    return null;
   }
 
   assertChainSupport({
     tokenIn,
     tokenOut,
     underlyingToken,
+    honeyNativeState,
   }: {
     tokenIn: Token;
     tokenOut: Token;
+    // needed in ERC4626 aggregator
     underlyingToken?: Token | null;
+    // needed in honey native aggregator
+    honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
   }): void {
-    if (!this.checkChainSupport({ tokenIn, tokenOut, underlyingToken })) {
-      throw new BeraError({
-        message: `${this.name} does not support tokens chain ID: ${tokenIn.chainId} and ${tokenOut.chainId}`,
-        level: "error",
-      });
+    const reason = this.getUnsupportedReason({
+      tokenIn,
+      tokenOut,
+      underlyingToken,
+      honeyNativeState,
+    });
+    if (reason !== null) {
+      throw new BeraError({ message: reason, level: "error" });
     }
   }
 
@@ -229,6 +288,7 @@ export abstract class BaseAggregator {
         this.notFoundMessages.some((message) => error.message.includes(message))
       ) {
         error.reason = BaseAggregator.PATH_NOT_FOUND_REASON;
+        error.level = "warning";
       }
       throw error;
     }

package/src/actions/dex/aggregators/bex.ts

@@ -1,5 +1,6 @@
 import {
   type Address,
+  DECIMAL_SCALES,
   Slippage,
   type SorSwapResult,
   Swap,
@@ -7,7 +8,7 @@ import {
   Token,
   TokenAmount,
 } from "@berachain-foundation/berancer-sdk";
-import { decodeFunctionData, formatEther, zeroAddress } from "viem";
+import { decodeFunctionData, formatEther } from "viem";
 
 import { getUriFromLink } from "@berachain/config";
 import { ChainId } from "@berachain/config/internal";
@@ -19,9 +20,13 @@ import { assertPublicClient } from "../../../errors/assert";
 import { BeraError } from "../../../errors/BeraError";
 import { BeraMonitoring } from "../../../errors/BeraMonitoring";
 import { RequestError } from "../../../errors/RequestError";
-import type { IAggregatorArgs, IRawAggregatorQuote } from "../../../types/dex";
+import type {
+  Token as BeraToken,
+  IAggregatorArgs,
+  IRawAggregatorQuote,
+} from "../../../types/dex";
 import { isToken } from "../../../utils/tokens";
-import { BalancerApi } from "../b-sdk";
+import { BalancerApi } from "../bSdk";
 import { BaseAggregator } from "./base";
 
 // Constants
@@ -35,6 +40,40 @@ class BexAggregator extends BaseAggregator {
   readonly url = getUriFromLink(this.config.api);
   readonly type = "graphql";
 
+  /**
+   * Opt bex out of tokens it structurally can't route (BGT, or decimals
+   * outside b-sdk's supported range) so the quote is never requested and other
+   * aggregators still handle it — see `supportsToken` for the specifics.
+   */
+  getUnsupportedReason(args: {
+    tokenIn: BeraToken;
+    tokenOut: BeraToken;
+  }): string | null {
+    const base = super.getUnsupportedReason(args);
+    if (base !== null) {
+      return base;
+    }
+    for (const token of [args.tokenIn, args.tokenOut]) {
+      if (!this.supportsToken(token)) {
+        return `${this.name} can't route ${token.symbol} (BGT or unsupported decimals).`;
+      }
+    }
+    return null;
+  }
+
+  private supportsToken(token: BeraToken) {
+    // BGT has no Balancer pool (it's redeemed via the BGT aggregator, not
+    // swapped), so a bex quote for it always throws NO_SWAP_PATHS (HUB-A5R).
+    if (isToken(token.address, "BGT", { config: this.config })) {
+      return false;
+    }
+    // b-sdk's `TokenAmount` scales via `DECIMAL_SCALES[18 - decimals]`; a token
+    // outside that 0–18 table (e.g. 27-decimal ctBeraUSDe) throws "Cannot mix
+    // BigInt and other types" (HUB-A6D). Mirror the exact lookup so this tracks
+    // b-sdk if the supported range ever changes.
+    const scaleKey = 18 - token.decimals;
+    return scaleKey in DECIMAL_SCALES;
+  }
   /**
    * Helper function to convert zero address to wrapped token address
    */
@@ -108,14 +147,7 @@ class BexAggregator extends BaseAggregator {
       // @ts-expect-error b-sdk has more chains than berajs
       this.chainId,
     );
-    const {
-      tokenIn,
-      tokenOut,
-      amount,
-      slippage,
-      account = zeroAddress,
-      publicClient,
-    } = args;
+    const { tokenIn, tokenOut, amount, slippage, publicClient } = args;
     this.assertChainSupport({ tokenIn, tokenOut });
 
     assertPublicClient(publicClient);
@@ -227,6 +259,7 @@ class BexAggregator extends BaseAggregator {
           abi: balancerVaultAbi,
           address: callData.to,
           value: callData.value || BigInt(0),
+          extraTags: { aggregator: this.name },
         };
       },
     };

package/src/actions/dex/aggregators/bgt.ts

@@ -15,23 +15,28 @@ class RedeemBgtAggregator extends BaseAggregator {
   supportedChains = [ChainId.MAINNET, ChainId.BEPOLIA];
   readonly type = "rpc";
 
-  checkChainSupport({
+  getUnsupportedReason({
     tokenIn,
     tokenOut,
   }: {
     tokenIn: MinimalERC20;
     tokenOut: MinimalERC20;
-  }): boolean {
-    if (!super.checkChainSupport({ tokenIn, tokenOut })) {
-      return false;
+  }): string | null {
+    const base = super.getUnsupportedReason({ tokenIn, tokenOut });
+    if (base !== null) {
+      return base;
     }
 
-    return (
+    if (
       // only supported on same chain
       tokenIn.chainId === tokenOut.chainId &&
       isToken(tokenIn, "BGT", { chainId: tokenIn.chainId }) &&
       isToken(tokenOut, "BERA")
-    );
+    ) {
+      return null;
+    }
+
+    return `${this.name} only redeems BGT → BERA on the same chain.`;
   }
   // handles native swaps: wrap and unwrap
   async getQuote({

package/src/actions/dex/aggregators/enso/enso.ts

@@ -121,6 +121,7 @@ class EnsoAggregator extends BaseAggregator {
             },
           ],
           functionName: "swap",
+          extraTags: { aggregator: this.name },
           abi: aggregatorsRouterAbi,
           // send full amount to router first, which will deduct the swap fee before executing trade
           value: isTokenInNative ? BigInt(amount) : BigInt("0"),

package/src/actions/dex/aggregators/enso/ensoErc4626.ts

@@ -13,6 +13,7 @@ import { BaseAggregator } from "../base";
 class EnsoErc4626Aggregator extends BaseAggregator {
   name = Aggregators.EnsoErc4626;
   supportedChains = null;
+  supportsBridging = true;
   readonly type = "rest";
   needsAccountForQuote = true;
 
@@ -53,6 +54,11 @@ class EnsoErc4626Aggregator extends BaseAggregator {
      */
     const zapTokenOut = underlyingToken ?? tokenOut;
 
+    // Single source of truth for whether this route bridges: the route action
+    // gets a `destinationChainId` (LayerZero) exactly when this is true, and it
+    // is stamped onto the returned quote so consumers stop re-deriving it.
+    const isCrossChain = tokenIn.chainId !== zapTokenOut.chainId;
+
     const bundleActions: BundleAction[] = [
       // this is the base route action, which will swap the token in to the zap token out
       // it handles cross-chain swaps and refunds the user if the swap fails
@@ -63,14 +69,15 @@ class EnsoErc4626Aggregator extends BaseAggregator {
         args: {
           tokenIn: tokenIn.address,
           tokenOut: zapTokenOut.address,
-          destinationChainId:
-            // must be undefined if the token is the same chain
-            tokenIn.chainId === zapTokenOut.chainId
-              ? undefined
-              : zapTokenOut.chainId,
+          // must be undefined if the token is the same chain
+          destinationChainId: isCrossChain ? zapTokenOut.chainId : undefined,
           refundReceiver: account,
+          receiver: account,
           amountIn: amount,
           slippage: slippage * 100, // Enso expects slippage in basis points
+          // We can't track CCIP delivery status (no poller in crossChainBridge),
+          // so keep Enso from routing cross-chain zaps through it.
+          ignoreBridges: isCrossChain ? ["ccip"] : undefined,
         },
       },
     ];
@@ -143,14 +150,21 @@ class EnsoErc4626Aggregator extends BaseAggregator {
       bundleActions,
     );
 
+    // Enso picks the bridge per-route (relay/stargate/ccip); it reports the
+    // choice on the route hop whose action is "bridge". The tracker needs this
+    // to know which explorer + status API to hit.
+    const bridgeProtocol = bundle.route?.find(
+      (hop) => hop.action === "bridge",
+    )?.protocol;
+
     const tokenOutAddress = (rewardVault?.toLowerCase() ??
       tokenOut.address.toLowerCase()) as Address;
 
-    const amountOut =
-      // @ts-expect-error enso has not typed this but is returned sometimes from API.
+    const amountOut = String(
       bundle.minAmountsOut?.[tokenOutAddress] ??
-      bundle.amountsOut[tokenOutAddress] ??
-      "0";
+        bundle.amountsOut?.[tokenOutAddress] ??
+        "0",
+    );
 
     return {
       amountOut,
@@ -162,6 +176,9 @@ class EnsoErc4626Aggregator extends BaseAggregator {
       }),
       name: this.name,
       swapFeeBps: 0,
+      isCrossChain,
+      srcChainId: tokenIn.chainId,
+      bridgeProtocol,
       priceImpactPercentage: bundle.priceImpact
         ? bundle.priceImpact / 100
         : null,
@@ -169,6 +186,7 @@ class EnsoErc4626Aggregator extends BaseAggregator {
         address: bundle.tx.to,
         data: bundle.tx.data as Hex,
         value: BigInt(bundle.tx.value ?? 0),
+        extraTags: { aggregator: this.name },
         // not returning gas limit because it's usually underestimated by enso.
         // gasLimit: BigInt(bundle.gas),
       }),

package/src/actions/dex/aggregators/erc4626.ts

@@ -30,7 +30,7 @@ class ERC4626Aggregator extends BaseAggregator {
    * Returns true when tokenOut is an ERC4626 vault whose underlying asset matches tokenIn,
    * or when depositing native BERA into swBERA.
    */
-  checkChainSupport({
+  getUnsupportedReason({
     tokenIn,
     tokenOut,
     underlyingToken,
@@ -38,16 +38,28 @@ class ERC4626Aggregator extends BaseAggregator {
     tokenIn: Token;
     tokenOut: Token;
     underlyingToken?: Token;
-  }): boolean {
-    const result =
-      super.checkChainSupport({ tokenIn, tokenOut, underlyingToken }) &&
+  }): string | null {
+    const base = super.getUnsupportedReason({
+      tokenIn,
+      tokenOut,
+      underlyingToken,
+    });
+    if (base !== null) {
+      return base;
+    }
+
+    const isVaultDeposit =
       !!underlyingToken &&
       underlyingToken?.chainId === tokenOut.chainId &&
       (isToken(underlyingToken, tokenIn) ||
         // this is a special case for the swbera vault
         (isToken(tokenIn, "BERA") && isToken(tokenOut, "SWBERA")));
 
-    return result;
+    if (isVaultDeposit) {
+      return null;
+    }
+
+    return `${this.name} only deposits a token into its matching ERC4626 vault.`;
   }
 
   /**
@@ -105,6 +117,7 @@ class ERC4626Aggregator extends BaseAggregator {
               functionName: "depositNative",
               params: [BigInt(amount), account],
               value: BigInt(amount),
+              extraTags: { aggregator: this.name },
             } satisfies Omit<
               IContractWrite<typeof stakeBeraVaultAbi, "depositNative">,
               "message" | "actionType"
@@ -116,6 +129,7 @@ class ERC4626Aggregator extends BaseAggregator {
               contractName: ContractName.ERC4626,
               params: [BigInt(amount), account],
               value: 0n,
+              extraTags: { aggregator: this.name },
             } satisfies Omit<
               IContractWrite<typeof erc4626Abi, "deposit">,
               "message" | "actionType"

package/src/actions/dex/aggregators/fly.ts

@@ -131,6 +131,7 @@ class FlyAggregator extends BaseAggregator {
             },
           ],
           functionName: "swap",
+          extraTags: { aggregator: this.name },
           abi: aggregatorsRouterAbi,
           // send full amount to router first, which will deduct the swap fee before executing trade
           value: isToken(tokenIn, "BERA") ? BigInt(amount) : BigInt("0"),

package/src/actions/dex/aggregators/haiku.ts

@@ -1,4 +1,4 @@
-import { formatUnits, parseUnits, zeroAddress } from "viem";
+import { type Address, formatUnits, parseUnits, zeroAddress } from "viem";
 
 import { ChainId } from "@berachain/config/internal";
 
@@ -6,7 +6,11 @@ import aggregatorsRouterAbi from "@berachain/abis/meta-aggregator/metaAggregator
 
 import { Aggregators, SwapReferrer } from "../../../enum/dex";
 import { BeraError } from "../../../errors/BeraError";
-import type { IAggregatorArgs, IRawAggregatorQuote } from "../../../types/dex";
+import type {
+  IAggregatorArgs,
+  IRawAggregatorQuote,
+  Token,
+} from "../../../types/dex";
 import type { IContractWrite } from "../../../types/global";
 import { BaseAggregator } from "./base";
 
@@ -21,6 +25,32 @@ class HaikuAggregator extends BaseAggregator {
     "No route found for the given input or the liquidity is not enough",
     "Invalid input amount. Please ensure the total amount of input is greater than 0.001 USD",
   ];
+
+  getUnsupportedReason({
+    tokenIn,
+    tokenOut,
+    rewardVault,
+  }: {
+    tokenIn: Token;
+    tokenOut: Token;
+    rewardVault?: Address;
+  }): string | null {
+    const base = super.getUnsupportedReason({ tokenIn, tokenOut });
+    if (base !== null) {
+      return base;
+    }
+
+    // Reward-vault staking zaps go through the restricted `zap-haiku` proxy key,
+    // which rejects quotes with a 400 (HUB-9FN/HUB-9FR). That's expected — Haiku
+    // isn't provisioned for zaps — so opt out up-front here so the quote hook is
+    // never called and no doomed request fires (and no Sentry error).
+    if (rewardVault) {
+      return `${this.name} does not support reward-vault staking.`;
+    }
+
+    return null;
+  }
+
   async getQuote({
     tokenIn,
     tokenOut,
@@ -158,6 +188,7 @@ class HaikuAggregator extends BaseAggregator {
             },
           ],
           functionName: "swap",
+          extraTags: { aggregator: this.name },
           abi: aggregatorsRouterAbi,
           // send full amount to router first, which will deduct the swap fee before executing trade
           value: isTokenInNative ? BigInt(amount) : BigInt("0"),

package/src/actions/dex/aggregators/honey.ts

@@ -69,7 +69,7 @@ export class HoneyNativeAggregator extends BaseAggregator {
     );
   }
 
-  checkChainSupport({
+  getUnsupportedReason({
     tokenIn,
     tokenOut,
     honeyNativeState,
@@ -77,16 +77,24 @@ export class HoneyNativeAggregator extends BaseAggregator {
     tokenIn: Token;
     tokenOut: Token;
     honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
-  }): boolean {
-    return (
-      super.checkChainSupport({ tokenIn, tokenOut }) &&
+  }): string | null {
+    const base = super.getUnsupportedReason({ tokenIn, tokenOut });
+    if (base !== null) {
+      return base;
+    }
+
+    if (
       tokenIn.chainId === tokenOut.chainId &&
       this.isHoneyNativeSwap({
         tokenIn: tokenIn.address,
         tokenOut: tokenOut.address,
         honeyNativeState,
       })
-    );
+    ) {
+      return null;
+    }
+
+    return `${this.name} only mints/redeems HONEY against a listed collateral.`;
   }
 
   async getQuote({
@@ -108,7 +116,10 @@ export class HoneyNativeAggregator extends BaseAggregator {
     }
     assertPublicClient(publicClient);
 
-    this.assertChainSupport({ tokenIn, tokenOut });
+    // Pass `honeyNativeState` through — Honey's `getUnsupportedReason` override
+    // needs it to confirm this is a valid mint/redeem. Without it the assert
+    // always fails with a misleading "chain ID: X and X" error (HUB-9FM).
+    this.assertChainSupport({ tokenIn, tokenOut, honeyNativeState });
 
     const isMint = isToken(tokenOut, this.honeyToken);
 

package/src/actions/dex/aggregators/kyberswap.ts

@@ -127,6 +127,7 @@ class KyberSwapAggregator extends BaseAggregator {
             },
           ],
           functionName: "swap",
+          extraTags: { aggregator: this.name },
           abi: aggregatorsRouterAbi,
           // send full amount to router first, which will deduct the swap fee before executing trade
           value: isTokenInNative ? BigInt(amount) : BigInt("0"),

package/src/actions/dex/aggregators/oogabooga.ts

@@ -100,6 +100,7 @@ class OogaboogaAggregator extends BaseAggregator {
             },
           ],
           functionName: "swap",
+          extraTags: { aggregator: this.name },
           abi: aggregatorsRouterAbi,
           // send full amount to router first, which will deduct the swap fee before executing trade
           value: isTokenInNative ? BigInt(amount) : BigInt("0"),

package/src/actions/dex/aggregators/openOcean.ts

@@ -136,6 +136,7 @@ class OpenOceanAggregator extends BaseAggregator {
             },
           ],
           functionName: "swap",
+          extraTags: { aggregator: this.name },
           abi: aggregatorsRouterAbi,
           // send full amount to router first, which will deduct the swap fee before executing trade
           value: isTokenInNative ? BigInt(amount) : BigInt("0"),

package/src/actions/dex/aggregators/wbera.ts

@@ -16,27 +16,31 @@ class WBeraAggregator extends BaseAggregator {
   name = Aggregators.Wrap;
   supportedChains = [ChainId.MAINNET, ChainId.BEPOLIA];
   readonly type = "rpc";
+  // This aggregator's entire job is BERA↔WBERA, so keep the base same-token
+  // (native-normalized) guard from rejecting it.
+  supportsBeraWrap = true;
 
-  checkChainSupport({
+  getUnsupportedReason({
     tokenIn,
     tokenOut,
   }: {
     tokenIn: Token;
     tokenOut: Token;
-  }): boolean {
+  }): string | null {
+    const base = super.getUnsupportedReason({ tokenIn, tokenOut });
+    if (base !== null) {
+      return base;
+    }
+
     if (
-      // same chain
-      tokenIn.chainId !== tokenOut.chainId ||
-      // must be one of our chains
-      !super.checkChainSupport({ tokenIn, tokenOut })
+      tokenIn.chainId === tokenOut.chainId &&
+      ((isToken(tokenIn, "BERA") && isToken(tokenOut, "WBERA")) ||
+        (isToken(tokenIn, "WBERA") && isToken(tokenOut, "BERA")))
     ) {
-      return false;
+      return null;
     }
 
-    return (
-      (isToken(tokenIn, "BERA") && isToken(tokenOut, "WBERA")) ||
-      (isToken(tokenIn, "WBERA") && isToken(tokenOut, "BERA"))
-    );
+    return `${this.name} only wraps/unwraps between BERA and WBERA on the same chain.`;
   }
 
   // handles native swaps: wrap and unwrap
@@ -67,6 +71,7 @@ class WBeraAggregator extends BaseAggregator {
               functionName: "deposit",
               params: [],
               value: BigInt(amount),
+              extraTags: { aggregator: this.name },
             } satisfies Omit<
               IContractWrite<typeof wberaAbi, "deposit">,
               "message" | "actionType"
@@ -77,6 +82,7 @@ class WBeraAggregator extends BaseAggregator {
               functionName: "withdraw",
               params: [BigInt(amount)],
               value: BigInt(0),
+              extraTags: { aggregator: this.name },
             } satisfies Omit<
               IContractWrite<typeof wberaAbi, "withdraw">,
               "message" | "actionType"

package/src/actions/dex/getPoolWithState.ts

@@ -7,7 +7,7 @@ import type { Address } from "viem";
 
 import type { MinimalPoolFragment } from "@berachain/graphql/dex/api";
 
-export const getPoolState = (apiPool: MinimalPoolFragment): PoolState => {
+export function getPoolState(apiPool: MinimalPoolFragment): PoolState {
   return {
     type: mapPoolType(apiPool.type),
     protocolVersion: apiPool.protocolVersion as 1 | 2 | 3,
@@ -21,4 +21,4 @@ export const getPoolState = (apiPool: MinimalPoolFragment): PoolState => {
     id: apiPool.id as Address,
     address: apiPool.address as Address,
   } satisfies PoolState;
-};
+}