@seljs/runtime 1.3.0-beta.28 → 1.3.0-beta.32

package/dist/analysis/dependency-analyzer.cjs

@@ -5,7 +5,7 @@ const debug = require("../debug.cjs").createLogger("analysis:dependency");
 /**
 * Detects circular dependencies in the graph using DFS with a recursion stack.
 *
-* @throws {@link CircularDependencyError} If a cycle is found, including the call IDs forming the cycle
+* @throws {@link SELCircularDependencyError} If a cycle is found, including the call IDs forming the cycle
 */
 const detectCycles = (nodes, edges) => {
 	const visited = /* @__PURE__ */ new Set();
@@ -14,7 +14,7 @@ const detectCycles = (nodes, edges) => {
 		if (inStack.has(nodeId)) {
 			const cycleStart = path.indexOf(nodeId);
 			const cycle = path.slice(cycleStart);
-			throw new require_errors.CircularDependencyError(`Circular dependency detected: ${cycle.join(" -> ")} -> ${nodeId}`, { callIds: cycle });
+			throw new require_errors.SELCircularDependencyError(`Circular dependency detected: ${cycle.join(" -> ")} -> ${nodeId}`, { callIds: cycle });
 		}
 		if (visited.has(nodeId)) return;
 		visited.add(nodeId);
@@ -35,7 +35,7 @@ const detectCycles = (nodes, edges) => {
 *
 * @param calls - Array of collected contract calls from AST traversal
 * @returns A dependency graph with nodes and directed edges
-* @throws {@link CircularDependencyError} If a circular dependency is detected between calls
+* @throws {@link SELCircularDependencyError} If a circular dependency is detected between calls
 */
 const analyzeDependencies = (calls) => {
 	const nodes = /* @__PURE__ */ new Map();

package/dist/analysis/dependency-analyzer.mjs

@@ -1,4 +1,4 @@
-import { CircularDependencyError } from "../errors/errors.mjs";
+import { SELCircularDependencyError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
 import { createLogger } from "../debug.mjs";
 //#region src/analysis/dependency-analyzer.ts
@@ -6,7 +6,7 @@ const debug = createLogger("analysis:dependency");
 /**
 * Detects circular dependencies in the graph using DFS with a recursion stack.
 *
-* @throws {@link CircularDependencyError} If a cycle is found, including the call IDs forming the cycle
+* @throws {@link SELCircularDependencyError} If a cycle is found, including the call IDs forming the cycle
 */
 const detectCycles = (nodes, edges) => {
 	const visited = /* @__PURE__ */ new Set();
@@ -15,7 +15,7 @@ const detectCycles = (nodes, edges) => {
 		if (inStack.has(nodeId)) {
 			const cycleStart = path.indexOf(nodeId);
 			const cycle = path.slice(cycleStart);
-			throw new CircularDependencyError(`Circular dependency detected: ${cycle.join(" -> ")} -> ${nodeId}`, { callIds: cycle });
+			throw new SELCircularDependencyError(`Circular dependency detected: ${cycle.join(" -> ")} -> ${nodeId}`, { callIds: cycle });
 		}
 		if (visited.has(nodeId)) return;
 		visited.add(nodeId);
@@ -36,7 +36,7 @@ const detectCycles = (nodes, edges) => {
 *
 * @param calls - Array of collected contract calls from AST traversal
 * @returns A dependency graph with nodes and directed edges
-* @throws {@link CircularDependencyError} If a circular dependency is detected between calls
+* @throws {@link SELCircularDependencyError} If a circular dependency is detected between calls
 */
 const analyzeDependencies = (calls) => {
 	const nodes = /* @__PURE__ */ new Map();

package/dist/analysis/round-planner.cjs

@@ -12,13 +12,13 @@ const debug = require("../debug.cjs").createLogger("analysis:plan");
 * @param graph Dependency graph representing calls and their relationships.
 * @param limits Optional limits for maximum rounds and total calls.
 * @returns Execution plan containing planned rounds, total calls, and maximum depth.
-* @throws ExecutionLimitError If total calls exceed maxCalls or rounds exceed maxRounds.
+* @throws {@link SELExecutionLimitError} If total calls exceed maxCalls or rounds exceed maxRounds.
 */
 const planRounds = (graph, limits = {}) => {
 	const maxRounds = limits.maxRounds ?? 10;
 	const maxCalls = limits.maxCalls ?? 100;
 	const totalCalls = graph.nodes.size;
-	if (totalCalls > maxCalls) throw new require_errors.ExecutionLimitError(`Execution limit exceeded: ${String(totalCalls)} calls exceeds maxCalls (${String(maxCalls)})`, {
+	if (totalCalls > maxCalls) throw new require_errors.SELExecutionLimitError(`Execution limit exceeded: ${String(totalCalls)} calls exceeds maxCalls (${String(maxCalls)})`, {
 		limitType: "maxCalls",
 		limit: maxCalls,
 		actual: totalCalls
@@ -36,7 +36,7 @@ const planRounds = (graph, limits = {}) => {
 		const readyNodes = [];
 		for (const [nodeId, degree] of inDegree) if (degree === 0 && !processed.has(nodeId)) readyNodes.push(nodeId);
 		if (readyNodes.length === 0) break;
-		if (rounds.length >= maxRounds) throw new require_errors.ExecutionLimitError(`Execution limit exceeded: requires more than maxRounds (${String(maxRounds)}) rounds`, {
+		if (rounds.length >= maxRounds) throw new require_errors.SELExecutionLimitError(`Execution limit exceeded: requires more than maxRounds (${String(maxRounds)}) rounds`, {
 			limitType: "maxRounds",
 			limit: maxRounds,
 			actual: rounds.length + 1

package/dist/analysis/round-planner.mjs

@@ -1,4 +1,4 @@
-import { ExecutionLimitError } from "../errors/errors.mjs";
+import { SELExecutionLimitError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
 import { createLogger } from "../debug.mjs";
 //#region src/analysis/round-planner.ts
@@ -13,13 +13,13 @@ const debug = createLogger("analysis:plan");
 * @param graph Dependency graph representing calls and their relationships.
 * @param limits Optional limits for maximum rounds and total calls.
 * @returns Execution plan containing planned rounds, total calls, and maximum depth.
-* @throws ExecutionLimitError If total calls exceed maxCalls or rounds exceed maxRounds.
+* @throws {@link SELExecutionLimitError} If total calls exceed maxCalls or rounds exceed maxRounds.
 */
 const planRounds = (graph, limits = {}) => {
 	const maxRounds = limits.maxRounds ?? 10;
 	const maxCalls = limits.maxCalls ?? 100;
 	const totalCalls = graph.nodes.size;
-	if (totalCalls > maxCalls) throw new ExecutionLimitError(`Execution limit exceeded: ${String(totalCalls)} calls exceeds maxCalls (${String(maxCalls)})`, {
+	if (totalCalls > maxCalls) throw new SELExecutionLimitError(`Execution limit exceeded: ${String(totalCalls)} calls exceeds maxCalls (${String(maxCalls)})`, {
 		limitType: "maxCalls",
 		limit: maxCalls,
 		actual: totalCalls
@@ -37,7 +37,7 @@ const planRounds = (graph, limits = {}) => {
 		const readyNodes = [];
 		for (const [nodeId, degree] of inDegree) if (degree === 0 && !processed.has(nodeId)) readyNodes.push(nodeId);
 		if (readyNodes.length === 0) break;
-		if (rounds.length >= maxRounds) throw new ExecutionLimitError(`Execution limit exceeded: requires more than maxRounds (${String(maxRounds)}) rounds`, {
+		if (rounds.length >= maxRounds) throw new SELExecutionLimitError(`Execution limit exceeded: requires more than maxRounds (${String(maxRounds)}) rounds`, {
 			limitType: "maxRounds",
 			limit: maxRounds,
 			actual: rounds.length + 1

package/dist/environment/contract-caller.cjs

@@ -18,7 +18,7 @@ var CallCounter = class {
 	}
 	increment(contractName, methodName) {
 		this.count++;
-		if (this.count > this.maxCalls) throw new require_errors.ExecutionLimitError(`Execution limit exceeded: ${String(this.count)} calls exceeds maxCalls (${String(this.maxCalls)})`, {
+		if (this.count > this.maxCalls) throw new require_errors.SELExecutionLimitError(`Execution limit exceeded: ${String(this.count)} calls exceeds maxCalls (${String(this.maxCalls)})`, {
 			limitType: "maxCalls",
 			limit: this.maxCalls,
 			actual: this.count

package/dist/environment/contract-caller.mjs

@@ -1,4 +1,4 @@
-import { ExecutionLimitError, SELContractError } from "../errors/errors.mjs";
+import { SELContractError, SELExecutionLimitError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
 import { createReplayCallId } from "./replay-cache.mjs";
 import { createLogger } from "../debug.mjs";
@@ -17,7 +17,7 @@ var CallCounter = class {
 	}
 	increment(contractName, methodName) {
 		this.count++;
-		if (this.count > this.maxCalls) throw new ExecutionLimitError(`Execution limit exceeded: ${String(this.count)} calls exceeds maxCalls (${String(this.maxCalls)})`, {
+		if (this.count > this.maxCalls) throw new SELExecutionLimitError(`Execution limit exceeded: ${String(this.count)} calls exceeds maxCalls (${String(this.maxCalls)})`, {
 			limitType: "maxCalls",
 			limit: this.maxCalls,
 			actual: this.count

package/dist/environment/environment.cjs

@@ -105,7 +105,9 @@ var SELRuntime = class {
 	*
 	* @param expression - A CEL expression string to type-check
 	* @returns The type-check result containing validity, inferred type, and any errors
-	* @throws {@link SELEvaluationError} If the expression contains unrecoverable type errors
+	* @throws {@link SELParseError} If the expression cannot be parsed
+	* @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+	* @throws {@link SELLintError} If lint rules with error severity match
 	*/
 	check(expression) {
 		try {
@@ -129,9 +131,19 @@ var SELRuntime = class {
 	* @param context Variable bindings for evaluation
 	* @param options Optional client override
 	* @returns An {@link EvaluateResult} containing the value and optional execution metadata
-	* @throws {@link SELLintError} If the expression fails parse, type-check, or lint rules
-	* @throws {@link SELContractError} If a contract call fails or no client is available
+	* @throws {@link SELParseError} If the expression cannot be parsed
+	* @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+	* @throws {@link SELLintError} If lint rules with error severity match
+	* @throws {@link SELConfigError} If an ABI / codec registry entry is missing
+	* @throws {@link SELContractError} If a contract call fails (non-revert)
+	* @throws {@link SELContractRevertError} If a contract call reverted
+	* @throws {@link SELMulticallBatchError} If the Multicall3 batch itself failed
+	* @throws {@link SELProviderTransportError} If the JSON-RPC transport failed
+	* @throws {@link SELProviderRpcError} If the node returned a JSON-RPC error
+	* @throws {@link SELExecutionLimitError} If maxRounds / maxCalls were exceeded
+	* @throws {@link SELCircularDependencyError} If the call graph has a cycle
 	* @throws {@link SELEvaluationError} If CEL evaluation fails
+	* @throws {@link SELTypeConversionError} If a Solidity type wrapper rejected an input
 	*/
 	async evaluate(expression, context, options) {
 		let release;
@@ -175,8 +187,9 @@ var SELRuntime = class {
 		try {
 			executionResult = await executor.execute(plan, executionVariables, await require_contract_caller.resolveExecutionBlockNumber(resolvedClient));
 		} catch (error) {
+			if (error instanceof require_errors.SELContractRevertError) throw error;
 			let failedCall = collectedCalls[0];
-			if (error instanceof require_errors.MulticallBatchError) {
+			if (error instanceof require_errors.SELMulticallBatchError) {
 				if (error.contractName && error.methodName) {
 					const contractName = error.contractName;
 					const methodName = error.methodName;
@@ -194,16 +207,10 @@ var SELRuntime = class {
 				} else if (typeof error.failedCallIndex === "number") failedCall = collectedCalls[error.failedCallIndex] ?? failedCall;
 			}
 			if (!failedCall) throw error;
-			const revertFields = error instanceof require_errors.MulticallBatchError ? {
-				revertReason: error.revertReason,
-				revertData: error.revertData,
-				decodedError: error.decodedError
-			} : {};
 			throw new require_errors.SELContractError(`Contract call failed: ${failedCall.contract}.${failedCall.method}`, {
 				cause: error,
 				contractName: failedCall.contract,
-				methodName: failedCall.method,
-				...revertFields
+				methodName: failedCall.method
 			});
 		}
 		return {

package/dist/environment/environment.d.cts

@@ -52,7 +52,9 @@ declare class SELRuntime {
    *
    * @param expression - A CEL expression string to type-check
    * @returns The type-check result containing validity, inferred type, and any errors
-   * @throws {@link SELEvaluationError} If the expression contains unrecoverable type errors
+   * @throws {@link SELParseError} If the expression cannot be parsed
+   * @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+   * @throws {@link SELLintError} If lint rules with error severity match
    */
   check(expression: string): TypeCheckResult;
   /**
@@ -70,9 +72,19 @@ declare class SELRuntime {
    * @param context Variable bindings for evaluation
    * @param options Optional client override
    * @returns An {@link EvaluateResult} containing the value and optional execution metadata
-   * @throws {@link SELLintError} If the expression fails parse, type-check, or lint rules
-   * @throws {@link SELContractError} If a contract call fails or no client is available
+   * @throws {@link SELParseError} If the expression cannot be parsed
+   * @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+   * @throws {@link SELLintError} If lint rules with error severity match
+   * @throws {@link SELConfigError} If an ABI / codec registry entry is missing
+   * @throws {@link SELContractError} If a contract call fails (non-revert)
+   * @throws {@link SELContractRevertError} If a contract call reverted
+   * @throws {@link SELMulticallBatchError} If the Multicall3 batch itself failed
+   * @throws {@link SELProviderTransportError} If the JSON-RPC transport failed
+   * @throws {@link SELProviderRpcError} If the node returned a JSON-RPC error
+   * @throws {@link SELExecutionLimitError} If maxRounds / maxCalls were exceeded
+   * @throws {@link SELCircularDependencyError} If the call graph has a cycle
    * @throws {@link SELEvaluationError} If CEL evaluation fails
+   * @throws {@link SELTypeConversionError} If a Solidity type wrapper rejected an input
    */
   evaluate<T = unknown>(expression: string, context?: Record<string, unknown>, options?: EvaluateOptions): Promise<EvaluateResult<T>>;
   private planExecution;

package/dist/environment/environment.d.mts

@@ -52,7 +52,9 @@ declare class SELRuntime {
    *
    * @param expression - A CEL expression string to type-check
    * @returns The type-check result containing validity, inferred type, and any errors
-   * @throws {@link SELEvaluationError} If the expression contains unrecoverable type errors
+   * @throws {@link SELParseError} If the expression cannot be parsed
+   * @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+   * @throws {@link SELLintError} If lint rules with error severity match
    */
   check(expression: string): TypeCheckResult;
   /**
@@ -70,9 +72,19 @@ declare class SELRuntime {
    * @param context Variable bindings for evaluation
    * @param options Optional client override
    * @returns An {@link EvaluateResult} containing the value and optional execution metadata
-   * @throws {@link SELLintError} If the expression fails parse, type-check, or lint rules
-   * @throws {@link SELContractError} If a contract call fails or no client is available
+   * @throws {@link SELParseError} If the expression cannot be parsed
+   * @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+   * @throws {@link SELLintError} If lint rules with error severity match
+   * @throws {@link SELConfigError} If an ABI / codec registry entry is missing
+   * @throws {@link SELContractError} If a contract call fails (non-revert)
+   * @throws {@link SELContractRevertError} If a contract call reverted
+   * @throws {@link SELMulticallBatchError} If the Multicall3 batch itself failed
+   * @throws {@link SELProviderTransportError} If the JSON-RPC transport failed
+   * @throws {@link SELProviderRpcError} If the node returned a JSON-RPC error
+   * @throws {@link SELExecutionLimitError} If maxRounds / maxCalls were exceeded
+   * @throws {@link SELCircularDependencyError} If the call graph has a cycle
    * @throws {@link SELEvaluationError} If CEL evaluation fails
+   * @throws {@link SELTypeConversionError} If a Solidity type wrapper rejected an input
    */
   evaluate<T = unknown>(expression: string, context?: Record<string, unknown>, options?: EvaluateOptions): Promise<EvaluateResult<T>>;
   private planExecution;

package/dist/environment/environment.mjs

@@ -1,5 +1,5 @@
 import { getBuiltinContracts } from "./builtin-contracts.mjs";
-import { MulticallBatchError, SELContractError, SELLintError } from "../errors/errors.mjs";
+import { SELContractError, SELContractRevertError, SELLintError, SELMulticallBatchError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
 import { validateClient } from "./client.mjs";
 import { normalizeContextForEvaluation } from "./context.mjs";
@@ -104,7 +104,9 @@ var SELRuntime = class {
 	*
 	* @param expression - A CEL expression string to type-check
 	* @returns The type-check result containing validity, inferred type, and any errors
-	* @throws {@link SELEvaluationError} If the expression contains unrecoverable type errors
+	* @throws {@link SELParseError} If the expression cannot be parsed
+	* @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+	* @throws {@link SELLintError} If lint rules with error severity match
 	*/
 	check(expression) {
 		try {
@@ -128,9 +130,19 @@ var SELRuntime = class {
 	* @param context Variable bindings for evaluation
 	* @param options Optional client override
 	* @returns An {@link EvaluateResult} containing the value and optional execution metadata
-	* @throws {@link SELLintError} If the expression fails parse, type-check, or lint rules
-	* @throws {@link SELContractError} If a contract call fails or no client is available
+	* @throws {@link SELParseError} If the expression cannot be parsed
+	* @throws {@link SELTypeCheckError} If the CEL type-checker rejects the expression
+	* @throws {@link SELLintError} If lint rules with error severity match
+	* @throws {@link SELConfigError} If an ABI / codec registry entry is missing
+	* @throws {@link SELContractError} If a contract call fails (non-revert)
+	* @throws {@link SELContractRevertError} If a contract call reverted
+	* @throws {@link SELMulticallBatchError} If the Multicall3 batch itself failed
+	* @throws {@link SELProviderTransportError} If the JSON-RPC transport failed
+	* @throws {@link SELProviderRpcError} If the node returned a JSON-RPC error
+	* @throws {@link SELExecutionLimitError} If maxRounds / maxCalls were exceeded
+	* @throws {@link SELCircularDependencyError} If the call graph has a cycle
 	* @throws {@link SELEvaluationError} If CEL evaluation fails
+	* @throws {@link SELTypeConversionError} If a Solidity type wrapper rejected an input
 	*/
 	async evaluate(expression, context, options) {
 		let release;
@@ -174,8 +186,9 @@ var SELRuntime = class {
 		try {
 			executionResult = await executor.execute(plan, executionVariables, await resolveExecutionBlockNumber(resolvedClient));
 		} catch (error) {
+			if (error instanceof SELContractRevertError) throw error;
 			let failedCall = collectedCalls[0];
-			if (error instanceof MulticallBatchError) {
+			if (error instanceof SELMulticallBatchError) {
 				if (error.contractName && error.methodName) {
 					const contractName = error.contractName;
 					const methodName = error.methodName;
@@ -193,16 +206,10 @@ var SELRuntime = class {
 				} else if (typeof error.failedCallIndex === "number") failedCall = collectedCalls[error.failedCallIndex] ?? failedCall;
 			}
 			if (!failedCall) throw error;
-			const revertFields = error instanceof MulticallBatchError ? {
-				revertReason: error.revertReason,
-				revertData: error.revertData,
-				decodedError: error.decodedError
-			} : {};
 			throw new SELContractError(`Contract call failed: ${failedCall.contract}.${failedCall.method}`, {
 				cause: error,
 				contractName: failedCall.contract,
-				methodName: failedCall.method,
-				...revertFields
+				methodName: failedCall.method
 			});
 		}
 		return {

package/dist/environment/error-wrapper.cjs

@@ -1,28 +1,87 @@
 require("../_virtual/_rolldown/runtime.cjs");
+const require_errors = require("../errors/errors.cjs");
 require("../errors/index.cjs");
 let _seljs_common = require("@seljs/common");
 let _marcbachmann_cel_js = require("@marcbachmann/cel-js");
+let viem = require("viem");
 //#region src/environment/error-wrapper.ts
 /**
+* Compose a human-readable message from a viem error. Uses `shortMessage`
+* when present and appends any `metaMessages` lines so context like the
+* contract address, function call, and chain is not lost.
+*/
+const extractViemMessage = (error) => {
+	const shortMessage = error.shortMessage || error.message;
+	const meta = error.metaMessages;
+	if (!meta || meta.length === 0) return shortMessage;
+	return `${shortMessage}\n${meta.join("\n")}`;
+};
+const wrapContractRevert = (error) => {
+	const decoded = error.data ? {
+		name: error.data.errorName,
+		args: error.data.args ?? []
+	} : void 0;
+	return new require_errors.SELContractRevertError(extractViemMessage(error), {
+		cause: error,
+		revertReason: error.reason,
+		revertData: error.raw,
+		decodedError: decoded
+	});
+};
+const wrapViemError = (error) => {
+	const nestedRevert = error.walk((e) => e instanceof viem.ContractFunctionRevertedError);
+	if (nestedRevert) return wrapContractRevert(nestedRevert);
+	if (error instanceof viem.ContractFunctionRevertedError) return wrapContractRevert(error);
+	if (error instanceof viem.ContractFunctionExecutionError) return new require_errors.SELContractError(extractViemMessage(error), {
+		cause: error,
+		contractName: error.contractAddress,
+		methodName: error.functionName
+	});
+	if (error instanceof viem.AbiDecodingDataSizeInvalidError || error instanceof viem.AbiDecodingZeroDataError || error instanceof viem.AbiErrorSignatureNotFoundError) return new require_errors.SELContractError(extractViemMessage(error), { cause: error });
+	if (error instanceof viem.HttpRequestError) return new require_errors.SELProviderTransportError(extractViemMessage(error), {
+		cause: error,
+		httpStatus: error.status,
+		url: error.url,
+		body: typeof error.body === "string" ? error.body : error.body !== void 0 ? JSON.stringify(error.body) : void 0
+	});
+	if (error instanceof viem.TimeoutError || error instanceof viem.WebSocketRequestError) return new require_errors.SELProviderTransportError(extractViemMessage(error), {
+		cause: error,
+		url: error instanceof viem.WebSocketRequestError ? error.url : void 0
+	});
+	if (error instanceof viem.RpcError) {
+		const rpc = error;
+		return new require_errors.SELProviderRpcError(extractViemMessage(error), {
+			cause: error,
+			rpcCode: rpc.code,
+			rpcData: rpc.data
+		});
+	}
+	return new require_errors.SELProviderError(extractViemMessage(error), { cause: error });
+};
+/**
 * Wraps an unknown error into a known SEL error type.
-* - If the error is already a SEL error, it is returned as is.
-* - If the error is a CEL error, it is wrapped into the corresponding SEL error type.
-* - If the error is an unknown type, it is wrapped into a generic Error.
 *
-* @param error The error to wrap.
-* @returns The wrapped error.
+* - A `SELError` is returned as-is.
+* - cel-js errors (`ParseError`, `TypeError`, `EvaluationError`) become the
+*   matching `SEL*Error` and preserve `cause`.
+* - viem errors are routed by concrete class: reverts → `SELContractRevertError`,
+*   transport/timeout → `SELProviderTransportError`, JSON-RPC → `SELProviderRpcError`,
+*   contract execution / ABI decode → `SELContractError`, everything else → `SELProviderError`.
+* - Any other `Error` becomes `SELEvaluationError` with the original as `cause`.
 */
 const wrapError = (error) => {
 	if (error instanceof _seljs_common.SELError) return error;
 	if (error instanceof _marcbachmann_cel_js.EvaluationError) {
 		const cause = error.cause;
 		if (cause instanceof _seljs_common.SELError) return cause;
+		if (cause instanceof viem.BaseError) return wrapViemError(cause);
 		return new _seljs_common.SELEvaluationError(error.message, { cause: error });
 	}
-	if (error instanceof _marcbachmann_cel_js.ParseError) return new _seljs_common.SELEvaluationError(error.message, { cause: error });
-	if (error instanceof _marcbachmann_cel_js.TypeError) return new _seljs_common.SELEvaluationError(error.message, { cause: error });
-	if (error instanceof Error) return error;
-	return new Error(String(error));
+	if (error instanceof _marcbachmann_cel_js.ParseError) return new _seljs_common.SELParseError(error.message, { cause: error });
+	if (error instanceof _marcbachmann_cel_js.TypeError) return new _seljs_common.SELTypeCheckError(error.message, { cause: error });
+	if (error instanceof viem.BaseError) return wrapViemError(error);
+	if (error instanceof Error) return new _seljs_common.SELEvaluationError(error.message, { cause: error });
+	return new _seljs_common.SELEvaluationError(String(error));
 };
 //#endregion
 exports.wrapError = wrapError;

package/dist/environment/error-wrapper.mjs

@@ -1,28 +1,86 @@
-import { SELEvaluationError } from "../errors/errors.mjs";
+import { SELContractError, SELContractRevertError, SELProviderError, SELProviderRpcError, SELProviderTransportError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
-import { SELError } from "@seljs/common";
+import { SELError, SELEvaluationError, SELParseError, SELTypeCheckError } from "@seljs/common";
 import { EvaluationError, ParseError, TypeError } from "@marcbachmann/cel-js";
+import { AbiDecodingDataSizeInvalidError, AbiDecodingZeroDataError, AbiErrorSignatureNotFoundError, BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, HttpRequestError, RpcError, TimeoutError, WebSocketRequestError } from "viem";
 //#region src/environment/error-wrapper.ts
 /**
+* Compose a human-readable message from a viem error. Uses `shortMessage`
+* when present and appends any `metaMessages` lines so context like the
+* contract address, function call, and chain is not lost.
+*/
+const extractViemMessage = (error) => {
+	const shortMessage = error.shortMessage || error.message;
+	const meta = error.metaMessages;
+	if (!meta || meta.length === 0) return shortMessage;
+	return `${shortMessage}\n${meta.join("\n")}`;
+};
+const wrapContractRevert = (error) => {
+	const decoded = error.data ? {
+		name: error.data.errorName,
+		args: error.data.args ?? []
+	} : void 0;
+	return new SELContractRevertError(extractViemMessage(error), {
+		cause: error,
+		revertReason: error.reason,
+		revertData: error.raw,
+		decodedError: decoded
+	});
+};
+const wrapViemError = (error) => {
+	const nestedRevert = error.walk((e) => e instanceof ContractFunctionRevertedError);
+	if (nestedRevert) return wrapContractRevert(nestedRevert);
+	if (error instanceof ContractFunctionRevertedError) return wrapContractRevert(error);
+	if (error instanceof ContractFunctionExecutionError) return new SELContractError(extractViemMessage(error), {
+		cause: error,
+		contractName: error.contractAddress,
+		methodName: error.functionName
+	});
+	if (error instanceof AbiDecodingDataSizeInvalidError || error instanceof AbiDecodingZeroDataError || error instanceof AbiErrorSignatureNotFoundError) return new SELContractError(extractViemMessage(error), { cause: error });
+	if (error instanceof HttpRequestError) return new SELProviderTransportError(extractViemMessage(error), {
+		cause: error,
+		httpStatus: error.status,
+		url: error.url,
+		body: typeof error.body === "string" ? error.body : error.body !== void 0 ? JSON.stringify(error.body) : void 0
+	});
+	if (error instanceof TimeoutError || error instanceof WebSocketRequestError) return new SELProviderTransportError(extractViemMessage(error), {
+		cause: error,
+		url: error instanceof WebSocketRequestError ? error.url : void 0
+	});
+	if (error instanceof RpcError) {
+		const rpc = error;
+		return new SELProviderRpcError(extractViemMessage(error), {
+			cause: error,
+			rpcCode: rpc.code,
+			rpcData: rpc.data
+		});
+	}
+	return new SELProviderError(extractViemMessage(error), { cause: error });
+};
+/**
 * Wraps an unknown error into a known SEL error type.
-* - If the error is already a SEL error, it is returned as is.
-* - If the error is a CEL error, it is wrapped into the corresponding SEL error type.
-* - If the error is an unknown type, it is wrapped into a generic Error.
 *
-* @param error The error to wrap.
-* @returns The wrapped error.
+* - A `SELError` is returned as-is.
+* - cel-js errors (`ParseError`, `TypeError`, `EvaluationError`) become the
+*   matching `SEL*Error` and preserve `cause`.
+* - viem errors are routed by concrete class: reverts → `SELContractRevertError`,
+*   transport/timeout → `SELProviderTransportError`, JSON-RPC → `SELProviderRpcError`,
+*   contract execution / ABI decode → `SELContractError`, everything else → `SELProviderError`.
+* - Any other `Error` becomes `SELEvaluationError` with the original as `cause`.
 */
 const wrapError = (error) => {
 	if (error instanceof SELError) return error;
 	if (error instanceof EvaluationError) {
 		const cause = error.cause;
 		if (cause instanceof SELError) return cause;
+		if (cause instanceof BaseError) return wrapViemError(cause);
 		return new SELEvaluationError(error.message, { cause: error });
 	}
-	if (error instanceof ParseError) return new SELEvaluationError(error.message, { cause: error });
-	if (error instanceof TypeError) return new SELEvaluationError(error.message, { cause: error });
-	if (error instanceof Error) return error;
-	return new Error(String(error));
+	if (error instanceof ParseError) return new SELParseError(error.message, { cause: error });
+	if (error instanceof TypeError) return new SELTypeCheckError(error.message, { cause: error });
+	if (error instanceof BaseError) return wrapViemError(error);
+	if (error instanceof Error) return new SELEvaluationError(error.message, { cause: error });
+	return new SELEvaluationError(String(error));
 };
 //#endregion
 export { wrapError };

package/dist/environment/types.d.cts

@@ -19,7 +19,7 @@ interface MulticallOptions {
  * Limits for contract call execution.
  *
  * Execution limits (`maxRounds`, `maxCalls`) bound the multi-round contract
- * execution engine. An {@link ExecutionLimitError} is thrown when exceeded.
+ * execution engine. An {@link SELExecutionLimitError} is thrown when exceeded.
  */
 interface SELLimits {
   /** Maximum number of dependency-ordered execution rounds (default: 10) */

package/dist/environment/types.d.mts

@@ -19,7 +19,7 @@ interface MulticallOptions {
  * Limits for contract call execution.
  *
  * Execution limits (`maxRounds`, `maxCalls`) bound the multi-round contract
- * execution engine. An {@link ExecutionLimitError} is thrown when exceeded.
+ * execution engine. An {@link SELExecutionLimitError} is thrown when exceeded.
  */
 interface SELLimits {
   /** Maximum number of dependency-ordered execution rounds (default: 10) */