@berachain/berajs 0.1.2 → 0.2.0

package/src/hooks/transactions/transactionStore.ts

@@ -1,12 +1,15 @@
 import { type Config, getPublicClient } from "@wagmi/core";
 import type { Address } from "viem";
 
-import type { TransactionActionType } from "~/enum";
+import type { TransactionActionType } from "~/enum/txnEnum";
+import { BeraMonitoring } from "~/errors/BeraMonitoring";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { initBeraError } from "~/errors/initBeraError";
 
 const storageKeyLegacy = "rk-transactions";
 const storageKey = "transactions";
 
-type TransactionStatus = "pending" | "confirmed" | "failed";
+export type TransactionStatus = "pending" | "confirmed" | "failed";
 
 export interface Transaction {
   hash: string;
@@ -105,17 +108,21 @@ function loadData(): Data {
 
 const transactionHashRegex = /^0x([A-Fa-f0-9]{64})$/;
 
-function validateTransaction(
-  transaction: Transaction | NewTransaction,
-): string[] {
-  const errors: string[] = [];
-
+function validateTransaction(transaction: Transaction | NewTransaction): void {
   if (!transactionHashRegex.test(transaction.hash)) {
-    errors.push("Invalid transaction hash");
+    throw new InvalidArgumentError({
+      property: "hash",
+      value: transaction.hash,
+      expected: "TransactionHash",
+    });
   }
 
   if (typeof transaction.description !== "string") {
-    errors.push("Transaction must have a description");
+    throw new InvalidArgumentError({
+      property: "description",
+      value: transaction.description,
+      expected: "string",
+    });
   }
 
   if (
@@ -123,10 +130,12 @@ function validateTransaction(
     (!Number.isInteger(transaction.confirmations) ||
       transaction.confirmations < 1)
   ) {
-    errors.push("Transaction confirmations must be a positiver integer");
+    throw new InvalidArgumentError({
+      property: "confirmations",
+      value: transaction.confirmations,
+      expected: "positive integer",
+    });
   }
-
-  return errors;
 }
 
 export function createTransactionStore({ config }: { config: Config }) {
@@ -139,21 +148,23 @@ export function createTransactionStore({ config }: { config: Config }) {
   }
 
   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"));
+    const normalized: Transaction = { ...transaction, status: "pending" };
+
+    try {
+      validateTransaction(normalized);
+
+      updateTransactions(account, (transactions) => {
+        return [
+          normalized,
+          ...transactions.filter(({ hash }) => {
+            // Omit any duplicate transactions
+            return hash !== normalized.hash;
+          }),
+        ];
+      });
+    } catch (error) {
+      BeraMonitoring.captureException(initBeraError({ cause: error }));
     }
-
-    updateTransactions(account, (transactions) => {
-      return [
-        { ...transaction, status: "pending" },
-        ...transactions.filter(({ hash }) => {
-          // Omit any duplicate transactions
-          return hash !== transaction.hash;
-        }),
-      ];
-    });
   }
 
   function clearTransactions(account: string): void {
@@ -174,43 +185,49 @@ export function createTransactionStore({ config }: { config: Config }) {
     });
   }
 
-  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);
+  async function refreshPendingTransactions(account: string): Promise<void> {
+    const pendingTransactions = getTransactions(account).filter(
+      (transaction) => transaction.status === "pending",
+    );
 
-          return await requestPromise;
-        }),
+    await Promise.allSettled(
+      pendingTransactions.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 }) => {
+            if (status === undefined) {
+              return;
+            }
+
+            setTransactionStatus(
+              account,
+              hash,
+              Number(status) === 0 ? "failed" : "confirmed",
+            );
+          })
+          .catch((error) => {
+            BeraMonitoring.captureException(initBeraError({ cause: error }));
+          })
+          .finally(() => {
+            transactionRequestCache.delete(hash);
+          });
+
+        transactionRequestCache.set(hash, requestPromise);
+
+        return await requestPromise;
+      }),
     );
   }
 
@@ -240,12 +257,15 @@ export function createTransactionStore({ config }: { config: Config }) {
 
     persistData();
     notifyListeners();
-    waitForPendingTransactions(account);
   }
 
   function persistData(): void {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+
     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
+    // remove legacy data now that it has been converted to the new data format and saved to the new key
     localStorage.removeItem(storageKeyLegacy);
   }
 
@@ -268,7 +288,8 @@ export function createTransactionStore({ config }: { config: Config }) {
     clearTransactions,
     getTransactions,
     onChange,
-    waitForPendingTransactions,
+    refreshPendingTransactions,
+    setTransactionStatus,
   };
 }
 

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

@@ -1,12 +1,38 @@
-import { describe, expect, it } from "vitest";
+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 = {
@@ -506,3 +532,30 @@ describe("mergeData", () => {
     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

@@ -3,7 +3,7 @@ import { useCallback } from "react";
 import { useBeraWagmi } from "@berachain/wagmi/hooks";
 
 import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import { useTransactionStore } from "./TransactionStoreContext";
+import { useTransactionStore } from "../../contexts/TransactionStoreContext";
 import type { NewTransaction } from "./transactionStore";
 
 export function useAddRecentTransaction(): (

package/src/hooks/transactions/useRecentTransactions.ts

@@ -2,7 +2,7 @@ import { useEffect, useState } from "react";
 
 import { useBeraWallet } from "@berachain/wagmi/hooks";
 
-import { useTransactionStore } from "./TransactionStoreContext";
+import { useTransactionStore } from "../../contexts/TransactionStoreContext";
 import type { Transaction } from "./transactionStore";
 
 export function useRecentTransactions(): Transaction[] {

package/src/hooks/transactions/useSetTransactionStatus.ts

@@ -0,0 +1,31 @@
+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],
+  );
+}

package/src/hooks/useContractWrite/useBeraContractWrite.ts

@@ -6,9 +6,10 @@ import { useBeraWagmi, useConfig } from "@berachain/wagmi/hooks";
 import { beraWriteContract } from "~/actions/transactions/beraWriteContract";
 import { useBeraFlag } from "~/contexts/BeraFlags/BeraFlags";
 import { TransactionFailedError } from "~/errors/TransactionFailedError";
+import type { IUseContractWriteArgs } from "~/hooks/useContractWrite/types";
 import type { IContractWrite } from "~/types/global";
 import { ActionEnum, initialState, reducer } from "./stateReducer";
-import type { IUseContractWriteArgs, UseContractWriteApi } from "./types";
+import type { UseContractWriteApi } from "./types";
 
 function useBeraContractWrite({
   onlyPermissionless,

package/src/hooks/validators/useAllValidators.ts

@@ -8,7 +8,7 @@ import type {
 
 import { getAllValidators } from "~/actions/validators/getAllValidators";
 import { POLLING } from "~/enum/polling";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 
 export const useAllValidatorsQueryKey = ({

package/src/hooks/validators/useApiValidator.ts

@@ -4,7 +4,7 @@ import { type Address, isHex } from "viem";
 import type { GetValidatorQuery } from "@berachain/graphql/pol/api";
 
 import { getApiValidator } from "~/actions/validators/getApiValidator";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export interface UsePollValidatorInfoResponse
   extends DefaultHookReturnType<GetValidatorQuery> {}

package/src/hooks/validators/useDailyValidatorBlockStats.ts

@@ -5,7 +5,7 @@ import type { GetValidatorBlockStatsQuery } from "@berachain/graphql/pol/subgrap
 
 import { getDailyValidatorBlockStats } from "~/actions/validators/getDailyValidatorBlockStats";
 import { POLLING } from "~/enum/polling";
-import type { DefaultHookReturnType } from "~/types";
+import type { DefaultHookReturnType } from "~/types/global";
 
 export const useDailyValidatorBlockStats = ({
   pubKey,

package/src/hooks/validators/useManagedValidatorByAccount.ts

@@ -2,7 +2,7 @@ import useSWRImmutable from "swr/immutable";
 import type { Address } from "viem";
 
 import { getManagedValidatorByAccount } from "~/actions/validators/getManagedValidatorByAccount";
-import type { DefaultHookOptions } from "~/types";
+import type { DefaultHookOptions } from "~/types/global";
 
 /**
  * Return the validators managed by the account

package/src/hooks/validators/useManagedValidatorRole.ts

@@ -8,7 +8,7 @@ import { getValidatorOperatorAddress } from "~/actions/validators/getValidatorOp
 import { getValidatorRewardAllocatorAddress } from "~/actions/validators/getValidatorRewardAllocatorAddress";
 import { useBeraFlag } from "~/contexts/BeraFlags/BeraFlags";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export type ManagedValidatorRole = {
   operator: Address | null;

package/src/hooks/validators/useOnChainValidator.ts

@@ -8,7 +8,7 @@ import { beaconDepositAbi } from "~/abi/pol/beaconDeposit";
 import { beraChefAbi } from "~/abi/pol/beraChef";
 import { bgtAbi } from "~/abi/pol/bgt";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 
 export const useOnChainValidator = (

package/src/hooks/validators/useStakingPoolBatch.ts

@@ -6,7 +6,7 @@ import { usePublicClient } from "@berachain/wagmi/hooks";
 import { getStakingPoolBatch } from "~/actions/validators/getStakingPoolBatch";
 import { POLLING } from "~/enum/polling";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export const useStakingPoolBatch = ({
   valPubKey,

package/src/hooks/validators/useUserActiveValidators.ts

@@ -9,7 +9,7 @@ import {
 import { POLLING } from "~/enum/polling";
 import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
-export interface UseUserActiveValidatorsResponse
+interface UseUserActiveValidatorsResponse
   extends DefaultHookReturnType<ValidatorWithUserBoost[] | undefined> {}
 
 export const useUserActiveValidators = (

package/src/hooks/validators/useUserBoostsOnValidator.ts

@@ -8,7 +8,7 @@ import {
   type UserBoostsOnValidator,
 } from "~/actions/validators/getUserBoostsOnValidator";
 import { POLLING } from "~/enum/polling";
-import type { DefaultHookReturnType } from "~/types";
+import type { DefaultHookReturnType } from "~/types/global";
 
 export const useUserBoostsOnValidator = ({
   pubkey,

package/src/hooks/validators/useUserClaimableIncentives.ts

@@ -1,17 +1,19 @@
 import { useCallback, useMemo } from "react";
-import * as Sentry from "@sentry/nextjs";
 import useSWR from "swr";
 
 import { useBeraWallet } from "@berachain/wagmi/hooks";
 
 import { getRewardProofsByValidator } from "~/actions/pol/getRewardProofsByValidator";
 import { getUserClaimableIncentives } from "~/actions/pol/getUserClaimableIncentives";
-import { POLLING } from "~/enum";
+import { POLLING } from "~/enum/polling";
 import { BeraError } from "~/errors/BeraError";
+import { BeraMonitoring } from "~/errors/BeraMonitoring";
 import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import type { BribeBoostRewardProof, DefaultHookReturnType } from "~/types";
+import type { BribeBoostRewardProof } from "~/types/bribe-boost";
+import type { DefaultHookReturnType } from "~/types/global";
 import { formatIncentivesTokenMap } from "~/utils/formatIncentivesTokenMap";
-export interface UseUserClaimableIncentivesReturnType
+
+interface UseUserClaimableIncentivesReturnType
   extends DefaultHookReturnType<BribeBoostRewardProof[]> {
   tokenMap?: Set<string> | undefined;
 }
@@ -56,17 +58,15 @@ export const useUserClaimableIncentives =
 
       // If the data is not an array, capture an error
       if (!Array.isArray(allRewards)) {
-        Sentry.captureException(
+        BeraMonitoring.captureException(
           new BeraError({
             message: "Incorrect aggregated incentives data receieved.",
             level: "error",
-          }),
-          {
             extra: {
               allRewards,
               account: account,
             },
-          },
+          }),
         );
         return undefined;
       }

package/src/hooks/validators/useValidator.ts

@@ -3,7 +3,7 @@ import { type Address, keccak256 } from "viem";
 import type { GqlValidatorDynamicData } from "@berachain/graphql/dex/api";
 import type { ApiValidatorFragment } from "@berachain/graphql/pol/api";
 
-import type { DefaultHookOptions } from "~/types";
+import type { DefaultHookOptions } from "~/types/global";
 import { useApiValidator } from "./useApiValidator";
 import { useOnChainValidator } from "./useOnChainValidator";
 

package/src/hooks/validators/useValidatorAnalytics.ts

@@ -5,7 +5,7 @@ import type { GetValidatorAnalyticsQuery } from "@berachain/graphql/pol/subgraph
 
 import { getValidatorAnalytics } from "~/actions/validators/getValidatorAnalytics";
 import { POLLING } from "~/enum/polling";
-import type { DefaultHookReturnType } from "~/types";
+import type { DefaultHookReturnType } from "~/types/global";
 
 export function useValidatorAnalytics({
   pubkey,

package/src/hooks/validators/useValidatorCommission.ts

@@ -4,7 +4,7 @@ import type { Address, PublicClient } from "viem";
 import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getValidatorCommission } from "~/actions/validators/getValidatorCommission";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export const useValidatorCommission = (
   pubKey: Address,

package/src/hooks/validators/useValidatorQueuedCommission.ts

@@ -8,7 +8,7 @@ import {
   type ValidatorQueuedCommission,
 } from "~/actions/validators/getValidatorQueuedCommission";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export function useValidatorQueuedCommission(
   pubKey: Address,

package/src/hooks/validators/useValidatorQueuedOperatorAddress.ts

@@ -7,7 +7,7 @@ import {
   getValidatorQueuedOperatorAddress,
   type ValidatorQueuedOperatorAddress,
 } from "~/actions/validators/getValidatorQueuedOperatorAddress";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export const useValidatorQueuedOperatorAddress = (
   pubKey: Address,

package/src/hooks/validators/useValidatorQueuedRewardAllocation.ts

@@ -5,7 +5,7 @@ import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getValidatorQueuedRewardAllocation } from "~/actions/validators/getValidatorQueuedRewardAllocation";
 import type { ValidatorRewardAllocation } from "~/actions/validators/getValidatorRewardAllocation";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export const useValidatorQueuedRewardAllocation = (
   pubKey: Address,

package/src/hooks/validators/useValidatorRewardAllocation.ts

@@ -4,7 +4,7 @@ import type { Address, PublicClient } from "viem";
 import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getValidatorRewardAllocation } from "~/actions/validators/getValidatorRewardAllocation";
-import type { DefaultHookOptions } from "~/types";
+import type { DefaultHookOptions } from "~/types/global";
 
 export function useValidatorRewardAllocation(
   pubKey: Address,