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

package/dist/errors/errors.cjs

@@ -2,32 +2,108 @@ require("../_virtual/_rolldown/runtime.cjs");
 let _seljs_common = require("@seljs/common");
 //#region src/errors/errors.ts
 /**
-* Thrown when contract validation or execution fails.
-* Includes optional contract name and method name for context.
-* When the failure is a contract revert, the decoded revert reason and raw
-* revert data are exposed on `revertReason` / `revertData`, and `decodedError`
-* carries any matched custom-error name + args from the contract's ABI.
+* 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 SELContractError = class extends _seljs_common.SELError {
+var SELContractError = class extends _seljs_common.SELRuntimeError {
 	contractName;
 	methodName;
-	revertReason;
-	revertData;
-	decodedError;
 	constructor(message, options) {
 		super(message, { cause: options?.cause });
 		this.contractName = options?.contractName;
 		this.methodName = options?.methodName;
+	}
+};
+/**
+* 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 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 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 });
@@ -38,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;
@@ -50,40 +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.
-* When an individual sub-call reverts, `revertReason` / `revertData` carry the
-* decoded reason text and raw return data, and `decodedError` carries any
-* matched custom-error name + args from the contract's ABI.
-*/
-var MulticallBatchError = class extends _seljs_common.SELError {
-	failedCallIndex;
-	contractName;
-	methodName;
-	revertReason;
-	revertData;
-	decodedError;
-	constructor(message, options) {
-		super(message, { cause: options?.cause });
-		this.failedCallIndex = options?.failedCallIndex;
-		this.contractName = options?.contractName;
-		this.methodName = options?.methodName;
-		this.revertReason = options?.revertReason;
-		this.revertData = options?.revertData;
-		this.decodedError = options?.decodedError;
-	}
-};
-/**
 * 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("; ");
@@ -92,9 +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.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,28 @@
 import { SELDiagnostic } from "@seljs/checker";
-import { SELError, SELEvaluationError } from "@seljs/common";
+import { SELError, SELEvaluationError, SELRuntimeError, SELStaticError } from "@seljs/common";
 
 //#region src/errors/errors.d.ts
 /**
- * Thrown when contract validation or execution fails.
- * Includes optional contract name and method name for context.
- * When the failure is a contract revert, the decoded revert reason and raw
- * revert data are exposed on `revertReason` / `revertData`, and `decodedError`
- * carries any matched custom-error name + args from the contract's ABI.
+ * 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 SELContractError extends SELError {
+declare class SELContractError extends SELRuntimeError {
   readonly contractName?: string;
   readonly methodName?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    contractName?: string;
+    methodName?: string;
+  });
+}
+/**
+ * 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?: {
@@ -31,10 +42,71 @@ 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 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;
@@ -45,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;
@@ -56,51 +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.
- * When an individual sub-call reverts, `revertReason` / `revertData` carry the
- * decoded reason text and raw return data, and `decodedError` carries any
- * matched custom-error name + args from the contract's ABI.
- */
-declare class MulticallBatchError extends SELError {
-  readonly failedCallIndex?: number;
-  readonly contractName?: string;
-  readonly methodName?: string;
-  readonly revertReason?: string;
-  readonly revertData?: `0x${string}`;
-  readonly decodedError?: {
-    name: string;
-    args: readonly unknown[];
-  };
-  constructor(message: string, options?: {
-    cause?: unknown;
-    failedCallIndex?: number;
-    contractName?: string;
-    methodName?: string;
-    revertReason?: string;
-    revertData?: `0x${string}`;
-    decodedError?: {
-      name: string;
-      args: readonly unknown[];
-    };
-  });
-}
 /**
  * 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 };
+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,28 @@
 import { SELDiagnostic } from "@seljs/checker";
-import { SELError as SELError$1, SELEvaluationError } 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 contract validation or execution fails.
- * Includes optional contract name and method name for context.
- * When the failure is a contract revert, the decoded revert reason and raw
- * revert data are exposed on `revertReason` / `revertData`, and `decodedError`
- * carries any matched custom-error name + args from the contract's ABI.
+ * 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 SELContractError extends SELError$1 {
+declare class SELContractError extends SELRuntimeError {
   readonly contractName?: string;
   readonly methodName?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    contractName?: string;
+    methodName?: string;
+  });
+}
+/**
+ * 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?: {
@@ -31,10 +42,71 @@ declare class SELContractError extends SELError$1 {
   });
 }
 /**
- * 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 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$1 {
+declare class SELCircularDependencyError extends SELExecutionError {
   readonly callIds: string[];
   constructor(message: string, options?: {
     cause?: unknown;
@@ -45,7 +117,7 @@ declare class CircularDependencyError extends SELError$1 {
  * Thrown when execution limits are exceeded (maxRounds or maxCalls).
  * Prevents infinite loops and runaway execution.
  */
-declare class ExecutionLimitError extends SELError$1 {
+declare class SELExecutionLimitError extends SELExecutionError {
   readonly limitType: "maxRounds" | "maxCalls";
   readonly limit: number;
   readonly actual: number;
@@ -56,51 +128,21 @@ declare class ExecutionLimitError extends SELError$1 {
     actual?: number;
   });
 }
-/**
- * Thrown when a Multicall3 batch execution fails.
- * Includes the failed call index and optional contract name/method name for context.
- * When an individual sub-call reverts, `revertReason` / `revertData` carry the
- * decoded reason text and raw return data, and `decodedError` carries any
- * matched custom-error name + args from the contract's ABI.
- */
-declare class MulticallBatchError extends SELError$1 {
-  readonly failedCallIndex?: number;
-  readonly contractName?: string;
-  readonly methodName?: string;
-  readonly revertReason?: string;
-  readonly revertData?: `0x${string}`;
-  readonly decodedError?: {
-    name: string;
-    args: readonly unknown[];
-  };
-  constructor(message: string, options?: {
-    cause?: unknown;
-    failedCallIndex?: number;
-    contractName?: string;
-    methodName?: string;
-    revertReason?: string;
-    revertData?: `0x${string}`;
-    decodedError?: {
-      name: string;
-      args: readonly unknown[];
-    };
-  });
-}
 /**
  * Thrown when the provided client fails validation or is misconfigured.
  */
-declare class SELClientError extends SELError$1 {
+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$1 {
+declare class SELLintError extends SELStaticError {
   readonly diagnostics: SELDiagnostic[];
   constructor(diagnostics: SELDiagnostic[], options?: {
     cause?: unknown;
   });
 }
 //#endregion
-export { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELClientError, SELContractError, SELError$1 as SELError, SELEvaluationError, SELLintError };
+export { SELCircularDependencyError, SELClientError, SELContractError, SELContractRevertError, SELError$1 as SELError, SELEvaluationError$1 as SELEvaluationError, SELExecutionError, SELExecutionLimitError, SELLintError, SELMulticallBatchError, SELProviderError, SELProviderRpcError, SELProviderTransportError, SELRuntimeError, SELStaticError };