@seljs/checker 1.0.0 → 1.0.1

package/dist/environment/register-types.js

@@ -1,154 +0,0 @@
-import { SolidityIntTypeWrapper, SOLIDITY_TYPES, toBigInt, toAddress, parseUnitsValue, formatUnitsValue, } from "@seljs/types";
-/**
- * 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) => {
-    // --- sol_int <op> sol_int arithmetic ---
-    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);
-    });
-    // Unary negation
-    env.registerOperator("-sol_int", (a) => toSolInt(-toBigInt(a)));
-    // --- sol_int <op> sol_int comparison ---
-    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));
-    /*
-     * --- sol_int <op> int cross-type arithmetic ---
-     *
-     * cel-js infers the result type of a binary operator from the LEFT operand.
-     * For "sol_int <op> int", the result type is "sol_int" — matching the
-     * SolidityIntTypeWrapper returned by toSolInt(). These are safe.
-     *
-     * We intentionally do NOT register "int <op> sol_int" arithmetic operators.
-     * cel-js would infer the result as "int", but the handler would return a
-     * SolidityIntTypeWrapper. The codec for "int" cannot unwrap that wrapper,
-     * causing the raw wrapper to leak into the evaluation result.
-     *
-     * Cross-type comparison operators (below) are fine — they return plain
-     * booleans regardless of operand order.
-     */
-    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);
-    });
-    // --- sol_int <op> int cross-type comparison ---
-    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.
- */
-export const registerSolidityTypes = (env) => {
-    for (const entry of SOLIDITY_TYPES) {
-        /*
-         * Builtin types are handled natively by CEL and don't need registration.
-         * They are in the registry for completeness/documentation but have no wrapper class or operators.
-         */
-        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);
-        }
-        // Register all the cast signatures for this type.
-        const Ctor = entry.wrapperClass;
-        for (const sig of entry.castSignatures) {
-            env.registerFunction(sig, (value) => new Ctor(value));
-        }
-    }
-    // --- Standalone helper functions ---
-    // parseUnits: scale human-readable values to sol_int
-    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))));
-    // formatUnits: scale sol_int down to human-readable double
-    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))));
-    // min: return the smaller of two values
-    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));
-    // max: return the larger of two values
-    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));
-    // abs: return the absolute value
-    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);
-    });
-    // isZeroAddress: check if an address is the zero address
-    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);
-};

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

@@ -1,17 +0,0 @@
-export 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.
- */
-export declare const toCelLiteralType: (celType: string) => string | null;
-/**
- * Wraps a raw value into the corresponding SEL wrapper type.
- */
-export declare const wrapValueForSel: (celType: string, value: unknown) => unknown;
-/**
- * Recursively wraps a raw struct value with the correct ctor and wrapped field values.
- */
-export declare const wrapStructValue: (registry: Map<string, StructInfo>, info: StructInfo, value: unknown) => unknown;

package/dist/environment/value-wrappers.js

@@ -1,65 +0,0 @@
-import { SolidityAddressTypeWrapper, SolidityIntTypeWrapper, } from "@seljs/types";
-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.
- */
-export 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.
- */
-export 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.
- */
-export 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,
-        ]));
-    }
-    // eslint-disable-next-line new-cap
-    return Object.assign(new ctor(), data);
-};

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./checker/index.js";
-export * from "./constants.js";
-export * from "./environment/index.js";
-export * from "./rules/index.js";

package/dist/index.js

@@ -1,4 +0,0 @@
-export * from "./checker/index.js";
-export * from "./constants.js";
-export * from "./environment/index.js";
-export * from "./rules/index.js";

package/dist/rules/defaults/deferred-call.d.ts

@@ -1,13 +0,0 @@
-import type { SELRule } from "../types.js";
-/**
- * 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
- */
-export declare const deferredCall: SELRule;

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

@@ -1,162 +0,0 @@
-import { isAstNode } from "@seljs/common";
-import { COMPREHENSION_MACROS, SCALAR_WRAPPER_FUNCTIONS, } from "../../constants.js";
-import { walkAST } from "../../utils/index.js";
-/**
- * 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;
-    }
-    // Scalar wrapper: solInt(...), solAddress(...)
-    if (argNode.op === "call") {
-        return isResolvableScalarWrapper(argNode, scopedVars);
-    }
-    // Literal value
-    if (argNode.op === "value") {
-        return true;
-    }
-    // Variable reference — resolvable only if NOT scoped
-    if (argNode.op === "id" && typeof argNode.args === "string") {
-        return !scopedVars.has(argNode.args);
-    }
-    // Nested contract call result — resolvable (will be pre-executed)
-    if (argNode.op === "rcall") {
-        return isContractRCall(argNode, contractNames);
-    }
-    return false;
-};
-/**
- * Checks whether an rcall node targets a registered contract.
- */
-const isContractRCall = (node, contractNames) => {
-    const nodeArgs = node.args;
-    const receiverNode = nodeArgs[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 undefined;
-    }
-    return { method, receiver, callArgs };
-};
-/**
- * Tracks scoped variables introduced by comprehension macros or cel.bind().
- */
-const trackScopedVars = (parsed, scopedVars) => {
-    const { method, receiver, callArgs } = parsed;
-    // Comprehension iteration variables
-    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);
-        }
-    }
-    // cel.bind() variables
-    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
- */
-export 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 = new Set();
-        walkAST(context.ast, (node) => {
-            if (node.op !== "rcall") {
-                return;
-            }
-            const parsed = parseRCallNode(node);
-            if (!parsed) {
-                return;
-            }
-            const { method, callArgs } = parsed;
-            // Track scoped variables
-            trackScopedVars(parsed, scopedVars);
-            // Only check contract calls
-            if (!isContractRCall(node, contractNames)) {
-                return;
-            }
-            const receiverNode = node.args[1];
-            const contractName = receiverNode.args;
-            // Check if any argument is unresolvable
-            const hasDeferred = callArgs.some((argNode) => !isResolvableArg(argNode, contractNames, scopedVars));
-            if (hasDeferred) {
-                diagnostics.push(context.report(node, `\`${contractName}.${method}()\` has dynamic arguments and will execute as a live RPC call instead of being batched.`));
-            }
-        });
-        return diagnostics;
-    },
-};

package/dist/rules/defaults/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./deferred-call.js";
-export * from "./no-constant-condition.js";
-export * from "./no-mixed-operators.js";
-export * from "./no-redundant-bool.js";
-export * from "./no-self-comparison.js";
-export * from "./require-type.js";

package/dist/rules/defaults/index.js

@@ -1,6 +0,0 @@
-export * from "./deferred-call.js";
-export * from "./no-constant-condition.js";
-export * from "./no-mixed-operators.js";
-export * from "./no-redundant-bool.js";
-export * from "./no-self-comparison.js";
-export * from "./require-type.js";

package/dist/rules/defaults/no-constant-condition.d.ts

@@ -1,7 +0,0 @@
-import type { SELRule } from "../types.js";
-/**
- * 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
- */
-export declare const noConstantCondition: SELRule;

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

@@ -1,36 +0,0 @@
-import { walkAST } from "../../utils/index.js";
-/**
- * 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
- */
-export 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) => {
-            // Check && / || with boolean literal operands
-            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;
-            }
-            // Check == / != where both sides are literals
-            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;
-    },
-};

package/dist/rules/defaults/no-mixed-operators.d.ts

@@ -1,9 +0,0 @@
-import type { SELRule } from "../types.js";
-/**
- * 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.
- */
-export declare const noMixedOperators: SELRule;

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

@@ -1,44 +0,0 @@
-import { nodeSpan, walkAST } from "../../utils/index.js";
-/**
- * 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) => {
-    const span = nodeSpan(child);
-    let i = span.from - 1;
-    while (i >= 0 && (src[i] === " " || src[i] === "\t")) {
-        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.
- */
-export const noMixedOperators = {
-    name: "no-mixed-operators",
-    description: "Require parentheses when mixing logical operators (&& and ||).",
-    defaultSeverity: "info",
-    tier: "structural",
-    run(context) {
-        const diagnostics = [];
-        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."));
-                    // one diagnostic per node
-                    break;
-                }
-            }
-        });
-        return diagnostics;
-    },
-};

package/dist/rules/defaults/no-redundant-bool.d.ts

@@ -1,5 +0,0 @@
-import type { SELRule } from "../types.js";
-/**
- * Flags redundant boolean comparisons: `x == true`, `x != false`, etc.
- */
-export declare const noRedundantBool: SELRule;

package/dist/rules/defaults/no-redundant-bool.js

@@ -1,27 +0,0 @@
-import { walkAST } from "../../utils/index.js";
-/**
- * Flags redundant boolean comparisons: `x == true`, `x != false`, etc.
- */
-export const noRedundantBool = {
-    name: "no-redundant-bool",
-    description: "Disallow redundant comparisons to boolean literals (true/false).",
-    defaultSeverity: "warning",
-    tier: "structural",
-    run(context) {
-        const diagnostics = [];
-        walkAST(context.ast, (node) => {
-            if (node.op !== "==" && node.op !== "!=") {
-                return;
-            }
-            const [left, right] = node.args;
-            const leftIsBool = left.op === "value" && typeof left.args === "boolean";
-            const rightIsBool = right.op === "value" && typeof right.args === "boolean";
-            if (!leftIsBool && !rightIsBool) {
-                return;
-            }
-            const boolValue = leftIsBool ? left.args : right.args;
-            diagnostics.push(context.report(node, `Redundant comparison to \`${String(boolValue)}\`. Simplify the expression.`));
-        });
-        return diagnostics;
-    },
-};

package/dist/rules/defaults/no-self-comparison.d.ts

@@ -1,9 +0,0 @@
-import type { SELRule } from "../types.js";
-/**
- * Flags comparisons where both sides are the same expression (tautology/contradiction).
- *
- * Uses `serialize()` for identity comparison (safe for this purpose —
- * normalization is acceptable when comparing subtree identity, unlike
- * span calculation where it would produce incorrect positions).
- */
-export declare const noSelfComparison: SELRule;

package/dist/rules/defaults/no-self-comparison.js

@@ -1,31 +0,0 @@
-import { serialize } from "@marcbachmann/cel-js";
-import { walkAST } from "../../utils/index.js";
-const COMPARISON_OPS = new Set(["==", "!=", "<", "<=", ">", ">="]);
-const ALWAYS_TRUE_OPS = new Set(["==", "<=", ">="]);
-/**
- * Flags comparisons where both sides are the same expression (tautology/contradiction).
- *
- * Uses `serialize()` for identity comparison (safe for this purpose —
- * normalization is acceptable when comparing subtree identity, unlike
- * span calculation where it would produce incorrect positions).
- */
-export const noSelfComparison = {
-    name: "no-self-comparison",
-    description: "Disallow comparing an expression to itself.",
-    defaultSeverity: "warning",
-    tier: "structural",
-    run(context) {
-        const diagnostics = [];
-        walkAST(context.ast, (node) => {
-            if (!COMPARISON_OPS.has(node.op)) {
-                return;
-            }
-            const [left, right] = node.args;
-            if (serialize(left) === serialize(right)) {
-                const alwaysResult = ALWAYS_TRUE_OPS.has(node.op) ? "true" : "false";
-                diagnostics.push(context.report(node, `Both sides of \`${node.op}\` are identical. This is always \`${alwaysResult}\`.`));
-            }
-        });
-        return diagnostics;
-    },
-};

package/dist/rules/defaults/require-type.d.ts

@@ -1,7 +0,0 @@
-import type { SELRule } from "../types.js";
-/**
- * Rule factory that enforces an expression evaluates to the expected CEL type.
- *
- * @param expected - The CEL type name the expression must resolve to (e.g. "bool", "uint256")
- */
-export declare const requireType: (expected: string) => SELRule;

package/dist/rules/defaults/require-type.js

@@ -1,19 +0,0 @@
-/**
- * Rule factory that enforces an expression evaluates to the expected CEL type.
- *
- * @param expected - The CEL type name the expression must resolve to (e.g. "bool", "uint256")
- */
-export const requireType = (expected) => ({
-    name: `require-type-${expected}`,
-    description: `Expression must evaluate to ${expected}.`,
-    defaultSeverity: "error",
-    tier: "type-aware",
-    run(context) {
-        if (context.resolvedType === expected) {
-            return [];
-        }
-        return [
-            context.reportAt(0, context.expression.length, `Expected expression to evaluate to "${expected}", but got "${String(context.resolvedType)}".`),
-        ];
-    },
-});