@berachain/berajs 0.2.13 → 0.3.0

package/src/actions/clients/getApolloClient.ts

@@ -3,13 +3,14 @@ import { HttpLink } from "@apollo/client/link/http";
 
 import type { HttpLink as BeraConfigHttpLink } from "@berachain/config";
 import { getUriFromLink } from "@berachain/config";
-import { currentDapp, goldskyBaseUrl } from "@berachain/config/internal";
+import { goldskyBaseUrl } from "@berachain/config/internal";
 
 import apiResults from "@berachain/graphql/dex/api";
 
 import { BeraError } from "../../errors/BeraError";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 import { BeraApolloClient } from "./BeraApolloClient";
+import { getClientName } from "./clientName";
 
 /**
  * If currentDapp is set, it will add the stellate client name and version to the headers.
@@ -17,8 +18,6 @@ import { BeraApolloClient } from "./BeraApolloClient";
  */
 function applyStellateClientName(url: BeraConfigHttpLink): BeraConfigHttpLink {
   const headers = typeof url === "string" ? undefined : url.headers;
-  const isDapp = !!currentDapp;
-  const isTest = process.env.VERCEL_ENV === "test";
 
   const uri = getUriFromLink(url);
   const name = typeof url === "string" ? "unknown" : url.name;
@@ -28,14 +27,7 @@ function applyStellateClientName(url: BeraConfigHttpLink): BeraConfigHttpLink {
     name,
     headers: {
       ...headers,
-      "x-graphql-client-name": `berachain.${
-        isDapp
-          ? "dapps"
-          : isTest
-            ? "test"
-            : // this tracks usage of the berajs package in other packages
-              "berajs"
-      }`,
+      "x-graphql-client-name": getClientName(),
       "x-graphql-client-version": `${process.env.VERCEL_TARGET_ENV}.${process.env.VERCEL_GIT_COMMIT_SHA}`,
     },
   };

package/src/actions/dex/__tests__/aggregators.unit.test.ts

@@ -1,11 +1,20 @@
 import { beforeEach, describe, expect, test } from "vitest";
 
-import { ChainId } from "@berachain/config/internal";
+import { ChainId, chainConfigs } from "@berachain/config/internal";
 
 import { Aggregators } from "../../../enum/dex";
 import { BeraError } from "../../../errors/BeraError";
-import type { IAggregatorArgs, IRawAggregatorQuote } from "../../../types/dex";
+import type {
+  IAggregatorArgs,
+  IRawAggregatorQuote,
+  MinimalERC20,
+} from "../../../types/dex";
 import { BaseAggregator } from "../aggregators/base";
+import { bex } from "../aggregators/bex";
+import { enso } from "../aggregators/enso/enso";
+import { ensoErc4626 } from "../aggregators/enso/ensoErc4626";
+import { haiku } from "../aggregators/haiku";
+import { wberaSwap } from "../aggregators/wbera";
 
 // Test implementation of BaseAggregator to access protected methods
 class TestAggregator extends BaseAggregator {
@@ -107,3 +116,223 @@ describe("BaseAggregator.getAmountAfterFees", () => {
     expect(result).toBe("996");
   });
 });
+
+describe("BexAggregator.getUnsupportedReason opt-outs (HUB-A6D, HUB-A5R)", () => {
+  function token(
+    decimals: number,
+    address = "0x0000000000000000000000000000000000000001",
+  ): MinimalERC20 {
+    return {
+      address: address as `0x${string}`,
+      decimals,
+      symbol: "TKN",
+      name: "Token",
+      chainId: ChainId.MAINNET,
+    };
+  }
+
+  const bgt = token(18, chainConfigs[ChainId.MAINNET].tokens.bgt);
+  const tokenA = token(18, "0x0000000000000000000000000000000000000001");
+  const tokenB = token(6, "0x0000000000000000000000000000000000000002");
+
+  test("supports a normal 0–18 decimal pair", () => {
+    expect(
+      bex.getUnsupportedReason({ tokenIn: tokenA, tokenOut: tokenB }),
+    ).toBeNull();
+  });
+
+  // b-sdk's `TokenAmount` scales by `pow10[18 - decimals]`; a token with >18
+  // decimals (e.g. 27-decimal ctBeraUSDe) or non-integer decimals throws
+  // "Cannot mix BigInt and other types".
+  test("rejects a token with >18 decimals", () => {
+    const highDecimals = token(
+      27,
+      "0x0000000000000000000000000000000000000003",
+    );
+    expect(
+      bex.getUnsupportedReason({ tokenIn: highDecimals, tokenOut: tokenB }),
+    ).not.toBeNull();
+  });
+
+  test("rejects a token with non-integer decimals", () => {
+    const nanDecimals = token(
+      Number.NaN,
+      "0x0000000000000000000000000000000000000004",
+    );
+    expect(
+      bex.getUnsupportedReason({ tokenIn: tokenA, tokenOut: nanDecimals }),
+    ).not.toBeNull();
+  });
+
+  // BGT has no Balancer pool (redeemed via the BGT aggregator), so a bex quote
+  // always throws NO_SWAP_PATHS — opt out whether it's in or out.
+  test("rejects BGT as tokenIn", () => {
+    expect(
+      bex.getUnsupportedReason({ tokenIn: bgt, tokenOut: token(18) }),
+    ).not.toBeNull();
+  });
+
+  test("rejects BGT as tokenOut", () => {
+    expect(
+      bex.getUnsupportedReason({ tokenIn: token(18), tokenOut: bgt }),
+    ).not.toBeNull();
+  });
+});
+
+describe("getUnsupportedReason BERA↔WBERA normalization (HUB-9FQ)", () => {
+  function token(address: string): MinimalERC20 {
+    return {
+      address: address as `0x${string}`,
+      decimals: 18,
+      symbol: "TKN",
+      name: "Token",
+      chainId: ChainId.MAINNET,
+    };
+  }
+
+  const bera = token("0x0000000000000000000000000000000000000000");
+  const wbera = token(chainConfigs[ChainId.MAINNET].tokens.wbera);
+  const honey = token(chainConfigs[ChainId.MAINNET].honey.token);
+
+  // Aggregators that normalize native BERA → WBERA collapse this pair to
+  // WBERA↔WBERA — the router 400s with "tokenIn and tokenOut cannot be the
+  // same". supportsBeraWrap is false for these, so the base gate rejects it.
+  test("rejects native BERA against WBERA for non-wrap aggregators", () => {
+    expect(
+      enso.getUnsupportedReason({ tokenIn: bera, tokenOut: wbera }),
+    ).not.toBeNull();
+    expect(
+      enso.getUnsupportedReason({ tokenIn: wbera, tokenOut: bera }),
+    ).not.toBeNull();
+    expect(
+      bex.getUnsupportedReason({ tokenIn: bera, tokenOut: wbera }),
+    ).not.toBeNull();
+  });
+
+  // The wrap/unwrap aggregator sets supportsBeraWrap, so it still accepts it.
+  test("keeps supporting BERA↔WBERA for the wrap aggregator", () => {
+    expect(
+      wberaSwap.getUnsupportedReason({ tokenIn: bera, tokenOut: wbera }),
+    ).toBeNull();
+    expect(
+      wberaSwap.getUnsupportedReason({ tokenIn: wbera, tokenOut: bera }),
+    ).toBeNull();
+  });
+
+  test("still supports a normal distinct pair", () => {
+    expect(
+      enso.getUnsupportedReason({ tokenIn: wbera, tokenOut: honey }),
+    ).toBeNull();
+  });
+
+  // getUnsupportedReason carries the reason; assertChainSupport used to throw a
+  // misleading "does not support chain ID" — it now surfaces the real reason.
+  test("carries an accurate BERA↔WBERA reason", () => {
+    expect(
+      enso.getUnsupportedReason({ tokenIn: bera, tokenOut: wbera }),
+    ).toMatch(/BERA and WBERA/);
+    expect(() =>
+      enso.assertChainSupport({ tokenIn: bera, tokenOut: wbera }),
+    ).toThrow(/BERA and WBERA/);
+  });
+});
+
+// Haiku's zap-haiku proxy key is restricted and 400s on reward-vault staking
+// (HUB-9FN/HUB-9FR). Opt out up-front so the quote hook never fires the request.
+describe("HaikuAggregator.getUnsupportedReason — reward-vault staking", () => {
+  function token(address: string): MinimalERC20 {
+    return {
+      address: address as `0x${string}`,
+      decimals: 18,
+      symbol: "TKN",
+      name: "Token",
+      chainId: ChainId.MAINNET,
+    };
+  }
+
+  const tokenA = token("0x0000000000000000000000000000000000000001");
+  const tokenB = token("0x0000000000000000000000000000000000000002");
+  const rewardVault = "0x0000000000000000000000000000000000000003" as const;
+
+  test("rejects a reward-vault zap", () => {
+    expect(
+      haiku.getUnsupportedReason({
+        tokenIn: tokenA,
+        tokenOut: tokenB,
+        rewardVault,
+      }),
+    ).not.toBeNull();
+  });
+
+  test("still supports a normal swap (no reward vault)", () => {
+    expect(
+      haiku.getUnsupportedReason({ tokenIn: tokenA, tokenOut: tokenB }),
+    ).toBeNull();
+  });
+});
+
+// A cross-chain pair (tokenIn.chainId !== tokenOut.chainId) is rejected up-front
+// unless the aggregator sets supportsBridging, so the swap-page fan-out can be
+// handed multichain pairs safely.
+describe("getUnsupportedReason cross-chain routing", () => {
+  // supportedChains: null isolates the bridging gate from the chain-support gate.
+  class NonBridgingAggregator extends BaseAggregator {
+    name = Aggregators.Fly;
+    readonly type = "rest";
+    supportedChains = null;
+
+    async getQuote(_args: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+      throw new Error("Not implemented for testing");
+    }
+  }
+  const singleChain = new NonBridgingAggregator();
+
+  function token(chainId: number, address: string): MinimalERC20 {
+    return {
+      address: address as `0x${string}`,
+      decimals: 18,
+      symbol: "TKN",
+      name: "Token",
+      chainId,
+    };
+  }
+
+  const beraToken = token(
+    ChainId.MAINNET,
+    "0x0000000000000000000000000000000000000001",
+  );
+  const foreignToken = token(
+    ChainId.BEPOLIA,
+    "0x0000000000000000000000000000000000000002",
+  );
+
+  test("rejects a cross-chain pair on a non-cross-chain aggregator", () => {
+    expect(
+      singleChain.getUnsupportedReason({
+        tokenIn: foreignToken,
+        tokenOut: beraToken,
+      }),
+    ).toMatch(/cannot route across chains/);
+  });
+
+  test("allows the same cross-chain pair on ensoErc4626", () => {
+    expect(
+      ensoErc4626.getUnsupportedReason({
+        tokenIn: foreignToken,
+        tokenOut: beraToken,
+      }),
+    ).toBeNull();
+  });
+
+  test("still allows a same-chain pair on a non-cross-chain aggregator", () => {
+    expect(
+      singleChain.getUnsupportedReason({
+        tokenIn: beraToken,
+        tokenOut: token(
+          ChainId.MAINNET,
+          "0x0000000000000000000000000000000000000003",
+        ),
+      }),
+    ).toBeNull();
+  });
+});

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

@@ -30,6 +30,28 @@ export abstract class BaseAggregator {
   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;
@@ -48,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
@@ -172,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,
   }: {
@@ -184,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" });
     }
   }
 

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

@@ -1,5 +1,6 @@
 import {
   type Address,
+  DECIMAL_SCALES,
   Slippage,
   type SorSwapResult,
   Swap,
@@ -19,7 +20,11 @@ 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 "../bSdk";
 import { BaseAggregator } from "./base";
@@ -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
    */
@@ -220,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"),