@berachain/berajs 0.2.0 → 0.2.1

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

@@ -1,561 +0,0 @@
-import type { Config } from "@wagmi/core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { Data, DataLegacy, Transaction } from "./transactionStore";
-import {
-  convertLegacyDataToNewData,
-  createTransactionStore,
-  filterDuplicatefn,
-  mergeData,
-} from "./transactionStore";
-
-const storage = new Map<string, string>();
-
-beforeEach(() => {
-  storage.clear();
-  const localStorageMock: Storage = {
-    get length() {
-      return storage.size;
-    },
-    clear: vi.fn(() => {
-      storage.clear();
-    }),
-    getItem: vi.fn((key: string) => storage.get(key) ?? null),
-    key: vi.fn((index: number) => Array.from(storage.keys())[index] ?? null),
-    removeItem: vi.fn((key: string) => {
-      storage.delete(key);
-    }),
-    setItem: vi.fn((key: string, value: string) => {
-      storage.set(key, value);
-    }),
-  };
-
-  vi.stubGlobal("localStorage", localStorageMock);
-});
-
-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");
-  });
-});
-
-describe("createTransactionStore", () => {
-  it("adds transactions and updates status", () => {
-    const store = createTransactionStore({ config: {} as Config });
-    const account = "0xAccount1";
-    const hash =
-      "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-
-    store.addTransaction(account, {
-      hash,
-      description: "Submitted",
-      timestamp: 123,
-      chainId: 1,
-    });
-
-    expect(store.getTransactions(account)).toHaveLength(1);
-    expect(store.getTransactions(account)[0]?.status).toBe("pending");
-
-    store.setTransactionStatus(account, hash, "confirmed");
-
-    expect(store.getTransactions(account)[0]?.status).toBe("confirmed");
-
-    store.setTransactionStatus(account, hash, "failed");
-
-    expect(store.getTransactions(account)[0]?.status).toBe("failed");
-  });
-});

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 "../../contexts/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 "../../contexts/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/hooks/transactions/useSetTransactionStatus.ts

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