@berachain/berajs 0.2.11 → 0.2.13

package/src/utils/formatIncentivesTokenMap.ts

@@ -1,19 +1,19 @@
-import type { BribeBoostRewardItem } from "../types/bribe-boost";
+import type { BribeBoostRewardItem } from "../types/bribeBoost";
 
-export const formatIncentivesTokenMap = (
+export function formatIncentivesTokenMap(
   allRewards: BribeBoostRewardItem[],
-) => {
+): Set<string> {
   const tokenMap = new Set<string>();
 
-  allRewards.forEach((item: BribeBoostRewardItem) => {
+  for (const item of allRewards) {
     if (Array.isArray(item.rewards)) {
-      item.rewards.forEach((reward) => {
+      for (const reward of item.rewards) {
         if (reward.token) {
           tokenMap.add(reward.token);
         }
-      });
+      }
     }
-  });
+  }
 
   return tokenMap;
-};
+}

package/src/utils/formatInputTokenValue.ts

@@ -1,4 +1,4 @@
-export const formatInputTokenValue = (inputValue: string) => {
+export function formatInputTokenValue(inputValue: string): string {
   if (inputValue === "0") return inputValue;
   // Remove all non-numeric characters except for the decimal point, and remove leading zeros
   let filteredValue = inputValue.replace(/^0+/, "").replaceAll(/[^0-9.]/g, "");
@@ -9,4 +9,4 @@ export const formatInputTokenValue = (inputValue: string) => {
   }
 
   return filteredValue;
-};
+}

package/src/utils/formatNumber.ts

@@ -208,18 +208,18 @@ export function formatNumber(
 
   return parts.join("");
 }
-export const getSafeNumber = (value: string | undefined): number => {
+export function getSafeNumber(value: string | undefined): number {
   if (!value) return 0;
   return Number(value) > Number.MAX_SAFE_INTEGER
     ? Number.MAX_SAFE_INTEGER
     : (Number(value) ?? 0);
-};
+}
 
-export const truncateDecimal = (
+export function truncateDecimal(
   value: string | number | undefined,
   maxDecimal: number,
-): string => {
+): string {
   if (!value) return "0";
   const [integerPart = "0", decimalPart = "0"] = `${value}`.split(".");
   return `${integerPart}.${decimalPart.substring(0, maxDecimal)}`;
-};
+}

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

@@ -7,11 +7,14 @@ import {
 } from "./formatTimestamps";
 
 // Helper function to convert Date to Unix timestamp in milliseconds
-const scaledTime = (time: Date): number => time.getTime() * 1000;
+function scaledTime(time: Date): number {
+  return time.getTime() * 1000;
+}
 
 // Helper function to convert Date to Unix timestamp
-const toUnixTimestamp = (date: Date): number =>
-  Math.floor(date.getTime() / 1000);
+function toUnixTimestamp(date: Date): number {
+  return Math.floor(date.getTime() / 1000);
+}
 
 describe("calculateTimestampFromDays", () => {
   beforeEach(() => {

package/src/utils/formatUsd.ts

@@ -14,10 +14,12 @@ export function formatUsd(
     ...decimalsSettings,
   });
   try {
-    const isNumber = (value: unknown): value is number =>
-      typeof value === "number";
-    const isString = (value: unknown): value is string =>
-      typeof value === "string";
+    function isNumber(value: unknown): value is number {
+      return typeof value === "number";
+    }
+    function isString(value: unknown): value is string {
+      return typeof value === "string";
+    }
 
     if (!isNumber(input) && !isString(input)) {
       return formatter.format(0);

package/src/utils/getServerSideClient.ts

@@ -16,9 +16,9 @@ import { tracedTransport } from "./tracedTransport";
  */
 const _clients: Map<ChainId, PublicClient> = new Map();
 
-export const getServerSidePublicClient = (
+export function getServerSidePublicClient(
   args: { chainId?: ChainId } = {},
-): PublicClient => {
+): PublicClient {
   const chainId: ChainId = args.chainId ?? defaultChainId;
 
   if (_clients.has(chainId)) {
@@ -47,4 +47,4 @@ export const getServerSidePublicClient = (
   _clients.set(chainId, client);
 
   return client;
-};
+}

package/src/utils/isDifferenceExceedingThreshold.ts

@@ -1,13 +1,17 @@
 import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
-export const isDifferenceExceedingThreshold = (
-  initialAmount: string,
-  newAmount: string,
-  threshold: number,
-) => {
+export function isDifferenceExceedingThreshold({
+  initialAmount,
+  newAmount,
+  threshold,
+}: {
+  initialAmount: string;
+  newAmount: string;
+  threshold: number;
+}): boolean {
   const upperBound = new BigNumber(1 + threshold).times(initialAmount);
   const lowerBound = new BigNumber(1 - threshold).times(initialAmount);
   return (
     upperBound.isLessThan(newAmount) || lowerBound.isGreaterThan(newAmount)
   );
-};
+}

package/src/utils/layerZeroScan.ts

@@ -33,7 +33,9 @@ type GetMessagesBySrcTxHashResponse = {
   messages: LayerZeroMessage[];
 };
 
-const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 async function getMessagesBySrcTxHash(
   srcTxHash: string,

package/src/utils/math.ts

@@ -8,12 +8,17 @@ import BigNumber from "@berachain/utils/pkg/bignumber.js";
  * @param {string} outAmount - The amount of the output token
  * @returns {number} The price impact of the swap
  */
-export const computePriceImpact = (
-  tokenInPrice: string,
-  tokenOutPrice: string,
-  inAmount: string,
-  outAmount: string,
-): number => {
+export function computePriceImpact({
+  tokenInPrice,
+  tokenOutPrice,
+  inAmount,
+  outAmount,
+}: {
+  tokenInPrice: string;
+  tokenOutPrice: string;
+  inAmount: string;
+  outAmount: string;
+}): number {
   if (!tokenInPrice || !tokenOutPrice || !inAmount || !outAmount) return 0;
 
   const usdIn = new BigNumber(tokenInPrice).times(inAmount);
@@ -25,4 +30,4 @@ export const computePriceImpact = (
 
   const ratio = usdOut.div(usdIn);
   return Number(new BigNumber(1).minus(ratio).toFixed());
-};
+}

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

@@ -4,46 +4,145 @@ import { computePriceImpact } from "./math";
 
 describe("computePriceImpact", () => {
   it("should return 0 for zero price impact (1:1 swap)", () => {
-    expect(computePriceImpact("1", "1", "100", "100")).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "1",
+        inAmount: "100",
+        outAmount: "100",
+      }),
+    ).toBe(0);
   });
 
   it("should calculate positive price impact (gain)", () => {
     // $100 in -> $110 out = 10% gain = -0.1 price impact
-    const result = computePriceImpact("1", "1", "100", "110");
+    const result = computePriceImpact({
+      tokenInPrice: "1",
+      tokenOutPrice: "1",
+      inAmount: "100",
+      outAmount: "110",
+    });
     expect(result).toBeCloseTo(-0.1, 2);
   });
 
   it("should calculate negative price impact (loss)", () => {
     // $100 in -> $90 out = 10% loss = 0.1 price impact
-    const result = computePriceImpact("1", "1", "100", "90");
+    const result = computePriceImpact({
+      tokenInPrice: "1",
+      tokenOutPrice: "1",
+      inAmount: "100",
+      outAmount: "90",
+    });
     expect(result).toBeCloseTo(0.1, 2);
   });
 
   it("should return 0 for missing inputs", () => {
-    expect(computePriceImpact("", "1", "100", "100")).toBe(0);
-    expect(computePriceImpact("1", "", "100", "100")).toBe(0);
-    expect(computePriceImpact("1", "1", "", "100")).toBe(0);
-    expect(computePriceImpact("1", "1", "100", "")).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "",
+        tokenOutPrice: "1",
+        inAmount: "100",
+        outAmount: "100",
+      }),
+    ).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "",
+        inAmount: "100",
+        outAmount: "100",
+      }),
+    ).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "1",
+        inAmount: "",
+        outAmount: "100",
+      }),
+    ).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "1",
+        inAmount: "100",
+        outAmount: "",
+      }),
+    ).toBe(0);
   });
 
   it("should return 0 for zero values", () => {
-    expect(computePriceImpact("0", "1", "100", "100")).toBe(0);
-    expect(computePriceImpact("1", "0", "100", "100")).toBe(0);
-    expect(computePriceImpact("1", "1", "0", "100")).toBe(0);
-    expect(computePriceImpact("1", "1", "100", "0")).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "0",
+        tokenOutPrice: "1",
+        inAmount: "100",
+        outAmount: "100",
+      }),
+    ).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "0",
+        inAmount: "100",
+        outAmount: "100",
+      }),
+    ).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "1",
+        inAmount: "0",
+        outAmount: "100",
+      }),
+    ).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "1",
+        inAmount: "100",
+        outAmount: "0",
+      }),
+    ).toBe(0);
   });
 
   it("should return 0 for very small amounts (< 0.01 USD)", () => {
-    expect(computePriceImpact("1", "1", "0.001", "0.001")).toBe(0);
-    expect(computePriceImpact("1", "1", "0.005", "0.005")).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "1",
+        inAmount: "0.001",
+        outAmount: "0.001",
+      }),
+    ).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "1",
+        tokenOutPrice: "1",
+        inAmount: "0.005",
+        outAmount: "0.005",
+      }),
+    ).toBe(0);
   });
 
   it("should handle different token prices", () => {
     // $2000 ETH -> $1 USDC: 1 ETH (2000) -> 2000 USDC
-    expect(computePriceImpact("2000", "1", "1", "2000")).toBe(0);
+    expect(
+      computePriceImpact({
+        tokenInPrice: "2000",
+        tokenOutPrice: "1",
+        inAmount: "1",
+        outAmount: "2000",
+      }),
+    ).toBe(0);
 
     // $2000 ETH -> $1 USDC: 1 ETH (2000) -> 1900 USDC = 5% loss
-    const result = computePriceImpact("2000", "1", "1", "1900");
+    const result = computePriceImpact({
+      tokenInPrice: "2000",
+      tokenOutPrice: "1",
+      inAmount: "1",
+      outAmount: "1900",
+    });
     expect(result).toBeCloseTo(0.05, 2);
   });
 });

package/src/utils/polyfillAbortSignalAny.ts

@@ -34,16 +34,16 @@ export function polyfillAbortSignalAny(): void {
     // 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 = () => {
+    function cleanup() {
       for (let i = 0; i < signals.length; i++) {
         signals[i].removeEventListener("abort", listeners[i]);
       }
-    };
+    }
     for (const signal of signals) {
-      const onAbort = () => {
+      function onAbort() {
         if (!controller.signal.aborted) controller.abort(signal.reason);
         cleanup();
-      };
+      }
       listeners.push(onAbort);
       signal.addEventListener("abort", onAbort);
     }

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

@@ -11,7 +11,9 @@ describe("polyfillAbortSignalAny", () => {
   });
 
   it("does not overwrite a native AbortSignal.any", () => {
-    const native = () => new AbortController().signal;
+    function native() {
+      return new AbortController().signal;
+    }
     (AbortSignal as { any?: unknown }).any = native;
     polyfillAbortSignalAny();
     expect((AbortSignal as { any?: unknown }).any).toBe(native);

package/src/utils/poolNamings.ts

@@ -4,26 +4,30 @@ import { formatUnits } from "viem";
 import type { Token } from "../types/dex";
 
 // Utility function to sort tokens by their address without modifying the original array
-const sortTokensByAddress = (tokens: Token[]): Token[] => {
+function sortTokensByAddress(tokens: Token[]): Token[] {
   return [...tokens].sort((a, b) =>
     a.address.toLowerCase().localeCompare(b.address.toLowerCase()),
   );
-};
+}
 
-export const generatePoolName = (tokens: Token[]): string => {
+export function generatePoolName(tokens: Token[]): string {
   if (tokens.length === 0) {
     return "";
   }
   return sortTokensByAddress(tokens)
     .map((token) => token.symbol)
     .join(" | ");
-};
+}
 
-export const generatePoolSymbol = (
-  tokens: Token[],
-  weights: bigint[],
-  poolType: PoolType,
-): string => {
+export function generatePoolSymbol({
+  tokens,
+  weights,
+  poolType,
+}: {
+  tokens: Token[];
+  weights: bigint[];
+  poolType: PoolType;
+}): string {
   let poolTypeString: string;
 
   switch (poolType) {
@@ -51,4 +55,4 @@ export const generatePoolSymbol = (
   return `${sortTokensByAddress(tokens)
     .map((token) => token.symbol)
     .join("-")}-${poolTypeString}`;
-};
+}

package/src/utils/pythHoneyUtils.ts

@@ -1,3 +1,3 @@
-export const getPythDefaultUpdateFee = (tokenListLength: number) => {
+export function getPythDefaultUpdateFee(tokenListLength: number): bigint {
   return 2n * BigInt(tokenListLength);
-};
+}

package/src/utils/truncateHash.ts

@@ -1,12 +1,12 @@
 /**
  * Truncate a transaction or address hash and optionally format with uppercase letters and a lowercase 'x'.
  */
-export const truncateHash = (
+export function truncateHash(
   address: `0x${string}` | string,
   startLength = 4,
   endLength = 4,
   formatUppercase = false,
-) => {
+): string {
   if (!address) return "";
 
   const formattedAddress = formatUppercase
@@ -17,4 +17,4 @@ export const truncateHash = (
     0,
     startLength,
   )}...${formattedAddress.substring(formattedAddress.length - endLength)}`;
-};
+}

package/src/actions/clients/fetchRailwayBackend.ts

@@ -1,34 +0,0 @@
-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/pol/getGlobalCuttingBoard.ts

@@ -1,25 +0,0 @@
-import {
-  type ApiVaultFragment,
-  GqlRewardVaultOrderBy,
-  GqlRewardVaultOrderDirection,
-} from "@berachain/graphql/pol/api";
-
-import { getRewardVaults } from "./getRewardVaults";
-
-export async function getGlobalCuttingBoard(
-  threshold: number,
-): Promise<ApiVaultFragment[]> {
-  const { gaugeList } = await getRewardVaults({
-    filter: {
-      // TODO sort by bgt capture percentage
-      orderBy: GqlRewardVaultOrderBy.Apr,
-      orderDirection: GqlRewardVaultOrderDirection.Desc,
-      pageSize: threshold,
-      where: {
-        includeNonWhitelisted: false,
-      },
-    },
-  });
-
-  return gaugeList;
-}

package/src/actions/pol/getIncentiveFeeClaimStats.ts

@@ -1,24 +0,0 @@
-import { BeraError } from "../../errors/BeraError";
-import { beraFetchJson } from "../../utils/beraFetch";
-
-export type IncentiveFeeClaimStats = {
-  sumAllClaims: number;
-  sumClaimsInLast24Hours: number;
-};
-
-/** Browser-only. Hits `/api/pol/incentive-fee-claims` (server computes totals). */
-export async function getIncentiveFeeClaimStats(): Promise<IncentiveFeeClaimStats> {
-  if (typeof window === "undefined") {
-    throw new BeraError({
-      message:
-        "getIncentiveFeeClaimStats is browser-only; call from a Client Component / SWR hook",
-      level: "error",
-    });
-  }
-
-  return beraFetchJson<IncentiveFeeClaimStats>({
-    url: "/api/pol/incentive-fee-claims",
-    name: "pol-incentive-fee-claims",
-    type: "rest",
-  });
-}

package/src/actions/validators/getDailyValidatorBlockStats.ts

@@ -1,38 +0,0 @@
-import type { Address } from "viem";
-
-import type { GetValidatorBlockStatsQuery } from "@berachain/graphql/pol/subgraph";
-
-import { BeraError } from "../../errors/BeraError";
-import { beraFetchJson } from "../../utils/beraFetch";
-
-/**
- * Browser-only. Hits `/api/pol/validator-block-stats`. Server callers (RSC)
- * should import from `@berachain/berajs/actions/server` instead — that path
- * has the static Apollo + GraphQL imports and does not pass through the
- * browser endpoint.
- */
-export async function getDailyValidatorBlockStats({
-  pubKey,
-  first = 1,
-}: {
-  pubKey: Address;
-  first?: number;
-}): Promise<GetValidatorBlockStatsQuery | undefined> {
-  if (typeof window === "undefined") {
-    throw new BeraError({
-      message:
-        "getDailyValidatorBlockStats is browser-only; for RSC use @berachain/berajs/actions/server",
-      level: "error",
-    });
-  }
-
-  const params = new URLSearchParams({
-    pubkey: pubKey,
-    first: String(first),
-  });
-  return beraFetchJson<GetValidatorBlockStatsQuery>({
-    url: `/api/pol/validator-block-stats?${params}`,
-    name: "pol-validator-block-stats",
-    type: "rest",
-  });
-}

package/src/hooks/tokens/useTokenCurrentPrice.ts

@@ -1,21 +0,0 @@
-import type { DefaultHookOptions } from "../../types/global";
-import { useTokenCurrentPrices } from "./useTokenCurrentPrices";
-
-/**
- * @deprecated use useTokenPrice instead
- */
-export function useTokenCurrentPrice(
-  { address }: { address: `0x${string}` | undefined },
-  options?: DefaultHookOptions,
-) {
-  const swrResponse = useTokenCurrentPrices(
-    {
-      addressIn: address ? [address] : undefined,
-    },
-    options,
-  );
-  return {
-    ...swrResponse,
-    data: address ? swrResponse.data?.[address.toLowerCase()] : undefined,
-  };
-}

package/src/hooks/validators/useDailyValidatorBlockStats.ts

@@ -1,35 +0,0 @@
-import type { Address } from "viem";
-
-import type { GetValidatorBlockStatsQuery } from "@berachain/graphql/pol/subgraph";
-import { useSWR } from "@berachain/utils/pkg/swr";
-
-import { getDailyValidatorBlockStats } from "../../actions/validators/getDailyValidatorBlockStats";
-import { POLLING } from "../../enum/polling";
-import type { DefaultHookReturnType } from "../../types/global";
-
-export const useDailyValidatorBlockStats = ({
-  pubKey,
-  first = 1,
-}: {
-  pubKey: Address | undefined;
-  first?: number;
-}): DefaultHookReturnType<GetValidatorBlockStatsQuery> => {
-  const QUERY_KEY = pubKey
-    ? (["useDailyValidatorBlockStats", pubKey, first] as const)
-    : null;
-
-  const swrResponse = useSWR(
-    QUERY_KEY,
-    async ([, pubKey, first]) => {
-      return await getDailyValidatorBlockStats({
-        pubKey: pubKey,
-        first,
-      });
-    },
-    {
-      refreshInterval: POLLING.SLOW,
-    },
-  );
-
-  return { ...swrResponse, refresh: () => swrResponse.mutate() };
-};

package/src/hooks/validators/useDefaultRewardAllocation.ts

@@ -1,31 +0,0 @@
-import { usePublicClient } from "@berachain/wagmi/hooks";
-import { useSWR } from "@berachain/utils/pkg/swr";
-
-import { getDefaultRewardAllocation } from "../../actions/validators/getDefaultRewardAllocation";
-import type { ValidatorRewardAllocation } from "../../actions/validators/getValidatorRewardAllocation";
-import { assertPublicClient } from "../../errors/assert";
-import type { DefaultHookOptions } from "../../types/global";
-
-export function useDefaultRewardAllocation(options?: DefaultHookOptions) {
-  const publicClient = usePublicClient();
-  const QUERY_KEY = publicClient ? ["useDefaultRewardAllocation"] : null;
-
-  const swrResponse = useSWR<ValidatorRewardAllocation | undefined>(
-    QUERY_KEY,
-    async () => {
-      assertPublicClient(publicClient);
-
-      return await getDefaultRewardAllocation({
-        client: publicClient,
-      });
-    },
-    {
-      ...options,
-    },
-  );
-
-  return {
-    ...swrResponse,
-    refresh: () => swrResponse.mutate(),
-  };
-}