@berachain/berajs 0.2.12 → 0.3.0

package/src/errors/BeraError.ts

@@ -37,6 +37,31 @@ export interface IBeraErrorArgs {
 
 type Primitive = number | string | boolean | bigint | symbol | null | undefined;
 
+/**
+ * JSON-RPC error codes that are transient / not actionable by us — provider-side
+ * or network failures rather than a bug in our request. Downleveled to "warning"
+ * so they don't pollute the Sentry error stream.
+ *
+ * We use an explicit allowlist rather than the whole -32000..-32099 server-error
+ * range, because that range is implementation-defined and includes *actionable*
+ * failures too (e.g. providers return -32000 for "invalid input" / "insufficient
+ * funds", -32004 for "method not supported"). Downleveling the whole range would
+ * hide malformed calls we should fix.
+ *
+ * @see https://www.jsonrpc.org/specification#error_object
+ * @see https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+const TRANSIENT_RPC_CODES = new Set<number>([
+  -32603, // internal JSON-RPC error (provider blew up handling a valid request)
+  -32002, // resource unavailable / request already pending
+  -32005, // limit exceeded (rate limited)
+  -32016, // request timed out
+]);
+
+function isTransientRpcCode(code: number): boolean {
+  return TRANSIENT_RPC_CODES.has(code);
+}
+
 /**
  * An helper type to make sure we only use the allowed tags. Sync this with docs/errors.md
  */
@@ -187,6 +212,10 @@ export class BeraError extends Error {
     // ContractFunctionRevertedError → RpcRequestError) and decodes revert data using ABI.
     // The extracted reason (e.g. "NotEnoughBalance", "BAL#508") is the key that drives
     // displayMessage resolution and Sentry fingerprinting.
+    // JSON-RPC error code carried by a plain-object cause (set below), used for
+    // level inference. Only populated when `cause` isn't a viem/Error.
+    let rpcCode: number | undefined;
+
     if (reason) {
       this.reason = reason;
     } else if (cause instanceof Error) {
@@ -202,14 +231,35 @@ export class BeraError extends Error {
         // parseViemError throws when it can't identify the error type and revertIfUnknown=true.
         // In that case, reason stays null and displayMessage falls back to GENERAL_ERROR.
       }
+    } else if (
+      // Plain object carrying a JSON-RPC error code (e.g. a wallet/RPC provider
+      // rejecting with `{ code: -32603, message: "Internal JSON-RPC error." }`).
+      // These aren't viem errors, so parseViemError never sees them — derive the
+      // reason straight from the code instead of dropping it.
+      typeof cause === "object" &&
+      cause !== null &&
+      "code" in cause &&
+      typeof cause.code === "number"
+    ) {
+      rpcCode = cause.code;
+      this.reason = rpcErrorToReason(cause.code);
     }
 
     // ── Level inference ─────────────────────────────────────────────────
-    // User rejections are "info" (not actionable by devs), everything else defaults to "error".
+    // Priority:
+    //   1. Explicit `level` from caller
+    //   2. User rejections → "info" (not actionable by devs)
+    //   3. Transient/provider JSON-RPC errors → "warning" (see isTransientRpcCode).
+    //      We deliberately do NOT downlevel the actionable codes (-32600 invalid
+    //      request, -32601 method not found, -32602 invalid params, -32700 parse
+    //      error) — those usually mean a bug in our request construction.
+    //   4. Everything else → "error"
     if (level) {
       this.level = level;
     } else if (this.reason === rpcErrorToReason("UserRejectedRequestError")) {
       this.level = "info";
+    } else if (rpcCode !== undefined && isTransientRpcCode(rpcCode)) {
+      this.level = "warning";
     } else {
       this.level = "error";
     }

package/src/errors/BeraError.unit.test.ts

@@ -0,0 +1,94 @@
+import { WaitForTransactionReceiptTimeoutError } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { BeraError } from "./BeraError.js";
+
+describe("BeraError JSON-RPC code classification", () => {
+  it("derives a reason from a plain-object cause carrying a numeric JSON-RPC code", () => {
+    // A wallet/RPC provider rejecting with `{ code, message }` (not a viem
+    // error) — parseViemError never sees it, so the code is the only signal.
+    const err = new BeraError({
+      cause: { code: -32000, message: "execution reverted" },
+    });
+
+    // -32000 has no errorMap keyword match, so the reason stays the raw RPC key.
+    expect(err.reason).toBe("RPC_ERROR_-32000");
+  });
+
+  it("classifies transient JSON-RPC provider errors (-32603) as warning", () => {
+    const err = new BeraError({
+      cause: { code: -32603, message: "Internal JSON-RPC error." },
+    });
+
+    // Not an actionable bug in our code — should not be a hard error.
+    expect(err.level).toBe("warning");
+  });
+
+  it("classifies known transient provider codes as warning", () => {
+    // Allowlisted transient/network failures, not a bug in our request.
+    for (const code of [-32603, -32002, -32005, -32016]) {
+      const err = new BeraError({ cause: { code, message: "server error" } });
+      expect(err.level).toBe("warning");
+    }
+  });
+
+  it("keeps actionable JSON-RPC codes as error (our request is likely wrong)", () => {
+    // Standard actionable codes (-32700 parse · -32600 invalid request ·
+    // -32601 method not found · -32602 invalid params) plus other
+    // implementation-defined codes in the -32000..-32099 range that providers
+    // use for actionable failures (e.g. -32000 invalid input, -32004 method
+    // not supported) — none of these should be hidden from Sentry error level.
+    for (const code of [-32700, -32600, -32601, -32602, -32000, -32004]) {
+      const err = new BeraError({ cause: { code, message: "bad request" } });
+      expect(err.level).toBe("error");
+    }
+  });
+
+  it("classifies code 4001 as a user rejection (info)", () => {
+    const err = new BeraError({
+      cause: { code: 4001, message: "User rejected the request." },
+    });
+
+    expect(err.reason).toBe("UserRejectedRequestError");
+    expect(err.level).toBe("info");
+  });
+
+  it("still extracts the message from the plain-object cause", () => {
+    const err = new BeraError({
+      cause: { code: -32603, message: "Internal JSON-RPC error." },
+    });
+
+    expect(err.message).toBe("Internal JSON-RPC error.");
+  });
+
+  it("respects an explicit level over the inferred one", () => {
+    const err = new BeraError({
+      cause: { code: -32603, message: "Internal JSON-RPC error." },
+      level: "fatal",
+    });
+
+    expect(err.level).toBe("fatal");
+  });
+});
+
+// The transaction store (transactionStore.ts) pins a stable Sentry fingerprint
+// on receipt timeouts by keying off exactly this reason string (HUB-97H/HUB-981
+// grouping). If the pipeline ever stops deriving it, that grouping silently
+// breaks — so lock the contract here.
+describe("BeraError reason — receipt timeout fingerprint contract", () => {
+  it("derives WaitForTransactionReceiptTimeoutError from viem's timeout error", () => {
+    const err = new BeraError({
+      cause: new WaitForTransactionReceiptTimeoutError({ hash: "0xdeadbeef" }),
+    });
+
+    expect(err.reason).toBe("WaitForTransactionReceiptTimeoutError");
+  });
+
+  it("does not derive that reason for an unrelated transaction error", () => {
+    const err = new BeraError({
+      cause: { code: 4001, message: "User rejected the request." },
+    });
+
+    expect(err.reason).not.toBe("WaitForTransactionReceiptTimeoutError");
+  });
+});

package/src/errors/BeraTracing.unit.test.ts

@@ -19,7 +19,7 @@ describe("BeraTracing", () => {
     it("wraps the callback in the handler", async () => {
       const order: string[] = [];
 
-      const handler = vi.fn(async (context: any, callback: any) => {
+      const handler = vi.fn(async (_context: any, callback: any) => {
         order.push("handler-start");
         const result = await callback();
         order.push("handler-end");
@@ -53,24 +53,24 @@ describe("BeraTracing", () => {
     it("chains handlers so first registered is outermost", async () => {
       const order: string[] = [];
 
-      const handler1 = async (_ctx: any, cb: () => Promise<any>) => {
+      async function handler1(_ctx: any, cb: () => Promise<any>) {
         order.push("h1-start");
         const r = await cb();
         order.push("h1-end");
         return r;
-      };
-      const handler2 = async (_ctx: any, cb: () => Promise<any>) => {
+      }
+      async function handler2(_ctx: any, cb: () => Promise<any>) {
         order.push("h2-start");
         const r = await cb();
         order.push("h2-end");
         return r;
-      };
-      const handler3 = async (_ctx: any, cb: () => Promise<any>) => {
+      }
+      async function handler3(_ctx: any, cb: () => Promise<any>) {
         order.push("h3-start");
         const r = await cb();
         order.push("h3-end");
         return r;
-      };
+      }
 
       const unsub1 = BeraTracing.addSpanHandler(handler1);
       const unsub2 = BeraTracing.addSpanHandler(handler2);
@@ -133,7 +133,9 @@ describe("BeraTracing", () => {
 
   describe("error propagation", () => {
     it("propagates errors from the callback through handlers", async () => {
-      const handler = async (_ctx: any, cb: () => Promise<any>) => cb();
+      async function handler(_ctx: any, cb: () => Promise<any>) {
+        return cb();
+      }
       const unsub = BeraTracing.addSpanHandler(handler);
 
       await expect(
@@ -149,9 +151,9 @@ describe("BeraTracing", () => {
     });
 
     it("propagates errors from a handler", async () => {
-      const handler = async () => {
+      async function handler<T>(): Promise<T> {
         throw new Error("handler error");
-      };
+      }
       const unsub = BeraTracing.addSpanHandler(handler);
 
       await expect(
@@ -171,10 +173,7 @@ describe("BeraTracing", () => {
       const statuses: string[] = [];
 
       // Simulates the Sentry adapter wrapper pattern
-      const adapterHandler = async (
-        _ctx: any,
-        callback: () => Promise<any>,
-      ) => {
+      async function adapterHandler(_ctx: any, callback: () => Promise<any>) {
         try {
           const result = await callback();
           statuses.push("ok");
@@ -187,7 +186,7 @@ describe("BeraTracing", () => {
           statuses.push(status);
           throw error;
         }
-      };
+      }
 
       const unsub = BeraTracing.addSpanHandler(adapterHandler);
 
@@ -234,13 +233,13 @@ describe("BeraTracing", () => {
     it("works with a handler that accepts (options, callback) like Sentry.startSpan", async () => {
       // Sentry.startSpan signature: <T>(options, callback: (span) => T) => T
       // When callback returns Promise<T>, the return is Promise<T>
-      const mockSentryStartSpan = <T>(
+      function mockSentryStartSpan<T>(
         _options: { name: string },
         callback: (span: unknown) => T,
-      ): T => {
+      ): T {
         // Sentry passes a span object to the callback; our callbacks ignore it
         return callback({ spanId: "mock-span" });
-      };
+      }
 
       const unsub = BeraTracing.addSpanHandler(
         mockSentryStartSpan as typeof BeraTracing.startSpan,

package/src/errors/RequestError.ts

@@ -20,6 +20,27 @@ export class RequestError extends BeraError {
   static isCorsError(error: Error) {
     return error.cause instanceof Response && error.cause.type === "cors";
   }
+
+  /**
+   * Matches the standard error messages browsers produce when fetch fails due
+   * to a network or CORS error, as empirically collected from Sentry. The
+   * trailing "(host)" suffix is our own annotation and optional: bare fetch
+   * TypeErrors are just "Failed to fetch" / "Load failed".
+   */
+  private static readonly NETWORK_ERROR_MESSAGE_REGEX =
+    /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed)(?: \(([a-z0-9-.]+)\))?$/;
+
+  /**
+   * Whether a message is a browser fetch network-failure message. Used to tell
+   * genuine network TypeErrors apart from ordinary TypeErrors (which must NOT
+   * be grouped as network errors — see sentryBeforeSend).
+   */
+  static isNetworkErrorMessage(message: string): boolean {
+    return (
+      message.startsWith("Network Error") ||
+      RequestError.NETWORK_ERROR_MESSAGE_REGEX.test(message)
+    );
+  }
   /**
    * The endpoint that was requested.
    */
@@ -54,6 +75,9 @@ export class RequestError extends BeraError {
     429: "RATE_LIMITED_429",
     NETWORK_ERROR: "NETWORK_ERROR",
     CORS_ERROR: "CORS",
+    // Aggregator/SOR found no route for the requested pair/amount. Expected, not
+    // a failure — reported as a warning and grouped into a single Sentry issue.
+    NO_SWAP_PATHS: "NO_SWAP_PATHS",
   } as const;
 
   constructor(
@@ -110,6 +134,14 @@ export class RequestError extends BeraError {
       }
     }
 
+    // "No swap paths" means the aggregator/SOR found no route for this token
+    // pair/amount — an expected condition, not a failure. Downlevel to "warning"
+    // so it stays out of the Sentry error stream. (The SWR error handler also
+    // collapses all sources into a single group; see SWRConfig.tsx.)
+    if (this.reason === RequestError.REASON_MAP.NO_SWAP_PATHS) {
+      this.level = args.level ?? "warning";
+    }
+
     // ── Span status inference ─────────────────────────────────────────
     // Re-infer from reason since it may have been set after super() ran
     // (e.g. NETWORK_ERROR → unavailable, RATE_LIMITED_429 → resource_exhausted).
@@ -142,6 +174,19 @@ export class RequestError extends BeraError {
     this.message = `${message}${endpointLabel}: ${this.message}`;
   }
 
+  /**
+   * The hostname of the requested endpoint (e.g. "beep.berachain.com"), used to
+   * group network errors by domain in Sentry. Falls back to the full url for
+   * relative/malformed urls that have no parseable host.
+   */
+  get host(): string {
+    try {
+      return new URL(this.endpoint.url).hostname;
+    } catch {
+      return this.endpoint.url;
+    }
+  }
+
   setEndpoint(
     endpoint:
       | string
@@ -164,6 +209,14 @@ export class RequestError extends BeraError {
       };
     }
 
+    // Redact 40-hex addresses in the path (e.g. /wallets/0x…/autoclaimed) so
+    // per-wallet urls collapse to one Sentry fingerprint. Mirrors the span-url
+    // redaction in beraFetch; the error message/title is built from this url.
+    this.endpoint.url = this.endpoint.url.replace(
+      /0x[a-fA-F0-9]{40}/g,
+      ":address",
+    );
+
     if (
       this.queryRichfulDomains.some((domain) =>
         this.endpoint.url.includes(getUriFromLink(domain)),
@@ -174,7 +227,10 @@ export class RequestError extends BeraError {
         const url = new URL(this.endpoint.url);
         url.search = "";
         this.endpoint.url = url.toString();
-      } catch {}
+      } catch {
+        // FIXME(coding-standards): error intentionally swallowed; a malformed
+        // URL just keeps the original endpoint url. Preserved to avoid behavior change.
+      }
     }
     this.tags = {
       ...this.tags,
@@ -209,16 +265,11 @@ export class RequestError extends BeraError {
         };
       }
 
-      // this matches standard error messages as they're returned by browser fetch when they either:
-      // - have a network error
-      // - have CORS errors
-      // the list is empirically collected from sentry error logs.
-      // The trailing "(host)" suffix is optional: some browsers/transports omit
-      // it (e.g. bare "Failed to fetch" / "Load failed"). We normalize all of
-      // them to a single NETWORK_ERROR reason so the variants group together,
-      // falling back to the endpoint url when no host is present in the message.
+      // We normalize all fetch network-failure variants to a single
+      // NETWORK_ERROR reason so they group together, falling back to the
+      // endpoint url when no host is present in the message.
       const failedToFetchMatch = message.match(
-        /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed)(?: \(([a-z0-9-.]+)\))?$/,
+        RequestError.NETWORK_ERROR_MESSAGE_REGEX,
       );
       if (failedToFetchMatch) {
         return {

package/src/errors/RequestError.unit.test.ts

@@ -24,6 +24,27 @@ describe("RequestError endpoint normalization (grouping)", () => {
     expect(b.endpoint.url).toBe(base);
     expect(a.endpoint.url).toBe(b.endpoint.url);
   });
+
+  it("redacts wallet addresses in the path so per-wallet urls group together (HUB-A8T)", () => {
+    function mk(addr: string) {
+      return new RequestError({
+        response: undefined,
+        statusCode: 500,
+        endpoint: {
+          url: `https://api-claim.berachain.com/api/v1/wallets/${addr}/autoclaimed/txhash`,
+          type: "rest",
+        },
+      });
+    }
+    const a = mk("0x9675b119c6907a1d17b4ad9ec14f03d3c4435635");
+    const b = mk("0x1111111111111111111111111111111111111111");
+
+    const expected =
+      "https://api-claim.berachain.com/api/v1/wallets/:address/autoclaimed/txhash";
+    expect(a.endpoint.url).toBe(expected);
+    expect(a.message).toBe(b.message);
+    expect(a.host).toBe("api-claim.berachain.com");
+  });
 });
 
 describe("RequestError network-error normalization (grouping)", () => {
@@ -52,4 +73,84 @@ describe("RequestError network-error normalization (grouping)", () => {
 
     expect(err.reason).not.toBe(RequestError.REASON_MAP.NETWORK_ERROR);
   });
+
+  it("groups network errors by host regardless of path/query (HONEY-1AH)", () => {
+    const a = new RequestError({
+      response: undefined,
+      cause: new TypeError("Failed to fetch"),
+      endpoint: {
+        url: "https://beep.berachain.com/v1/honey/balances",
+        type: "rest",
+      },
+    });
+    const b = new RequestError({
+      response: undefined,
+      cause: new TypeError("Failed to fetch"),
+      endpoint: {
+        url: "https://beep.berachain.com/v1/bonders?start=2025-11-28",
+        type: "rest",
+      },
+    });
+
+    expect(a.host).toBe("beep.berachain.com");
+    expect(a.host).toBe(b.host);
+  });
+
+  it("falls back to the raw url for a relative/malformed endpoint", () => {
+    const err = new RequestError({
+      response: undefined,
+      endpoint: { url: "/api/internal/foo", type: "rest" },
+    });
+
+    // No parseable host on a relative url → fall back to the url itself so the
+    // fingerprint stays stable rather than throwing.
+    expect(err.host).toBe("/api/internal/foo");
+  });
+});
+
+describe("RequestError NO_SWAP_PATHS leveling", () => {
+  it("downlevels NO_SWAP_PATHS to warning (expected, not a failure)", () => {
+    const err = new RequestError({
+      response: undefined,
+      reason: RequestError.REASON_MAP.NO_SWAP_PATHS,
+      endpoint: { url: "https://api.berachain.com", type: "graphql" },
+    });
+
+    expect(err.reason).toBe(RequestError.REASON_MAP.NO_SWAP_PATHS);
+    expect(err.level).toBe("warning");
+  });
+
+  it("keeps the level the same regardless of which source reported it", () => {
+    const fromOpenOcean = new RequestError({
+      response: undefined,
+      reason: RequestError.REASON_MAP.NO_SWAP_PATHS,
+      endpoint: {
+        url: "https://open-api.openocean.finance/v4/bera/swap",
+        type: "rest",
+      },
+    });
+
+    expect(fromOpenOcean.level).toBe("warning");
+  });
+
+  it("lets an explicit level override the downlevel", () => {
+    const err = new RequestError({
+      response: undefined,
+      reason: RequestError.REASON_MAP.NO_SWAP_PATHS,
+      level: "error",
+      endpoint: { url: "https://api.berachain.com", type: "graphql" },
+    });
+
+    expect(err.level).toBe("error");
+  });
+
+  it("does not downlevel other reasons to warning", () => {
+    const err = new RequestError({
+      response: undefined,
+      reason: "SOME_OTHER_REASON",
+      endpoint: { url: "https://api.berachain.com", type: "graphql" },
+    });
+
+    expect(err.level).toBe("error");
+  });
 });

package/src/errors/assert.ts

@@ -124,7 +124,13 @@ export function assertAddress(
  * @throws An InvalidArgumentError if the value is not positive.
  */
 export function assertPositive(
+  /**
+   * The value to assert.
+   */
   value: string | bigint | number,
+  /**
+   * The property name.
+   */
   property: string,
 ): void {
   const isPositive = typeof value === "bigint" ? value > 0n : Number(value) > 0;
@@ -137,6 +143,29 @@ export function assertPositive(
   }
 }
 
+/**
+ * Asserts that a value is an integer.
+ * @throws An InvalidArgumentError if the value is not an integer.
+ */
+export function assertInteger(
+  /**
+   * The value to assert.
+   */
+  value: number,
+  /**
+   * The property name.
+   */
+  property: string,
+): void {
+  if (!Number.isInteger(value)) {
+    throw new InvalidArgumentError({
+      property,
+      value,
+      expected: "integer",
+    });
+  }
+}
+
 /**
  * Asserts that a value is a number greater than 0.
  * @throws An InvalidArgumentError if the value is undefined, null, not a string or number, or not a number greater than 0.

package/src/errors/errorMap.ts

@@ -108,10 +108,15 @@ export const errorMsgMap = {
       errorMSG:
         "It seems an RPC error has occurred. Please try your request one more later.",
     },
-    HASH: {
-      keywords: ["hash"],
+    // Tx was broadcast but we timed out waiting for the receipt (RPC lag / dropped
+    // tx). Match on viem's error name (exact reason) — NOT a bare "hash" keyword,
+    // which used to match any message mentioning a tx/block/typehash and dumped
+    // unrelated errors into one meaningless "HASH" group (HUB-A9T).
+    TRANSACTION_TIMEOUT: {
+      reasons: ["WaitForTransactionReceiptTimeoutError"],
+      keywords: ["Timed out while waiting for transaction with hash"],
       errorMSG:
-        "It seems an RPC error has occurred. Please check if your transaction was finalized. If not, please try again.",
+        "Transaction sent, but we couldn't confirm it in time. Check your wallet — if it didn't go through, try again.",
     },
     USER_REJECTION: {
       reasons: ["UserRejectedRequestError"],

package/src/errors/getErrorMessage.unit.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+
+import { findMatchingError } from "./getErrorMessage.js";
+
+describe("findMatchingError — transaction timeout (HUB-A9T)", () => {
+  const timeoutMessage =
+    'Timed out while waiting for transaction with hash "0x18160719ceffa85166d389a3a075ca081e8925b69d6e73884af01082421d124b" to be confirmed.';
+
+  it("matches viem's timeout error name via exact reason", () => {
+    const matched = findMatchingError({
+      reason: "WaitForTransactionReceiptTimeoutError",
+      message: timeoutMessage,
+    });
+    expect(matched?.key).toBe("TRANSACTION_TIMEOUT");
+    expect(matched?.matchedByReason).toBe(true);
+  });
+
+  it("still matches the timeout by message keyword when reason is absent", () => {
+    const matched = findMatchingError({ message: timeoutMessage });
+    expect(matched?.key).toBe("TRANSACTION_TIMEOUT");
+  });
+
+  it("no longer misfiles unrelated hash-mentioning errors into a HASH bucket", () => {
+    // Regression: the old `keywords: ["hash"]` entry swallowed any message
+    // containing "hash" (tx hash, block hash, typehash, …).
+    const matched = findMatchingError({
+      message: "invalid domain separator typehash for permit signature",
+    });
+    expect(matched?.key).not.toBe("HASH");
+    expect(matched?.key).not.toBe("TRANSACTION_TIMEOUT");
+  });
+});

package/src/hooks/bend/useGetConvertToAssets.ts

@@ -6,14 +6,14 @@ import { getConvertToAssets } from "../../actions/bend/getConvertToAssets";
 import { assertPublicClient } from "../../errors/assert";
 import type { DefaultHookOptions } from "../../types/global";
 
-export const useGetConvertToAssets = (
+export function useGetConvertToAssets(
   {
     sharesAmount,
     vaultAddress,
     vaultChainId,
   }: Omit<GetConvertToAssetsProps, "publicClient"> & { vaultChainId?: number },
   options?: DefaultHookOptions,
-) => {
+) {
   const publicClient = usePublicClient({ chainId: vaultChainId });
   return useSWR(
     publicClient && sharesAmount && vaultAddress
@@ -32,4 +32,4 @@ export const useGetConvertToAssets = (
       ...options,
     },
   );
-};
+}

package/src/hooks/dex/useAggregatorsQuotes.ts

@@ -183,7 +183,13 @@ export function useAggregatorsQuotes(
       ...args,
       aggregator: bex,
     },
-    { ...swrOptions, isEnabled: bexProtocol.isPaused === false },
+    {
+      ...swrOptions,
+      // Compose with the caller's gate (e.g. same-token suppression from
+      // useSwap) instead of overwriting it — otherwise bex fetches whenever
+      // it's unpaused, regardless of isEnabled (HUB-9FQ).
+      isEnabled: (options?.isEnabled ?? true) && bexProtocol.isPaused === false,
+    },
   );
 
   const wberaSwapResult = raw_useSingleAggregatorQuote({

package/src/hooks/dex/useAggregatorsRouterFeeBps.ts

@@ -7,7 +7,7 @@ import { useSWRImmutable } from "@berachain/utils/pkg/swr";
 
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 
-export const useAggregatorsRouterFeeBps = () => {
+export function useAggregatorsRouterFeeBps() {
   const publicClient = usePublicClient() as PublicClient;
   const { config } = parseBaseArgs({
     chainId: publicClient.chain?.id,
@@ -27,4 +27,4 @@ export const useAggregatorsRouterFeeBps = () => {
       return Number(fee);
     },
   );
-};
+}