@seljs/checker 1.0.0 → 1.0.1

package/dist/environment/hydrate.cjs

@@ -0,0 +1,163 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_debug = require("../debug.cjs");
+const require_codec_registry = require("./codec-registry.cjs");
+const require_register_types = require("./register-types.cjs");
+const require_value_wrappers = require("./value-wrappers.cjs");
+let _seljs_common = require("@seljs/common");
+let _marcbachmann_cel_js = require("@marcbachmann/cel-js");
+//#region src/environment/hydrate.ts
+const debug = require_debug.createLogger("hydrate");
+const hydrateEnvironment = (env, schema, handler) => {
+	const contractBindings = {};
+	const structRegistry = /* @__PURE__ */ new Map();
+	for (const type of schema.types) if (type.kind === "struct" && type.fields) {
+		const fields = {};
+		for (const field of type.fields) fields[field.name] = field.type;
+		try {
+			if (handler !== void 0) {
+				const StructCtor = class {};
+				env.registerType(type.name, {
+					ctor: StructCtor,
+					fields
+				});
+				structRegistry.set(type.name, {
+					ctor: StructCtor,
+					fieldNames: Object.keys(fields),
+					fieldTypes: fields
+				});
+			} else env.registerType(type.name, { fields });
+		} catch (err) {
+			debug("skipped type %s: %O", type.name, err);
+		}
+	}
+	const codecRegistry = handler !== void 0 ? new require_codec_registry.CelCodecRegistry({ structs: Array.from(structRegistry.entries()).map(([name, info]) => ({
+		name,
+		...info
+	})) }) : void 0;
+	for (const contract of schema.contracts) {
+		const typeName = (0, _seljs_common.contractTypeName)(contract.name);
+		class ContractType {
+			constructor(name) {
+				this.name = name;
+			}
+		}
+		env.registerType(typeName, {
+			ctor: ContractType,
+			fields: {}
+		}).registerVariable(contract.name, typeName);
+		contractBindings[contract.name] = new ContractType(contract.name);
+		for (const method of contract.methods) {
+			const returnType = method.returns || "dyn";
+			const methodHandler = handler !== void 0 ? async (...args) => {
+				const raw = await handler(contract.name, method.name, args.slice(1));
+				if (!codecRegistry) throw new Error("codecRegistry is required when handler is provided");
+				return codecRegistry.resolve(returnType).parse(raw);
+			} : () => void 0;
+			try {
+				env.registerFunction({
+					name: method.name,
+					receiverType: typeName,
+					returnType,
+					handler: methodHandler,
+					params: method.params.map((param) => ({
+						name: param.name,
+						type: param.type
+					}))
+				}, void 0);
+			} catch (err) {
+				debug("skipped method %s.%s: %O", contract.name, method.name, err);
+			}
+			if (method.params.some((p) => require_value_wrappers.toCelLiteralType(p.type) !== null)) try {
+				env.registerFunction({
+					name: method.name,
+					receiverType: typeName,
+					returnType,
+					handler: methodHandler,
+					params: method.params.map((param) => ({
+						name: param.name,
+						type: require_value_wrappers.toCelLiteralType(param.type) ?? param.type
+					}))
+				}, void 0);
+			} catch (err) {
+				debug("skipped literal overload %s.%s: %O", contract.name, method.name, err);
+			}
+		}
+	}
+	for (const variable of schema.variables) try {
+		env.registerVariable(variable.name, variable.type);
+	} catch (err) {
+		debug("variable %s: fallback to dyn: %O", variable.name, err);
+		env.registerVariable(variable.name, "dyn");
+	}
+	for (const fn of schema.functions) {
+		if (!fn.receiverType) continue;
+		try {
+			env.registerFunction({
+				name: fn.name,
+				receiverType: fn.receiverType,
+				returnType: fn.returns,
+				handler: () => void 0,
+				params: fn.params.map((param) => ({
+					name: param.name,
+					type: param.type
+				}))
+			}, void 0);
+		} catch (err) {
+			if (!(err instanceof Error) || !err.message.includes("overlaps with existing overload")) throw err;
+			debug("skipped overlapping overload: %O", err);
+		}
+	}
+	return {
+		contractBindings,
+		codecRegistry
+	};
+};
+/**
+* Create a base CEL environment with Solidity types registered.
+* No contracts, no variables — just the type system.
+*
+* Use this when you need to register contracts and variables yourself
+* (e.g., runtime evaluation with real async handlers).
+*/
+const createBaseEnvironment = (options) => {
+	const env = new _marcbachmann_cel_js.Environment({
+		unlistedVariablesAreDyn: false,
+		...options?.limits ? { limits: options.limits } : {}
+	});
+	require_register_types.registerSolidityTypes(env);
+	return env;
+};
+/**
+* Create a fully hydrated checker environment from a SELSchema.
+*
+* Registers Solidity primitive types, contract types with their methods
+* (using no-op handlers since the checker only needs type information),
+* schema variables, and built-in functions.
+*/
+const createCheckerEnvironment = (schema) => {
+	const env = createBaseEnvironment();
+	hydrateEnvironment(env, schema);
+	return env;
+};
+/**
+* Create a fully hydrated runtime environment from a SELSchema with a
+* real async handler for contract method calls.
+*/
+const createRuntimeEnvironment = (schema, handler, options) => {
+	const env = new _marcbachmann_cel_js.Environment({
+		unlistedVariablesAreDyn: options?.unlistedVariablesAreDyn ?? false,
+		...options?.limits ? { limits: options.limits } : {}
+	});
+	require_register_types.registerSolidityTypes(env);
+	const result = hydrateEnvironment(env, schema, handler);
+	if (!result.codecRegistry) throw new Error("codecRegistry is required when handler is provided");
+	return {
+		env,
+		contractBindings: result.contractBindings,
+		codecRegistry: result.codecRegistry
+	};
+};
+//#endregion
+exports.createBaseEnvironment = createBaseEnvironment;
+exports.createCheckerEnvironment = createCheckerEnvironment;
+exports.createRuntimeEnvironment = createRuntimeEnvironment;

package/dist/environment/hydrate.d.cts

@@ -0,0 +1,52 @@
+import { CelCodecRegistry } from "./codec-registry.cjs";
+import { Environment } from "@marcbachmann/cel-js";
+import { SELSchema } from "@seljs/schema";
+
+//#region src/environment/hydrate.d.ts
+/**
+ * CEL environment limits configuration.
+ */
+interface CelLimits {
+  maxAstNodes?: number;
+  maxDepth?: number;
+  maxListElements?: number;
+  maxMapEntries?: number;
+  maxCallArguments?: number;
+}
+/**
+ * Handler called when a contract method is invoked at runtime.
+ */
+type ContractCallHandler = (contractName: string, methodName: string, args: unknown[]) => unknown;
+/**
+ * Create a base CEL environment with Solidity types registered.
+ * No contracts, no variables — just the type system.
+ *
+ * Use this when you need to register contracts and variables yourself
+ * (e.g., runtime evaluation with real async handlers).
+ */
+declare const createBaseEnvironment: (options?: {
+  limits?: CelLimits;
+}) => Environment;
+/**
+ * Create a fully hydrated checker environment from a SELSchema.
+ *
+ * Registers Solidity primitive types, contract types with their methods
+ * (using no-op handlers since the checker only needs type information),
+ * schema variables, and built-in functions.
+ */
+declare const createCheckerEnvironment: (schema: SELSchema) => Environment;
+interface RuntimeEnvironmentResult {
+  env: Environment;
+  contractBindings: Record<string, unknown>;
+  codecRegistry: CelCodecRegistry;
+}
+/**
+ * Create a fully hydrated runtime environment from a SELSchema with a
+ * real async handler for contract method calls.
+ */
+declare const createRuntimeEnvironment: (schema: SELSchema, handler: ContractCallHandler, options?: {
+  limits?: CelLimits;
+  unlistedVariablesAreDyn?: boolean;
+}) => RuntimeEnvironmentResult;
+//#endregion
+export { CelLimits, ContractCallHandler, RuntimeEnvironmentResult, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment };

package/dist/environment/hydrate.d.mts

@@ -0,0 +1,52 @@
+import { CelCodecRegistry } from "./codec-registry.mjs";
+import { Environment } from "@marcbachmann/cel-js";
+import { SELSchema } from "@seljs/schema";
+
+//#region src/environment/hydrate.d.ts
+/**
+ * CEL environment limits configuration.
+ */
+interface CelLimits {
+  maxAstNodes?: number;
+  maxDepth?: number;
+  maxListElements?: number;
+  maxMapEntries?: number;
+  maxCallArguments?: number;
+}
+/**
+ * Handler called when a contract method is invoked at runtime.
+ */
+type ContractCallHandler = (contractName: string, methodName: string, args: unknown[]) => unknown;
+/**
+ * Create a base CEL environment with Solidity types registered.
+ * No contracts, no variables — just the type system.
+ *
+ * Use this when you need to register contracts and variables yourself
+ * (e.g., runtime evaluation with real async handlers).
+ */
+declare const createBaseEnvironment: (options?: {
+  limits?: CelLimits;
+}) => Environment;
+/**
+ * Create a fully hydrated checker environment from a SELSchema.
+ *
+ * Registers Solidity primitive types, contract types with their methods
+ * (using no-op handlers since the checker only needs type information),
+ * schema variables, and built-in functions.
+ */
+declare const createCheckerEnvironment: (schema: SELSchema) => Environment;
+interface RuntimeEnvironmentResult {
+  env: Environment;
+  contractBindings: Record<string, unknown>;
+  codecRegistry: CelCodecRegistry;
+}
+/**
+ * Create a fully hydrated runtime environment from a SELSchema with a
+ * real async handler for contract method calls.
+ */
+declare const createRuntimeEnvironment: (schema: SELSchema, handler: ContractCallHandler, options?: {
+  limits?: CelLimits;
+  unlistedVariablesAreDyn?: boolean;
+}) => RuntimeEnvironmentResult;
+//#endregion
+export { CelLimits, ContractCallHandler, RuntimeEnvironmentResult, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment };

package/dist/environment/hydrate.mjs

@@ -0,0 +1,160 @@
+import { createLogger } from "../debug.mjs";
+import { CelCodecRegistry } from "./codec-registry.mjs";
+import { registerSolidityTypes } from "./register-types.mjs";
+import { toCelLiteralType } from "./value-wrappers.mjs";
+import { contractTypeName } from "@seljs/common";
+import { Environment } from "@marcbachmann/cel-js";
+//#region src/environment/hydrate.ts
+const debug = createLogger("hydrate");
+const hydrateEnvironment = (env, schema, handler) => {
+	const contractBindings = {};
+	const structRegistry = /* @__PURE__ */ new Map();
+	for (const type of schema.types) if (type.kind === "struct" && type.fields) {
+		const fields = {};
+		for (const field of type.fields) fields[field.name] = field.type;
+		try {
+			if (handler !== void 0) {
+				const StructCtor = class {};
+				env.registerType(type.name, {
+					ctor: StructCtor,
+					fields
+				});
+				structRegistry.set(type.name, {
+					ctor: StructCtor,
+					fieldNames: Object.keys(fields),
+					fieldTypes: fields
+				});
+			} else env.registerType(type.name, { fields });
+		} catch (err) {
+			debug("skipped type %s: %O", type.name, err);
+		}
+	}
+	const codecRegistry = handler !== void 0 ? new CelCodecRegistry({ structs: Array.from(structRegistry.entries()).map(([name, info]) => ({
+		name,
+		...info
+	})) }) : void 0;
+	for (const contract of schema.contracts) {
+		const typeName = contractTypeName(contract.name);
+		class ContractType {
+			constructor(name) {
+				this.name = name;
+			}
+		}
+		env.registerType(typeName, {
+			ctor: ContractType,
+			fields: {}
+		}).registerVariable(contract.name, typeName);
+		contractBindings[contract.name] = new ContractType(contract.name);
+		for (const method of contract.methods) {
+			const returnType = method.returns || "dyn";
+			const methodHandler = handler !== void 0 ? async (...args) => {
+				const raw = await handler(contract.name, method.name, args.slice(1));
+				if (!codecRegistry) throw new Error("codecRegistry is required when handler is provided");
+				return codecRegistry.resolve(returnType).parse(raw);
+			} : () => void 0;
+			try {
+				env.registerFunction({
+					name: method.name,
+					receiverType: typeName,
+					returnType,
+					handler: methodHandler,
+					params: method.params.map((param) => ({
+						name: param.name,
+						type: param.type
+					}))
+				}, void 0);
+			} catch (err) {
+				debug("skipped method %s.%s: %O", contract.name, method.name, err);
+			}
+			if (method.params.some((p) => toCelLiteralType(p.type) !== null)) try {
+				env.registerFunction({
+					name: method.name,
+					receiverType: typeName,
+					returnType,
+					handler: methodHandler,
+					params: method.params.map((param) => ({
+						name: param.name,
+						type: toCelLiteralType(param.type) ?? param.type
+					}))
+				}, void 0);
+			} catch (err) {
+				debug("skipped literal overload %s.%s: %O", contract.name, method.name, err);
+			}
+		}
+	}
+	for (const variable of schema.variables) try {
+		env.registerVariable(variable.name, variable.type);
+	} catch (err) {
+		debug("variable %s: fallback to dyn: %O", variable.name, err);
+		env.registerVariable(variable.name, "dyn");
+	}
+	for (const fn of schema.functions) {
+		if (!fn.receiverType) continue;
+		try {
+			env.registerFunction({
+				name: fn.name,
+				receiverType: fn.receiverType,
+				returnType: fn.returns,
+				handler: () => void 0,
+				params: fn.params.map((param) => ({
+					name: param.name,
+					type: param.type
+				}))
+			}, void 0);
+		} catch (err) {
+			if (!(err instanceof Error) || !err.message.includes("overlaps with existing overload")) throw err;
+			debug("skipped overlapping overload: %O", err);
+		}
+	}
+	return {
+		contractBindings,
+		codecRegistry
+	};
+};
+/**
+* Create a base CEL environment with Solidity types registered.
+* No contracts, no variables — just the type system.
+*
+* Use this when you need to register contracts and variables yourself
+* (e.g., runtime evaluation with real async handlers).
+*/
+const createBaseEnvironment = (options) => {
+	const env = new Environment({
+		unlistedVariablesAreDyn: false,
+		...options?.limits ? { limits: options.limits } : {}
+	});
+	registerSolidityTypes(env);
+	return env;
+};
+/**
+* Create a fully hydrated checker environment from a SELSchema.
+*
+* Registers Solidity primitive types, contract types with their methods
+* (using no-op handlers since the checker only needs type information),
+* schema variables, and built-in functions.
+*/
+const createCheckerEnvironment = (schema) => {
+	const env = createBaseEnvironment();
+	hydrateEnvironment(env, schema);
+	return env;
+};
+/**
+* Create a fully hydrated runtime environment from a SELSchema with a
+* real async handler for contract method calls.
+*/
+const createRuntimeEnvironment = (schema, handler, options) => {
+	const env = new Environment({
+		unlistedVariablesAreDyn: options?.unlistedVariablesAreDyn ?? false,
+		...options?.limits ? { limits: options.limits } : {}
+	});
+	registerSolidityTypes(env);
+	const result = hydrateEnvironment(env, schema, handler);
+	if (!result.codecRegistry) throw new Error("codecRegistry is required when handler is provided");
+	return {
+		env,
+		contractBindings: result.contractBindings,
+		codecRegistry: result.codecRegistry
+	};
+};
+//#endregion
+export { createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment };

package/dist/environment/index.cjs

@@ -0,0 +1,4 @@
+require("./codec-registry.cjs");
+require("./register-types.cjs");
+require("./value-wrappers.cjs");
+require("./hydrate.cjs");

package/dist/environment/index.d.mts

@@ -0,0 +1,4 @@
+import { CelCodecRegistry, CelCodecRegistryOptions, StructCodecDescriptor } from "./codec-registry.mjs";
+import { CelLimits, ContractCallHandler, RuntimeEnvironmentResult, createBaseEnvironment, createCheckerEnvironment, createRuntimeEnvironment } from "./hydrate.mjs";
+import { registerSolidityTypes } from "./register-types.mjs";
+import { StructInfo, toCelLiteralType, wrapStructValue, wrapValueForSel } from "./value-wrappers.mjs";

package/dist/environment/index.mjs

@@ -0,0 +1,5 @@
+import "./codec-registry.mjs";
+import "./register-types.mjs";
+import "./value-wrappers.mjs";
+import "./hydrate.mjs";
+export {};

package/dist/environment/register-types.cjs

@@ -0,0 +1,107 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let _seljs_types = require("@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) => (0, _seljs_types.toAddress)(left) === (0, _seljs_types.toAddress)(right));
+	env.registerOperator("sol_address < sol_address", (left, right) => (0, _seljs_types.toAddress)(left) < (0, _seljs_types.toAddress)(right));
+	env.registerOperator("sol_address <= sol_address", (left, right) => (0, _seljs_types.toAddress)(left) <= (0, _seljs_types.toAddress)(right));
+	env.registerOperator("sol_address > sol_address", (left, right) => (0, _seljs_types.toAddress)(left) > (0, _seljs_types.toAddress)(right));
+	env.registerOperator("sol_address >= sol_address", (left, right) => (0, _seljs_types.toAddress)(left) >= (0, _seljs_types.toAddress)(right));
+};
+const toSolInt = (value) => new _seljs_types.SolidityIntTypeWrapper(value);
+const registerIntegerOperators = (env) => {
+	env.registerOperator("sol_int + sol_int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) + (0, _seljs_types.toBigInt)(b)));
+	env.registerOperator("sol_int - sol_int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) - (0, _seljs_types.toBigInt)(b)));
+	env.registerOperator("sol_int * sol_int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) * (0, _seljs_types.toBigInt)(b)));
+	env.registerOperator("sol_int / sol_int", (a, b) => {
+		const divisor = (0, _seljs_types.toBigInt)(b);
+		if (divisor === 0n) throw new Error("division by zero");
+		return toSolInt((0, _seljs_types.toBigInt)(a) / divisor);
+	});
+	env.registerOperator("sol_int % sol_int", (a, b) => {
+		const divisor = (0, _seljs_types.toBigInt)(b);
+		if (divisor === 0n) throw new Error("modulo by zero");
+		return toSolInt((0, _seljs_types.toBigInt)(a) % divisor);
+	});
+	env.registerOperator("-sol_int", (a) => toSolInt(-(0, _seljs_types.toBigInt)(a)));
+	env.registerOperator("sol_int == sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) === (0, _seljs_types.toBigInt)(b));
+	env.registerOperator("sol_int < sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) < (0, _seljs_types.toBigInt)(b));
+	env.registerOperator("sol_int <= sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) <= (0, _seljs_types.toBigInt)(b));
+	env.registerOperator("sol_int > sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) > (0, _seljs_types.toBigInt)(b));
+	env.registerOperator("sol_int >= sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) >= (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "sol_int + int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) + (0, _seljs_types.toBigInt)(b)));
+	tryRegisterOperator(env, "sol_int - int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) - (0, _seljs_types.toBigInt)(b)));
+	tryRegisterOperator(env, "sol_int * int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) * (0, _seljs_types.toBigInt)(b)));
+	tryRegisterOperator(env, "sol_int / int", (a, b) => {
+		const divisor = (0, _seljs_types.toBigInt)(b);
+		if (divisor === 0n) throw new Error("division by zero");
+		return toSolInt((0, _seljs_types.toBigInt)(a) / divisor);
+	});
+	tryRegisterOperator(env, "sol_int % int", (a, b) => {
+		const divisor = (0, _seljs_types.toBigInt)(b);
+		if (divisor === 0n) throw new Error("modulo by zero");
+		return toSolInt((0, _seljs_types.toBigInt)(a) % divisor);
+	});
+	tryRegisterOperator(env, "sol_int == int", (a, b) => (0, _seljs_types.toBigInt)(a) === (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "int == sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) === (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "sol_int < int", (a, b) => (0, _seljs_types.toBigInt)(a) < (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "int < sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) < (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "sol_int <= int", (a, b) => (0, _seljs_types.toBigInt)(a) <= (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "int <= sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) <= (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "sol_int > int", (a, b) => (0, _seljs_types.toBigInt)(a) > (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "int > sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) > (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "sol_int >= int", (a, b) => (0, _seljs_types.toBigInt)(a) >= (0, _seljs_types.toBigInt)(b));
+	tryRegisterOperator(env, "int >= sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) >= (0, _seljs_types.toBigInt)(b));
+};
+/**
+* Register all Solidity primitive types on a CEL Environment.
+*/
+const registerSolidityTypes = (env) => {
+	for (const entry of _seljs_types.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) => (0, _seljs_types.parseUnitsValue)(value, Number((0, _seljs_types.toBigInt)(decimals))));
+	env.registerFunction("parseUnits(int, int): sol_int", (value, decimals) => (0, _seljs_types.parseUnitsValue)(value, Number((0, _seljs_types.toBigInt)(decimals))));
+	env.registerFunction("parseUnits(double, int): sol_int", (value, decimals) => (0, _seljs_types.parseUnitsValue)(value, Number((0, _seljs_types.toBigInt)(decimals))));
+	env.registerFunction("parseUnits(sol_int, int): sol_int", (value, decimals) => (0, _seljs_types.parseUnitsValue)(value, Number((0, _seljs_types.toBigInt)(decimals))));
+	env.registerFunction("formatUnits(sol_int, int): double", (value, decimals) => (0, _seljs_types.formatUnitsValue)(value, Number((0, _seljs_types.toBigInt)(decimals))));
+	env.registerFunction("formatUnits(int, int): double", (value, decimals) => (0, _seljs_types.formatUnitsValue)(value, Number((0, _seljs_types.toBigInt)(decimals))));
+	env.registerFunction("min(sol_int, sol_int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) <= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("min(sol_int, int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) <= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("min(int, sol_int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) <= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("min(int, int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) <= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(sol_int, sol_int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) >= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(sol_int, int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) >= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(int, sol_int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) >= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("max(int, int): sol_int", (a, b) => (0, _seljs_types.toBigInt)(a) >= (0, _seljs_types.toBigInt)(b) ? toSolInt(a) : toSolInt(b));
+	env.registerFunction("abs(sol_int): sol_int", (a) => {
+		const v = (0, _seljs_types.toBigInt)(a);
+		return toSolInt(v < 0n ? -v : v);
+	});
+	env.registerFunction("abs(int): sol_int", (a) => {
+		const v = (0, _seljs_types.toBigInt)(a);
+		return toSolInt(v < 0n ? -v : v);
+	});
+	const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+	env.registerFunction("isZeroAddress(sol_address): bool", (addr) => (0, _seljs_types.toAddress)(addr) === ZERO_ADDRESS);
+	env.registerFunction("isZeroAddress(string): bool", (addr) => (0, _seljs_types.toAddress)(addr) === ZERO_ADDRESS);
+};
+//#endregion
+exports.registerSolidityTypes = registerSolidityTypes;

package/dist/environment/register-types.d.cts

@@ -0,0 +1,15 @@
+import { Environment } from "@marcbachmann/cel-js";
+
+//#region src/environment/register-types.d.ts
+/**
+ * Subset of the CEL Environment API needed for Solidity type registration.
+ * Mirrors the parameter signatures from Environment but drops the return type
+ * to void — registerSolidityTypes never chains the return value.
+ */
+type SolidityTypeHost = { [K in "registerType" | "registerOperator" | "registerFunction"]: (...args: Parameters<Environment[K]>) => void };
+/**
+ * Register all Solidity primitive types on a CEL Environment.
+ */
+declare const registerSolidityTypes: (env: SolidityTypeHost) => void;
+//#endregion
+export { registerSolidityTypes };

package/dist/environment/register-types.d.mts

@@ -0,0 +1,15 @@
+import { Environment } from "@marcbachmann/cel-js";
+
+//#region src/environment/register-types.d.ts
+/**
+ * Subset of the CEL Environment API needed for Solidity type registration.
+ * Mirrors the parameter signatures from Environment but drops the return type
+ * to void — registerSolidityTypes never chains the return value.
+ */
+type SolidityTypeHost = { [K in "registerType" | "registerOperator" | "registerFunction"]: (...args: Parameters<Environment[K]>) => void };
+/**
+ * Register all Solidity primitive types on a CEL Environment.
+ */
+declare const registerSolidityTypes: (env: SolidityTypeHost) => void;
+//#endregion
+export { registerSolidityTypes };