@berachain/berajs 0.2.13 → 0.3.1

package/src/hooks/validators/useUserActiveValidators.ts

@@ -1,8 +1,12 @@
+import { useMemo } from "react";
+
 import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
 import {
-  getUserActiveValidators,
+  getUserActiveValidatorsApi,
+  getUserActiveValidatorsOnChain,
+  mergeUserActiveValidators,
   type ValidatorWithUserBoost,
 } from "../../actions/validators/getUserActiveValidators";
 import { POLLING } from "../../enum/polling";
@@ -12,23 +16,42 @@ import type {
 } from "../../types/global";
 
 interface UseUserActiveValidatorsResponse
-  extends DefaultHookReturnType<ValidatorWithUserBoost[] | undefined> {}
+  extends DefaultHookReturnType<ValidatorWithUserBoost[] | undefined> {
+  /**
+   * Re-reads the on-chain boost amounts without re-fetching the API validator
+   * list. Use after a boost/drop tx to reflect new amounts immediately.
+   */
+  refreshOnChain: () => void;
+}
 
 export function useUserActiveValidators(
   options?: DefaultHookOptions,
 ): UseUserActiveValidatorsResponse {
   const { address: account } = useBeraWallet();
   const publicClient = usePublicClient();
-  const QUERY_KEY =
-    publicClient && account
-      ? (["useUserActiveValidators", account] as const)
-      : null;
 
-  return useSWR(
-    QUERY_KEY,
+  const apiSwr = useSWR(
+    account ? (["useUserActiveValidatorsApi", account] as const) : null,
     async ([, account]) => {
-      return await getUserActiveValidators({
+      return await getUserActiveValidatorsApi({ account });
+    },
+    {
+      ...options,
+      refreshInterval: options?.refreshInterval ?? POLLING.SLOW,
+      keepPreviousData: true,
+    },
+  );
+
+  const validators = apiSwr.data;
+
+  const onChainSwr = useSWR(
+    publicClient && account && validators
+      ? (["useUserActiveValidatorsOnChain", account, validators] as const)
+      : null,
+    async ([, account, validators]) => {
+      return await getUserActiveValidatorsOnChain({
         account,
+        validators,
         publicClient,
       });
     },
@@ -38,4 +61,26 @@ export function useUserActiveValidators(
       keepPreviousData: true,
     },
   );
+
+  const onChainBoosts = onChainSwr.data;
+
+  const data = useMemo(() => {
+    if (!validators || !onChainBoosts) return undefined;
+    return mergeUserActiveValidators({ validators, onChainBoosts });
+  }, [validators, onChainBoosts]);
+
+  return {
+    ...apiSwr,
+    data,
+    isLoading: apiSwr.isLoading || onChainSwr.isLoading,
+    isValidating: apiSwr.isValidating || onChainSwr.isValidating,
+    error: apiSwr.error ?? onChainSwr.error,
+    refresh: () => {
+      apiSwr.refresh();
+      onChainSwr.refresh();
+    },
+    refreshOnChain: () => {
+      onChainSwr.refresh();
+    },
+  };
 }

package/src/hooks/validators/useValidatorIncentiveDistribution.ts

@@ -1,17 +1,16 @@
 import type { Address } from "viem";
 
-import type { ValidatorIncentivesResponse } from "@berachain/graphql/beep";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
 import { getValidatorIncentiveDistribution } from "../../actions/validators/getValidatorIncentiveDistribution";
 import { POLLING } from "../../enum/polling";
+import type { ValidatorIncentivesResponse } from "../../generated/beep";
 import type { DefaultHookReturnType } from "../../types/global";
 
 /**
- * Historical per-validator incentive distribution. Split from
- * `useValidatorAnalytics` so the IncentivesEarned chart can switch data
- * sources independently of the other charts that still consume the umbrella
- * `GetValidatorAnalytics` query.
+ * Historical per-validator incentive distribution, powering the
+ * IncentivesEarned chart. Owns its own data source so it can be swapped
+ * independently.
  */
 export function useValidatorIncentiveDistribution({
   pubkey,

package/src/types/beep/exports.ts

@@ -0,0 +1,4 @@
+// Type-only OpenAPI beep types, re-exported for hub/honey via
+// `@berachain/berajs/types/beep`. The source is generated at prebuild
+// (`codegen:api`, skipped on Vercel) into src/generated/beep.ts.
+export type * from "../../generated/beep";

package/src/types/bribeBoost.d.ts

@@ -1,37 +1,5 @@
 import type { Address } from "viem";
 
-export interface BribeBoostReward {
-  token: string;
-  total_unclaimed: string;
-}
-
-export interface BribeBoostRewardItem {
-  rewards: BribeBoostReward[];
-  validator: string;
-}
-
-export interface BribeBoostRewardProof {
-  validator?: string;
-  pagination: {
-    next: number;
-    previous: number;
-    record_per_page: number;
-    current_page: number;
-    total_page: number;
-  };
-  rewards:
-    | {
-        id: string;
-        dist_id: string;
-        token: Address;
-        recipient: string;
-        amount: string;
-        merkle_proof: string[];
-        available_at: number;
-      }[]
-    | null;
-}
-
 // 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
@@ -50,20 +18,3 @@ export type AutoclaimedIncentivesTxHashResponse = Record<
   Address,
   Record<Address, Record<Address, { txhash: string }>>
 >;
-
-export interface BribeBoostValidatorApr {
-  id: string;
-  boost_total_bgt: string;
-  rewards_total_usd: string;
-  daily_rate: string;
-  apr: string;
-  apy: string;
-  tokens: Address[]; // Confirm this type with backend real data
-  validator: string;
-  start_block: number;
-  end_block: number;
-  start_timestamp: number;
-  end_timestamp: number;
-  created_at: string;
-  updated_at: 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/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);
+  }
+}