@berachain/berajs 0.2.12 → 0.3.0

package/src/hooks/validators/useValidatorQueuedRewardAllocation.ts

@@ -10,10 +10,10 @@ import type {
   DefaultHookReturnType,
 } from "../../types/global";
 
-export const useValidatorQueuedRewardAllocation = (
+export function useValidatorQueuedRewardAllocation(
   pubKey: Address,
   options?: DefaultHookOptions,
-): DefaultHookReturnType<ValidatorRewardAllocation | undefined> => {
+): DefaultHookReturnType<ValidatorRewardAllocation | undefined> {
   const publicClient = usePublicClient();
   const QUERY_KEY =
     publicClient && pubKey
@@ -32,4 +32,4 @@ export const useValidatorQueuedRewardAllocation = (
       ...options,
     },
   );
-};
+}

package/src/types/bribeBoost.d.ts

@@ -0,0 +1,20 @@
+import type { Address } from "viem";
+
+// Response shape of GET /api/v1/wallets/:wallet/autoclaimed:
+//   { [wallet]: { [validatorPubkey]: { [tokenAddress]: { amount } } } }
+// `amount` is a stringified bigint in token base units. The backend now
+// aggregates across validators under a single fake pubkey (`0x000…000`),
+// so consumers can collapse the validator dimension blindly.
+export type AutoclaimedIncentivesResponse = Record<
+  Address,
+  Record<Address, Record<Address, { amount: string }>>
+>;
+
+// Response shape of GET /api/v1/wallets/:wallet/autoclaimed/txhash: same
+// nesting, but each token leaf is `{ txhash }`. Tokens still pending are
+// simply absent — when a token from `/autoclaimed` has no entry here, the
+// bot hasn't distributed it yet.
+export type AutoclaimedIncentivesTxHashResponse = Record<
+  Address,
+  Record<Address, Record<Address, { txhash: string }>>
+>;

package/src/types/dex.d.ts

@@ -195,6 +195,13 @@ export type Calldata = {
   data?: Hex;
   value: bigint;
   gasLimit?: bigint;
+  /**
+   * Extra Sentry tags to attach when this calldata is submitted via `useTxn`.
+   * Aggregators set `{ aggregator: this.name }` so failures like
+   * AggregatorNotWhitelisted can be attributed to a source without decoding
+   * calldata.
+   */
+  extraTags?: Record<string, string>;
 };
 
 export type IRawAggregatorQuote = {
@@ -208,6 +215,16 @@ export type IRawAggregatorQuote = {
   isNativeSwap?: boolean;
   priceImpactPercentage?: number | null;
   swapFeeBps: number;
+  /** True when the route bridges chains; set by the aggregator (source of truth). */
+  isCrossChain?: boolean;
+  /** Chain the input token (and therefore the tx) lives on. */
+  srcChainId?: number;
+  /**
+   * Bridge the cross-chain route uses, from Enso's chosen bridge hop
+   * (`relay` | `stargate` | `ccip`). Drives which explorer/status API the
+   * tracker uses; undefined for same-chain routes.
+   */
+  bridgeProtocol?: string;
   getCalldata?: ({ account }: { account: Address }) => Calldata;
 };
 

package/src/types/enso.d.ts

@@ -1,26 +1,9 @@
-import type { BundleData, EnsoClient } from "@ensofinance/sdk";
+import type { BundleData } from "@ensofinance/sdk";
 import type { Address, Hex, PublicClient, TransactionRequest } from "viem";
 
 import type { MinimalERC20 } from "./dex";
 
 export type Quantity = string | number;
-export type ActionOutputReference<T> = T | StrictOutputReference<T>;
-type StrictOutputReference<T> = {
-  useOutputOfCallAt: number;
-  index?: number;
-};
-
-export interface GetEnsoSwapBundleArgs {
-  fromAddress: Address;
-  amountIn: Quantity;
-  tokenIn: Address;
-  tokenOut: Address;
-  chainId: number;
-  ensoClient: EnsoClient;
-  slippage: number;
-  destinationChainId?: number;
-  publicClient: PublicClient;
-}
 
 export type GetZapTransaction = TransactionRequest & {
   to: Address;
@@ -29,15 +12,6 @@ export type GetZapTransaction = TransactionRequest & {
   gasLimit?: bigint;
 };
 export type GetZapTransactions = GetZapTransaction[];
-export interface GetZapTransactionsArgs {
-  fromAddress: Address;
-  amountIn: Quantity;
-  tokenIn: Address;
-  chainId: number;
-  ensoClient: EnsoClient;
-  bundle: BundleData;
-  publicClient: PublicClient;
-}
 
 export interface GetEnsoWalletTransactionsWithApprovalArgs {
   fromAddress: Address;

package/src/types/exports.ts

@@ -1,4 +1,4 @@
-export * from "./bribe-boost.d";
+export * from "./bribeBoost.d";
 export * from "./dex.d";
 export * from "./enso.d";
 export * from "./global.d";

package/src/types/global.d.ts

@@ -94,6 +94,13 @@ export type IContractWrite<
    */
   actionType: TransactionActionType;
   txnName?: string;
+  /**
+   * Extra Sentry tags to attach to this transaction's scope, merged under the
+   * `operation.txn.*` namespace (e.g. `{ aggregator: "oogabooga" }` becomes the
+   * `operation.txn.aggregator` tag). Use for context that helps triage failures
+   * without decoding calldata.
+   */
+  extraTags?: Record<string, string>;
   gasLimit?: bigint;
   account?: Account | Address;
   /**

package/src/types/pol.d.ts

@@ -1,49 +1,4 @@
-import type { Address } from "viem";
-
-import type { ApiValidatorFragment } from "@berachain/graphql/pol/api";
-
-import type { Token, TokenWithMetadata } from "./dex";
-
-export type IncentiveReward = {
-  tokenMetadata: Token | undefined;
-  tokenPrice: number;
-  tokenValue: number;
-  id: string;
-  dist_id: string;
-  token: string;
-  recipient: string;
-  formattedAmount: string;
-  amount: string;
-  merkle_proof: string[];
-  available_at: number;
-};
-export interface IncentiveRewardChunksWithValidatorData {
-  validator: ApiValidatorInListFragment | ApiValidatorFragment | undefined;
-  maxTimestamp: number | undefined;
-  minTimestamp: number | undefined;
-  totalValue: number;
-  tokenTotals: {
-    chainId: number;
-    address: Address;
-    amount: number;
-    value: number;
-    metadata: Token | undefined;
-  }[];
-  rewards: IncentiveReward[];
-  isCurrent: boolean;
-}
-
-export interface AggregatedTokenTotals {
-  address: Address;
-  amount: number;
-  value: number;
-  metadata: Token | undefined;
-  chainId: number;
-}
-
-export type ClaimedIncentives = Record<string, string>;
-
-export type ClaimedIncentivesLocalState = Record<string, ClaimedIncentives>;
+import type { TokenWithMetadata } from "./dex";
 
 export interface UserVaultInfo {
   balance: bigint;
@@ -56,11 +11,11 @@ export interface UserVaultInfo {
 export type StakedBeraAsset = {
   token: TokenWithMetadata;
   /**
-   * Staking APR, or `undefined` when unavailable (e.g. the APR backend is
+   * Staking APY, or `undefined` when unavailable (e.g. the APY backend is
    * down). `undefined` lets the UI render a "—" placeholder instead of a
    * misleading "0%".
    */
-  apr: number | undefined;
+  apy: number | undefined;
   stakedAmount: number;
   /**
    * USD value of the staked amount, or `undefined` when the token price is

package/src/utils/crossChainBridge.ts

@@ -0,0 +1,290 @@
+import { fetchLayerzero } from "../actions/clients/fetchLayerzero";
+import { BeraError } from "../errors/BeraError";
+import { InvalidArgumentError } from "../errors/InvalidArgumentError";
+import { RequestError } from "../errors/RequestError";
+import { beraFetchJson } from "./beraFetch";
+
+// Enso routes cross-chain zaps over one of these bridges (from the "bridge"
+// hop's `protocol` in its route response). Each has its own status API +
+// explorer, so tracking has to branch on the bridge.
+export type BridgeProtocol = "relay" | "stargate" | "ccip" | "layerzero";
+
+const RELAY_API_URL = "https://api.relay.link";
+
+// Public explorer origins for deep-linking a bridged tx. See getBridgeExplorerUrl.
+const LAYERZERO_SCAN_EXPLORER = "https://layerzeroscan.com";
+const RELAY_EXPLORER = "https://relay.link";
+
+export enum BridgeMessageStatus {
+  INFLIGHT = "INFLIGHT",
+  DELIVERED = "DELIVERED",
+  FAILED = "FAILED",
+}
+
+export type BridgeMessage = {
+  srcTxHash?: string;
+  dstTxHash?: string;
+  status: BridgeMessageStatus;
+  statusMessage?: string;
+  /**
+   * Bridge-specific id for deep-linking the explorer, when the explorer keys
+   * on something other than the source tx hash (Relay uses its requestId).
+   */
+  explorerId?: string;
+};
+
+export type BridgeDeliveredMessage = BridgeMessage & {
+  dstTxHash: string;
+};
+
+// --- LayerZero / Stargate ---------------------------------------------------
+
+async function getLayerZeroMessage(srcTxHash: string): Promise<BridgeMessage> {
+  const { data } = await fetchLayerzero("/messages/tx/{tx}", {
+    path: { tx: srcTxHash },
+  });
+
+  const message = data[0];
+  if (!message) {
+    // not indexed yet — keep polling
+    return { srcTxHash, status: BridgeMessageStatus.INFLIGHT };
+  }
+
+  return {
+    srcTxHash: message.source?.tx?.txHash,
+    // the destination union has several shapes; only the plain-delivery one
+    // carries `tx.txHash`, so narrow before reading it.
+    dstTxHash:
+      message.destination && "tx" in message.destination
+        ? message.destination.tx?.txHash
+        : undefined,
+    statusMessage: message.status?.message,
+    // v1 exposes many transient states; anything not DELIVERED/FAILED means
+    // "keep polling", so collapse unknown names to INFLIGHT.
+    status:
+      message.status?.name === "DELIVERED"
+        ? BridgeMessageStatus.DELIVERED
+        : message.status?.name === "FAILED"
+          ? BridgeMessageStatus.FAILED
+          : BridgeMessageStatus.INFLIGHT,
+  };
+}
+
+// --- Relay ------------------------------------------------------------------
+
+// Relay has no OpenAPI schema/client yet (unlike LayerZero's fetchLayerzero),
+// so this stays hand-rolled over beraFetchJson with a local response type.
+// Raw shape of the Relay requests API (only the fields we consume).
+type RelayRequestsResponse = {
+  requests: {
+    id: string;
+    status: string;
+    data?: {
+      failReason?: string;
+      outTxs?: { hash?: string }[];
+    };
+  }[];
+};
+
+async function getRelayMessage(srcTxHash: string): Promise<BridgeMessage> {
+  const { requests } = await beraFetchJson<RelayRequestsResponse>({
+    url: `${RELAY_API_URL}/requests/v2?hash=${srcTxHash}`,
+    type: "rest",
+    name: "Relay",
+  });
+
+  const request = requests[0];
+  if (!request) {
+    // not indexed yet — keep polling
+    return { srcTxHash, status: BridgeMessageStatus.INFLIGHT };
+  }
+
+  return {
+    srcTxHash,
+    dstTxHash: request.data?.outTxs?.[0]?.hash,
+    statusMessage: request.data?.failReason,
+    // Relay's explorer keys on the requestId, not the source tx hash.
+    explorerId: request.id,
+    status:
+      request.status === "success"
+        ? BridgeMessageStatus.DELIVERED
+        : request.status === "failure" || request.status === "refund"
+          ? BridgeMessageStatus.FAILED
+          : BridgeMessageStatus.INFLIGHT,
+  };
+}
+
+// --- Unified poller ---------------------------------------------------------
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getBridgeMessage(
+  bridgeProtocol: string,
+  srcTxHash: string,
+): Promise<BridgeMessage> {
+  switch (bridgeProtocol) {
+    case "relay":
+      return getRelayMessage(srcTxHash);
+    // Enso's "stargate" is LayerZero's Stargate; both track on LayerZero Scan.
+    case "stargate":
+    case "layerzero":
+      return getLayerZeroMessage(srcTxHash);
+    default:
+      // ccip and anything else aren't tracked (ccip is excluded at routing time
+      // via `ignoreBridges` in ensoErc4626) — reject so the caller can decide
+      // (the tracker treats this as "can't poll", not "failed").
+      throw new InvalidArgumentError({
+        property: "bridgeProtocol",
+        value: bridgeProtocol,
+        expected: "relay | stargate | layerzero",
+      });
+  }
+}
+
+export interface BridgeExplorerUrlArgs {
+  /** Bridge Enso routed through; picks which explorer to link. */
+  bridgeProtocol?: string;
+  /** Source-chain tx hash — how LayerZero/Stargate + the fallback key. */
+  srcTxHash?: string;
+  /**
+   * Relay's requestId, when known. Relay's explorer prefers it but also resolves
+   * on the src tx hash, so a missing id still links to the bridge explorer.
+   */
+  explorerId?: string;
+  /**
+   * Source-chain block explorer origin (e.g. https://etherscan.io). Only a
+   * last resort for an unknown/untracked bridge; tracked bridges always link to
+   * their own bridge explorer (which shows the src→dst delivery still in flight).
+   */
+  fallbackExplorerUrl: string;
+}
+
+/**
+ * Deep-link a bridged tx to the right *bridge* explorer — the one showing the
+ * source→destination delivery, which is what's still in flight once a tracker is
+ * visible (the source tx already confirmed). Enso picks the bridge per-route, so
+ * a single hardcoded explorer is wrong for the others; each keys differently
+ * (LayerZero/Stargate on the src tx hash, Relay on its requestId or the src tx
+ * hash). Only a genuinely unknown protocol falls back to the source chain's own
+ * block explorer.
+ *
+ * We deliberately don't route this through Enso's `getBridgeStatus`
+ * (`/{protocol}/bridge/check`): it normalizes status but doesn't return Relay's
+ * requestId, which the Relay deep link prefers — so we'd still branch per bridge.
+ */
+export function getBridgeExplorerUrl({
+  bridgeProtocol,
+  srcTxHash,
+  explorerId,
+  fallbackExplorerUrl,
+}: BridgeExplorerUrlArgs): string | undefined {
+  switch (bridgeProtocol) {
+    case "relay":
+      // Relay's explorer resolves on either the requestId or the src tx hash,
+      // so stay on the bridge explorer even before we've fetched the id.
+      return srcTxHash || explorerId
+        ? `${RELAY_EXPLORER}/transaction/${explorerId ?? srcTxHash}`
+        : undefined;
+    case "stargate":
+    case "layerzero":
+      return srcTxHash
+        ? `${LAYERZERO_SCAN_EXPLORER}/tx/${srcTxHash}`
+        : undefined;
+    default:
+      // Unknown/untracked bridge (shouldn't surface — ccip is routed out and the
+      // tracker needs a known protocol to poll): no bridge explorer exists, so
+      // the source chain's block explorer is the only link we can build.
+      return srcTxHash ? `${fallbackExplorerUrl}/tx/${srcTxHash}` : undefined;
+  }
+}
+
+/**
+ * One-shot status lookup for a bridged tx. Used to grab the explorer id (e.g.
+ * Relay's requestId) for the pending-state link before delivery. Swallows
+ * errors into an INFLIGHT result so a not-yet-indexed tx doesn't throw.
+ */
+export async function getBridgeMessageOnce(
+  bridgeProtocol: string,
+  srcTxHash: string,
+): Promise<BridgeMessage> {
+  try {
+    return await getBridgeMessage(bridgeProtocol, srcTxHash);
+  } catch {
+    return { srcTxHash, status: BridgeMessageStatus.INFLIGHT };
+  }
+}
+
+export type WaitForMessageReceivedOptions = {
+  /** Which bridge Enso routed through; narrowed at getBridgeMessage's switch. */
+  bridgeProtocol: string;
+  /** Polling interval in ms (default: 3000). */
+  pollInterval?: number;
+  /** Timeout in ms (default: 600000 / 10 minutes). */
+  timeout?: number;
+};
+
+/**
+ * Polls the bridge's status API until the cross-chain message is delivered or
+ * fails, then resolves with the delivered message (incl. destination tx hash).
+ * HTTP errors are silently retried until timeout. Throws InvalidArgumentError
+ * if srcTxHash/bridgeProtocol is missing or unsupported, or BeraError if the
+ * message fails or times out.
+ */
+export async function waitForBridgeMessageReceived(
+  srcTxHash: string,
+  options: WaitForMessageReceivedOptions,
+): Promise<BridgeDeliveredMessage> {
+  const { bridgeProtocol, pollInterval = 3000, timeout = 600_000 } = options;
+
+  if (!srcTxHash) {
+    throw new InvalidArgumentError({
+      property: "srcTxHash",
+      value: srcTxHash,
+      expected: "string",
+    });
+  }
+
+  const startTime = Date.now();
+
+  while (true) {
+    if (Date.now() - startTime > timeout) {
+      throw new BeraError({
+        message: `Bridge message tracking timed out after ${timeout}ms`,
+        reason: "BRIDGE_TIMEOUT",
+        level: "warning",
+      });
+    }
+
+    try {
+      const message = await getBridgeMessage(bridgeProtocol, srcTxHash);
+
+      if (message.status === BridgeMessageStatus.FAILED) {
+        throw new BeraError({
+          message: `Bridge message failed: ${message.statusMessage}`,
+          reason: "BRIDGE_MESSAGE_FAILED",
+        });
+      }
+
+      // Only resolve once we actually have the destination tx hash the type
+      // promises. A DELIVERED status without one (e.g. LZ's destination union
+      // lacking `tx`) means the dst tx isn't indexed yet — keep polling rather
+      // than cast a message with `dstTxHash: undefined`.
+      if (
+        message.status === BridgeMessageStatus.DELIVERED &&
+        message.dstTxHash
+      ) {
+        return message as BridgeDeliveredMessage;
+      }
+    } catch (error) {
+      // re-throw non-retryable errors (validation, failed message) but allow
+      // RequestError to retry (network issues, temporary API errors)
+      if (error instanceof BeraError && !(error instanceof RequestError)) {
+        throw error;
+      }
+    }
+
+    await sleep(pollInterval);
+  }
+}

package/src/utils/crossChainBridge.unit.test.ts

@@ -0,0 +1,177 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  BridgeMessageStatus,
+  getBridgeExplorerUrl,
+  getBridgeMessageOnce,
+} from "./crossChainBridge";
+
+const mockFetchLayerzero = vi.fn();
+const mockBeraFetchJson = vi.fn();
+
+vi.mock("../actions/clients/fetchLayerzero", () => ({
+  fetchLayerzero: (...args: unknown[]) => mockFetchLayerzero(...args),
+}));
+vi.mock("./beraFetch", () => ({
+  beraFetchJson: (...args: unknown[]) => mockBeraFetchJson(...args),
+}));
+
+const TX = "0xabc";
+const SRC = "0xsrc";
+const DST = "0xdst";
+const FALLBACK = "https://etherscan.io";
+
+describe("getBridgeExplorerUrl", () => {
+  it("links LayerZero/Stargate to LZ Scan by src tx hash", () => {
+    for (const bridgeProtocol of ["layerzero", "stargate"]) {
+      expect(
+        getBridgeExplorerUrl({
+          bridgeProtocol,
+          srcTxHash: TX,
+          fallbackExplorerUrl: FALLBACK,
+        }),
+      ).toBe(`https://layerzeroscan.com/tx/${TX}`);
+    }
+  });
+
+  it("links Relay to relay.link by explorerId (requestId)", () => {
+    expect(
+      getBridgeExplorerUrl({
+        bridgeProtocol: "relay",
+        srcTxHash: TX,
+        explorerId: "req-1",
+        fallbackExplorerUrl: FALLBACK,
+      }),
+    ).toBe("https://relay.link/transaction/req-1");
+  });
+
+  it("keeps Relay on its explorer via src tx hash when no explorerId yet", () => {
+    expect(
+      getBridgeExplorerUrl({
+        bridgeProtocol: "relay",
+        srcTxHash: TX,
+        fallbackExplorerUrl: FALLBACK,
+      }),
+    ).toBe(`https://relay.link/transaction/${TX}`);
+  });
+
+  it("falls back to the src chain for untracked/unknown bridges", () => {
+    expect(
+      getBridgeExplorerUrl({
+        bridgeProtocol: "ccip",
+        srcTxHash: TX,
+        fallbackExplorerUrl: FALLBACK,
+      }),
+    ).toBe(`${FALLBACK}/tx/${TX}`);
+    expect(
+      getBridgeExplorerUrl({
+        srcTxHash: TX,
+        fallbackExplorerUrl: FALLBACK,
+      }),
+    ).toBe(`${FALLBACK}/tx/${TX}`);
+  });
+
+  it("returns undefined when there's no tx hash to key on", () => {
+    expect(
+      getBridgeExplorerUrl({
+        bridgeProtocol: "layerzero",
+        fallbackExplorerUrl: FALLBACK,
+      }),
+    ).toBeUndefined();
+  });
+});
+
+// Parser tests: feed representative API JSON (shapes captured from the live
+// LayerZero Scan + Relay APIs) through the mappers via getBridgeMessageOnce,
+// which dispatches by protocol. Guards against the response shape / status
+// vocabulary drifting away from what the mappers expect.
+describe("getBridgeMessageOnce parsers", () => {
+  beforeEach(() => {
+    mockFetchLayerzero.mockReset();
+    mockBeraFetchJson.mockReset();
+  });
+
+  describe("LayerZero / Stargate", () => {
+    it("maps a delivered message with its destination tx hash", async () => {
+      mockFetchLayerzero.mockResolvedValue({
+        data: [
+          {
+            source: { tx: { txHash: SRC } },
+            destination: { tx: { txHash: DST } },
+            status: { name: "DELIVERED" },
+          },
+        ],
+      });
+      const msg = await getBridgeMessageOnce("layerzero", SRC);
+      expect(msg.status).toBe(BridgeMessageStatus.DELIVERED);
+      expect(msg.dstTxHash).toBe(DST);
+    });
+
+    it("maps FAILED and carries the status message", async () => {
+      mockFetchLayerzero.mockResolvedValue({
+        data: [{ status: { name: "FAILED", message: "revert reason" } }],
+      });
+      const msg = await getBridgeMessageOnce("stargate", SRC);
+      expect(msg.status).toBe(BridgeMessageStatus.FAILED);
+      expect(msg.statusMessage).toBe("revert reason");
+    });
+
+    it("collapses transient states (e.g. CONFIRMING) to INFLIGHT", async () => {
+      mockFetchLayerzero.mockResolvedValue({
+        data: [{ status: { name: "CONFIRMING" } }],
+      });
+      const msg = await getBridgeMessageOnce("layerzero", SRC);
+      expect(msg.status).toBe(BridgeMessageStatus.INFLIGHT);
+    });
+
+    it("treats a not-yet-indexed (empty) response as INFLIGHT", async () => {
+      mockFetchLayerzero.mockResolvedValue({ data: [] });
+      const msg = await getBridgeMessageOnce("layerzero", SRC);
+      expect(msg.status).toBe(BridgeMessageStatus.INFLIGHT);
+    });
+  });
+
+  describe("Relay", () => {
+    it("maps success -> DELIVERED with requestId + dst tx hash", async () => {
+      mockBeraFetchJson.mockResolvedValue({
+        requests: [
+          { id: "req-1", status: "success", data: { outTxs: [{ hash: DST }] } },
+        ],
+      });
+      const msg = await getBridgeMessageOnce("relay", SRC);
+      expect(msg.status).toBe(BridgeMessageStatus.DELIVERED);
+      expect(msg.dstTxHash).toBe(DST);
+      expect(msg.explorerId).toBe("req-1");
+    });
+
+    it("maps failure and refund -> FAILED", async () => {
+      for (const status of ["failure", "refund"]) {
+        mockBeraFetchJson.mockResolvedValue({
+          requests: [{ id: "r", status, data: { failReason: "boom" } }],
+        });
+        const msg = await getBridgeMessageOnce("relay", SRC);
+        expect(msg.status).toBe(BridgeMessageStatus.FAILED);
+        expect(msg.statusMessage).toBe("boom");
+      }
+    });
+
+    it("treats pending / unknown status as INFLIGHT", async () => {
+      mockBeraFetchJson.mockResolvedValue({
+        requests: [{ id: "r", status: "pending", data: {} }],
+      });
+      const msg = await getBridgeMessageOnce("relay", SRC);
+      expect(msg.status).toBe(BridgeMessageStatus.INFLIGHT);
+    });
+
+    it("treats a not-yet-indexed (empty) response as INFLIGHT", async () => {
+      mockBeraFetchJson.mockResolvedValue({ requests: [] });
+      const msg = await getBridgeMessageOnce("relay", SRC);
+      expect(msg.status).toBe(BridgeMessageStatus.INFLIGHT);
+    });
+  });
+
+  it("swallows an unsupported bridge into INFLIGHT (never throws)", async () => {
+    const msg = await getBridgeMessageOnce("ccip", SRC);
+    expect(msg.status).toBe(BridgeMessageStatus.INFLIGHT);
+  });
+});

package/src/utils/exports.ts

@@ -1,6 +1,7 @@
 export { defaultFlags as defaultBeraFlags } from "../contexts/BeraFlags/defaultFlags";
 export * from "./beraFetch";
 export * from "./constants";
+export * from "./crossChainBridge";
 export * from "./formatInputTokenValue";
 export * from "./formatNumber";
 export * from "./formatTimestamps";
@@ -11,7 +12,6 @@ export * from "./getServerSideClient";
 export { getTestClient } from "./getTestClient";
 export * from "./isDifferenceExceedingThreshold";
 export * from "./isSubgraphStale";
-export * from "./layerZeroScan";
 export * from "./math";
 export * from "./parseBaseArgs";
 export * from "./parseWhiskToken";