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

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) */

package/dist/errors/errors.cjs

@@ -2,15 +2,12 @@ require("../_virtual/_rolldown/runtime.cjs");
 let _seljs_common = require("@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 _seljs_common.SELError {};
-/**
-* Thrown when contract validation or execution fails.
-* Includes optional contract name and method name for context.
-*/
-var SELContractError = class extends _seljs_common.SELError {
+var SELContractError = class extends _seljs_common.SELRuntimeError {
 	contractName;
 	methodName;
 	constructor(message, options) {
@@ -20,10 +17,93 @@ var SELContractError = class extends _seljs_common.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 _seljs_common.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 _seljs_common.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 _seljs_common.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 });
@@ -34,7 +114,7 @@ var CircularDependencyError = class extends _seljs_common.SELError {
 * Thrown when execution limits are exceeded (maxRounds or maxCalls).
 * Prevents infinite loops and runaway execution.
 */
-var ExecutionLimitError = class extends _seljs_common.SELError {
+var SELExecutionLimitError = class extends SELExecutionError {
 	limitType;
 	limit;
 	actual;
@@ -46,31 +126,16 @@ var ExecutionLimitError = class extends _seljs_common.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 _seljs_common.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 _seljs_common.SELError {
+var SELClientError = class extends _seljs_common.SELStaticError {
 	name = "SELClientError";
 };
 /**
 * Thrown when lint rules with error severity detect violations.
 * Contains the diagnostics that caused the failure.
 */
-var SELLintError = class extends _seljs_common.SELError {
+var SELLintError = class extends _seljs_common.SELStaticError {
 	diagnostics;
 	constructor(diagnostics, options) {
 		const messages = diagnostics.map((d) => d.message).join("; ");
@@ -79,10 +144,14 @@ var SELLintError = class extends _seljs_common.SELError {
 	}
 };
 //#endregion
-exports.CircularDependencyError = CircularDependencyError;
-exports.ExecutionLimitError = ExecutionLimitError;
-exports.MulticallBatchError = MulticallBatchError;
+exports.SELCircularDependencyError = SELCircularDependencyError;
 exports.SELClientError = SELClientError;
 exports.SELContractError = SELContractError;
-exports.SELEvaluationError = SELEvaluationError;
+exports.SELContractRevertError = SELContractRevertError;
+exports.SELExecutionError = SELExecutionError;
+exports.SELExecutionLimitError = SELExecutionLimitError;
 exports.SELLintError = SELLintError;
+exports.SELMulticallBatchError = SELMulticallBatchError;
+exports.SELProviderError = SELProviderError;
+exports.SELProviderRpcError = SELProviderRpcError;
+exports.SELProviderTransportError = SELProviderTransportError;

package/dist/errors/errors.d.cts

@@ -1,17 +1,14 @@
 import { SELDiagnostic } from "@seljs/checker";
-import { SELError, SELParseError, SELTypeError } from "@seljs/common";
+import { SELError, SELEvaluationError, SELRuntimeError, SELStaticError } from "@seljs/common";
 
 //#region src/errors/errors.d.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}.
  */
-declare class SELEvaluationError extends SELError {}
-/**
- * Thrown when contract validation or execution fails.
- * Includes optional contract name and method name for context.
- */
-declare class SELContractError extends SELError {
+declare class SELContractError extends SELRuntimeError {
   readonly contractName?: string;
   readonly methodName?: string;
   constructor(message: string, options?: {
@@ -21,10 +18,95 @@ declare class SELContractError 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.
+ */
+declare class SELContractRevertError extends SELContractError {
+  readonly revertReason?: string;
+  readonly revertData?: `0x${string}`;
+  readonly decodedError?: {
+    name: string;
+    args: readonly unknown[];
+  };
+  constructor(message: string, options?: {
+    cause?: unknown;
+    contractName?: string;
+    methodName?: string;
+    revertReason?: string;
+    revertData?: `0x${string}`;
+    decodedError?: {
+      name: string;
+      args: readonly unknown[];
+    };
+  });
+}
+/**
+ * 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.
+ */
+declare class SELMulticallBatchError extends SELContractError {
+  readonly failedCallIndex?: number;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    failedCallIndex?: number;
+    contractName?: string;
+    methodName?: string;
+  });
+}
+/**
+ * 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.
+ */
+declare class SELProviderError extends SELRuntimeError {}
+/**
+ * Thrown when the transport layer (HTTP, WebSocket) or a timeout
+ * prevented the request from reaching the node.
+ */
+declare class SELProviderTransportError extends SELProviderError {
+  readonly httpStatus?: number;
+  readonly url?: string;
+  readonly body?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    httpStatus?: number;
+    url?: string;
+    body?: string;
+  });
+}
+/**
+ * Thrown when the node returned a JSON-RPC error response (rate limit,
+ * invalid params, unsupported method, user rejection, etc.).
+ */
+declare class SELProviderRpcError extends SELProviderError {
+  readonly rpcCode?: number;
+  readonly rpcData?: unknown;
+  readonly method?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    rpcCode?: number;
+    rpcData?: unknown;
+    method?: string;
+  });
+}
+/**
+ * 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}.
+ */
+declare class SELExecutionError 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).
  */
-declare class CircularDependencyError extends SELError {
+declare class SELCircularDependencyError extends SELExecutionError {
   readonly callIds: string[];
   constructor(message: string, options?: {
     cause?: unknown;
@@ -35,7 +117,7 @@ declare class CircularDependencyError extends SELError {
  * Thrown when execution limits are exceeded (maxRounds or maxCalls).
  * Prevents infinite loops and runaway execution.
  */
-declare class ExecutionLimitError extends SELError {
+declare class SELExecutionLimitError extends SELExecutionError {
   readonly limitType: "maxRounds" | "maxCalls";
   readonly limit: number;
   readonly actual: number;
@@ -46,36 +128,21 @@ declare class ExecutionLimitError extends SELError {
     actual?: number;
   });
 }
-/**
- * Thrown when a Multicall3 batch execution fails.
- * Includes the failed call index and optional contract name/method name for context.
- */
-declare class MulticallBatchError extends SELError {
-  readonly failedCallIndex?: number;
-  readonly contractName?: string;
-  readonly methodName?: string;
-  constructor(message: string, options?: {
-    cause?: unknown;
-    failedCallIndex?: number;
-    contractName?: string;
-    methodName?: string;
-  });
-}
 /**
  * Thrown when the provided client fails validation or is misconfigured.
  */
-declare class SELClientError extends SELError {
+declare class SELClientError extends SELStaticError {
   readonly name = "SELClientError";
 }
 /**
  * Thrown when lint rules with error severity detect violations.
  * Contains the diagnostics that caused the failure.
  */
-declare class SELLintError extends SELError {
+declare class SELLintError extends SELStaticError {
   readonly diagnostics: SELDiagnostic[];
   constructor(diagnostics: SELDiagnostic[], options?: {
     cause?: unknown;
   });
 }
 //#endregion
-export { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELClientError, SELContractError, SELError, SELEvaluationError, SELLintError, SELParseError, SELTypeError };
+export { SELCircularDependencyError, SELClientError, SELContractError, SELContractRevertError, SELError, SELEvaluationError, SELExecutionError, SELExecutionLimitError, SELLintError, SELMulticallBatchError, SELProviderError, SELProviderRpcError, SELProviderTransportError, SELRuntimeError, SELStaticError };

package/dist/errors/errors.d.mts

@@ -1,17 +1,14 @@
 import { SELDiagnostic } from "@seljs/checker";
-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.d.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}.
  */
-declare class SELEvaluationError extends SELError {}
-/**
- * Thrown when contract validation or execution fails.
- * Includes optional contract name and method name for context.
- */
-declare class SELContractError extends SELError {
+declare class SELContractError extends SELRuntimeError {
   readonly contractName?: string;
   readonly methodName?: string;
   constructor(message: string, options?: {
@@ -21,10 +18,95 @@ declare class SELContractError 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.
+ */
+declare class SELContractRevertError extends SELContractError {
+  readonly revertReason?: string;
+  readonly revertData?: `0x${string}`;
+  readonly decodedError?: {
+    name: string;
+    args: readonly unknown[];
+  };
+  constructor(message: string, options?: {
+    cause?: unknown;
+    contractName?: string;
+    methodName?: string;
+    revertReason?: string;
+    revertData?: `0x${string}`;
+    decodedError?: {
+      name: string;
+      args: readonly unknown[];
+    };
+  });
+}
+/**
+ * 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.
+ */
+declare class SELMulticallBatchError extends SELContractError {
+  readonly failedCallIndex?: number;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    failedCallIndex?: number;
+    contractName?: string;
+    methodName?: string;
+  });
+}
+/**
+ * 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.
+ */
+declare class SELProviderError extends SELRuntimeError {}
+/**
+ * Thrown when the transport layer (HTTP, WebSocket) or a timeout
+ * prevented the request from reaching the node.
+ */
+declare class SELProviderTransportError extends SELProviderError {
+  readonly httpStatus?: number;
+  readonly url?: string;
+  readonly body?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    httpStatus?: number;
+    url?: string;
+    body?: string;
+  });
+}
+/**
+ * Thrown when the node returned a JSON-RPC error response (rate limit,
+ * invalid params, unsupported method, user rejection, etc.).
+ */
+declare class SELProviderRpcError extends SELProviderError {
+  readonly rpcCode?: number;
+  readonly rpcData?: unknown;
+  readonly method?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    rpcCode?: number;
+    rpcData?: unknown;
+    method?: string;
+  });
+}
+/**
+ * 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}.
+ */
+declare class SELExecutionError 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).
  */
-declare class CircularDependencyError extends SELError {
+declare class SELCircularDependencyError extends SELExecutionError {
   readonly callIds: string[];
   constructor(message: string, options?: {
     cause?: unknown;
@@ -35,7 +117,7 @@ declare class CircularDependencyError extends SELError {
  * Thrown when execution limits are exceeded (maxRounds or maxCalls).
  * Prevents infinite loops and runaway execution.
  */
-declare class ExecutionLimitError extends SELError {
+declare class SELExecutionLimitError extends SELExecutionError {
   readonly limitType: "maxRounds" | "maxCalls";
   readonly limit: number;
   readonly actual: number;
@@ -46,36 +128,21 @@ declare class ExecutionLimitError extends SELError {
     actual?: number;
   });
 }
-/**
- * Thrown when a Multicall3 batch execution fails.
- * Includes the failed call index and optional contract name/method name for context.
- */
-declare class MulticallBatchError extends SELError {
-  readonly failedCallIndex?: number;
-  readonly contractName?: string;
-  readonly methodName?: string;
-  constructor(message: string, options?: {
-    cause?: unknown;
-    failedCallIndex?: number;
-    contractName?: string;
-    methodName?: string;
-  });
-}
 /**
  * Thrown when the provided client fails validation or is misconfigured.
  */
-declare class SELClientError extends SELError {
+declare class SELClientError extends SELStaticError {
   readonly name = "SELClientError";
 }
 /**
  * Thrown when lint rules with error severity detect violations.
  * Contains the diagnostics that caused the failure.
  */
-declare class SELLintError extends SELError {
+declare class SELLintError extends SELStaticError {
   readonly diagnostics: SELDiagnostic[];
   constructor(diagnostics: SELDiagnostic[], options?: {
     cause?: unknown;
   });
 }
 //#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 };