@berachain/berajs 0.2.13 → 0.3.0

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";

package/dist/BeraError-7-A5JYy_.d.ts

@@ -1,123 +0,0 @@
-import { Abi } from 'viem';
-
-/**
- * Severity levels for error reporting.
- * Mirrors Sentry's SeverityLevel for compatibility, but owned by berajs
- * so we don't depend on @sentry/nextjs.
- */
-type SeverityLevel = "fatal" | "error" | "warning" | "log" | "info" | "debug";
-
-/**
- * Span status codes for tracing.
- * Mirrors Sentry's SpanStatusType for compatibility, but owned by berajs
- * so we don't depend on @sentry/nextjs.
- *
- * @see https://develop.sentry.dev/sdk/foundations/transport/event-payloads/span/
- */
-type SpanStatusType = "ok" | "cancelled" | "unknown_error" | "invalid_argument" | "deadline_exceeded" | "not_found" | "already_exists" | "permission_denied" | "resource_exhausted" | "failed_precondition" | "aborted" | "out_of_range" | "unimplemented" | "internal_error" | "unavailable" | "data_loss" | "unauthenticated";
-/**
- * Maps an HTTP status code to a span status.
- */
-declare function httpStatusToSpanStatus(code: number): SpanStatusType;
-/**
- * Maps a BeraError reason code to a span status.
- * Returns undefined if no mapping exists (caller keeps existing spanStatus).
- */
-declare function reasonToSpanStatus(reason: string | null): SpanStatusType | undefined;
-
-interface IBeraErrorArgs {
-    message?: string;
-    displayMessage?: string;
-    cause?: unknown;
-    reason?: string;
-    chainId?: number;
-    fingerprint?: string[];
-    /**
-     * The level of the error to be used for error reporting.
-     */
-    level?: SeverityLevel;
-    tags?: {
-        [key in TagsKey]?: Primitive;
-    };
-    extra?: Record<string, unknown>;
-    /**
-     * Optional ABI to be used to parse the error.
-     */
-    abi?: Abi;
-    /**
-     * Span status for tracing. When set, the tracing adapter uses this to
-     * set the span status instead of a generic "internal_error".
-     * Auto-inferred from `reason` when not explicitly provided.
-     */
-    spanStatus?: SpanStatusType;
-}
-type Primitive = number | string | boolean | bigint | symbol | null | undefined;
-/**
- * An helper type to make sure we only use the allowed tags. Sync this with docs/errors.md
- */
-type TagsKey = "wallet.chain" | "wallet.connector" | "wallet.address" | "error.reason" | "operation.type" | "operation.key" | "operation.txn.functionName" | "operation.txn.to" | "operation.txn.status" | "operation.source.url" | "operation.source.name" | "operation.source.queryName" | "operation.source.type";
-/**
- * Base error class for the entire berajs SDK.
- *
- * All errors should be a BeraError or one of its subclasses. Unknown errors should be
- * normalized via `initBeraError({ cause })`.
- *
- * Key design: the constructor runs an **automatic reason detection pipeline** when `reason`
- * is not explicitly provided. It calls `parseViemError` on the `cause` to extract a
- * machine-readable reason code (e.g. "NotEnoughBalance", "BAL#508", "UserRejectedRequestError").
- * That reason is then matched against `errorMap.ts` to resolve a user-friendly `displayMessage`.
- *
- * This means: for most viem errors, you only need to pass `cause` and everything else
- * (reason, displayMessage, level) is derived automatically.
- *
- * @see parseViemError — the reason extraction engine
- * @see errorMap.ts — reason → displayMessage mapping
- * @see initBeraError — normalizes any error into a BeraError (preferred entry point)
- */
-declare class BeraError extends Error {
-    /**
-     * A human-readable message that can be displayed to end user.
-     *
-     * In berachain dapps, this is shown in the error pop-up.
-     */
-    displayMessage: string;
-    /**
-     * The cause of the error.
-     *
-     * This is typically the error that was thrown.
-     */
-    cause: unknown;
-    /**
-     * The chain id of the error.
-     */
-    chainId?: number;
-    /**
-     * The code for the reason for the error.
-     *
-     * This is typically the error code can be found in the errorMap.ts file. I.e. NotEnoughBalance or BAL#508
-     */
-    reason: string | null;
-    /**
-     * The fingerprint for the error.
-     *
-     * This is typically used to group errors in Sentry.
-     */
-    fingerprint: string[] | undefined;
-    private _tags;
-    set tags(tags: {
-        [key: string | TagsKey]: Primitive;
-    });
-    get tags(): {
-        [key: string | TagsKey]: Primitive;
-    };
-    level: SeverityLevel;
-    /**
-     * Span status for tracing providers.
-     * Auto-inferred from `reason` when not explicitly provided.
-     */
-    spanStatus?: SpanStatusType;
-    extra: Record<string, unknown>;
-    constructor({ message: m, displayMessage: dm, cause, reason, level, abi, tags, chainId, fingerprint, spanStatus, }: IBeraErrorArgs);
-}
-
-export { BeraError as B, type IBeraErrorArgs as I, type SeverityLevel as S, type SpanStatusType as a, httpStatusToSpanStatus as h, reasonToSpanStatus as r };

package/dist/BexStatusProvider-DRymVlQf.d.ts

@@ -1,70 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as react from 'react';
-import { Dispatch, SetStateAction, PropsWithChildren } from 'react';
-import { Hex } from 'viem';
-import { EdgeConfigSchema } from '@berachain/config/internal/edge-config';
-
-type FactoryStatus = {
-    /**
-     * If the composable stable factory is enabled
-     */
-    composableStable: "paused" | "enabled";
-    /**
-     * If the weighted factory is enabled
-     */
-    weighted: "paused" | "enabled";
-};
-interface BexStatusProviderProps {
-    isVaultPaused: boolean;
-    pool?: {
-        id: Hex;
-        isInRecoveryMode: boolean;
-        isPaused: boolean;
-    };
-    factories: FactoryStatus;
-    labels?: NonNullable<EdgeConfigSchema["bex"]>["emergencyLabels"];
-}
-declare const BexStateContext: react.Context<{
-    protocol: {
-        isPaused: boolean;
-        factories: FactoryStatus & {
-            allPaused: boolean;
-        };
-    };
-    onPoolChange: Dispatch<SetStateAction<BexStatusProviderProps["pool"]>>;
-    pool?: {
-        id: Hex;
-        isInRecoveryMode: boolean;
-        isPaused: boolean;
-        disablePoolWithdrawals: boolean;
-        disablePoolDeposits: boolean;
-    };
-    labels?: NonNullable<EdgeConfigSchema["bex"]>["emergencyLabels"];
-}>;
-/**
- * @description Determines the status of a pool or vault and returns the appropriate messages and flags to disable functionality.
- * More information here https://www.notion.so/berachain/BEX-RecoveryMode-and-Pause-explained-17c6120abced80e0985dd589b57ff018
- *
- * @returns status flags to enable/disable/notify users across the BEX
- *
- **/
-declare function useBexStatus(): {
-    protocol: {
-        isPaused: boolean;
-        factories: FactoryStatus & {
-            allPaused: boolean;
-        };
-    };
-    onPoolChange: Dispatch<SetStateAction<BexStatusProviderProps["pool"]>>;
-    pool?: {
-        id: Hex;
-        isInRecoveryMode: boolean;
-        isPaused: boolean;
-        disablePoolWithdrawals: boolean;
-        disablePoolDeposits: boolean;
-    };
-    labels?: NonNullable<EdgeConfigSchema["bex"]>["emergencyLabels"];
-};
-declare function BexStatusProvider({ children, isVaultPaused, labels, factories, }: PropsWithChildren<BexStatusProviderProps>): react_jsx_runtime.JSX.Element;
-
-export { BexStateContext as B, BexStatusProvider as a, type BexStatusProviderProps as b, useBexStatus as u };