@berachain/berajs 0.1.0 → 0.1.2

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

@@ -0,0 +1,191 @@
+import { zeroAddress } from "viem";
+import { describe, expect, expectTypeOf, test } from "vitest";
+
+import {
+  Aggregators,
+  type IAggregatorQuote,
+  type IRawAggregatorQuote,
+  type Token,
+} from "~/types/dex";
+import { formatAggregatorsQuotes } from "./formatAggregatorsQuotes";
+
+const mockToken = (symbol: string, decimals: number): Token => ({
+  symbol,
+  decimals,
+  address: zeroAddress,
+  name: symbol,
+  chainId: 1,
+});
+
+const mockCalldata = {
+  params: [],
+  functionName: "",
+  abi: [],
+  address: zeroAddress,
+  value: BigInt(0),
+};
+
+const mockQuotes: IRawAggregatorQuote<false>[] = [
+  {
+    amountOut: "1000000000000000000", // 1 token
+    amountIn: "2000000000000000000", // 2 tokens
+    name: Aggregators.Fly,
+    spender: zeroAddress,
+    calldata: mockCalldata,
+    swapFeeBps: 10,
+  },
+  {
+    amountOut: "1200000000000000000", // 1.2 tokens
+    amountIn: "2000000000000000000", // 2 tokens
+    name: Aggregators.HubPools,
+    spender: zeroAddress,
+    calldata: mockCalldata,
+    swapFeeBps: 10,
+  },
+  {
+    amountOut: "800000000000000000", // 0.8 tokens
+    amountIn: "2000000000000000000", // 2 tokens
+    name: Aggregators.Oogabooga,
+    spender: zeroAddress,
+    calldata: mockCalldata,
+    swapFeeBps: 10,
+  },
+];
+
+describe("formatAggregatorsQuotes", () => {
+  test("should return an empty array if no quotes are provided", () => {
+    expect(formatAggregatorsQuotes([], undefined, undefined, 0, 0)).toEqual([]);
+  });
+
+  test("should return the correct type", () => {
+    const results = formatAggregatorsQuotes(
+      mockQuotes,
+      undefined,
+      undefined,
+      0,
+      0,
+    );
+    expectTypeOf(results).toEqualTypeOf<IAggregatorQuote[]>();
+  });
+
+  test("should sort quotes by amountOut in descending order", () => {
+    const tokenIn = mockToken("TOKEN_IN", 18);
+    const tokenOut = mockToken("TOKEN_OUT", 18);
+
+    const results = formatAggregatorsQuotes(
+      mockQuotes,
+      tokenIn,
+      tokenOut,
+      1,
+      1,
+    );
+
+    expect(results[0].amountOut).toBe("1.2");
+    expect(results[1].amountOut).toBe("1");
+    expect(results[2].amountOut).toBe("0.8");
+  });
+
+  test("should calculate relative loss percentage correctly", () => {
+    const tokenIn = mockToken("ABC", 18);
+    const tokenOut = mockToken("XYZ", 18);
+
+    const results = formatAggregatorsQuotes(
+      mockQuotes,
+      tokenIn,
+      tokenOut,
+      1,
+      1,
+    );
+
+    // best quote has 0% loss
+    expect(results[0].relativeLossPercentage).toBe(0);
+
+    // other quotes show percentage loss relative to best quote
+    expect(results[1].relativeLossPercentage).toBeCloseTo(0.166);
+    expect(results[2].relativeLossPercentage).toBeCloseTo(0.333);
+  });
+
+  test("should handle tokens with different decimals", () => {
+    const tokenIn = mockToken("USDC", 6);
+    const tokenOut = mockToken("ETH", 18);
+
+    const quotesWithDifferentDecimals: IRawAggregatorQuote<false>[] = [
+      {
+        amountOut: "1000000000000000000", // 1 ETH
+        amountIn: "2000000", // 2 USDC
+        name: Aggregators.Fly,
+        spender: zeroAddress,
+        calldata: mockCalldata,
+        swapFeeBps: 10,
+      },
+    ];
+
+    const results = formatAggregatorsQuotes(
+      quotesWithDifferentDecimals,
+      tokenIn,
+      tokenOut,
+      1,
+      1,
+    );
+
+    expect(results[0].amountIn).toBe("2");
+    expect(results[0].amountOut).toBe("1");
+  });
+
+  test("should calculate amountOutUsd correctly", () => {
+    const tokenIn = mockToken("ABC", 18);
+    const tokenOut = mockToken("XYZ", 18);
+    const tokenOutPrice = 100; // $100 per token
+
+    const results = formatAggregatorsQuotes(
+      mockQuotes,
+      tokenIn,
+      tokenOut,
+      1,
+      tokenOutPrice,
+    );
+
+    // amountOutUsd = amountOut * tokenOutPrice
+    expect(results[0].amountOutUsd).toBe("120"); // 1.2 * $100
+    expect(results[1].amountOutUsd).toBe("100"); // 1.0 * $100
+    expect(results[2].amountOutUsd).toBe("80"); // 0.8 * $100
+  });
+
+  test("should calculate amountOutUsd correctly with different decimals", () => {
+    const tokenIn = mockToken("USDC", 6);
+    const tokenOut = mockToken("ETH", 18);
+    const tokenOutPrice = 100.5; // $100.50 per token
+
+    const results = formatAggregatorsQuotes(
+      mockQuotes,
+      tokenIn,
+      tokenOut,
+      1,
+      tokenOutPrice,
+    );
+
+    // amountOutUsd = amountOut * tokenOutPrice
+    expect(results[0].amountOutUsd).toBe("120.6"); // 1.2 * $100.50
+    expect(results[1].amountOutUsd).toBe("100.5"); // 1.0 * $100.50
+    expect(results[2].amountOutUsd).toBe("80.4"); // 0.8 * $100.50
+  });
+
+  test("should calculate price impact when token prices provided", () => {
+    const tokenIn = mockToken("ABC", 18);
+    const tokenOut = mockToken("XYZ", 18);
+
+    const results = formatAggregatorsQuotes(
+      mockQuotes,
+      tokenIn,
+      tokenOut,
+      100, // $100 per token in
+      50, // $50 per token out
+    );
+
+    // For best quote (1.2 out for 2 in):
+    // USD in = 2 * $100 = $200
+    // USD out = 1.2 * $50 = $60
+    // Price impact = 1 - (60/200) = 0.7 = 70%
+    expect(results[0].priceImpactPercentage).toBe(0.7);
+  });
+});

package/src/utils/formatIncentivesTokenMap.ts

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

package/src/utils/formatInputTokenValue.ts

@@ -0,0 +1,12 @@
+export const formatInputTokenValue = (inputValue: 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, "");
+
+  // Keep the 0
+  if (filteredValue.startsWith(".")) {
+    filteredValue = `0${filteredValue}`;
+  }
+
+  return filteredValue;
+};

package/src/utils/formatNumber.ts

@@ -0,0 +1,225 @@
+import { BigNumber } from "bignumber.js";
+
+export type BigNumberValue = string | number | BigNumber;
+
+export interface FormatNumberOptions {
+  /** Number of visible decimal places */
+  visibleDecimals?: number;
+  /** Whether to use compact notation (K, M, B, etc.) */
+  compact?: boolean;
+  /** Show as percentage */
+  percent?: boolean;
+  /** Round down instead of normal rounding */
+  roundDown?: boolean;
+  /** Round up instead of normal rounding */
+  roundUp?: boolean;
+  /** Threshold above which compact notation is used */
+  compactThreshold?: number;
+  /** Maximum value to display (shows ∞ if exceeded) */
+  maxValue?: number;
+  /** Currency symbol (e.g., "USD" for $) */
+  symbol?: string;
+  /** Prefix text */
+  prefixText?: string;
+  /** Suffix text */
+  suffixText?: string;
+  /** Show "< min" or "> min" indicators for very small values */
+  showIsSmallerThanMin?: boolean;
+  /** Text to show if value is null/undefined */
+  ifNullish?: string;
+}
+
+const POSTFIXES = ["", "K", "M", "B", "T", "P", "E", "Z", "Y"];
+
+function valueToBigNumber(amount: BigNumberValue): BigNumber {
+  if (amount instanceof BigNumber) return amount;
+  return new BigNumber(amount);
+}
+
+function normalizeBN(n: BigNumberValue, decimals: number): BigNumber {
+  return valueToBigNumber(n).shiftedBy(decimals * -1);
+}
+
+export function formatNumber(
+  value: BigNumberValue | undefined | null,
+  options: FormatNumberOptions | number = {},
+): string {
+  if (typeof options === "number") {
+    const decimals = options;
+    if (value === undefined || value === null) {
+      return "";
+    }
+
+    if (typeof value === "object") {
+      throw new Error("Value must be a number if using deprecated version");
+    }
+
+    // Convert to string with up to 8 decimal places
+    let formatted = Number(value).toFixed(decimals);
+    // Remove trailing zeros and decimal point if not needed
+    formatted = formatted.replace(/(\.\d*?[1-9])0+$|\.0*$/, "$1");
+    return formatted;
+  }
+
+  const {
+    visibleDecimals,
+    compact = true,
+    percent = false,
+    roundDown = false,
+    roundUp = false,
+    compactThreshold,
+    maxValue,
+    symbol,
+    prefixText = "",
+    suffixText = "",
+    showIsSmallerThanMin = true,
+    ifNullish = "",
+  } = options || {};
+
+  // Handle null/undefined values
+  if (value === undefined || value === null) {
+    return ifNullish;
+  }
+
+  const number = percent ? Number(value) * 100 : Number(value);
+
+  // Handle special numeric values
+  if (Number.isNaN(number)) {
+    return "NaN";
+  }
+  if (number === Number.POSITIVE_INFINITY) {
+    return "Infinity";
+  }
+  if (number === Number.NEGATIVE_INFINITY) {
+    return "-Infinity";
+  }
+
+  // Determine decimal places
+  let decimals: number = visibleDecimals ?? 0;
+  if (number === 0) {
+    decimals = 0;
+  } else if (visibleDecimals === undefined) {
+    if (Math.abs(number) > 1 || percent || symbol === "USD") {
+      decimals = 2;
+    } else {
+      decimals = 7;
+    }
+  }
+
+  const minValue = 10 ** -(decimals as number);
+  const isSmallerThanMin =
+    number !== 0 && Math.abs(number) < Math.abs(minValue);
+  const isNegative = number < 0;
+  const isBiggerThanMax = maxValue ? Math.abs(number) > maxValue : false;
+
+  let formattedNumber = isSmallerThanMin ? minValue : number;
+  const forceCompact =
+    compact && (!compactThreshold || Math.abs(number) > compactThreshold);
+
+  // Apply rounding for non-compact numbers
+  if (roundDown && !forceCompact) {
+    formattedNumber =
+      Math.trunc(Number(formattedNumber) * 10 ** decimals) / 10 ** decimals;
+  } else if (roundUp && !forceCompact) {
+    formattedNumber =
+      Math.ceil(Number(formattedNumber) * 10 ** decimals) / 10 ** decimals;
+  }
+
+  let formattedValue: string;
+
+  if (isBiggerThanMax) {
+    formattedValue = number > maxValue! ? "∞" : "-∞";
+  } else if (!forceCompact) {
+    const absFormatted = new Intl.NumberFormat("en-US", {
+      maximumFractionDigits: decimals,
+      minimumFractionDigits: decimals,
+    }).format(Math.abs(formattedNumber));
+    formattedValue = `${isNegative ? "-" : ""}${absFormatted}`;
+  } else {
+    // Compact number formatting
+    const bnValue = valueToBigNumber(formattedNumber);
+    let integerPlaces = bnValue.abs().toFixed(0).length;
+    if (compactThreshold && Math.abs(number) <= compactThreshold) {
+      integerPlaces = 0;
+    }
+
+    const significantDigitsGroup = Math.min(
+      Math.floor(integerPlaces ? (integerPlaces - 1) / 3 : 0),
+      POSTFIXES.length - 1,
+    );
+
+    const postfix = POSTFIXES[significantDigitsGroup];
+    let compactValue = normalizeBN(
+      bnValue,
+      3 * significantDigitsGroup,
+    ).toNumber();
+
+    if (roundDown) {
+      compactValue =
+        Math.trunc(Number(compactValue) * 10 ** decimals) / 10 ** decimals;
+    } else if (roundUp) {
+      compactValue =
+        Math.ceil(Number(compactValue) * 10 ** decimals) / 10 ** decimals;
+    }
+
+    const prefix = new Intl.NumberFormat("en-US", {
+      maximumFractionDigits: decimals,
+      minimumFractionDigits: decimals,
+    }).format(compactValue);
+
+    formattedValue = `${prefix}${postfix}`;
+  }
+
+  // Build the final formatted string
+  const parts: string[] = [];
+
+  // Add prefix text
+  if (prefixText) {
+    parts.push(prefixText);
+  }
+
+  // Add smaller than indicator
+  if (isSmallerThanMin && showIsSmallerThanMin) {
+    parts.push(number < 0 ? ">" : "<");
+  }
+
+  // Add USD symbol
+  if (symbol?.toLowerCase() === "usd" && !percent) {
+    parts.push("$");
+  }
+
+  // Add the formatted number
+  parts.push(formattedValue);
+
+  // Add percentage symbol
+  if (percent) {
+    parts.push("%");
+  }
+
+  // Add other symbols
+  if (symbol?.toLowerCase() !== "usd" && typeof symbol !== "undefined") {
+    parts.push(" ", symbol);
+  }
+
+  // Add suffix text
+  if (suffixText) {
+    parts.push(suffixText);
+  }
+
+  return parts.join("");
+}
+export const 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 = (
+  value: string | number | undefined,
+  maxDecimal: number,
+): string => {
+  if (!value) return "0";
+  const [integerPart = "0", decimalPart = "0"] = `${value}`.split(".");
+  return `${integerPart}.${decimalPart.substring(0, maxDecimal)}`;
+};

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

@@ -0,0 +1,245 @@
+import { BigNumber } from "bignumber.js";
+import { describe, expect, it } from "vitest";
+
+import { formatNumber } from "./formatNumber";
+
+describe("formatNumber", () => {
+  it("should return empty string for null input by default", () => {
+    const result = formatNumber(null);
+    expect(result).toBe("");
+  });
+
+  it("should return empty string for undefined input by default", () => {
+    const result = formatNumber(undefined);
+    expect(result).toBe("");
+  });
+
+  it("should return ifNullish text for null/undefined when provided", () => {
+    const result1 = formatNumber(null, { ifNullish: "N/A" });
+    expect(result1).toBe("N/A");
+
+    const result2 = formatNumber(undefined, { ifNullish: "No data" });
+    expect(result2).toBe("No data");
+  });
+
+  it("should format basic numbers", () => {
+    const result = formatNumber(123.456);
+    expect(result).toBe("123.46");
+  });
+
+  it("should format negative numbers", () => {
+    const result = formatNumber(-123.456);
+    expect(result).toBe("-123.46");
+  });
+
+  it("should format percentages", () => {
+    const result = formatNumber(0.1234, { percent: true });
+    expect(result).toBe("12.34%");
+  });
+
+  it("should handle zero", () => {
+    const result = formatNumber(0);
+    expect(result).toBe("0");
+  });
+
+  it("should detect and show smaller than minimum values", () => {
+    const result = formatNumber(0.000001, { visibleDecimals: 2 });
+    expect(result).toBe("<0.01");
+  });
+
+  it("should detect and show bigger than maximum values", () => {
+    const result = formatNumber(1000000, { maxValue: 100000 });
+    expect(result).toBe("∞");
+
+    const result2 = formatNumber(-1000000, { maxValue: 100000 });
+    expect(result2).toBe("-∞");
+  });
+
+  it("should use compact notation by default", () => {
+    const result = formatNumber(1500);
+    expect(result).toBe("1.50K");
+  });
+
+  it("should not use compact notation when disabled", () => {
+    const result = formatNumber(1500, { compact: false });
+    expect(result).toBe("1,500.00");
+  });
+
+  it("should respect compact threshold", () => {
+    const result = formatNumber(500, { compactThreshold: 1000 });
+    expect(result).toBe("500.00");
+  });
+
+  it("should handle rounding down", () => {
+    const result = formatNumber(123.789, {
+      visibleDecimals: 2,
+      roundDown: true,
+      compact: false,
+    });
+    expect(result).toBe("123.78");
+  });
+
+  it("should handle rounding up", () => {
+    const result = formatNumber(123.781, {
+      visibleDecimals: 2,
+      roundUp: true,
+      compact: false,
+    });
+    expect(result).toBe("123.79");
+  });
+
+  it("should auto-determine decimals for large numbers", () => {
+    const result = formatNumber(1000, { compact: false });
+    expect(result).toBe("1,000.00");
+  });
+
+  it("should auto-determine decimals for small numbers", () => {
+    const result = formatNumber(0.123456789, { compact: false });
+    expect(result).toBe("0.1234568");
+  });
+
+  it("should handle USD symbol", () => {
+    const result = formatNumber(123.45, { symbol: "USD", compact: false });
+    expect(result).toBe("$123.45");
+  });
+
+  it("should handle other symbols", () => {
+    const result = formatNumber(123.45, { symbol: "ETH", compact: false });
+    expect(result).toBe("123.45 ETH");
+  });
+
+  it("should handle BigNumber input", () => {
+    const input = new BigNumber("123.456");
+    const result = formatNumber(input);
+    expect(result).toBe("123.46");
+  });
+
+  it("should handle string input", () => {
+    const result = formatNumber("123.456");
+    expect(result).toBe("123.46");
+  });
+
+  it("should handle prefix text", () => {
+    const result = formatNumber(123.45, {
+      prefixText: "Value: ",
+      compact: false,
+    });
+    expect(result).toBe("Value: 123.45");
+  });
+
+  it("should handle suffix text", () => {
+    const result = formatNumber(123.45, { suffixText: " USD", compact: false });
+    expect(result).toBe("123.45 USD");
+  });
+
+  it("should handle percentage with symbol", () => {
+    const result = formatNumber(0.1234, { percent: true, compact: false });
+    expect(result).toBe("12.34%");
+  });
+
+  it("should handle USD symbol with percentage (no $ shown)", () => {
+    const result = formatNumber(0.1234, {
+      symbol: "USD",
+      percent: true,
+      compact: false,
+    });
+    expect(result).toBe("12.34%");
+  });
+
+  it("should show smaller than indicator for positive small values", () => {
+    const result = formatNumber(0.000001, {
+      visibleDecimals: 2,
+      compact: false,
+    });
+    expect(result).toBe("<0.01");
+  });
+
+  it("should show greater than indicator for negative small values", () => {
+    const result = formatNumber(-0.000001, {
+      visibleDecimals: 2,
+      compact: false,
+    });
+    expect(result).toBe(">-0.01");
+  });
+
+  it("should not show smaller than indicator when disabled", () => {
+    const result = formatNumber(0.000001, {
+      visibleDecimals: 2,
+      compact: false,
+      showIsSmallerThanMin: false,
+    });
+    expect(result).toBe("0.01");
+  });
+
+  it("should handle all options together", () => {
+    const result = formatNumber(123.45, {
+      prefixText: "Price: ",
+      suffixText: " total",
+      symbol: "USD",
+      compact: false,
+    });
+    expect(result).toBe("Price: $123.45 total");
+  });
+
+  it("should format compact numbers with K postfix", () => {
+    const result = formatNumber(1500, { visibleDecimals: 2 });
+    expect(result).toBe("1.50K");
+  });
+
+  it("should not use compact when not needed", () => {
+    const result = formatNumber(900, { visibleDecimals: 2 });
+    expect(result).toBe("900.00");
+  });
+
+  it("should format compact numbers with M postfix", () => {
+    const result = formatNumber(1500000, { visibleDecimals: 2 });
+    expect(result).toBe("1.50M");
+  });
+
+  it("should format compact numbers with B postfix", () => {
+    const result = formatNumber(1500000000, { visibleDecimals: 2 });
+    expect(result).toBe("1.50B");
+  });
+
+  it("should handle compact rounding down", () => {
+    const result = formatNumber(1237, { visibleDecimals: 2, roundDown: true });
+    expect(result).toBe("1.23K");
+  });
+
+  it("should handle compact rounding up", () => {
+    const result = formatNumber(1232, { visibleDecimals: 2, roundUp: true });
+    expect(result).toBe("1.24K");
+  });
+});
+
+describe("FormatNumber Edge cases", () => {
+  it("should handle very large numbers", () => {
+    const result = formatNumber(1e21);
+    expect(result).toContain("Z");
+  });
+
+  it("should handle very small positive numbers", () => {
+    const result = formatNumber(1e-10, { compact: false });
+    expect(result).toContain("<");
+  });
+
+  it("should handle very small negative numbers", () => {
+    const result = formatNumber(-1e-10, { compact: false });
+    expect(result).toContain(">");
+  });
+
+  it("should handle infinity", () => {
+    const result = formatNumber(Number.POSITIVE_INFINITY);
+    expect(result).toBe("Infinity");
+  });
+
+  it("should handle negative infinity", () => {
+    const result = formatNumber(Number.NEGATIVE_INFINITY);
+    expect(result).toBe("-Infinity");
+  });
+
+  it("should handle NaN", () => {
+    const result = formatNumber(Number.NaN);
+    expect(result).toBe("NaN");
+  });
+});