@berachain/berajs 0.1.0 → 0.1.2

package/src/errors/BeraError.ts

@@ -0,0 +1,202 @@
+import type * as Sentry from "@sentry/nextjs";
+import { type Abi, BaseError } from "viem";
+
+import { appConfig } from "@berachain/config/internal";
+
+import { GENERAL_ERROR } from "./errorMap";
+import { getErrorMessage } from "./getErrorMessage";
+import { parseViemError, rpcErrorToReason } from "./parseViemError";
+
+export interface IBeraErrorArgs {
+  message?: string;
+  displayMessage?: string;
+  cause?: unknown;
+  reason?: string;
+  chainId?: number;
+  /**
+   * The level of the error to be used for Sentry.
+   */
+  level?: Sentry.SeverityLevel;
+  tags?: {
+    [key in TagsKey]?: Primitive;
+  };
+  extra?: Record<string, unknown>;
+  /**
+   * Optional ABI to be used to parse the error.
+   */
+  abi?: Abi;
+}
+
+/**
+ * Copy pasted from sentry types
+ */
+type Primitive = number | string | boolean | bigint | symbol | null | undefined;
+
+/**
+ * An helper type to make sure we only use the allowed tags. Sync this with docs/errors.md
+ */
+type TagsKey =
+  | "wallet.chain"
+  | "wallet.connector"
+  | "wallet.address"
+  | "error.reason"
+  | "operation.type"
+  | "operation.key"
+  | "operation.txn.functionName"
+  | "operation.txn.to"
+  | "operation.txn.status"
+  | "operation.source.url"
+  | "operation.source.name"
+  | "operation.source.queryName"
+  | "operation.source.type";
+
+/**
+ * This is a generic error class that can be used to handle errors in the SDK.
+ */
+export class BeraError extends Error {
+  /**
+   * A human-readable message that can be displayed to end user.
+   *
+   * In berachain dapps, this is shown in the error pop-up.
+   */
+  displayMessage: string;
+
+  /**
+   * The cause of the error.
+   *
+   * This is typically the error that was thrown.
+   */
+  cause: unknown;
+
+  /**
+   * The chain id of the error.
+   */
+  chainId?: number;
+
+  /**
+   * The code for the reason for the error.
+   *
+   * This is typically the error code can be found in the errorMap.ts file. I.e. NotEnoughBalance or BAL#508
+   */
+  reason: string | null = null;
+
+  private _tags: {
+    [key: string | TagsKey]: Primitive;
+  } = {};
+
+  set tags(tags: {
+    [key: string | TagsKey]: Primitive;
+  }) {
+    this._tags = tags;
+  }
+
+  get tags(): {
+    [key: string | TagsKey]: Primitive;
+  } {
+    return {
+      ...this._tags,
+      "error.displayMessage": this.displayMessage,
+      "error.reason": this.reason,
+      "error.level": this.level,
+    };
+  }
+
+  level: Sentry.SeverityLevel = "error";
+
+  extra: Record<string, unknown> = {};
+
+  constructor({
+    message: m,
+    displayMessage: dm,
+    cause,
+    reason,
+    level,
+    abi,
+    tags,
+    chainId,
+  }: IBeraErrorArgs) {
+    let message = m;
+
+    if (!message) {
+      if (cause instanceof BaseError) {
+        // Using shortMesage as it doesn't include the payload.
+        message = cause.shortMessage;
+      } else if (cause instanceof Error) {
+        message = cause.message;
+      } else if (
+        typeof cause === "object" &&
+        cause !== null &&
+        "message" in cause &&
+        typeof cause.message === "string"
+      ) {
+        // this covers responses from HTTP requests
+        message = cause.message;
+      }
+    }
+    super(message, {
+      cause,
+    });
+
+    this.name = "BeraError";
+
+    this.cause = cause;
+
+    this.chainId = chainId;
+
+    if (reason) {
+      this.reason = reason;
+    } else if (cause instanceof Error) {
+      try {
+        const parsed = parseViemError({
+          error: cause,
+          revertIfUnknown: true,
+          abi,
+        });
+
+        this.reason = parsed?.reason ?? null;
+      } catch {
+        // Maybe we can do something here
+      }
+    }
+
+    if (level) {
+      this.level = level;
+    } else if (this.reason === rpcErrorToReason("UserRejectedRequestError")) {
+      this.level = "info";
+    } else {
+      this.level = "error";
+    }
+
+    let displayMessage = dm;
+
+    if (
+      this.cause instanceof BeraError &&
+      this.cause.displayMessage !== GENERAL_ERROR
+    ) {
+      // If the cause is a BeraError, use the displayMessage of the cause
+      displayMessage = this.cause.displayMessage;
+    }
+
+    // Skip if displayMessage is already provided
+    if (!displayMessage) {
+      displayMessage = getErrorMessage(this);
+    }
+
+    this.displayMessage = displayMessage ?? GENERAL_ERROR;
+
+    this.tags = {
+      ...this.tags,
+      ...tags,
+    };
+    // Useful for debugging in development or on vercel preview links
+    if (!appConfig.env.isProduction && process.env.NODE_ENV !== "test") {
+      console.group("BeraError thrown");
+      console.debug("Level", this.level);
+      console.debug("Reason", this.reason);
+      console.debug("Message", this.message);
+      console.debug("Display Message", this.displayMessage);
+      console.debug("Cause", this.cause);
+      console.groupEnd();
+    }
+  }
+}

package/src/errors/InvalidArgumentError.ts

@@ -0,0 +1,81 @@
+import { BeraError, type IBeraErrorArgs } from "./BeraError";
+
+export interface IInvalidArgumentErrorArgs extends IBeraErrorArgs {
+  /**
+   * The name of the argument that is invalid.
+   */
+  property: string;
+  /**
+   * The value of the argument that is invalid.
+   */
+  value: unknown;
+
+  /**
+   * The expected type of the value as a string, eg. string, number, boolean, etc.
+   */
+  expected: string;
+}
+
+/**
+ * Error thrown when argument validation fails. (e.g. an argument is missing or invalid)
+ *
+ * Default level is "warning".
+ *
+ * @example ```ts
+ * if (!publicClient) {
+ *  throw new InvalidArgumentError({
+ *    property: "publicClient",
+ *    value: publicClient,
+ *    expected: "PublicClient",
+ *  });
+ * }
+ * if (!address || !isAddress(address)) {
+ *  throw new InvalidArgumentError({
+ *    property: "address",
+ *    value: address,
+ *    expected: "Address",
+ *  });
+ * }
+ * ```
+ *
+ */
+export class InvalidArgumentError extends BeraError {
+  /**
+   * The name of the argument that is invalid.
+   */
+  property: string;
+  /**
+   * The value of the argument that is invalid.
+   */
+  value: unknown;
+
+  /**
+   * The expected value of the argument.
+   */
+  expected: string;
+
+  constructor(args: IInvalidArgumentErrorArgs) {
+    super(args);
+    this.level = args.level ?? "warning";
+    this.name = "InvalidArgumentError";
+    this.property = args.property;
+    this.value = args.value;
+    this.expected = args.expected;
+    this.message = `Invalid argument: ${this.property} ${this.isMissing ? "is missing" : `is invalid, expected ${this.expected}`}`;
+
+    if (!args.reason) {
+      this.reason = `${this.name}.${this.property}.${this.isInvalid ? "invalid" : "missing"}`;
+    }
+  }
+
+  get isMissing(): boolean {
+    return this.value === undefined;
+  }
+
+  /**
+   * Whether the argument is defined but invalid.
+   */
+  get isInvalid(): boolean {
+    return this.value !== undefined;
+  }
+}

package/src/errors/NotFoundError.ts

@@ -0,0 +1,34 @@
+import { BeraError, type IBeraErrorArgs } from "./BeraError";
+
+export interface INotFoundErrorArgs extends IBeraErrorArgs {
+  resource: string;
+  id: string;
+  chainId: number;
+}
+
+/**
+ * Error thrown when a resource is not found.
+ */
+export class NotFoundError extends BeraError {
+  /**
+   * The name of the resource that was not found.
+   *
+   * @example "Reward vault"
+   */
+  resource: string;
+  /**
+   * The id of the resource that was not found.
+   *
+   * @example "0x1234567890123456789012345678901234567890"
+   */
+  id: string;
+
+  constructor(args: INotFoundErrorArgs) {
+    super(args);
+    this.name = "NotFoundError";
+    this.level = args.level ?? "info";
+    this.message = `Resource ${args.resource} with id ${args.id} not found`;
+    this.resource = args.resource;
+    this.id = args.id;
+  }
+}

package/src/errors/RequestError.ts

@@ -0,0 +1,207 @@
+import type { ErrorLike } from "@apollo/client";
+
+import mainnet from "@berachain/config/mainnet";
+
+import { BeraError, type IBeraErrorArgs } from "./BeraError";
+import { errorMsgMap } from "./errorMap";
+
+/**
+ * This is an error class that should be used to handle errors from fetch requests.
+ */
+export class RequestError extends BeraError {
+  /**
+   * The error response from the request.
+   */
+  response: Response | ErrorLike | undefined;
+
+  static isCorsError(error: Error) {
+    return error.cause instanceof Response && error.cause.type === "cors";
+  }
+  /**
+   * The endpoint that was requested.
+   */
+  endpoint: {
+    name?: string;
+    url: string;
+    type?: "rest" | "graphql" | "rpc";
+  };
+
+  /**
+   * A list of domains that should have their query params removed.
+   */
+  private queryRichfulDomains = [
+    mainnet.bex.aggregatorsProxyUrl,
+    "https://api.magpiefi.xyz/aggregator/quote",
+    "https://open-api.openocean.finance/v4/bera/swap",
+    // vercel internal proxy
+    "/api/aggregators?aggregator",
+  ];
+
+  statusCode: number | undefined;
+
+  payload?: object;
+
+  static readonly REASON_MAP = {
+    429: "RATE_LIMITED_429",
+    NETWORK_ERROR: "NETWORK_ERROR",
+    CORS_ERROR: "CORS",
+  } as const;
+
+  constructor(
+    args: IBeraErrorArgs & {
+      response: Response | ErrorLike | undefined;
+      /**
+       * The payload sent to the request.
+       */
+      payload?: object;
+      endpoint:
+        | string
+        | URL
+        | {
+            name?: string;
+            url: string | URL;
+            type: "rest" | "graphql" | "rpc";
+          };
+      statusCode?: number;
+    },
+  ) {
+    super(args);
+    this.name = "RequestError";
+    this.response = args.response;
+    this.payload = args.payload;
+    this.endpoint = this.setEndpoint(args.endpoint);
+
+    if (
+      !this.message &&
+      typeof this.cause === "object" &&
+      this.cause !== null
+    ) {
+      if ("error" in this.cause && typeof this.cause.error === "string") {
+        // haiku returns the error in the response as { error: string }
+        this.message = this.cause.error;
+      }
+    }
+
+    if (args.statusCode) {
+      this.statusCode = args.statusCode;
+    } else if (this.response instanceof Response) {
+      this.statusCode = this.response.status;
+    }
+
+    if (this.statusCode === 429) {
+      this.reason = RequestError.REASON_MAP[429];
+      this.displayMessage = errorMsgMap.HTTP.RATE_LIMITED_429.errorMSG;
+      this.level = args.level ?? "warning";
+    } else {
+      const networkError = this.tryMatchNetworkError();
+      if (networkError) {
+        this.reason = this.reason ?? networkError.reason;
+        this.level = args.level ?? "warning";
+        this.endpoint.url = this.endpoint.url ?? networkError.url;
+      }
+    }
+
+    this.tags = {
+      ...this.tags,
+      "error.statusCode": this.statusCode,
+      "operation.type": "query",
+      ...args.tags,
+    };
+
+    let message = "";
+
+    if (this.reason) {
+      message += `${this.reason} – `;
+    } else if (this.statusCode && this.statusCode >= 400) {
+      message += `HTTP ${this.statusCode} – `;
+    }
+
+    this.message = `${message}${this.endpoint.type}(${this.endpoint.url}): ${this.message}`;
+  }
+
+  setEndpoint(
+    endpoint:
+      | string
+      | URL
+      | {
+          name?: string;
+          url: string | URL;
+          type?: "rest" | "graphql" | "rpc";
+        },
+  ) {
+    if (typeof endpoint === "string" || endpoint instanceof URL) {
+      this.endpoint = {
+        url: typeof endpoint === "string" ? endpoint : endpoint.toString(),
+      };
+    } else {
+      this.endpoint = {
+        ...this.endpoint,
+        ...endpoint,
+        url: endpoint.url.toString(),
+      };
+    }
+
+    if (
+      this.queryRichfulDomains.some((domain) =>
+        this.endpoint.url.includes(domain),
+      )
+    ) {
+      // remove query params if it's an aggregator url
+      try {
+        const url = new URL(this.endpoint.url);
+        url.search = "";
+        this.endpoint.url = url.toString();
+      } catch {}
+    }
+    this.tags = {
+      ...this.tags,
+      "operation.source.url": this.endpoint.url,
+      "operation.source.name": this.endpoint.name,
+      "operation.source.type": this.endpoint.type,
+    };
+
+    return this.endpoint;
+  }
+
+  private tryMatchNetworkError():
+    | false
+    | {
+        reason: string;
+        message: string;
+        url: string;
+      } {
+    if (
+      (this.cause instanceof Error &&
+        "message" in this.cause &&
+        typeof this.cause.message === "string") ||
+      this.cause instanceof TypeError
+    ) {
+      const message = this.cause.message as string;
+
+      if (message.startsWith("Network Error")) {
+        return {
+          reason: RequestError.REASON_MAP.NETWORK_ERROR,
+          message: message,
+          url: this.endpoint.url,
+        };
+      }
+
+      // this matches standard error messages as they're returned by browser fetch when they either:
+      // - have a network error
+      // - have CORS errors
+      // the list is empirically collected from sentry error logs.
+      const failedToFetchMatch = message.match(
+        /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed) \(([a-z0-9-.]+)\)$/,
+      );
+      if (failedToFetchMatch) {
+        return {
+          reason: RequestError.REASON_MAP.NETWORK_ERROR,
+          message: message,
+          url: failedToFetchMatch[1],
+        };
+      }
+    }
+
+    return false;
+  }
+}

package/src/errors/TransactionFailedError.ts

@@ -0,0 +1,93 @@
+import type { Hex } from "@berachain-foundation/berancer-sdk";
+import type { Address, TransactionReceipt } from "viem";
+
+import { BeraError, type IBeraErrorArgs } from "./BeraError";
+
+/**
+ * This error is generally thrown by beraWriteContract when a transaction or simulation fails.
+ */
+export class TransactionFailedError extends BeraError {
+  /**
+   * The hash of the transaction that failed.
+   *
+   * Null if the error is due to a simulation failure.
+   */
+  txHash: string | null;
+
+  /**
+   * The receipt of the transaction that failed.
+   *
+   * Null if the error is due to a simulation failure.
+   */
+  receipt: TransactionReceipt | null;
+
+  /**
+   * The address of the contract that was called.
+   */
+  to: Address | undefined;
+
+  /**
+   * The data of the transaction that failed.
+   */
+  callData: Hex | undefined;
+
+  /**
+   * The block number of the transaction that failed.
+   */
+  blockNumber: bigint | null = null;
+
+  /**
+   * The input of the transaction that failed.
+   */
+  input: object;
+
+  /**
+   * The function name of the transaction that failed.
+   */
+  functionName: string | undefined;
+
+  constructor(
+    args: IBeraErrorArgs & {
+      txHash?: string;
+      receipt?: TransactionReceipt;
+      to?: Address;
+      blockNumber?: bigint;
+      functionName?: string;
+      input: object;
+    },
+  ) {
+    super(args);
+    this.name = "TransactionFailedError";
+    this.txHash = args.txHash || null;
+    this.receipt = args.receipt || null;
+    this.to = args.to;
+    this.functionName = args.functionName;
+    this.blockNumber = args.blockNumber ?? null;
+    this.input = args.input;
+
+    if (this.receipt) {
+      // If we have a receipt, transaction reverted on chain
+      this.message = `Transaction reverted on chain for reason: ${this.reason}`;
+    } else if (this.txHash) {
+      // If we have a tx hash, transaction reverted after being broadcasted but we never got a receipt
+      // Might happen for network reasons
+      this.message = `Transaction reverted after being broadcasted for reason: ${this.reason}`;
+    } else {
+      this.message = `${this.reason}: ${this.message}`;
+    }
+
+    this.tags = {
+      ...this.tags,
+      "operation.txn.status": args.txHash ? "execution" : "simulation",
+      ...args.tags,
+    };
+
+    if (this.to) {
+      this.tags["operation.txn.to"] = this.to;
+    }
+
+    if (this.functionName) {
+      this.tags["operation.txn.functionName"] = this.functionName;
+    }
+  }
+}