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

package/dist/errors/errors.mjs

@@ -1,15 +1,12 @@
-import { SELError, SELParseError, SELTypeError } from "@seljs/common";
+import { SELError as SELError$1, SELEvaluationError as SELEvaluationError$1, SELRuntimeError, SELStaticError } from "@seljs/common";
 //#region src/errors/errors.ts
 /**
-* Thrown when CEL expression evaluation fails.
-* Wraps cel-js EvaluationError with additional context.
+* Thrown when a contract-layer call fails after execution reached the
+* chain (unknown method, ABI decode mismatch, etc.). Reverts are reported
+* as {@link SELContractRevertError}, a subclass; batch-level Multicall3
+* failures as {@link SELMulticallBatchError}.
 */
-var SELEvaluationError = class extends SELError {};
-/**
-* Thrown when contract validation or execution fails.
-* Includes optional contract name and method name for context.
-*/
-var SELContractError = class extends SELError {
+var SELContractError = class extends SELRuntimeError {
 	contractName;
 	methodName;
 	constructor(message, options) {
@@ -19,10 +16,93 @@ var SELContractError = class extends SELError {
 	}
 };
 /**
-* Thrown when a circular dependency is detected in the call dependency graph.
-* Indicates that call A depends on call B which depends on call A (directly or transitively).
+* Thrown when a contract call reverted. Carries the decoded revert
+* reason, raw revert data, and — when the selector matched a custom
+* error in the contract's ABI — the decoded custom-error name and args.
+*/
+var SELContractRevertError = class extends SELContractError {
+	revertReason;
+	revertData;
+	decodedError;
+	constructor(message, options) {
+		super(message, {
+			cause: options?.cause,
+			contractName: options?.contractName,
+			methodName: options?.methodName
+		});
+		this.revertReason = options?.revertReason;
+		this.revertData = options?.revertData;
+		this.decodedError = options?.decodedError;
+	}
+};
+/**
+* Thrown when a Multicall3 batch fails at the batch level — the aggregate
+* call itself reverted, or individual calls could not be encoded/decoded.
+* Individual sub-call reverts surface as {@link SELContractRevertError},
+* not as this class.
+*/
+var SELMulticallBatchError = class extends SELContractError {
+	failedCallIndex;
+	constructor(message, options) {
+		super(message, {
+			cause: options?.cause,
+			contractName: options?.contractName,
+			methodName: options?.methodName
+		});
+		this.failedCallIndex = options?.failedCallIndex;
+	}
+};
+/**
+* Base for failures from the JSON-RPC transport or node — the call never
+* reached the contract. Transport errors (HTTP, WebSocket, timeout) use
+* {@link SELProviderTransportError}; node-reported JSON-RPC errors use
+* {@link SELProviderRpcError}. Catch the base to retry safely against an
+* alternate RPC.
+*/
+var SELProviderError = class extends SELRuntimeError {};
+/**
+* Thrown when the transport layer (HTTP, WebSocket) or a timeout
+* prevented the request from reaching the node.
+*/
+var SELProviderTransportError = class extends SELProviderError {
+	httpStatus;
+	url;
+	body;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.httpStatus = options?.httpStatus;
+		this.url = options?.url;
+		this.body = options?.body;
+	}
+};
+/**
+* Thrown when the node returned a JSON-RPC error response (rate limit,
+* invalid params, unsupported method, user rejection, etc.).
 */
-var CircularDependencyError = class extends SELError {
+var SELProviderRpcError = class extends SELProviderError {
+	rpcCode;
+	rpcData;
+	method;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.rpcCode = options?.rpcCode;
+		this.rpcData = options?.rpcData;
+		this.method = options?.method;
+	}
+};
+/**
+* Base for failures from the execution-framework layer that sits between
+* parsed expressions and contract calls (dependency analysis, round
+* planning). Concrete subclasses: {@link SELExecutionLimitError},
+* {@link SELCircularDependencyError}.
+*/
+var SELExecutionError = class extends SELRuntimeError {};
+/**
+* Thrown when a circular dependency is detected in the call dependency
+* graph. Indicates that call A depends on call B which depends on call A
+* (directly or transitively).
+*/
+var SELCircularDependencyError = class extends SELExecutionError {
 	callIds;
 	constructor(message, options) {
 		super(message, { cause: options?.cause });
@@ -33,7 +113,7 @@ var CircularDependencyError = class extends SELError {
 * Thrown when execution limits are exceeded (maxRounds or maxCalls).
 * Prevents infinite loops and runaway execution.
 */
-var ExecutionLimitError = class extends SELError {
+var SELExecutionLimitError = class extends SELExecutionError {
 	limitType;
 	limit;
 	actual;
@@ -45,31 +125,16 @@ var ExecutionLimitError = class extends SELError {
 	}
 };
 /**
-* Thrown when a Multicall3 batch execution fails.
-* Includes the failed call index and optional contract name/method name for context.
-*/
-var MulticallBatchError = class extends SELError {
-	failedCallIndex;
-	contractName;
-	methodName;
-	constructor(message, options) {
-		super(message, { cause: options?.cause });
-		this.failedCallIndex = options?.failedCallIndex;
-		this.contractName = options?.contractName;
-		this.methodName = options?.methodName;
-	}
-};
-/**
 * Thrown when the provided client fails validation or is misconfigured.
 */
-var SELClientError = class extends SELError {
+var SELClientError = class extends SELStaticError {
 	name = "SELClientError";
 };
 /**
 * Thrown when lint rules with error severity detect violations.
 * Contains the diagnostics that caused the failure.
 */
-var SELLintError = class extends SELError {
+var SELLintError = class extends SELStaticError {
 	diagnostics;
 	constructor(diagnostics, options) {
 		const messages = diagnostics.map((d) => d.message).join("; ");
@@ -78,4 +143,4 @@ var SELLintError = class extends SELError {
 	}
 };
 //#endregion
-export { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELClientError, SELContractError, SELError, SELEvaluationError, SELLintError, SELParseError, SELTypeError };
+export { SELCircularDependencyError, SELClientError, SELContractError, SELContractRevertError, SELError$1 as SELError, SELEvaluationError$1 as SELEvaluationError, SELExecutionError, SELExecutionLimitError, SELLintError, SELMulticallBatchError, SELProviderError, SELProviderRpcError, SELProviderTransportError, SELRuntimeError, SELStaticError };

package/dist/errors/index.d.mts

@@ -1 +1 @@
-import { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELClientError, SELContractError, SELError, SELEvaluationError, SELLintError, SELParseError, SELTypeError } from "./errors.mjs";
+import { SELCircularDependencyError, SELClientError, SELContractError, SELContractRevertError, SELError, SELEvaluationError, SELExecutionError, SELExecutionLimitError, SELLintError, SELMulticallBatchError, SELProviderError, SELProviderRpcError, SELProviderTransportError, SELRuntimeError, SELStaticError } from "./errors.mjs";

package/dist/execution/decode-revert.cjs

@@ -0,0 +1,67 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let ox = require("ox");
+//#region src/execution/decode-revert.ts
+const ERROR_STRING_SELECTOR = "0x08c379a0";
+const PANIC_SELECTOR = "0x4e487b71";
+const PANIC_CODES = {
+	0: "generic panic",
+	1: "assertion failed",
+	17: "arithmetic overflow or underflow",
+	18: "division or modulo by zero",
+	33: "enum conversion out of bounds",
+	34: "incorrectly encoded storage byte array",
+	49: "pop on empty array",
+	50: "array index out of bounds",
+	65: "excessive memory allocation",
+	81: "zero-initialized internal function type"
+};
+const errorStringAbi = ox.AbiError.from("error Error(string reason)");
+const panicAbi = ox.AbiError.from("error Panic(uint256 code)");
+function decodeRevertData(data, abi) {
+	if (data === "0x" || data.length < 10) return { data };
+	const selector = data.slice(0, 10).toLowerCase();
+	if (selector === ERROR_STRING_SELECTOR) try {
+		return {
+			data,
+			reason: ox.AbiError.decode(errorStringAbi, data)
+		};
+	} catch {
+		return { data };
+	}
+	if (selector === PANIC_SELECTOR) try {
+		const code = ox.AbiError.decode(panicAbi, data);
+		const numeric = Number(code);
+		return {
+			data,
+			reason: `Panic: ${PANIC_CODES[numeric] ?? `panic code 0x${numeric.toString(16)}`}`
+		};
+	} catch {
+		return { data };
+	}
+	try {
+		const error = ox.AbiError.fromAbi(abi, data);
+		const decoded = ox.AbiError.decode(error, data);
+		const args = decoded === void 0 ? [] : Array.isArray(decoded) ? decoded : [decoded];
+		const formattedArgs = args.map(formatArg).join(", ");
+		return {
+			data,
+			reason: `${error.name}(${formattedArgs})`,
+			decodedError: {
+				name: error.name,
+				args
+			}
+		};
+	} catch {
+		return { data };
+	}
+}
+function formatArg(arg) {
+	if (typeof arg === "bigint") return arg.toString();
+	if (typeof arg === "string") return arg;
+	if (typeof arg === "number" || typeof arg === "boolean" || arg === null || arg === void 0) return String(arg);
+	if (Array.isArray(arg)) return `[${arg.map(formatArg).join(", ")}]`;
+	if (typeof arg === "object") return `{${Object.entries(arg).map(([k, v]) => `${k}: ${formatArg(v)}`).join(", ")}}`;
+	return "";
+}
+//#endregion
+exports.decodeRevertData = decodeRevertData;

package/dist/execution/decode-revert.mjs

@@ -0,0 +1,66 @@
+import { AbiError } from "ox";
+//#region src/execution/decode-revert.ts
+const ERROR_STRING_SELECTOR = "0x08c379a0";
+const PANIC_SELECTOR = "0x4e487b71";
+const PANIC_CODES = {
+	0: "generic panic",
+	1: "assertion failed",
+	17: "arithmetic overflow or underflow",
+	18: "division or modulo by zero",
+	33: "enum conversion out of bounds",
+	34: "incorrectly encoded storage byte array",
+	49: "pop on empty array",
+	50: "array index out of bounds",
+	65: "excessive memory allocation",
+	81: "zero-initialized internal function type"
+};
+const errorStringAbi = AbiError.from("error Error(string reason)");
+const panicAbi = AbiError.from("error Panic(uint256 code)");
+function decodeRevertData(data, abi) {
+	if (data === "0x" || data.length < 10) return { data };
+	const selector = data.slice(0, 10).toLowerCase();
+	if (selector === ERROR_STRING_SELECTOR) try {
+		return {
+			data,
+			reason: AbiError.decode(errorStringAbi, data)
+		};
+	} catch {
+		return { data };
+	}
+	if (selector === PANIC_SELECTOR) try {
+		const code = AbiError.decode(panicAbi, data);
+		const numeric = Number(code);
+		return {
+			data,
+			reason: `Panic: ${PANIC_CODES[numeric] ?? `panic code 0x${numeric.toString(16)}`}`
+		};
+	} catch {
+		return { data };
+	}
+	try {
+		const error = AbiError.fromAbi(abi, data);
+		const decoded = AbiError.decode(error, data);
+		const args = decoded === void 0 ? [] : Array.isArray(decoded) ? decoded : [decoded];
+		const formattedArgs = args.map(formatArg).join(", ");
+		return {
+			data,
+			reason: `${error.name}(${formattedArgs})`,
+			decodedError: {
+				name: error.name,
+				args
+			}
+		};
+	} catch {
+		return { data };
+	}
+}
+function formatArg(arg) {
+	if (typeof arg === "bigint") return arg.toString();
+	if (typeof arg === "string") return arg;
+	if (typeof arg === "number" || typeof arg === "boolean" || arg === null || arg === void 0) return String(arg);
+	if (Array.isArray(arg)) return `[${arg.map(formatArg).join(", ")}]`;
+	if (typeof arg === "object") return `{${Object.entries(arg).map(([k, v]) => `${k}: ${formatArg(v)}`).join(", ")}}`;
+	return "";
+}
+//#endregion
+export { decodeRevertData };

package/dist/execution/multicall-batcher.cjs

@@ -38,14 +38,14 @@ var MulticallBatcher = class {
 				data,
 				blockNumber
 			});
-			if (!response.data) throw new require_errors.MulticallBatchError("Multicall3 aggregate3 returned no data");
+			if (!response.data) throw new require_errors.SELMulticallBatchError("Multicall3 aggregate3 returned no data");
 			return ox.AbiFunction.decodeResult(require_multicall.multicall3Function, response.data).map((r) => ({
 				success: r.success,
 				returnData: r.returnData
 			}));
 		} catch (error) {
-			if (error instanceof require_errors.MulticallBatchError) throw error;
-			throw new require_errors.MulticallBatchError("Multicall3 aggregate3 call failed", { cause: error });
+			if (error instanceof require_errors.SELMulticallBatchError) throw error;
+			throw new require_errors.SELMulticallBatchError("Multicall3 aggregate3 call failed", { cause: error });
 		}
 	}
 };

package/dist/execution/multicall-batcher.mjs

@@ -1,5 +1,5 @@
 import { multicall3Function } from "./multicall.mjs";
-import { MulticallBatchError } from "../errors/errors.mjs";
+import { SELMulticallBatchError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
 import { createLogger } from "../debug.mjs";
 import { AbiFunction } from "ox";
@@ -37,14 +37,14 @@ var MulticallBatcher = class {
 				data,
 				blockNumber
 			});
-			if (!response.data) throw new MulticallBatchError("Multicall3 aggregate3 returned no data");
+			if (!response.data) throw new SELMulticallBatchError("Multicall3 aggregate3 returned no data");
 			return AbiFunction.decodeResult(multicall3Function, response.data).map((r) => ({
 				success: r.success,
 				returnData: r.returnData
 			}));
 		} catch (error) {
-			if (error instanceof MulticallBatchError) throw error;
-			throw new MulticallBatchError("Multicall3 aggregate3 call failed", { cause: error });
+			if (error instanceof SELMulticallBatchError) throw error;
+			throw new SELMulticallBatchError("Multicall3 aggregate3 call failed", { cause: error });
 		}
 	}
 };

package/dist/execution/round-executor.cjs

@@ -2,7 +2,9 @@ require("../_virtual/_rolldown/runtime.cjs");
 const require_errors = require("../errors/errors.cjs");
 require("../errors/index.cjs");
 const require_debug = require("../debug.cjs");
+const require_decode_revert = require("./decode-revert.cjs");
 let ox = require("ox");
+let _seljs_common = require("@seljs/common");
 //#region src/execution/round-executor.ts
 const debug = require_debug.createLogger("execute:round");
 var RoundExecutor = class {
@@ -22,17 +24,17 @@ var RoundExecutor = class {
 				failedCallContract = call.contract;
 				failedCallMethod = call.method;
 				const contract = this.contracts.get(call.contract);
-				if (!contract) throw new Error(`No ABI registered for contract "${call.contract}"`);
+				if (!contract) throw new _seljs_common.SELConfigError(`No ABI registered for contract "${call.contract}"`, { setting: "abi" });
 				const resolvedArgs = this.resolveArgs(call.args, context);
 				encodedCalls.push({
 					target: contract.address,
-					allowFailure: false,
+					allowFailure: true,
 					callData: ox.AbiFunction.encodeData(contract.abi, call.method, resolvedArgs)
 				});
 			}
 		} catch (error) {
-			if (error instanceof require_errors.MulticallBatchError) throw error;
-			throw new require_errors.MulticallBatchError("Failed to encode call", {
+			if (error instanceof require_errors.SELMulticallBatchError || error instanceof _seljs_common.SELConfigError) throw error;
+			throw new require_errors.SELMulticallBatchError("Failed to encode call", {
 				cause: error,
 				failedCallIndex,
 				contractName: failedCallContract,
@@ -43,13 +45,19 @@ var RoundExecutor = class {
 		const results = await this.batcher.executeBatch(encodedCalls, context.blockNumber);
 		for (const [i, call] of round.calls.entries()) {
 			const contract = this.contracts.get(call.contract);
-			if (!contract) throw new Error(`No ABI registered for contract "${call.contract}"`);
+			if (!contract) throw new _seljs_common.SELConfigError(`No ABI registered for contract "${call.contract}"`, { setting: "abi" });
 			const result = results[i];
-			if (!result?.success) throw new require_errors.MulticallBatchError(`Call failed: ${call.contract}.${call.method}`, {
-				failedCallIndex: i,
-				contractName: call.contract,
-				methodName: call.method
-			});
+			if (!result?.success) {
+				const decoded = require_decode_revert.decodeRevertData(result?.returnData ?? "0x", contract.abi);
+				const suffix = decoded.reason ? ` — ${decoded.reason}` : "";
+				throw new require_errors.SELContractRevertError(`Call reverted: ${call.contract}.${call.method}${suffix}`, {
+					contractName: call.contract,
+					methodName: call.method,
+					revertReason: decoded.reason,
+					revertData: decoded.data,
+					decodedError: decoded.decodedError
+				});
+			}
 			const decoded = ox.AbiFunction.decodeResult(contract.abi, call.method, result.returnData);
 			debug("decoded %s.%s -> %o", call.contract, call.method, decoded);
 			this.cache.set(call.id, decoded);

package/dist/execution/round-executor.mjs

@@ -1,7 +1,9 @@
-import { MulticallBatchError } from "../errors/errors.mjs";
+import { SELContractRevertError, SELMulticallBatchError } from "../errors/errors.mjs";
 import "../errors/index.mjs";
 import { createLogger } from "../debug.mjs";
+import { decodeRevertData } from "./decode-revert.mjs";
 import { AbiFunction } from "ox";
+import { SELConfigError } from "@seljs/common";
 //#region src/execution/round-executor.ts
 const debug = createLogger("execute:round");
 var RoundExecutor = class {
@@ -21,17 +23,17 @@ var RoundExecutor = class {
 				failedCallContract = call.contract;
 				failedCallMethod = call.method;
 				const contract = this.contracts.get(call.contract);
-				if (!contract) throw new Error(`No ABI registered for contract "${call.contract}"`);
+				if (!contract) throw new SELConfigError(`No ABI registered for contract "${call.contract}"`, { setting: "abi" });
 				const resolvedArgs = this.resolveArgs(call.args, context);
 				encodedCalls.push({
 					target: contract.address,
-					allowFailure: false,
+					allowFailure: true,
 					callData: AbiFunction.encodeData(contract.abi, call.method, resolvedArgs)
 				});
 			}
 		} catch (error) {
-			if (error instanceof MulticallBatchError) throw error;
-			throw new MulticallBatchError("Failed to encode call", {
+			if (error instanceof SELMulticallBatchError || error instanceof SELConfigError) throw error;
+			throw new SELMulticallBatchError("Failed to encode call", {
 				cause: error,
 				failedCallIndex,
 				contractName: failedCallContract,
@@ -42,13 +44,19 @@ var RoundExecutor = class {
 		const results = await this.batcher.executeBatch(encodedCalls, context.blockNumber);
 		for (const [i, call] of round.calls.entries()) {
 			const contract = this.contracts.get(call.contract);
-			if (!contract) throw new Error(`No ABI registered for contract "${call.contract}"`);
+			if (!contract) throw new SELConfigError(`No ABI registered for contract "${call.contract}"`, { setting: "abi" });
 			const result = results[i];
-			if (!result?.success) throw new MulticallBatchError(`Call failed: ${call.contract}.${call.method}`, {
-				failedCallIndex: i,
-				contractName: call.contract,
-				methodName: call.method
-			});
+			if (!result?.success) {
+				const decoded = decodeRevertData(result?.returnData ?? "0x", contract.abi);
+				const suffix = decoded.reason ? ` — ${decoded.reason}` : "";
+				throw new SELContractRevertError(`Call reverted: ${call.contract}.${call.method}${suffix}`, {
+					contractName: call.contract,
+					methodName: call.method,
+					revertReason: decoded.reason,
+					revertData: decoded.data,
+					decodedError: decoded.decodedError
+				});
+			}
 			const decoded = AbiFunction.decodeResult(contract.abi, call.method, result.returnData);
 			debug("decoded %s.%s -> %o", call.contract, call.method, decoded);
 			this.cache.set(call.id, decoded);

package/dist/execution/types.d.cts

@@ -7,11 +7,17 @@ import { SELDiagnostic } from "@seljs/checker";
  * Contains statistics and block information from the execution run.
  */
 interface ExecutionMeta {
-  /** Number of rounds executed (topological depth) */
+  /**
+   * Number of rounds executed (topological depth)
+   */
   roundsExecuted: number;
-  /** Total number of contract calls executed */
+  /**
+   *  Total number of contract calls executed
+   */
   totalCalls: number;
-  /** Block number at which calls were executed */
+  /**
+   * Block number at which calls were executed
+   */
   blockNumber: bigint;
 }
 /**
@@ -19,9 +25,13 @@ interface ExecutionMeta {
  * Maps call IDs to their decoded results.
  */
 interface ExecutionResult {
-  /** Map of callId to decoded result value */
+  /**
+   * Map of callId to decoded result value
+   */
   results: Map<string, unknown>;
-  /** Execution metadata */
+  /**
+   *  Execution metadata
+   */
   meta: ExecutionMeta;
 }
 /**
@@ -29,16 +39,22 @@ interface ExecutionResult {
  * Contains the block number and variable bindings.
  */
 interface ExecutionContext {
-  /** Block number for consistent reads across all calls */
+  /**
+   *  Block number for consistent reads across all calls
+   */
   blockNumber: bigint;
-  /** Variable name to value mapping from evaluate() context */
+  /**
+   *  Variable name to value mapping from evaluate() context
+   */
   variables: Record<string, unknown>;
 }
 /**
  * Options for the evaluate() call.
  */
 interface EvaluateOptions {
-  /** Override client for this evaluation */
+  /**
+   * Override client for this evaluation
+   */
   client?: SELClient;
 }
 /**
@@ -48,11 +64,21 @@ interface EvaluateOptions {
  * contract calls were executed, absent for pure CEL expressions.
  */
 interface EvaluateResult<T = unknown> {
-  /** The evaluated result value */
+  /**
+   *  The evaluated result value
+   */
   value: T;
-  /** Execution metadata, present when contract calls were executed */
+  /**
+   *  The inferred type of the expression, when available
+   */
+  type?: string;
+  /**
+   *  Execution metadata, present when contract calls were executed
+   */
   meta?: ExecutionMeta;
-  /** Advisory diagnostics (warnings/info) from lint rules, when non-empty */
+  /**
+   *  Advisory diagnostics (warnings/info) from lint rules, when non-empty
+   */
   diagnostics?: SELDiagnostic[];
 }
 //#endregion

package/dist/execution/types.d.mts

@@ -7,11 +7,17 @@ import { SELDiagnostic } from "@seljs/checker";
  * Contains statistics and block information from the execution run.
  */
 interface ExecutionMeta {
-  /** Number of rounds executed (topological depth) */
+  /**
+   * Number of rounds executed (topological depth)
+   */
   roundsExecuted: number;
-  /** Total number of contract calls executed */
+  /**
+   *  Total number of contract calls executed
+   */
   totalCalls: number;
-  /** Block number at which calls were executed */
+  /**
+   * Block number at which calls were executed
+   */
   blockNumber: bigint;
 }
 /**
@@ -19,9 +25,13 @@ interface ExecutionMeta {
  * Maps call IDs to their decoded results.
  */
 interface ExecutionResult {
-  /** Map of callId to decoded result value */
+  /**
+   * Map of callId to decoded result value
+   */
   results: Map<string, unknown>;
-  /** Execution metadata */
+  /**
+   *  Execution metadata
+   */
   meta: ExecutionMeta;
 }
 /**
@@ -29,16 +39,22 @@ interface ExecutionResult {
  * Contains the block number and variable bindings.
  */
 interface ExecutionContext {
-  /** Block number for consistent reads across all calls */
+  /**
+   *  Block number for consistent reads across all calls
+   */
   blockNumber: bigint;
-  /** Variable name to value mapping from evaluate() context */
+  /**
+   *  Variable name to value mapping from evaluate() context
+   */
   variables: Record<string, unknown>;
 }
 /**
  * Options for the evaluate() call.
  */
 interface EvaluateOptions {
-  /** Override client for this evaluation */
+  /**
+   * Override client for this evaluation
+   */
   client?: SELClient;
 }
 /**
@@ -48,11 +64,21 @@ interface EvaluateOptions {
  * contract calls were executed, absent for pure CEL expressions.
  */
 interface EvaluateResult<T = unknown> {
-  /** The evaluated result value */
+  /**
+   *  The evaluated result value
+   */
   value: T;
-  /** Execution metadata, present when contract calls were executed */
+  /**
+   *  The inferred type of the expression, when available
+   */
+  type?: string;
+  /**
+   *  Execution metadata, present when contract calls were executed
+   */
   meta?: ExecutionMeta;
-  /** Advisory diagnostics (warnings/info) from lint rules, when non-empty */
+  /**
+   *  Advisory diagnostics (warnings/info) from lint rules, when non-empty
+   */
   diagnostics?: SELDiagnostic[];
 }
 //#endregion

package/dist/index.cjs

@@ -7,16 +7,21 @@ const require_environment = require("./environment/environment.cjs");
 require("./environment/index.cjs");
 const require_factory = require("./factory.cjs");
 let _seljs_common = require("@seljs/common");
-exports.CircularDependencyError = require_errors.CircularDependencyError;
-exports.ExecutionLimitError = require_errors.ExecutionLimitError;
-exports.MulticallBatchError = require_errors.MulticallBatchError;
+exports.SELCircularDependencyError = require_errors.SELCircularDependencyError;
 exports.SELClientError = require_errors.SELClientError;
 exports.SELContractError = require_errors.SELContractError;
+exports.SELContractRevertError = require_errors.SELContractRevertError;
 exports.SELError = _seljs_common.SELError;
-exports.SELEvaluationError = require_errors.SELEvaluationError;
+exports.SELEvaluationError = _seljs_common.SELEvaluationError;
+exports.SELExecutionError = require_errors.SELExecutionError;
+exports.SELExecutionLimitError = require_errors.SELExecutionLimitError;
 exports.SELLintError = require_errors.SELLintError;
-exports.SELParseError = _seljs_common.SELParseError;
+exports.SELMulticallBatchError = require_errors.SELMulticallBatchError;
+exports.SELProviderError = require_errors.SELProviderError;
+exports.SELProviderRpcError = require_errors.SELProviderRpcError;
+exports.SELProviderTransportError = require_errors.SELProviderTransportError;
 exports.SELRuntime = require_environment.SELRuntime;
-exports.SELTypeError = _seljs_common.SELTypeError;
+exports.SELRuntimeError = _seljs_common.SELRuntimeError;
+exports.SELStaticError = _seljs_common.SELStaticError;
 exports.createSEL = require_factory.createSEL;
 exports.validateClient = require_client.validateClient;