@callcium/sdk 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -20,6 +20,8 @@ type Context = {
   blockNumber?: bigint;
   chainId?: bigint;
   txOrigin?: Address;
+  baseFee?: bigint;
+  gasPrice?: bigint;
 };
 /** Result of enforcing a policy: pass with matched group index, or fail with one violation per failed group. */
 type EnforceResult = {
@@ -203,7 +205,7 @@ type DecodedPolicy = {
 /** Severity of a validation issue. */
 type IssueSeverity = "info" | "warning" | "error";
 /** Category of a validation issue. */
-type IssueCategory = "typeMismatch" | "contradiction" | "redundancy" | "vacuity";
+type IssueCategory = "typeMismatch" | "contradiction" | "redundancy" | "vacuity" | "compatibility";
 /** A single validation issue found during policy analysis. */
 type Issue = {
   severity: IssueSeverity;
@@ -285,10 +287,7 @@ declare class ConstraintBuilder implements Constraint {
  * Target a calldata argument by path.
  * Each argument is a big-endian uint16 step; multiple steps navigate into nested types.
  */
-declare function arg(p0: number): ConstraintBuilder;
-declare function arg(p0: number, p1: number): ConstraintBuilder;
-declare function arg(p0: number, p1: number, p2: number): ConstraintBuilder;
-declare function arg(p0: number, p1: number, p2: number, p3: number): ConstraintBuilder;
+declare function arg(p0: number, ...rest: number[]): ConstraintBuilder;
 /** Target the `msg.sender` context property. */
 declare function msgSender(): ConstraintBuilder;
 /** Target the `msg.value` context property. */
@@ -301,6 +300,10 @@ declare function blockNumber(): ConstraintBuilder;
 declare function chainId(): ConstraintBuilder;
 /** Target the `tx.origin` context property. */
 declare function txOrigin(): ConstraintBuilder;
+/** Target the `block.basefee` context property. */
+declare function baseFee(): ConstraintBuilder;
+/** Target the `tx.gasprice` context property. */
+declare function gasPrice(): ConstraintBuilder;
 //#endregion
 //#region src/policy-builder.d.ts
 /** Fluent builder for constructing Callcium policies. */
@@ -325,11 +328,21 @@ declare class PolicyBuilder {
   /** Start a new constraint group (OR branch). */
   or(): this;
   /**
-   * Build the policy into an encoded binary blob.
+   * Build the policy into an encoded binary blob with strict validation.
+   * Throws on any issue, regardless of severity. Use {@link validate} to
+   * inspect issues, or {@link buildUnsafe} to encode without validation.
    * @returns The policy as a 0x-prefixed hex string.
-   * @throws {CallciumError} If any group is empty or validation finds errors.
+   * @throws {CallciumError} If any group is empty or validation finds any issue.
    */
   build(): Hex;
+  /**
+   * Build the policy into an encoded binary blob without validation.
+   * The resulting policy may be invalid. Prefer {@link build}; use this
+   * only to knowingly bypass a reported issue.
+   * @returns The policy as a 0x-prefixed hex string.
+   * @throws {CallciumError} If any group is empty.
+   */
+  buildUnsafe(): Hex;
   /**
    * Validate the policy without encoding.
    * @returns All validation issues found.
@@ -417,6 +430,19 @@ declare function inspect(desc: Uint8Array, offset: number): TypeInfo;
  * @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
  */
 declare function typeAt(desc: Uint8Array, steps: number[]): TypeInfo;
+/**
+ * Resolve the type at the path and the declared length of the static array a
+ * quantifier step descends into (zero when the path holds no quantifier step
+ * over a static array).
+ * @param desc - Raw descriptor bytes.
+ * @param steps - Path steps, length >= 1.
+ * @returns TypeInfo at the resolved path and the quantified static array length.
+ * @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
+ */
+declare function walkPath(desc: Uint8Array, steps: number[]): {
+  typeInfo: TypeInfo;
+  quantifiedStaticLength: number;
+};
 /**
  * Return tuple field count at a tuple node offset.
  * @param desc - Raw descriptor bytes.
@@ -445,6 +471,7 @@ declare const Descriptor: {
   staticArrayLength: typeof staticArrayLength;
   nodeLength: typeof nodeLength;
   arrayElementOffset: typeof arrayElementOffset;
+  walkPath: typeof walkPath;
 };
 //#endregion
 //#region src/policy-validator.d.ts
@@ -470,7 +497,7 @@ declare const PolicyValidator: {
  * @param policy - Binary policy blob as 0x-prefixed hex string.
  * @param callData - ABI-encoded call data as 0x-prefixed hex string.
  * @param context - Optional execution context for context-scoped rules.
- * @returns Pass with matched group index, or fail with one violation per failed group.
+ * @returns Pass with matched group index, or fail with one violation per evaluated failing group.
  * @throws {CallciumError} If the policy blob is structurally malformed.
  */
 declare function check(policy: Hex, callData: Hex, context?: Context): EnforceResult;
@@ -584,6 +611,16 @@ declare const ContextProperty: CodeMap<readonly [{
   readonly code: 5;
   readonly label: "tx.origin";
   readonly typeCode: 64;
+}, {
+  readonly key: "BASE_FEE";
+  readonly code: 6;
+  readonly label: "block.basefee";
+  readonly typeCode: 31;
+}, {
+  readonly key: "GAS_PRICE";
+  readonly code: 7;
+  readonly label: "tx.gasprice";
+  readonly typeCode: 31;
 }]>;
 /** Display metadata for a context property code. */
 type ContextPropertyInfo = {
@@ -772,7 +809,7 @@ declare function isLengthOp(opCode: number): boolean;
 //#endregion
 //#region src/errors.d.ts
 /** Machine-readable error code for structural decoding and validation failures. */
-type CallciumErrorCode = "UNSUPPORTED_VERSION" | "MALFORMED_HEADER" | "UNEXPECTED_END" | "NODE_OVERFLOW" | "UNKNOWN_TYPE_CODE" | "INVALID_OPERATOR" | "INVALID_ARRAY_LENGTH" | "INVALID_TUPLE_FIELD_COUNT" | "PARAM_COUNT_MISMATCH" | "EMPTY_POLICY" | "EMPTY_GROUP" | "EMPTY_PATH" | "INVALID_CONTEXT_PATH" | "INVALID_CONTEXT_PROPERTY" | "INVALID_QUANTIFIER" | "INVALID_SCOPE" | "RULE_SIZE_MISMATCH" | "GROUP_SIZE_MISMATCH" | "GROUP_OVERFLOW" | "RULE_OVERFLOW" | "TRAILING_BYTES" | "INTERNAL_ERROR" | "INVALID_SIGNATURE" | "INVALID_TYPE_STRING" | "UNKNOWN_TYPE" | "DESCRIPTOR_TOO_LARGE" | "INVALID_PATH" | "DUPLICATE_PATH" | "INVALID_CONSTRAINT" | "INVALID_OPERATOR_DATA" | "EMPTY_SET" | "SET_TOO_LARGE" | "INVALID_RANGE" | "GROUP_COUNT_OVERFLOW" | "RULE_COUNT_OVERFLOW" | "RULE_SIZE_OVERFLOW" | "DESC_LENGTH_OVERFLOW" | "INVALID_HEX" | "VALIDATION_ERROR";
+type CallciumErrorCode = "UNSUPPORTED_VERSION" | "MALFORMED_HEADER" | "UNEXPECTED_END" | "NODE_OVERFLOW" | "NESTING_TOO_DEEP" | "UNKNOWN_TYPE_CODE" | "INVALID_OPERATOR" | "UNSORTED_IN_SET" | "INVALID_ARRAY_LENGTH" | "INVALID_TUPLE_FIELD_COUNT" | "PARAM_COUNT_MISMATCH" | "EMPTY_POLICY" | "EMPTY_GROUP" | "EMPTY_PATH" | "INVALID_CONTEXT_PATH" | "INVALID_CONTEXT_PROPERTY" | "INVALID_QUANTIFIER" | "INVALID_SCOPE" | "RULE_SIZE_MISMATCH" | "GROUP_SIZE_MISMATCH" | "GROUP_OVERFLOW" | "RULE_OVERFLOW" | "TRAILING_BYTES" | "INTERNAL_ERROR" | "INVALID_SIGNATURE" | "INVALID_TYPE_STRING" | "UNKNOWN_TYPE" | "DESCRIPTOR_TOO_LARGE" | "INVALID_PATH" | "PATH_TOO_DEEP" | "DUPLICATE_PATH" | "INVALID_CONSTRAINT" | "INVALID_OPERATOR_DATA" | "EMPTY_SET" | "SET_TOO_LARGE" | "INVALID_RANGE" | "GROUP_COUNT_OVERFLOW" | "RULE_COUNT_OVERFLOW" | "RULE_SIZE_OVERFLOW" | "DESC_LENGTH_OVERFLOW" | "INVALID_HEX" | "VALIDATION_ERROR";
 /**
  * Thrown when a policy or descriptor blob is structurally malformed.
  * The optional `offset` indicates the byte position in the source blob where the error was detected.
@@ -798,5 +835,5 @@ declare class PolicyViolationError extends Error {
   constructor(violations: Violation[]);
 }
 //#endregion
-export { type Address, CallciumError, type CallciumErrorCode, type CalldataNavigationViolation, type Constraint, type ConstraintBuilder, type Context, ContextProperty, type ContextPropertyInfo, type DecodedGroup, type DecodedParam, type DecodedPolicy, type DecodedRule, Descriptor, DescriptorCoder, type EnforceResult, type Field, type Hex, type Issue, type IssueCategory, type IssueSeverity, Limits, type MissingContextViolation, type MissingSelectorViolation, type NavigationViolationCode, Op, type OpInfo, type Operands, PolicyBuilder, PolicyCoder, type PolicyData, PolicyEnforcer, PolicyValidator, PolicyViolationError, Quantifier, type QuantifierEmptyArrayViolation, type QuantifierInfo, type QuantifierLimitExceededViolation, type ScalarValue, Scope, type ScopeInfo, type SelectorMismatchViolation, type Span, type TypeClass, type TypeClassInfo, TypeCode, type TypeCodeInfo, type TypeInfo, type ValueMismatchViolation, type Violation, type ViolationCode, arg, blockNumber, blockTimestamp, bytesToHex, chainId, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
+export { type Address, CallciumError, type CallciumErrorCode, type CalldataNavigationViolation, type Constraint, type ConstraintBuilder, type Context, ContextProperty, type ContextPropertyInfo, type DecodedGroup, type DecodedParam, type DecodedPolicy, type DecodedRule, Descriptor, DescriptorCoder, type EnforceResult, type Field, type Hex, type Issue, type IssueCategory, type IssueSeverity, Limits, type MissingContextViolation, type MissingSelectorViolation, type NavigationViolationCode, Op, type OpInfo, type Operands, PolicyBuilder, PolicyCoder, type PolicyData, PolicyEnforcer, PolicyValidator, PolicyViolationError, Quantifier, type QuantifierEmptyArrayViolation, type QuantifierInfo, type QuantifierLimitExceededViolation, type ScalarValue, Scope, type ScopeInfo, type SelectorMismatchViolation, type Span, type TypeClass, type TypeClassInfo, TypeCode, type TypeCodeInfo, type TypeInfo, type ValueMismatchViolation, type Violation, type ViolationCode, arg, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/constraint.ts","../src/policy-builder.ts","../src/policy-coder.ts","../src/descriptor.ts","../src/policy-validator.ts","../src/policy-enforcer.ts","../src/bytes.ts","../src/descriptor-coder.ts","../src/constants.ts","../src/operators.ts","../src/errors.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/constraint.ts","../src/policy-builder.ts","../src/policy-coder.ts","../src/descriptor.ts","../src/policy-validator.ts","../src/policy-enforcer.ts","../src/bytes.ts","../src/descriptor-coder.ts","../src/constants.ts","../src/operators.ts","../src/errors.ts"],"mappings":"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"}

package/dist/index.js

@@ -116,7 +116,8 @@ const DescriptorFormat = {
 	MAX_NODE_LENGTH: 4095,
 	MAX_STATIC_ARRAY_LENGTH: 4095,
 	MAX_TUPLE_FIELDS: 4089,
-	MAX_PARAMS: 255
+	MAX_PARAMS: 255,
+	MAX_NESTING_DEPTH: 64
 };
 /** Binary layout constants for the Callcium policy format. */
 const PolicyFormat = {
@@ -207,6 +208,18 @@ const CTX_PROP_TABLE = [
 		code: 5,
 		label: "tx.origin",
 		typeCode: 64
+	},
+	{
+		key: "BASE_FEE",
+		code: 6,
+		label: "block.basefee",
+		typeCode: 31
+	},
+	{
+		key: "GAS_PRICE",
+		code: 7,
+		label: "tx.gasprice",
+		typeCode: 31
 	}
 ];
 /** Well-known context property IDs for context-scope rules. */
@@ -220,7 +233,9 @@ const CTX_KEY_MAP = {
 	BLOCK_TIMESTAMP: "blockTimestamp",
 	BLOCK_NUMBER: "blockNumber",
 	CHAIN_ID: "chainId",
-	TX_ORIGIN: "txOrigin"
+	TX_ORIGIN: "txOrigin",
+	BASE_FEE: "baseFee",
+	GAS_PRICE: "gasPrice"
 };
 const ctxPropByCode = new Map(CTX_PROP_TABLE.map((e) => [e.code, {
 	label: e.label,
@@ -562,11 +577,24 @@ function inspect$1(desc, offset) {
 * @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
 */
 function typeAt(desc, steps) {
+	return walkPath(desc, steps).typeInfo;
+}
+/**
+* Resolve the type at the path and the declared length of the static array a
+* quantifier step descends into (zero when the path holds no quantifier step
+* over a static array).
+* @param desc - Raw descriptor bytes.
+* @param steps - Path steps, length >= 1.
+* @returns TypeInfo at the resolved path and the quantified static array length.
+* @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
+*/
+function walkPath(desc, steps) {
 	if (steps.length === 0) throw new CallciumError("INVALID_PATH", "Path must have at least one step.");
 	const paramIndex = steps[0];
 	const count = desc[1];
 	if (paramIndex >= count) throw new CallciumError("INVALID_PATH", `Param index ${paramIndex} out of range (paramCount=${count}).`);
 	let cursor = paramOffset(desc, paramIndex);
+	let quantifiedStaticLength = 0;
 	for (let stepIndex = 1; stepIndex < steps.length; stepIndex++) {
 		const typeCode = desc[cursor];
 		const step = steps[stepIndex];
@@ -574,10 +602,15 @@ function typeAt(desc, steps) {
 			const fields = tupleFieldCount(desc, cursor);
 			if (step >= fields) throw new CallciumError("INVALID_PATH", `Tuple field index ${step} out of range (tuple has ${fields} fields).`);
 			cursor = tupleFieldOffset(desc, cursor, step);
-		} else if (typeCode === TypeCode.STATIC_ARRAY || typeCode === TypeCode.DYNAMIC_ARRAY) cursor = arrayElementOffset(cursor);
-		else throw new CallciumError("INVALID_PATH", `Cannot descend into elementary type at offset ${cursor}.`);
+		} else if (typeCode === TypeCode.STATIC_ARRAY || typeCode === TypeCode.DYNAMIC_ARRAY) {
+			if (typeCode === TypeCode.STATIC_ARRAY && isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
+			cursor = arrayElementOffset(cursor);
+		} else throw new CallciumError("INVALID_PATH", `Cannot descend into elementary type at offset ${cursor}.`);
 	}
-	return inspect$1(desc, cursor);
+	return {
+		typeInfo: inspect$1(desc, cursor),
+		quantifiedStaticLength
+	};
 }
 /**
 * Return tuple field count at a tuple node offset.
@@ -613,7 +646,8 @@ const Descriptor = {
 	tupleFieldCount,
 	staticArrayLength,
 	nodeLength,
-	arrayElementOffset
+	arrayElementOffset,
+	walkPath
 };
 //#endregion
 //#region src/type-desc.ts
@@ -939,7 +973,7 @@ function toTypes(desc) {
 	return types.join(",");
 }
 /** Recursively parse a single descriptor node starting at offset. */
-function parseNode(data, offset) {
+function parseNode(data, offset, depth) {
 	if (offset >= data.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end of descriptor", offset);
 	const code = data[offset];
 	const info = classifyTypeCode(code);
@@ -957,6 +991,7 @@ function parseNode(data, offset) {
 		},
 		next: metaOffset
 	};
+	if (depth > DescriptorFormat.MAX_NESTING_DEPTH) throw new CallciumError("NESTING_TOO_DEEP", `Composite nesting exceeds maximum depth ${DescriptorFormat.MAX_NESTING_DEPTH}`, offset);
 	const metaEnd = metaOffset + DescriptorFormat.COMPOSITE_META_SIZE;
 	if (metaEnd > data.length) throw new CallciumError("UNEXPECTED_END", "Incomplete composite metadata", offset);
 	const meta = readU24(data, metaOffset);
@@ -977,7 +1012,7 @@ function parseNode(data, offset) {
 		const fields = [];
 		let cursor = offset + DescriptorFormat.TUPLE_HEADER_SIZE;
 		for (let i = 0; i < fieldCount; i++) {
-			const result = parseNode(data, cursor);
+			const result = parseNode(data, cursor, depth + 1);
 			fields.push(result.node);
 			cursor = result.next;
 		}
@@ -997,7 +1032,7 @@ function parseNode(data, offset) {
 		};
 	}
 	if (info.typeClass === "staticArray") {
-		const elemResult = parseNode(data, Descriptor.arrayElementOffset(offset));
+		const elemResult = parseNode(data, Descriptor.arrayElementOffset(offset), depth + 1);
 		const lengthOffset = elemResult.next;
 		if (lengthOffset + DescriptorFormat.ARRAY_LENGTH_SIZE > data.length) throw new CallciumError("UNEXPECTED_END", "Missing static array length suffix", offset);
 		const length = readU16(data, lengthOffset);
@@ -1025,7 +1060,7 @@ function parseNode(data, offset) {
 			typeCode: code,
 			isDynamic: true,
 			staticSize: 0,
-			element: parseNode(data, Descriptor.arrayElementOffset(offset)).node,
+			element: parseNode(data, Descriptor.arrayElementOffset(offset), depth + 1).node,
 			span: {
 				start: offset,
 				end: nodeEnd
@@ -1050,7 +1085,7 @@ function decodeDescriptor(data) {
 	let cursor = DescriptorFormat.HEADER_SIZE;
 	while (cursor < data.length) {
 		if (params.length >= DescriptorFormat.MAX_PARAMS) throw new CallciumError("PARAM_COUNT_MISMATCH", `Descriptor exceeds the maximum of ${DescriptorFormat.MAX_PARAMS} top-level params`);
-		const { node, next } = parseNode(data, cursor);
+		const { node, next } = parseNode(data, cursor, 1);
 		tree.push(node);
 		params.push({
 			index: params.length,
@@ -1161,10 +1196,15 @@ function decodePolicy(blob) {
 			const depthOffset = ruleOffset + PolicyFormat.RULE_DEPTH_OFFSET;
 			const depthValue = data[depthOffset];
 			if (depthValue === 0) throw new CallciumError("EMPTY_PATH", "Rule path must have at least one step", ruleOffset);
+			if (depthValue > Limits.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depthValue} exceeds maximum ${Limits.MAX_PATH_DEPTH}`, ruleOffset);
 			if (scopeValue === Scope.CONTEXT && depthValue !== 1) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope rules must have exactly one path step", ruleOffset);
 			const pathStart = ruleOffset + PolicyFormat.RULE_PATH_OFFSET;
 			const pathLength = depthValue * PolicyFormat.PATH_STEP_SIZE;
 			const pathHex = toHex(data, pathStart, pathStart + pathLength);
+			if (scopeValue === Scope.CONTEXT) {
+				const contextPropertyId = readU16(data, pathStart);
+				if (contextPropertyId > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("INVALID_CONTEXT_PROPERTY", `Context rule references undefined context property 0x${contextPropertyId.toString(16).padStart(4, "0")}`, ruleOffset);
+			}
 			const opCodeOffset = pathStart + pathLength;
 			const opCodeValue = data[opCodeOffset];
 			const dataLengthOffset = opCodeOffset + PolicyFormat.RULE_OPCODE_SIZE;
@@ -1174,6 +1214,10 @@ function decodePolicy(blob) {
 			if (ruleSizeValue !== expectedRuleSize) throw new CallciumError("RULE_SIZE_MISMATCH", `Declared rule size ${ruleSizeValue} does not match computed size ${expectedRuleSize}`, ruleOffset);
 			const opBase = opCodeValue & ~Op.NOT;
 			if (opBase === 0 || !isValidOperatorData(opBase, dataLengthValue)) throw new CallciumError("INVALID_OPERATOR", "Unrecognized or malformed operator", ruleOffset);
+			if (opBase === Op.IN) {
+				const wordCount = dataLengthValue / 32;
+				for (let word = 1; word < wordCount; word++) if (compareBytes(data.subarray(dataStart + (word - 1) * 32, dataStart + word * 32), data.subarray(dataStart + word * 32, dataStart + (word + 1) * 32)) >= 0) throw new CallciumError("UNSORTED_IN_SET", "IN operands must be strictly ascending", ruleOffset);
+			}
 			rules.push({
 				ruleSize: field(ruleSizeValue, ruleOffset, ruleOffset + PolicyFormat.RULE_SIZE_SIZE),
 				scope: field(scopeValue, scopeOffset, scopeOffset + 1),
@@ -1264,7 +1308,7 @@ function encodeRule(rule) {
 	if ((rule.path.length & 1) !== 0) throw new CallciumError("INVALID_PATH", "Path byte length must be even.");
 	if (rule.operator.length < 1) throw new CallciumError("INVALID_OPERATOR", "Operator must have at least one byte (opcode).");
 	const depth = rule.path.length / 2;
-	if (depth > Limits.MAX_PATH_DEPTH) throw new CallciumError("INVALID_PATH", `Path depth ${depth} exceeds maximum ${Limits.MAX_PATH_DEPTH}.`);
+	if (depth > Limits.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depth} exceeds maximum ${Limits.MAX_PATH_DEPTH}.`);
 	if (rule.scope === Scope.CONTEXT && depth !== 1) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope rules must have exactly one path step.");
 	const opCode = rule.operator[0];
 	const data = rule.operator.subarray(1);
@@ -1412,6 +1456,35 @@ function toBigInt(bytes, offset = 0) {
 function isSigned(typeCode) {
 	return typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
 }
+/**
+* Canonicalize a raw 256-bit calldata word to its ABI value for the declared type (Policy Spec §7.8).
+* A scalar loaded from untrusted calldata may carry bits outside the declared width; masking
+* unsigned/address/bool/function/bytesN to width and sign-extending signed integers makes the
+* comparison use the canonical ABI value rather than the raw bytes.
+* @param value - The raw 256-bit word loaded from calldata.
+* @param typeCode - The declared type code of the value.
+* @returns The canonicalized 256-bit value.
+*/
+function canonicalize(value, typeCode) {
+	if (typeCode <= TypeCode.UINT_MAX) {
+		const bits = BigInt((typeCode + 1) * 8);
+		return bits === 256n ? value : value & (1n << bits) - 1n;
+	}
+	if (typeCode <= TypeCode.INT_MAX) {
+		const bits = (typeCode - TypeCode.INT_MIN + 1) * 8;
+		return bits === 256 ? value : BigInt.asUintN(256, BigInt.asIntN(bits, value));
+	}
+	if (typeCode === TypeCode.ADDRESS) return value & (1n << 160n) - 1n;
+	if (typeCode === TypeCode.BOOL) return value & 1n;
+	if (typeCode === TypeCode.FUNCTION) return value >> 64n << 64n;
+	if (typeCode >= TypeCode.FIXED_BYTES_MIN && typeCode <= TypeCode.FIXED_BYTES_MAX) {
+		const n = typeCode - TypeCode.FIXED_BYTES_MIN + 1;
+		if (n === 32) return value;
+		const padBits = BigInt((32 - n) * 8);
+		return value >> padBits << padBits;
+	}
+	return value;
+}
 /** Return true when the operator code (with or without NOT flag) is a LENGTH_* variant. */
 function isLengthOp(opCode) {
 	const base = opCode & ~Op.NOT;
@@ -1676,6 +1749,22 @@ function vacuousLengthGte(groupIndex, constraintIndex, value) {
 function vacuousLengthLte(groupIndex, constraintIndex, value) {
 	return makeIssue("info", "vacuity", groupIndex, constraintIndex, "VACUOUS_LENGTH_LTE", value, ZERO, "lengthLte() bound equals maximum (always true)");
 }
+/** Path deeper than the reference enforcer's cap. */
+function pathDepthExceeded(groupIndex, constraintIndex, depth, maxDepth) {
+	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "PATH_DEPTH_EXCEEDED", depth, maxDepth, "Path depth exceeds the reference enforcer cap");
+}
+/** Quantifier over a static array beyond the reference enforcer's iteration cap. */
+function quantifierOverStaticLimit(groupIndex, constraintIndex, arrayLength, maxLength) {
+	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "QUANTIFIER_OVER_STATIC_LIMIT", arrayLength, maxLength, "Quantifier over static array exceeds the reference enforcer cap");
+}
+/** Context property ID outside the assigned set. */
+function unknownContextProperty(groupIndex, constraintIndex, contextId, maxContextId) {
+	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "UNKNOWN_CONTEXT_PROPERTY", contextId, maxContextId, "Unknown context property ID");
+}
+/** Negated operator under the existential quantifier. */
+function negationUnderAny(groupIndex, constraintIndex, opCode) {
+	return makeIssue("warning", "compatibility", groupIndex, constraintIndex, "NEGATION_UNDER_ANY", opCode, ZERO, "Negated operator under any() passes when a decoy element differs");
+}
 /** Pre-select value or length issue factories for a bound domain. */
 function boundIssues(isLength) {
 	return {
@@ -1795,6 +1884,10 @@ function getIncompat(opBase, typeInfo) {
 			code: "VALUE_OP_ON_DYNAMIC",
 			message: "Value operator used on dynamic type"
 		};
+		if (classifyTypeCode(typeCode).typeClass !== "elementary") return {
+			code: "VALUE_OP_ON_COMPOSITE",
+			message: "Value operator used on composite type"
+		};
 		if (isComparisonOp(opBase) && !isNumericType(typeCode)) return {
 			code: "NUMERIC_OP_ON_NON_NUMERIC",
 			message: "Comparison operator used on non-numeric type"
@@ -1803,6 +1896,10 @@ function getIncompat(opBase, typeInfo) {
 			code: "BITMASK_ON_INVALID",
 			message: "Bitmask operator used on incompatible type"
 		};
+		if (opBase === Op.IN && typeCode === TypeCode.BOOL) return {
+			code: "IN_ON_BOOL",
+			message: "IN operator used on boolean type"
+		};
 		return null;
 	}
 	if (isLengthOp(opBase)) {
@@ -2116,10 +2213,12 @@ function checkDuplicates(issues, operators, groupIndex, constraintIndex) {
 /** Validate all operators on a single constraint against its domain context. */
 function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues) {
 	const operators = constraint.operators;
+	const underAny = constraint.scope === Scope.CALLDATA && parsePathSteps(constraint.path).includes(Quantifier.ANY);
 	for (const opHex of operators) {
 		const opCode = parseInt(opHex.slice(2, 4), 16);
 		const base = opCode & ~Op.NOT;
 		const isNegated = (opCode & Op.NOT) !== 0;
+		if (underAny && isNegated) issues.push(negationUnderAny(groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
 		const compat = checkCompatibility(base, ctx.typeInfo.typeCode, ctx.typeInfo.isDynamic, ctx.typeInfo.staticSize);
 		if (!compat.compatible) {
 			issues.push(fromOpRule(compat.code, compat.message, groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
@@ -2169,10 +2268,20 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			let typeInfo;
 			if (constraint.scope === Scope.CALLDATA) {
 				const steps = parsePathSteps(constraint.path);
-				typeInfo = Descriptor.typeAt(descBytes, steps);
+				if (steps.length > Limits.MAX_PATH_DEPTH) issues.push(pathDepthExceeded(groupIndex, constraintIndex, bigintToHex(BigInt(steps.length)), bigintToHex(BigInt(Limits.MAX_PATH_DEPTH))));
+				const walk = Descriptor.walkPath(descBytes, steps);
+				if (walk.quantifiedStaticLength > Limits.MAX_QUANTIFIED_ARRAY_LENGTH) issues.push(quantifierOverStaticLimit(groupIndex, constraintIndex, bigintToHex(BigInt(walk.quantifiedStaticLength)), bigintToHex(BigInt(Limits.MAX_QUANTIFIED_ARRAY_LENGTH))));
+				typeInfo = walk.typeInfo;
 			} else {
 				const ctxId = parsePathSteps(constraint.path)[0];
-				typeInfo = {
+				if (ctxId > MAX_CONTEXT_PROPERTY_ID) {
+					issues.push(unknownContextProperty(groupIndex, constraintIndex, bigintToHex(BigInt(ctxId)), bigintToHex(BigInt(MAX_CONTEXT_PROPERTY_ID))));
+					typeInfo = {
+						typeCode: TypeCode.UINT_MAX,
+						isDynamic: false,
+						staticSize: 32
+					};
+				} else typeInfo = {
 					typeCode: lookupContextProperty(ctxId).typeCode,
 					isDynamic: false,
 					staticSize: 32
@@ -2350,18 +2459,31 @@ var PolicyBuilder = class PolicyBuilder {
 		return this;
 	}
 	/**
-	* Build the policy into an encoded binary blob.
+	* Build the policy into an encoded binary blob with strict validation.
+	* Throws on any issue, regardless of severity. Use {@link validate} to
+	* inspect issues, or {@link buildUnsafe} to encode without validation.
 	* @returns The policy as a 0x-prefixed hex string.
-	* @throws {CallciumError} If any group is empty or validation finds errors.
+	* @throws {CallciumError} If any group is empty or validation finds any issue.
 	*/
 	build() {
 		this.checkGroups();
 		const policyData = this.toPolicyData();
-		const firstError = PolicyValidator.validate(policyData).find((issue) => issue.severity === "error");
-		if (firstError) throw new CallciumError("VALIDATION_ERROR", firstError.message);
+		const issues = PolicyValidator.validate(policyData);
+		if (issues.length > 0) throw new CallciumError("VALIDATION_ERROR", issues[0].message);
 		return PolicyCoder.encode(policyData);
 	}
 	/**
+	* Build the policy into an encoded binary blob without validation.
+	* The resulting policy may be invalid. Prefer {@link build}; use this
+	* only to knowingly bypass a reported issue.
+	* @returns The policy as a 0x-prefixed hex string.
+	* @throws {CallciumError} If any group is empty.
+	*/
+	buildUnsafe() {
+		this.checkGroups();
+		return PolicyCoder.encode(this.toPolicyData());
+	}
+	/**
 	* Validate the policy without encoding.
 	* @returns All validation issues found.
 	*/
@@ -2582,6 +2704,14 @@ function chainId() {
 function txOrigin() {
 	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.TX_ORIGIN]));
 }
+/** Target the `block.basefee` context property. */
+function baseFee() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BASE_FEE]));
+}
+/** Target the `tx.gasprice` context property. */
+function gasPrice() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.GAS_PRICE]));
+}
 //#endregion
 //#region src/reader.ts
 /** Read 32 bytes at offset, bounds-checked. */
@@ -2885,9 +3015,16 @@ function loadSlice(callData, location) {
 		ok: false,
 		code: lengthResult.code
 	};
+	const dataOffset = dataStart + 32;
+	const node = location.node;
+	const stride = node.type === "dynamicArray" ? node.element.isDynamic ? 32 : node.element.staticSize : 1;
+	if (dataOffset > callData.length || lengthResult > Math.floor((callData.length - dataOffset) / stride)) return {
+		ok: false,
+		code: "CALLDATA_OUT_OF_BOUNDS"
+	};
 	return {
 		ok: true,
-		dataOffset: dataStart + 32,
+		dataOffset,
 		length: lengthResult
 	};
 }
@@ -2917,6 +3054,12 @@ function descendPath(callData, location, pathBytes) {
 }
 //#endregion
 //#region src/policy-enforcer.ts
+/** Violations that abort evaluation instead of failing only their group (spec §10.3). */
+const ABORT_VIOLATION_CODES = new Set([
+	"CALLDATA_OUT_OF_BOUNDS",
+	"ARRAY_INDEX_OUT_OF_BOUNDS",
+	"QUANTIFIER_LIMIT_EXCEEDED"
+]);
 /** Convert a hex address to a 256-bit bigint (zero-padded to 32 bytes). */
 function addressToBigInt(hex) {
 	const bytes = hexToBytes(hex);
@@ -2951,7 +3094,7 @@ function resolveLeafTypeCode(elementNode, remainingPath) {
 * @param policy - Binary policy blob as 0x-prefixed hex string.
 * @param callData - ABI-encoded call data as 0x-prefixed hex string.
 * @param context - Optional execution context for context-scoped rules.
-* @returns Pass with matched group index, or fail with one violation per failed group.
+* @returns Pass with matched group index, or fail with one violation per evaluated failing group.
 * @throws {CallciumError} If the policy blob is structurally malformed.
 */
 function check(policy, callData, context) {
@@ -2983,6 +3126,10 @@ function check(policy, callData, context) {
 			const violation = evaluateRule(rule, tree, callDataBytes, baseOffset, groupIndex, ruleIndex, context);
 			if (violation !== null) {
 				allViolations.push(violation);
+				if (ABORT_VIOLATION_CODES.has(violation.code)) return {
+					ok: false,
+					violations: allViolations
+				};
 				groupFailed = true;
 				break;
 			}
@@ -3015,7 +3162,6 @@ function evaluateRule(rule, tree, callDataBytes, baseOffset, groupIndex, ruleInd
 	const pathBytes = hexToBytes(rule.path.value);
 	const opCode = rule.opCode.value;
 	const operandData = hexToBytes(rule.data.value);
-	if (pathBytes.length / 2 > Limits.MAX_PATH_DEPTH) throw new CallciumError("INVALID_PATH", `Path depth ${pathBytes.length / 2} exceeds maximum ${Limits.MAX_PATH_DEPTH}.`);
 	if (scope === Scope.CONTEXT) return evaluateContextRule(pathBytes, opCode, operandData, groupIndex, ruleIndex, rule.path.value, context);
 	const locResult = locate(tree, callDataBytes, pathBytes, baseOffset);
 	if (!locResult.ok) return {
@@ -3083,9 +3229,10 @@ function applyLeafOperator(callDataBytes, location, opCode, operandData) {
 	}
 	const result = loadScalar(callDataBytes, location);
 	if (!result.ok) return { error: result.code };
+	const value = canonicalize(toBigInt(result.value, 0), node.typeCode);
 	return {
-		passed: applyOperator(opCode, toBigInt(result.value, 0), 32, operandData, node.typeCode),
-		resolvedValue: bytesToHex(result.value)
+		passed: applyOperator(opCode, value, 32, operandData, node.typeCode),
+		resolvedValue: bigintToHex(value)
 	};
 }
 /** Evaluate a leaf rule, producing a violation on failure or null on pass. */
@@ -3236,6 +3383,6 @@ const PolicyEnforcer = {
 	enforce
 };
 //#endregion
-export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, Limits, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, arg, blockNumber, blockTimestamp, bytesToHex, chainId, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
+export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, Limits, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, arg, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
 
 //# sourceMappingURL=index.js.map