@callcium/sdk 0.5.0 → 0.6.0

package/dist/index.d.ts

@@ -118,6 +118,23 @@ type QuantifierLimitExceededViolation = {
   path: Hex; /** Hex-encoded element count of the offending array. */
   resolvedValue: Hex;
 };
+/**
+ * A resolved word is not the canonical encoding of its declared type (spec §7.4).
+ *
+ * `resolvedValue` is the raw 32-byte word as it appeared in calldata, before any masking.
+ */
+type NonCanonicalValueViolation = {
+  code: "NON_CANONICAL_VALUE";
+  group: number;
+  rule: number;
+  scope: number;
+  path: Hex; /** Type code of the target whose encoding was violated. */
+  typeCode: number; /** Raw 32-byte word as it appeared in calldata, before any masking. */
+  resolvedValue: Hex;
+  opCode?: number;
+  operandData?: Hex;
+  elementIndex?: number;
+};
 /** A quantifier (`ANY` or `ALL`) was applied to an empty array. */
 type QuantifierEmptyArrayViolation = {
   code: "QUANTIFIER_EMPTY_ARRAY";
@@ -132,7 +149,7 @@ type QuantifierEmptyArrayViolation = {
  * Carries semantic data only — message strings are the consumer's responsibility.
  * Discriminate on `code` to narrow to the matching variant.
  */
-type Violation = MissingSelectorViolation | SelectorMismatchViolation | MissingContextViolation | ValueMismatchViolation | CalldataNavigationViolation | QuantifierLimitExceededViolation | QuantifierEmptyArrayViolation;
+type Violation = MissingSelectorViolation | SelectorMismatchViolation | MissingContextViolation | ValueMismatchViolation | CalldataNavigationViolation | NonCanonicalValueViolation | QuantifierLimitExceededViolation | QuantifierEmptyArrayViolation;
 /** Machine-readable reason code for an enforcement violation. Derived from `Violation` to prevent drift. */
 type ViolationCode = Violation["code"];
 /** Canonical structured representation of a policy. */
@@ -427,7 +444,7 @@ declare function inspect(desc: Uint8Array, offset: number): TypeInfo;
  * @param desc - Raw descriptor bytes.
  * @param steps - Path steps, length >= 1.
  * @returns TypeInfo for the node at the resolved path.
- * @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
+ * @throws {CallciumError} On empty steps, out-of-bounds param or array index, or descent into elementary type.
  */
 declare function typeAt(desc: Uint8Array, steps: number[]): TypeInfo;
 /**
@@ -437,7 +454,7 @@ declare function typeAt(desc: Uint8Array, steps: number[]): TypeInfo;
  * @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.
+ * @throws {CallciumError} On empty steps, out-of-bounds param or array index, or descent into elementary type.
  */
 declare function walkPath(desc: Uint8Array, steps: number[]): {
   typeInfo: TypeInfo;
@@ -484,6 +501,8 @@ declare function isOpAllowed(opCode: number, typeInfo: TypeInfo): boolean;
  * Validate a policy for type mismatches, contradictions, redundancies, and vacuities.
  * @param data - The canonical policy data to validate.
  * @returns All validation issues found, ordered by group and constraint index.
+ * @throws {CallciumError} If the descriptor is not well-formed; semantic validation is
+ * defined only over a well-formed descriptor.
  */
 declare function validate(data: PolicyData): Issue[];
 /** Semantic validation for policies. */
@@ -835,5 +854,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, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, gasPrice, 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, type NonCanonicalValueViolation, 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

@@ -574,7 +574,7 @@ function inspect$1(desc, offset) {
 * @param desc - Raw descriptor bytes.
 * @param steps - Path steps, length >= 1.
 * @returns TypeInfo for the node at the resolved path.
-* @throws {CallciumError} On empty steps, out-of-bounds param, or descent into elementary type.
+* @throws {CallciumError} On empty steps, out-of-bounds param or array index, or descent into elementary type.
 */
 function typeAt(desc, steps) {
 	return walkPath(desc, steps).typeInfo;
@@ -586,7 +586,7 @@ function typeAt(desc, steps) {
 * @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.
+* @throws {CallciumError} On empty steps, out-of-bounds param or array index, 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.");
@@ -603,7 +603,11 @@ function walkPath(desc, steps) {
 			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) {
-			if (typeCode === TypeCode.STATIC_ARRAY && isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
+			if (typeCode === TypeCode.STATIC_ARRAY) if (isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
+			else {
+				const length = staticArrayLength(desc, cursor);
+				if (step >= length) throw new CallciumError("INVALID_PATH", `Array index ${step} out of range (length=${length}).`);
+			}
 			cursor = arrayElementOffset(cursor);
 		} else throw new CallciumError("INVALID_PATH", `Cannot descend into elementary type at offset ${cursor}.`);
 	}
@@ -807,6 +811,7 @@ function commaPositions(input, start, end) {
 */
 function parseUint(input, start, end) {
 	if (start >= end) return -1;
+	if (end - start > 1 && input.charCodeAt(start) === 48) return -1;
 	let value = 0;
 	for (let i = start; i < end; i++) {
 		const code = input.charCodeAt(i);
@@ -1612,6 +1617,19 @@ function fromOpRule(code, message, groupIndex, constraintIndex, opCode) {
 		message
 	};
 }
+/** Issue for a calldata path that does not navigate the descriptor. */
+function unnavigablePath(groupIndex, constraintIndex) {
+	return {
+		severity: "error",
+		category: "typeMismatch",
+		groupIndex,
+		constraintIndex,
+		code: "UNNAVIGABLE_PATH",
+		value1: ZERO,
+		value2: ZERO,
+		message: "Path does not navigate the descriptor"
+	};
+}
 /** Issue for an operand that is not canonically encoded for the declared type. */
 function nonCanonicalOperand(groupIndex, constraintIndex, operand, canonical) {
 	return {
@@ -1937,6 +1955,19 @@ function vacuousLte(isLength, groupIndex, constraintIndex, value) {
 		message: isLength ? "lengthLte() bound equals maximum (always true)" : "lte() bound equals type maximum (always true)"
 	};
 }
+/** Negated range with inverted bounds excludes nothing (always true). */
+function vacuousNegatedRange(isLength, groupIndex, constraintIndex, low, high) {
+	return {
+		severity: "info",
+		category: "vacuity",
+		groupIndex,
+		constraintIndex,
+		code: isLength ? "VACUOUS_NEGATED_LENGTH_RANGE" : "VACUOUS_NEGATED_RANGE",
+		value1: low,
+		value2: high,
+		message: isLength ? "Negated lengthBetween() with low > high excludes nothing (always true)" : "Negated between() with low > high excludes nothing (always true)"
+	};
+}
 /** Path deeper than the reference enforcer's cap. */
 function pathDepthExceeded(groupIndex, constraintIndex, depth, maxDepth) {
 	return {
@@ -1992,20 +2023,8 @@ function negationUnderAny(groupIndex, constraintIndex, opCode) {
 //#endregion
 //#region src/policy-validator.ts
 /**
-* Maximum number of tracked "holes" (neq exclusions) and notIn values per
-* domain. A hole is a single value excluded via a negated equality (neq).
-* During cross-operator analysis, holes punch values out of isIn sets — if
-* every member of an isIn set is excluded by holes or notIn, the constraint
-* is unsatisfiable (SET_FULLY_EXCLUDED). When only some are excluded, the
-* validator emits SET_PARTIALLY_EXCLUDED.
-*
-* Both caps are protocol-defined limits. Beyond these limits,
-* additional exclusions are silently ignored — the validator becomes
-* best-effort for set-reduction diagnostics but never produces false
-* positives, only potential false negatives (missed redundancy warnings).
+* Maximum length value for dynamic types.
 */
-const MAX_HOLES = 8;
-const MAX_NOT_IN = 8;
 const LENGTH_MAX = 4294967295n;
 const UINT256_MAX = (1n << 256n) - 1n;
 const INT256_SIGN_BIT = 1n << 255n;
@@ -2220,7 +2239,7 @@ function updateBound(domain, base, isNegated, value, isLength, groupIndex, const
 				alreadyHole = true;
 				break;
 			}
-			if (!alreadyHole && domain.holes.length < MAX_HOLES) domain.holes.push(value);
+			if (!alreadyHole) domain.holes.push(value);
 		} else updateBound(domain, negateBoundOp(base), false, value, isLength, groupIndex, constraintIndex, issues);
 		return;
 	}
@@ -2352,10 +2371,11 @@ function updateSet(ctx, isNegated, values, groupIndex, constraintIndex, issues)
 				}
 				if (inSet) issues.push(setReduction(groupIndex, constraintIndex, bigintToHex(value)));
 			}
-			if (ctx.set.notInValues.length < MAX_NOT_IN) ctx.set.notInValues.push(value);
+			ctx.set.notInValues.push(value);
 		}
 		checkSetEmpty(ctx, groupIndex, constraintIndex, issues);
 	} else {
+		for (const value of values) if (signedCompare(value, ctx.numeric.min, ctx.numeric.isSigned) < 0n || signedCompare(value, ctx.numeric.max, ctx.numeric.isSigned) > 0n) issues.push(outOfPhysicalBounds(false, groupIndex, constraintIndex, bigintToHex(value)));
 		if (ctx.numeric.hasEq) {
 			let found = false;
 			for (const candidate of values) if (candidate === ctx.numeric.eq) {
@@ -2455,11 +2475,11 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 				}
 			}
 			if (base >= Op.EQ && base <= Op.BETWEEN) if (base === Op.BETWEEN) {
+				const { low, high } = readPair(opHex);
 				if (!isNegated) {
-					const { low, high } = readPair(opHex);
 					updateBound(ctx.numeric, Op.GTE, false, low, false, groupIndex, constraintIndex, issues);
 					updateBound(ctx.numeric, Op.LTE, false, high, false, groupIndex, constraintIndex, issues);
-				}
+				} else if (signedCompare(low, high, ctx.numeric.isSigned) > 0n) issues.push(vacuousNegatedRange(false, groupIndex, constraintIndex, bigintToHex(low), bigintToHex(high)));
 			} else {
 				const value = readValue(opHex);
 				const holesBefore = ctx.numeric.holes.length;
@@ -2473,11 +2493,11 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 				else updateSet(ctx, isNegated, values, groupIndex, constraintIndex, issues);
 			}
 		} else if (isLengthOp(base)) if (base === Op.LENGTH_BETWEEN) {
+			const { low, high } = readPair(opHex);
 			if (!isNegated) {
-				const { low, high } = readPair(opHex);
 				updateBound(ctx.length, Op.GTE, false, low, true, groupIndex, constraintIndex, issues);
 				updateBound(ctx.length, Op.LTE, false, high, true, groupIndex, constraintIndex, issues);
-			}
+			} else if (low > high) issues.push(vacuousNegatedRange(true, groupIndex, constraintIndex, bigintToHex(low), bigintToHex(high)));
 		} else {
 			const value = readValue(opHex);
 			updateBound(ctx.length, normalizeLengthOp(base), isNegated, value, true, groupIndex, constraintIndex, issues);
@@ -2502,7 +2522,16 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			if (constraint.scope === Scope.CALLDATA) {
 				const steps = parsePathSteps(constraint.path);
 				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);
+				let walk;
+				try {
+					walk = Descriptor.walkPath(descBytes, steps);
+				} catch (error) {
+					if (error instanceof CallciumError && error.code === "INVALID_PATH") {
+						issues.push(unnavigablePath(groupIndex, constraintIndex));
+						continue;
+					}
+					throw error;
+				}
 				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 {
@@ -2531,10 +2560,13 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 * Validate a policy for type mismatches, contradictions, redundancies, and vacuities.
 * @param data - The canonical policy data to validate.
 * @returns All validation issues found, ordered by group and constraint index.
+* @throws {CallciumError} If the descriptor is not well-formed; semantic validation is
+* defined only over a well-formed descriptor.
 */
 function validate(data) {
 	const issues = [];
 	const descBytes = hexToBytes(data.descriptor);
+	decodeDescriptor(descBytes);
 	for (let groupIndex = 0; groupIndex < data.groups.length; groupIndex++) {
 		if (data.groups[groupIndex].length === 0) {
 			issues.push(emptyGroup(groupIndex));
@@ -3285,10 +3317,11 @@ function descendPath(callData, location, pathBytes) {
 }
 //#endregion
 //#region src/policy-enforcer.ts
-/** Violations that abort evaluation instead of failing only their group (spec §10.3). */
+/** Violations that abort evaluation instead of failing only their group (spec §9.3). */
 const ABORT_VIOLATION_CODES = new Set([
 	"CALLDATA_OUT_OF_BOUNDS",
 	"ARRAY_INDEX_OUT_OF_BOUNDS",
+	"NON_CANONICAL_VALUE",
 	"QUANTIFIER_LIMIT_EXCEEDED"
 ]);
 /** Convert a hex address to a 256-bit bigint (zero-padded to 32 bytes). */
@@ -3461,7 +3494,11 @@ function applyLeafOperator(callDataBytes, location, opCode, operandData) {
 	if (node.isDynamic || node.type !== "elementary") throw new CallciumError("NOT_SCALAR", "Value operator on a target without a scalar word.");
 	const result = loadScalar(callDataBytes, location);
 	if (!result.ok) return { error: result.code };
-	const value = canonicalize(toBigInt(result.value, 0), node.typeCode);
+	const value = toBigInt(result.value, 0);
+	if (canonicalize(value, node.typeCode) !== value) return {
+		error: "NON_CANONICAL_VALUE",
+		resolvedValue: bigintToHex(value)
+	};
 	return {
 		passed: applyOperator(opCode, value, 32, operandData, node.typeCode),
 		resolvedValue: bigintToHex(value)
@@ -3471,16 +3508,29 @@ function applyLeafOperator(callDataBytes, location, opCode, operandData) {
 function evaluateLeaf(location, callDataBytes, opCode, operandData, groupIndex, ruleIndex, pathHex) {
 	const result = applyLeafOperator(callDataBytes, location, opCode, operandData);
 	const typeCode = location.node.typeCode;
-	if ("error" in result) return {
-		group: groupIndex,
-		rule: ruleIndex,
-		code: result.error,
-		scope: Scope.CALLDATA,
-		path: pathHex,
-		opCode,
-		operandData: bytesToHex(operandData),
-		typeCode
-	};
+	if ("error" in result) {
+		if (result.error === "NON_CANONICAL_VALUE") return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: result.error,
+			scope: Scope.CALLDATA,
+			path: pathHex,
+			opCode,
+			operandData: bytesToHex(operandData),
+			typeCode,
+			resolvedValue: result.resolvedValue
+		};
+		return {
+			group: groupIndex,
+			rule: ruleIndex,
+			code: result.error,
+			scope: Scope.CALLDATA,
+			path: pathHex,
+			opCode,
+			operandData: bytesToHex(operandData),
+			typeCode
+		};
+	}
 	if (!result.passed) return {
 		group: groupIndex,
 		rule: ruleIndex,
@@ -3570,6 +3620,18 @@ function evaluateQuantifier(qResult, callDataBytes, opCode, operandData, groupIn
 		} else leafLocation = elemLocation;
 		const applied = applyLeafOperator(callDataBytes, leafLocation, opCode, operandData);
 		if ("error" in applied) {
+			if (applied.error === "NON_CANONICAL_VALUE") return {
+				group: groupIndex,
+				rule: ruleIndex,
+				code: applied.error,
+				scope: Scope.CALLDATA,
+				path: pathHex,
+				opCode,
+				operandData: operandHex,
+				typeCode: leafTypeCode,
+				elementIndex: elemIndex,
+				resolvedValue: applied.resolvedValue
+			};
 			if (isUniversal) return {
 				group: groupIndex,
 				rule: ruleIndex,