@seljs/runtime 1.3.0-beta.3 → 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/client.d.cts

@@ -16,7 +16,7 @@ interface SELClient {
     data: `0x${string}`;
     blockNumber?: bigint;
   }) => Promise<{
-    data?: `0x${string}`;
+    data?: `0x${string}` | undefined;
   }>;
   /**
    *  Get the current block number (eth_blockNumber) for pinning reads

package/dist/environment/client.d.mts

@@ -16,7 +16,7 @@ interface SELClient {
     data: `0x${string}`;
     blockNumber?: bigint;
   }) => Promise<{
-    data?: `0x${string}`;
+    data?: `0x${string}` | undefined;
   }>;
   /**
    *  Get the current block number (eth_blockNumber) for pinning reads

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

@@ -13,7 +13,6 @@ const require_dependency_analyzer = require("../analysis/dependency-analyzer.cjs
 const require_round_planner = require("../analysis/round-planner.cjs");
 const require_multi_round_executor = require("../execution/multi-round-executor.cjs");
 let _seljs_checker = require("@seljs/checker");
-let _seljs_common = require("@seljs/common");
 //#region src/environment/environment.ts
 /**
 * Core SEL runtime that bridges CEL expression evaluation with EVM contract reads.
@@ -106,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 SELTypeError} 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 {
@@ -130,10 +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 SELParseError} If the expression has invalid syntax
-	* @throws {@link SELTypeError} If type-checking fails
-	* @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;
@@ -149,23 +159,21 @@ var SELRuntime = class {
 		}
 	}
 	planExecution(expression, evaluationContext) {
+		const checkResult = this.checker.check(expression);
+		if (!checkResult.valid) throw new require_errors.SELLintError(checkResult.diagnostics.filter((d) => d.severity === "error"));
 		const parseResult = this.env.parse(expression);
 		const collectedCalls = require_call_collector.collectCalls(parseResult.ast, { get: (name) => this.findContract(name) });
 		debug("evaluate: collected %d calls", collectedCalls.length);
 		const normalizedContext = Object.keys(evaluationContext).length ? require_context.normalizeContextForEvaluation(evaluationContext, this.variableTypes, this.codecRegistry) : void 0;
 		const executionVariables = Object.keys(evaluationContext).length ? evaluationContext : {};
-		const typeCheckResult = parseResult.check();
-		if (!typeCheckResult.valid) throw new _seljs_common.SELTypeError(typeCheckResult.error?.message ?? "Type check failed", { cause: typeCheckResult.error });
-		const lintResult = this.checker.check(expression);
-		const lintErrors = lintResult.diagnostics.filter((d) => d.severity === "error");
-		if (lintErrors.length > 0) throw new require_errors.SELLintError(lintErrors);
+		const diagnostics = checkResult.diagnostics.filter((d) => d.severity !== "error");
 		return {
 			parseResult,
 			collectedCalls,
 			normalizedContext,
 			executionVariables,
-			typeCheckResult,
-			diagnostics: lintResult.diagnostics.filter((d) => d.severity !== "error")
+			resolvedType: checkResult.type,
+			diagnostics
 		};
 	}
 	async executeContractCalls(collectedCalls, executionVariables, resolvedClient) {
@@ -179,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;
@@ -216,7 +225,7 @@ var SELRuntime = class {
 		const resolvedClient = options?.client ?? this.client;
 		if (resolvedClient && resolvedClient !== this.client) require_client.validateClient(resolvedClient);
 		try {
-			const { parseResult, collectedCalls, normalizedContext, executionVariables, typeCheckResult, diagnostics } = this.planExecution(expression, context ?? {});
+			const { parseResult, collectedCalls, normalizedContext, executionVariables, resolvedType, diagnostics } = this.planExecution(expression, context ?? {});
 			let executionMeta;
 			let executionCache;
 			if (collectedCalls.length > 0) {
@@ -240,12 +249,13 @@ var SELRuntime = class {
 				this.currentClient = void 0;
 				this.currentCallCounter = void 0;
 			}
-			const value = typeCheckResult.type ? this.codecRegistry.encode(typeCheckResult.type, result) : result;
+			const value = resolvedType ? this.codecRegistry.encode(resolvedType, result) : result;
 			debug("evaluate: result type=%s", typeof value);
 			const evalResult = executionMeta ? {
 				value,
 				meta: executionMeta
 			} : { value };
+			if (resolvedType) evalResult.type = resolvedType;
 			if (diagnostics.length > 0) evalResult.diagnostics = diagnostics;
 			return evalResult;
 		} catch (error) {

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 SELTypeError} 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,10 +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 SELParseError} If the expression has invalid syntax
-   * @throws {@link SELTypeError} If type-checking fails
-   * @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 SELTypeError} 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,10 +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 SELParseError} If the expression has invalid syntax
-   * @throws {@link SELTypeError} If type-checking fails
-   * @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, SELTypeError } 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 SELTypeError} 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,10 +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 SELParseError} If the expression has invalid syntax
-	* @throws {@link SELTypeError} If type-checking fails
-	* @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;
@@ -147,23 +158,21 @@ var SELRuntime = class {
 		}
 	}
 	planExecution(expression, evaluationContext) {
+		const checkResult = this.checker.check(expression);
+		if (!checkResult.valid) throw new SELLintError(checkResult.diagnostics.filter((d) => d.severity === "error"));
 		const parseResult = this.env.parse(expression);
 		const collectedCalls = collectCalls(parseResult.ast, { get: (name) => this.findContract(name) });
 		debug("evaluate: collected %d calls", collectedCalls.length);
 		const normalizedContext = Object.keys(evaluationContext).length ? normalizeContextForEvaluation(evaluationContext, this.variableTypes, this.codecRegistry) : void 0;
 		const executionVariables = Object.keys(evaluationContext).length ? evaluationContext : {};
-		const typeCheckResult = parseResult.check();
-		if (!typeCheckResult.valid) throw new SELTypeError(typeCheckResult.error?.message ?? "Type check failed", { cause: typeCheckResult.error });
-		const lintResult = this.checker.check(expression);
-		const lintErrors = lintResult.diagnostics.filter((d) => d.severity === "error");
-		if (lintErrors.length > 0) throw new SELLintError(lintErrors);
+		const diagnostics = checkResult.diagnostics.filter((d) => d.severity !== "error");
 		return {
 			parseResult,
 			collectedCalls,
 			normalizedContext,
 			executionVariables,
-			typeCheckResult,
-			diagnostics: lintResult.diagnostics.filter((d) => d.severity !== "error")
+			resolvedType: checkResult.type,
+			diagnostics
 		};
 	}
 	async executeContractCalls(collectedCalls, executionVariables, resolvedClient) {
@@ -177,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;
@@ -214,7 +224,7 @@ var SELRuntime = class {
 		const resolvedClient = options?.client ?? this.client;
 		if (resolvedClient && resolvedClient !== this.client) validateClient(resolvedClient);
 		try {
-			const { parseResult, collectedCalls, normalizedContext, executionVariables, typeCheckResult, diagnostics } = this.planExecution(expression, context ?? {});
+			const { parseResult, collectedCalls, normalizedContext, executionVariables, resolvedType, diagnostics } = this.planExecution(expression, context ?? {});
 			let executionMeta;
 			let executionCache;
 			if (collectedCalls.length > 0) {
@@ -238,12 +248,13 @@ var SELRuntime = class {
 				this.currentClient = void 0;
 				this.currentCallCounter = void 0;
 			}
-			const value = typeCheckResult.type ? this.codecRegistry.encode(typeCheckResult.type, result) : result;
+			const value = resolvedType ? this.codecRegistry.encode(resolvedType, result) : result;
 			debug("evaluate: result type=%s", typeof value);
 			const evalResult = executionMeta ? {
 				value,
 				meta: executionMeta
 			} : { value };
+			if (resolvedType) evalResult.type = resolvedType;
 			if (diagnostics.length > 0) evalResult.diagnostics = diagnostics;
 			return evalResult;
 		} catch (error) {

package/dist/environment/error-wrapper.cjs

@@ -1,29 +1,87 @@
 require("../_virtual/_rolldown/runtime.cjs");
 const require_errors = require("../errors/errors.cjs");
 require("../errors/index.cjs");
-let _marcbachmann_cel_js = require("@marcbachmann/cel-js");
 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 require_errors.SELContractError) return error;
-	if (error instanceof _marcbachmann_cel_js.ParseError) return new _seljs_common.SELParseError(error.message, { cause: error });
+	if (error instanceof _seljs_common.SELError) return error;
 	if (error instanceof _marcbachmann_cel_js.EvaluationError) {
 		const cause = error.cause;
-		if (cause instanceof require_errors.SELContractError) return cause;
-		return new require_errors.SELEvaluationError(error.message, { cause: error });
+		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.TypeError) return new _seljs_common.SELTypeError(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,27 +1,86 @@
-import { SELContractError, SELEvaluationError, SELParseError, SELTypeError } from "../errors/errors.mjs";
+import { SELContractError, SELContractRevertError, SELProviderError, SELProviderRpcError, SELProviderTransportError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
+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 SELContractError) return error;
-	if (error instanceof ParseError) return new SELParseError(error.message, { cause: error });
+	if (error instanceof SELError) return error;
 	if (error instanceof EvaluationError) {
 		const cause = error.cause;
-		if (cause instanceof SELContractError) return cause;
+		if (cause instanceof SELError) return cause;
+		if (cause instanceof BaseError) return wrapViemError(cause);
 		return new SELEvaluationError(error.message, { cause: error });
 	}
-	if (error instanceof TypeError) return new SELTypeError(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 };