@seljs/runtime 1.0.0 → 1.0.1-beta.9

package/dist/environment/error-wrapper.cjs

@@ -0,0 +1,29 @@
+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");
+//#region src/environment/error-wrapper.ts
+/**
+* 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.
+*/
+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 _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 (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));
+};
+//#endregion
+exports.wrapError = wrapError;

package/dist/environment/error-wrapper.mjs

@@ -0,0 +1,27 @@
+import { SELContractError, SELEvaluationError, SELParseError, SELTypeError } from "../errors/errors.mjs";
+import "../errors/index.mjs";
+import { EvaluationError, ParseError, TypeError } from "@marcbachmann/cel-js";
+//#region src/environment/error-wrapper.ts
+/**
+* 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.
+*/
+const wrapError = (error) => {
+	if (error instanceof SELContractError) return error;
+	if (error instanceof ParseError) return new SELParseError(error.message, { cause: error });
+	if (error instanceof EvaluationError) {
+		const cause = error.cause;
+		if (cause instanceof SELContractError) return 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));
+};
+//#endregion
+export { wrapError };

package/dist/environment/index.cjs

@@ -0,0 +1 @@
+require("./environment.cjs");

package/dist/environment/index.d.mts

@@ -0,0 +1,2 @@
+import { MulticallOptions, SELLimits, SELRuntimeConfig } from "./types.mjs";
+import { SELRuntime } from "./environment.mjs";

package/dist/environment/index.mjs

@@ -0,0 +1,2 @@
+import "./environment.mjs";
+export {};

package/dist/environment/replay-cache.cjs

@@ -0,0 +1,48 @@
+//#region src/environment/replay-cache.ts
+const resolveReplayArgs = (args, variables, results, paramTypes, codecRegistry) => args.map((arg, i) => {
+	const celType = paramTypes[i] ?? "dyn";
+	if (arg.type === "literal") return codecRegistry.encode(celType, arg.value);
+	if (arg.type === "variable") {
+		const name = arg.variableName;
+		if (!name) return;
+		return codecRegistry.encode(celType, variables[name]);
+	}
+	const id = arg.dependsOnCallId;
+	if (!id) return;
+	return codecRegistry.encode(celType, results.get(id));
+});
+/**
+* Builds a replay cache that maps unique identifiers for contract calls to their results.
+* This allows for efficient retrieval of results during execution replay, ensuring that the same inputs yield the same outputs without needing to re-execute the calls.
+*
+* @param calls An array of collected contract calls, each containing information about the contract, method, arguments, and dependencies.
+* @param results A map of call IDs to their corresponding results, which will be used to resolve arguments that depend on previous calls.
+* @param variables A record of variable names to their values, which will be used to resolve arguments that depend on variables.
+*/
+const buildExecutionReplayCache = (calls, results, variables, codecRegistry, getParamTypes) => {
+	const replayCache = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		const result = results.get(call.id);
+		const paramTypes = getParamTypes(call.contract, call.method);
+		const resolvedArgs = resolveReplayArgs(call.args, variables, results, paramTypes, codecRegistry);
+		const replayCallId = createReplayCallId(call.contract, call.method, resolvedArgs);
+		replayCache.set(replayCallId, result);
+	}
+	return replayCache;
+};
+/**
+* Creates a unique identifier for a contract call based on contract name,
+* method, and arguments.
+*
+* IMPORTANT: Args must be pre-encoded via codecRegistry.encode() before
+* calling this function. The encode step normalizes types (e.g., sol_int
+* always produces bigint, sol_address always produces string), which
+* prevents type collisions in String() serialization. If args are NOT
+* pre-encoded, String(42n) === String(42) would cause cache key collisions.
+*/
+const createReplayCallId = (contract, method, args) => {
+	return `${contract}:${method}:${args.map((arg) => String(arg)).join(",")}`;
+};
+//#endregion
+exports.buildExecutionReplayCache = buildExecutionReplayCache;
+exports.createReplayCallId = createReplayCallId;

package/dist/environment/replay-cache.mjs

@@ -0,0 +1,47 @@
+//#region src/environment/replay-cache.ts
+const resolveReplayArgs = (args, variables, results, paramTypes, codecRegistry) => args.map((arg, i) => {
+	const celType = paramTypes[i] ?? "dyn";
+	if (arg.type === "literal") return codecRegistry.encode(celType, arg.value);
+	if (arg.type === "variable") {
+		const name = arg.variableName;
+		if (!name) return;
+		return codecRegistry.encode(celType, variables[name]);
+	}
+	const id = arg.dependsOnCallId;
+	if (!id) return;
+	return codecRegistry.encode(celType, results.get(id));
+});
+/**
+* Builds a replay cache that maps unique identifiers for contract calls to their results.
+* This allows for efficient retrieval of results during execution replay, ensuring that the same inputs yield the same outputs without needing to re-execute the calls.
+*
+* @param calls An array of collected contract calls, each containing information about the contract, method, arguments, and dependencies.
+* @param results A map of call IDs to their corresponding results, which will be used to resolve arguments that depend on previous calls.
+* @param variables A record of variable names to their values, which will be used to resolve arguments that depend on variables.
+*/
+const buildExecutionReplayCache = (calls, results, variables, codecRegistry, getParamTypes) => {
+	const replayCache = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		const result = results.get(call.id);
+		const paramTypes = getParamTypes(call.contract, call.method);
+		const resolvedArgs = resolveReplayArgs(call.args, variables, results, paramTypes, codecRegistry);
+		const replayCallId = createReplayCallId(call.contract, call.method, resolvedArgs);
+		replayCache.set(replayCallId, result);
+	}
+	return replayCache;
+};
+/**
+* Creates a unique identifier for a contract call based on contract name,
+* method, and arguments.
+*
+* IMPORTANT: Args must be pre-encoded via codecRegistry.encode() before
+* calling this function. The encode step normalizes types (e.g., sol_int
+* always produces bigint, sol_address always produces string), which
+* prevents type collisions in String() serialization. If args are NOT
+* pre-encoded, String(42n) === String(42) would cause cache key collisions.
+*/
+const createReplayCallId = (contract, method, args) => {
+	return `${contract}:${method}:${args.map((arg) => String(arg)).join(",")}`;
+};
+//#endregion
+export { buildExecutionReplayCache, createReplayCallId };

package/dist/environment/types.d.cts

@@ -0,0 +1,60 @@
+import { SELSchema } from "@seljs/schema";
+import { Address, PublicClient } from "viem";
+
+//#region src/environment/types.d.ts
+/**
+ * Options for multicall3 batching of contract calls.
+ *
+ * When multiple independent contract calls are executed in the same round,
+ * they are batched into a single multicall3 RPC request for efficiency.
+ */
+interface MulticallOptions {
+  /** Maximum number of calls per multicall3 batch. Unbounded if omitted. */
+  batchSize?: number;
+  /** Custom multicall3 contract address. Defaults to the canonical deployment. */
+  address?: Address;
+}
+/**
+ * Limits for expression parsing and contract call execution.
+ *
+ * AST limits (`maxAstNodes`, `maxDepth`, `maxListElements`, `maxMapEntries`,
+ * `maxCallArguments`) are forwarded to the underlying CEL parser to constrain
+ * expression complexity.
+ *
+ * Execution limits (`maxRounds`, `maxCalls`) bound the multi-round contract
+ * execution engine. An {@link ExecutionLimitError} is thrown when exceeded.
+ */
+interface SELLimits {
+  /** Maximum number of AST nodes allowed in a parsed expression */
+  maxAstNodes?: number;
+  /** Maximum nesting depth of the AST */
+  maxDepth?: number;
+  /** Maximum number of elements in a list literal */
+  maxListElements?: number;
+  /** Maximum number of entries in a map literal */
+  maxMapEntries?: number;
+  /** Maximum number of arguments in a single function call */
+  maxCallArguments?: number;
+  /** Maximum number of dependency-ordered execution rounds (default: 10) */
+  maxRounds?: number;
+  /** Maximum total number of contract calls across all rounds (default: 100) */
+  maxCalls?: number;
+}
+/**
+ * Configuration for creating an immutable {@link SELRuntime}.
+ *
+ * All contracts and context must be declared here — the environment
+ * cannot be mutated after construction.
+ */
+interface SELRuntimeConfig {
+  /** SEL schema describing contracts, variables, types, functions, and macros */
+  schema: SELSchema;
+  /** Viem public client for executing on-chain contract reads */
+  client?: PublicClient;
+  /** Multicall3 batching options for contract call execution */
+  multicall?: MulticallOptions;
+  /** AST parsing and execution limits */
+  limits?: SELLimits;
+}
+//#endregion
+export { MulticallOptions, SELLimits, SELRuntimeConfig };

package/dist/environment/types.d.mts

@@ -0,0 +1,60 @@
+import { Address, PublicClient } from "viem";
+import { SELSchema } from "@seljs/schema";
+
+//#region src/environment/types.d.ts
+/**
+ * Options for multicall3 batching of contract calls.
+ *
+ * When multiple independent contract calls are executed in the same round,
+ * they are batched into a single multicall3 RPC request for efficiency.
+ */
+interface MulticallOptions {
+  /** Maximum number of calls per multicall3 batch. Unbounded if omitted. */
+  batchSize?: number;
+  /** Custom multicall3 contract address. Defaults to the canonical deployment. */
+  address?: Address;
+}
+/**
+ * Limits for expression parsing and contract call execution.
+ *
+ * AST limits (`maxAstNodes`, `maxDepth`, `maxListElements`, `maxMapEntries`,
+ * `maxCallArguments`) are forwarded to the underlying CEL parser to constrain
+ * expression complexity.
+ *
+ * Execution limits (`maxRounds`, `maxCalls`) bound the multi-round contract
+ * execution engine. An {@link ExecutionLimitError} is thrown when exceeded.
+ */
+interface SELLimits {
+  /** Maximum number of AST nodes allowed in a parsed expression */
+  maxAstNodes?: number;
+  /** Maximum nesting depth of the AST */
+  maxDepth?: number;
+  /** Maximum number of elements in a list literal */
+  maxListElements?: number;
+  /** Maximum number of entries in a map literal */
+  maxMapEntries?: number;
+  /** Maximum number of arguments in a single function call */
+  maxCallArguments?: number;
+  /** Maximum number of dependency-ordered execution rounds (default: 10) */
+  maxRounds?: number;
+  /** Maximum total number of contract calls across all rounds (default: 100) */
+  maxCalls?: number;
+}
+/**
+ * Configuration for creating an immutable {@link SELRuntime}.
+ *
+ * All contracts and context must be declared here — the environment
+ * cannot be mutated after construction.
+ */
+interface SELRuntimeConfig {
+  /** SEL schema describing contracts, variables, types, functions, and macros */
+  schema: SELSchema;
+  /** Viem public client for executing on-chain contract reads */
+  client?: PublicClient;
+  /** Multicall3 batching options for contract call execution */
+  multicall?: MulticallOptions;
+  /** AST parsing and execution limits */
+  limits?: SELLimits;
+}
+//#endregion
+export { MulticallOptions, SELLimits, SELRuntimeConfig };

package/dist/errors/errors.cjs

@@ -0,0 +1,68 @@
+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.
+*/
+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 {
+	contractName;
+	methodName;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.contractName = options?.contractName;
+		this.methodName = options?.methodName;
+	}
+};
+/**
+* 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 CircularDependencyError = class extends _seljs_common.SELError {
+	callIds;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.callIds = options?.callIds ?? [];
+	}
+};
+/**
+* Thrown when execution limits are exceeded (maxRounds or maxCalls).
+* Prevents infinite loops and runaway execution.
+*/
+var ExecutionLimitError = class extends _seljs_common.SELError {
+	limitType;
+	limit;
+	actual;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.limitType = options?.limitType ?? "maxRounds";
+		this.limit = options?.limit ?? 0;
+		this.actual = options?.actual ?? 0;
+	}
+};
+/**
+* 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;
+	}
+};
+//#endregion
+exports.CircularDependencyError = CircularDependencyError;
+exports.ExecutionLimitError = ExecutionLimitError;
+exports.MulticallBatchError = MulticallBatchError;
+exports.SELContractError = SELContractError;
+exports.SELEvaluationError = SELEvaluationError;

package/dist/errors/errors.d.cts

@@ -0,0 +1,64 @@
+import { SELError, SELParseError, SELTypeError } from "@seljs/common";
+
+//#region src/errors/errors.d.ts
+/**
+ * Thrown when CEL expression evaluation fails.
+ * Wraps cel-js EvaluationError with additional context.
+ */
+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 {
+  readonly contractName?: string;
+  readonly methodName?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    contractName?: string;
+    methodName?: string;
+  });
+}
+/**
+ * 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 {
+  readonly callIds: string[];
+  constructor(message: string, options?: {
+    cause?: unknown;
+    callIds?: string[];
+  });
+}
+/**
+ * Thrown when execution limits are exceeded (maxRounds or maxCalls).
+ * Prevents infinite loops and runaway execution.
+ */
+declare class ExecutionLimitError extends SELError {
+  readonly limitType: "maxRounds" | "maxCalls";
+  readonly limit: number;
+  readonly actual: number;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    limitType?: "maxRounds" | "maxCalls";
+    limit?: number;
+    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;
+  });
+}
+//#endregion
+export { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELTypeError };

package/dist/errors/errors.d.mts

@@ -0,0 +1,64 @@
+import { SELError, SELParseError, SELTypeError } from "@seljs/common";
+
+//#region src/errors/errors.d.ts
+/**
+ * Thrown when CEL expression evaluation fails.
+ * Wraps cel-js EvaluationError with additional context.
+ */
+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 {
+  readonly contractName?: string;
+  readonly methodName?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    contractName?: string;
+    methodName?: string;
+  });
+}
+/**
+ * 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 {
+  readonly callIds: string[];
+  constructor(message: string, options?: {
+    cause?: unknown;
+    callIds?: string[];
+  });
+}
+/**
+ * Thrown when execution limits are exceeded (maxRounds or maxCalls).
+ * Prevents infinite loops and runaway execution.
+ */
+declare class ExecutionLimitError extends SELError {
+  readonly limitType: "maxRounds" | "maxCalls";
+  readonly limit: number;
+  readonly actual: number;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    limitType?: "maxRounds" | "maxCalls";
+    limit?: number;
+    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;
+  });
+}
+//#endregion
+export { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELTypeError };

package/dist/errors/errors.mjs

@@ -0,0 +1,63 @@
+import { SELError, SELParseError, SELTypeError } from "@seljs/common";
+//#region src/errors/errors.ts
+/**
+* Thrown when CEL expression evaluation fails.
+* Wraps cel-js EvaluationError with additional context.
+*/
+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 {
+	contractName;
+	methodName;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.contractName = options?.contractName;
+		this.methodName = options?.methodName;
+	}
+};
+/**
+* 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 CircularDependencyError = class extends SELError {
+	callIds;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.callIds = options?.callIds ?? [];
+	}
+};
+/**
+* Thrown when execution limits are exceeded (maxRounds or maxCalls).
+* Prevents infinite loops and runaway execution.
+*/
+var ExecutionLimitError = class extends SELError {
+	limitType;
+	limit;
+	actual;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.limitType = options?.limitType ?? "maxRounds";
+		this.limit = options?.limit ?? 0;
+		this.actual = options?.actual ?? 0;
+	}
+};
+/**
+* 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;
+	}
+};
+//#endregion
+export { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELTypeError };

package/dist/errors/index.cjs

@@ -0,0 +1,3 @@
+require("../_virtual/_rolldown/runtime.cjs");
+require("./errors.cjs");
+require("@seljs/common");

package/dist/errors/index.d.mts

@@ -0,0 +1 @@
+import { CircularDependencyError, ExecutionLimitError, MulticallBatchError, SELContractError, SELError, SELEvaluationError, SELParseError, SELTypeError } from "./errors.mjs";

package/dist/errors/index.mjs

@@ -0,0 +1,2 @@
+import "./errors.mjs";
+export {};

package/dist/execution/multi-round-executor.cjs

@@ -0,0 +1,45 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_debug = require("../debug.cjs");
+const require_multicall_batcher = require("./multicall-batcher.cjs");
+const require_result_cache = require("./result-cache.cjs");
+const require_round_executor = require("./round-executor.cjs");
+let viem_actions = require("viem/actions");
+//#region src/execution/multi-round-executor.ts
+const debug = require_debug.createLogger("execute");
+var MultiRoundExecutor = class {
+	contracts;
+	constructor(client, contracts, multicallOptions) {
+		this.client = client;
+		this.multicallOptions = multicallOptions;
+		this.contracts = contracts;
+	}
+	async execute(plan, variables = {}, blockNumber) {
+		const lockedBlockNumber = blockNumber ?? await (0, viem_actions.getBlockNumber)(this.client);
+		debug("start: %d rounds, %d calls, block=%s", plan.rounds.length, plan.totalCalls, String(lockedBlockNumber));
+		const cache = new require_result_cache.ResultCache();
+		const batcher = new require_multicall_batcher.MulticallBatcher(this.client, this.multicallOptions);
+		const executor = new require_round_executor.RoundExecutor(this.contracts, cache, batcher);
+		const context = {
+			client: this.client,
+			blockNumber: lockedBlockNumber,
+			variables
+		};
+		for (const round of plan.rounds) {
+			debug("round %d: %d calls", round.roundNumber, round.calls.length);
+			await executor.executeRound(round, context);
+		}
+		const results = /* @__PURE__ */ new Map();
+		for (const round of plan.rounds) for (const call of round.calls) results.set(call.id, cache.get(call.id));
+		debug("complete: %d results collected", results.size);
+		return {
+			results,
+			meta: {
+				roundsExecuted: plan.rounds.length,
+				totalCalls: plan.totalCalls,
+				blockNumber: lockedBlockNumber
+			}
+		};
+	}
+};
+//#endregion
+exports.MultiRoundExecutor = MultiRoundExecutor;

package/dist/execution/multi-round-executor.mjs

@@ -0,0 +1,44 @@
+import { createLogger } from "../debug.mjs";
+import { MulticallBatcher } from "./multicall-batcher.mjs";
+import { ResultCache } from "./result-cache.mjs";
+import { RoundExecutor } from "./round-executor.mjs";
+import { getBlockNumber } from "viem/actions";
+//#region src/execution/multi-round-executor.ts
+const debug = createLogger("execute");
+var MultiRoundExecutor = class {
+	contracts;
+	constructor(client, contracts, multicallOptions) {
+		this.client = client;
+		this.multicallOptions = multicallOptions;
+		this.contracts = contracts;
+	}
+	async execute(plan, variables = {}, blockNumber) {
+		const lockedBlockNumber = blockNumber ?? await getBlockNumber(this.client);
+		debug("start: %d rounds, %d calls, block=%s", plan.rounds.length, plan.totalCalls, String(lockedBlockNumber));
+		const cache = new ResultCache();
+		const batcher = new MulticallBatcher(this.client, this.multicallOptions);
+		const executor = new RoundExecutor(this.contracts, cache, batcher);
+		const context = {
+			client: this.client,
+			blockNumber: lockedBlockNumber,
+			variables
+		};
+		for (const round of plan.rounds) {
+			debug("round %d: %d calls", round.roundNumber, round.calls.length);
+			await executor.executeRound(round, context);
+		}
+		const results = /* @__PURE__ */ new Map();
+		for (const round of plan.rounds) for (const call of round.calls) results.set(call.id, cache.get(call.id));
+		debug("complete: %d results collected", results.size);
+		return {
+			results,
+			meta: {
+				roundsExecuted: plan.rounds.length,
+				totalCalls: plan.totalCalls,
+				blockNumber: lockedBlockNumber
+			}
+		};
+	}
+};
+//#endregion
+export { MultiRoundExecutor };