@berachain/berajs 0.2.12 → 0.3.0

package/src/utils/filter.ts

@@ -3,11 +3,9 @@
  * @param data - The data to filter
  * @returns The filtered data
  */
-export const dailyResolution = <
+export function dailyResolution<
   T extends { timestamp?: number; _timestamp?: number },
->(
-  data: T[],
-) => {
+>(data: T[]): T[] {
   // Filter to get one data point per day
   const dailyData: T[] = [];
   let lastDay = "";
@@ -31,4 +29,4 @@ export const dailyResolution = <
   }
 
   return dailyData;
-};
+}

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/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)}`;
-};
+}