@berachain/berajs 0.2.9 → 0.2.11

package/src/hooks/validators/useValidatorRewardAllocation.ts

@@ -1,7 +1,7 @@
-import useSWR from "swr";
 import type { Address, PublicClient } from "viem";
 
 import { usePublicClient } from "@berachain/wagmi/hooks";
+import { useSWR } from "@berachain/utils/pkg/swr";
 
 import { getValidatorRewardAllocation } from "../../actions/validators/getValidatorRewardAllocation";
 import type { DefaultHookOptions } from "../../types/global";
@@ -25,7 +25,7 @@ export function useValidatorRewardAllocation(
       });
     },
     {
-      ...options?.opts,
+      ...options,
     },
   );
 

package/src/types/bribe-boost.d.ts

@@ -33,11 +33,22 @@ export interface BribeBoostRewardProof {
 }
 
 // Response shape of GET /api/v1/wallets/:wallet/autoclaimed:
-//   { [wallet]: { [validatorPubkey]: { [tokenAddress]: rawAmount (stringified bigint) } } }
-// Top-level wallet key is the lowercase wallet address that was queried.
+//   { [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, string>>
+  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 }>>
 >;
 
 export interface BribeBoostValidatorApr {

package/src/types/global.d.ts

@@ -1,5 +1,4 @@
 import type { Config, GetWalletClientReturnType } from "@wagmi/core";
-import type { SWRConfiguration, SWRResponse } from "swr";
 import type {
   Abi,
   Account,
@@ -13,6 +12,8 @@ import type {
 
 import type { BeraConfig, ChainId } from "@berachain/config";
 
+import type { SWRConfiguration, SWRResponse } from "@berachain/utils/pkg/swr";
+
 import type { ContractName } from "../enum/contracts";
 import type { TransactionActionType } from "../enum/txnEnum";
 import type {
@@ -20,9 +21,7 @@ import type {
   TxnEventKeys,
 } from "../hooks/useContractWrite/types";
 
-export type DefaultHookOptions = {
-  opts?: SWRConfiguration & { isEnabled?: boolean };
-};
+export type DefaultHookOptions = SWRConfiguration & { isEnabled?: boolean };
 
 export type DefaultHookReturnType<T = any> = Omit<
   SWRResponse<T, any, any>,

package/src/types/pol.d.ts

@@ -55,10 +55,24 @@ export interface UserVaultInfo {
 
 export type StakedBeraAsset = {
   token: TokenWithMetadata;
-  apr: number;
+  /**
+   * Staking APR, or `undefined` when unavailable (e.g. the APR backend is
+   * down). `undefined` lets the UI render a "—" placeholder instead of a
+   * misleading "0%".
+   */
+  apr: number | undefined;
   stakedAmount: number;
-  stakedAmountUsd: number;
+  /**
+   * USD value of the staked amount, or `undefined` when the token price is
+   * unavailable (e.g. the price backend is down). `undefined` lets the UI
+   * render a "—" placeholder instead of a misleading "$0.00".
+   */
+  stakedAmountUsd: number | undefined;
   earnedAmount: number;
-  earnedAmountUsd: number;
+  /**
+   * USD value of the earned amount, or `undefined` when the token price is
+   * unavailable. See {@link stakedAmountUsd}.
+   */
+  earnedAmountUsd: number | undefined;
   isLoadingEarnings?: boolean;
 };

package/src/utils/polyfillAbortSignalAny.ts

@@ -0,0 +1,53 @@
+/**
+ * Polyfill for `AbortSignal.any`.
+ *
+ * `AbortSignal.any` ships in Chrome 116+, Safari 17.4+, Firefox 124+. Older
+ * environments — notably Android WebViews bundled with old Chromium (e.g.
+ * Chrome Mobile WebView 114) — lack it, and third-party libraries that call it
+ * (e.g. @pythnetwork/hermes-client) throw "AbortSignal.any is not a function".
+ *
+ * This installs a spec-compatible-enough fallback: it returns a controller's
+ * signal that aborts as soon as any of the input signals abort (propagating the
+ * abort reason). It is idempotent and a no-op when the native API exists.
+ */
+export function polyfillAbortSignalAny(): void {
+  if (typeof AbortSignal === "undefined") return;
+  if (typeof (AbortSignal as { any?: unknown }).any === "function") return;
+
+  (
+    AbortSignal as unknown as { any: (signals: AbortSignal[]) => AbortSignal }
+  ).any = (signals: AbortSignal[]): AbortSignal => {
+    const controller = new AbortController();
+
+    // Phase 1: if any signal is already aborted, short-circuit before attaching
+    // any listeners (attaching to the others would leave dangling listeners
+    // that never fire — the leak the WeakRef/FinalizationRegistry versions guard
+    // against; checking first avoids it without that machinery).
+    for (const signal of signals) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+        return controller.signal;
+      }
+    }
+
+    // Phase 2: forward the first abort, then detach every listener so none
+    // outlive the combined signal. Safe for our short-lived usage (per-request
+    // fetch signals that settle and are collected together).
+    const listeners: Array<() => void> = [];
+    const cleanup = () => {
+      for (let i = 0; i < signals.length; i++) {
+        signals[i].removeEventListener("abort", listeners[i]);
+      }
+    };
+    for (const signal of signals) {
+      const onAbort = () => {
+        if (!controller.signal.aborted) controller.abort(signal.reason);
+        cleanup();
+      };
+      listeners.push(onAbort);
+      signal.addEventListener("abort", onAbort);
+    }
+
+    return controller.signal;
+  };
+}

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

@@ -0,0 +1,81 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { polyfillAbortSignalAny } from "./polyfillAbortSignalAny.js";
+
+describe("polyfillAbortSignalAny", () => {
+  const original = (AbortSignal as { any?: unknown }).any;
+
+  afterEach(() => {
+    // restore whatever the runtime had (native or undefined)
+    (AbortSignal as { any?: unknown }).any = original;
+  });
+
+  it("does not overwrite a native AbortSignal.any", () => {
+    const native = () => new AbortController().signal;
+    (AbortSignal as { any?: unknown }).any = native;
+    polyfillAbortSignalAny();
+    expect((AbortSignal as { any?: unknown }).any).toBe(native);
+  });
+
+  it("installs a fallback when AbortSignal.any is missing", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+    expect(typeof (AbortSignal as { any?: unknown }).any).toBe("function");
+  });
+
+  it("aborts the combined signal when one input aborts", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+
+    const a = new AbortController();
+    const b = new AbortController();
+    const combined = (
+      AbortSignal as unknown as { any: (s: AbortSignal[]) => AbortSignal }
+    ).any([a.signal, b.signal]);
+
+    expect(combined.aborted).toBe(false);
+    b.abort("boom");
+    expect(combined.aborted).toBe(true);
+    expect(combined.reason).toBe("boom");
+  });
+
+  it("removes listeners from all inputs once the combined signal aborts", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+
+    const a = new AbortController();
+    const b = new AbortController();
+    const removed: AbortSignal[] = [];
+    for (const c of [a, b]) {
+      const orig = c.signal.removeEventListener.bind(c.signal);
+      c.signal.removeEventListener = ((...args: Parameters<typeof orig>) => {
+        removed.push(c.signal);
+        return orig(...args);
+      }) as typeof orig;
+    }
+
+    (AbortSignal as unknown as { any: (s: AbortSignal[]) => AbortSignal }).any([
+      a.signal,
+      b.signal,
+    ]);
+
+    a.abort("x");
+    // both inputs should have had their abort listener detached, not just the firing one
+    expect(removed).toContain(a.signal);
+    expect(removed).toContain(b.signal);
+  });
+
+  it("is already aborted if an input is already aborted", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+
+    const a = new AbortController();
+    a.abort("early");
+    const combined = (
+      AbortSignal as unknown as { any: (s: AbortSignal[]) => AbortSignal }
+    ).any([a.signal]);
+
+    expect(combined.aborted).toBe(true);
+    expect(combined.reason).toBe("early");
+  });
+});

package/dist/polling-BKnyavLI.d.ts

@@ -1,8 +0,0 @@
-declare enum POLLING {
-    FAST = 10000,// 10 sec
-    NORMAL = 100000,// 100 sec
-    SLOW = 180000,// 3 min
-    REFRESH_BLOCK_INTERVAL = 10000
-}
-
-export { POLLING as P };