@berachain/berajs 0.2.12 → 0.2.13

package/dist/errors/errorMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorMap.d.ts","sourceRoot":"","sources":["../../src/errors/errorMap.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAMD,eAAO,MAAM,aAAa,kDAAkD,CAAC;AAE7E,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8nCU,CAAC"}

package/dist/errors/exports.d.ts

@@ -1,328 +1,13 @@
-import { GetPublicClientReturnType } from '@wagmi/core';
-import { Address, PublicClient, TransactionReceipt } from 'viem';
-import { B as BeraError, S as SeverityLevel, I as IBeraErrorArgs } from '../BeraError-7-A5JYy_.js';
-export { a as SpanStatusType, h as httpStatusToSpanStatus, r as reasonToSpanStatus } from '../BeraError-7-A5JYy_.js';
-import { E as EmitterMixin } from '../RequestError-DBOIV65x.js';
-export { B as BeraTracing, R as RequestError, S as SpanContext } from '../RequestError-DBOIV65x.js';
-import { Hex } from '@berachain-foundation/berancer-sdk';
-import '@apollo/client';
-
-/**
- * Asserts that a value is defined.
- * @throws An InvalidArgumentError if the value is undefined or null.
- */
-declare function assertDefined<T>(
-/**
- * The value to assert.
- */
-value: T, 
-/**
- * The property name.
- */
-property: string): asserts value is NonNullable<T>;
-/**
- * Asserts that a value is a PublicClient.
- * @throws An InvalidArgumentError if the value is undefined or not a PublicClient.
- */
-declare function assertPublicClient(
-/**
- * The value to assert.
- */
-value: // it's important to have both types here because it helps with typescript build performance
-PublicClient | GetPublicClientReturnType | undefined, 
-/**
- * The property name.
- */
-property?: string): asserts value is PublicClient;
-/**
- * Asserts that a value is an address (20 bytes).
- * @throws An InvalidArgumentError if the value is undefined, null, not a string, or not an address.
- */
-declare function assertAddress(
-/**
- * The value to assert.
- */
-value: string | undefined | null, 
-/**
- * The property name.
- */
-property: string): asserts value is Address;
-/**
- * Asserts that a value is positive (> 0).
- * @throws An InvalidArgumentError if the value is not positive.
- */
-declare function assertPositive(value: string | bigint | number, property: string): void;
-/**
- * Asserts that a value is a number greater than 0.
- * @throws An InvalidArgumentError if the value is undefined, null, not a string or number, or not a number greater than 0.
- */
-declare function assertAmount(
-/**
- * The value to assert.
- */
-value: unknown, 
-/**
- * The property name.
- */
-property: string): asserts value is string | number;
-
-/**
- * Context passed alongside captured exceptions.
- * Mirrors the subset of Sentry's CaptureContext that berajs actually uses.
- */
-interface CaptureContext {
-    level: SeverityLevel;
-    extra?: Record<string, unknown>;
-    tags?: Record<string, string | number | boolean | null | undefined>;
-    fingerprint?: string[];
-    data?: Record<string, unknown>;
-}
-interface ErrorEvent {
-    exception: BeraError;
-    timestamp: number;
-}
-/**
- * A generic error reporter for berajs.
- *
- * Instead of calling Sentry.captureException directly, berajs calls
- * `BeraMonitoring.captureException()`. Consumer apps subscribe via `.on()` and
- * forward events to their monitoring provider (Sentry, Datadog, etc.).
- *
- * @example
- * ```ts
- * // In berajs code:
- * import { BeraMonitoring } from "./BeraMonitoring";
- * BeraMonitoring.captureExceptionException(error);
- *
- * // In app instrumentation:
- * import { BeraMonitoring } from "@berachain/berajs/errors";
- * BeraMonitoring.on((event) => {
- *   if (event.type === "exception") {
- *     Sentry.captureException(event.exception);
- *   }
- * });
- * ```
- */
-declare const BeraMonitoring: {
-    captureException: (exception: BeraError) => void;
-} & EmitterMixin<{
-    exception: (event: ErrorEvent) => void;
-}>;
-
-interface MatchedError {
-    /** The error key in the errorMap (e.g. "NOT_ENOUGH_GAS_TOKEN") */
-    key: string;
-    /** The category in the errorMap (e.g. "RPC", "BEX") */
-    category: string;
-    /** The user-friendly display message */
-    errorMSG: string;
-    /** Whether the match was by exact reason (true) or keyword (false) */
-    matchedByReason: boolean;
-}
-/**
- * Finds the matching error entry in errorMap by reason or message.
- *
- * ## Matching priority:
- * 1. **Exact reason match** (preferred): checks `errorType.reasons` for an exact string match.
- * 2. **Keyword fallback**: checks `errorType.keywords` for case-insensitive substring matches in `message`.
- *
- * @returns The matched error entry with key and category, or null if no match found.
- */
-declare function findMatchingError({ reason, message, }: {
-    reason?: string | null;
-    message?: string;
-}): MatchedError | null;
-/**
- * Resolves a user-friendly displayMessage by matching `reason` and `message` against `errorMap.ts`.
- *
- * This is the bridge between the automatic reason detection pipeline (parseViemError) and
- * the user-facing error messages. Called by the BeraError constructor.
- *
- * ## Matching priority:
- * 1. **Exact reason match** (preferred): checks `errorType.reasons` for an exact string match.
- *    This is the most reliable path — contract revert reasons like "NotEnoughBalance" or "BAL#508"
- *    are matched deterministically.
- * 2. **Keyword fallback**: checks `errorType.keywords` for case-insensitive substring matches in `message`.
- *    Use sparingly — keyword matching can cause false positives (e.g. "InsufficientBalance"
- *    keyword would also match "InsufficientBalanceToPayPythFee").
- * 3. **GENERAL_ERROR fallback**: "Something went wrong. Please try again later."
- *
- * To ensure new contract errors get good displayMessages, add their reason to `errorMap.ts`.
- * The reason is auto-detected by parseViemError — you only need to map it to a message here.
- */
-declare function getErrorMessage({ reason, message, }: {
-    reason?: string | null;
-    message?: string;
-}): string;
-
-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",
- *  });
- * }
- * ```
- *
- */
-declare 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);
-    get isMissing(): boolean;
-    /**
-     * Whether the argument is defined but invalid.
-     */
-    get isInvalid(): boolean;
-}
-
-/**
- * The preferred way to normalize any unknown error into a BeraError.
- *
- * This function acts as a smart factory that picks the correct BeraError subclass:
- *
- * 1. If `cause` is already a `BeraError`, returns it as-is (no double-wrapping).
- * 2. If `cause` is a viem `BaseError`, runs `parseViemError` to classify it:
- *    - If the root cause is an `HttpRequestError` (RPC transport failure), wraps it
- *      in a `RequestError` with the endpoint URL extracted from the error.
- * 3. Otherwise, wraps in a new `BeraError` — which triggers the automatic reason
- *    detection pipeline in the BeraError constructor (parseViemError → errorMap → displayMessage).
- *
- * **Use this instead of `new BeraError({ cause })` when you don't know the error type.**
- * It ensures RequestErrors are correctly classified (important for Sentry filtering
- * and fingerprinting — RequestErrors are skipped from transaction error grouping).
- *
- * @example
- * ```ts
- * try {
- *   await someOperation();
- * } catch (error) {
- *   // Normalizes to the right subclass, reason auto-detected
- *   throw initBeraError({ cause: error });
- * }
- * ```
- *
- * @example
- * ```ts
- * // Reporting to Sentry without rethrowing
- * catch (error) {
- *   captureException(initBeraError({ cause: error }));
- * }
- * ```
- */
-declare function initBeraError({ cause: error, level, }: {
-    cause: unknown;
-    /**
-     * The severity level of the error, only used if the error is not a BeraError.
-     */
-    level?: SeverityLevel;
-}): BeraError;
-
-interface INotFoundErrorArgs extends IBeraErrorArgs {
-    resource: string;
-    id: string;
-    chainId: number;
-}
-/**
- * Error thrown when a resource is not found.
- */
-declare 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);
-}
-
-/**
- * This error is generally thrown by beraWriteContract when a transaction or simulation fails.
- */
-declare 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;
-    /**
-     * 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;
-    });
-}
-
-export { BeraError, BeraMonitoring, type CaptureContext, type ErrorEvent, IBeraErrorArgs, type IInvalidArgumentErrorArgs, type INotFoundErrorArgs, InvalidArgumentError, type MatchedError, NotFoundError, SeverityLevel, TransactionFailedError, assertAddress, assertAmount, assertDefined, assertPositive, assertPublicClient, findMatchingError, getErrorMessage, initBeraError };
+export * from "./assert";
+export * from "./BeraError";
+export { BeraMonitoring, type CaptureContext, type ErrorEvent, } from "./BeraMonitoring";
+export { BeraTracing, type SpanContext } from "./BeraTracing";
+export * from "./getErrorMessage";
+export * from "./InvalidArgumentError";
+export * from "./initBeraError";
+export * from "./NotFoundError";
+export * from "./RequestError";
+export type { SeverityLevel } from "./severity";
+export { httpStatusToSpanStatus, reasonToSpanStatus, type SpanStatusType, } from "./spanStatus";
+export * from "./TransactionFailedError";
+//# sourceMappingURL=exports.d.ts.map

package/dist/errors/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../src/errors/exports.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,OAAO,EACL,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AACtB,cAAc,0BAA0B,CAAC"}

package/dist/errors/exports.mjs

@@ -1,24 +1,25 @@
 import {
   NotFoundError,
   TransactionFailedError
-} from "../chunk-AUOPN6NK.mjs";
+} from "../chunk-EJIGERYM.mjs";
 import {
   BeraMonitoring,
   initBeraError
-} from "../chunk-FGION6F6.mjs";
+} from "../chunk-LE4CYW7S.mjs";
 import {
   assertAddress,
   assertAmount,
   assertDefined,
+  assertInteger,
   assertPositive,
   assertPublicClient
-} from "../chunk-GY6B3PD5.mjs";
+} from "../chunk-QQASX4LJ.mjs";
 import {
   BeraTracing
-} from "../chunk-SZ5C44L5.mjs";
+} from "../chunk-BMNEN4OK.mjs";
 import {
   RequestError
-} from "../chunk-RFJGL4MF.mjs";
+} from "../chunk-P3YZ7F22.mjs";
 import {
   BeraError,
   InvalidArgumentError,
@@ -26,7 +27,7 @@ import {
   getErrorMessage,
   httpStatusToSpanStatus,
   reasonToSpanStatus
-} from "../chunk-KHXJDYA4.mjs";
+} from "../chunk-NZAH3SGT.mjs";
 export {
   BeraError,
   BeraMonitoring,
@@ -38,6 +39,7 @@ export {
   assertAddress,
   assertAmount,
   assertDefined,
+  assertInteger,
   assertPositive,
   assertPublicClient,
   findMatchingError,
@@ -46,3 +48,4 @@ export {
   initBeraError,
   reasonToSpanStatus
 };
+//# sourceMappingURL=exports.mjs.map

package/dist/errors/exports.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/errors/getErrorMessage.d.ts

@@ -0,0 +1,46 @@
+export interface MatchedError {
+    /** The error key in the errorMap (e.g. "NOT_ENOUGH_GAS_TOKEN") */
+    key: string;
+    /** The category in the errorMap (e.g. "RPC", "BEX") */
+    category: string;
+    /** The user-friendly display message */
+    errorMSG: string;
+    /** Whether the match was by exact reason (true) or keyword (false) */
+    matchedByReason: boolean;
+}
+/**
+ * Finds the matching error entry in errorMap by reason or message.
+ *
+ * ## Matching priority:
+ * 1. **Exact reason match** (preferred): checks `errorType.reasons` for an exact string match.
+ * 2. **Keyword fallback**: checks `errorType.keywords` for case-insensitive substring matches in `message`.
+ *
+ * @returns The matched error entry with key and category, or null if no match found.
+ */
+export declare function findMatchingError({ reason, message, }: {
+    reason?: string | null;
+    message?: string;
+}): MatchedError | null;
+/**
+ * Resolves a user-friendly displayMessage by matching `reason` and `message` against `errorMap.ts`.
+ *
+ * This is the bridge between the automatic reason detection pipeline (parseViemError) and
+ * the user-facing error messages. Called by the BeraError constructor.
+ *
+ * ## Matching priority:
+ * 1. **Exact reason match** (preferred): checks `errorType.reasons` for an exact string match.
+ *    This is the most reliable path — contract revert reasons like "NotEnoughBalance" or "BAL#508"
+ *    are matched deterministically.
+ * 2. **Keyword fallback**: checks `errorType.keywords` for case-insensitive substring matches in `message`.
+ *    Use sparingly — keyword matching can cause false positives (e.g. "InsufficientBalance"
+ *    keyword would also match "InsufficientBalanceToPayPythFee").
+ * 3. **GENERAL_ERROR fallback**: "Something went wrong. Please try again later."
+ *
+ * To ensure new contract errors get good displayMessages, add their reason to `errorMap.ts`.
+ * The reason is auto-detected by parseViemError — you only need to map it to a message here.
+ */
+export declare function getErrorMessage({ reason, message, }: {
+    reason?: string | null;
+    message?: string;
+}): string;
+//# sourceMappingURL=getErrorMessage.d.ts.map

package/dist/errors/getErrorMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getErrorMessage.d.ts","sourceRoot":"","sources":["../../src/errors/getErrorMessage.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,MAAM,EACN,OAAO,GACR,EAAE;IACD,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,YAAY,GAAG,IAAI,CAyCtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,OAAO,GACR,EAAE;IACD,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAET"}

package/dist/errors/getRevertReason.d.ts

@@ -0,0 +1,53 @@
+import { type Abi, type Address, type Hex, type PublicClient } from "viem";
+import { parseViemError } from "./parseViemError";
+export type GetRevertReasonArgs = {
+    publicClient: PublicClient;
+    abi?: Abi;
+} & ({
+    txHash: Hex;
+} | ({
+    blockNumber: bigint;
+    to: Address;
+    account: Address;
+    value?: bigint | undefined;
+} & ({
+    data: Hex;
+} | {
+    value: bigint;
+} | {
+    args: readonly unknown[] | undefined;
+    functionName: string | undefined;
+    value?: bigint;
+})));
+/**
+ * Recovers the revert reason for a transaction that failed **on-chain**.
+ *
+ * When a transaction is mined but reverts, the revert reason is no longer available in the
+ * original viem error (we only get `status: "reverted"` in the receipt). This function
+ * recovers the reason by **replaying the transaction** at the same block number.
+ *
+ * ## How it works
+ *
+ * 1. **Reconstruct the call:** Either from a `txHash` (fetches tx data from chain) or from
+ *    explicit `blockNumber + to + account + data/functionName+args`.
+ * 2. **Replay via simulateContract:** Calls `publicClient.simulateContract` at the original
+ *    `blockNumber`, which reproduces the exact revert that happened on-chain.
+ * 3. **Parse the revert:** The simulated revert throws a viem error, which is caught and
+ *    parsed by `parseViemError` to extract the reason.
+ *
+ * ## Usage context
+ *
+ * This function is called internally by `beraWriteContract` when a transaction receipt has
+ * `status: "reverted"`. The recovered reason is passed into `TransactionFailedError`, which
+ * then feeds into the standard pipeline (errorMap → displayMessage → Sentry).
+ *
+ * ## ABI importance
+ *
+ * Passing the correct ABI is critical here. Without it, custom error names cannot be decoded
+ * and the reason falls back to a hex selector. The ABI is merged with `commonAbiErrors`
+ * (which includes `Error(string)` and `Panic(uint256)`) to handle standard reverts.
+ *
+ * @returns Same shape as parseViemError: `{ reason, rootCause }`
+ */
+export declare function getRevertReason({ publicClient, abi: providedAbi, ...params }: GetRevertReasonArgs): Promise<ReturnType<typeof parseViemError>>;
+//# sourceMappingURL=getRevertReason.d.ts.map

package/dist/errors/getRevertReason.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRevertReason.d.ts","sourceRoot":"","sources":["../../src/errors/getRevertReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,GAAG,EAER,KAAK,OAAO,EAEZ,KAAK,GAAG,EACR,KAAK,YAAY,EAClB,MAAM,MAAM,CAAC;AAId,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,CAAC,EAAE,GAAG,CAAC;CACX,GAAG,CACA;IACE,MAAM,EAAE,GAAG,CAAC;CACb,GACD,CAAC;IACC,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B,GAAG,CACA;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GACb;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACjB;IACE,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,CAAC;IACrC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CACJ,CAAC,CACL,CAAC;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,eAAe,CAAC,EACpC,YAAY,EACZ,GAAG,EAAE,WAAW,EAChB,GAAG,MAAM,EACV,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAmJlE"}

package/dist/errors/getRevertReason.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getRevertReason.integration.test.d.ts.map

package/dist/errors/getRevertReason.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRevertReason.integration.test.d.ts","sourceRoot":"","sources":["../../src/errors/getRevertReason.integration.test.ts"],"names":[],"mappings":""}

package/dist/errors/initBeraError.d.ts

@@ -0,0 +1,44 @@
+import { BeraError } from "./BeraError";
+import type { SeverityLevel } from "./severity";
+/**
+ * The preferred way to normalize any unknown error into a BeraError.
+ *
+ * This function acts as a smart factory that picks the correct BeraError subclass:
+ *
+ * 1. If `cause` is already a `BeraError`, returns it as-is (no double-wrapping).
+ * 2. If `cause` is a viem `BaseError`, runs `parseViemError` to classify it:
+ *    - If the root cause is an `HttpRequestError` (RPC transport failure), wraps it
+ *      in a `RequestError` with the endpoint URL extracted from the error.
+ * 3. Otherwise, wraps in a new `BeraError` — which triggers the automatic reason
+ *    detection pipeline in the BeraError constructor (parseViemError → errorMap → displayMessage).
+ *
+ * **Use this instead of `new BeraError({ cause })` when you don't know the error type.**
+ * It ensures RequestErrors are correctly classified (important for Sentry filtering
+ * and fingerprinting — RequestErrors are skipped from transaction error grouping).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   // Normalizes to the right subclass, reason auto-detected
+ *   throw initBeraError({ cause: error });
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Reporting to Sentry without rethrowing
+ * catch (error) {
+ *   captureException(initBeraError({ cause: error }));
+ * }
+ * ```
+ */
+export declare function initBeraError({ cause: error, level, }: {
+    cause: unknown;
+    /**
+     * The severity level of the error, only used if the error is not a BeraError.
+     */
+    level?: SeverityLevel;
+}): BeraError;
+//# sourceMappingURL=initBeraError.d.ts.map

package/dist/errors/initBeraError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initBeraError.d.ts","sourceRoot":"","sources":["../../src/errors/initBeraError.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EAAE,KAAK,EACZ,KAAK,GACN,EAAE;IACD,KAAK,EAAE,OAAO,CAAC;IACf;;OAEG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB,GAAG,SAAS,CAwCZ"}

package/dist/errors/parseViemError.d.ts

@@ -0,0 +1,88 @@
+import { type Abi, type DecodeErrorResultReturnType, type ProviderRpcErrorCode } from "viem";
+/**
+ * Extracts a human-readable reason string from a decoded Solidity error.
+ *
+ * Solidity has two kinds of revert errors:
+ * - `revert("some message")` → decoded as `Error(string)` where the message is in `args[0]`.
+ *   In this case we return the string argument (e.g. `"BAL#508"`).
+ * - `revert CustomError(...)` → decoded as `CustomError(...)` where `errorName` is the
+ *   custom error name. In this case we return `errorName` (e.g. `"NotEnoughBalance"`).
+ *
+ * The returned string is used as the `reason` field in BeraError and is matched against
+ * `errorMap.ts` to resolve a user-friendly `displayMessage`.
+ */
+export declare function parseDecodedError<const abi extends Abi | readonly unknown[]>(error: DecodeErrorResultReturnType<abi>): string | undefined;
+/**
+ * The reason extraction engine — recursively unwraps viem error chains to extract
+ * a machine-readable `reason` string.
+ *
+ * This function is the core of the automatic reason detection system. It is called by:
+ * - `BeraError` constructor (when `reason` is not manually provided)
+ * - `initBeraError` (to detect if the error is a RequestError)
+ * - `getRevertReason` (after replaying a failed on-chain transaction)
+ *
+ * ## Viem error chain structure
+ *
+ * Viem errors are deeply nested. The typical chains look like:
+ *
+ * **From `simulateContract`:**
+ * ```
+ * ContractFunctionExecutionError          ← wrapper, skipped
+ *   └── ContractFunctionRevertedError     ← reason extracted here (cause.reason / cause.signature)
+ * ```
+ *
+ * **From `publicClient.call` (raw call):**
+ * ```
+ * CallExecutionError                      ← wrapper, skipped
+ *   └── ExecutionRevertedError            ← wrapper, skipped
+ *         └── RpcRequestError             ← reason decoded from cause.data using ABI
+ * ```
+ *
+ * **From `writeContract` / `sendTransaction`:**
+ * ```
+ * TransactionExecutionError               ← checked for special wallet errors
+ *   └── UserRejectedRequestError          ← "UserRejectedRequestError"
+ *   └── AtomicReadyWalletRejectedUpgradeError ← "AtomicReadyWalletRejectedUpgradeError"
+ * ```
+ *
+ * **From RPC transport failures:**
+ * ```
+ * ContractFunctionExecutionError          ← wrapper, skipped
+ *   └── HttpRequestError                  ← "HttpRequestError(status:<code>)", isRequestError=true
+ * ```
+ *
+ * The function walks `cause.cause` in a while loop until it finds an error type it can
+ * extract a reason from, or runs out of nested causes.
+ *
+ * ## Parameters
+ *
+ * @param error - Any Error instance (typically a viem BaseError).
+ * @param abi - Optional contract ABI. Merged with `commonAbiErrors` to decode revert data.
+ *              Passing the correct ABI enables decoding custom error names (e.g. "SlippageExceeded")
+ *              instead of falling back to hex selectors (e.g. "0xa3b1e29f").
+ * @param revertIfUnknown - If true, throws when the error doesn't match any known pattern.
+ *                          The BeraError constructor calls with `true`; `initBeraError` calls with `false`.
+ *
+ * @returns `{ reason, rootCause, isRequestError? }` where:
+ *   - `reason` is the extracted error code/name (matched against errorMap.ts for displayMessage)
+ *   - `rootCause` is the deepest error in the chain that was identified
+ *   - `isRequestError` is true if the error is an HTTP/RPC transport failure
+ */
+export declare function parseViemError({ error, abi, revertIfUnknown, }: {
+    error: Error;
+    abi?: Abi;
+    revertIfUnknown: boolean;
+}): {
+    reason: string | undefined;
+    rootCause: unknown;
+    isRequestError?: boolean;
+};
+/**
+ * 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 declare function rpcErrorToReason(errCode: number | ProviderRpcErrorCode | "UserRejectedRequestError"): string;
+//# sourceMappingURL=parseViemError.d.ts.map

package/dist/errors/parseViemError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseViemError.d.ts","sourceRoot":"","sources":["../../src/errors/parseViemError.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,GAAG,EAKR,KAAK,2BAA2B,EAGhC,KAAK,oBAAoB,EAI1B,MAAM,MAAM,CAAC;AAmDd;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,CAAC,GAAG,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC1E,KAAK,EAAE,2BAA2B,CAAC,GAAG,CAAC,GACtC,MAAM,GAAG,SAAS,CAYpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,GAAG,EACH,eAAsB,GACvB,EAAE;IACD,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,eAAe,EAAE,OAAO,CAAC;CAC1B,GAAG;IACF,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CA6IA;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EACH,MAAM,GACN,oBAAoB,GAEpB,0BAA0B,GAC7B,MAAM,CASR"}

package/dist/errors/severity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Severity levels for error reporting.
+ * Mirrors Sentry's SeverityLevel for compatibility, but owned by berajs
+ * so we don't depend on @sentry/nextjs.
+ */
+export type SeverityLevel = "fatal" | "error" | "warning" | "log" | "info" | "debug";
+//# sourceMappingURL=severity.d.ts.map

package/dist/errors/severity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"severity.d.ts","sourceRoot":"","sources":["../../src/errors/severity.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GACrB,OAAO,GACP,OAAO,GACP,SAAS,GACT,KAAK,GACL,MAAM,GACN,OAAO,CAAC"}