@berachain/berajs 0.1.2 → 0.2.1

package/src/hooks/enso/useZapTransactionRequests.ts

@@ -1,81 +0,0 @@
-"use client";
-
-import useSWR from "swr";
-
-import { POLLING } from "~/enum/polling";
-import { assertAddress, assertAmount, assertDefined } from "~/errors/assert";
-import type {
-  BalanceToken,
-  BalanceTokenWithMetadata,
-  GetZapTransactionResponse,
-} from "~/types";
-import { useEnsoZap } from "./useEnsoZap";
-
-/**
- * Get the zap transaction requests for swapping tokens using Enso.
- * @param {Pick<BalanceToken, "address" | "decimals">} tokenIn - The input token to swap from
- * @param {Pick<BalanceToken, "address" | "decimals">} tokenOut - The output token to swap to
- * @param {string} amount - The amount of input token to swap
- * @param {number} slippage - The slippage tolerance to use for the route in percentage
- * @returns {DefaultHookReturnType<GetZapTransactionResponse> & {tokens: BalanceTokenWithMetadata[], refresh: () => void}}
- *
- * The zap transaction response data with polling enabled, see {@link GetZapTransactionResponse} and {@link BalanceTokenWithMetadata}
- * @remarks The hook is only enabled when all parameters are provided and amount is greater than 0
- * @see {@link useEnsoZap}
- */
-export const useZapTransactionRequests = ({
-  tokenIn,
-  tokenOut,
-  amount,
-  slippage,
-  chainId,
-}: {
-  tokenIn?: Pick<BalanceToken, "address" | "decimals">;
-  tokenOut?: Pick<BalanceToken, "address" | "decimals">;
-  amount?: string;
-  slippage?: number;
-  chainId?: number;
-}) => {
-  const { getZapTransactionRequests, refreshTokens, tokens } = useEnsoZap({
-    chainId,
-  });
-  const isEnabled =
-    !!tokenIn && !!tokenOut && !!amount && Number(amount) > 0 && !!slippage;
-  const QUERY_KEY = isEnabled
-    ? ([
-        "useZapTransactionRequests",
-        tokenIn,
-        tokenOut,
-        amount,
-        slippage,
-      ] as const)
-    : null;
-
-  const swrResponse = useSWR(
-    QUERY_KEY,
-    async ([, tokenIn, tokenOut, amount, slippage]) => {
-      assertDefined(tokenIn, "tokenIn");
-      assertAddress(tokenOut?.address, "tokenOutAddress");
-      assertAmount(amount, "amount");
-      assertAmount(slippage, "slippage");
-      return getZapTransactionRequests({
-        amount,
-        tokenIn: tokenIn,
-        tokenOut: tokenOut.address,
-        slippage,
-      });
-    },
-    {
-      refreshInterval: POLLING.NORMAL,
-      isEnabled: isEnabled,
-    },
-  );
-  return {
-    ...swrResponse,
-    tokens,
-    refresh: () => {
-      swrResponse.mutate();
-      refreshTokens();
-    },
-  };
-};

package/src/hooks/pol/useEarnedStakedBeraVault.ts

@@ -1,59 +0,0 @@
-import useSWR from "swr";
-
-import {
-  GetStakeBeraVaultEarningsByOwner,
-  type GetStakeBeraVaultEarningsByOwnerQuery,
-  type GetStakeBeraVaultEarningsByOwnerQueryVariables,
-} from "@berachain/graphql/pol/api";
-import { useBeraWallet } from "@berachain/wagmi/hooks";
-
-import { getApolloClient } from "~/actions/clients/getApolloClient";
-import { POLLING } from "~/enum/polling";
-import type {
-  DefaultHookOptions,
-  DefaultHookReturnType,
-  TokenWithMetadata,
-} from "~/types";
-
-type UseEarnedStakedBeraVaultArgs = {
-  /**
-   * The token that the user has staked
-   */
-  receiptToken: TokenWithMetadata;
-};
-export function useEarnedStakedBeraVault(
-  { receiptToken }: UseEarnedStakedBeraVaultArgs,
-  opt?: DefaultHookOptions,
-): DefaultHookReturnType<string> {
-  const { address: account } = useBeraWallet();
-
-  const QUERY_KEY =
-    receiptToken.address && account
-      ? (["useEarnedStakedBeraVault", receiptToken.address, account] as const)
-      : null;
-
-  const swrResponse = useSWR(
-    QUERY_KEY,
-    async ([_, , account]) => {
-      const bexApiGraphqlClient = getApolloClient("api", {});
-      const response = await bexApiGraphqlClient.query<
-        GetStakeBeraVaultEarningsByOwnerQuery,
-        GetStakeBeraVaultEarningsByOwnerQueryVariables
-      >({
-        query: GetStakeBeraVaultEarningsByOwner,
-        variables: {
-          owner: account,
-        },
-      });
-      return response.data?.polGetStakeBeraVaultEarningsByOwner?.earnings;
-    },
-    {
-      refreshInterval: POLLING.SLOW,
-      ...opt?.opts,
-    },
-  );
-  return {
-    ...swrResponse,
-    refresh: swrResponse.mutate,
-  };
-}

package/src/hooks/pol/useStakedBeraSnapshots.ts

@@ -1,27 +0,0 @@
-import useSWR from "swr";
-
-import type { GetSWberaVaultSnapshotsQuery } from "@berachain/graphql/pol/api";
-
-import {
-  type GetStakedBeraSnapshotsArgs,
-  getStakedBeraSnapshots,
-} from "~/actions/pol/getStakedBeraSnapshots";
-import type { DefaultHookReturnType } from "~/types/global";
-
-export const useStakedBeraSnapshots = ({
-  range,
-}: GetStakedBeraSnapshotsArgs): DefaultHookReturnType<
-  GetSWberaVaultSnapshotsQuery["polGetSWberaVaultSnapshots"]
-> => {
-  const QUERY_KEY = range ? (["useStakedBeraSnapshots", range] as const) : null;
-  const swrResponse = useSWR(QUERY_KEY, ([, range]) =>
-    getStakedBeraSnapshots({
-      range,
-    }),
-  );
-
-  return {
-    ...swrResponse,
-    refresh: () => swrResponse.mutate(),
-  };
-};

package/src/hooks/transactions/TransactionStoreContext.tsx

@@ -1,59 +0,0 @@
-import type React from "react";
-import { createContext, useContext, useEffect, useState } from "react";
-
-import { useBeraWagmi, useConfig } from "@berachain/wagmi/hooks";
-
-import {
-  createTransactionStore,
-  type TransactionStore,
-} from "./transactionStore";
-
-// Only allow a single instance of the store to exist at once
-// so that multiple RainbowKitProvider instances can share the same store.
-// We delay the creation of the store until the first time it is used
-// so that it always has access to a provider.
-let storeSingleton: ReturnType<typeof createTransactionStore> | undefined;
-
-const TransactionStoreContext = createContext<TransactionStore | null>(null);
-
-export function TransactionStoreProvider({
-  children,
-}: {
-  children: React.ReactNode;
-}) {
-  const { account } = useBeraWagmi();
-  const address = account?.wallet?.address;
-  const config = useConfig();
-
-  // Use existing store if it exists, or lazily create one
-  const [store] = useState(
-    () =>
-      storeSingleton ??
-      (storeSingleton = createTransactionStore({
-        config,
-      })),
-  );
-
-  // Wait for pending transactions whenever address changes
-  useEffect(() => {
-    if (address) {
-      store.waitForPendingTransactions(address);
-    }
-  }, [store, address]);
-
-  return (
-    <TransactionStoreContext.Provider value={store}>
-      {children}
-    </TransactionStoreContext.Provider>
-  );
-}
-
-export function useTransactionStore(): TransactionStore {
-  const store = useContext(TransactionStoreContext);
-
-  if (!store) {
-    throw new Error("Transaction hooks must be used within ");
-  }
-
-  return store;
-}

package/src/hooks/transactions/transactionStore.ts

@@ -1,275 +0,0 @@
-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>;