@seljs/checker 1.0.0 → 1.0.1

package/dist/environment/register-types.mjs

@@ -0,0 +1,106 @@
+import { SOLIDITY_TYPES, SolidityIntTypeWrapper, formatUnitsValue, parseUnitsValue, toAddress, toBigInt } from "@seljs/types";
+//#region src/environment/register-types.ts
+/**
+* Try to register an operator, silently ignoring "already registered" errors.
+* cel-js auto-derives some cross-type operators (e.g., registering
+* `sol_int == int` also creates `int == sol_int`).
+*/
+const tryRegisterOperator = (env, signature, handler) => {
+	try {
+		env.registerOperator(signature, handler);
+	} catch (error) {
+		if (!(error instanceof Error) || !error.message.includes("already registered")) throw error;
+	}
+};
+const registerAddressOperators = (env) => {
+	env.registerOperator("sol_address == sol_address", (left, right) => toAddress(left) === toAddress(right));
+	env.registerOperator("sol_address < sol_address", (left, right) => toAddress(left) < toAddress(right));
+	env.registerOperator("sol_address <= sol_address", (left, right) => toAddress(left) <= toAddress(right));
+	env.registerOperator("sol_address > sol_address", (left, right) => toAddress(left) > toAddress(right));
+	env.registerOperator("sol_address >= sol_address", (left, right) => toAddress(left) >= toAddress(right));
+};
+const toSolInt = (value) => new SolidityIntTypeWrapper(value);
+const registerIntegerOperators = (env) => {
+	env.registerOperator("sol_int + sol_int", (a, b) => toSolInt(toBigInt(a) + toBigInt(b)));
+	env.registerOperator("sol_int - sol_int", (a, b) => toSolInt(toBigInt(a) - toBigInt(b)));
+	env.registerOperator("sol_int * sol_int", (a, b) => toSolInt(toBigInt(a) * toBigInt(b)));
+	env.registerOperator("sol_int / sol_int", (a, b) => {
+		const divisor = toBigInt(b);
+		if (divisor === 0n) throw new Error("division by zero");
+		return toSolInt(toBigInt(a) / divisor);
+	});
+	env.registerOperator("sol_int % sol_int", (a, b) => {
+		const divisor = toBigInt(b);
+		if (divisor === 0n) throw new Error("modulo by zero");
+		return toSolInt(toBigInt(a) % divisor);
+	});
+	env.registerOperator("-sol_int", (a) => toSolInt(-toBigInt(a)));
+	env.registerOperator("sol_int == sol_int", (a, b) => toBigInt(a) === toBigInt(b));
+	env.registerOperator("sol_int < sol_int", (a, b) => toBigInt(a) < toBigInt(b));
+	env.registerOperator("sol_int <= sol_int", (a, b) => toBigInt(a) <= toBigInt(b));
+	env.registerOperator("sol_int > sol_int", (a, b) => toBigInt(a) > toBigInt(b));
+	env.registerOperator("sol_int >= sol_int", (a, b) => toBigInt(a) >= toBigInt(b));
+	tryRegisterOperator(env, "sol_int + int", (a, b) => toSolInt(toBigInt(a) + toBigInt(b)));
+	tryRegisterOperator(env, "sol_int - int", (a, b) => toSolInt(toBigInt(a) - toBigInt(b)));
+	tryRegisterOperator(env, "sol_int * int", (a, b) => toSolInt(toBigInt(a) * toBigInt(b)));
+	tryRegisterOperator(env, "sol_int / int", (a, b) => {
+		const divisor = toBigInt(b);
+		if (divisor === 0n) throw new Error("division by zero");
+		return toSolInt(toBigInt(a) / divisor);
+	});
+	tryRegisterOperator(env, "sol_int % int", (a, b) => {
+		const divisor = toBigInt(b);
+		if (divisor === 0n) throw new Error("modulo by zero");
+		return toSolInt(toBigInt(a) % divisor);
+	});
+	tryRegisterOperator(env, "sol_int == int", (a, b) => toBigInt(a) === toBigInt(b));
+	tryRegisterOperator(env, "int == sol_int", (a, b) => toBigInt(a) === toBigInt(b));
+	tryRegisterOperator(env, "sol_int < int", (a, b) => toBigInt(a) < toBigInt(b));
+	tryRegisterOperator(env, "int < sol_int", (a, b) => toBigInt(a) < toBigInt(b));
+	tryRegisterOperator(env, "sol_int <= int", (a, b) => toBigInt(a) <= toBigInt(b));
+	tryRegisterOperator(env, "int <= sol_int", (a, b) => toBigInt(a) <= toBigInt(b));
+	tryRegisterOperator(env, "sol_int > int", (a, b) => toBigInt(a) > toBigInt(b));
+	tryRegisterOperator(env, "int > sol_int", (a, b) => toBigInt(a) > toBigInt(b));
+	tryRegisterOperator(env, "sol_int >= int", (a, b) => toBigInt(a) >= toBigInt(b));
+	tryRegisterOperator(env, "int >= sol_int", (a, b) => toBigInt(a) >= toBigInt(b));
+};
+/**
+* Register all Solidity primitive types on a CEL Environment.
+*/
+const registerSolidityTypes = (env) => {
+	for (const entry of SOLIDITY_TYPES) {
+		if (entry.type === "builtin") continue;
+		env.registerType(entry.name, entry.wrapperClass);
+		if (entry.name === "sol_address") registerAddressOperators(env);
+		if (entry.name === "sol_int") registerIntegerOperators(env);
+		const Ctor = entry.wrapperClass;
+		for (const sig of entry.castSignatures) env.registerFunction(sig, (value) => new Ctor(value));
+	}
+	env.registerFunction("parseUnits(string, int): sol_int", (value, decimals) => parseUnitsValue(value, Number(toBigInt(decimals))));
+	env.registerFunction("parseUnits(int, int): sol_int", (value, decimals) => parseUnitsValue(value, Number(toBigInt(decimals))));
+	env.registerFunction("parseUnits(double, int): sol_int", (value, decimals) => parseUnitsValue(value, Number(toBigInt(decimals))));
+	env.registerFunction("parseUnits(sol_int, int): sol_int", (value, decimals) => parseUnitsValue(value, Number(toBigInt(decimals))));
+	env.registerFunction("formatUnits(sol_int, int): double", (value, decimals) => formatUnitsValue(value, Number(toBigInt(decimals))));
+	env.registerFunction("formatUnits(int, int): double", (value, decimals) => formatUnitsValue(value, Number(toBigInt(decimals))));
+	env.registerFunction("min(sol_int, sol_int): sol_int", (a, b) => toBigInt(a) <= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("min(sol_int, int): sol_int", (a, b) => toBigInt(a) <= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("min(int, sol_int): sol_int", (a, b) => toBigInt(a) <= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("min(int, int): sol_int", (a, b) => toBigInt(a) <= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(sol_int, sol_int): sol_int", (a, b) => toBigInt(a) >= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(sol_int, int): sol_int", (a, b) => toBigInt(a) >= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(int, sol_int): sol_int", (a, b) => toBigInt(a) >= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(int, int): sol_int", (a, b) => toBigInt(a) >= toBigInt(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("abs(sol_int): sol_int", (a) => {
+		const v = toBigInt(a);
+		return toSolInt(v < 0n ? -v : v);
+	});
+	env.registerFunction("abs(int): sol_int", (a) => {
+		const v = toBigInt(a);
+		return toSolInt(v < 0n ? -v : v);
+	});
+	const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+	env.registerFunction("isZeroAddress(sol_address): bool", (addr) => toAddress(addr) === ZERO_ADDRESS);
+	env.registerFunction("isZeroAddress(string): bool", (addr) => toAddress(addr) === ZERO_ADDRESS);
+};
+//#endregion
+export { registerSolidityTypes };

package/dist/environment/value-wrappers.cjs

@@ -0,0 +1,44 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let _seljs_types = require("@seljs/types");
+//#region src/environment/value-wrappers.ts
+const wrapFieldValue = (registry, celType, value) => {
+	const nested = registry.get(celType);
+	if (nested) return wrapStructValue(registry, nested, value);
+	return wrapValueForSel(celType, value);
+};
+/**
+* Maps a CEL type to the native CEL literal type for dual function registration.
+*/
+const toCelLiteralType = (celType) => {
+	if (celType === "sol_int") return "int";
+	if (celType === "sol_address") return "string";
+	return null;
+};
+/**
+* Wraps a raw value into the corresponding SEL wrapper type.
+*/
+const wrapValueForSel = (celType, value) => {
+	if (value instanceof _seljs_types.SolidityAddressTypeWrapper) return value;
+	if (value instanceof _seljs_types.SolidityIntTypeWrapper) return value;
+	if (celType === "sol_address") return new _seljs_types.SolidityAddressTypeWrapper(value);
+	if (typeof value === "bigint") return new _seljs_types.SolidityIntTypeWrapper(value);
+	if (typeof value === "number" && Number.isInteger(value)) return new _seljs_types.SolidityIntTypeWrapper(BigInt(value));
+	return value;
+};
+/**
+* Recursively wraps a raw struct value with the correct ctor and wrapped field values.
+*/
+const wrapStructValue = (registry, info, value) => {
+	const { ctor, fieldNames, fieldTypes } = info;
+	let data;
+	if (Array.isArray(value)) data = Object.fromEntries(fieldNames.map((name, i) => [name, wrapFieldValue(registry, fieldTypes[name] ?? "dyn", value[i])]));
+	else {
+		const raw = value;
+		data = Object.fromEntries(Object.entries(raw).map(([name, val]) => [name, fieldTypes[name] ? wrapFieldValue(registry, fieldTypes[name], val) : val]));
+	}
+	return Object.assign(new ctor(), data);
+};
+//#endregion
+exports.toCelLiteralType = toCelLiteralType;
+exports.wrapStructValue = wrapStructValue;
+exports.wrapValueForSel = wrapValueForSel;

package/dist/environment/value-wrappers.d.cts

@@ -0,0 +1,20 @@
+//#region src/environment/value-wrappers.d.ts
+interface StructInfo {
+  ctor: new () => object;
+  fieldNames: string[];
+  fieldTypes: Record<string, string>;
+}
+/**
+ * Maps a CEL type to the native CEL literal type for dual function registration.
+ */
+declare const toCelLiteralType: (celType: string) => string | null;
+/**
+ * Wraps a raw value into the corresponding SEL wrapper type.
+ */
+declare const wrapValueForSel: (celType: string, value: unknown) => unknown;
+/**
+ * Recursively wraps a raw struct value with the correct ctor and wrapped field values.
+ */
+declare const wrapStructValue: (registry: Map<string, StructInfo>, info: StructInfo, value: unknown) => unknown;
+//#endregion
+export { StructInfo, toCelLiteralType, wrapStructValue, wrapValueForSel };

package/dist/environment/value-wrappers.d.mts

@@ -0,0 +1,20 @@
+//#region src/environment/value-wrappers.d.ts
+interface StructInfo {
+  ctor: new () => object;
+  fieldNames: string[];
+  fieldTypes: Record<string, string>;
+}
+/**
+ * Maps a CEL type to the native CEL literal type for dual function registration.
+ */
+declare const toCelLiteralType: (celType: string) => string | null;
+/**
+ * Wraps a raw value into the corresponding SEL wrapper type.
+ */
+declare const wrapValueForSel: (celType: string, value: unknown) => unknown;
+/**
+ * Recursively wraps a raw struct value with the correct ctor and wrapped field values.
+ */
+declare const wrapStructValue: (registry: Map<string, StructInfo>, info: StructInfo, value: unknown) => unknown;
+//#endregion
+export { StructInfo, toCelLiteralType, wrapStructValue, wrapValueForSel };

package/dist/environment/value-wrappers.mjs

@@ -0,0 +1,41 @@
+import { SolidityAddressTypeWrapper, SolidityIntTypeWrapper } from "@seljs/types";
+//#region src/environment/value-wrappers.ts
+const wrapFieldValue = (registry, celType, value) => {
+	const nested = registry.get(celType);
+	if (nested) return wrapStructValue(registry, nested, value);
+	return wrapValueForSel(celType, value);
+};
+/**
+* Maps a CEL type to the native CEL literal type for dual function registration.
+*/
+const toCelLiteralType = (celType) => {
+	if (celType === "sol_int") return "int";
+	if (celType === "sol_address") return "string";
+	return null;
+};
+/**
+* Wraps a raw value into the corresponding SEL wrapper type.
+*/
+const wrapValueForSel = (celType, value) => {
+	if (value instanceof SolidityAddressTypeWrapper) return value;
+	if (value instanceof SolidityIntTypeWrapper) return value;
+	if (celType === "sol_address") return new SolidityAddressTypeWrapper(value);
+	if (typeof value === "bigint") return new SolidityIntTypeWrapper(value);
+	if (typeof value === "number" && Number.isInteger(value)) return new SolidityIntTypeWrapper(BigInt(value));
+	return value;
+};
+/**
+* Recursively wraps a raw struct value with the correct ctor and wrapped field values.
+*/
+const wrapStructValue = (registry, info, value) => {
+	const { ctor, fieldNames, fieldTypes } = info;
+	let data;
+	if (Array.isArray(value)) data = Object.fromEntries(fieldNames.map((name, i) => [name, wrapFieldValue(registry, fieldTypes[name] ?? "dyn", value[i])]));
+	else {
+		const raw = value;
+		data = Object.fromEntries(Object.entries(raw).map(([name, val]) => [name, fieldTypes[name] ? wrapFieldValue(registry, fieldTypes[name], val) : val]));
+	}
+	return Object.assign(new ctor(), data);
+};
+//#endregion
+export { toCelLiteralType, wrapStructValue, wrapValueForSel };

package/dist/index.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_type_compatibility = require("./checker/type-compatibility.cjs");
+const require_codec_registry = require("./environment/codec-registry.cjs");
+const require_register_types = require("./environment/register-types.cjs");
+const require_value_wrappers = require("./environment/value-wrappers.cjs");
+const require_hydrate = require("./environment/hydrate.cjs");
+const require_constants = require("./constants.cjs");
+const require_facade = require("./rules/facade.cjs");
+const require_runner = require("./rules/runner.cjs");
+require("./rules/index.cjs");
+const require_checker = require("./checker/checker.cjs");
+require("./checker/index.cjs");
+require("./environment/index.cjs");
+exports.COMPREHENSION_MACROS = require_constants.COMPREHENSION_MACROS;
+exports.CelCodecRegistry = require_codec_registry.CelCodecRegistry;
+exports.SCALAR_WRAPPER_FUNCTIONS = require_constants.SCALAR_WRAPPER_FUNCTIONS;
+exports.SELChecker = require_checker.SELChecker;
+exports.createBaseEnvironment = require_hydrate.createBaseEnvironment;
+exports.createCheckerEnvironment = require_hydrate.createCheckerEnvironment;
+exports.createRuntimeEnvironment = require_hydrate.createRuntimeEnvironment;
+exports.isTypeCompatible = require_type_compatibility.isTypeCompatible;
+exports.registerSolidityTypes = require_register_types.registerSolidityTypes;
+exports.rules = require_facade.rules;
+exports.runRules = require_runner.runRules;
+exports.toCelLiteralType = require_value_wrappers.toCelLiteralType;
+exports.wrapStructValue = require_value_wrappers.wrapStructValue;
+exports.wrapValueForSel = require_value_wrappers.wrapValueForSel;

package/dist/index.d.cts

@@ -0,0 +1,11 @@
+import { RuleContext, RuleSeverity, RuleTier, SELRule } from "./rules/types.cjs";
+import { rules } from "./rules/facade.cjs";
+import { RunRulesOptions, runRules } from "./rules/runner.cjs";
+import { CompletionItem, SELChecker, SELCheckerOptions, SELDiagnostic } from "./checker/checker.cjs";
+import { isTypeCompatible } from "./checker/type-compatibility.cjs";
+import { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS } from "./constants.cjs";
+import { CelCodecRegistry, CelCodecRegistryOptions, StructCodecDescriptor } from "./environment/codec-registry.cjs";
+import { CelLimits, ContractCallHandler, RuntimeEnvironmentResult, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment } from "./environment/hydrate.cjs";
+import { registerSolidityTypes } from "./environment/register-types.cjs";
+import { StructInfo, toCelLiteralType, wrapStructValue, wrapValueForSel } from "./environment/value-wrappers.cjs";
+export { COMPREHENSION_MACROS, CelCodecRegistry, CelCodecRegistryOptions, CelLimits, CompletionItem, ContractCallHandler, RuleContext, RuleSeverity, RuleTier, RunRulesOptions, RuntimeEnvironmentResult, SCALAR_WRAPPER_FUNCTIONS, SELChecker, SELCheckerOptions, SELDiagnostic, SELRule, StructCodecDescriptor, StructInfo, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment, isTypeCompatible, registerSolidityTypes, rules, runRules, toCelLiteralType, wrapStructValue, wrapValueForSel };

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { RuleContext, RuleSeverity, RuleTier, SELRule } from "./rules/types.mjs";
+import { rules } from "./rules/facade.mjs";
+import { RunRulesOptions, runRules } from "./rules/runner.mjs";
+import { CompletionItem, SELChecker, SELCheckerOptions, SELDiagnostic } from "./checker/checker.mjs";
+import { isTypeCompatible } from "./checker/type-compatibility.mjs";
+import { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS } from "./constants.mjs";
+import { CelCodecRegistry, CelCodecRegistryOptions, StructCodecDescriptor } from "./environment/codec-registry.mjs";
+import { CelLimits, ContractCallHandler, RuntimeEnvironmentResult, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment } from "./environment/hydrate.mjs";
+import { registerSolidityTypes } from "./environment/register-types.mjs";
+import { StructInfo, toCelLiteralType, wrapStructValue, wrapValueForSel } from "./environment/value-wrappers.mjs";
+export { COMPREHENSION_MACROS, CelCodecRegistry, CelCodecRegistryOptions, CelLimits, CompletionItem, ContractCallHandler, RuleContext, RuleSeverity, RuleTier, RunRulesOptions, RuntimeEnvironmentResult, SCALAR_WRAPPER_FUNCTIONS, SELChecker, SELCheckerOptions, SELDiagnostic, SELRule, StructCodecDescriptor, StructInfo, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment, isTypeCompatible, registerSolidityTypes, rules, runRules, toCelLiteralType, wrapStructValue, wrapValueForSel };

package/dist/index.mjs

@@ -0,0 +1,13 @@
+import { isTypeCompatible } from "./checker/type-compatibility.mjs";
+import { CelCodecRegistry } from "./environment/codec-registry.mjs";
+import { registerSolidityTypes } from "./environment/register-types.mjs";
+import { toCelLiteralType, wrapStructValue, wrapValueForSel } from "./environment/value-wrappers.mjs";
+import { createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment } from "./environment/hydrate.mjs";
+import { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS } from "./constants.mjs";
+import { rules } from "./rules/facade.mjs";
+import { runRules } from "./rules/runner.mjs";
+import "./rules/index.mjs";
+import { SELChecker } from "./checker/checker.mjs";
+import "./checker/index.mjs";
+import "./environment/index.mjs";
+export { COMPREHENSION_MACROS, CelCodecRegistry, SCALAR_WRAPPER_FUNCTIONS, SELChecker, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment, isTypeCompatible, registerSolidityTypes, rules, runRules, toCelLiteralType, wrapStructValue, wrapValueForSel };

package/dist/rules/defaults/deferred-call.cjs

@@ -0,0 +1,107 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_constants = require("../../constants.cjs");
+const require_ast_utils = require("../../utils/ast-utils.cjs");
+let _seljs_common = require("@seljs/common");
+//#region src/rules/defaults/deferred-call.ts
+/**
+* Checks whether a scalar wrapper inner value (inside solInt/solAddress) is resolvable.
+*/
+const isScalarInnerResolvable = (inner, scopedVars) => {
+	if (!(0, _seljs_common.isAstNode)(inner)) return false;
+	if (inner.op === "value") return true;
+	return inner.op === "id" && typeof inner.args === "string" && !scopedVars.has(inner.args);
+};
+/**
+* Checks whether a call node is a resolvable scalar wrapper (solInt/solAddress).
+*/
+const isResolvableScalarWrapper = (node, scopedVars) => {
+	const nodeArgs = node.args;
+	const fnName = nodeArgs[0];
+	const fnArgs = nodeArgs[1];
+	if (typeof fnName !== "string" || !require_constants.SCALAR_WRAPPER_FUNCTIONS.has(fnName) || !Array.isArray(fnArgs) || fnArgs.length !== 1) return false;
+	return isScalarInnerResolvable(fnArgs[0], scopedVars);
+};
+/**
+* Checks whether a single argument node is statically resolvable
+* (literal, context variable, or nested contract call result).
+*/
+const isResolvableArg = (argNode, contractNames, scopedVars) => {
+	if (!(0, _seljs_common.isAstNode)(argNode)) return false;
+	if (argNode.op === "call") return isResolvableScalarWrapper(argNode, scopedVars);
+	if (argNode.op === "value") return true;
+	if (argNode.op === "id" && typeof argNode.args === "string") return !scopedVars.has(argNode.args);
+	if (argNode.op === "rcall") return isContractRCall(argNode, contractNames);
+	return false;
+};
+/**
+* Checks whether an rcall node targets a registered contract.
+*/
+const isContractRCall = (node, contractNames) => {
+	const receiverNode = node.args[1];
+	return (0, _seljs_common.isAstNode)(receiverNode) && receiverNode.op === "id" && typeof receiverNode.args === "string" && contractNames.has(receiverNode.args);
+};
+/**
+* Extracts the rcall components: method name, receiver node, and argument list.
+*/
+const parseRCallNode = (node) => {
+	const nodeArgs = node.args;
+	const method = nodeArgs[0];
+	const receiver = nodeArgs[1];
+	const callArgs = nodeArgs[2];
+	if (typeof method !== "string" || !Array.isArray(callArgs)) return;
+	return {
+		method,
+		receiver,
+		callArgs
+	};
+};
+/**
+* Tracks scoped variables introduced by comprehension macros or cel.bind().
+*/
+const trackScopedVars = (parsed, scopedVars) => {
+	const { method, receiver, callArgs } = parsed;
+	if ((0, _seljs_common.isAstNode)(receiver) && receiver.op !== "id" && require_constants.COMPREHENSION_MACROS.has(method) && callArgs.length >= 1) {
+		const iterVarNode = callArgs[0];
+		if ((0, _seljs_common.isAstNode)(iterVarNode) && iterVarNode.op === "id" && typeof iterVarNode.args === "string") scopedVars.add(iterVarNode.args);
+	}
+	if (method === "bind" && (0, _seljs_common.isAstNode)(receiver) && receiver.op === "id" && receiver.args === "cel" && callArgs.length >= 1) {
+		const nameNode = callArgs[0];
+		if ((0, _seljs_common.isAstNode)(nameNode) && nameNode.op === "id" && typeof nameNode.args === "string") scopedVars.add(nameNode.args);
+	}
+};
+/**
+* Flags contract calls whose arguments cannot be resolved statically,
+* meaning they will execute as live RPC calls at evaluation time instead
+* of being batched via multicall.
+*
+* This includes calls with arguments that depend on:
+* - Comprehension iteration variables (map/filter/exists)
+* - cel.bind() scoped variables
+* - Arithmetic or other expressions on call results
+* - Struct field access on call results
+*/
+const deferredCall = {
+	name: "deferred-call",
+	description: "Flags contract calls with dynamic arguments that cannot be batched via multicall.",
+	defaultSeverity: "info",
+	tier: "structural",
+	run(context) {
+		const contractNames = new Set(context.schema.contracts.map((c) => c.name));
+		if (contractNames.size === 0) return [];
+		const diagnostics = [];
+		const scopedVars = /* @__PURE__ */ new Set();
+		require_ast_utils.walkAST(context.ast, (node) => {
+			if (node.op !== "rcall") return;
+			const parsed = parseRCallNode(node);
+			if (!parsed) return;
+			const { method, callArgs } = parsed;
+			trackScopedVars(parsed, scopedVars);
+			if (!isContractRCall(node, contractNames)) return;
+			const contractName = node.args[1].args;
+			if (callArgs.some((argNode) => !isResolvableArg(argNode, contractNames, scopedVars))) diagnostics.push(context.report(node, `\`${contractName}.${method}()\` has dynamic arguments and will execute as a live RPC call instead of being batched.`));
+		});
+		return diagnostics;
+	}
+};
+//#endregion
+exports.deferredCall = deferredCall;

package/dist/rules/defaults/deferred-call.mjs

@@ -0,0 +1,106 @@
+import { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS } from "../../constants.mjs";
+import { walkAST } from "../../utils/ast-utils.mjs";
+import { isAstNode } from "@seljs/common";
+//#region src/rules/defaults/deferred-call.ts
+/**
+* Checks whether a scalar wrapper inner value (inside solInt/solAddress) is resolvable.
+*/
+const isScalarInnerResolvable = (inner, scopedVars) => {
+	if (!isAstNode(inner)) return false;
+	if (inner.op === "value") return true;
+	return inner.op === "id" && typeof inner.args === "string" && !scopedVars.has(inner.args);
+};
+/**
+* Checks whether a call node is a resolvable scalar wrapper (solInt/solAddress).
+*/
+const isResolvableScalarWrapper = (node, scopedVars) => {
+	const nodeArgs = node.args;
+	const fnName = nodeArgs[0];
+	const fnArgs = nodeArgs[1];
+	if (typeof fnName !== "string" || !SCALAR_WRAPPER_FUNCTIONS.has(fnName) || !Array.isArray(fnArgs) || fnArgs.length !== 1) return false;
+	return isScalarInnerResolvable(fnArgs[0], scopedVars);
+};
+/**
+* Checks whether a single argument node is statically resolvable
+* (literal, context variable, or nested contract call result).
+*/
+const isResolvableArg = (argNode, contractNames, scopedVars) => {
+	if (!isAstNode(argNode)) return false;
+	if (argNode.op === "call") return isResolvableScalarWrapper(argNode, scopedVars);
+	if (argNode.op === "value") return true;
+	if (argNode.op === "id" && typeof argNode.args === "string") return !scopedVars.has(argNode.args);
+	if (argNode.op === "rcall") return isContractRCall(argNode, contractNames);
+	return false;
+};
+/**
+* Checks whether an rcall node targets a registered contract.
+*/
+const isContractRCall = (node, contractNames) => {
+	const receiverNode = node.args[1];
+	return isAstNode(receiverNode) && receiverNode.op === "id" && typeof receiverNode.args === "string" && contractNames.has(receiverNode.args);
+};
+/**
+* Extracts the rcall components: method name, receiver node, and argument list.
+*/
+const parseRCallNode = (node) => {
+	const nodeArgs = node.args;
+	const method = nodeArgs[0];
+	const receiver = nodeArgs[1];
+	const callArgs = nodeArgs[2];
+	if (typeof method !== "string" || !Array.isArray(callArgs)) return;
+	return {
+		method,
+		receiver,
+		callArgs
+	};
+};
+/**
+* Tracks scoped variables introduced by comprehension macros or cel.bind().
+*/
+const trackScopedVars = (parsed, scopedVars) => {
+	const { method, receiver, callArgs } = parsed;
+	if (isAstNode(receiver) && receiver.op !== "id" && COMPREHENSION_MACROS.has(method) && callArgs.length >= 1) {
+		const iterVarNode = callArgs[0];
+		if (isAstNode(iterVarNode) && iterVarNode.op === "id" && typeof iterVarNode.args === "string") scopedVars.add(iterVarNode.args);
+	}
+	if (method === "bind" && isAstNode(receiver) && receiver.op === "id" && receiver.args === "cel" && callArgs.length >= 1) {
+		const nameNode = callArgs[0];
+		if (isAstNode(nameNode) && nameNode.op === "id" && typeof nameNode.args === "string") scopedVars.add(nameNode.args);
+	}
+};
+/**
+* Flags contract calls whose arguments cannot be resolved statically,
+* meaning they will execute as live RPC calls at evaluation time instead
+* of being batched via multicall.
+*
+* This includes calls with arguments that depend on:
+* - Comprehension iteration variables (map/filter/exists)
+* - cel.bind() scoped variables
+* - Arithmetic or other expressions on call results
+* - Struct field access on call results
+*/
+const deferredCall = {
+	name: "deferred-call",
+	description: "Flags contract calls with dynamic arguments that cannot be batched via multicall.",
+	defaultSeverity: "info",
+	tier: "structural",
+	run(context) {
+		const contractNames = new Set(context.schema.contracts.map((c) => c.name));
+		if (contractNames.size === 0) return [];
+		const diagnostics = [];
+		const scopedVars = /* @__PURE__ */ new Set();
+		walkAST(context.ast, (node) => {
+			if (node.op !== "rcall") return;
+			const parsed = parseRCallNode(node);
+			if (!parsed) return;
+			const { method, callArgs } = parsed;
+			trackScopedVars(parsed, scopedVars);
+			if (!isContractRCall(node, contractNames)) return;
+			const contractName = node.args[1].args;
+			if (callArgs.some((argNode) => !isResolvableArg(argNode, contractNames, scopedVars))) diagnostics.push(context.report(node, `\`${contractName}.${method}()\` has dynamic arguments and will execute as a live RPC call instead of being batched.`));
+		});
+		return diagnostics;
+	}
+};
+//#endregion
+export { deferredCall };

package/dist/rules/defaults/index.cjs

@@ -0,0 +1,6 @@
+require("./deferred-call.cjs");
+require("./no-constant-condition.cjs");
+require("./no-mixed-operators.cjs");
+require("./no-redundant-bool.cjs");
+require("./no-self-comparison.cjs");
+require("./require-type.cjs");

package/dist/rules/defaults/index.mjs

@@ -0,0 +1,7 @@
+import "./deferred-call.mjs";
+import "./no-constant-condition.mjs";
+import "./no-mixed-operators.mjs";
+import "./no-redundant-bool.mjs";
+import "./no-self-comparison.mjs";
+import "./require-type.mjs";
+export {};

package/dist/rules/defaults/no-constant-condition.cjs

@@ -0,0 +1,31 @@
+const require_ast_utils = require("../../utils/ast-utils.cjs");
+//#region src/rules/defaults/no-constant-condition.ts
+/**
+* Flags conditions that are always true or always false:
+* - `true && x`, `false || x` (boolean literal in logical operator)
+* - Both sides are literal values in a comparison
+*/
+const noConstantCondition = {
+	name: "no-constant-condition",
+	description: "Disallow constant conditions in logical and comparison operators.",
+	defaultSeverity: "warning",
+	tier: "structural",
+	run(context) {
+		const diagnostics = [];
+		require_ast_utils.walkAST(context.ast, (node) => {
+			if (node.op === "&&" || node.op === "||") {
+				const [left, right] = node.args;
+				if (left.op === "value" && typeof left.args === "boolean") diagnostics.push(context.report(node, `Constant condition: left side of \`${node.op}\` is always \`${String(left.args)}\`.`));
+				if (right.op === "value" && typeof right.args === "boolean") diagnostics.push(context.report(node, `Constant condition: right side of \`${node.op}\` is always \`${String(right.args)}\`.`));
+				return;
+			}
+			if (node.op === "==" || node.op === "!=") {
+				const [left, right] = node.args;
+				if (left.op === "value" && right.op === "value") diagnostics.push(context.report(node, `Constant condition: both sides of \`${node.op}\` are literal values.`));
+			}
+		});
+		return diagnostics;
+	}
+};
+//#endregion
+exports.noConstantCondition = noConstantCondition;

package/dist/rules/defaults/no-constant-condition.mjs

@@ -0,0 +1,31 @@
+import { walkAST } from "../../utils/ast-utils.mjs";
+//#region src/rules/defaults/no-constant-condition.ts
+/**
+* Flags conditions that are always true or always false:
+* - `true && x`, `false || x` (boolean literal in logical operator)
+* - Both sides are literal values in a comparison
+*/
+const noConstantCondition = {
+	name: "no-constant-condition",
+	description: "Disallow constant conditions in logical and comparison operators.",
+	defaultSeverity: "warning",
+	tier: "structural",
+	run(context) {
+		const diagnostics = [];
+		walkAST(context.ast, (node) => {
+			if (node.op === "&&" || node.op === "||") {
+				const [left, right] = node.args;
+				if (left.op === "value" && typeof left.args === "boolean") diagnostics.push(context.report(node, `Constant condition: left side of \`${node.op}\` is always \`${String(left.args)}\`.`));
+				if (right.op === "value" && typeof right.args === "boolean") diagnostics.push(context.report(node, `Constant condition: right side of \`${node.op}\` is always \`${String(right.args)}\`.`));
+				return;
+			}
+			if (node.op === "==" || node.op === "!=") {
+				const [left, right] = node.args;
+				if (left.op === "value" && right.op === "value") diagnostics.push(context.report(node, `Constant condition: both sides of \`${node.op}\` are literal values.`));
+			}
+		});
+		return diagnostics;
+	}
+};
+//#endregion
+export { noConstantCondition };

package/dist/rules/defaults/no-mixed-operators.cjs

@@ -0,0 +1,39 @@
+const require_ast_utils = require("../../utils/ast-utils.cjs");
+//#region src/rules/defaults/no-mixed-operators.ts
+/**
+* Check whether a child expression has explicit parentheses in the source.
+* Scans backwards from the child's start position for a `(`.
+*/
+const hasExplicitParens = (src, child) => {
+	let i = require_ast_utils.nodeSpan(child).from - 1;
+	while (i >= 0 && (src[i] === " " || src[i] === "	")) i--;
+	return i >= 0 && src[i] === "(";
+};
+/**
+* Flags mixed `&&` and `||` without explicit parentheses.
+*
+* The cel-js parser discards parentheses from the AST, so this rule
+* inspects the original source text via `node.input` to determine
+* whether parentheses were explicitly written.
+*/
+const noMixedOperators = {
+	name: "no-mixed-operators",
+	description: "Require parentheses when mixing logical operators (&& and ||).",
+	defaultSeverity: "info",
+	tier: "structural",
+	run(context) {
+		const diagnostics = [];
+		require_ast_utils.walkAST(context.ast, (node) => {
+			if (node.op !== "&&" && node.op !== "||") return;
+			const opposite = node.op === "&&" ? "||" : "&&";
+			const [left, right] = node.args;
+			for (const child of [left, right]) if (child.op === opposite && !hasExplicitParens(node.input, child)) {
+				diagnostics.push(context.report(node, "Mixed logical operators without parentheses. Add explicit grouping to clarify precedence."));
+				break;
+			}
+		});
+		return diagnostics;
+	}
+};
+//#endregion
+exports.noMixedOperators = noMixedOperators;