@seljs/checker 1.3.0-beta.2 → 1.3.0-beta.21

package/dist/environment/codec-registry.cjs

@@ -25,12 +25,7 @@ var CelCodecRegistry = class {
 		this.codecs.set("bool", zod.z.boolean());
 		this.codecs.set("string", zod.z.string());
 		this.codecs.set("int", zod.z.bigint());
-		this.codecs.set("bytes", zod.z.union([zod.z.instanceof(Uint8Array), zod.z.string().transform((s) => {
-			const hex = s.startsWith("0x") ? s.slice(2) : s;
-			const bytes = new Uint8Array(hex.length / 2);
-			for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-			return bytes;
-		})]));
+		this.codecs.set("bytes", zod.z.union([zod.z.instanceof(Uint8Array), zod.z.string().transform((s) => (0, _seljs_types.hexToBytes)(s))]));
 		this.codecs.set("dyn", zod.z.unknown().transform((v) => typeof v === "bigint" ? new _seljs_types.SolidityIntTypeWrapper(v) : v));
 		for (const desc of options?.structs ?? []) {
 			this.codecs.set(desc.name, this.buildStructCodec(desc));

package/dist/environment/codec-registry.mjs

@@ -1,4 +1,4 @@
-import { SolidityAddressTypeWrapper, SolidityIntTypeWrapper } from "@seljs/types";
+import { SolidityAddressTypeWrapper, SolidityIntTypeWrapper, hexToBytes } from "@seljs/types";
 import { z } from "zod";
 //#region src/environment/codec-registry.ts
 const solidityAddressCodec = z.codec(z.string(), z.instanceof(SolidityAddressTypeWrapper), {
@@ -24,12 +24,7 @@ var CelCodecRegistry = class {
 		this.codecs.set("bool", z.boolean());
 		this.codecs.set("string", z.string());
 		this.codecs.set("int", z.bigint());
-		this.codecs.set("bytes", z.union([z.instanceof(Uint8Array), z.string().transform((s) => {
-			const hex = s.startsWith("0x") ? s.slice(2) : s;
-			const bytes = new Uint8Array(hex.length / 2);
-			for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-			return bytes;
-		})]));
+		this.codecs.set("bytes", z.union([z.instanceof(Uint8Array), z.string().transform((s) => hexToBytes(s))]));
 		this.codecs.set("dyn", z.unknown().transform((v) => typeof v === "bigint" ? new SolidityIntTypeWrapper(v) : v));
 		for (const desc of options?.structs ?? []) {
 			this.codecs.set(desc.name, this.buildStructCodec(desc));

package/dist/environment/hydrate.cjs

@@ -91,12 +91,17 @@ const hydrateEnvironment = (env, schema, handler) => {
 	}
 	for (const fn of schema.functions) {
 		if (!fn.receiverType) continue;
+		const fnHandler = handler !== void 0 ? async (...args) => {
+			const raw = await handler(fn.receiverType, fn.name, args);
+			if (!codecRegistry) throw new Error("codecRegistry is required when handler is provided");
+			return codecRegistry.resolve(fn.returns).parse(raw);
+		} : () => void 0;
 		try {
 			env.registerFunction({
 				name: fn.name,
 				receiverType: fn.receiverType,
 				returnType: fn.returns,
-				handler: () => void 0,
+				handler: fnHandler,
 				params: fn.params.map((param) => ({
 					name: param.name,
 					type: param.type

package/dist/environment/hydrate.mjs

@@ -90,12 +90,17 @@ const hydrateEnvironment = (env, schema, handler) => {
 	}
 	for (const fn of schema.functions) {
 		if (!fn.receiverType) continue;
+		const fnHandler = handler !== void 0 ? async (...args) => {
+			const raw = await handler(fn.receiverType, fn.name, args);
+			if (!codecRegistry) throw new Error("codecRegistry is required when handler is provided");
+			return codecRegistry.resolve(fn.returns).parse(raw);
+		} : () => void 0;
 		try {
 			env.registerFunction({
 				name: fn.name,
 				receiverType: fn.receiverType,
 				returnType: fn.returns,
-				handler: () => void 0,
+				handler: fnHandler,
 				params: fn.params.map((param) => ({
 					name: param.name,
 					type: param.type

package/dist/environment/register-types.cjs

@@ -1,5 +1,6 @@
 require("../_virtual/_rolldown/runtime.cjs");
 let _seljs_types = require("@seljs/types");
+let viem = require("viem");
 //#region src/environment/register-types.ts
 /**
 * Try to register an operator, silently ignoring "already registered" errors.
@@ -54,6 +55,19 @@ const registerIntegerOperators = (env) => {
 		if (divisor === 0n) throw new Error("modulo by zero");
 		return toSolInt((0, _seljs_types.toBigInt)(a) % divisor);
 	});
+	tryRegisterOperator(env, "int + sol_int: sol_int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) + (0, _seljs_types.toBigInt)(b)));
+	tryRegisterOperator(env, "int - sol_int: sol_int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) - (0, _seljs_types.toBigInt)(b)));
+	tryRegisterOperator(env, "int * sol_int: sol_int", (a, b) => toSolInt((0, _seljs_types.toBigInt)(a) * (0, _seljs_types.toBigInt)(b)));
+	tryRegisterOperator(env, "int / 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);
+	});
+	tryRegisterOperator(env, "int % 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);
+	});
 	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));
@@ -78,11 +92,17 @@ const registerSolidityTypes = (env) => {
 		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(string, sol_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(int, sol_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(double, sol_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("parseUnits(sol_int, sol_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(sol_int, sol_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("formatUnits(int, sol_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));
@@ -102,6 +122,29 @@ const registerSolidityTypes = (env) => {
 	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);
+	env.registerFunction("hexBytes(string): bytes", (hex) => (0, _seljs_types.hexToBytes)(hex));
+	env.registerFunction("hexBytes(string, int): bytes", (hex, length) => {
+		const out = (0, _seljs_types.hexToBytes)(hex);
+		const expected = Number((0, _seljs_types.toBigInt)(length));
+		if (out.length !== expected) throw new Error(`hexBytes: expected ${String(expected)} bytes, got ${String(out.length)}`);
+		return out;
+	});
+	env.registerFunction("keccak256(string): bytes", (value) => (0, _seljs_types.hexToBytes)((0, viem.keccak256)((0, viem.toBytes)(value))));
+	env.registerFunction("keccak256(bytes): bytes", (value) => (0, _seljs_types.hexToBytes)((0, viem.keccak256)(value)));
+	class SelNamespace {}
+	const selFields = {};
+	const selValues = {};
+	for (const constant of _seljs_types.EVM_CONSTANTS) {
+		selFields[constant.name] = constant.type;
+		if (constant.type === "sol_int") selValues[constant.name] = new _seljs_types.SolidityIntTypeWrapper(constant.value);
+		else if (constant.type === "sol_address") selValues[constant.name] = new _seljs_types.SolidityAddressTypeWrapper(constant.value);
+		else selValues[constant.name] = constant.value;
+	}
+	env.registerType("SelNamespace", {
+		ctor: SelNamespace,
+		fields: selFields
+	});
+	env.registerConstant("sel", "SelNamespace", Object.assign(new SelNamespace(), selValues));
 };
 //#endregion
 exports.registerSolidityTypes = registerSolidityTypes;

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

@@ -6,7 +6,7 @@ import { Environment } from "@marcbachmann/cel-js";
  * 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 };
+type SolidityTypeHost = { [K in "registerType" | "registerOperator" | "registerFunction" | "registerConstant"]: (...args: Parameters<Environment[K]>) => void };
 /**
  * Register all Solidity primitive types on a CEL Environment.
  */

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

@@ -6,7 +6,7 @@ import { Environment } from "@marcbachmann/cel-js";
  * 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 };
+type SolidityTypeHost = { [K in "registerType" | "registerOperator" | "registerFunction" | "registerConstant"]: (...args: Parameters<Environment[K]>) => void };
 /**
  * Register all Solidity primitive types on a CEL Environment.
  */

package/dist/environment/register-types.mjs

@@ -1,4 +1,5 @@
-import { SOLIDITY_TYPES, SolidityIntTypeWrapper, formatUnitsValue, parseUnitsValue, toAddress, toBigInt } from "@seljs/types";
+import { EVM_CONSTANTS, SOLIDITY_TYPES, SolidityAddressTypeWrapper, SolidityIntTypeWrapper, formatUnitsValue, hexToBytes, parseUnitsValue, toAddress, toBigInt } from "@seljs/types";
+import { keccak256, toBytes } from "viem";
 //#region src/environment/register-types.ts
 /**
 * Try to register an operator, silently ignoring "already registered" errors.
@@ -53,6 +54,19 @@ const registerIntegerOperators = (env) => {
 		if (divisor === 0n) throw new Error("modulo by zero");
 		return toSolInt(toBigInt(a) % divisor);
 	});
+	tryRegisterOperator(env, "int + sol_int: sol_int", (a, b) => toSolInt(toBigInt(a) + toBigInt(b)));
+	tryRegisterOperator(env, "int - sol_int: sol_int", (a, b) => toSolInt(toBigInt(a) - toBigInt(b)));
+	tryRegisterOperator(env, "int * sol_int: sol_int", (a, b) => toSolInt(toBigInt(a) * toBigInt(b)));
+	tryRegisterOperator(env, "int / sol_int: sol_int", (a, b) => {
+		const divisor = toBigInt(b);
+		if (divisor === 0n) throw new Error("division by zero");
+		return toSolInt(toBigInt(a) / divisor);
+	});
+	tryRegisterOperator(env, "int % sol_int: sol_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));
@@ -77,11 +91,17 @@ const registerSolidityTypes = (env) => {
 		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(string, sol_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(int, sol_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(double, sol_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("parseUnits(sol_int, sol_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(sol_int, sol_int): double", (value, decimals) => formatUnitsValue(value, Number(toBigInt(decimals))));
 	env.registerFunction("formatUnits(int, int): double", (value, decimals) => formatUnitsValue(value, Number(toBigInt(decimals))));
+	env.registerFunction("formatUnits(int, sol_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));
@@ -101,6 +121,29 @@ const registerSolidityTypes = (env) => {
 	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);
+	env.registerFunction("hexBytes(string): bytes", (hex) => hexToBytes(hex));
+	env.registerFunction("hexBytes(string, int): bytes", (hex, length) => {
+		const out = hexToBytes(hex);
+		const expected = Number(toBigInt(length));
+		if (out.length !== expected) throw new Error(`hexBytes: expected ${String(expected)} bytes, got ${String(out.length)}`);
+		return out;
+	});
+	env.registerFunction("keccak256(string): bytes", (value) => hexToBytes(keccak256(toBytes(value))));
+	env.registerFunction("keccak256(bytes): bytes", (value) => hexToBytes(keccak256(value)));
+	class SelNamespace {}
+	const selFields = {};
+	const selValues = {};
+	for (const constant of EVM_CONSTANTS) {
+		selFields[constant.name] = constant.type;
+		if (constant.type === "sol_int") selValues[constant.name] = new SolidityIntTypeWrapper(constant.value);
+		else if (constant.type === "sol_address") selValues[constant.name] = new SolidityAddressTypeWrapper(constant.value);
+		else selValues[constant.name] = constant.value;
+	}
+	env.registerType("SelNamespace", {
+		ctor: SelNamespace,
+		fields: selFields
+	});
+	env.registerConstant("sel", "SelNamespace", Object.assign(new SelNamespace(), selValues));
 };
 //#endregion
 export { registerSolidityTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seljs/checker",
-  "version": "1.3.0-beta.2",
+  "version": "1.3.0-beta.21",
   "repository": {
     "url": "https://github.com/abinnovision/seljs"
   },
@@ -50,13 +50,14 @@
   },
   "dependencies": {
     "@marcbachmann/cel-js": "^7.5.3",
-    "@seljs/common": "1.3.0-beta.2",
+    "@seljs/common": "1.3.0-beta.21",
     "@seljs/schema": "1.2.0",
-    "@seljs/types": "1.3.0-beta.2",
-    "debug": "^4.4.3"
+    "@seljs/types": "1.3.0-beta.21",
+    "debug": "^4.4.3",
+    "viem": "^2.47.6"
   },
   "devDependencies": {
-    "@abinnovision/eslint-config-base": "^3.2.0",
+    "@abinnovision/eslint-config-base": "^3.2.2",
     "@abinnovision/prettier-config": "^2.1.5",
     "@seljs-internal/tsconfig": "^0.0.0",
     "@types/debug": "^4.1.13",