@callcium/sdk 0.10.0 → 0.11.1

package/dist/index.js

@@ -1,4 +1,5 @@
 import { keccak_256 } from "@noble/hashes/sha3.js";
+import { utf8ToBytes } from "@noble/hashes/utils.js";
 //#region src/errors.ts
 var CallciumError = class extends Error {
 	code;
@@ -8,6 +9,7 @@ var CallciumError = class extends Error {
 		super(`${prefix}${message}`);
 		this.name = "CallciumError";
 		this.code = code;
+		if (offset !== void 0) this.offset = offset;
 	}
 };
 var ValidationError = class extends CallciumError {
@@ -115,6 +117,11 @@ const DescriptorFormat = {
 	MAX_NESTING_DEPTH: 64
 };
 const RULE_DATALENGTH_SIZE = 2;
+const PATH_STEP_SIZE = 2;
+const RULE_FIXED_OVERHEAD = 7;
+function fieldMax(byteWidth) {
+	return 256 ** byteWidth - 1;
+}
 const PolicyFormat = {
 	VERSION: 2,
 	VERSION_MASK: 15,
@@ -134,11 +141,12 @@ const PolicyFormat = {
 	RULE_SCOPE_OFFSET: 2,
 	RULE_DEPTH_OFFSET: 3,
 	RULE_PATH_OFFSET: 4,
-	PATH_STEP_SIZE: 2,
+	PATH_STEP_SIZE,
+	PATH_STEP_MAX: fieldMax(PATH_STEP_SIZE),
 	RULE_OPCODE_SIZE: 1,
 	RULE_DATALENGTH_SIZE,
-	RULE_FIXED_OVERHEAD: 7,
-	RULE_MIN_SIZE: 9,
+	RULE_FIXED_OVERHEAD,
+	RULE_MIN_SIZE: RULE_FIXED_OVERHEAD + PATH_STEP_SIZE,
 	HINT_HEADER_SIZE: 1,
 	HINT_HOP_SIZE: 8,
 	HINT_HOP_INDEX_OFFSET: 4,
@@ -164,10 +172,14 @@ const PolicyFormat = {
 	HINT_META_STRIDE_MASK: 4095,
 	MAX_PATH_DEPTH: 32,
 	MAX_QUANTIFIED_ARRAY_LENGTH: 256,
-	MAX_SET_MEMBERS: Math.floor((256 ** RULE_DATALENGTH_SIZE - 1) / 32)
+	MAX_SET_MEMBERS: Math.floor(fieldMax(RULE_DATALENGTH_SIZE) / 32)
 };
+function formatCode(code, byteWidth) {
+	if (!Number.isInteger(code) || code < 0 || code > fieldMax(byteWidth)) return String(code);
+	return `0x${code.toString(16).padStart(byteWidth * 2, "0")}`;
+}
 function buildCodeMap(table) {
-	return Object.fromEntries(table.map((e) => [e.key, e.code]));
+	return Object.fromEntries(table.map((entry) => [entry.key, entry.code]));
 }
 const SCOPE_TABLE = [{
 	key: "CONTEXT",
@@ -179,7 +191,7 @@ const SCOPE_TABLE = [{
 	label: "calldata"
 }];
 const Scope = buildCodeMap(SCOPE_TABLE);
-const scopeByCode = new Map(SCOPE_TABLE.map((e) => [e.code, { label: e.label }]));
+const scopeByCode = new Map(SCOPE_TABLE.map((entry) => [entry.code, { label: entry.label }]));
 function lookupScope(code) {
 	const info = scopeByCode.get(code);
 	if (!info) throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${code}`);
@@ -260,15 +272,18 @@ const CTX_PROPERTY_TABLE = [
 	}
 ];
 const ContextProperty = buildCodeMap(CTX_PROPERTY_TABLE);
-const MAX_CONTEXT_PROPERTY_ID = Math.max(...CTX_PROPERTY_TABLE.map((e) => e.code));
-const ctxPropertyByCode = new Map(CTX_PROPERTY_TABLE.map((e) => [e.code, {
-	label: e.label,
-	contextKey: e.contextKey,
-	typeCode: e.typeCode
+const MAX_CONTEXT_PROPERTY_ID = Math.max(...CTX_PROPERTY_TABLE.map((entry) => entry.code));
+const ctxPropertyByCode = new Map(CTX_PROPERTY_TABLE.map((entry) => [entry.code, {
+	label: entry.label,
+	contextKey: entry.contextKey,
+	typeCode: entry.typeCode
 }]));
+function findContextProperty(code) {
+	return ctxPropertyByCode.get(code);
+}
 function lookupContextProperty(code) {
 	const info = ctxPropertyByCode.get(code);
-	if (!info) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Unknown context property ${code}`);
+	if (!info) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Unknown context property ID ${formatCode(code, PATH_STEP_SIZE)}`);
 	return info;
 }
 const OP_TABLE = [
@@ -379,14 +394,14 @@ const Op = {
 	...buildCodeMap(OP_TABLE),
 	NOT: 128
 };
-const opByCode = new Map(OP_TABLE.map((e) => [e.code, {
-	label: e.label,
-	operands: e.operands
+const opByCode = new Map(OP_TABLE.map((entry) => [entry.code, {
+	label: entry.label,
+	operands: entry.operands
 }]));
 function lookupOp(code) {
 	const base = code & ~Op.NOT;
 	const info = opByCode.get(base);
-	if (!info) throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}`);
+	if (!info) throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code ${formatCode(base, PolicyFormat.RULE_OPCODE_SIZE)}`);
 	return info;
 }
 function operandsOf(opBase) {
@@ -404,18 +419,22 @@ const QUANTIFIER_TABLE = [{
 	label: "any"
 }];
 const Quantifier = buildCodeMap(QUANTIFIER_TABLE);
-const quantifierByCode = new Map(QUANTIFIER_TABLE.map((e) => [e.code, { label: e.label }]));
+const quantifierByCode = new Map(QUANTIFIER_TABLE.map((entry) => [entry.code, { label: entry.label }]));
 function isQuantifier(step) {
 	return step >= Quantifier.ANY;
 }
 function lookupQuantifier(code) {
 	const info = quantifierByCode.get(code);
-	if (!info) throw new CallciumError("UNKNOWN_QUANTIFIER", `Unknown quantifier step 0x${code.toString(16)}`);
+	if (!info) throw new CallciumError("UNKNOWN_QUANTIFIER", `Unknown quantifier step ${formatCode(code, PolicyFormat.PATH_STEP_SIZE)}`);
 	return info;
 }
 function encodePath(steps) {
-	const buffer = new Uint8Array(steps.length * 2);
-	for (let i = 0; i < steps.length; i++) writeBE16(buffer, i * 2, steps[i]);
+	const buffer = new Uint8Array(steps.length * PolicyFormat.PATH_STEP_SIZE);
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i];
+		if (!Number.isInteger(step) || step < 0 || step > PolicyFormat.PATH_STEP_MAX) throw new CallciumError("PATH_STEP_OVERFLOW", `Path step ${step} is outside the path step field`);
+		writeBE16(buffer, i * PolicyFormat.PATH_STEP_SIZE, step);
+	}
 	return bytesToHex(buffer);
 }
 function parsePathSteps(path) {
@@ -426,221 +445,181 @@ function parsePathSteps(path) {
 	return steps;
 }
 //#endregion
-//#region src/descriptor.ts
-function nodeLength(desc, offset) {
-	if (desc[offset] < TypeCode.STATIC_ARRAY) return DescriptorFormat.TYPECODE_SIZE;
-	return readU24(desc, offset + 1) & DescriptorFormat.META_NODE_LENGTH_MASK;
-}
-function tupleFieldOffset(desc, tupleOffset, fieldIndex) {
-	let cursor = tupleOffset + DescriptorFormat.TUPLE_HEADER_SIZE;
-	for (let i = 0; i < fieldIndex; i++) cursor += nodeLength(desc, cursor);
-	return cursor;
+//#region src/constraint.ts
+const OPERAND_MIN = -(2n ** 255n);
+const OPERAND_MAX = 2n ** 256n - 1n;
+function checkOperandRange(value) {
+	if (value < OPERAND_MIN || value > OPERAND_MAX) throw new CallciumError("OPERAND_OVERFLOW", `Operand ${value} is outside the range a 32-byte word represents`);
+	return value;
 }
-function paramCount(desc) {
-	return desc[1];
+function addressBody(value) {
+	return toAddress(value).slice(2);
 }
-function paramOffset(desc, index) {
-	const count = desc[1];
-	if (index >= count) throw new CallciumError("PARAM_INDEX_OUT_OF_BOUNDS", `Param index ${index} out of range (paramCount=${count})`);
-	let cursor = DescriptorFormat.HEADER_SIZE;
-	for (let i = 0; i < index; i++) cursor += nodeLength(desc, cursor);
-	return cursor;
+function encodeWord(value) {
+	const word = new Uint8Array(32);
+	if (typeof value === "boolean") {
+		word[31] = value ? 1 : 0;
+		return word;
+	}
+	if (typeof value === "string") {
+		word.set(hexToBytes(addressBody(value)), 12);
+		return word;
+	}
+	let bigValue = checkOperandRange(value);
+	for (let i = 31; i >= 0; i--) {
+		word[i] = Number(bigValue & 255n);
+		bigValue >>= 8n;
+	}
+	return word;
 }
-function inspect$1(desc, offset) {
-	const typeCode = desc[offset];
-	let staticWords;
-	if (typeCode < TypeCode.STATIC_ARRAY) staticWords = typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING ? 0 : 1;
-	else staticWords = readU24(desc, offset + 1) >> DescriptorFormat.META_STATIC_WORDS_SHIFT;
-	return {
-		typeCode,
-		isDynamic: staticWords === 0,
-		staticSize: staticWords * 32
-	};
+function singleOp(opCode, value) {
+	const buffer = new Uint8Array(33);
+	buffer[0] = opCode;
+	buffer.set(encodeWord(value), 1);
+	return bytesToHex(buffer);
 }
-function typeAt(desc, steps) {
-	return walkPath(desc, steps).typeInfo;
+function rangeOp(opCode, min, max) {
+	const minValue = checkOperandRange(min);
+	const maxValue = checkOperandRange(max);
+	if (minValue > maxValue) throw new CallciumError("INVALID_RANGE", `Range min (${minValue}) must not exceed max (${maxValue})`);
+	const buffer = new Uint8Array(65);
+	buffer[0] = opCode;
+	buffer.set(encodeWord(minValue), 1);
+	buffer.set(encodeWord(maxValue), 33);
+	return bytesToHex(buffer);
 }
-function walkPath(desc, steps) {
-	if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step");
-	const paramIndex = steps[0];
-	const count = desc[1];
-	if (paramIndex >= count) throw new CallciumError("PARAM_INDEX_OUT_OF_BOUNDS", `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];
-		if (typeCode === TypeCode.TUPLE) {
-			const fields = tupleFieldCount(desc, cursor);
-			if (step >= fields) throw new CallciumError("TUPLE_FIELD_OUT_OF_BOUNDS", `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) if (isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
-			else {
-				const length = staticArrayLength(desc, cursor);
-				if (step >= length) throw new CallciumError("STATIC_ARRAY_INDEX_OUT_OF_BOUNDS", `Array index ${step} out of range (length=${length})`);
-			}
-			cursor = arrayElementOffset(cursor);
-		} else throw new CallciumError("NOT_COMPOSITE", `Cannot descend into elementary type at offset ${cursor}`);
-	}
-	return {
-		typeInfo: inspect$1(desc, cursor),
-		quantifiedStaticLength
-	};
+function contextOperand(contextPropertyId) {
+	lookupContextProperty(contextPropertyId);
+	return BigInt(contextPropertyId);
 }
-function tupleFieldCount(desc, offset) {
-	return readU16(desc, offset + 4);
+function setOp(opCode, values) {
+	const words = values.map((value) => {
+		if (typeof value === "bigint") return BigInt.asUintN(256, checkOperandRange(value));
+		if (typeof value === "boolean") return value ? 1n : 0n;
+		return BigInt("0x" + addressBody(value));
+	});
+	const deduped = [...new Set(words)].toSorted((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	if (deduped.length === 0) throw new CallciumError("EMPTY_SET", "Set must contain at least one value");
+	if (deduped.length > PolicyFormat.MAX_SET_MEMBERS) throw new CallciumError("SET_TOO_LARGE", `Set must contain at most ${PolicyFormat.MAX_SET_MEMBERS} values`);
+	const buffer = new Uint8Array(1 + deduped.length * 32);
+	buffer[0] = opCode;
+	for (let i = 0; i < deduped.length; i++) buffer.set(encodeWord(deduped[i]), 1 + i * 32);
+	return bytesToHex(buffer);
 }
-function staticArrayLength(desc, offset) {
-	const elemOffset = arrayElementOffset(offset);
-	return readU16(desc, elemOffset + nodeLength(desc, elemOffset));
+function readOperandExtremes(constraint) {
+	return "operandExtremes" in constraint ? constraint.operandExtremes : void 0;
 }
-function arrayElementOffset(offset) {
-	return offset + DescriptorFormat.ARRAY_HEADER_SIZE;
+var ConstraintBuilder = class {
+	scope;
+	path;
+	operators;
+	operandExtremes;
+	constructor(scope, path) {
+		this.scope = scope;
+		this.path = path;
+		this.operators = [];
+		this.operandExtremes = {
+			leastNegative: 0n,
+			greatest: 0n
+		};
+	}
+	push(opHex, values = []) {
+		for (const value of values) {
+			if (typeof value !== "bigint") continue;
+			if (value < this.operandExtremes.leastNegative) this.operandExtremes.leastNegative = value;
+			if (value > this.operandExtremes.greatest) this.operandExtremes.greatest = value;
+		}
+		this.operators.push(opHex);
+		return this;
+	}
+	eq(value) {
+		return this.push(singleOp(Op.EQ, value), [value]);
+	}
+	neq(value) {
+		return this.push(singleOp(Op.EQ | Op.NOT, value), [value]);
+	}
+	eqCtx(contextPropertyId) {
+		return this.push(singleOp(Op.EQ_CTX, contextOperand(contextPropertyId)));
+	}
+	neqCtx(contextPropertyId) {
+		return this.push(singleOp(Op.EQ_CTX | Op.NOT, contextOperand(contextPropertyId)));
+	}
+	gt(bound) {
+		return this.push(singleOp(Op.GT, bound), [bound]);
+	}
+	lt(bound) {
+		return this.push(singleOp(Op.LT, bound), [bound]);
+	}
+	gte(bound) {
+		return this.push(singleOp(Op.GTE, bound), [bound]);
+	}
+	lte(bound) {
+		return this.push(singleOp(Op.LTE, bound), [bound]);
+	}
+	between(min, max) {
+		return this.push(rangeOp(Op.BETWEEN, min, max), [min, max]);
+	}
+	isIn(values) {
+		return this.push(setOp(Op.IN, values), values);
+	}
+	notIn(values) {
+		return this.push(setOp(Op.IN | Op.NOT, values), values);
+	}
+	bitmaskAll(mask) {
+		return this.push(singleOp(Op.BITMASK_ALL, mask));
+	}
+	bitmaskAny(mask) {
+		return this.push(singleOp(Op.BITMASK_ANY, mask));
+	}
+	bitmaskNone(mask) {
+		return this.push(singleOp(Op.BITMASK_NONE, mask));
+	}
+	lengthEq(length) {
+		return this.push(singleOp(Op.LENGTH_EQ, length));
+	}
+	lengthGt(length) {
+		return this.push(singleOp(Op.LENGTH_GT, length));
+	}
+	lengthLt(length) {
+		return this.push(singleOp(Op.LENGTH_LT, length));
+	}
+	lengthGte(length) {
+		return this.push(singleOp(Op.LENGTH_GTE, length));
+	}
+	lengthLte(length) {
+		return this.push(singleOp(Op.LENGTH_LTE, length));
+	}
+	lengthBetween(min, max) {
+		return this.push(rangeOp(Op.LENGTH_BETWEEN, min, max));
+	}
+};
+function arg(...steps) {
+	return new ConstraintBuilder(Scope.CALLDATA, encodePath(steps));
 }
-function uncompilablePath(stepIndex) {
-	return new CallciumError("UNCOMPILABLE_PATH", `Path step ${stepIndex} does not resolve to a hop-chain target`);
+function msgSender() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.MSG_SENDER]));
 }
-function headSpan(desc, offset, count) {
-	let span = 0;
-	let nodeOffset = offset;
-	for (let i = 0; i < count; i++) {
-		const node = inspect$1(desc, nodeOffset);
-		span += node.isDynamic ? 32 : node.staticSize;
-		nodeOffset += nodeLength(desc, nodeOffset);
-	}
-	return {
-		span,
-		nodeOffset
-	};
+function msgValue() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.MSG_VALUE]));
 }
-function arrayMeta(desc, arrayOffset, code) {
-	const element = inspect$1(desc, arrayElementOffset(arrayOffset));
-	let meta = element.isDynamic ? 1 : element.staticSize >> 5;
-	if (element.isDynamic) meta |= PolicyFormat.HINT_META_ELEM_DYNAMIC;
-	if (code === TypeCode.DYNAMIC_ARRAY) meta |= PolicyFormat.HINT_META_DYNAMIC_ARRAY;
-	return {
-		meta,
-		elemIsDynamic: element.isDynamic
-	};
+function blockTimestamp() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BLOCK_TIMESTAMP]));
 }
-function enterNode(walk, needed) {
-	if (!needed) return;
-	walk.chain.push([
-		walk.delta,
-		PolicyFormat.HINT_NO_INDEX,
-		0
-	]);
-	walk.delta = 0;
+function blockNumber() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BLOCK_NUMBER]));
 }
-function walkStep(desc, walk, descOffset, step, stepIndex) {
-	const node = inspect$1(desc, descOffset);
-	if (node.typeCode === TypeCode.TUPLE) {
-		if (step >= tupleFieldCount(desc, descOffset)) throw uncompilablePath(stepIndex);
-		enterNode(walk, node.isDynamic && !walk.entered);
-		const field = headSpan(desc, descOffset + DescriptorFormat.TUPLE_HEADER_SIZE, step);
-		walk.delta += field.span;
-		walk.entered = false;
-		return field.nodeOffset;
-	}
-	if (node.typeCode !== TypeCode.STATIC_ARRAY && node.typeCode !== TypeCode.DYNAMIC_ARRAY) throw uncompilablePath(stepIndex);
-	if (node.typeCode === TypeCode.STATIC_ARRAY && !isQuantifier(step) && step >= staticArrayLength(desc, descOffset)) throw uncompilablePath(stepIndex);
-	const { meta, elemIsDynamic } = arrayMeta(desc, descOffset, node.typeCode);
-	if (isQuantifier(step)) {
-		if (walk.kind !== PolicyFormat.HINT_KIND_NONE) throw uncompilablePath(stepIndex);
-		enterNode(walk, node.isDynamic && !walk.entered);
-		const count = node.typeCode === TypeCode.DYNAMIC_ARRAY ? 0 : staticArrayLength(desc, descOffset);
-		walk.frame = {
-			arrayDelta: walk.delta,
-			count,
-			meta
-		};
-		walk.kind = step === Quantifier.ALL ? PolicyFormat.HINT_KIND_ALL : PolicyFormat.HINT_KIND_ANY;
-		walk.mainHops = walk.chain;
-		walk.chain = [];
-		walk.delta = 0;
-	} else if (node.isDynamic) {
-		enterNode(walk, !walk.entered);
-		walk.chain.push([
-			0,
-			step,
-			meta
-		]);
-		walk.delta = 0;
-	} else walk.delta += step * (meta & PolicyFormat.HINT_META_STRIDE_MASK) * 32;
-	walk.entered = elemIsDynamic;
-	return arrayElementOffset(descOffset);
+function chainId() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.CHAIN_ID]));
 }
-function writeHops(out, offset, hops) {
-	for (const [delta, index, meta] of hops) {
-		writeBE32(out, offset, delta);
-		writeBE16(out, offset + PolicyFormat.HINT_HOP_INDEX_OFFSET, index);
-		writeBE16(out, offset + PolicyFormat.HINT_HOP_META_OFFSET, meta);
-		offset += PolicyFormat.HINT_HOP_SIZE;
-	}
-	return offset;
+function txOrigin() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.TX_ORIGIN]));
 }
-function encodeHint(walk, targetMeta, typeCode, depth) {
-	let suffixHops = [];
-	if (walk.kind === PolicyFormat.HINT_KIND_NONE) walk.mainHops = walk.chain;
-	else suffixHops = walk.chain;
-	const mainHopCount = walk.mainHops.length;
-	const suffixHopCount = suffixHops.length;
-	if (mainHopCount > PolicyFormat.HINT_HOP_COUNT_MASK || suffixHopCount > PolicyFormat.HINT_HOP_COUNT_MASK) throw uncompilablePath(depth);
-	const quantified = walk.kind !== PolicyFormat.HINT_KIND_NONE;
-	const frameSize = quantified ? PolicyFormat.HINT_FRAME_PREFIX_SIZE + PolicyFormat.HINT_HEADER_SIZE + suffixHopCount * PolicyFormat.HINT_HOP_SIZE : 0;
-	const out = new Uint8Array(PolicyFormat.HINT_HEADER_SIZE + mainHopCount * PolicyFormat.HINT_HOP_SIZE + frameSize + PolicyFormat.HINT_TARGET_SIZE);
-	let offset = 0;
-	out[offset] = walk.kind << PolicyFormat.HINT_KIND_SHIFT | mainHopCount;
-	offset = writeHops(out, offset + PolicyFormat.HINT_HEADER_SIZE, walk.mainHops);
-	if (quantified) {
-		writeBE32(out, offset, walk.frame.arrayDelta);
-		writeBE16(out, offset + PolicyFormat.HINT_FRAME_COUNT_OFFSET, walk.frame.count);
-		writeBE16(out, offset + PolicyFormat.HINT_FRAME_META_OFFSET, walk.frame.meta);
-		out[offset + PolicyFormat.HINT_FRAME_PREFIX_SIZE] = suffixHopCount;
-		offset = writeHops(out, offset + PolicyFormat.HINT_FRAME_PREFIX_SIZE + PolicyFormat.HINT_HEADER_SIZE, suffixHops);
-	}
-	writeBE32(out, offset, walk.delta);
-	writeBE16(out, offset + PolicyFormat.HINT_TARGET_META_OFFSET, targetMeta);
-	out[offset + PolicyFormat.HINT_TARGET_TYPECODE_OFFSET] = typeCode;
-	return out;
+function baseFee() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BASE_FEE]));
 }
-function compileHint(desc, steps) {
-	if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step");
-	const argIndex = steps[0];
-	if (argIndex >= paramCount(desc)) throw uncompilablePath(0);
-	const arg = headSpan(desc, DescriptorFormat.HEADER_SIZE, argIndex);
-	const walk = {
-		chain: [],
-		mainHops: [],
-		delta: arg.span,
-		frame: {
-			arrayDelta: 0,
-			count: 0,
-			meta: 0
-		},
-		kind: PolicyFormat.HINT_KIND_NONE,
-		entered: false
-	};
-	let descOffset = arg.nodeOffset;
-	for (let stepIndex = 1; stepIndex < steps.length; stepIndex++) descOffset = walkStep(desc, walk, descOffset, steps[stepIndex], stepIndex);
-	const target = inspect$1(desc, descOffset);
-	enterNode(walk, target.isDynamic && !walk.entered);
-	return encodeHint(walk, target.typeCode === TypeCode.DYNAMIC_ARRAY ? arrayMeta(desc, descOffset, target.typeCode).meta : 0, target.typeCode, steps.length);
+function gasPrice() {
+	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.GAS_PRICE]));
 }
-const Descriptor = {
-	paramCount,
-	paramOffset,
-	inspect: inspect$1,
-	typeAt,
-	tupleFieldOffset,
-	tupleFieldCount,
-	staticArrayLength,
-	nodeLength,
-	arrayElementOffset,
-	walkPath,
-	compileHint
-};
 //#endregion
 //#region src/operators.ts
 function toBigInt(bytes, offset = 0) {
@@ -712,7 +691,7 @@ function isIn(value, data) {
 function applyOperator(opCode, value, valueLength, operandData, typeCode) {
 	let base = opCode & ~Op.NOT;
 	if (isLengthOp(base)) {
-		value = BigInt(valueLength);
+		value = valueLength;
 		typeCode = TypeCode.UINT_MAX;
 		base = lengthToValueOp(base);
 	}
@@ -757,7 +736,7 @@ function applyOperator(opCode, value, valueLength, operandData, typeCode) {
 			result = (value & mask) === 0n;
 			break;
 		}
-		default: throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}`);
+		default: throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code ${formatCode(base, PolicyFormat.RULE_OPCODE_SIZE)}`);
 	}
 	return (opCode & Op.NOT) !== 0 ? !result : result;
 }
@@ -768,8 +747,13 @@ function isValidOperatorData(opBase, dataLength) {
 	if (operands === "variadic") return dataLength > 0 && dataLength % 32 === 0;
 	return false;
 }
+function toOperatorBytes(operator) {
+	const bytes = hexToBytes(operator);
+	if (bytes.length < 1) throw new CallciumError("INVALID_OPERATOR_BYTES", "Operator must have at least one byte (opcode)");
+	return bytes;
+}
 function unknownTypeCode(code) {
-	throw new CallciumError("UNKNOWN_TYPE_CODE", `Unknown type code 0x${code.toString(16).padStart(2, "0")}`);
+	throw new CallciumError("UNKNOWN_TYPE_CODE", `Unknown type code ${formatCode(code, DescriptorFormat.TYPECODE_SIZE)}`);
 }
 const ELEMENTARY = {
 	typeClass: "elementary",
@@ -805,6 +789,13 @@ function classifyTypeCode(code) {
 	if (code === TypeCode.TUPLE) return TUPLE;
 	unknownTypeCode(code);
 }
+function isElementary(code) {
+	try {
+		return classifyTypeCode(code).typeClass === "elementary";
+	} catch {
+		return false;
+	}
+}
 function isAddressableTarget(code) {
 	let info;
 	try {
@@ -828,12 +819,243 @@ function typeCodeLabel(code) {
 	if (code === TypeCode.TUPLE) return "tuple";
 	return `0x${code.toString(16).padStart(2, "0")}`;
 }
-function lookupTypeCode(code) {
-	return {
-		label: typeCodeLabel(code),
-		...classifyTypeCode(code)
+function lookupTypeCode(code) {
+	return {
+		label: typeCodeLabel(code),
+		...classifyTypeCode(code)
+	};
+}
+//#endregion
+//#region src/descriptor.ts
+function readNode(desc, offset) {
+	if (offset >= desc.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end of descriptor", offset);
+	const typeCode = desc[offset];
+	const info = classifyTypeCode(typeCode);
+	if (info.typeClass === "elementary") return {
+		typeCode,
+		staticWords: info.isDynamic ? 0 : 1,
+		nodeLength: DescriptorFormat.TYPECODE_SIZE
+	};
+	if (offset + DescriptorFormat.TYPECODE_SIZE + DescriptorFormat.COMPOSITE_META_SIZE > desc.length) throw new CallciumError("UNEXPECTED_END", "Incomplete composite metadata", offset);
+	const meta = readU24(desc, offset + DescriptorFormat.TYPECODE_SIZE);
+	const length = meta & DescriptorFormat.META_NODE_LENGTH_MASK;
+	const minHeader = info.typeClass === "tuple" ? DescriptorFormat.TUPLE_HEADER_SIZE : DescriptorFormat.ARRAY_HEADER_SIZE;
+	if (length < minHeader) throw new CallciumError("NODE_LENGTH_TOO_SMALL", `Composite node length ${length} is smaller than minimum header ${minHeader}`, offset);
+	if (offset + length > desc.length) throw new CallciumError("NODE_OVERFLOW", "Composite node extends beyond descriptor", offset);
+	return {
+		typeCode,
+		staticWords: meta >> DescriptorFormat.META_STATIC_WORDS_SHIFT,
+		nodeLength: length
+	};
+}
+function nodeLength(desc, offset) {
+	return readNode(desc, offset).nodeLength;
+}
+function tupleFieldOffset(desc, tupleOffset, fieldIndex) {
+	let cursor = tupleOffset + DescriptorFormat.TUPLE_HEADER_SIZE;
+	for (let i = 0; i < fieldIndex; i++) cursor += nodeLength(desc, cursor);
+	return cursor;
+}
+function paramCount(desc) {
+	if (desc.length < DescriptorFormat.HEADER_SIZE) throw new CallciumError("MALFORMED_HEADER", "Descriptor too short for header");
+	return desc[1];
+}
+function paramOffset(desc, index) {
+	const count = paramCount(desc);
+	if (index >= count) throw new CallciumError("PARAM_INDEX_OUT_OF_BOUNDS", `Param index ${index} out of range (paramCount=${count})`);
+	let cursor = DescriptorFormat.HEADER_SIZE;
+	for (let i = 0; i < index; i++) cursor += nodeLength(desc, cursor);
+	return cursor;
+}
+function inspect$1(desc, offset) {
+	const { typeCode, staticWords } = readNode(desc, offset);
+	return {
+		typeCode,
+		isDynamic: staticWords === 0,
+		staticSize: staticWords * 32
+	};
+}
+function typeAt(desc, steps) {
+	return walkPath(desc, steps).typeInfo;
+}
+function walkPath(desc, steps) {
+	if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step");
+	let cursor = paramOffset(desc, steps[0]);
+	let quantifiedStaticLength = 0;
+	for (let stepIndex = 1; stepIndex < steps.length; stepIndex++) {
+		const typeCode = desc[cursor];
+		const step = steps[stepIndex];
+		if (typeCode === TypeCode.TUPLE) {
+			const fields = tupleFieldCount(desc, cursor);
+			if (step >= fields) throw new CallciumError("TUPLE_FIELD_OUT_OF_BOUNDS", `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) if (isQuantifier(step)) quantifiedStaticLength = staticArrayLength(desc, cursor);
+			else {
+				const length = staticArrayLength(desc, cursor);
+				if (step >= length) throw new CallciumError("STATIC_ARRAY_INDEX_OUT_OF_BOUNDS", `Array index ${step} out of range (length=${length})`);
+			}
+			cursor = arrayElementOffset(cursor);
+		} else throw new CallciumError("NOT_COMPOSITE", `Cannot descend into elementary type at offset ${cursor}`);
+	}
+	return {
+		typeInfo: inspect$1(desc, cursor),
+		quantifiedStaticLength
+	};
+}
+function tupleFieldCount(desc, offset) {
+	return readU16(desc, offset + 4);
+}
+function staticArrayLength(desc, offset) {
+	const elemOffset = arrayElementOffset(offset);
+	return readU16(desc, elemOffset + nodeLength(desc, elemOffset));
+}
+function arrayElementOffset(offset) {
+	return offset + DescriptorFormat.ARRAY_HEADER_SIZE;
+}
+function uncompilablePath(stepIndex) {
+	return new CallciumError("UNCOMPILABLE_PATH", `Path step ${stepIndex} does not resolve to a hop-chain target`);
+}
+function headSpan(desc, offset, count) {
+	let span = 0;
+	let nodeOffset = offset;
+	for (let i = 0; i < count; i++) {
+		const node = inspect$1(desc, nodeOffset);
+		span += node.isDynamic ? 32 : node.staticSize;
+		nodeOffset += nodeLength(desc, nodeOffset);
+	}
+	return {
+		span,
+		nodeOffset
+	};
+}
+function arrayMeta(desc, arrayOffset, code) {
+	const element = inspect$1(desc, arrayElementOffset(arrayOffset));
+	let meta = element.isDynamic ? 1 : element.staticSize >> 5;
+	if (element.isDynamic) meta |= PolicyFormat.HINT_META_ELEM_DYNAMIC;
+	if (code === TypeCode.DYNAMIC_ARRAY) meta |= PolicyFormat.HINT_META_DYNAMIC_ARRAY;
+	return {
+		meta,
+		elemIsDynamic: element.isDynamic
+	};
+}
+function enterNode(walk, needed) {
+	if (!needed) return;
+	walk.chain.push([
+		walk.delta,
+		PolicyFormat.HINT_NO_INDEX,
+		0
+	]);
+	walk.delta = 0;
+}
+function walkStep(desc, walk, descOffset, step, stepIndex) {
+	const node = inspect$1(desc, descOffset);
+	if (node.typeCode === TypeCode.TUPLE) {
+		if (step >= tupleFieldCount(desc, descOffset)) throw uncompilablePath(stepIndex);
+		enterNode(walk, node.isDynamic && !walk.entered);
+		const field = headSpan(desc, descOffset + DescriptorFormat.TUPLE_HEADER_SIZE, step);
+		walk.delta += field.span;
+		walk.entered = false;
+		return field.nodeOffset;
+	}
+	if (node.typeCode !== TypeCode.STATIC_ARRAY && node.typeCode !== TypeCode.DYNAMIC_ARRAY) throw uncompilablePath(stepIndex);
+	if (node.typeCode === TypeCode.STATIC_ARRAY && !isQuantifier(step) && step >= staticArrayLength(desc, descOffset)) throw uncompilablePath(stepIndex);
+	const { meta, elemIsDynamic } = arrayMeta(desc, descOffset, node.typeCode);
+	if (isQuantifier(step)) {
+		if (walk.kind !== PolicyFormat.HINT_KIND_NONE) throw uncompilablePath(stepIndex);
+		enterNode(walk, node.isDynamic && !walk.entered);
+		const count = node.typeCode === TypeCode.DYNAMIC_ARRAY ? 0 : staticArrayLength(desc, descOffset);
+		walk.frame = {
+			arrayDelta: walk.delta,
+			count,
+			meta
+		};
+		walk.kind = step === Quantifier.ALL ? PolicyFormat.HINT_KIND_ALL : PolicyFormat.HINT_KIND_ANY;
+		walk.mainHops = walk.chain;
+		walk.chain = [];
+		walk.delta = 0;
+	} else if (node.isDynamic) {
+		enterNode(walk, !walk.entered);
+		walk.chain.push([
+			0,
+			step,
+			meta
+		]);
+		walk.delta = 0;
+	} else walk.delta += step * (meta & PolicyFormat.HINT_META_STRIDE_MASK) * 32;
+	walk.entered = elemIsDynamic;
+	return arrayElementOffset(descOffset);
+}
+function writeHops(out, offset, hops) {
+	for (const [delta, index, meta] of hops) {
+		writeBE32(out, offset, delta);
+		writeBE16(out, offset + PolicyFormat.HINT_HOP_INDEX_OFFSET, index);
+		writeBE16(out, offset + PolicyFormat.HINT_HOP_META_OFFSET, meta);
+		offset += PolicyFormat.HINT_HOP_SIZE;
+	}
+	return offset;
+}
+function encodeHint(walk, targetMeta, typeCode, depth) {
+	let suffixHops = [];
+	if (walk.kind === PolicyFormat.HINT_KIND_NONE) walk.mainHops = walk.chain;
+	else suffixHops = walk.chain;
+	const mainHopCount = walk.mainHops.length;
+	const suffixHopCount = suffixHops.length;
+	if (mainHopCount > PolicyFormat.HINT_HOP_COUNT_MASK || suffixHopCount > PolicyFormat.HINT_HOP_COUNT_MASK) throw uncompilablePath(depth);
+	const quantified = walk.kind !== PolicyFormat.HINT_KIND_NONE;
+	const frameSize = quantified ? PolicyFormat.HINT_FRAME_PREFIX_SIZE + PolicyFormat.HINT_HEADER_SIZE + suffixHopCount * PolicyFormat.HINT_HOP_SIZE : 0;
+	const out = new Uint8Array(PolicyFormat.HINT_HEADER_SIZE + mainHopCount * PolicyFormat.HINT_HOP_SIZE + frameSize + PolicyFormat.HINT_TARGET_SIZE);
+	let offset = 0;
+	out[offset] = walk.kind << PolicyFormat.HINT_KIND_SHIFT | mainHopCount;
+	offset = writeHops(out, offset + PolicyFormat.HINT_HEADER_SIZE, walk.mainHops);
+	if (quantified) {
+		writeBE32(out, offset, walk.frame.arrayDelta);
+		writeBE16(out, offset + PolicyFormat.HINT_FRAME_COUNT_OFFSET, walk.frame.count);
+		writeBE16(out, offset + PolicyFormat.HINT_FRAME_META_OFFSET, walk.frame.meta);
+		out[offset + PolicyFormat.HINT_FRAME_PREFIX_SIZE] = suffixHopCount;
+		offset = writeHops(out, offset + PolicyFormat.HINT_FRAME_PREFIX_SIZE + PolicyFormat.HINT_HEADER_SIZE, suffixHops);
+	}
+	writeBE32(out, offset, walk.delta);
+	writeBE16(out, offset + PolicyFormat.HINT_TARGET_META_OFFSET, targetMeta);
+	out[offset + PolicyFormat.HINT_TARGET_TYPECODE_OFFSET] = typeCode;
+	return out;
+}
+function compileHint(desc, steps) {
+	if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step");
+	const argIndex = steps[0];
+	if (argIndex >= paramCount(desc)) throw uncompilablePath(0);
+	const arg = headSpan(desc, DescriptorFormat.HEADER_SIZE, argIndex);
+	const walk = {
+		chain: [],
+		mainHops: [],
+		delta: arg.span,
+		frame: {
+			arrayDelta: 0,
+			count: 0,
+			meta: 0
+		},
+		kind: PolicyFormat.HINT_KIND_NONE,
+		entered: false
 	};
+	let descOffset = arg.nodeOffset;
+	for (let stepIndex = 1; stepIndex < steps.length; stepIndex++) descOffset = walkStep(desc, walk, descOffset, steps[stepIndex], stepIndex);
+	const target = inspect$1(desc, descOffset);
+	enterNode(walk, target.isDynamic && !walk.entered);
+	return encodeHint(walk, target.typeCode === TypeCode.DYNAMIC_ARRAY ? arrayMeta(desc, descOffset, target.typeCode).meta : 0, target.typeCode, steps.length);
 }
+const Descriptor = {
+	paramCount,
+	paramOffset,
+	inspect: inspect$1,
+	typeAt,
+	tupleFieldOffset,
+	tupleFieldCount,
+	staticArrayLength,
+	nodeLength,
+	arrayElementOffset,
+	walkPath,
+	compileHint
+};
 //#endregion
 //#region src/type-desc.ts
 function extractStaticWords(desc) {
@@ -864,9 +1086,9 @@ function bytes() {
 function string_() {
 	return new Uint8Array([TypeCode.STRING]);
 }
-function bytesN(n) {
-	if (n < 1 || n > 32) throw new CallciumError("UNKNOWN_TYPE", `Invalid bytesN size: ${n}. Must be 1–32`);
-	return new Uint8Array([TypeCode.FIXED_BYTES_MIN + (n - 1)]);
+function bytesN(length) {
+	if (length < 1 || length > 32) throw new CallciumError("UNKNOWN_TYPE", `Invalid bytesN size: ${length}. Must be 1–32`);
+	return new Uint8Array([TypeCode.FIXED_BYTES_MIN + (length - 1)]);
 }
 function array(elemDesc, length) {
 	if (length === void 0) {
@@ -927,9 +1149,12 @@ function commaPositions(input, start, end) {
 	for (let i = start; i < end; i++) {
 		const char = input[i];
 		if (char === "(" || char === "[") depth++;
-		else if (char === ")" || char === "]") depth--;
-		else if (char === "," && depth === 0) positions.push(i);
+		else if (char === ")" || char === "]") {
+			if (depth === 0) throw new CallciumError("MALFORMED_TYPE_STRING", `Unmatched '${char}' at position ${i}`);
+			depth--;
+		} else if (char === "," && depth === 0) positions.push(i);
 	}
+	if (depth !== 0) throw new CallciumError("MALFORMED_TYPE_STRING", `Unclosed '${input.slice(start, end)}'`);
 	return positions;
 }
 const MAX_TYPE_STRING_NUMBER = 256 ** DescriptorFormat.ARRAY_LENGTH_SIZE - 1;
@@ -963,12 +1188,12 @@ function parseTuple(input, start, end) {
 	const innerEnd = closeIndex;
 	const commas = commaPositions(input, innerStart, innerEnd);
 	const segments = [];
-	let segStart = innerStart;
+	let segmentStart = innerStart;
 	for (const comma of commas) {
-		segments.push([segStart, comma]);
-		segStart = comma + 1;
+		segments.push([segmentStart, comma]);
+		segmentStart = comma + 1;
 	}
-	segments.push([segStart, innerEnd]);
+	segments.push([segmentStart, innerEnd]);
 	if (segments.length === 1 && segments[0][0] === segments[0][1]) return tuple([]);
 	return tuple(segments.map(([fieldStart, fieldEnd]) => parseType(input, fieldStart, fieldEnd)));
 }
@@ -980,28 +1205,25 @@ function parseBaseType(input, start, end) {
 	if (segment === "bytes") return bytes();
 	if (segment === "string") return string_();
 	if (segment.startsWith("(")) return parseTuple(input, start, end);
-	if (segment.startsWith("uint")) return uintN(parseUint(input, start + 4, end));
-	if (segment.startsWith("int")) return intN(parseUint(input, start + 3, end));
-	if (segment.startsWith("bytes")) return bytesN(parseUint(input, start + 5, end));
+	if (segment.length > 4 && segment.startsWith("uint")) return uintN(parseUint(input, start + 4, end));
+	if (segment.length > 3 && segment.startsWith("int")) return intN(parseUint(input, start + 3, end));
+	if (segment.length > 5 && segment.startsWith("bytes")) return bytesN(parseUint(input, start + 5, end));
 	throw new CallciumError("UNKNOWN_TYPE", `Unrecognised type '${segment}'`);
 }
 function parseType(input, start, end) {
 	if (start >= end) throw new CallciumError("MALFORMED_TYPE_STRING", "Empty type segment");
-	const suffixes = [];
+	const spans = [];
 	let baseEnd = end;
 	while (baseEnd > start && input[baseEnd - 1] === "]") {
 		const closeIndex = baseEnd - 1;
 		let openIndex = closeIndex - 1;
 		while (openIndex > start && input[openIndex] !== "[") openIndex--;
 		if (input[openIndex] !== "[") throw new CallciumError("MALFORMED_TYPE_STRING", `Unmatched ']' at position ${closeIndex}`);
-		const innerStart = openIndex + 1;
-		const innerEnd = closeIndex;
-		suffixes.unshift(innerStart === innerEnd ? void 0 : parseUint(input, innerStart, innerEnd));
+		spans.unshift([openIndex + 1, closeIndex]);
 		baseEnd = openIndex;
 	}
-	if (input[start] !== "(" && input.slice(start, baseEnd).includes("[")) throw new CallciumError("MALFORMED_TYPE_STRING", `Unmatched '[' in '${input.slice(start, baseEnd)}'`);
 	let desc = parseBaseType(input, start, baseEnd);
-	for (const length of suffixes) desc = array(desc, length);
+	for (const [innerStart, innerEnd] of spans) desc = array(desc, innerStart === innerEnd ? void 0 : parseUint(input, innerStart, innerEnd));
 	return desc;
 }
 function fromTypes(typesCsv) {
@@ -1025,10 +1247,11 @@ function fromTypes(typesCsv) {
 		result.set(desc, offset);
 		offset += desc.length;
 	}
+	decodeDescriptor(result);
 	return result;
 }
 function nodeToTypeString(desc, offset) {
-	const typeCode = desc[offset];
+	const { typeCode } = Descriptor.inspect(desc, offset);
 	if (typeCode === TypeCode.TUPLE) {
 		const fieldCount = Descriptor.tupleFieldCount(desc, offset);
 		const fieldTypes = [];
@@ -1057,30 +1280,20 @@ function toTypes(desc) {
 	return types.join(",");
 }
 function parseNode(data, offset, depth) {
-	if (offset >= data.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end of descriptor", offset);
-	const code = data[offset];
+	const { typeCode: code, staticWords, nodeLength } = readNode(data, offset);
 	const info = classifyTypeCode(code);
-	const metaOffset = offset + DescriptorFormat.TYPECODE_SIZE;
+	const isDynamic = staticWords === 0;
+	const staticSize = isDynamic ? 0 : staticWords * 32;
+	const nodeEnd = offset + nodeLength;
 	if (info.typeClass === "elementary") return {
 		typeCode: code,
-		isDynamic: info.isDynamic,
-		staticSize: info.isDynamic ? 0 : 32,
-		next: metaOffset
+		isDynamic,
+		staticSize,
+		next: nodeEnd
 	};
 	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);
-	const staticWords = meta >> DescriptorFormat.META_STATIC_WORDS_SHIFT;
-	const nodeLength = meta & DescriptorFormat.META_NODE_LENGTH_MASK;
-	const minHeader = info.typeClass === "tuple" ? DescriptorFormat.TUPLE_HEADER_SIZE : DescriptorFormat.ARRAY_HEADER_SIZE;
-	if (nodeLength < minHeader) throw new CallciumError("NODE_LENGTH_TOO_SMALL", `Composite node length ${nodeLength} is smaller than minimum header ${minHeader}`, offset);
-	if (offset + nodeLength > data.length) throw new CallciumError("NODE_OVERFLOW", "Composite node extends beyond descriptor", offset);
-	const isDynamic = staticWords === 0;
-	const staticSize = isDynamic ? 0 : staticWords * 32;
-	const nodeEnd = offset + nodeLength;
 	if (info.typeClass === "tuple") {
-		const fieldCountOffset = metaEnd;
+		const fieldCountOffset = offset + DescriptorFormat.TYPECODE_SIZE + DescriptorFormat.COMPOSITE_META_SIZE;
 		if (fieldCountOffset + 2 > data.length) throw new CallciumError("UNEXPECTED_END", "Incomplete tuple header", offset);
 		const fieldCount = readU16(data, fieldCountOffset);
 		if (fieldCount === 0) throw new CallciumError("INVALID_TUPLE_FIELD_COUNT", "Tuple must have at least one field", offset);
@@ -1126,8 +1339,8 @@ function decodeDescriptor(data) {
 	const params = [];
 	let cursor = DescriptorFormat.HEADER_SIZE;
 	while (cursor < data.length) {
-		if (params.length >= DescriptorFormat.MAX_PARAMS) throw new CallciumError("TOO_MANY_PARAMS", `Descriptor exceeds the maximum of ${DescriptorFormat.MAX_PARAMS} top-level params`);
 		const { typeCode, isDynamic, staticSize, next } = parseNode(data, cursor, 1);
+		if (params.length === DescriptorFormat.MAX_PARAMS) throw new CallciumError("TOO_MANY_PARAMS", `Descriptor exceeds the maximum of ${DescriptorFormat.MAX_PARAMS} top-level params`);
 		params.push({
 			index: params.length,
 			typeCode,
@@ -1163,6 +1376,21 @@ function field(value, start, end) {
 		}
 	};
 }
+function hexField(data, start, end) {
+	let hex;
+	return {
+		get value() {
+			return hex ??= toHex(data, start, end);
+		},
+		set value(replacement) {
+			hex = replacement;
+		},
+		span: {
+			start,
+			end
+		}
+	};
+}
 function resolveHintSize(data, hintStart, ruleEnd, ruleOffset) {
 	const overrun = () => {
 		throw new CallciumError("RULE_FIELD_OUT_OF_BOUNDS", "Rule is too small to hold a hint block", ruleOffset);
@@ -1219,7 +1447,7 @@ function hintTargetTypeCode(data, hintStart, hintSize) {
 }
 function decodePolicy(blob) {
 	const data = hexToBytes(blob);
-	if (data.length < PolicyFormat.DESC_OFFSET + 1) throw new CallciumError("MALFORMED_HEADER", "Policy blob is too short");
+	if (data.length < PolicyFormat.DESC_OFFSET) throw new CallciumError("MALFORMED_HEADER", "Policy blob is too short");
 	const headerByte = data[0];
 	const version = headerByte & PolicyFormat.VERSION_MASK;
 	if (version !== PolicyFormat.VERSION) throw new CallciumError("UNSUPPORTED_VERSION", `Version ${version} is not supported (expected ${PolicyFormat.VERSION})`);
@@ -1244,7 +1472,7 @@ function decodePolicy(blob) {
 			end: descStart + param.span.end
 		}
 	}));
-	const descriptorRaw = toHex(data, descStart, descEnd);
+	const descriptorRaw = hexField(data, descStart, descEnd);
 	const groupCountStart = groupCountOffset;
 	const groupCountEnd = groupCountStart + PolicyFormat.GROUP_COUNT_SIZE;
 	const groupCountValue = data[groupCountOffset];
@@ -1257,18 +1485,18 @@ function decodePolicy(blob) {
 		const groupSizeValue = readU32(data, groupSizeStart);
 		const groupBodyStart = offset + PolicyFormat.GROUP_HEADER_SIZE;
 		const groupEnd = groupBodyStart + groupSizeValue;
+		if (groupEnd > data.length) throw new CallciumError("GROUP_OVERFLOW", "Group extends beyond policy blob", offset);
 		const ruleCountStart = offset;
 		const ruleCountValue = readU16(data, ruleCountStart);
 		if (ruleCountValue === 0) throw new CallciumError("EMPTY_GROUP", "Group must contain at least one rule", offset);
 		if (groupSizeValue < ruleCountValue * PolicyFormat.RULE_MIN_SIZE) throw new CallciumError("GROUP_TOO_SMALL", "Declared group size is too small for its rule count", offset);
-		if (groupEnd > data.length) throw new CallciumError("GROUP_OVERFLOW", "Group extends beyond policy blob", offset);
 		const rules = [];
 		let ruleOffset = groupBodyStart;
 		for (let ruleIndex = 0; ruleIndex < ruleCountValue; ruleIndex++) {
 			if (ruleOffset + PolicyFormat.RULE_SIZE_SIZE > data.length) throw new CallciumError("UNEXPECTED_END", "Unexpected end while reading rule size", ruleOffset);
 			const ruleSizeValue = readU16(data, ruleOffset);
 			if (ruleSizeValue < PolicyFormat.RULE_MIN_SIZE) throw new CallciumError("RULE_TOO_SMALL", `Rule size ${ruleSizeValue} is below minimum ${PolicyFormat.RULE_MIN_SIZE}`, ruleOffset);
-			if (ruleOffset + ruleSizeValue > groupEnd) throw new CallciumError("RULE_OVERFLOW", "Rule extends beyond group boundary", ruleOffset);
+			if (ruleOffset + ruleSizeValue > data.length) throw new CallciumError("RULE_OVERFLOW", "Rule extends beyond policy blob", ruleOffset);
 			const scopeOffset = ruleOffset + PolicyFormat.RULE_SCOPE_OFFSET;
 			const scopeValue = data[scopeOffset];
 			if (scopeValue !== Scope.CONTEXT && scopeValue !== Scope.CALLDATA) throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${scopeValue}`, ruleOffset);
@@ -1297,7 +1525,12 @@ function decodePolicy(blob) {
 			const dataStart = dataLengthOffset + PolicyFormat.RULE_DATALENGTH_SIZE;
 			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);
+				let prev = toBigInt(data, dataStart);
+				for (let word = 1; word < wordCount; word++) {
+					const cur = toBigInt(data, dataStart + word * 32);
+					if (cur <= prev) throw new CallciumError("UNSORTED_IN_SET", "IN operands must be strictly ascending", ruleOffset);
+					prev = cur;
+				}
 			}
 			if (opBase === Op.EQ_CTX) {
 				if (toBigInt(data, dataStart) > BigInt(MAX_CONTEXT_PROPERTY_ID)) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", "EQ_CTX operand references an undefined context property", ruleOffset);
@@ -1307,7 +1540,7 @@ function decodePolicy(blob) {
 			if (scopeValue === Scope.CONTEXT) {
 				if (depthValue !== 1) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope rules must have exactly one path step", ruleOffset);
 				const contextPropertyId = readU16(data, pathStart);
-				if (contextPropertyId > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Context rule references undefined context property 0x${contextPropertyId.toString(16).padStart(4, "0")}`, ruleOffset);
+				if (contextPropertyId > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Context rule references undefined context property ${formatCode(contextPropertyId, PolicyFormat.PATH_STEP_SIZE)}`, ruleOffset);
 			}
 			const pathHex = toHex(data, pathStart, pathStart + pathLength);
 			rules.push({
@@ -1315,15 +1548,16 @@ function decodePolicy(blob) {
 				scope: field(scopeValue, scopeOffset, scopeOffset + 1),
 				pathDepth: field(depthValue, depthOffset, depthOffset + 1),
 				path: field(pathHex, pathStart, pathStart + pathLength),
-				...hintSize > 0 && { hint: field(toHex(data, hintStart, hintStart + hintSize), hintStart, hintStart + hintSize) },
+				...hintSize > 0 && { hint: hexField(data, hintStart, hintStart + hintSize) },
 				opCode: field(opCodeValue, opCodeOffset, opCodeOffset + PolicyFormat.RULE_OPCODE_SIZE),
 				dataLength: field(dataLengthValue, dataLengthOffset, dataLengthOffset + PolicyFormat.RULE_DATALENGTH_SIZE),
-				data: field(toHex(data, dataStart, dataStart + dataLengthValue), dataStart, dataStart + dataLengthValue),
+				data: hexField(data, dataStart, dataStart + dataLengthValue),
 				span: {
 					start: ruleOffset,
 					end: ruleOffset + ruleSizeValue
 				}
 			});
+			if (ruleOffset + ruleSizeValue > groupEnd) throw new CallciumError("RULE_OVERFLOW", "Rule extends beyond group boundary", ruleOffset);
 			ruleOffset += ruleSizeValue;
 		}
 		if (ruleOffset !== groupEnd) throw new CallciumError("GROUP_SIZE_MISMATCH", "Rules do not exactly fill the declared group size", offset);
@@ -1345,7 +1579,12 @@ function decodePolicy(blob) {
 			selector: field(selectorHex, selectorStart, selectorEnd),
 			descLength: field(descLengthValue, descLengthStart, descLengthStart + PolicyFormat.DESC_LENGTH_SIZE),
 			descriptor: {
-				raw: descriptorRaw,
+				get raw() {
+					return descriptorRaw.value;
+				},
+				set raw(replacement) {
+					descriptorRaw.value = replacement;
+				},
 				header: field({
 					version: desc.version,
 					paramCount: desc.params.length
@@ -1368,21 +1607,28 @@ function decodePolicy(blob) {
 		data
 	};
 }
-function flattenConstraint(constraint, desc) {
-	const operators = constraint.operators.map(hexToBytes);
-	for (const operator of operators) if (operator.length < 1) throw new CallciumError("INVALID_OPERATOR_BYTES", "Operator must have at least one byte (opcode)");
+function readConstraintTarget(constraint, desc) {
 	const path = hexToBytes(constraint.path);
 	if (path.length === 0) throw new CallciumError("EMPTY_PATH", "Rule path must have at least one step");
 	if ((path.length & 1) !== 0) throw new CallciumError("MALFORMED_PATH", "Path byte length must be even");
 	const depth = path.length / 2;
 	if (depth > PolicyFormat.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depth} exceeds maximum ${PolicyFormat.MAX_PATH_DEPTH}`);
-	const hint = constraint.scope === Scope.CALLDATA ? Descriptor.compileHint(desc, parsePathSteps(constraint.path)) : new Uint8Array(0);
-	return operators.map((operator) => ({
-		scope: constraint.scope,
+	return {
 		path,
-		operator,
-		hint
-	}));
+		hint: constraint.scope === Scope.CALLDATA ? Descriptor.compileHint(desc, parsePathSteps(constraint.path)) : new Uint8Array(0)
+	};
+}
+function flattenConstraint(constraint, desc) {
+	let target;
+	return constraint.operators.map((operatorHex) => {
+		const operator = toOperatorBytes(operatorHex);
+		target ??= readConstraintTarget(constraint, desc);
+		return {
+			scope: constraint.scope,
+			operator,
+			...target
+		};
+	});
 }
 function compareBytes(a, b) {
 	const length = Math.min(a.length, b.length);
@@ -1400,12 +1646,16 @@ function sortRules(rules) {
 		return compareBytes(a.operator, b.operator);
 	});
 }
+function requireFieldFits(value, byteWidth, code, subject) {
+	const max = fieldMax(byteWidth);
+	if (value > max) throw new CallciumError(code, `${subject} ${value} exceeds maximum ${max}`);
+}
 function encodeRule(rule) {
 	const depth = rule.path.length / 2;
 	if (rule.scope === Scope.CONTEXT && depth !== 1) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope rules must have exactly one path step");
 	const data = rule.operator.subarray(1);
 	const ruleSize = PolicyFormat.RULE_FIXED_OVERHEAD + rule.path.length + rule.hint.length + data.length;
-	if (ruleSize > 65535) throw new CallciumError("RULE_SIZE_OVERFLOW", `Rule size ${ruleSize} exceeds maximum 65535`);
+	requireFieldFits(ruleSize, PolicyFormat.RULE_SIZE_SIZE, "RULE_SIZE_OVERFLOW", "Rule size");
 	const buf = new Uint8Array(ruleSize);
 	writeBE16(buf, 0, ruleSize);
 	buf[2] = rule.scope;
@@ -1435,16 +1685,16 @@ function buildOperatorHex(rule) {
 function encode(data) {
 	const descBytes = hexToBytes(data.descriptor);
 	if (data.groups.length === 0) throw new CallciumError("EMPTY_POLICY", "Policy must contain at least one group");
-	if (data.groups.length > 255) throw new CallciumError("GROUP_COUNT_OVERFLOW", `Group count ${data.groups.length} exceeds maximum 255`);
+	requireFieldFits(data.groups.length, PolicyFormat.GROUP_COUNT_SIZE, "GROUP_COUNT_OVERFLOW", "Group count");
 	const sortedGroups = data.groups.map((group) => {
 		const rules = group.flatMap((constraint) => flattenConstraint(constraint, descBytes));
 		sortRules(rules);
 		return rules;
 	});
-	if (descBytes.length > 65535) throw new CallciumError("DESC_LENGTH_OVERFLOW", `Descriptor length ${descBytes.length} exceeds maximum 65535`);
+	requireFieldFits(descBytes.length, PolicyFormat.DESC_LENGTH_SIZE, "DESC_LENGTH_OVERFLOW", "Descriptor length");
 	const encodedGroups = sortedGroups.map((rules, groupIndex) => {
 		if (rules.length === 0) throw new CallciumError("EMPTY_GROUP", `Group ${groupIndex} is empty`);
-		if (rules.length > 65535) throw new CallciumError("RULE_COUNT_OVERFLOW", `Group ${groupIndex} rule count ${rules.length} exceeds maximum 65535`);
+		requireFieldFits(rules.length, PolicyFormat.GROUP_RULECOUNT_SIZE, "RULE_COUNT_OVERFLOW", `Group ${groupIndex} rule count`);
 		return {
 			wireBytes: encodeGroupRules(rules),
 			ruleCount: rules.length
@@ -1454,7 +1704,8 @@ function encode(data) {
 		const hashes = new Map(encodedGroups.map((group) => [group, keccak_256(group.wireBytes)]));
 		encodedGroups.sort((a, b) => compareBytes(hashes.get(a), hashes.get(b)));
 	}
-	const selectorBytes = data.isSelectorless ? new Uint8Array(4) : hexToBytes(data.selector);
+	const selectorBytes = data.isSelectorless ? new Uint8Array(PolicyFormat.SELECTOR_SIZE) : hexToBytes(data.selector);
+	if (selectorBytes.length !== PolicyFormat.SELECTOR_SIZE) throw new CallciumError("MALFORMED_SELECTOR", `Selector must be ${PolicyFormat.SELECTOR_SIZE} bytes, got ${selectorBytes.length}`);
 	const headerByte = PolicyFormat.VERSION | (data.isSelectorless ? PolicyFormat.FLAG_NO_SELECTOR : 0);
 	let totalSize = PolicyFormat.HEADER_SIZE + PolicyFormat.SELECTOR_SIZE + PolicyFormat.DESC_LENGTH_SIZE + descBytes.length + PolicyFormat.GROUP_COUNT_SIZE;
 	for (const g of encodedGroups) totalSize += PolicyFormat.GROUP_HEADER_SIZE + g.wireBytes.length;
@@ -1482,7 +1733,6 @@ function decode(blob) {
 	const { policy } = decodePolicy(blob);
 	const groups = policy.groups.map((group) => {
 		const constraintMap = /* @__PURE__ */ new Map();
-		const constraintOrder = [];
 		for (const rule of group.rules) {
 			const hintHex = rule.hint?.value;
 			const key = `${rule.scope.value}:${rule.path.value}:${hintHex ?? ""}`;
@@ -1498,10 +1748,9 @@ function decode(blob) {
 					span: rule.span
 				};
 				constraintMap.set(key, constraint);
-				constraintOrder.push(key);
 			}
 		}
-		return constraintOrder.map((k) => constraintMap.get(k));
+		return [...constraintMap.values()];
 	});
 	return {
 		isSelectorless: policy.isSelectorless,
@@ -1945,7 +2194,6 @@ function negationUnderAny(groupIndex, constraintIndex, opCode) {
 //#endregion
 //#region src/policy-validator.ts
 const navigabilityCodes = new Set([
-	"EMPTY_PATH",
 	"PARAM_INDEX_OUT_OF_BOUNDS",
 	"TUPLE_FIELD_OUT_OF_BOUNDS",
 	"STATIC_ARRAY_INDEX_OUT_OF_BOUNDS",
@@ -1956,8 +2204,11 @@ const UINT256_MAX = (1n << 256n) - 1n;
 const INT256_SIGN_BIT = 1n << 255n;
 function signedCompare(a, b, signed) {
 	if (!signed) return a - b;
-	const toS = (v) => v >= INT256_SIGN_BIT ? v - (1n << 256n) : v;
-	return toS(a) - toS(b);
+	const toSigned = (word) => word >= INT256_SIGN_BIT ? word - (1n << 256n) : word;
+	return toSigned(a) - toSigned(b);
+}
+function isOutsideDomain(domain, value) {
+	return signedCompare(value, domain.min, domain.isSigned) < 0n || signedCompare(value, domain.max, domain.isSigned) > 0n;
 }
 function isNumericType(typeCode) {
 	return typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX || typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
@@ -2015,7 +2266,7 @@ function getIncompat(opBase, typeInfo) {
 			code: "VALUE_OP_ON_DYNAMIC",
 			message: "Value operator used on dynamic type"
 		};
-		if (classifyTypeCode(typeCode).typeClass !== "elementary") return {
+		if (!isElementary(typeCode)) return {
 			code: "VALUE_OP_ON_COMPOSITE",
 			message: "Value operator used on composite type"
 		};
@@ -2126,7 +2377,7 @@ function initContext(scope, path, steps, typeInfo) {
 		numeric: emptyBoundDomain(isSigned(typeInfo.typeCode), min, max),
 		bitmask: {
 			mustBeOne: 0n,
-			mustBeZero: 0n
+			mustBeZero: isBitmaskCompatible(typeInfo.typeCode) ? UINT256_MAX ^ max : 0n
 		},
 		length: emptyBoundDomain(false, 0n, LENGTH_MAX),
 		set: {
@@ -2139,6 +2390,7 @@ function initContext(scope, path, steps, typeInfo) {
 function updateBound(domain, base, isNegated, value, isLength, groupIndex, constraintIndex, issues) {
 	if (isNegated) {
 		if (base === Op.EQ) {
+			if (isOutsideDomain(domain, value)) issues.push(outOfPhysicalBounds(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 			if (domain.hasEq && domain.eq === value) issues.push(eqNeqContradiction(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 			let alreadyHole = false;
 			for (let j = 0; j < domain.holes.length; j++) if (domain.holes[j] === value) {
@@ -2151,7 +2403,7 @@ function updateBound(domain, base, isNegated, value, isLength, groupIndex, const
 	}
 	if (base === Op.GTE && value === domain.min) issues.push(vacuousGte(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 	else if (base === Op.LTE && value === domain.max) issues.push(vacuousLte(isLength, groupIndex, constraintIndex, bigintToHex(value)));
-	if (signedCompare(value, domain.min, domain.isSigned) < 0n || signedCompare(value, domain.max, domain.isSigned) > 0n) issues.push(outOfPhysicalBounds(isLength, groupIndex, constraintIndex, bigintToHex(value)));
+	if (isOutsideDomain(domain, value)) issues.push(outOfPhysicalBounds(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 	else if (base === Op.GT && value === domain.max) issues.push(impossibleGt(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 	else if (base === Op.LT && value === domain.min) issues.push(impossibleLt(isLength, groupIndex, constraintIndex, bigintToHex(value)));
 	let changedEq = false;
@@ -2266,6 +2518,7 @@ function checkSetEmpty(ctx, groupIndex, constraintIndex, issues) {
 	else if (possibleCount < inCount) issues.push(setPartiallyExcluded(groupIndex, constraintIndex, bigintToHex(BigInt(inCount - possibleCount))));
 }
 function updateSet(ctx, isNegated, values, groupIndex, constraintIndex, issues) {
+	for (const value of values) if (isOutsideDomain(ctx.numeric, value)) issues.push(outOfPhysicalBounds(false, groupIndex, constraintIndex, bigintToHex(value)));
 	if (isNegated) {
 		for (const value of values) {
 			if (ctx.numeric.hasEq && ctx.numeric.eq === value) issues.push(setExcludesEquality(groupIndex, constraintIndex, bigintToHex(value)));
@@ -2281,7 +2534,6 @@ function updateSet(ctx, isNegated, values, groupIndex, constraintIndex, issues)
 		}
 		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) {
@@ -2323,6 +2575,9 @@ function checkFusibleRange(ctx, operators, groupIndex, constraintIndex, issues)
 	const lengthPair = findLonePair(operators, Op.LENGTH_GTE, Op.LENGTH_LTE);
 	if (lengthPair && getIncompat(Op.LENGTH_GTE, ctx.typeInfo) === null && lengthPair.low <= lengthPair.high) issues.push(fusibleRange(true, groupIndex, constraintIndex, bigintToHex(lengthPair.low), bigintToHex(lengthPair.high)));
 }
+function hasValidPayload(opBase, dataLength) {
+	return dataLength <= fieldMax(PolicyFormat.RULE_DATALENGTH_SIZE) && isValidOperatorData(opBase, dataLength);
+}
 function findLonePair(operators, lowerOp, upperOp) {
 	let lowerCount = 0;
 	let upperCount = 0;
@@ -2331,7 +2586,7 @@ function findLonePair(operators, lowerOp, upperOp) {
 	for (const opHex of operators) {
 		const opCode = parseInt(opHex.slice(2, 4), 16);
 		const dataLength = (opHex.length - 4) / 2;
-		if (dataLength > 65535 || !isValidOperatorData(opCode & ~Op.NOT, dataLength)) continue;
+		if (!hasValidPayload(opCode & ~Op.NOT, dataLength)) continue;
 		if (opCode === lowerOp) {
 			lowerCount++;
 			low = readValue(opHex);
@@ -2349,10 +2604,10 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 	const operators = constraint.operators;
 	const underAny = constraint.scope === Scope.CALLDATA && ctx.steps.includes(Quantifier.ANY);
 	for (const opHex of operators) {
-		const opCode = parseInt(opHex.slice(2, 4), 16);
+		const opBytes = toOperatorBytes(opHex);
+		const opCode = opBytes[0];
 		const base = opCode & ~Op.NOT;
-		const dataLength = (opHex.length - 4) / 2;
-		if (dataLength > 65535 || !isValidOperatorData(base, dataLength)) {
+		if (!hasValidPayload(base, opBytes.length - 1)) {
 			issues.push(fromOpRule("UNKNOWN_OPERATOR", "Unknown operator code", groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
 			continue;
 		}
@@ -2365,8 +2620,9 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 		}
 		if (base === Op.EQ_CTX) {
 			const ctxOperand = readValue(opHex);
-			if (ctxOperand > BigInt(MAX_CONTEXT_PROPERTY_ID)) issues.push(unknownContextProperty(groupIndex, constraintIndex, bigintToHex(ctxOperand), bigintToHex(BigInt(MAX_CONTEXT_PROPERTY_ID))));
-			else if (lookupContextProperty(Number(ctxOperand)).typeCode === TypeCode.ADDRESS !== (ctx.typeInfo.typeCode === TypeCode.ADDRESS)) issues.push(contextTypeMismatch(groupIndex, constraintIndex, bigintToHex(ctxOperand), bigintToHex(BigInt(ctx.typeInfo.typeCode))));
+			const property = findContextProperty(Number(ctxOperand));
+			if (!property) issues.push(unknownContextProperty(groupIndex, constraintIndex, bigintToHex(ctxOperand), bigintToHex(BigInt(MAX_CONTEXT_PROPERTY_ID))));
+			else if (property.typeCode === TypeCode.ADDRESS !== (ctx.typeInfo.typeCode === TypeCode.ADDRESS)) issues.push(contextTypeMismatch(groupIndex, constraintIndex, bigintToHex(ctxOperand), bigintToHex(BigInt(ctx.typeInfo.typeCode))));
 		} else if (isValueOp(base)) {
 			const typeCode = ctx.typeInfo.typeCode;
 			if (isLeftAligned(typeCode)) {
@@ -2420,6 +2676,7 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 		}
 		if (!ctx) {
 			const steps = parsePathSteps(constraint.path);
+			if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step");
 			let typeInfo;
 			if (constraint.scope === Scope.CALLDATA) {
 				if (steps.length > PolicyFormat.MAX_PATH_DEPTH) issues.push(pathDepthExceeded(groupIndex, constraintIndex, bigintToHex(BigInt(steps.length)), bigintToHex(BigInt(PolicyFormat.MAX_PATH_DEPTH))));
@@ -2441,15 +2698,10 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 				typeInfo = walk.typeInfo;
 			} else {
 				const ctxId = steps[0];
-				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,
+				const property = findContextProperty(ctxId);
+				if (!property) issues.push(unknownContextProperty(groupIndex, constraintIndex, bigintToHex(BigInt(ctxId)), bigintToHex(BigInt(MAX_CONTEXT_PROPERTY_ID))));
+				typeInfo = {
+					typeCode: property?.typeCode ?? TypeCode.UINT_MAX,
 					isDynamic: false,
 					staticSize: 32
 				};
@@ -2457,7 +2709,7 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			ctx = initContext(constraint.scope, normalizedPath, steps, typeInfo);
 			contexts.push(ctx);
 		}
-		if (constraint.scope === Scope.CALLDATA && constraint.hint !== void 0 && ctx.steps.length <= PolicyFormat.MAX_PATH_DEPTH) {
+		if (constraint.scope === Scope.CALLDATA && constraint.hint !== void 0 && constraint.hint !== "0x" && ctx.steps.length <= PolicyFormat.MAX_PATH_DEPTH) {
 			if (bytesToHex(Descriptor.compileHint(descBytes, ctx.steps)) !== constraint.hint.toLowerCase()) issues.push(hintMismatch(groupIndex, constraintIndex));
 		}
 		validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues);
@@ -2480,33 +2732,31 @@ function validate(data) {
 const PolicyValidator = { validate };
 //#endregion
 //#region src/signature.ts
-function isAlpha(c) {
-	return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+function isAlpha(char) {
+	return char >= 65 && char <= 90 || char >= 97 && char <= 122;
 }
-function isAlphanum(c) {
-	return isAlpha(c) || c >= 48 && c <= 57;
+function isAlphanum(char) {
+	return isAlpha(char) || char >= 48 && char <= 57;
 }
 function parse(signature) {
 	if (signature.length < 3) throw new CallciumError("MALFORMED_SIGNATURE", `Invalid signature: too short, got "${signature}"`);
 	let openParen = -1;
 	for (let i = 0; i < signature.length; i++) {
-		const c = signature.charCodeAt(i);
-		if (c === 32 || c === 9 || c === 10 || c === 13) throw new CallciumError("SIGNATURE_CONTAINS_WHITESPACE", "Signature must not contain whitespace");
-		if (c > 126) throw new CallciumError("MALFORMED_SIGNATURE", "Signature must contain only ASCII characters");
-		if (openParen === -1 && c === 40) openParen = i;
+		const char = signature.charCodeAt(i);
+		if (char === 32 || char === 9 || char === 10 || char === 13) throw new CallciumError("SIGNATURE_CONTAINS_WHITESPACE", "Signature must not contain whitespace");
+		if (openParen === -1 && char === 40) openParen = i;
 	}
-	if (openParen < 1) throw new CallciumError("MALFORMED_SIGNATURE", `Invalid signature: must have a function name followed by parentheses, got "${signature}"`);
+	if (openParen === -1) throw new CallciumError("MALFORMED_SIGNATURE", `Invalid signature: must have a function name followed by parentheses, got "${signature}"`);
 	if (!signature.endsWith(")")) throw new CallciumError("MALFORMED_SIGNATURE", `Invalid signature: must end with ")", got "${signature}"`);
+	if (openParen === 0) throw new CallciumError("INVALID_FUNCTION_NAME", "Function name must not be empty");
 	const firstChar = signature.charCodeAt(0);
 	if (!isAlpha(firstChar) && firstChar !== 95) throw new CallciumError("INVALID_FUNCTION_NAME", "Function name must start with a letter or underscore");
 	for (let i = 1; i < openParen; i++) {
-		const c = signature.charCodeAt(i);
-		if (!isAlphanum(c) && c !== 95) throw new CallciumError("INVALID_FUNCTION_NAME", "Function name must contain only alphanumeric characters or underscores");
+		const char = signature.charCodeAt(i);
+		if (!isAlphanum(char) && char !== 95) throw new CallciumError("INVALID_FUNCTION_NAME", "Function name must contain only alphanumeric characters or underscores");
 	}
-	const encoded = new Uint8Array(signature.length);
-	for (let i = 0; i < signature.length; i++) encoded[i] = signature.charCodeAt(i);
 	return {
-		selector: bytesToHex(keccak_256(encoded).subarray(0, 4)),
+		selector: bytesToHex(keccak_256(utf8ToBytes(signature)).subarray(0, 4)),
 		types: signature.slice(openParen + 1, signature.length - 1)
 	};
 }
@@ -2515,8 +2765,7 @@ const SignatureParser = { parse };
 //#region src/policy-builder.ts
 function validateContextPath(steps) {
 	if (steps.length !== 1) throw new CallciumError("INVALID_CONTEXT_PATH", "Context-scope path must be exactly one step");
-	const step = steps[0];
-	if (step > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Unknown context property ID 0x${step.toString(16).padStart(4, "0")}`);
+	return lookupContextProperty(steps[0]).typeCode;
 }
 function validateCalldataPath(steps, desc) {
 	const argIndex = steps[0];
@@ -2545,6 +2794,33 @@ function validateCalldataPath(steps, desc) {
 			offset = Descriptor.arrayElementOffset(offset);
 		} else throw new CallciumError("NOT_COMPOSITE", "Cannot descend into an elementary type");
 	}
+	return Descriptor.inspect(desc, offset).typeCode;
+}
+const WORD_VALUES = 1n << 256n;
+function targetBounds(typeCode) {
+	if (typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX) return {
+		min: 0n,
+		max: (1n << BigInt(typeCode - TypeCode.UINT_MIN + 1) * 8n) - 1n
+	};
+	if (typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX) {
+		const half = 1n << BigInt(typeCode - TypeCode.INT_MIN + 1) * 8n - 1n;
+		return {
+			min: -half,
+			max: half - 1n
+		};
+	}
+	return null;
+}
+function reject(written, folded) {
+	throw new CallciumError("OUT_OF_PHYSICAL_BOUNDS", `Operand ${written} is outside the physical range of the type and encodes as ${folded}`);
+}
+function checkOperandDomain(constraint, typeCode) {
+	const bounds = targetBounds(typeCode);
+	const extremes = readOperandExtremes(constraint);
+	if (bounds === null || extremes === void 0) return;
+	if (extremes.leastNegative < 0n && typeCode === TypeCode.UINT_MAX) reject(extremes.leastNegative, extremes.leastNegative + WORD_VALUES);
+	if (!isSigned(typeCode)) return;
+	if (extremes.greatest >= WORD_VALUES + bounds.min) reject(extremes.greatest, extremes.greatest - WORD_VALUES);
 }
 var PolicyBuilder = class PolicyBuilder {
 	draft;
@@ -2559,7 +2835,7 @@ var PolicyBuilder = class PolicyBuilder {
 			selector: parsed.selector,
 			descriptor,
 			groups: [[]],
-			pathHashes: [/* @__PURE__ */ new Set()]
+			groupPathKeys: /* @__PURE__ */ new Set()
 		});
 	}
 	static createRaw(typesCsv) {
@@ -2568,32 +2844,34 @@ var PolicyBuilder = class PolicyBuilder {
 			selector: "0x00000000",
 			descriptor: DescriptorCoder.fromTypes(typesCsv),
 			groups: [[]],
-			pathHashes: [/* @__PURE__ */ new Set()]
+			groupPathKeys: /* @__PURE__ */ new Set()
 		});
 	}
 	add(constraint) {
-		const c = {
+		const added = {
 			scope: constraint.scope,
 			path: constraint.path,
-			operators: [...constraint.operators]
+			operators: [...constraint.operators],
+			..."hint" in constraint && constraint.hint !== void 0 && { hint: constraint.hint }
 		};
-		if (c.operators.length === 0) throw new CallciumError("NO_CONSTRAINT_OPERATORS", "Constraint must have at least one operator");
-		const steps = parsePathSteps(c.path);
+		if (added.operators.length === 0) throw new CallciumError("NO_CONSTRAINT_OPERATORS", "Constraint must have at least one operator");
+		const steps = parsePathSteps(added.path);
 		if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step");
-		if (c.scope === Scope.CONTEXT) validateContextPath(steps);
-		else if (c.scope === Scope.CALLDATA) validateCalldataPath(steps, this.draft.descriptor);
-		else throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${c.scope}`);
-		const key = `${c.scope}:${c.path.toLowerCase()}`;
-		const currentHashes = this.draft.pathHashes[this.draft.pathHashes.length - 1];
-		if (currentHashes.has(key)) throw new CallciumError("DUPLICATE_PATH_IN_GROUP", `Duplicate path ${c.path} in the same group`);
-		currentHashes.add(key);
-		this.draft.groups[this.draft.groups.length - 1].push(c);
+		let targetTypeCode;
+		if (added.scope === Scope.CONTEXT) targetTypeCode = validateContextPath(steps);
+		else if (added.scope === Scope.CALLDATA) targetTypeCode = validateCalldataPath(steps, this.draft.descriptor);
+		else throw new CallciumError("INVALID_SCOPE", `Unknown scope value ${added.scope}`);
+		checkOperandDomain(constraint, targetTypeCode);
+		const key = `${added.scope}:${added.path.toLowerCase()}`;
+		if (this.draft.groupPathKeys.has(key)) throw new CallciumError("DUPLICATE_PATH_IN_GROUP", `Duplicate path ${added.path} in the same group`);
+		this.draft.groupPathKeys.add(key);
+		this.draft.groups[this.draft.groups.length - 1].push(added);
 		return this;
 	}
 	or() {
 		if (this.draft.groups[this.draft.groups.length - 1].length === 0) throw new CallciumError("EMPTY_GROUP", "Cannot start a new group when the current group is empty");
 		this.draft.groups.push([]);
-		this.draft.pathHashes.push(/* @__PURE__ */ new Set());
+		this.draft.groupPathKeys.clear();
 		return this;
 	}
 	build() {
@@ -2625,167 +2903,16 @@ var PolicyBuilder = class PolicyBuilder {
 	}
 };
 //#endregion
-//#region src/constraint.ts
-function addressBody(value) {
-	return toAddress(value).slice(2);
-}
-function encodeWord(value) {
-	const word = new Uint8Array(32);
-	if (typeof value === "boolean") {
-		word[31] = value ? 1 : 0;
-		return word;
-	}
-	if (typeof value === "string") {
-		word.set(hexToBytes(addressBody(value)), 12);
-		return word;
-	}
-	let bigValue = typeof value === "number" ? BigInt(value) : value;
-	for (let i = 31; i >= 0; i--) {
-		word[i] = Number(bigValue & 255n);
-		bigValue >>= 8n;
-	}
-	return word;
-}
-function singleOp(opCode, value) {
-	const buffer = new Uint8Array(33);
-	buffer[0] = opCode;
-	buffer.set(encodeWord(value), 1);
-	return bytesToHex(buffer);
-}
-function rangeOp(opCode, min, max) {
-	if (min > max) throw new CallciumError("INVALID_RANGE", `Range min (${min}) must not exceed max (${max})`);
-	const buffer = new Uint8Array(65);
-	buffer[0] = opCode;
-	buffer.set(encodeWord(min), 1);
-	buffer.set(encodeWord(max), 33);
-	return bytesToHex(buffer);
-}
-function checkContextPropertyId(contextPropertyId) {
-	if (!Number.isInteger(contextPropertyId) || contextPropertyId < 0 || contextPropertyId > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Unknown context property ID ${contextPropertyId}`);
-	return contextPropertyId;
-}
-function setOp(opCode, values) {
-	const bigs = values.map((v) => {
-		if (typeof v === "bigint") return v;
-		if (typeof v === "number") return BigInt(v);
-		if (typeof v === "boolean") return v ? 1n : 0n;
-		return BigInt("0x" + addressBody(v));
-	});
-	const deduped = [...new Set(bigs)].toSorted((a, b) => a < b ? -1 : a > b ? 1 : 0);
-	if (deduped.length === 0) throw new CallciumError("EMPTY_SET", "Set must contain at least one value");
-	if (deduped.length > PolicyFormat.MAX_SET_MEMBERS) throw new CallciumError("SET_TOO_LARGE", `Set must contain at most ${PolicyFormat.MAX_SET_MEMBERS} values`);
-	const buffer = new Uint8Array(1 + deduped.length * 32);
-	buffer[0] = opCode;
-	for (let i = 0; i < deduped.length; i++) buffer.set(encodeWord(deduped[i]), 1 + i * 32);
-	return bytesToHex(buffer);
-}
-var ConstraintBuilder = class {
-	scope;
-	path;
-	operators;
-	constructor(scope, path) {
-		this.scope = scope;
-		this.path = path;
-		this.operators = [];
-	}
-	push(opHex) {
-		this.operators.push(opHex);
-		return this;
-	}
-	eq(value) {
-		return this.push(singleOp(Op.EQ, value));
-	}
-	neq(value) {
-		return this.push(singleOp(Op.EQ | Op.NOT, value));
-	}
-	eqCtx(contextPropertyId) {
-		return this.push(singleOp(Op.EQ_CTX, checkContextPropertyId(contextPropertyId)));
-	}
-	neqCtx(contextPropertyId) {
-		return this.push(singleOp(Op.EQ_CTX | Op.NOT, checkContextPropertyId(contextPropertyId)));
-	}
-	gt(bound) {
-		return this.push(singleOp(Op.GT, bound));
-	}
-	lt(bound) {
-		return this.push(singleOp(Op.LT, bound));
-	}
-	gte(bound) {
-		return this.push(singleOp(Op.GTE, bound));
-	}
-	lte(bound) {
-		return this.push(singleOp(Op.LTE, bound));
-	}
-	between(min, max) {
-		return this.push(rangeOp(Op.BETWEEN, BigInt(min), BigInt(max)));
-	}
-	isIn(values) {
-		return this.push(setOp(Op.IN, values));
-	}
-	notIn(values) {
-		return this.push(setOp(Op.IN | Op.NOT, values));
-	}
-	bitmaskAll(mask) {
-		return this.push(singleOp(Op.BITMASK_ALL, mask));
-	}
-	bitmaskAny(mask) {
-		return this.push(singleOp(Op.BITMASK_ANY, mask));
-	}
-	bitmaskNone(mask) {
-		return this.push(singleOp(Op.BITMASK_NONE, mask));
-	}
-	lengthEq(n) {
-		return this.push(singleOp(Op.LENGTH_EQ, n));
-	}
-	lengthGt(n) {
-		return this.push(singleOp(Op.LENGTH_GT, n));
-	}
-	lengthLt(n) {
-		return this.push(singleOp(Op.LENGTH_LT, n));
-	}
-	lengthGte(n) {
-		return this.push(singleOp(Op.LENGTH_GTE, n));
-	}
-	lengthLte(n) {
-		return this.push(singleOp(Op.LENGTH_LTE, n));
-	}
-	lengthBetween(min, max) {
-		return this.push(rangeOp(Op.LENGTH_BETWEEN, BigInt(min), BigInt(max)));
-	}
-};
-function arg(...steps) {
-	return new ConstraintBuilder(Scope.CALLDATA, encodePath(steps));
-}
-function msgSender() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.MSG_SENDER]));
-}
-function msgValue() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.MSG_VALUE]));
-}
-function blockTimestamp() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BLOCK_TIMESTAMP]));
-}
-function blockNumber() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BLOCK_NUMBER]));
-}
-function chainId() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.CHAIN_ID]));
-}
-function txOrigin() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.TX_ORIGIN]));
-}
-function baseFee() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.BASE_FEE]));
-}
-function gasPrice() {
-	return new ConstraintBuilder(Scope.CONTEXT, encodePath([ContextProperty.GAS_PRICE]));
-}
-//#endregion
 //#region src/calldata-reader.ts
 function loadWord(callData, offset) {
 	if (offset < 0 || offset + 32 > callData.length) return { code: "CALLDATA_OUT_OF_BOUNDS" };
 	return callData.subarray(offset, offset + 32);
 }
+function readLength(callData, head) {
+	const word = loadWord(callData, head);
+	if (word instanceof Uint8Array) return toBigInt(word, 0);
+	return word;
+}
 function readPointer(callData, head) {
 	const word = loadWord(callData, head);
 	if (word instanceof Uint8Array) {
@@ -2802,8 +2929,10 @@ const abortViolationCodes = new Set([
 	"NON_CANONICAL_VALUE",
 	"QUANTIFIER_LIMIT_EXCEEDED"
 ]);
-function addressToBigInt(hex) {
-	return BigInt(toAddress(hex));
+function contextValueToWord(value) {
+	if (typeof value === "string") return BigInt(toAddress(value));
+	if (BigInt.asUintN(256, value) !== value) throw new CallciumError("CONTEXT_VALUE_OVERFLOW", `Context value ${value} is outside the range a 32-byte word represents`);
+	return value;
 }
 function check(policy, callData, context) {
 	const { policy: decoded, data: policyBytes } = decodePolicy(policy);
@@ -2870,7 +2999,11 @@ function resolveContextOperand(operandData, context) {
 	const propertyInfo = lookupContextProperty(Number(toBigInt(operandData, 0)));
 	const value = context?.[propertyInfo.contextKey];
 	if (value === void 0) return { ctxTypeCode: propertyInfo.typeCode };
-	return typeof value === "string" ? addressToBigInt(value) : value;
+	return contextValueToWord(value);
+}
+function referenceOperand(opCode, operandData, context) {
+	if ((opCode & ~Op.NOT) !== Op.EQ_CTX) return void 0;
+	return resolveContextOperand(operandData, context);
 }
 function readTargetBlock(hint, targetOffset) {
 	return {
@@ -2882,6 +3015,7 @@ function readTargetBlock(hint, targetOffset) {
 function follow(callData, from, at) {
 	const word = readPointer(callData, at);
 	if (typeof word !== "number") return word;
+	if (from > callData.length || word > callData.length - from) return { code: "CALLDATA_OUT_OF_BOUNDS" };
 	return from + word;
 }
 function chainResolve(hint, callData, base, hopsOffset, hopCount) {
@@ -2897,8 +3031,8 @@ function chainResolve(hint, callData, base, hopsOffset, hopCount) {
 		const meta = readU16(hint, hop + PolicyFormat.HINT_HOP_META_OFFSET);
 		let elems = base;
 		if ((meta & PolicyFormat.HINT_META_DYNAMIC_ARRAY) !== 0) {
-			const length = readPointer(callData, elems);
-			if (typeof length !== "number") return length;
+			const length = readLength(callData, elems);
+			if (typeof length !== "bigint") return length;
 			if (index >= length) return { code: "ARRAY_INDEX_OUT_OF_BOUNDS" };
 			elems += 32;
 		}
@@ -2911,21 +3045,19 @@ function chainResolve(hint, callData, base, hopsOffset, hopCount) {
 	}
 	return base;
 }
-function evalTarget(callData, target, block, opCode, operandData, context) {
+function evalTarget(callData, target, block, opCode, operandData, ctxOperand) {
 	const typeCode = block.typeCode;
 	if (isLengthValidType(typeCode)) {
-		if (!isLengthOp(opCode)) throw new CallciumError("OPERATOR_TARGET_MISMATCH", "Value operator on a target without a scalar word");
-		const length = readPointer(callData, target);
-		if (typeof length !== "number") return { error: length.code };
+		const length = readLength(callData, target);
+		if (typeof length !== "bigint") return { error: length.code };
 		const stride = typeCode === TypeCode.DYNAMIC_ARRAY ? (block.targetMeta & PolicyFormat.HINT_META_STRIDE_MASK) * 32 : 1;
 		const room = callData.length - (target + 32);
-		if (stride !== 0 && length > Math.floor(room / stride)) return { error: "CALLDATA_OUT_OF_BOUNDS" };
+		if (stride !== 0 && length > BigInt(Math.floor(room / stride))) return { error: "CALLDATA_OUT_OF_BOUNDS" };
 		return {
 			passed: applyOperator(opCode, 0n, length, operandData, typeCode),
-			value: BigInt(length)
+			value: length
 		};
 	}
-	if (classifyTypeCode(typeCode).typeClass !== "elementary") throw new CallciumError("OPERATOR_TARGET_MISMATCH", "Operator target does not carry a scalar word");
 	const word = loadWord(callData, target);
 	if (!(word instanceof Uint8Array)) return { error: word.code };
 	const value = toBigInt(word, 0);
@@ -2933,57 +3065,50 @@ function evalTarget(callData, target, block, opCode, operandData, context) {
 		error: "NON_CANONICAL_VALUE",
 		value
 	};
-	if ((opCode & ~Op.NOT) === Op.EQ_CTX) {
-		const operand = resolveContextOperand(operandData, context);
-		if (typeof operand !== "bigint") return {
+	if (ctxOperand !== void 0) {
+		if (typeof ctxOperand !== "bigint") return {
 			error: "MISSING_CONTEXT",
-			ctxTypeCode: operand.ctxTypeCode
+			ctxTypeCode: ctxOperand.ctxTypeCode
 		};
 		return {
-			passed: value === operand !== ((opCode & Op.NOT) !== 0),
+			passed: value === ctxOperand !== ((opCode & Op.NOT) !== 0),
 			value,
-			ctxOperand: operand
+			ctxOperand
 		};
 	}
 	return {
-		passed: applyOperator(opCode, value, 32, operandData, typeCode),
+		passed: applyOperator(opCode, value, 32n, operandData, typeCode),
 		value
 	};
 }
-function navigationViolation(frame, code, elementIndex) {
+function ruleFields(frame) {
 	return {
 		group: frame.group,
 		rule: frame.rule,
-		code,
 		scope: Scope.CALLDATA,
 		path: frame.path,
 		opCode: frame.opCode,
 		operandData: bytesToHex(frame.operandData),
-		typeCode: frame.typeCode,
+		typeCode: frame.typeCode
+	};
+}
+function navigationViolation(frame, code, elementIndex) {
+	return {
+		code,
+		...ruleFields(frame),
 		...elementIndex !== void 0 && { elementIndex }
 	};
 }
 function targetViolation(frame, result, elementIndex) {
 	if ("error" in result) {
 		if (result.error === "MISSING_CONTEXT") return {
-			group: frame.group,
-			rule: frame.rule,
 			code: result.error,
-			scope: Scope.CALLDATA,
-			path: frame.path,
-			opCode: frame.opCode,
-			operandData: bytesToHex(frame.operandData),
+			...ruleFields(frame),
 			typeCode: result.ctxTypeCode
 		};
 		if (result.error === "NON_CANONICAL_VALUE") return {
-			group: frame.group,
-			rule: frame.rule,
 			code: result.error,
-			scope: Scope.CALLDATA,
-			path: frame.path,
-			opCode: frame.opCode,
-			operandData: bytesToHex(frame.operandData),
-			typeCode: frame.typeCode,
+			...ruleFields(frame),
 			resolvedValue: bigintToHex(result.value),
 			...elementIndex !== void 0 && { elementIndex }
 		};
@@ -2991,14 +3116,8 @@ function targetViolation(frame, result, elementIndex) {
 	}
 	if (result.passed) return null;
 	return {
-		group: frame.group,
-		rule: frame.rule,
 		code: "VALUE_MISMATCH",
-		scope: Scope.CALLDATA,
-		path: frame.path,
-		opCode: frame.opCode,
-		operandData: bytesToHex(frame.operandData),
-		typeCode: frame.typeCode,
+		...ruleFields(frame),
 		resolvedValue: bigintToHex(result.value),
 		...result.ctxOperand !== void 0 && { resolvedOperand: bigintToHex(result.ctxOperand) },
 		...elementIndex !== void 0 && { elementIndex }
@@ -3021,7 +3140,7 @@ function evaluateCalldataRule(hint, callDataBytes, baseOffset, opCode, operandDa
 	};
 	const base = chainResolve(hint, callDataBytes, baseOffset, hopsOffset, hopCount);
 	if (typeof base !== "number") return navigationViolation(frame, base.code);
-	return targetViolation(frame, evalTarget(callDataBytes, base + block.targetDelta, block, opCode, operandData, context));
+	return targetViolation(frame, evalTarget(callDataBytes, base + block.targetDelta, block, opCode, operandData, referenceOperand(opCode, operandData, context)));
 }
 function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, hopCount, opCode, operandData, groupIndex, ruleIndex, pathHex, context) {
 	const frameOffset = hopsOffset + hopCount * PolicyFormat.HINT_HOP_SIZE;
@@ -3040,23 +3159,23 @@ function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, h
 	const chained = chainResolve(hint, callDataBytes, baseOffset, hopsOffset, hopCount);
 	if (typeof chained !== "number") return navigationViolation(frame, chained.code);
 	let elems = chained + readU32(hint, frameOffset);
-	let count = readU16(hint, frameOffset + PolicyFormat.HINT_FRAME_COUNT_OFFSET);
-	if (count === 0) {
-		const length = readPointer(callDataBytes, elems);
-		if (typeof length !== "number") return navigationViolation(frame, length.code);
+	let count = BigInt(readU16(hint, frameOffset + PolicyFormat.HINT_FRAME_COUNT_OFFSET));
+	if (count === 0n) {
+		const length = readLength(callDataBytes, elems);
+		if (typeof length !== "bigint") return navigationViolation(frame, length.code);
 		count = length;
 		elems += 32;
 	}
-	if (count > PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH) return {
+	if (count > BigInt(PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH)) return {
 		group: groupIndex,
 		rule: ruleIndex,
 		code: "QUANTIFIER_LIMIT_EXCEEDED",
 		scope: Scope.CALLDATA,
 		path: pathHex,
-		resolvedValue: bigintToHex(BigInt(count))
+		resolvedValue: bigintToHex(count)
 	};
 	const isUniversal = kind === PolicyFormat.HINT_KIND_ALL;
-	if (count === 0) {
+	if (count === 0n) {
 		if (isUniversal) return null;
 		return {
 			group: groupIndex,
@@ -3069,7 +3188,7 @@ function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, h
 	const meta = readU16(hint, frameOffset + PolicyFormat.HINT_FRAME_META_OFFSET);
 	const elemStride = (meta & PolicyFormat.HINT_META_STRIDE_MASK) * 32;
 	const elemIsDynamic = (meta & PolicyFormat.HINT_META_ELEM_DYNAMIC) !== 0;
-	let ctxOperand;
+	const reference = referenceOperand(opCode, operandData, context);
 	for (let elemIndex = 0; elemIndex < count; elemIndex++) {
 		const slot = elems + elemIndex * elemStride;
 		let elem = slot;
@@ -3084,65 +3203,51 @@ function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, h
 			if (typeof chainedElem !== "number") return navigationViolation(frame, chainedElem.code, elemIndex);
 			base = chainedElem;
 		}
-		const applied = evalTarget(callDataBytes, base + block.targetDelta, block, opCode, operandData, context);
+		const applied = evalTarget(callDataBytes, base + block.targetDelta, block, opCode, operandData, reference);
 		if ("error" in applied) return targetViolation(frame, applied, elemIndex);
 		if (applied.passed) {
 			if (!isUniversal) return null;
 		} else if (isUniversal) return targetViolation(frame, applied, elemIndex);
-		ctxOperand = applied.ctxOperand;
 	}
 	if (isUniversal) return null;
 	return {
-		group: groupIndex,
-		rule: ruleIndex,
 		code: "VALUE_MISMATCH",
-		scope: Scope.CALLDATA,
-		path: pathHex,
-		opCode,
-		operandData: bytesToHex(operandData),
-		typeCode: block.typeCode,
-		...ctxOperand !== void 0 && { resolvedOperand: bigintToHex(ctxOperand) }
+		...ruleFields(frame),
+		...typeof reference === "bigint" && { resolvedOperand: bigintToHex(reference) }
 	};
 }
 function evaluateContextRule(pathBytes, opCode, operandData, groupIndex, ruleIndex, pathHex, context) {
-	const propertyId = readU16(pathBytes, 0);
-	if (propertyId > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Unknown context property ID 0x${propertyId.toString(16).padStart(4, "0")}`);
-	const propertyInfo = lookupContextProperty(propertyId);
+	const propertyInfo = lookupContextProperty(readU16(pathBytes, 0));
 	const contextValue = context?.[propertyInfo.contextKey];
-	if (contextValue === void 0) return {
+	const site = {
 		group: groupIndex,
 		rule: ruleIndex,
-		code: "MISSING_CONTEXT",
 		scope: Scope.CONTEXT,
-		path: pathHex,
+		path: pathHex
+	};
+	if (contextValue === void 0) return {
+		code: "MISSING_CONTEXT",
+		...site,
 		typeCode: propertyInfo.typeCode
 	};
-	let value;
-	if (typeof contextValue === "string") value = addressToBigInt(contextValue);
-	else value = contextValue;
+	const value = contextValueToWord(contextValue);
 	let result;
 	let ctxOperand;
 	if ((opCode & ~Op.NOT) === Op.EQ_CTX) {
 		const operand = resolveContextOperand(operandData, context);
 		if (typeof operand !== "bigint") return {
-			group: groupIndex,
-			rule: ruleIndex,
 			code: "MISSING_CONTEXT",
-			scope: Scope.CONTEXT,
-			path: pathHex,
+			...site,
 			opCode,
 			operandData: bytesToHex(operandData),
 			typeCode: operand.ctxTypeCode
 		};
 		result = value === operand !== ((opCode & Op.NOT) !== 0);
 		ctxOperand = operand;
-	} else result = applyOperator(opCode, value, 32, operandData, propertyInfo.typeCode);
+	} else result = applyOperator(opCode, value, 32n, operandData, propertyInfo.typeCode);
 	if (!result) return {
-		group: groupIndex,
-		rule: ruleIndex,
 		code: "VALUE_MISMATCH",
-		scope: Scope.CONTEXT,
-		path: pathHex,
+		...site,
 		opCode,
 		operandData: bytesToHex(operandData),
 		typeCode: propertyInfo.typeCode,
@@ -3156,6 +3261,6 @@ const PolicyEnforcer = {
 	enforce
 };
 //#endregion
-export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, MAX_CONTEXT_PROPERTY_ID, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyFormat, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, ValidationError, arg, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
+export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, MAX_CONTEXT_PROPERTY_ID, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyFormat, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, ValidationError, arg, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, findContextProperty, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
 
 //# sourceMappingURL=index.js.map