@berachain/berajs 0.1.0 → 0.1.2

package/src/actions/clients/getApolloClient.ts

@@ -0,0 +1,109 @@
+import { InMemoryCache, type InMemoryCacheConfig } from "@apollo/client";
+import { HttpLink } from "@apollo/client/link/http";
+
+import type { HttpLink as BeraConfigHttpLink } from "@berachain/config";
+import { getUriFromLink } from "@berachain/config";
+import { currentDapp } from "@berachain/config/internal";
+
+import apiResults from "@berachain/graphql/dex/api";
+
+import { BeraError } from "~/errors/BeraError";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { BeraApolloClient } from "./BeraApolloClient";
+
+/**
+ * If currentDapp is set, it will add the stellate client name and version to the headers.
+ * @see {@link https://stellate.co/docs/graphql-metrics/tracking/clients}
+ */
+function applyStellateClientName(url: BeraConfigHttpLink): BeraConfigHttpLink {
+  if (!currentDapp) {
+    return url;
+  }
+  const headers = typeof url === "string" ? undefined : url.headers;
+  return {
+    uri: getUriFromLink(url),
+    headers: {
+      ...headers,
+      "x-graphql-client-name": `berachain.${currentDapp}.${process.env.NEXT_RUNTIME || "browser"}`,
+      "x-graphql-client-version": `${process.env.VERCEL_TARGET_ENV}.${process.env.VERCEL_GIT_COMMIT_SHA}`,
+    },
+  };
+}
+
+export { gql } from "@apollo/client";
+
+function getClient(
+  endpoint: BeraConfigHttpLink,
+  {
+    ssrMode,
+    inMemoryCacheOptions,
+  }: {
+    ssrMode?: boolean;
+    inMemoryCacheOptions?: InMemoryCacheConfig;
+  } = {},
+) {
+  const url = getUriFromLink(endpoint);
+  const headers = typeof endpoint === "string" ? undefined : endpoint.headers;
+
+  return new BeraApolloClient({
+    url,
+    link: new HttpLink({
+      uri: url,
+      headers,
+    }),
+    defaultOptions: {
+      query: {
+        // With the default none error policy, an error causes the promise to reject.
+        errorPolicy: "none",
+        fetchPolicy: "no-cache",
+      },
+    },
+    cache: new InMemoryCache(inMemoryCacheOptions),
+    ssrMode,
+  });
+}
+
+type GraphqlClient =
+  | "honey.subgraph"
+  | "pol.subgraph"
+  | "governance.subgraph"
+  | "blocks.subgraph"
+  | "bex.subgraph"
+  | "api"
+  | "bend.whisk";
+
+export function getApolloClient(
+  clientName: GraphqlClient,
+  { ...args }: BeraJS.BaseFunctionArgs,
+): BeraApolloClient {
+  const { config } = parseBaseArgs(args);
+
+  switch (clientName) {
+    case "api":
+      return getClient(applyStellateClientName(config.api), {
+        inMemoryCacheOptions: {
+          possibleTypes: apiResults.possibleTypes,
+        },
+      });
+
+    case "bend.whisk":
+      if (!config.bend.whiskApi) {
+        throw new BeraError({
+          message: "Bend whisk API is not configured on this chain",
+          level: "error",
+        });
+      }
+      return getClient(config.bend.whiskApi);
+
+    case "honey.subgraph":
+      return getClient(config.honey.subgraph);
+    case "pol.subgraph":
+      return getClient(config.pol.subgraph);
+    case "governance.subgraph":
+      return getClient(config.governance.subgraph);
+    case "blocks.subgraph":
+      return getClient(config.blocksSubgraph);
+    case "bex.subgraph":
+      return getClient(config.bex.subgraph);
+  }
+}

package/src/actions/clients/getEnsoClient.ts

@@ -0,0 +1,24 @@
+import { EnsoClient } from "@ensofinance/sdk";
+
+import { appConfig } from "@berachain/config/internal";
+
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+const isProduction =
+  process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test";
+
+export function getEnsoClient({
+  useProxy = isProduction,
+  ...args
+}: BeraJS.BaseFunctionArgs & { useProxy?: boolean } = {}) {
+  const { config } = parseBaseArgs(args);
+  return new EnsoClient({
+    baseURL: useProxy
+      ? `${config.bex.aggregatorsProxyUrl}/enso/api/v1/`
+      : undefined,
+    apiKey: useProxy
+      ? // no API key since proxy has CORS for .berachain.com domains
+        ""
+      : appConfig.apiKeys.public.enso,
+  });
+}

package/src/actions/dex/__tests__/aggregators.unit.test.ts

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, test } from "vitest";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { BeraError } from "~/errors/BeraError";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import { BaseAggregator } from "../aggregators/base";
+
+// Test implementation of BaseAggregator to access protected methods
+class TestAggregator extends BaseAggregator {
+  name = Aggregators.Fly;
+  readonly type = "rest";
+  supportedChains = [ChainId.MAINNET];
+
+  async getQuote(_args: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    throw new Error("Not implemented for testing");
+  }
+
+  // expose the protected method for testing
+  public testGetAmountAfterFees(
+    amount: string,
+    aggregatorsFeeBps?: number,
+  ): string {
+    return this.getAmountAfterFees(amount, aggregatorsFeeBps);
+  }
+}
+
+describe("BaseAggregator.getAmountAfterFees", () => {
+  let testAggregator: TestAggregator;
+
+  beforeEach(() => {
+    testAggregator = new TestAggregator();
+  });
+
+  test("should throw BeraError when aggregatorsFeeBps is undefined", () => {
+    expect(() => {
+      testAggregator.testGetAmountAfterFees("1000000000000000000");
+    }).toThrow(BeraError);
+
+    try {
+      testAggregator.testGetAmountAfterFees("1000000000000000000");
+    } catch (error) {
+      expect(error).toBeInstanceOf(BeraError);
+      expect((error as BeraError).message).toBe(
+        "aggregatorsFeeBps is required",
+      );
+      expect((error as BeraError).level).toBe("error");
+    }
+  });
+
+  test("should calculate fees correctly with normal values", () => {
+    // 1 ETH (18 decimals) with 1% fee (100 bps)
+    const amount = "1000000000000000000"; // 1 ETH
+    const feeBps = 100; // 1%
+
+    const result = testAggregator.testGetAmountAfterFees(amount, feeBps);
+
+    // Expected: 1 ETH - (1 ETH * 100 / 10000) = 1 ETH - 0.01 ETH = 0.99 ETH
+    const expected = "990000000000000000";
+    expect(result).toBe(expected);
+  });
+
+  test("should handle specific amount with 10% bps", () => {
+    // example from Bany
+    const amount = "8173367508422477769";
+    const feeBps = 10; // 0.1%
+
+    const result = testAggregator.testGetAmountAfterFees(amount, feeBps);
+    expect(result).toBe("8165194140914055292");
+  });
+
+  test("should handle zero fee correctly", () => {
+    const amount = "1000000000000000000";
+    const result = testAggregator.testGetAmountAfterFees(amount, 0);
+
+    // With 0% fee, should return the original amount
+    expect(result).toBe(amount);
+  });
+
+  test("should handle zero amount correctly", () => {
+    const result = testAggregator.testGetAmountAfterFees("0", 100);
+
+    // Zero amount with any fee should still be zero
+    expect(result).toBe("0");
+  });
+
+  test("should handle maximum possible fee (100%)", () => {
+    const amount = "1000000000000000000";
+    const feeBps = 10000; // 100%
+
+    const result = testAggregator.testGetAmountAfterFees(amount, feeBps);
+
+    // 100% fee should result in 0
+    expect(result).toBe("0");
+  });
+
+  test("should round fees down to nearest integer", () => {
+    // Amount that will produce fractional fees
+    const amount = "999";
+    const feeBps = 33; // 0.33%
+
+    const result = testAggregator.testGetAmountAfterFees(amount, feeBps);
+
+    // Fee calculation: 999 * 33 / 10000 = 3.2967 -> rounds to 3
+    // Result: 999 - 3 = 996
+    expect(result).toBe("996");
+  });
+});

package/src/actions/dex/__tests__/allPools.integration.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+
+import { getAllPools } from "../getAllPools";
+
+describe("allPools", async () => {
+  const pools = await getAllPools({
+    textSearch: "",
+  });
+
+  it("should return all pools", () => {
+    expect(pools.pools.length).toBeGreaterThan(0);
+  });
+});

package/src/actions/dex/__tests__/getOnChainPool.unit.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { getOnChainPool } from "../getOnChainPool";
+
+describe("getOnChainPool", () => {
+  it("should fail on invalid pool id", async () => {
+    const invalidPoolPromise = getOnChainPool({
+      poolId:
+        "0x4e7ab786f93737026711ab3165aac911746b6613000000000000000000000011",
+      publicClient: getServerSidePublicClient(),
+    });
+    await expect(invalidPoolPromise).rejects.toThrowError();
+  });
+});

package/src/actions/dex/__tests__/haiku.integration.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+
+import { ChainId, defaultChainId } from "@berachain/config/internal";
+
+import { assertAddress } from "~/errors/assert";
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+describe.runIf(defaultChainId === ChainId.MAINNET)("haiku", () => {
+  const { config } = parseBaseArgs({ chainId: defaultChainId });
+  const publicClient = getServerSidePublicClient();
+
+  it("should have a matching haikuAgentAddress computed from haikuRouter.calcAgent", async () => {
+    assertAddress(config.bex.haikuRouter, "haikuRouter");
+    assertAddress(
+      config.bex.aggregatorsRouterExecutor,
+      "aggregatorsRouterExecutor",
+    );
+    assertAddress(config.bex.haikuAgentAddress, "haikuAgentAddress");
+    const abi = [
+      {
+        inputs: [{ internalType: "address", name: "user", type: "address" }],
+        name: "calcAgent",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+      },
+    ] as const;
+    const computedAgentAddress = await publicClient.readContract({
+      address: config.bex.haikuRouter,
+      abi,
+      functionName: "calcAgent",
+      args: [config.bex.aggregatorsRouterExecutor],
+    });
+
+    expect(computedAgentAddress.toLowerCase()).toBe(
+      config.bex.haikuAgentAddress?.toLowerCase(),
+    );
+  });
+});

package/src/actions/dex/aggregators/base.ts

@@ -0,0 +1,174 @@
+import { BigNumber } from "bignumber.js";
+import { type Address, isAddress, zeroAddress } from "viem";
+
+import type { BeraConfig, ChainId } from "@berachain/config/internal";
+
+import { BeraError } from "~/errors/BeraError";
+import { initBeraError } from "~/errors/initBeraError";
+import type {
+  Aggregators,
+  IAggregatorArgs,
+  IRawAggregatorQuote,
+} from "~/types/dex";
+import { beraFetch } from "~/utils/beraFetch";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { isToken } from "~/utils/tokens";
+
+export abstract class BaseAggregator {
+  abstract name: Aggregators;
+  abstract supportedChains: ChainId[];
+  static PATH_NOT_FOUND_REASON = "NO_SWAP_PATHS";
+
+  notFoundMessages: string[] = [];
+
+  config: BeraConfig;
+
+  chainId: ChainId;
+  constructor(args: BeraJS.BaseFunctionArgs = {}) {
+    const { config, chainId } = parseBaseArgs(args);
+    this.config = config;
+    this.chainId = chainId;
+  }
+
+  /**
+   * Identifies the url of the last sent request. Might not have all query params.
+   * Mainly used for error reporting.
+   */
+  url: string = "";
+  abstract readonly type: "rest" | "graphql" | "rpc";
+
+  abstract getQuote(
+    args: IAggregatorArgs,
+  ):
+    | Promise<IRawAggregatorQuote | undefined>
+    | Promise<IRawAggregatorQuote<false> | undefined>;
+
+  /**
+   * return wbera for native tokens to accomodate the aggregator's router logic
+   */
+  protected parseAddresses(
+    tokenIn: string,
+    tokenOut: string,
+  ): {
+    tokenInAddress: Address;
+    tokenOutAddress: Address;
+    isTokenInNative: boolean;
+    isTokenOutNative: boolean;
+  } {
+    if (!isAddress(tokenIn) || !isAddress(tokenOut)) {
+      throw new BeraError({
+        message: `Invalid address: ${tokenIn} or ${tokenOut}`,
+        level: "error",
+      });
+    }
+
+    return {
+      tokenInAddress: isToken(tokenIn, "BERA")
+        ? this.config.tokens.wbera
+        : tokenIn,
+      tokenOutAddress: isToken(tokenOut, "BERA")
+        ? this.config.tokens.wbera
+        : tokenOut,
+      isTokenInNative: isToken(tokenIn, "BERA"),
+      isTokenOutNative: isToken(tokenOut, "BERA"),
+    };
+  }
+
+  /**
+   * Calculate input amount after fees
+   */
+  protected getAmountAfterFees(
+    amount: string,
+    aggregatorsFeeBps?: number,
+  ): string {
+    if (aggregatorsFeeBps === undefined) {
+      throw new BeraError({
+        message: "aggregatorsFeeBps is required",
+        level: "error",
+      });
+    }
+
+    const fees = new BigNumber(amount)
+      .times(aggregatorsFeeBps)
+      .dividedBy(10_000)
+      .toFixed(0, BigNumber.ROUND_DOWN);
+    return new BigNumber(amount).minus(fees).toFixed(0, BigNumber.ROUND_DOWN);
+  }
+  /**
+   * Formats input data for aggregator swaps
+   */
+  protected getInputData({
+    tokenIn,
+    amountIn,
+    isNative,
+    isPermit2Approval = false,
+    permit2SpenderAddress = zeroAddress,
+  }: {
+    tokenIn: Address;
+    amountIn: string;
+    isNative: boolean;
+    isPermit2Approval?: boolean;
+    permit2SpenderAddress?: Address;
+  }) {
+    return {
+      tokenIn,
+      amountIn: BigInt(amountIn),
+      isNative,
+      isPermit2Approval,
+      permit2SpenderAddress,
+    };
+  }
+
+  /**
+   * Calculate min amount out
+   */
+  protected getMinAmountOut(amountOut: string, slippage: number): bigint {
+    if (slippage === undefined) {
+      throw new BeraError({
+        message: "slippage is required",
+        level: "error",
+      });
+    }
+    const minAmountOut = new BigNumber(amountOut).times(1 - slippage / 100);
+
+    if (minAmountOut.isNaN() || minAmountOut.isZero()) {
+      return 0n;
+    }
+    return BigInt(minAmountOut.toFixed(0));
+  }
+
+  /**
+   * Check if chain is supported
+   */
+  protected checkChainSupport(): void {
+    if (!this.supportedChains.includes(this.chainId)) {
+      throw new BeraError({
+        message: `${this.name} is not supported on chain ${this.chainId}`,
+        level: "error",
+      });
+    }
+  }
+
+  protected async fetch(url: string | URL, options?: RequestInit) {
+    try {
+      return await beraFetch(
+        { url, name: this.name, type: this.type },
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          ...options,
+        },
+      );
+    } catch (err) {
+      const error = initBeraError({ cause: err });
+      if (
+        this.notFoundMessages.some((message) => error.message.includes(message))
+      ) {
+        error.reason = BaseAggregator.PATH_NOT_FOUND_REASON;
+      }
+      throw error;
+    }
+  }
+}