@berachain/berajs 0.2.9 → 0.2.10

package/dist/hooks/governance/exports.mjs

@@ -5,16 +5,16 @@ import {
   getProposalDetails,
   getProposalFromTx,
   getProposalVotes
-} from "../../chunk-AFN4CVD3.mjs";
+} from "../../chunk-GUURQAME.mjs";
 import "../../chunk-DKMAIU74.mjs";
 import "../../chunk-SGIJVHZO.mjs";
 import {
   assertPublicClient
-} from "../../chunk-KQUMKB66.mjs";
+} from "../../chunk-GY6B3PD5.mjs";
 import {
   parseBaseArgs
-} from "../../chunk-75M6TF7M.mjs";
-import "../../chunk-J5I45WGQ.mjs";
+} from "../../chunk-DQRH5VE3.mjs";
+import "../../chunk-KHXJDYA4.mjs";
 
 // src/hooks/governance/useCreateProposal.ts
 import { useCallback, useEffect, useState } from "react";

package/dist/{pol.d-CqPA9K6m.d.ts → pol.d-Dw5SQcRX.d.ts}

@@ -35,11 +35,22 @@ 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.
 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.
+type AutoclaimedIncentivesTxHashResponse = Record<
+  Address,
+  Record<Address, Record<Address, { txhash: string }>>
 >;
 
 interface BribeBoostValidatorApr {
@@ -139,4 +150,4 @@ type StakedBeraAsset = {
   isLoadingEarnings?: boolean;
 };
 
-export type { AutoclaimedIncentivesResponse as A, BribeBoostRewardProof as B, ClaimedIncentives as C, IncentiveReward as I, ProtocolMetadata as P, StakingConfig as S, UserVaultInfo as U, BribeBoostRewardItem as a, StakedBeraAsset as b, AggregatedTokenTotals as c, BribeBoostReward as d, BribeBoostValidatorApr as e, ClaimedIncentivesLocalState as f, IncentiveRewardChunksWithValidatorData as g };
+export type { AutoclaimedIncentivesResponse as A, BribeBoostRewardProof as B, ClaimedIncentives as C, IncentiveReward as I, ProtocolMetadata as P, StakingConfig as S, UserVaultInfo as U, AutoclaimedIncentivesTxHashResponse as a, BribeBoostRewardItem as b, StakedBeraAsset as c, AggregatedTokenTotals as d, BribeBoostReward as e, BribeBoostValidatorApr as f, ClaimedIncentivesLocalState as g, IncentiveRewardChunksWithValidatorData as h };

package/dist/types/exports.d.ts

@@ -1,4 +1,4 @@
-export { c as AggregatedTokenTotals, A as AutoclaimedIncentivesResponse, d as BribeBoostReward, a as BribeBoostRewardItem, B as BribeBoostRewardProof, e as BribeBoostValidatorApr, C as ClaimedIncentives, f as ClaimedIncentivesLocalState, I as IncentiveReward, g as IncentiveRewardChunksWithValidatorData, P as ProtocolMetadata, b as StakedBeraAsset, S as StakingConfig, U as UserVaultInfo } from '../pol.d-CqPA9K6m.js';
+export { d as AggregatedTokenTotals, A as AutoclaimedIncentivesResponse, a as AutoclaimedIncentivesTxHashResponse, e as BribeBoostReward, b as BribeBoostRewardItem, B as BribeBoostRewardProof, f as BribeBoostValidatorApr, C as ClaimedIncentives, g as ClaimedIncentivesLocalState, I as IncentiveReward, h as IncentiveRewardChunksWithValidatorData, P as ProtocolMetadata, c as StakedBeraAsset, S as StakingConfig, U as UserVaultInfo } from '../pol.d-Dw5SQcRX.js';
 import { M as MinimalERC20 } from '../HoneyConfigProvider-Dkj-_a5x.js';
 export { A as AllowanceQueryItem, j as AllowanceToken, B as BalanceToken, y as BexStatus, x as Calldata, H as HoneySwapActions, I as IAggregatorArgs, z as IAggregatorQuote, g as IRawAggregatorQuote, v as IUserPosition, h as PythPriceFeedMap, S as SwapRequest, b as Token, i as TokenCurrentPriceMap, w as TokenPriceInfo, t as TokenWithAmount, a as TokenWithMetadata, D as TokenWithPrice } from '../HoneyConfigProvider-Dkj-_a5x.js';
 import { BundleData, EnsoClient } from '@ensofinance/sdk';

package/dist/utils/exports.mjs

@@ -2,7 +2,7 @@ import {
   computePriceImpact,
   wrapNativeToken,
   wrapNativeTokens
-} from "../chunk-FFB5LFDW.mjs";
+} from "../chunk-QVHEM4BG.mjs";
 import {
   CAP_LIMIT_BUFFER,
   DEFAULT_METAMASK_GAS_LIMIT,
@@ -10,8 +10,6 @@ import {
   MAX_CUSTOM_SLIPPAGE,
   MIN_CUSTOM_DEADLINE,
   MIN_CUSTOM_SLIPPAGE,
-  beraFetch,
-  beraFetchJson,
   bignumber_js_default,
   calculateTimestampFromDays,
   days,
@@ -29,14 +27,18 @@ import {
   months,
   monthsInSeconds,
   msToSeconds,
-  sanitizeRpcUrl,
   seconds,
   truncateDecimal,
   weeks,
   weeksInSeconds,
   years,
   yearsInSeconds
-} from "../chunk-CDFWPU2R.mjs";
+} from "../chunk-E7YFXBBQ.mjs";
+import {
+  beraFetch,
+  beraFetchJson,
+  sanitizeRpcUrl
+} from "../chunk-Y6THHG77.mjs";
 import {
   defaultFlags
 } from "../chunk-BGMRHTBQ.mjs";
@@ -45,20 +47,20 @@ import {
   getHoneyToken,
   isToken,
   wBeraToken
-} from "../chunk-NPBQLVL3.mjs";
+} from "../chunk-IXIBY5FP.mjs";
 import {
   parseBaseArgs
-} from "../chunk-75M6TF7M.mjs";
+} from "../chunk-DQRH5VE3.mjs";
 import {
   BeraTracing
 } from "../chunk-SZ5C44L5.mjs";
 import {
   RequestError
-} from "../chunk-XIYN6AL6.mjs";
+} from "../chunk-ZLTMIFCZ.mjs";
 import {
   BeraError,
   InvalidArgumentError
-} from "../chunk-J5I45WGQ.mjs";
+} from "../chunk-KHXJDYA4.mjs";
 
 // src/utils/formatInputTokenValue.ts
 var formatInputTokenValue = (inputValue) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@berachain/berajs",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "sideEffects": false,
   "files": [
     "dist",
@@ -12,9 +12,9 @@
   "dependencies": {
     "@apollo/client": "4.1.6",
     "@berachain-foundation/berancer-sdk": "1.1.7",
-    "@berachain/abis": "0.1.2",
-    "@berachain/config": "0.1.16",
-    "@berachain/graphql": "0.4.17",
+    "@berachain/abis": "0.1.3-beta.0",
+    "@berachain/config": "0.1.17",
+    "@berachain/graphql": "0.5.0",
     "@ensofinance/sdk": "2.3.1",
     "@pythnetwork/hermes-client": "2.0.0",
     "@wagmi/core": "2.22.1",

package/src/actions/clients/exports.ts

@@ -1,3 +1,6 @@
+export { fetchBeep } from "./fetchBeep";
+export { fetchOpenApi } from "./fetchOpenApi";
+export { fetchRailwayBackend } from "./fetchRailwayBackend";
 export {
   getApolloClient,
   gql,

package/src/actions/clients/fetchBeep.ts

@@ -0,0 +1,34 @@
+import type { paths } from "@berachain/graphql/beep";
+
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import {
+  type DefinedParams,
+  fetchOpenApi,
+  type GetPath,
+  type GetResponse,
+} from "./fetchOpenApi";
+
+/**
+ * Typed GET against the next-gen "beep" backend.
+ *
+ * The `path`, its path/query params and the response are all type-checked
+ * against the beep schema (`@berachain/graphql/beep`), so route shapes (e.g.
+ * the `/v0/stake/*` namespace) can never drift out of sync with the backend.
+ * The base URL is resolved from `config.beep`.
+ *
+ * @throws if `config.beep` is not set for the active chain. Callers should only
+ * reach for beep when `config.beep` is non-null.
+ */
+export function fetchBeep<P extends GetPath<paths>>(
+  path: P,
+  params: DefinedParams<paths, P>,
+  args: BeraJS.BaseFunctionArgs = {},
+): Promise<GetResponse<paths, P>> {
+  const { config } = parseBaseArgs(args);
+
+  if (!config.beep) {
+    throw new Error("fetchBeep: `beep` backend is not configured.");
+  }
+
+  return fetchOpenApi<paths, P>(config.beep, path, params, "beep");
+}

package/src/actions/clients/fetchOpenApi.ts

@@ -0,0 +1,93 @@
+import type { HttpLink } from "@berachain/config";
+import { getUriFromLink } from "@berachain/config";
+
+import { beraFetchJson } from "../../utils/beraFetch";
+
+/**
+ * A minimal, fully-typed GET helper for our `openapi-typescript`-generated
+ * backends. Both backends serve only GETs, so rather than a full OpenAPI client
+ * we type a single `fetchOpenApi` against a schema's `paths` and wrap it per
+ * backend (`fetchBeep`, `fetchRailwayBackend`).
+ *
+ * The `path`, its path/query params and the response body are all type-checked
+ * against the schema, so route shapes can never drift out of sync with the
+ * backend. Requests go through {@link beraFetchJson} so they keep the same
+ * Sentry tracing, `RequestError` handling and URL sanitization as the rest of
+ * the codebase.
+ */
+
+/** Any `openapi-typescript` `paths` object. */
+// biome-ignore lint/suspicious/noExplicitAny: schema `paths` are structurally diverse; constrained at call sites by the concrete schema.
+type AnyPaths = Record<string, any>;
+
+/** Paths in a schema that expose a JSON GET response. */
+export type GetPath<Paths extends AnyPaths> = {
+  [P in keyof Paths]: Paths[P] extends {
+    get: { responses: { 200: { content: { "application/json": unknown } } } };
+  }
+    ? P
+    : never;
+}[keyof Paths];
+
+type GetParams<
+  Paths extends AnyPaths,
+  P extends GetPath<Paths>,
+> = Paths[P]["get"] extends { parameters: infer Params } ? Params : never;
+
+export type GetResponse<
+  Paths extends AnyPaths,
+  P extends GetPath<Paths>,
+> = Paths[P]["get"]["responses"][200]["content"]["application/json"];
+
+// Drop the params keys that are `never` (e.g. an endpoint with no query) so
+// callers only pass what an endpoint actually accepts.
+export type DefinedParams<Paths extends AnyPaths, P extends GetPath<Paths>> = {
+  [K in keyof GetParams<Paths, P> as GetParams<Paths, P>[K] extends never
+    ? never
+    : K]: GetParams<Paths, P>[K];
+};
+
+/**
+ * Perform a typed GET against an OpenAPI backend.
+ *
+ * @param link    The backend `HttpLink`. The base URL and monitoring name are
+ *                read from it.
+ * @param path    An OpenAPI path template, e.g. `/v0/stake/{vault}/stats-by-day`.
+ * @param params  Path and query params, typed from the schema for `path`.
+ * @param fallbackName  Monitoring name to use when `link` is a bare string.
+ */
+// biome-ignore lint/complexity/useMaxParams: internal helper; the wrappers (fetchBeep / fetchRailwayBackend) are the public surface.
+export function fetchOpenApi<Paths extends AnyPaths, P extends GetPath<Paths>>(
+  link: HttpLink,
+  path: P,
+  params: DefinedParams<Paths, P>,
+  fallbackName: string,
+): Promise<GetResponse<Paths, P>> {
+  const { path: pathParams, query } = params as {
+    path?: Record<string, string | number>;
+    query?: Record<string, string | number>;
+  };
+
+  // Substitute `{param}` placeholders from the typed path params.
+  const pathStr = path as string;
+  const resolvedPath = pathStr.replace(/\{([^}]+)\}/g, (_, key) => {
+    const value = pathParams?.[key];
+    if (value === undefined) {
+      throw new Error(
+        `fetchOpenApi: missing path param "${key}" for "${pathStr}"`,
+      );
+    }
+    return encodeURIComponent(String(value));
+  });
+
+  const search = query
+    ? new URLSearchParams(
+        Object.entries(query).map(([k, v]) => [k, String(v)]),
+      ).toString()
+    : "";
+
+  const url = `${getUriFromLink(link)}${resolvedPath}${search ? `?${search}` : ""}`;
+  const name = typeof link === "string" ? fallbackName : link.name;
+
+  return beraFetchJson<GetResponse<Paths, P>>({ url, name, type: "rest" });
+}

package/src/actions/clients/fetchOpenApi.unit.test.ts

@@ -0,0 +1,223 @@
+import {
+  assert,
+  beforeEach,
+  describe,
+  expect,
+  expectTypeOf,
+  it,
+  vi,
+} from "vitest";
+
+import type { HttpLink } from "@berachain/config";
+import { bepolia } from "@berachain/config/bepolia";
+import { mainnet } from "@berachain/config/mainnet";
+
+import type {
+  paths as beepPaths,
+  StakeEarningResponse,
+  StakeStatsByDayResponse,
+  ValidatorsResponse,
+} from "@berachain/graphql/beep";
+
+import { fetchBeep } from "./fetchBeep";
+import { fetchOpenApi } from "./fetchOpenApi";
+
+// Mock the network layer so we can assert exactly what the helpers build and
+// pass through, without hitting a backend.
+const beraFetchJson = vi.fn();
+vi.mock("../../utils/beraFetch", () => ({
+  beraFetchJson: (...args: unknown[]) => beraFetchJson(...args),
+}));
+
+const BASE = "https://beep.testnet.berachain.com";
+const NAMED_LINK: HttpLink = { name: "Berachain Beep", uri: BASE };
+
+const VAULT = "0x1111111111111111111111111111111111111111" as const;
+const OWNER = "0x2222222222222222222222222222222222222222" as const;
+
+describe("fetchOpenApi", () => {
+  beforeEach(() => {
+    beraFetchJson.mockReset();
+    beraFetchJson.mockResolvedValue(undefined);
+  });
+
+  it("substitutes path params and serializes the query", async () => {
+    await fetchOpenApi<beepPaths, "/v0/stake/{vault}/stats-by-day">(
+      NAMED_LINK,
+      "/v0/stake/{vault}/stats-by-day",
+      { path: { vault: VAULT }, query: { days: "30" } },
+      "beep",
+    );
+
+    expect(beraFetchJson).toHaveBeenCalledTimes(1);
+    expect(beraFetchJson).toHaveBeenCalledWith({
+      url: `${BASE}/v0/stake/${VAULT}/stats-by-day?days=30`,
+      name: "Berachain Beep",
+      type: "rest",
+    });
+  });
+
+  it("substitutes multiple path params and omits the query when absent", async () => {
+    await fetchOpenApi<beepPaths, "/v0/stake/{vault}/earnings/{owner}">(
+      NAMED_LINK,
+      "/v0/stake/{vault}/earnings/{owner}",
+      { path: { vault: VAULT, owner: OWNER } },
+      "beep",
+    );
+
+    expect(beraFetchJson).toHaveBeenCalledWith({
+      url: `${BASE}/v0/stake/${VAULT}/earnings/${OWNER}`,
+      name: "Berachain Beep",
+      type: "rest",
+    });
+  });
+
+  it("url-encodes path param values", async () => {
+    // `pubkey` is a free-form string segment; reserved chars must be encoded.
+    await fetchOpenApi<beepPaths, "/v0/validators/{pubkey}/incentives">(
+      NAMED_LINK,
+      "/v0/validators/{pubkey}/incentives",
+      { path: { pubkey: "a/b c" } },
+      "beep",
+    );
+
+    expect(beraFetchJson).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: `${BASE}/v0/validators/a%2Fb%20c/incentives`,
+      }),
+    );
+  });
+
+  it("falls back to the provided name for a string link", async () => {
+    await fetchOpenApi<beepPaths, "/v0/validators">(
+      BASE,
+      "/v0/validators",
+      {},
+      "beep",
+    );
+
+    expect(beraFetchJson).toHaveBeenCalledWith(
+      expect.objectContaining({ name: "beep" }),
+    );
+  });
+
+  it("throws when a required path param is missing", () => {
+    expect(() =>
+      fetchOpenApi<beepPaths, "/v0/stake/{vault}/earnings/{owner}">(
+        NAMED_LINK,
+        "/v0/stake/{vault}/earnings/{owner}",
+        // @ts-expect-error — `vault` is required by the schema for this path.
+        { path: { owner: OWNER } },
+        "beep",
+      ),
+    ).toThrow(/missing path param "vault"/);
+  });
+
+  it("returns the response from beraFetchJson", async () => {
+    const response = [{ total_assets: "1", total_supply: "2", timestamp: 3 }];
+    beraFetchJson.mockResolvedValue(response);
+
+    const result = await fetchOpenApi<
+      beepPaths,
+      "/v0/stake/{vault}/stats-by-day"
+    >(
+      NAMED_LINK,
+      "/v0/stake/{vault}/stats-by-day",
+      { path: { vault: VAULT }, query: { days: "30" } },
+      "beep",
+    );
+
+    expect(result).toBe(response);
+  });
+});
+
+describe("fetchBeep", () => {
+  beforeEach(() => {
+    beraFetchJson.mockReset();
+    beraFetchJson.mockResolvedValue(undefined);
+  });
+
+  it("resolves the base URL from config.beep", async () => {
+    await fetchBeep(
+      "/v0/stake/{vault}/stats-by-day",
+      { path: { vault: VAULT }, query: { days: "30" } },
+      { config: bepolia },
+    );
+
+    expect(beraFetchJson).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: `${BASE}/v0/stake/${VAULT}/stats-by-day?days=30`,
+        name: "Berachain Beep",
+        type: "rest",
+      }),
+    );
+  });
+
+  it("throws when config.beep is not set (e.g. mainnet)", () => {
+    expect(() =>
+      fetchBeep(
+        "/v0/stake/{vault}/earnings/{owner}",
+        { path: { vault: VAULT, owner: OWNER } },
+        { config: mainnet },
+      ),
+    ).toThrow(/`beep` backend is not configured/);
+  });
+});
+
+// Type-only assertions. The bodies are never executed at runtime (they would
+// hit the `beep` not-configured throw); they exist so `tsc` validates inference
+// and the `@ts-expect-error` lines. `expectTypeOf` is purely compile-time.
+describe("fetchBeep types", () => {
+  it("infers the response type per path", () => {
+    const _assert = () => {
+      expectTypeOf(
+        fetchBeep("/v0/stake/{vault}/stats-by-day", {
+          path: { vault: VAULT },
+          query: { days: "30" },
+        }),
+      ).resolves.toEqualTypeOf<StakeStatsByDayResponse>();
+
+      expectTypeOf(
+        fetchBeep("/v0/stake/{vault}/earnings/{owner}", {
+          path: { vault: VAULT, owner: OWNER },
+        }),
+      ).resolves.toEqualTypeOf<StakeEarningResponse>();
+
+      expectTypeOf(
+        fetchBeep("/v0/validators", {}),
+      ).resolves.toEqualTypeOf<ValidatorsResponse>();
+    };
+    assert.ok(_assert);
+  });
+
+  it("rejects unknown paths", () => {
+    const _assert = () => {
+      // @ts-expect-error — not a path in the beep schema.
+      fetchBeep("/v0/not/a/real/path", { path: {} });
+    };
+    assert.ok(_assert);
+  });
+
+  it("rejects unknown path params", () => {
+    const _assert = () => {
+      fetchBeep("/v0/stake/{vault}/stats-by-day", {
+        // @ts-expect-error — `owner` is not a param of stats-by-day.
+        path: { vault: VAULT, owner: OWNER },
+        query: { days: "30" },
+      });
+    };
+    assert.ok(_assert);
+  });
+
+  it("constrains query values to the schema enum", () => {
+    const _assert = () => {
+      fetchBeep("/v0/stake/{vault}/stats-by-day", {
+        path: { vault: VAULT },
+        // @ts-expect-error — `7` is not an allowed `days` value.
+        query: { days: "7" },
+      });
+    };
+
+    assert.ok(_assert);
+  });
+});

package/src/actions/clients/fetchRailwayBackend.ts

@@ -0,0 +1,34 @@
+import type { paths } from "@berachain/graphql/api";
+
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import {
+  type DefinedParams,
+  fetchOpenApi,
+  type GetPath,
+  type GetResponse,
+} from "./fetchOpenApi";
+
+/**
+ * Typed GET against the legacy Railway backend.
+ *
+ * The `path`, its path/query params and the response are all type-checked
+ * against the Railway schema (`@berachain/graphql/api`). The base URL is
+ * resolved from `config.backend`.
+ *
+ * @deprecated The Railway backend is being replaced by beep; prefer
+ * {@link fetchBeep} where `config.beep` is available.
+ */
+export function fetchRailwayBackend<P extends GetPath<paths>>(
+  path: P,
+  params: DefinedParams<paths, P>,
+  args: BeraJS.BaseFunctionArgs = {},
+): Promise<GetResponse<paths, P>> {
+  const { config } = parseBaseArgs(args);
+
+  return fetchOpenApi<paths, P>(
+    config.backend,
+    path,
+    params,
+    "backend-railway",
+  );
+}

package/src/actions/enso/getEnsoUserTokensWithBalances.ts

@@ -31,6 +31,24 @@ export async function getEnsoUserTokensWithBalances({
     eoaAddress: account,
   });
 
+  // The Enso SDK can return a non-array (e.g. an error object) on a malformed
+  // or empty response. Guard before mapping to avoid the unactionable minified
+  // "(...).map is not a function" crash — but still report it as a typed,
+  // stably-grouped warning so we don't silently swallow an Enso API problem
+  // (an empty portfolio would otherwise look like "user has no tokens").
+  if (!Array.isArray(ensoBalances)) {
+    BeraMonitoring.captureException(
+      new InvalidArgumentError({
+        property: "ensoBalances",
+        value: ensoBalances,
+        expected: "BalanceToken[]",
+        chainId: typeof chainId === "number" ? chainId : undefined,
+        extra: { account, chainId },
+      }),
+    );
+    return [];
+  }
+
   const tokens: BalanceToken[] = ensoBalances.map(
     (balance) =>
       ({

package/src/actions/exports.ts

@@ -43,6 +43,7 @@ export * from "./honey/isBadCollateralAsset";
 export * from "./honey/isBasketModeEnabled";
 export * from "./misc/getBlockTimestamp";
 export * from "./pol/getAutoclaimedIncentives";
+export * from "./pol/getAutoclaimedIncentivesTxHash";
 export * from "./pol/getBeraTokenTotalSupply";
 export * from "./pol/getBgtAprSimulation";
 export * from "./pol/getBgtIncentiveDistributorPaused";

package/src/actions/honey/getPythLatestPrices.ts

@@ -1,8 +1,15 @@
 import { HermesClient } from "@pythnetwork/hermes-client";
 import { formatUnits } from "viem";
 
+import { polyfillAbortSignalAny } from "../../utils/polyfillAbortSignalAny";
+
 const pythEndpoint = "https://hermes.pyth.network";
 
+// @pythnetwork/hermes-client uses AbortSignal.any, which is missing on older
+// browsers/WebViews (e.g. Chrome Mobile WebView 114). Install the polyfill
+// before the client runs so getLatestPriceUpdates doesn't throw. See HONEY-188.
+polyfillAbortSignalAny();
+
 /**
  * Interface representing the latest Pyth price updates
  * @interface PythLatestUpdates

package/src/actions/pol/__tests__/rewardVaults.integration.test.ts

@@ -25,7 +25,7 @@ describe("rewardVaults", async () => {
   it("should have consistent data", () => {
     const totalBgtCatpure = gaugeList.reduce(
       (acc, vault) =>
-        acc + Number(vault.dynamicData?.bgtCapturePercentage ?? 0),
+        acc + Number(vault.dynamicData?.rewardCapturePercentage ?? 0),
       0,
     );
 

package/src/actions/pol/getAutoclaimedIncentives.ts

@@ -1,5 +1,6 @@
 import type { Address } from "viem";
 
+import { RequestError } from "../../errors/RequestError";
 import type { AutoclaimedIncentivesResponse } from "../../types/bribe-boost";
 import { beraFetchJson } from "../../utils/beraFetch";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
@@ -8,6 +9,9 @@ import { parseBaseArgs } from "../../utils/parseBaseArgs";
  * Server-side function to fetch the incentives the bot autoclaimed on behalf
  * of a wallet during the BGT → BERA cutover. Only valid to call once the
  * bgtIncentiveDistributor contract is paused.
+ *
+ * Returns `null` on 404 — the endpoint 404s when the bot has not yet processed
+ * the wallet, which is a normal "no data yet" state rather than an error.
  */
 export async function getAutoclaimedIncentives({
   account,
@@ -17,14 +21,21 @@ export async function getAutoclaimedIncentives({
 } & BeraJS.BaseFunctionArgs): Promise<AutoclaimedIncentivesResponse | null> {
   const { config } = parseBaseArgs(args);
 
-  return beraFetchJson<AutoclaimedIncentivesResponse>(
-    {
-      url: `${
-        config.pol.bribeBoostApi
-      }/api/v1/wallets/${account.toLowerCase()}/autoclaimed`,
-      name: "pol-autoclaimed-incentives",
-      type: "rest",
-    },
-    { cache: "no-store" },
-  );
+  try {
+    return await beraFetchJson<AutoclaimedIncentivesResponse>(
+      {
+        url: `${
+          config.pol.bribeBoostApi
+        }/api/v1/wallets/${account.toLowerCase()}/autoclaimed`,
+        name: "pol-autoclaimed-incentives",
+        type: "rest",
+      },
+      { cache: "no-store" },
+    );
+  } catch (error) {
+    if (error instanceof RequestError && error.statusCode === 404) {
+      return null;
+    }
+    throw error;
+  }
 }