@berachain/berajs 0.1.2 → 0.2.1

package/src/types/staking.d.ts

@@ -0,0 +1,22 @@
+import type { TokenWithMetadata } from "./dex";
+
+export interface ProtocolMetadata {
+  name: string;
+  logoURI: string;
+  url: string;
+  description: string;
+  tags?: string[];
+}
+
+/**
+ * Configuration for a single staking option.
+ * Maps receipt tokens to their accepted input tokens.
+ */
+export type StakingConfig = {
+  /** Unique identifier for this staking config */
+  id: string;
+  /** The token received when staking (e.g., sWBERA, siBERA) */
+  receiptToken: TokenWithMetadata;
+  /** Tokens that can be staked to receive the receipt token */
+  inputTokens: TokenWithMetadata[];
+};

package/src/utils/createEmitter.ts

@@ -0,0 +1,122 @@
+interface EventsMap {
+  [event: string]: any;
+}
+
+interface DefaultEvents extends EventsMap {
+  [event: string]: (...args: any) => void;
+}
+
+export type Unsubscribe = () => void;
+
+export interface Emitter<Events extends EventsMap = DefaultEvents> {
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * ```js
+   * ee.emit('tick', tickType, tickDuration)
+   * ```
+   *
+   * @param event The event name.
+   * @param args The arguments for listeners.
+   */
+  emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): void;
+
+  /**
+   * Add a listener for a given event.
+   *
+   * ```js
+   * const unbind = ee.on('tick', (tickType, tickDuration) => {
+   *   count += 1
+   * })
+   *
+   * disable () {
+   *   unbind()
+   * }
+   * ```
+   *
+   * @param event The event name.
+   * @param cb The listener function.
+   * @returns Unbind listener from event.
+   */
+  on<K extends keyof Events>(event: K, cb: Events[K]): Unsubscribe;
+  events: Partial<{ [E in keyof Events]: Events[E][] }>;
+}
+
+/**
+ * An interface for mixins that expose the `on` function (without the emitter
+ * bound to `this`)
+ *
+ * ```js
+ * import { createEmitter } from '~utils/createEmitter'
+ *
+ * class Ticker implements EmitterMixin<Events> {
+ *   constructor() {
+ *     this.emitter = createEmitter()
+ *   }
+ *   on(...args) {
+ *     return this.emitter.on(...args)
+ *   }
+ *   tick() {
+ *     this.emitter.emit('tick')
+ *   }
+ * }
+ * ```
+ */
+export interface EmitterMixin<Events extends EventsMap = DefaultEvents> {
+  on<K extends keyof Events>(event: K, cb: Events[K]): Unsubscribe;
+}
+
+/**
+ * Create event emitter.
+ *
+ * ```js
+ * import { createEmitter } from '~/utils/createEmitter'
+ *
+ * class Ticker {
+ *   constructor() {
+ *     this.emitter = createEmitter()
+ *   }
+ *   on(...args) {
+ *     return this.emitter.on(...args)
+ *   }
+ *   tick() {
+ *     this.emitter.emit('tick')
+ *   }
+ * }
+ * ```
+ *
+ * Inspired by {@link https://github.com/ai/nanoevents}
+ */
+export function createEmitter<
+  Events extends EventsMap = DefaultEvents,
+>(): Emitter<Events> {
+  /**
+   * Event names in keys and arrays with listeners in values.
+   *
+   * ```js
+   * emitter1.events = emitter2.events
+   * emitter2.events = { }
+   * ```
+   */
+  const events: Partial<{ [E in keyof Events]: Events[E][] }> = {};
+
+  return {
+    emit(event, ...args) {
+      for (const callback of events[event] || []) {
+        callback(...args);
+      }
+    },
+    events,
+    on(event, cb) {
+      if (!events[event]) {
+        events[event] = [];
+      }
+
+      events[event].push(cb);
+
+      return () => {
+        events[event] = events[event]?.filter((i) => cb !== i);
+      };
+    },
+  };
+}

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

@@ -0,0 +1,149 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createEmitter } from "./createEmitter.js";
+
+describe("createEmitter", () => {
+  it("is empty from the beginning", () => {
+    const ee = createEmitter();
+    expect(ee.events).toEqual({});
+  });
+
+  it("adds listeners", () => {
+    const ee = createEmitter();
+
+    ee.on("one", () => true);
+    ee.on("two", () => true);
+    ee.on("two", () => true);
+
+    expect(Object.keys(ee.events)).toEqual(["one", "two"]);
+    expect(ee.events.one?.length).toEqual(1);
+    expect(ee.events.two?.length).toEqual(2);
+  });
+
+  it("calls listener", () => {
+    const ee = createEmitter();
+    const calls: number[][] = [];
+    ee.on("event", (...args) => {
+      calls.push(args);
+    });
+
+    ee.emit("event");
+    ee.emit("event", 11);
+    ee.emit("event", 21, 22);
+    ee.emit("event", 31, 32, 33);
+    ee.emit("event", 41, 42, 43, 44);
+
+    expect(calls).toEqual([[], [11], [21, 22], [31, 32, 33], [41, 42, 43, 44]]);
+  });
+
+  it("unbinds listener", () => {
+    const ee = createEmitter();
+
+    const calls1: number[] = [];
+    const unbind = ee.on("event", (a) => {
+      calls1.push(a);
+    });
+
+    const calls2: number[] = [];
+    ee.on("event", (a) => {
+      calls2.push(a);
+    });
+
+    ee.emit("event", 1);
+    unbind();
+    ee.emit("event", 2);
+
+    expect(calls1).toEqual([1]);
+    expect(calls2).toEqual([1, 2]);
+  });
+
+  it("calls unbind after cleaning events", () => {
+    const ee = createEmitter();
+    const unbind = ee.on("event", () => undefined);
+    ee.events = {};
+    expect(() => {
+      unbind();
+    }).not.toThrow();
+  });
+
+  it("removes event on no listeners", () => {
+    const ee = createEmitter();
+    const unbind1 = ee.on("one", () => {});
+    const unbind2 = ee.on("one", () => {});
+
+    unbind1();
+    expect(ee.events.one?.length).toEqual(1);
+
+    unbind1();
+    expect(ee.events.one?.length).toEqual(1);
+
+    unbind2();
+    expect(ee.events.one?.length).toEqual(0);
+
+    unbind2();
+    expect(ee.events.one?.length).toEqual(0);
+  });
+
+  it("removes listener during event", () => {
+    const ee = createEmitter();
+
+    const calls: number[] = [];
+    const remove1 = ee.on("event", () => {
+      remove1();
+      calls.push(1);
+    });
+    ee.on("event", () => {
+      calls.push(2);
+    });
+
+    ee.emit("event");
+    expect(calls).toEqual([1, 2]);
+  });
+
+  it("allows to use arrow function to bind a context", () => {
+    const ee = createEmitter();
+    const app = {
+      check: ["a"],
+
+      getListener() {
+        return () => {
+          this.check = this.value.split("");
+        };
+      },
+
+      value: "test",
+    };
+
+    const unbind = ee.on("event", app.getListener());
+
+    expect(() => {
+      ee.emit("event");
+    }).not.toThrow();
+
+    expect(app.check).toEqual(["t", "e", "s", "t"]);
+
+    unbind();
+  });
+
+  it("allows to replace listeners", () => {
+    const ee1 = createEmitter<{ A: () => void; B: () => void }>();
+    const ee2 = createEmitter<{ A: () => void; B: () => void }>();
+
+    const aSpy = vi.fn();
+    ee1.on("A", aSpy);
+    const bSpy = vi.fn();
+    ee2.on("B", bSpy);
+
+    ee1.events = ee2.events;
+
+    ee1.emit("A");
+    expect(aSpy).toHaveBeenCalledTimes(1);
+
+    ee1.emit("B");
+    expect(bSpy).toHaveBeenCalledTimes(0);
+
+    ee2.emit("B");
+    expect(bSpy).toHaveBeenCalledTimes(1);
+    expect(aSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/utils/{index.ts → exports.ts}

@@ -1,7 +1,6 @@
 export { defaultFlags as defaultBeraFlags } from "../contexts/BeraFlags/defaultFlags";
 export * from "./beraFetch";
 export * from "./constants";
-export * from "./formatAggregatorsQuotes";
 export * from "./formatInputTokenValue";
 export * from "./formatNumber";
 export * from "./formatTimestamps";
@@ -12,9 +11,11 @@ export * from "./getServerSideClient";
 export { getTestClient } from "./getTestClient";
 export * from "./isDifferenceExceedingThreshold";
 export * from "./isSubgraphStale";
+export * from "./layerZeroScan";
+export * from "./math";
 export * from "./parseBaseArgs";
+export * from "./parseWhiskToken";
 export * from "./pythHoneyUtils";
-export { sentryBeforeSend } from "./sentryBeforeSend";
 export * from "./time";
 export {
   beraToken as internal_beraToken,

package/src/utils/filter.ts

@@ -0,0 +1,34 @@
+/**
+ * Filters data to get one data point per day
+ * @param data - The data to filter
+ * @returns The filtered data
+ */
+export const dailyResolution = <
+  T extends { timestamp?: number; _timestamp?: number },
+>(
+  data: T[],
+) => {
+  // Filter to get one data point per day
+  const dailyData: T[] = [];
+  let lastDay = "";
+
+  for (const item of data) {
+    if (!item.timestamp && !item._timestamp) continue;
+    // Convert Unix timestamp (seconds) to milliseconds for Date constructor
+    const timestampMs = (item?.timestamp ?? item?._timestamp ?? 0) * 1000;
+    const currentDay = new Date(timestampMs);
+    const currentDayStr = currentDay.toDateString();
+    if (currentDayStr !== lastDay) {
+      const newTimestamp =
+        new Date(currentDay.setHours(0, 0, 0, 0)).getTime() / 1000;
+      dailyData.push({
+        ...item,
+        timestamp: newTimestamp,
+        _timestamp: newTimestamp,
+      });
+      lastDay = currentDayStr;
+    }
+  }
+
+  return dailyData;
+};

package/src/utils/formatNumber.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from "bignumber.js";
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
 export type BigNumberValue = string | number | BigNumber;
 

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

@@ -1,6 +1,7 @@
-import { BigNumber } from "bignumber.js";
 import { describe, expect, it } from "vitest";
 
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
 import { formatNumber } from "./formatNumber";
 
 describe("formatNumber", () => {

package/src/utils/formatTokenList.ts

@@ -1,4 +1,4 @@
-import type { Token, TokenWithMetadata } from "../types";
+import type { Token, TokenWithMetadata } from "../types/dex";
 import { isToken } from "./tokens";
 
 export interface FormatTokenListReturnType {
@@ -19,11 +19,9 @@ export interface FormatTokenListReturnType {
 function formatTokenList({
   defaultTokenList = [],
   externalList = [],
-  chainId,
 }: {
   defaultTokenList: TokenWithMetadata[];
   externalList?: Token[];
-  chainId: number;
 }): FormatTokenListReturnType {
   if (defaultTokenList.length === 0) {
     return {
@@ -33,13 +31,9 @@ function formatTokenList({
     };
   }
 
-  const defaultList = defaultTokenList
-    .filter(
-      (token) => !token.chainId || Number(token.chainId) === Number(chainId),
-    )
-    .map((token) => {
-      return { ...token, default: true };
-    });
+  const defaultList = defaultTokenList.map((token) => {
+    return { ...token, default: true };
+  });
 
   const featuredTokenList = defaultList.filter((token) => {
     return token.tags?.some((tag) => tag === "featured");

package/src/utils/getHoneySwapMessage.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import type { IHoneySwapState } from "@berachain/berajs/hooks";
-
+import type { IHoneySwapState } from "~/hooks/honey/useHoneySwapState";
 import { getHoneySwapMessage as getMessage } from "./getHoneySwapMessage";
 
 describe("getMessage", () => {

package/src/utils/getServerSideClient.ts

@@ -1,13 +1,12 @@
 import { createPublicClient, fallback, http, type PublicClient } from "viem";
+import { berachain, berachainBepolia } from "viem/chains";
 
 import {
-  type ChainId,
+  ChainId,
   defaultChainId,
   getRpcUrls,
 } from "@berachain/config/internal";
 
-import { defaultBeraNetworkConfig } from "@berachain/wagmi/config";
-
 /**
  * This is a singleton to avoid creating a new client for each request.
  *
@@ -37,9 +36,9 @@ export const getServerSidePublicClient = (
   if (fallbackTransports.length === 0) {
     fallbackTransports.push(http());
   }
-
+  const chain = chainId === ChainId.MAINNET ? berachain : berachainBepolia;
   const client = createPublicClient({
-    chain: defaultBeraNetworkConfig.chain,
+    chain,
     transport: fallback(fallbackTransports),
   });
 

package/src/utils/isDifferenceExceedingThreshold.ts

@@ -1,4 +1,4 @@
-import BigNumber from "bignumber.js";
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
 export const isDifferenceExceedingThreshold = (
   initialAmount: string,

package/src/utils/layerZeroScan.ts

@@ -0,0 +1,122 @@
+import { BeraError } from "../errors/BeraError";
+import { InvalidArgumentError } from "../errors/InvalidArgumentError";
+import { RequestError } from "../errors/RequestError";
+import { beraFetchJson } from "./beraFetch";
+
+const LAYERZERO_SCAN_MAINNET_URL = "https://api-mainnet.layerzero-scan.com";
+
+export enum LayerZeroMessageStatus {
+  INFLIGHT = "INFLIGHT",
+  DELIVERED = "DELIVERED",
+  FAILED = "FAILED",
+}
+
+export type LayerZeroMessage = {
+  srcUaAddress: string;
+  dstUaAddress: string;
+  srcChainId: number;
+  dstChainId: number;
+  dstTxHash?: string;
+  dstTxError?: string;
+  srcTxHash?: string;
+  srcBlockHash?: string;
+  srcBlockNumber?: string;
+  srcUaNonce: number;
+  status: LayerZeroMessageStatus;
+};
+
+export type LayerZeroDeliveredMessage = LayerZeroMessage & {
+  dstTxHash: string;
+};
+
+type GetMessagesBySrcTxHashResponse = {
+  messages: LayerZeroMessage[];
+};
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function getMessagesBySrcTxHash(
+  srcTxHash: string,
+): Promise<GetMessagesBySrcTxHashResponse> {
+  return beraFetchJson<GetMessagesBySrcTxHashResponse>({
+    url: `${LAYERZERO_SCAN_MAINNET_URL}/tx/${srcTxHash}`,
+    type: "rest",
+    name: "LayerZero Scan",
+  });
+}
+
+export type WaitForMessageReceivedOptions = {
+  pollInterval?: number;
+  timeout?: number;
+};
+
+/**
+ * Polls LayerZero scan API until the cross-chain message is delivered or fails.
+ * HTTP errors are silently retried until timeout.
+ *
+ * @param srcTxHash - The source transaction hash to track
+ * @param options - Configuration options
+ * @param options.pollInterval - Polling interval in ms (default: 3000)
+ * @param options.timeout - Timeout in ms (default: 600000 / 10 minutes)
+ * @returns The delivered message with destination tx hash
+ * @throws InvalidArgumentError if srcTxHash is missing
+ * @throws BeraError if message fails, times out, or multiple messages found
+ */
+export async function waitForLayerZeroMessageReceived(
+  srcTxHash: string,
+  options: WaitForMessageReceivedOptions = {},
+): Promise<LayerZeroDeliveredMessage> {
+  const { pollInterval = 3000, timeout = 600_000 } = options;
+
+  if (!srcTxHash) {
+    throw new InvalidArgumentError({
+      property: "srcTxHash",
+      value: srcTxHash,
+      expected: "string",
+    });
+  }
+
+  const startTime = Date.now();
+
+  while (true) {
+    // check timeout
+    if (Date.now() - startTime > timeout) {
+      throw new BeraError({
+        message: `LayerZero message tracking timed out after ${timeout}ms`,
+        reason: "LAYERZERO_TIMEOUT",
+        level: "warning",
+      });
+    }
+
+    try {
+      const { messages } = await getMessagesBySrcTxHash(srcTxHash);
+      const message = messages[0];
+
+      if (messages.length > 1) {
+        throw new BeraError({
+          message: "More than one LayerZero message found for transaction",
+          reason: "LAYERZERO_MULTIPLE_MESSAGES",
+        });
+      }
+
+      if (message?.status === LayerZeroMessageStatus.FAILED) {
+        throw new BeraError({
+          message: `LayerZero message failed: ${message.dstTxError}`,
+          reason: "LAYERZERO_MESSAGE_FAILED",
+        });
+      }
+
+      if (message?.status === LayerZeroMessageStatus.DELIVERED) {
+        return message as LayerZeroDeliveredMessage;
+      }
+    } catch (error) {
+      // re-throw non-retryable errors (validation, timeout, failed message)
+      // but allow RequestError to retry (network issues, temporary API errors)
+      if (error instanceof BeraError && !(error instanceof RequestError)) {
+        throw error;
+      }
+    }
+
+    await sleep(pollInterval);
+  }
+}

package/src/utils/math.ts

@@ -1,4 +1,4 @@
-import BigNumber from "bignumber.js";
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
 /**
  * Compute the price impact of a swap

package/src/utils/parseWhiskToken.ts

@@ -0,0 +1,15 @@
+import type { TokenInfoFragmentFragment } from "@berachain/graphql/bend/whisk";
+
+import type { TokenWithMetadata } from "~/types/dex";
+
+/**
+ * Parse a token from the Whisk API into a TokenWithMetadata object.
+ *
+ * @returns
+ */
+export function parseWhiskToken(token: TokenInfoFragmentFragment) {
+  return {
+    ...token,
+    chainId: token.chain.id,
+  } as const satisfies TokenWithMetadata;
+}

package/src/utils/poolNamings.ts

@@ -1,7 +1,7 @@
 import { PoolType } from "@berachain-foundation/berancer-sdk";
 import { formatUnits } from "viem";
 
-import type { Token } from "~/types";
+import type { Token } from "~/types/dex";
 
 // Utility function to sort tokens by their address without modifying the original array
 const sortTokensByAddress = (tokens: Token[]): Token[] => {

package/src/utils/tokens.ts

@@ -1,6 +1,6 @@
 import { type Address, ethAddress, isAddress, zeroAddress } from "viem";
 
-import mainnet from "@berachain/config/mainnet";
+import { mainnet } from "@berachain/config/mainnet";
 
 import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
 import type { TokenWithMetadata } from "../types/dex";
@@ -13,23 +13,24 @@ export const beraToken = {
   symbol: "BERA",
   logoURI:
     "https://res.cloudinary.com/duv0g402y/image/upload/v1738720154/brand/berachain-chain-logo.png.png",
-} as const satisfies TokenWithMetadata;
+} as const satisfies Omit<TokenWithMetadata, "chainId">;
 
 export const wBeraToken = {
   address: mainnet.tokens.wbera,
   decimals: 18,
   name: "WBera",
   symbol: "WBERA",
-} as const satisfies TokenWithMetadata;
+} as const satisfies Omit<TokenWithMetadata, "chainId">;
 
 export function getHoneyToken(baseArgs: BeraJS.BaseFunctionArgs) {
-  const { config } = parseBaseArgs(baseArgs);
+  const { config, chainId } = parseBaseArgs(baseArgs);
 
   return {
     address: config.honey.token,
     symbol: "HONEY",
     name: "Honey",
     decimals: 18,
+    chainId,
   } as const satisfies TokenWithMetadata;
 }
 
@@ -46,7 +47,9 @@ type InputToken = BaseToken | string | undefined;
 type IsTokenParams =
   | [
       token: InputToken,
-      compareTo: BaseToken | Extract<KnownTokens, "BERA" | "WBERA" | "ETH">,
+      compareTo:
+        | BaseToken
+        | Extract<KnownTokens, "BERA" | "WBERA" | "ETH" | "SWBERA">,
     ]
   | [
       token: InputToken,
@@ -61,7 +64,12 @@ export function isToken(...args: IsTokenParams): boolean {
 
   const tokenAddress = typeof token === "string" ? token : token.address;
 
-  if (typeof compareTo === "string" && !isAddress(compareTo)) {
+  if (
+    typeof compareTo === "string" &&
+    !isAddress(compareTo) &&
+    // this is a safeguard against weird inputs from enso. `0x00`
+    !compareTo.startsWith("0x")
+  ) {
     if (compareTo === "BERA") {
       return tokenAddress.toLowerCase() === zeroAddress;
     }
@@ -74,13 +82,21 @@ export function isToken(...args: IsTokenParams): boolean {
       return tokenAddress.toLowerCase() === ethAddress;
     }
 
+    if (compareTo === "SWBERA") {
+      // we are sure that wbera token is the same on all chains because it's checked on the config and forced as types
+      return tokenAddress.toLowerCase() === mainnet.tokens.swbera.toLowerCase();
+    }
+
     if (baseArgs === undefined) {
       throw new InvalidArgumentError({
         property: "baseArgs",
         value: baseArgs,
         expected: "BeraJS.BaseFunctionArgs",
         message:
-          "baseArgs is required when compared to a known token different than BERA or WBERA",
+          "baseArgs is required when compared to a known token different than BERA or WBERA. Checking against token: " +
+          compareTo +
+          " and token address: " +
+          tokenAddress,
       });
     }
     const { config } = parseBaseArgs(baseArgs);