@berachain/berajs 0.2.12 → 0.3.0

package/src/actions/clients/fetchEnso.ts

@@ -0,0 +1,48 @@
+import { appConfig } from "@berachain/config/internal";
+
+import type { paths } from "@berachain/graphql/enso";
+
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import {
+  type DefinedParams,
+  fetchOpenApi,
+  type GetPath,
+  type GetResponse,
+} from "./fetchOpenApi";
+
+const isProduction =
+  process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test";
+
+/** Enso's public API origin. Schema paths already carry the `/api/v1` prefix. */
+const ENSO_API_ORIGIN = "https://api.enso.build";
+
+/**
+ * Typed GET against the Enso API.
+ *
+ * The `path`, its path/query params and the response are all type-checked
+ * against the Enso schema (`@berachain/graphql/enso`). Base URL and auth mirror
+ * {@link getEnsoClient}: in production requests go through the aggregators proxy
+ * (which injects Enso auth), and in dev/test they hit Enso directly with the
+ * public API key.
+ *
+ * Enso covers relay/bridge-check routes today, but callers should treat this as
+ * "the Enso implementation" of those flows — if we later relay such txns
+ * without Enso, swap the helper at the call site rather than generalizing this.
+ */
+export function fetchEnso<P extends GetPath<paths>>(
+  path: P,
+  params: DefinedParams<paths, P>,
+  args: BeraJS.BaseFunctionArgs = {},
+): Promise<GetResponse<paths, P>> {
+  const { config } = parseBaseArgs(args);
+
+  // Proxy in prod (auth handled by the proxy); direct + public key otherwise.
+  const origin = isProduction
+    ? `${config.bex.aggregatorsProxyUrl}/enso`
+    : ENSO_API_ORIGIN;
+  const headers = isProduction
+    ? undefined
+    : { Authorization: `Bearer ${appConfig.apiKeys.public.enso}` };
+
+  return fetchOpenApi<paths, P>(origin, path, params, "enso", headers);
+}

package/src/actions/clients/fetchLayerzero.ts

@@ -0,0 +1,34 @@
+import type { paths } from "@berachain/graphql/layerzero";
+
+import {
+  type DefinedParams,
+  fetchOpenApi,
+  type GetPath,
+  type GetResponse,
+} from "./fetchOpenApi";
+
+/**
+ * LayerZero Scan API origin. Schema paths are relative to this base (e.g.
+ * `/messages/tx/{tx}`).
+ */
+const LAYERZERO_SCAN_ORIGIN = "https://scan.layerzero-api.com/v1";
+
+/**
+ * Typed GET against the LayerZero Scan API.
+ *
+ * The `path`, its path/query params and the response are all type-checked
+ * against the LayerZero schema (`@berachain/graphql/layerzero`). The Scan API is
+ * public (no auth), so requests hit it directly — no proxy split like
+ * {@link fetchEnso}.
+ */
+export function fetchLayerzero<P extends GetPath<paths>>(
+  path: P,
+  params: DefinedParams<paths, P>,
+): Promise<GetResponse<paths, P>> {
+  return fetchOpenApi<paths, P>(
+    LAYERZERO_SCAN_ORIGIN,
+    path,
+    params,
+    "layerzero",
+  );
+}

package/src/actions/clients/fetchOpenApi.ts

@@ -55,13 +55,17 @@ export type DefinedParams<Paths extends AnyPaths, P extends GetPath<Paths>> = {
  * @param path    An OpenAPI path template, e.g. `/v0/stake/{vault}/stats-by-day`.
  * @param params  Path and query params, typed from the schema for `path`.
  * @param fallbackName  Monitoring name to use when `link` is a bare string.
+ * @param headers  Request headers. Kept minimal by default — extra headers
+ *                 (e.g. `X-Client-Id`, which only beep needs) trigger a CORS
+ *                 preflight that third-party gateways like Enso reject.
  */
-// biome-ignore lint/complexity/useMaxParams: internal helper; the wrapper (fetchBeep) is the public surface.
+// biome-ignore lint/complexity/useMaxParams: internal helper; the wrappers (fetchBeep, fetchEnso) are the public surface.
 export function fetchOpenApi<Paths extends AnyPaths, P extends GetPath<Paths>>(
   link: HttpLink,
   path: P,
   params: DefinedParams<Paths, P>,
   fallbackName: string,
+  headers?: Record<string, string>,
 ): Promise<GetResponse<Paths, P>> {
   const { path: pathParams, query } = params as {
     path?: Record<string, string | number>;
@@ -93,5 +97,8 @@ export function fetchOpenApi<Paths extends AnyPaths, P extends GetPath<Paths>>(
   const url = `${getUriFromLink(link)}${resolvedPath}${search ? `?${search}` : ""}`;
   const name = typeof link === "string" ? fallbackName : link.name;
 
-  return beraFetchJson<GetResponse<Paths, P>>({ url, name, type: "rest" });
+  return beraFetchJson<GetResponse<Paths, P>>(
+    { url, name, type: "rest" },
+    { headers },
+  );
 }

package/src/actions/clients/fetchOpenApi.unit.test.ts

@@ -18,9 +18,15 @@ import type {
   ValidatorsResponse,
 } from "@berachain/graphql/beep";
 
+import { getClientName } from "./clientName";
 import { fetchBeep } from "./fetchBeep";
 import { fetchOpenApi } from "./fetchOpenApi";
 
+// fetchBeep is the only wrapper that sends X-Client-Id; the bare fetchOpenApi
+// helper forwards nothing so third-party gateways (Enso) skip a CORS preflight.
+const CLIENT_HEADERS = { headers: { "X-Client-Id": getClientName() } };
+const NO_HEADERS = { headers: undefined };
+
 // Mock the network layer so we can assert exactly what the helpers build and
 // pass through, without hitting a backend.
 const beraFetchJson = vi.fn();
@@ -49,11 +55,14 @@ describe("fetchOpenApi", () => {
     );
 
     expect(beraFetchJson).toHaveBeenCalledTimes(1);
-    expect(beraFetchJson).toHaveBeenCalledWith({
-      url: `${BASE}/v0/stake/${VAULT}/stats-by-day?days=30`,
-      name: "Berachain Beep",
-      type: "rest",
-    });
+    expect(beraFetchJson).toHaveBeenCalledWith(
+      {
+        url: `${BASE}/v0/stake/${VAULT}/stats-by-day?days=30`,
+        name: "Berachain Beep",
+        type: "rest",
+      },
+      NO_HEADERS,
+    );
   });
 
   it("substitutes multiple path params and omits the query when absent", async () => {
@@ -64,11 +73,14 @@ describe("fetchOpenApi", () => {
       "beep",
     );
 
-    expect(beraFetchJson).toHaveBeenCalledWith({
-      url: `${BASE}/v0/stake/${VAULT}/earnings/${OWNER}`,
-      name: "Berachain Beep",
-      type: "rest",
-    });
+    expect(beraFetchJson).toHaveBeenCalledWith(
+      {
+        url: `${BASE}/v0/stake/${VAULT}/earnings/${OWNER}`,
+        name: "Berachain Beep",
+        type: "rest",
+      },
+      NO_HEADERS,
+    );
   });
 
   it("omits query params whose value is undefined", async () => {
@@ -85,6 +97,7 @@ describe("fetchOpenApi", () => {
       expect.objectContaining({
         url: `${BASE}/v0/honey/transactions/latest?perPage=10`,
       }),
+      NO_HEADERS,
     );
   });
 
@@ -101,6 +114,7 @@ describe("fetchOpenApi", () => {
       expect.objectContaining({
         url: `${BASE}/v0/validators/a%2Fb%20c/incentives`,
       }),
+      NO_HEADERS,
     );
   });
 
@@ -114,6 +128,7 @@ describe("fetchOpenApi", () => {
 
     expect(beraFetchJson).toHaveBeenCalledWith(
       expect.objectContaining({ name: "beep" }),
+      NO_HEADERS,
     );
   });
 
@@ -166,6 +181,7 @@ describe("fetchBeep", () => {
         name: "Berachain Beep",
         type: "rest",
       }),
+      CLIENT_HEADERS,
     );
   });
 });
@@ -175,7 +191,7 @@ describe("fetchBeep", () => {
 // purely compile-time.
 describe("fetchBeep types", () => {
   it("infers the response type per path", () => {
-    const _assert = () => {
+    function _assert() {
       expectTypeOf(
         fetchBeep("/v0/stake/{vault}/stats-by-day", {
           path: { vault: VAULT },
@@ -192,37 +208,37 @@ describe("fetchBeep types", () => {
       expectTypeOf(
         fetchBeep("/v0/validators", {}),
       ).resolves.toEqualTypeOf<ValidatorsResponse>();
-    };
+    }
     assert.ok(_assert);
   });
 
   it("rejects unknown paths", () => {
-    const _assert = () => {
-      // @ts-expect-error — not a path in the beep schema.
+    function _assert() {
+      // @ts-expect-error — `/v0/not/a/real/path` is not a known path.
       fetchBeep("/v0/not/a/real/path", { path: {} });
-    };
+    }
     assert.ok(_assert);
   });
 
   it("rejects unknown path params", () => {
-    const _assert = () => {
+    function _assert() {
       fetchBeep("/v0/stake/{vault}/stats-by-day", {
         // @ts-expect-error — `owner` is not a param of stats-by-day.
         path: { vault: VAULT, owner: OWNER },
         query: { days: "30" },
       });
-    };
+    }
     assert.ok(_assert);
   });
 
   it("constrains query values to the schema enum", () => {
-    const _assert = () => {
+    function _assert() {
       fetchBeep("/v0/stake/{vault}/stats-by-day", {
         path: { vault: VAULT },
         // @ts-expect-error — `7` is not an allowed `days` value.
         query: { days: "7" },
       });
-    };
+    }
 
     assert.ok(_assert);
   });

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();
+  });
+});