@berachain/berajs 0.1.2 → 0.2.1

package/src/hooks/transactions/transactionStore.unit.test.ts

@@ -1,508 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { Data, DataLegacy, Transaction } from "./transactionStore";
-import {
-  convertLegacyDataToNewData,
-  filterDuplicatefn,
-  mergeData,
-} from "./transactionStore";
-
-describe("convertLegacyDataToNewData", () => {
-  it("should convert legacy nested data to flat array format", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        1: [
-          {
-            hash: "0x123",
-            description: "Swap",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 1,
-          },
-        ],
-        2: [
-          {
-            hash: "0x456",
-            description: "Transfer",
-            timestamp: 2000,
-            status: "pending",
-            chainId: 2,
-          },
-        ],
-      },
-    };
-
-    const result = convertLegacyDataToNewData(legacyData);
-
-    expect(result).toEqual({
-      "0xAccount1": [
-        {
-          hash: "0x123",
-          description: "Swap",
-          timestamp: 1000,
-          status: "confirmed",
-          chainId: 1,
-        },
-        {
-          hash: "0x456",
-          description: "Transfer",
-          timestamp: 2000,
-          status: "pending",
-          chainId: 2,
-        },
-      ],
-    });
-  });
-
-  it("should handle multiple accounts with multiple chains", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        1: [
-          {
-            hash: "0x111",
-            description: "Tx1",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 1,
-          },
-        ],
-      },
-      "0xAccount2": {
-        2: [
-          {
-            hash: "0x222",
-            description: "Tx2",
-            timestamp: 2000,
-            status: "pending",
-            chainId: 2,
-          },
-        ],
-      },
-    };
-
-    const result = convertLegacyDataToNewData(legacyData);
-
-    expect(result).toEqual({
-      "0xAccount1": [
-        {
-          hash: "0x111",
-          description: "Tx1",
-          timestamp: 1000,
-          status: "confirmed",
-          chainId: 1,
-        },
-      ],
-      "0xAccount2": [
-        {
-          hash: "0x222",
-          description: "Tx2",
-          timestamp: 2000,
-          status: "pending",
-          chainId: 2,
-        },
-      ],
-    });
-  });
-
-  it("should handle empty legacy data", () => {
-    const legacyData: DataLegacy = {};
-    const result = convertLegacyDataToNewData(legacyData);
-    expect(result).toEqual({});
-  });
-
-  it("should skip undefined transactions", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        1: undefined,
-        2: [
-          {
-            hash: "0x123",
-            description: "Test",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 2,
-          },
-        ],
-      },
-    };
-
-    const result = convertLegacyDataToNewData(legacyData);
-
-    expect(result).toEqual({
-      "0xAccount1": [
-        {
-          hash: "0x123",
-          description: "Test",
-          timestamp: 1000,
-          status: "confirmed",
-          chainId: 2,
-        },
-      ],
-    });
-  });
-
-  it("should correctly convert chainId from string to number", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        80085: [
-          {
-            hash: "0xbeef",
-            description: "Berachain Tx",
-            timestamp: 5000,
-            status: "confirmed",
-            chainId: 80085,
-          },
-        ],
-      },
-    };
-
-    const result = convertLegacyDataToNewData(legacyData);
-
-    expect(result["0xAccount1"]?.[0]?.chainId).toBe(80085);
-    expect(typeof result["0xAccount1"]?.[0]?.chainId).toBe("number");
-  });
-});
-
-describe("filterDuplicatefn", () => {
-  it("should filter out duplicate transactions by hash", () => {
-    const transactions: Transaction[] = [
-      {
-        hash: "0x123",
-        description: "First",
-        timestamp: 1000,
-        status: "confirmed",
-        chainId: 1,
-      },
-      {
-        hash: "0x456",
-        description: "Second",
-        timestamp: 2000,
-        status: "pending",
-        chainId: 1,
-      },
-      {
-        hash: "0x123",
-        description: "Duplicate",
-        timestamp: 3000,
-        status: "failed",
-        chainId: 1,
-      },
-    ];
-
-    const result = transactions.filter(filterDuplicatefn);
-
-    expect(result).toHaveLength(2);
-    expect(result[0]?.hash).toBe("0x123");
-    expect(result[0]?.description).toBe("First");
-    expect(result[1]?.hash).toBe("0x456");
-  });
-
-  it("should keep all transactions when there are no duplicates", () => {
-    const transactions: Transaction[] = [
-      {
-        hash: "0x111",
-        description: "Tx1",
-        timestamp: 1000,
-        status: "confirmed",
-        chainId: 1,
-      },
-      {
-        hash: "0x222",
-        description: "Tx2",
-        timestamp: 2000,
-        status: "pending",
-        chainId: 1,
-      },
-      {
-        hash: "0x333",
-        description: "Tx3",
-        timestamp: 3000,
-        status: "failed",
-        chainId: 1,
-      },
-    ];
-
-    const result = transactions.filter(filterDuplicatefn);
-
-    expect(result).toHaveLength(3);
-    expect(result).toEqual(transactions);
-  });
-
-  it("should handle empty array", () => {
-    const transactions: Transaction[] = [];
-    const result = transactions.filter(filterDuplicatefn);
-    expect(result).toEqual([]);
-  });
-
-  it("should handle array with single transaction", () => {
-    const transactions: Transaction[] = [
-      {
-        hash: "0x123",
-        description: "Only one",
-        timestamp: 1000,
-        status: "confirmed",
-        chainId: 1,
-      },
-    ];
-
-    const result = transactions.filter(filterDuplicatefn);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual(transactions[0]);
-  });
-
-  it("should keep first occurrence when there are multiple duplicates", () => {
-    const transactions: Transaction[] = [
-      {
-        hash: "0xabc",
-        description: "First",
-        timestamp: 1000,
-        status: "confirmed",
-        chainId: 1,
-      },
-      {
-        hash: "0xabc",
-        description: "Second",
-        timestamp: 2000,
-        status: "pending",
-        chainId: 1,
-      },
-      {
-        hash: "0xabc",
-        description: "Third",
-        timestamp: 3000,
-        status: "failed",
-        chainId: 1,
-      },
-    ];
-
-    const result = transactions.filter(filterDuplicatefn);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]?.description).toBe("First");
-  });
-});
-
-describe("mergeData", () => {
-  it("should merge legacy and new data for same account", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        1: [
-          {
-            hash: "0x111",
-            description: "Legacy Tx",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 1,
-          },
-        ],
-      },
-    };
-
-    const newData: Data = {
-      "0xAccount1": [
-        {
-          hash: "0x222",
-          description: "New Tx",
-          timestamp: 2000,
-          status: "pending",
-          chainId: 1,
-        },
-      ],
-    };
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result["0xAccount1"]).toHaveLength(2);
-    expect(result["0xAccount1"]?.map((tx) => tx.hash)).toContain("0x111");
-    expect(result["0xAccount1"]?.map((tx) => tx.hash)).toContain("0x222");
-  });
-
-  it("should remove duplicate transactions when merging", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        1: [
-          {
-            hash: "0xDuplicate",
-            description: "Legacy",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 1,
-          },
-        ],
-      },
-    };
-
-    const newData: Data = {
-      "0xAccount1": [
-        {
-          hash: "0xDuplicate",
-          description: "New",
-          timestamp: 2000,
-          status: "pending",
-          chainId: 1,
-        },
-      ],
-    };
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result["0xAccount1"]).toHaveLength(1);
-    expect(result["0xAccount1"]?.[0]?.hash).toBe("0xDuplicate");
-    // Should keep the first occurrence (from newData since it's first in the array)
-    expect(result["0xAccount1"]?.[0]?.description).toBe("New");
-  });
-
-  it("should handle accounts that only exist in legacy data", () => {
-    const legacyData: DataLegacy = {
-      "0xLegacyOnly": {
-        1: [
-          {
-            hash: "0x111",
-            description: "Legacy",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 1,
-          },
-        ],
-      },
-    };
-
-    const newData: Data = {
-      "0xNewOnly": [
-        {
-          hash: "0x222",
-          description: "New",
-          timestamp: 2000,
-          status: "pending",
-          chainId: 1,
-        },
-      ],
-    };
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result["0xLegacyOnly"]).toHaveLength(1);
-    expect(result["0xNewOnly"]).toHaveLength(1);
-  });
-
-  it("should handle empty legacy data", () => {
-    const legacyData: DataLegacy = {};
-    const newData: Data = {
-      "0xAccount1": [
-        {
-          hash: "0x123",
-          description: "New",
-          timestamp: 1000,
-          status: "confirmed",
-          chainId: 1,
-        },
-      ],
-    };
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result).toEqual(newData);
-  });
-
-  it("should handle empty new data", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        1: [
-          {
-            hash: "0x123",
-            description: "Legacy",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 1,
-          },
-        ],
-      },
-    };
-    const newData: Data = {};
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result["0xAccount1"]).toHaveLength(1);
-    expect(result["0xAccount1"]?.[0]?.hash).toBe("0x123");
-  });
-
-  it("should handle both empty legacy and new data", () => {
-    const legacyData: DataLegacy = {};
-    const newData: Data = {};
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result).toEqual({});
-  });
-
-  it("should merge multiple chains from legacy data correctly", () => {
-    const legacyData: DataLegacy = {
-      "0xAccount1": {
-        1: [
-          {
-            hash: "0x111",
-            description: "Chain 1",
-            timestamp: 1000,
-            status: "confirmed",
-            chainId: 1,
-          },
-        ],
-        2: [
-          {
-            hash: "0x222",
-            description: "Chain 2",
-            timestamp: 2000,
-            status: "pending",
-            chainId: 2,
-          },
-        ],
-      },
-    };
-
-    const newData: Data = {
-      "0xAccount1": [
-        {
-          hash: "0x333",
-          description: "New",
-          timestamp: 3000,
-          status: "confirmed",
-          chainId: 1,
-        },
-      ],
-    };
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result["0xAccount1"]).toHaveLength(3);
-    expect(result["0xAccount1"]?.map((tx) => tx.chainId)).toContain(1);
-    expect(result["0xAccount1"]?.map((tx) => tx.chainId)).toContain(2);
-  });
-
-  it("should filter duplicates when new data has duplicates", () => {
-    const legacyData: DataLegacy = {};
-    const newData: Data = {
-      "0xAccount1": [
-        {
-          hash: "0xDup",
-          description: "First",
-          timestamp: 1000,
-          status: "confirmed",
-          chainId: 1,
-        },
-        {
-          hash: "0xDup",
-          description: "Second",
-          timestamp: 2000,
-          status: "pending",
-          chainId: 1,
-        },
-      ],
-    };
-
-    const result = mergeData(legacyData, newData);
-
-    expect(result["0xAccount1"]).toHaveLength(1);
-    expect(result["0xAccount1"]?.[0]?.description).toBe("First");
-  });
-});

package/src/hooks/transactions/useAddRecentTransaction.ts

@@ -1,29 +0,0 @@
-import { useCallback } from "react";
-
-import { useBeraWagmi } from "@berachain/wagmi/hooks";
-
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import { useTransactionStore } from "./TransactionStoreContext";
-import type { NewTransaction } from "./transactionStore";
-
-export function useAddRecentTransaction(): (
-  transaction: NewTransaction,
-) => void {
-  const store = useTransactionStore();
-  const { account } = useBeraWagmi();
-  const address = account?.wallet?.address;
-  return useCallback(
-    (transaction: NewTransaction) => {
-      if (!address) {
-        throw new InvalidArgumentError({
-          property: "address",
-          value: address,
-          expected: "Address",
-        });
-      }
-
-      store.addTransaction(address, transaction);
-    },
-    [store, address],
-  );
-}

package/src/hooks/transactions/useRecentTransactions.ts

@@ -1,27 +0,0 @@
-import { useEffect, useState } from "react";
-
-import { useBeraWallet } from "@berachain/wagmi/hooks";
-
-import { useTransactionStore } from "./TransactionStoreContext";
-import type { Transaction } from "./transactionStore";
-
-export function useRecentTransactions(): Transaction[] {
-  const store = useTransactionStore();
-  const { address } = useBeraWallet();
-
-  const [transactions, setTransactions] = useState(() =>
-    store && address ? store.getTransactions(address) : [],
-  );
-
-  useEffect(() => {
-    if (store && address) {
-      setTransactions(store.getTransactions(address));
-
-      return store.onChange(() => {
-        setTransactions(store.getTransactions(address));
-      });
-    }
-  }, [store, address]);
-
-  return transactions;
-}

package/src/types/index.ts

@@ -1,8 +0,0 @@
-export * from "./bribe-boost";
-export * from "./dex";
-export * from "./enso";
-export * from "./global";
-export * from "./governance";
-export * from "./honeySwap";
-export * from "./pol";
-export * from "./staking";

package/src/types/staking.ts

@@ -1,7 +0,0 @@
-export interface ProtocolMetadata {
-  name: string;
-  logoURI: string;
-  url: string;
-  description: string;
-  tags?: string[];
-}

package/src/utils/formatAggregatorsQuotes.ts

@@ -1,57 +0,0 @@
-import BigNumber from "bignumber.js";
-import { formatUnits } from "viem";
-
-import type { IAggregatorQuote, IRawAggregatorQuote, Token } from "~/types";
-import { computePriceImpact } from "./math";
-
-export const formatAggregatorsQuotes = (
-  rawQuotes: (IRawAggregatorQuote | IRawAggregatorQuote<false>)[],
-  selectedFrom: Token | undefined,
-  selectedTo: Token | undefined,
-  tokenInPrice: number,
-  tokenOutPrice: number,
-): IAggregatorQuote[] =>
-  rawQuotes
-    .map((quote) => {
-      const amountOut = formatUnits(
-        BigInt(quote.amountOut),
-        selectedTo?.decimals || 18,
-      );
-      const amountIn = formatUnits(
-        BigInt(quote.amountIn),
-        selectedFrom?.decimals || 18,
-      );
-      const amountOutUsd = new BigNumber(amountOut)
-        .times(tokenOutPrice)
-        .toFixed();
-      const amountInUsd = new BigNumber(amountIn).times(tokenInPrice).toFixed();
-      const priceImpactPercentage = computePriceImpact(
-        (tokenInPrice || 0).toString(),
-        (tokenOutPrice || 0).toString(),
-        amountIn,
-        amountOut,
-      );
-      return {
-        ...quote,
-        exchangeRate: new BigNumber(amountOut).div(amountIn).toNumber(),
-        amountIn,
-        amountOut,
-        amountOutUsd,
-        amountInUsd,
-        priceImpactPercentage,
-      };
-    })
-    .sort((a, b) => new BigNumber(b.amountOut).minus(a.amountOut).toNumber())
-    .map((quote, _, allQuotes) => ({
-      ...quote,
-      relativeLossPercentage: computePriceImpact(
-        // hardcoded to 1 since we're calculating relative loss percentage
-        // between this quote's output amount and the best quote's output amount.
-        // The input amounts are the same for all quotes, so we use 1 as a base
-        // to get the pure percentage difference between outputs.
-        "1",
-        "1",
-        allQuotes[0].amountOut,
-        quote.amountOut,
-      ),
-    }));