@berachain/berajs 0.2.13 → 0.3.1

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