@berachain/berajs 0.1.0 → 0.1.2

package/src/hooks/transactions/transactionStore.ts

@@ -0,0 +1,275 @@
+import { type Config, getPublicClient } from "@wagmi/core";
+import type { Address } from "viem";
+
+import type { TransactionActionType } from "~/enum";
+
+const storageKeyLegacy = "rk-transactions";
+const storageKey = "transactions";
+
+type TransactionStatus = "pending" | "confirmed" | "failed";
+
+export interface Transaction {
+  hash: string;
+  description: string;
+  actionType?: TransactionActionType;
+  timestamp: number;
+  status: TransactionStatus;
+  confirmations?: number;
+  chainId: number;
+}
+
+export type NewTransaction = Omit<Transaction, "status">;
+
+export type DataLegacy = Record<
+  string,
+  Record<number, Transaction[] | undefined>
+>;
+export type Data = Record<string, Transaction[] | undefined>;
+
+export function safeParseJsonData<T = DataLegacy | Data>(
+  string: string | null,
+): T {
+  try {
+    const value = string ? JSON.parse(string) : {};
+    return typeof value === "object" ? value : {};
+  } catch {
+    return {} as T;
+  }
+}
+/**
+ *
+ * @param legacyData - The legacy data to convert to the new data format.
+ * removes the nested chains and converts the data to a flat array.
+ * @returns Data in the new format with the chainId added to each transaction.
+ */
+export function convertLegacyDataToNewData(legacyData: DataLegacy): Data {
+  return Object.entries(legacyData).reduce((acc, [account, chains]) => {
+    return {
+      ...acc,
+      [account]: Object.entries(chains).reduce(
+        (acc, [chainId, transactions]) => {
+          if (!transactions) {
+            return acc;
+          }
+          const transactionsArray = transactions.map(
+            (transaction): Transaction => ({
+              ...transaction,
+              chainId: Number(chainId),
+            }),
+          );
+          acc.push(...transactionsArray);
+          return acc;
+        },
+        [] as NewTransaction[],
+      ),
+    };
+  }, {});
+}
+
+/**
+ * Filter out duplicate transactions by hash
+ */
+export const filterDuplicatefn = (
+  tx: Transaction,
+  idx: number,
+  arr: Transaction[],
+) => arr.findIndex((otherTx) => otherTx.hash === tx.hash) === idx;
+
+export function mergeData(legacyData: DataLegacy, newData: Data): Data {
+  const mergedData = convertLegacyDataToNewData(legacyData);
+  for (const [account, transactions] of Object.entries(newData)) {
+    if (mergedData[account] && transactions) {
+      // Merge and filter out duplicates by transaction hash
+      mergedData[account] = [...transactions, ...mergedData[account]].filter(
+        filterDuplicatefn,
+      );
+    } else {
+      mergedData[account] = transactions?.filter(filterDuplicatefn);
+    }
+  }
+  return mergedData;
+}
+function loadData(): Data {
+  const legacyData = safeParseJsonData<DataLegacy>(
+    typeof localStorage !== "undefined"
+      ? localStorage.getItem(storageKeyLegacy)
+      : null,
+  );
+  const data = safeParseJsonData<Data>(
+    typeof localStorage !== "undefined"
+      ? localStorage.getItem(storageKey)
+      : null,
+  );
+  return mergeData(legacyData, data);
+}
+
+const transactionHashRegex = /^0x([A-Fa-f0-9]{64})$/;
+
+function validateTransaction(
+  transaction: Transaction | NewTransaction,
+): string[] {
+  const errors: string[] = [];
+
+  if (!transactionHashRegex.test(transaction.hash)) {
+    errors.push("Invalid transaction hash");
+  }
+
+  if (typeof transaction.description !== "string") {
+    errors.push("Transaction must have a description");
+  }
+
+  if (
+    typeof transaction.confirmations !== "undefined" &&
+    (!Number.isInteger(transaction.confirmations) ||
+      transaction.confirmations < 1)
+  ) {
+    errors.push("Transaction confirmations must be a positiver integer");
+  }
+
+  return errors;
+}
+
+export function createTransactionStore({ config }: { config: Config }) {
+  let data: Data = loadData();
+  const listeners: Set<() => void> = new Set();
+  const transactionRequestCache: Map<string, Promise<void>> = new Map();
+
+  function getTransactions(account: string): Transaction[] {
+    return data[account] ?? [];
+  }
+
+  function addTransaction(account: string, transaction: NewTransaction): void {
+    const errors = validateTransaction(transaction);
+
+    if (errors.length > 0) {
+      throw new Error(["Unable to add transaction", ...errors].join("\n"));
+    }
+
+    updateTransactions(account, (transactions) => {
+      return [
+        { ...transaction, status: "pending" },
+        ...transactions.filter(({ hash }) => {
+          // Omit any duplicate transactions
+          return hash !== transaction.hash;
+        }),
+      ];
+    });
+  }
+
+  function clearTransactions(account: string): void {
+    updateTransactions(account, () => {
+      return [];
+    });
+  }
+
+  function setTransactionStatus(
+    account: string,
+    hash: string,
+    status: TransactionStatus,
+  ): void {
+    updateTransactions(account, (transactions) => {
+      return transactions.map((transaction) =>
+        transaction.hash === hash ? { ...transaction, status } : transaction,
+      );
+    });
+  }
+
+  async function waitForPendingTransactions(account: string): Promise<void> {
+    await Promise.all(
+      getTransactions(account)
+        .filter((transaction) => transaction.status === "pending")
+        .map(async (transaction) => {
+          const { confirmations, hash, chainId } = transaction;
+
+          const existingRequest = transactionRequestCache.get(hash);
+
+          if (existingRequest) {
+            return await existingRequest;
+          }
+          const provider = getPublicClient(config, { chainId });
+          if (!provider) {
+            return;
+          }
+
+          const requestPromise = provider
+            .waitForTransactionReceipt({ confirmations, hash: hash as Address })
+            .then(({ status }) => {
+              transactionRequestCache.delete(hash);
+
+              if (status === undefined) {
+                return;
+              }
+
+              setTransactionStatus(
+                account,
+                hash,
+                Number(status) === 0 ? "failed" : "confirmed",
+              );
+            });
+
+          transactionRequestCache.set(hash, requestPromise);
+
+          return await requestPromise;
+        }),
+    );
+  }
+
+  function updateTransactions(
+    account: string,
+    updateFn: (transactions: Transaction[]) => Transaction[],
+  ): void {
+    // Ensure we’re always operating on the latest data in case we have
+    // multiple instances/tabs/etc. since we write all data back to
+    // local storage after updating
+    data = loadData();
+
+    data[account] = data[account] ?? [];
+
+    const MAX_TRANSACTIONS = 10;
+    const updatedTransactions = updateFn(data?.[account] ?? []);
+
+    const transactions = updatedTransactions
+      // Sort by timestamp (latest first) and keep only the latest 10
+      .sort((a, b) => b.timestamp - a.timestamp)
+      .slice(0, MAX_TRANSACTIONS);
+
+    data[account] =
+      transactions.length > 0
+        ? transactions.filter(filterDuplicatefn)
+        : undefined;
+
+    persistData();
+    notifyListeners();
+    waitForPendingTransactions(account);
+  }
+
+  function persistData(): void {
+    localStorage.setItem(storageKey, JSON.stringify(data));
+    // remove legacy data how that it has been converted to the new data format and saved to the new key
+    localStorage.removeItem(storageKeyLegacy);
+  }
+
+  function notifyListeners(): void {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+
+  function onChange(fn: () => void): () => void {
+    listeners.add(fn);
+
+    return () => {
+      listeners.delete(fn);
+    };
+  }
+
+  return {
+    addTransaction,
+    clearTransactions,
+    getTransactions,
+    onChange,
+    waitForPendingTransactions,
+  };
+}
+
+export type TransactionStore = ReturnType<typeof createTransactionStore>;