@berachain/berajs 0.1.0 → 0.1.2

package/src/errors/initBeraError.ts

@@ -0,0 +1,46 @@
+import { BaseError } from "viem";
+
+import { BeraError } from "./BeraError";
+import { parseViemError } from "./parseViemError";
+import { RequestError } from "./RequestError";
+
+/**
+ * Initialize a BeraError from an error.
+ *
+ * If the error is already a BeraError, it will be returned as is.
+ * Otherwise, a new BeraError will be created with the error as the cause.
+ */
+export function initBeraError({ cause: error }: { cause: unknown }): BeraError {
+  if (error instanceof BaseError) {
+    const parsed = parseViemError({
+      error,
+      revertIfUnknown: false,
+    });
+    if (
+      parsed.isRequestError &&
+      parsed.rootCause instanceof BaseError &&
+      "url" in parsed.rootCause &&
+      typeof parsed.rootCause.url === "string"
+    ) {
+      // the best way would be to return the RequestError
+      // but that pattern is not recommended by biome (seems legit)
+      // this is mostly supported by `initBeraError()`
+      return new RequestError({
+        cause: parsed.rootCause,
+        response: undefined,
+        endpoint: {
+          url: parsed.rootCause.url as string,
+          type: "rpc",
+        },
+      });
+    }
+  }
+  const err =
+    error instanceof BeraError
+      ? error
+      : new BeraError({
+          cause: error,
+        });
+
+  return err;
+}

package/src/errors/parseViemError.ts

@@ -0,0 +1,239 @@
+import {
+  type Abi,
+  AtomicReadyWalletRejectedUpgradeError,
+  BaseError,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  type DecodeErrorResultReturnType,
+  decodeErrorResult,
+  HttpRequestError,
+  type ProviderRpcErrorCode,
+  RpcRequestError,
+  TransactionExecutionError,
+  UserRejectedRequestError,
+} from "viem";
+
+import { commonAbiErrors } from "~/abi/utils/commonAbiErrors";
+
+function isBaseError(error: unknown): error is BaseError {
+  if (error instanceof BaseError) {
+    return true;
+  }
+
+  if (
+    error instanceof Error &&
+    "shortMessage" in error &&
+    "message" in error &&
+    "details" in error
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function isViemError<T extends Error>(
+  error: Error,
+  name: T["name"],
+  shouldBeInstanceOf: new (...args: any[]) => T,
+): error is T {
+  if (error instanceof shouldBeInstanceOf) {
+    return true;
+  }
+
+  if (error.name === name) {
+    return true;
+  }
+
+  return false;
+}
+
+export function parseDecodedError<const abi extends Abi | readonly unknown[]>(
+  error: DecodeErrorResultReturnType<abi>,
+): string | undefined {
+  if (
+    error.errorName === "Error" &&
+    Array.isArray(error.args) &&
+    error.args?.at(0)
+  ) {
+    // this is a solidity error thrown by `revert` and the message is the first argument
+    // for other errors, we return the error name
+    return error.args?.at(0) as string;
+  }
+
+  return error.errorName;
+}
+
+/**
+ * Parses errors thrown by `publicClient.simulateContract` or `publicClient.call`.
+ *
+ * @returns error code if available, otherwise signature or a message from the error.
+ */
+export function parseViemError({
+  error,
+  abi,
+  /**
+   * If true, error is thrown if the revert reason is not a CallExecutionError or ContractFunctionExecutionError
+   */
+  revertIfUnknown = true,
+}: {
+  error: Error;
+  abi?: Abi;
+  revertIfUnknown: boolean;
+}): {
+  reason: string | undefined;
+  rootCause: unknown;
+  /**
+   * If true, the error is a request error.
+   */
+  isRequestError?: boolean;
+} {
+  if (!isBaseError(error)) {
+    if (revertIfUnknown) {
+      throw error;
+    }
+
+    if (error instanceof BaseError) {
+      return { reason: error.shortMessage, rootCause: error };
+    }
+
+    return { reason: error.message, rootCause: error };
+  }
+
+  let cause: unknown = error;
+
+  while (isBaseError(cause)) {
+    if (
+      isViemError(
+        cause,
+        "ContractFunctionExecutionError",
+        ContractFunctionExecutionError,
+      )
+    ) {
+      // let's skip to the deeper cause
+      cause = cause.cause;
+
+      continue;
+    }
+
+    if (
+      isViemError(cause, "TransactionExecutionError", TransactionExecutionError)
+    ) {
+      if (cause.cause instanceof AtomicReadyWalletRejectedUpgradeError) {
+        return {
+          reason: "AtomicReadyWalletRejectedUpgradeError",
+          rootCause: cause.cause,
+        };
+      }
+    }
+    /**
+     * This error is likely to be thrown by publicClient.call. In this case no args are provided when sending tx
+     * but if ABI was provided, we can decode the error from the data
+     *
+     * In theory, we get here from CallExecutionError -> ExecutionRevertedError -> RpcRequestError
+     */
+    if (isViemError(cause, "RpcRequestError", RpcRequestError)) {
+      if (!cause.data) {
+        if (
+          typeof cause.cause === "object" &&
+          cause.cause &&
+          "message" in cause.cause &&
+          typeof cause.cause.message === "string"
+        ) {
+          // this covers special cases
+          return { reason: cause.cause.message, rootCause: cause.cause };
+        }
+
+        throw new Error("No data", { cause });
+      }
+
+      const decodedError = decodeErrorResult({
+        data: cause.data as `0x${string}`,
+        abi: [...commonAbiErrors, ...(abi ?? [])],
+      });
+
+      return {
+        reason: parseDecodedError(decodedError) ?? cause.shortMessage,
+        rootCause: cause,
+      };
+    }
+
+    /**
+     * This error is likely to be thrown by publicClient.simulateContract.
+     * In this case, we can decode the error from the data
+     *
+     * In theory, we get here from ContractFunctionExecutionError -> ContractFunctionRevertedError
+     */
+    if (
+      isViemError(
+        cause,
+        "ContractFunctionRevertedError",
+        ContractFunctionRevertedError,
+      )
+    ) {
+      // If error is not found in the abi, reason is undefined
+      // In this case, we return the signature
+      return {
+        reason:
+          cause.reason ??
+          cause.signature ??
+          cause.data?.errorName ??
+          cause.shortMessage,
+        rootCause: cause,
+      };
+    }
+
+    if (
+      isViemError(cause, "UserRejectedRequestError", UserRejectedRequestError)
+    ) {
+      return { reason: "UserRejectedRequestError", rootCause: cause };
+    }
+
+    if (isViemError(cause, "HttpRequestError", HttpRequestError)) {
+      return {
+        reason: `HttpRequestError(status:${cause.status})`,
+        rootCause: cause,
+        isRequestError: true,
+      };
+    }
+
+    if (!cause.cause) {
+      return { reason: cause.name, rootCause: cause };
+    }
+
+    cause = cause.cause;
+  }
+
+  if (!revertIfUnknown) {
+    return { reason: undefined, rootCause: cause };
+  }
+
+  // Cannot use BeraError here because of circular dependency
+  throw new Error("UnknownErrorInGetRevertReason", {
+    cause: cause,
+  });
+}
+
+/**
+ * Returns the error code thrown by RpcError.
+ *
+ * @see {@link RpcError}
+ * @param errCode - The error code to get the name for.
+ * @returns The name of the error code.
+ */
+export function rpcErrorToReason(
+  errCode:
+    | number
+    | ProviderRpcErrorCode
+    // Here we add errors for which we know the code
+    | "UserRejectedRequestError",
+): string {
+  switch (errCode) {
+    // Actually this should not get here if UserRejectedRequestError is thrown
+    case "UserRejectedRequestError":
+    case 4001:
+      return "UserRejectedRequestError";
+    default:
+      return `RPC_ERROR_${errCode}`;
+  }
+}

package/src/hooks/bend/useGetConvertToAssets.ts

@@ -0,0 +1,42 @@
+import useSWR from "swr";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { type GetConvertToAssetsProps, getConvertToAssets } from "~/actions";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types";
+
+export const useGetConvertToAssets = (
+  {
+    sharesAmount,
+    vaultAddress,
+    vaultChainId,
+  }: Omit<GetConvertToAssetsProps, "publicClient"> & { vaultChainId?: number },
+  options?: DefaultHookOptions,
+) => {
+  const publicClient = usePublicClient({ chainId: vaultChainId });
+  const swrResponse = useSWR(
+    publicClient && sharesAmount && vaultAddress
+      ? ["useGetConvertToAssets", sharesAmount, vaultAddress, vaultChainId]
+      : null,
+    async ([_, sharesAmount, vaultAddress]) => {
+      assertPublicClient(publicClient);
+
+      return getConvertToAssets({
+        sharesAmount,
+        vaultAddress,
+        publicClient,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => {
+      swrResponse.mutate();
+    },
+  };
+};