@berachain/berajs 0.2.11 → 0.2.13

package/src/actions/pol/getVaultsSupply.ts

@@ -2,6 +2,8 @@ import type { Address, PublicClient } from "viem";
 
 import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
 
+import { assertAddress, assertPublicClient } from "../../errors/assert";
+
 export interface GetVaultsSupply {
   vaultAddress: Address;
   publicClient: PublicClient | undefined;
@@ -11,8 +13,9 @@ export async function getVaultsSupply({
   vaultAddress,
   publicClient,
 }: GetVaultsSupply): Promise<bigint> {
-  if (!publicClient) throw new Error("Missing public client");
-  if (!vaultAddress) throw new Error("Missing vault address");
+  assertPublicClient(publicClient);
+  assertAddress(vaultAddress, "vaultAddress");
+
   try {
     const result = await publicClient.readContract({
       address: vaultAddress,

package/src/actions/server/getDailyValidatorBlockStats.ts

@@ -1,12 +1,11 @@
 import type { Address } from "viem";
 
-import {
-  GetValidatorBlockStats,
-  type GetValidatorBlockStatsQuery,
-  type GetValidatorBlockStatsQueryVariables,
-} from "@berachain/graphql/pol/subgraph";
+import type {
+  BlocksBlockStatsResponse,
+  ValidatorBlockStatsResponse,
+} from "@berachain/graphql/beep";
 
-import { getApolloClient } from "../clients/getApolloClient";
+import { fetchBeep } from "../clients/fetchBeep";
 
 /**
  * Server-only RSC variant. Goes directly to the pol subgraph upstream
@@ -15,19 +14,31 @@ import { getApolloClient } from "../clients/getApolloClient";
 export async function getDailyValidatorBlockStats({
   pubKey,
   first = 1,
-  ...args
 }: BeraJS.BaseFunctionArgs & {
   pubKey: Address;
   first?: number;
-}): Promise<GetValidatorBlockStatsQuery | undefined> {
-  const client = getApolloClient("pol.subgraph", args);
+}): Promise<{
+  validatorBlockStats: ValidatorBlockStatsResponse;
+  blockStats: BlocksBlockStatsResponse;
+}> {
+  const [validatorBlockStats, blockStats] = await Promise.all([
+    fetchBeep("/v0/validators/{pubkey}/block-stats", {
+      path: { pubkey: pubKey },
+      query: {
+        interval: "day",
+        perPage: first.toString(),
+      },
+    }),
+    fetchBeep("/v0/blocks/block-stats", {
+      query: {
+        interval: "day",
+        perPage: first.toString(),
+      },
+    }),
+  ]);
 
-  const result = await client.query<
-    GetValidatorBlockStatsQuery,
-    GetValidatorBlockStatsQueryVariables
-  >({
-    query: GetValidatorBlockStats,
-    variables: { pubKey, first },
-  });
-  return result.data;
+  return {
+    validatorBlockStats: validatorBlockStats,
+    blockStats: blockStats,
+  };
 }

package/src/actions/tokens/getWalletBalances.ts

@@ -70,10 +70,8 @@ export async function getWalletBalances({
   wagmiConfig: config,
 }: GetWalletBalances): Promise<BalanceToken[] | undefined> {
   assertDefined(config, "config");
-  if (!account || !tokenList)
-    throw new Error("account or tokenList is not defined");
-
   assertAddress(account, "account");
+  assertDefined(tokenList, "tokenList");
 
   const filteredTokenList = tokenList.filter((token) =>
     isAddress(token.address),

package/src/actions/transactions/beraWriteContract.integration.test.ts

@@ -1,5 +1,8 @@
 import {
+  type Abi,
   type Address,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
   createWalletClient,
   encodeFunctionData,
   erc20Abi,
@@ -19,7 +22,7 @@ import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
 import { getConfig } from "@berachain/wagmi/config";
 
 import { TransactionActionType } from "../../enum/txnEnum";
-import type { IContractWriteFn } from "../../types/global";
+import type { IContractWrite } from "../../types/global";
 import { getServerSidePublicClient } from "../../utils/getServerSideClient";
 import { getTestClient } from "../../utils/getTestClient";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
@@ -28,9 +31,19 @@ import { testTransports } from "../__test/transports";
 import { getUserVaults } from "../pol/getUserVaults";
 import { beraWriteContract } from "./beraWriteContract";
 
-const testFn: IContractWriteFn = async (_args) => {
+async function testFn<
+  abi extends Abi | undefined = undefined,
+  functionName extends abi extends Abi
+    ? ContractFunctionName<abi>
+    : never = abi extends Abi ? ContractFunctionName<abi> : never,
+  params extends abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never = abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never,
+>(_args: IContractWrite<abi, functionName, params>) {
   return undefined;
-};
+}
 
 describe("beraWriteContract", () => {
   const { config } = parseBaseArgs({ chainId: defaultChain.id });

package/src/actions/transactions/beraWriteContract.ts

@@ -44,9 +44,9 @@ import { seconds } from "../../utils/time";
  */
 const defaultPollingInterval = seconds(1);
 
-const increaseByPercentage = (value: bigint, percentage: number) => {
+function increaseByPercentage(value: bigint, percentage: number) {
   return (value * (100n + BigInt(percentage))) / 100n;
-};
+}
 
 /**
  * This helps prevent IntegerOutOfRangeError by not providing a nonce if it's too large.

package/src/actions/validators/getApiEnrichedAllocation.ts

@@ -24,7 +24,7 @@ export async function getApiEnrichedAllocation({
         percentage: allocation.percentage,
         receiver: allocation.receiver,
         startBlock,
-        receivingVault: vaults?.gaugeList.find((vault) =>
+        receivingVault: vaults?.rewardVaultList.find((vault) =>
           isAddressEqual(vault.address, allocation.receiver),
         ),
       };

package/src/actions/validators/getUserBoostsOnValidator.ts

@@ -2,6 +2,7 @@ import { type Address, formatEther, type PublicClient } from "viem";
 
 import { bgtAbi } from "@berachain/abis/pol/bgt";
 
+import { assertAddress, assertPublicClient } from "../../errors/assert";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 
 export type UserBoostsOnValidator = {
@@ -35,12 +36,8 @@ export async function getUserBoostsOnValidator({
 } & BeraJS.BaseFunctionArgs): Promise<UserBoostsOnValidator> {
   const { config } = parseBaseArgs(args);
 
-  if (!account) {
-    throw new Error("account is required");
-  }
-  if (!publicClient) {
-    throw new Error("publicClient is required");
-  }
+  assertAddress(account, "address");
+  assertPublicClient(publicClient);
 
   const [activeBoostAmount, queuedBoostAmount, queuedDropBoostAmount] =
     await Promise.all([
@@ -48,19 +45,19 @@ export async function getUserBoostsOnValidator({
         address: config.tokens.bgt,
         abi: bgtAbi,
         functionName: "boosted",
-        args: [account!, pubkey!],
+        args: [account, pubkey],
       }),
       publicClient.readContract({
         address: config.tokens.bgt,
         abi: bgtAbi,
         functionName: "boostedQueue",
-        args: [account!, pubkey!],
+        args: [account, pubkey],
       }),
       publicClient.readContract({
         address: config.tokens.bgt,
         abi: bgtAbi,
         functionName: "dropBoostQueue",
-        args: [account!, pubkey!],
+        args: [account, pubkey],
       }),
     ]);
 

package/src/actions/validators/getValidatorAnalytics.ts

@@ -5,7 +5,11 @@ import type { GetValidatorAnalyticsQuery } from "@berachain/graphql/pol/subgraph
 import { BeraError } from "../../errors/BeraError";
 import { beraFetchJson } from "../../utils/beraFetch";
 
-/** Browser-only. Hits `/api/pol/validator-analytics`. */
+/**
+ * Browser-only. Hits `/api/pol/validator-analytics`.
+ *
+ * @deprecated will be removed in pol vNext
+ */
 export async function getValidatorAnalytics({
   pubkey,
   dayRange,

package/src/actions/validators/getValidatorEstimatedBgtPerYear.ts

@@ -2,11 +2,11 @@ import type { ApiValidatorMinimalFragment } from "@berachain/graphql/pol/api";
 
 import { yearsInSeconds } from "../../utils/time";
 
-export const getValidatorEstimatedBgtPerYear = (
+export function getValidatorEstimatedBgtPerYear(
   validator: ApiValidatorMinimalFragment,
   totalStakedBeraAmount: number,
   blockTime: number,
-): number => {
+): number {
   if (!totalStakedBeraAmount || !validator) return 0;
 
   const estimatedBlocksPerYear = yearsInSeconds(1) / blockTime;
@@ -22,4 +22,4 @@ export const getValidatorEstimatedBgtPerYear = (
     estimatedValidatorBlocksPerYear *
     Number.parseFloat(validator.dynamicData?.rewardRate ?? "0")
   );
-};
+}

package/src/actions/validators/getValidatorIncentiveDistribution.ts

@@ -3,12 +3,10 @@ import type { Address } from "viem";
 import type { ValidatorIncentivesResponse } from "@berachain/graphql/beep";
 
 import { BeraError } from "../../errors/BeraError";
-import { beraFetchJson } from "../../utils/beraFetch";
 import { calculateTimestampFromDays } from "../../utils/formatTimestamps";
-import { parseBaseArgs } from "../../utils/parseBaseArgs";
 import { fetchBeep } from "../clients/fetchBeep";
 
-/** Browser-only. Reads from beep when configured, else the subgraph proxy. */
+/** Browser-only. Reads validator incentive distribution from beep. */
 export async function getValidatorIncentiveDistribution({
   pubkey,
   dayRange,
@@ -24,28 +22,8 @@ export async function getValidatorIncentiveDistribution({
     });
   }
 
-  const { config } = parseBaseArgs({});
-
-  // TODO(beep): remove this entire block (and the subgraph proxy route at
-  // `/api/pol/validator-incentive-distribution`) once `beep` is deployed on
-  // every chain. beep then becomes the sole implementation. The route already
-  // maps the subgraph response into beep's `ValidatorIncentivesResponse` shape,
-  // so the client consumes a single (beep) type regardless of source.
-  if (!config.beep) {
-    const params = new URLSearchParams({
-      pubkey,
-      dayRange: String(dayRange),
-    });
-    return beraFetchJson<ValidatorIncentivesResponse>({
-      url: `/api/pol/validator-incentive-distribution?${params}`,
-      name: "pol-validator-incentive-distribution",
-      type: "rest",
-    });
-  }
-
   // beep backend (next-gen). It is a public (`NEXT_PUBLIC_*`) URL, so it can be
-  // called directly from the browser; the subgraph above stays behind the proxy
-  // because it needs server-side auth headers.
+  // called directly from the browser — no Vercel proxy.
   //
   // beep's `after` cursor is in seconds; `calculateTimestampFromDays` returns
   // microseconds, matching the subgraph's `timestamp_gte`. Pin it to the start

package/src/contexts/exports.ts

@@ -7,7 +7,7 @@ export {
   useBeraFlags,
 } from "./BeraFlags/BeraFlags";
 export * from "./BexStatusProvider";
-export * from "./block-time-provider";
+export * from "./BlockTimeProvider";
 export * from "./HoneyConfigProvider";
 export * from "./SwrFallback";
 export * from "./TokensProvider";

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,71 @@
+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");
+  });
+});

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

@@ -40,9 +40,9 @@ export class RequestError extends BeraError {
     "https://open-api.openocean.finance/v4/bera/swap",
     // vercel internal proxy
     "/api/aggregators?aggregator",
-    // bonder endpoints have date-based query params (e.g. ?start=2025-11-28)
-    mainnet.backend,
-    // beep (next-gen backend) on testnet — same date-based bonder query params
+    // beep (next-gen backend) bonder endpoints have date-based query params
+    // (e.g. ?start=2025-11-28) on both networks
+    mainnet.beep,
     bepolia.beep,
   ];
 
@@ -54,6 +54,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 +113,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).
@@ -174,7 +185,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,

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

@@ -53,3 +53,50 @@ describe("RequestError network-error normalization (grouping)", () => {
     expect(err.reason).not.toBe(RequestError.REASON_MAP.NETWORK_ERROR);
   });
 });
+
+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");
+  });
+});