@callcium/sdk 0.8.0 → 0.10.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { keccak_256 } from "@noble/hashes/sha3.js";
 //#region src/errors.ts
-var CallciumError = class CallciumError extends Error {
+var CallciumError = class extends Error {
 	code;
 	offset;
 	constructor(code, message, offset) {
@@ -8,25 +8,22 @@ var CallciumError = class CallciumError extends Error {
 		super(`${prefix}${message}`);
 		this.name = "CallciumError";
 		this.code = code;
-		Object.setPrototypeOf(this, CallciumError.prototype);
 	}
 };
-var ValidationError = class ValidationError extends CallciumError {
+var ValidationError = class extends CallciumError {
 	issues;
 	constructor(issues) {
 		super("VALIDATION_ERROR", issues[0]?.message ?? "Policy validation failed");
 		this.name = "ValidationError";
 		this.issues = issues;
-		Object.setPrototypeOf(this, ValidationError.prototype);
 	}
 };
-var PolicyViolationError = class PolicyViolationError extends Error {
+var PolicyViolationError = class extends Error {
 	violations;
 	constructor(violations) {
 		super(formatDiagnostic(violations[0]));
 		this.name = "PolicyViolationError";
 		this.violations = violations;
-		Object.setPrototypeOf(this, PolicyViolationError.prototype);
 	}
 };
 function formatDiagnostic(violation) {
@@ -36,29 +33,29 @@ function formatDiagnostic(violation) {
 }
 //#endregion
 //#region src/bytes.ts
-const HEX_BODY_RE = /^[0-9a-fA-F]*$/;
+const hexBodyPattern = /^[0-9a-fA-F]*$/;
 const HEX_DIGITS = "0123456789abcdef";
-const NIBBLE = new Int8Array(128).fill(-1);
+const nibble = new Int8Array(128).fill(-1);
 for (let value = 0; value < 16; value++) {
-	NIBBLE[HEX_DIGITS.charCodeAt(value)] = value;
-	NIBBLE[HEX_DIGITS.toUpperCase().charCodeAt(value)] = value;
+	nibble[HEX_DIGITS.charCodeAt(value)] = value;
+	nibble[HEX_DIGITS.toUpperCase().charCodeAt(value)] = value;
 }
 function hexToBytes(hex) {
 	const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
 	if (clean.length % 2 !== 0) throw new CallciumError("INVALID_HEX", "Odd-length hex string");
 	const bytes = new Uint8Array(clean.length / 2);
 	for (let i = 0; i < bytes.length; i++) {
-		const high = NIBBLE[clean.charCodeAt(i * 2)] ?? -1;
-		const low = NIBBLE[clean.charCodeAt(i * 2 + 1)] ?? -1;
+		const high = nibble[clean.charCodeAt(i * 2)] ?? -1;
+		const low = nibble[clean.charCodeAt(i * 2 + 1)] ?? -1;
 		if (high < 0 || low < 0) throw new CallciumError("INVALID_HEX", "Invalid hex characters");
 		bytes[i] = high << 4 | low;
 	}
 	return bytes;
 }
-const HEX_LUT = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+const hexPairs = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function bytesToHex(bytes) {
 	let body = "";
-	for (let i = 0; i < bytes.length; i++) body += HEX_LUT[bytes[i]];
+	for (let i = 0; i < bytes.length; i++) body += hexPairs[bytes[i]];
 	return `0x${body}`;
 }
 function toHex(data, start, end) {
@@ -94,7 +91,7 @@ function bigintToHex(value) {
 function toAddress(hex) {
 	const body = hex.startsWith("0x") ? hex.slice(2) : hex;
 	if (body.length !== 40) throw new CallciumError("INVALID_HEX", `Invalid address length: expected 40 hex chars, got ${body.length}`);
-	if (!HEX_BODY_RE.test(body)) throw new CallciumError("INVALID_HEX", "Invalid hex characters in address");
+	if (!hexBodyPattern.test(body)) throw new CallciumError("INVALID_HEX", "Invalid hex characters in address");
 	return `0x${body}`;
 }
 //#endregion
@@ -117,6 +114,7 @@ const DescriptorFormat = {
 	MAX_PARAMS: 255,
 	MAX_NESTING_DEPTH: 64
 };
+const RULE_DATALENGTH_SIZE = 2;
 const PolicyFormat = {
 	VERSION: 2,
 	VERSION_MASK: 15,
@@ -138,7 +136,7 @@ const PolicyFormat = {
 	RULE_PATH_OFFSET: 4,
 	PATH_STEP_SIZE: 2,
 	RULE_OPCODE_SIZE: 1,
-	RULE_DATALENGTH_SIZE: 2,
+	RULE_DATALENGTH_SIZE,
 	RULE_FIXED_OVERHEAD: 7,
 	RULE_MIN_SIZE: 9,
 	HINT_HEADER_SIZE: 1,
@@ -163,7 +161,10 @@ const PolicyFormat = {
 	HINT_META_ELEM_DYNAMIC: 32768,
 	HINT_META_DYNAMIC_ARRAY: 16384,
 	HINT_META_RESERVED_MASK: 12288,
-	HINT_META_STRIDE_MASK: 4095
+	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)
 };
 function buildCodeMap(table) {
 	return Object.fromEntries(table.map((e) => [e.key, e.code]));
@@ -200,83 +201,76 @@ const TypeCode = {
 	DYNAMIC_ARRAY: 129,
 	TUPLE: 144
 };
-const CTX_PROP_TABLE = [
+const CTX_PROPERTY_TABLE = [
 	{
 		key: "MSG_SENDER",
 		code: 0,
 		label: "msg.sender",
+		contextKey: "msgSender",
 		typeCode: TypeCode.ADDRESS
 	},
 	{
 		key: "MSG_VALUE",
 		code: 1,
 		label: "msg.value",
+		contextKey: "msgValue",
 		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "BLOCK_TIMESTAMP",
 		code: 2,
 		label: "block.timestamp",
+		contextKey: "blockTimestamp",
 		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "BLOCK_NUMBER",
 		code: 3,
 		label: "block.number",
+		contextKey: "blockNumber",
 		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "CHAIN_ID",
 		code: 4,
 		label: "block.chainid",
+		contextKey: "chainId",
 		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "TX_ORIGIN",
 		code: 5,
 		label: "tx.origin",
+		contextKey: "txOrigin",
 		typeCode: TypeCode.ADDRESS
 	},
 	{
 		key: "BASE_FEE",
 		code: 6,
 		label: "block.basefee",
+		contextKey: "baseFee",
 		typeCode: TypeCode.UINT_MAX
 	},
 	{
 		key: "GAS_PRICE",
 		code: 7,
 		label: "tx.gasprice",
+		contextKey: "gasPrice",
 		typeCode: TypeCode.UINT_MAX
 	}
 ];
-const ContextProperty = buildCodeMap(CTX_PROP_TABLE);
-const MAX_CONTEXT_PROPERTY_ID = Math.max(...CTX_PROP_TABLE.map((e) => e.code));
-const CTX_KEY_MAP = {
-	MSG_SENDER: "msgSender",
-	MSG_VALUE: "msgValue",
-	BLOCK_TIMESTAMP: "blockTimestamp",
-	BLOCK_NUMBER: "blockNumber",
-	CHAIN_ID: "chainId",
-	TX_ORIGIN: "txOrigin",
-	BASE_FEE: "baseFee",
-	GAS_PRICE: "gasPrice"
-};
-const ctxPropByCode = new Map(CTX_PROP_TABLE.map((e) => [e.code, {
+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: CTX_KEY_MAP[e.key],
+	contextKey: e.contextKey,
 	typeCode: e.typeCode
 }]));
 function lookupContextProperty(code) {
-	const info = ctxPropByCode.get(code);
+	const info = ctxPropertyByCode.get(code);
 	if (!info) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Unknown context property ${code}`);
 	return info;
 }
-const Limits = {
-	MAX_PATH_DEPTH: 32,
-	MAX_QUANTIFIED_ARRAY_LENGTH: 256,
-	MAX_SET_MEMBERS: Math.floor((256 ** PolicyFormat.RULE_DATALENGTH_SIZE - 1) / 32)
-};
 const OP_TABLE = [
 	{
 		key: "EQ",
@@ -320,6 +314,12 @@ const OP_TABLE = [
 		label: "in",
 		operands: "variadic"
 	},
+	{
+		key: "EQ_CTX",
+		code: 8,
+		label: "== ctx",
+		operands: "single"
+	},
 	{
 		key: "BITMASK_ALL",
 		code: 16,
@@ -389,13 +389,11 @@ function lookupOp(code) {
 	if (!info) throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}`);
 	return info;
 }
-function isValidOperatorData(opBase, dataLength) {
-	const operands = opByCode.get(opBase)?.operands;
-	if (operands === "single") return dataLength === 32;
-	if (operands === "range") return dataLength === 64;
-	if (operands === "variadic") return dataLength > 0 && dataLength % 32 === 0;
-	return false;
+function operandsOf(opBase) {
+	return opByCode.get(opBase)?.operands;
 }
+//#endregion
+//#region src/path.ts
 const QUANTIFIER_TABLE = [{
 	key: "ALL",
 	code: 65535,
@@ -415,71 +413,17 @@ function lookupQuantifier(code) {
 	if (!info) throw new CallciumError("UNKNOWN_QUANTIFIER", `Unknown quantifier step 0x${code.toString(16)}`);
 	return info;
 }
-function unknownTypeCode(code) {
-	throw new CallciumError("UNKNOWN_TYPE_CODE", `Unknown type code 0x${code.toString(16).padStart(2, "0")}`);
-}
-const ELEMENTARY = {
-	typeClass: "elementary",
-	isDynamic: false
-};
-const ELEMENTARY_DYN = {
-	typeClass: "elementary",
-	isDynamic: true
-};
-const STATIC_ARR = {
-	typeClass: "staticArray",
-	isDynamic: false
-};
-const DYNAMIC_ARR = {
-	typeClass: "dynamicArray",
-	isDynamic: true
-};
-const TUPLE = {
-	typeClass: "tuple",
-	isDynamic: false
-};
-function classifyTypeCode(code) {
-	if (code >= TypeCode.UINT_MIN && code <= TypeCode.UINT_MAX) return ELEMENTARY;
-	if (code >= TypeCode.INT_MIN && code <= TypeCode.INT_MAX) return ELEMENTARY;
-	if (code === TypeCode.ADDRESS || code === TypeCode.BOOL || code === TypeCode.FUNCTION) return ELEMENTARY;
-	if (code >= 68 && code <= 79) unknownTypeCode(code);
-	if (code >= TypeCode.FIXED_BYTES_MIN && code <= TypeCode.FIXED_BYTES_MAX) return ELEMENTARY;
-	if (code === TypeCode.BYTES || code === TypeCode.STRING) return ELEMENTARY_DYN;
-	if (code >= 114 && code <= 127) unknownTypeCode(code);
-	if (code === TypeCode.STATIC_ARRAY) return STATIC_ARR;
-	if (code === TypeCode.DYNAMIC_ARRAY) return DYNAMIC_ARR;
-	if (code >= 130 && code <= 143) unknownTypeCode(code);
-	if (code === TypeCode.TUPLE) return TUPLE;
-	unknownTypeCode(code);
-}
-function isAddressableTarget(code) {
-	let info;
-	try {
-		info = classifyTypeCode(code);
-	} catch {
-		return false;
-	}
-	return info.typeClass === "elementary" || info.typeClass === "dynamicArray";
-}
-function typeCodeLabel(code) {
-	if (code >= TypeCode.UINT_MIN && code <= TypeCode.UINT_MAX) return `uint${(code - TypeCode.UINT_MIN + 1) * 8}`;
-	if (code >= TypeCode.INT_MIN && code <= TypeCode.INT_MAX) return `int${(code - TypeCode.INT_MIN + 1) * 8}`;
-	if (code === TypeCode.ADDRESS) return "address";
-	if (code === TypeCode.BOOL) return "bool";
-	if (code === TypeCode.FUNCTION) return "function";
-	if (code >= TypeCode.FIXED_BYTES_MIN && code <= TypeCode.FIXED_BYTES_MAX) return `bytes${code - TypeCode.FIXED_BYTES_MIN + 1}`;
-	if (code === TypeCode.BYTES) return "bytes";
-	if (code === TypeCode.STRING) return "string";
-	if (code === TypeCode.STATIC_ARRAY) return "T[k]";
-	if (code === TypeCode.DYNAMIC_ARRAY) return "T[]";
-	if (code === TypeCode.TUPLE) return "tuple";
-	return `0x${code.toString(16).padStart(2, "0")}`;
+function encodePath(steps) {
+	const buffer = new Uint8Array(steps.length * 2);
+	for (let i = 0; i < steps.length; i++) writeBE16(buffer, i * 2, steps[i]);
+	return bytesToHex(buffer);
 }
-function lookupTypeCode(code) {
-	return {
-		label: typeCodeLabel(code),
-		...classifyTypeCode(code)
-	};
+function parsePathSteps(path) {
+	const bytes = hexToBytes(path);
+	if (bytes.length % PolicyFormat.PATH_STEP_SIZE !== 0) throw new CallciumError("MALFORMED_PATH", `Path byte length ${bytes.length} is not a whole number of steps`);
+	const steps = [];
+	for (let offset = 0; offset < bytes.length; offset += PolicyFormat.PATH_STEP_SIZE) steps.push(readU16(bytes, offset));
+	return steps;
 }
 //#endregion
 //#region src/descriptor.ts
@@ -497,7 +441,7 @@ function paramCount(desc) {
 }
 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}).`);
+	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;
@@ -517,10 +461,10 @@ 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.");
+	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}).`);
+	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++) {
@@ -528,16 +472,16 @@ function walkPath(desc, steps) {
 		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).`);
+			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}).`);
+				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}.`);
+		} else throw new CallciumError("NOT_COMPOSITE", `Cannot descend into elementary type at offset ${cursor}`);
 	}
 	return {
 		typeInfo: inspect$1(desc, cursor),
@@ -555,7 +499,7 @@ 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.`);
+	return new CallciumError("UNCOMPILABLE_PATH", `Path step ${stepIndex} does not resolve to a hop-chain target`);
 }
 function headSpan(desc, offset, count) {
 	let span = 0;
@@ -662,7 +606,7 @@ function encodeHint(walk, targetMeta, typeCode, depth) {
 	return out;
 }
 function compileHint(desc, steps) {
-	if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step.");
+	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);
@@ -698,6 +642,199 @@ const Descriptor = {
 	compileHint
 };
 //#endregion
+//#region src/operators.ts
+function toBigInt(bytes, offset = 0) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset + offset, 32);
+	return view.getBigUint64(0, false) << 192n | view.getBigUint64(8, false) << 128n | view.getBigUint64(16, false) << 64n | view.getBigUint64(24, false);
+}
+function isSigned(typeCode) {
+	return typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
+}
+function isLeftAligned(typeCode) {
+	return typeCode >= TypeCode.FIXED_BYTES_MIN && typeCode <= TypeCode.FIXED_BYTES_MAX || typeCode === TypeCode.FUNCTION;
+}
+function canonicalize(value, typeCode) {
+	if (typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX) {
+		const bits = BigInt(typeCode * 8);
+		return bits === 256n ? value : value & (1n << bits) - 1n;
+	}
+	if (typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX) {
+		const bits = (typeCode - TypeCode.INT_MIN + 1) * 8;
+		return bits === 256 ? value : BigInt.asUintN(256, BigInt.asIntN(bits, value));
+	}
+	if (typeCode === TypeCode.ADDRESS) return value & (1n << 160n) - 1n;
+	if (typeCode === TypeCode.BOOL) return value & 1n;
+	if (typeCode === TypeCode.FUNCTION) return value >> 64n << 64n;
+	if (typeCode >= TypeCode.FIXED_BYTES_MIN && typeCode <= TypeCode.FIXED_BYTES_MAX) {
+		const n = typeCode - TypeCode.FIXED_BYTES_MIN + 1;
+		if (n === 32) return value;
+		const padBits = BigInt((32 - n) * 8);
+		return value >> padBits << padBits;
+	}
+	return value;
+}
+function isLengthOp(opCode) {
+	const base = opCode & ~Op.NOT;
+	return base >= Op.LENGTH_EQ && base <= Op.LENGTH_BETWEEN;
+}
+function lengthToValueOp(base) {
+	if (base === Op.LENGTH_EQ) return Op.EQ;
+	if (base === Op.LENGTH_GT) return Op.GT;
+	if (base === Op.LENGTH_LT) return Op.LT;
+	if (base === Op.LENGTH_GTE) return Op.GTE;
+	if (base === Op.LENGTH_LTE) return Op.LTE;
+	return Op.BETWEEN;
+}
+function isLengthValidType(typeCode) {
+	return typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING || typeCode === TypeCode.DYNAMIC_ARRAY;
+}
+function compareTyped(a, b, typeCode) {
+	if (isSigned(typeCode)) {
+		const sa = BigInt.asIntN(256, a);
+		const sb = BigInt.asIntN(256, b);
+		return sa < sb ? -1 : sa > sb ? 1 : 0;
+	}
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function isIn(value, data) {
+	const count = data.length / 32;
+	let low = 0;
+	let high = count - 1;
+	while (low <= high) {
+		const mid = low + high >>> 1;
+		const elem = toBigInt(data, mid * 32);
+		if (value === elem) return true;
+		if (value < elem) high = mid - 1;
+		else low = mid + 1;
+	}
+	return false;
+}
+function applyOperator(opCode, value, valueLength, operandData, typeCode) {
+	let base = opCode & ~Op.NOT;
+	if (isLengthOp(base)) {
+		value = BigInt(valueLength);
+		typeCode = TypeCode.UINT_MAX;
+		base = lengthToValueOp(base);
+	}
+	let result;
+	switch (base) {
+		case Op.EQ:
+			result = value === toBigInt(operandData, 0);
+			break;
+		case Op.GT:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) > 0;
+			break;
+		case Op.LT:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) < 0;
+			break;
+		case Op.GTE:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) >= 0;
+			break;
+		case Op.LTE:
+			result = compareTyped(value, toBigInt(operandData, 0), typeCode) <= 0;
+			break;
+		case Op.BETWEEN: {
+			const min = toBigInt(operandData, 0);
+			const max = toBigInt(operandData, 32);
+			result = compareTyped(value, min, typeCode) >= 0 && compareTyped(value, max, typeCode) <= 0;
+			break;
+		}
+		case Op.IN:
+			result = isIn(value, operandData);
+			break;
+		case Op.BITMASK_ALL: {
+			const mask = toBigInt(operandData, 0);
+			result = (value & mask) === mask;
+			break;
+		}
+		case Op.BITMASK_ANY: {
+			const mask = toBigInt(operandData, 0);
+			result = (value & mask) !== 0n;
+			break;
+		}
+		case Op.BITMASK_NONE: {
+			const mask = toBigInt(operandData, 0);
+			result = (value & mask) === 0n;
+			break;
+		}
+		default: throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}`);
+	}
+	return (opCode & Op.NOT) !== 0 ? !result : result;
+}
+function isValidOperatorData(opBase, dataLength) {
+	const operands = operandsOf(opBase);
+	if (operands === "single") return dataLength === 32;
+	if (operands === "range") return dataLength === 64;
+	if (operands === "variadic") return dataLength > 0 && dataLength % 32 === 0;
+	return false;
+}
+function unknownTypeCode(code) {
+	throw new CallciumError("UNKNOWN_TYPE_CODE", `Unknown type code 0x${code.toString(16).padStart(2, "0")}`);
+}
+const ELEMENTARY = {
+	typeClass: "elementary",
+	isDynamic: false
+};
+const ELEMENTARY_DYNAMIC = {
+	typeClass: "elementary",
+	isDynamic: true
+};
+const STATIC_ARR = {
+	typeClass: "staticArray",
+	isDynamic: false
+};
+const DYNAMIC_ARR = {
+	typeClass: "dynamicArray",
+	isDynamic: true
+};
+const TUPLE = {
+	typeClass: "tuple",
+	isDynamic: false
+};
+function classifyTypeCode(code) {
+	if (code >= TypeCode.UINT_MIN && code <= TypeCode.UINT_MAX) return ELEMENTARY;
+	if (code >= TypeCode.INT_MIN && code <= TypeCode.INT_MAX) return ELEMENTARY;
+	if (code === TypeCode.ADDRESS || code === TypeCode.BOOL || code === TypeCode.FUNCTION) return ELEMENTARY;
+	if (code >= 68 && code <= 79) unknownTypeCode(code);
+	if (code >= TypeCode.FIXED_BYTES_MIN && code <= TypeCode.FIXED_BYTES_MAX) return ELEMENTARY;
+	if (code === TypeCode.BYTES || code === TypeCode.STRING) return ELEMENTARY_DYNAMIC;
+	if (code >= 114 && code <= 127) unknownTypeCode(code);
+	if (code === TypeCode.STATIC_ARRAY) return STATIC_ARR;
+	if (code === TypeCode.DYNAMIC_ARRAY) return DYNAMIC_ARR;
+	if (code >= 130 && code <= 143) unknownTypeCode(code);
+	if (code === TypeCode.TUPLE) return TUPLE;
+	unknownTypeCode(code);
+}
+function isAddressableTarget(code) {
+	let info;
+	try {
+		info = classifyTypeCode(code);
+	} catch {
+		return false;
+	}
+	return info.typeClass === "elementary" || info.typeClass === "dynamicArray";
+}
+function typeCodeLabel(code) {
+	if (code >= TypeCode.UINT_MIN && code <= TypeCode.UINT_MAX) return `uint${(code - TypeCode.UINT_MIN + 1) * 8}`;
+	if (code >= TypeCode.INT_MIN && code <= TypeCode.INT_MAX) return `int${(code - TypeCode.INT_MIN + 1) * 8}`;
+	if (code === TypeCode.ADDRESS) return "address";
+	if (code === TypeCode.BOOL) return "bool";
+	if (code === TypeCode.FUNCTION) return "function";
+	if (code >= TypeCode.FIXED_BYTES_MIN && code <= TypeCode.FIXED_BYTES_MAX) return `bytes${code - TypeCode.FIXED_BYTES_MIN + 1}`;
+	if (code === TypeCode.BYTES) return "bytes";
+	if (code === TypeCode.STRING) return "string";
+	if (code === TypeCode.STATIC_ARRAY) return "T[k]";
+	if (code === TypeCode.DYNAMIC_ARRAY) return "T[]";
+	if (code === TypeCode.TUPLE) return "tuple";
+	return `0x${code.toString(16).padStart(2, "0")}`;
+}
+function lookupTypeCode(code) {
+	return {
+		label: typeCodeLabel(code),
+		...classifyTypeCode(code)
+	};
+}
+//#endregion
 //#region src/type-desc.ts
 function extractStaticWords(desc) {
 	const typeCode = desc[0];
@@ -714,11 +851,11 @@ function function_() {
 	return new Uint8Array([TypeCode.FUNCTION]);
 }
 function uintN(bits) {
-	if (bits < 8 || bits > 256 || bits % 8 !== 0) throw new CallciumError("UNKNOWN_TYPE", `Invalid uintN bits: ${bits}. Must be 8–256 in steps of 8.`);
+	if (bits < 8 || bits > 256 || bits % 8 !== 0) throw new CallciumError("UNKNOWN_TYPE", `Invalid uintN bits: ${bits}. Must be 8–256 in steps of 8`);
 	return new Uint8Array([TypeCode.UINT_MIN + (bits / 8 - 1)]);
 }
 function intN(bits) {
-	if (bits < 8 || bits > 256 || bits % 8 !== 0) throw new CallciumError("UNKNOWN_TYPE", `Invalid intN bits: ${bits}. Must be 8–256 in steps of 8.`);
+	if (bits < 8 || bits > 256 || bits % 8 !== 0) throw new CallciumError("UNKNOWN_TYPE", `Invalid intN bits: ${bits}. Must be 8–256 in steps of 8`);
 	return new Uint8Array([TypeCode.INT_MIN + (bits / 8 - 1)]);
 }
 function bytes() {
@@ -728,13 +865,13 @@ 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.`);
+	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 array(elemDesc, length) {
 	if (length === void 0) {
 		const nodeLength = DescriptorFormat.ARRAY_HEADER_SIZE + elemDesc.length;
-		if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("NODE_LENGTH_TOO_LARGE", `Dynamic array node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}.`);
+		if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("NODE_LENGTH_TOO_LARGE", `Dynamic array node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}`);
 		const meta24 = 0 << DescriptorFormat.META_STATIC_WORDS_SHIFT | nodeLength;
 		const buf = new Uint8Array(1 + DescriptorFormat.COMPOSITE_META_SIZE + elemDesc.length);
 		buf[0] = TypeCode.DYNAMIC_ARRAY;
@@ -742,12 +879,12 @@ function array(elemDesc, length) {
 		buf.set(elemDesc, 4);
 		return buf;
 	}
-	if (length <= 0 || length > DescriptorFormat.MAX_STATIC_ARRAY_LENGTH) throw new CallciumError("INVALID_ARRAY_LENGTH", `Static array length ${length} out of range. Must be 1–${DescriptorFormat.MAX_STATIC_ARRAY_LENGTH}.`);
+	if (length <= 0 || length > DescriptorFormat.MAX_STATIC_ARRAY_LENGTH) throw new CallciumError("INVALID_ARRAY_LENGTH", `Static array length ${length} out of range. Must be 1–${DescriptorFormat.MAX_STATIC_ARRAY_LENGTH}`);
 	const nodeLength = DescriptorFormat.ARRAY_HEADER_SIZE + elemDesc.length + DescriptorFormat.ARRAY_LENGTH_SIZE;
-	if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("NODE_LENGTH_TOO_LARGE", `Static array node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}.`);
+	if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("NODE_LENGTH_TOO_LARGE", `Static array node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}`);
 	const elemStaticWords = extractStaticWords(elemDesc);
 	const staticWords = elemStaticWords === 0 ? 0 : length * elemStaticWords;
-	if (staticWords > DescriptorFormat.MAX_STATIC_WORDS) throw new CallciumError("STATIC_WORDS_TOO_LARGE", `Static array static words ${staticWords} exceeds maximum ${DescriptorFormat.MAX_STATIC_WORDS}.`);
+	if (staticWords > DescriptorFormat.MAX_STATIC_WORDS) throw new CallciumError("STATIC_WORDS_TOO_LARGE", `Static array static words ${staticWords} exceeds maximum ${DescriptorFormat.MAX_STATIC_WORDS}`);
 	const meta24 = staticWords << DescriptorFormat.META_STATIC_WORDS_SHIFT | nodeLength;
 	const buf = new Uint8Array(1 + DescriptorFormat.COMPOSITE_META_SIZE + elemDesc.length + DescriptorFormat.ARRAY_LENGTH_SIZE);
 	buf[0] = TypeCode.STATIC_ARRAY;
@@ -757,10 +894,10 @@ function array(elemDesc, length) {
 	return buf;
 }
 function tuple(fieldDescs) {
-	if (fieldDescs.length === 0 || fieldDescs.length > DescriptorFormat.MAX_TUPLE_FIELDS) throw new CallciumError("INVALID_TUPLE_FIELD_COUNT", `Tuple field count ${fieldDescs.length} out of range. Must be 1–${DescriptorFormat.MAX_TUPLE_FIELDS}.`);
+	if (fieldDescs.length === 0 || fieldDescs.length > DescriptorFormat.MAX_TUPLE_FIELDS) throw new CallciumError("INVALID_TUPLE_FIELD_COUNT", `Tuple field count ${fieldDescs.length} out of range. Must be 1–${DescriptorFormat.MAX_TUPLE_FIELDS}`);
 	const totalFieldBytes = fieldDescs.reduce((sum, f) => sum + f.length, 0);
 	const nodeLength = DescriptorFormat.TUPLE_HEADER_SIZE + totalFieldBytes;
-	if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("NODE_LENGTH_TOO_LARGE", `Tuple node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}.`);
+	if (nodeLength > DescriptorFormat.MAX_NODE_LENGTH) throw new CallciumError("NODE_LENGTH_TOO_LARGE", `Tuple node length ${nodeLength} exceeds maximum ${DescriptorFormat.MAX_NODE_LENGTH}`);
 	let anyDynamic = false;
 	let staticWordsSum = 0;
 	for (const field of fieldDescs) {
@@ -769,7 +906,7 @@ function tuple(fieldDescs) {
 		staticWordsSum += staticWords;
 	}
 	const staticWords = anyDynamic ? 0 : staticWordsSum;
-	if (staticWords > DescriptorFormat.MAX_STATIC_WORDS) throw new CallciumError("STATIC_WORDS_TOO_LARGE", `Tuple static words ${staticWords} exceeds maximum ${DescriptorFormat.MAX_STATIC_WORDS}.`);
+	if (staticWords > DescriptorFormat.MAX_STATIC_WORDS) throw new CallciumError("STATIC_WORDS_TOO_LARGE", `Tuple static words ${staticWords} exceeds maximum ${DescriptorFormat.MAX_STATIC_WORDS}`);
 	const meta24 = staticWords << DescriptorFormat.META_STATIC_WORDS_SHIFT | nodeLength;
 	const buf = new Uint8Array(1 + DescriptorFormat.COMPOSITE_META_SIZE + DescriptorFormat.TUPLE_FIELDCOUNT_SIZE + totalFieldBytes);
 	buf[0] = TypeCode.TUPLE;
@@ -811,19 +948,19 @@ function parseUint(input, start, end) {
 function parseTuple(input, start, end) {
 	if (input[start] !== "(") throw new CallciumError("MALFORMED_TYPE_STRING", `Expected '(' at position ${start}`);
 	let depth = 0;
-	let closePos = -1;
+	let closeIndex = -1;
 	for (let i = start; i < end; i++) if (input[i] === "(") depth++;
 	else if (input[i] === ")") {
 		depth--;
 		if (depth === 0) {
-			closePos = i;
+			closeIndex = i;
 			break;
 		}
 	}
-	if (closePos === -1) throw new CallciumError("MALFORMED_TYPE_STRING", `Unmatched '(' at position ${start}`);
-	if (closePos !== end - 1) throw new CallciumError("MALFORMED_TYPE_STRING", `Unexpected characters after ')' at position ${closePos + 1}`);
+	if (closeIndex === -1) throw new CallciumError("MALFORMED_TYPE_STRING", `Unmatched '(' at position ${start}`);
+	if (closeIndex !== end - 1) throw new CallciumError("MALFORMED_TYPE_STRING", `Unexpected characters after ')' at position ${closeIndex + 1}`);
 	const innerStart = start + 1;
-	const innerEnd = closePos;
+	const innerEnd = closeIndex;
 	const commas = commaPositions(input, innerStart, innerEnd);
 	const segments = [];
 	let segStart = innerStart;
@@ -853,14 +990,14 @@ function parseType(input, start, end) {
 	const suffixes = [];
 	let baseEnd = end;
 	while (baseEnd > start && input[baseEnd - 1] === "]") {
-		const closePos = baseEnd - 1;
-		let openPos = closePos - 1;
-		while (openPos > start && input[openPos] !== "[") openPos--;
-		if (input[openPos] !== "[") throw new CallciumError("MALFORMED_TYPE_STRING", `Unmatched ']' at position ${closePos}`);
-		const innerStart = openPos + 1;
-		const innerEnd = closePos;
+		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));
-		baseEnd = openPos;
+		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);
@@ -878,7 +1015,7 @@ function fromTypes(typesCsv) {
 	}
 	segments.push([segStart, typesCsv.length]);
 	const paramDescs = segments.map(([start, end]) => parseType(typesCsv, start, end));
-	if (paramDescs.length > DescriptorFormat.MAX_PARAMS) throw new CallciumError("TOO_MANY_PARAMS", `Parameter count ${paramDescs.length} exceeds maximum ${DescriptorFormat.MAX_PARAMS}.`);
+	if (paramDescs.length > DescriptorFormat.MAX_PARAMS) throw new CallciumError("TOO_MANY_PARAMS", `Parameter count ${paramDescs.length} exceeds maximum ${DescriptorFormat.MAX_PARAMS}`);
 	const totalBytes = paramDescs.reduce((sum, d) => sum + d.length, 0);
 	const result = new Uint8Array(DescriptorFormat.HEADER_SIZE + totalBytes);
 	result[0] = DescriptorFormat.VERSION;
@@ -1016,134 +1153,7 @@ const DescriptorCoder = {
 	toTypes
 };
 //#endregion
-//#region src/operators.ts
-function toBigInt(bytes, offset = 0) {
-	const view = new DataView(bytes.buffer, bytes.byteOffset + offset, 32);
-	return view.getBigUint64(0, false) << 192n | view.getBigUint64(8, false) << 128n | view.getBigUint64(16, false) << 64n | view.getBigUint64(24, false);
-}
-function isSigned(typeCode) {
-	return typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
-}
-function isLeftAligned(typeCode) {
-	return typeCode >= TypeCode.FIXED_BYTES_MIN && typeCode <= TypeCode.FIXED_BYTES_MAX || typeCode === TypeCode.FUNCTION;
-}
-function canonicalize(value, typeCode) {
-	if (typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX) {
-		const bits = BigInt(typeCode * 8);
-		return bits === 256n ? value : value & (1n << bits) - 1n;
-	}
-	if (typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX) {
-		const bits = (typeCode - TypeCode.INT_MIN + 1) * 8;
-		return bits === 256 ? value : BigInt.asUintN(256, BigInt.asIntN(bits, value));
-	}
-	if (typeCode === TypeCode.ADDRESS) return value & (1n << 160n) - 1n;
-	if (typeCode === TypeCode.BOOL) return value & 1n;
-	if (typeCode === TypeCode.FUNCTION) return value >> 64n << 64n;
-	if (typeCode >= TypeCode.FIXED_BYTES_MIN && typeCode <= TypeCode.FIXED_BYTES_MAX) {
-		const n = typeCode - TypeCode.FIXED_BYTES_MIN + 1;
-		if (n === 32) return value;
-		const padBits = BigInt((32 - n) * 8);
-		return value >> padBits << padBits;
-	}
-	return value;
-}
-function isLengthOp(opCode) {
-	const base = opCode & ~Op.NOT;
-	return base >= Op.LENGTH_EQ && base <= Op.LENGTH_BETWEEN;
-}
-function lengthToValueOp(base) {
-	if (base === Op.LENGTH_EQ) return Op.EQ;
-	if (base === Op.LENGTH_GT) return Op.GT;
-	if (base === Op.LENGTH_LT) return Op.LT;
-	if (base === Op.LENGTH_GTE) return Op.GTE;
-	if (base === Op.LENGTH_LTE) return Op.LTE;
-	return Op.BETWEEN;
-}
-function isLengthValidType(typeCode) {
-	return typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING || typeCode === TypeCode.DYNAMIC_ARRAY;
-}
-function compareTyped(a, b, typeCode) {
-	if (isSigned(typeCode)) {
-		const sa = BigInt.asIntN(256, a);
-		const sb = BigInt.asIntN(256, b);
-		return sa < sb ? -1 : sa > sb ? 1 : 0;
-	}
-	return a < b ? -1 : a > b ? 1 : 0;
-}
-function isIn(value, data) {
-	const count = data.length / 32;
-	let lo = 0;
-	let hi = count - 1;
-	while (lo <= hi) {
-		const mid = lo + hi >>> 1;
-		const elem = toBigInt(data, mid * 32);
-		if (value === elem) return true;
-		if (value < elem) hi = mid - 1;
-		else lo = mid + 1;
-	}
-	return false;
-}
-function applyOperator(opCode, value, valueLength, operandData, typeCode) {
-	let base = opCode & ~Op.NOT;
-	if (isLengthOp(base)) {
-		value = BigInt(valueLength);
-		typeCode = TypeCode.UINT_MAX;
-		base = lengthToValueOp(base);
-	}
-	let result;
-	switch (base) {
-		case Op.EQ:
-			result = value === toBigInt(operandData, 0);
-			break;
-		case Op.GT:
-			result = compareTyped(value, toBigInt(operandData, 0), typeCode) > 0;
-			break;
-		case Op.LT:
-			result = compareTyped(value, toBigInt(operandData, 0), typeCode) < 0;
-			break;
-		case Op.GTE:
-			result = compareTyped(value, toBigInt(operandData, 0), typeCode) >= 0;
-			break;
-		case Op.LTE:
-			result = compareTyped(value, toBigInt(operandData, 0), typeCode) <= 0;
-			break;
-		case Op.BETWEEN: {
-			const min = toBigInt(operandData, 0);
-			const max = toBigInt(operandData, 32);
-			result = compareTyped(value, min, typeCode) >= 0 && compareTyped(value, max, typeCode) <= 0;
-			break;
-		}
-		case Op.IN:
-			result = isIn(value, operandData);
-			break;
-		case Op.BITMASK_ALL: {
-			const mask = toBigInt(operandData, 0);
-			result = (value & mask) === mask;
-			break;
-		}
-		case Op.BITMASK_ANY: {
-			const mask = toBigInt(operandData, 0);
-			result = (value & mask) !== 0n;
-			break;
-		}
-		case Op.BITMASK_NONE: {
-			const mask = toBigInt(operandData, 0);
-			result = (value & mask) === 0n;
-			break;
-		}
-		default: throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code 0x${base.toString(16).padStart(2, "0")}.`);
-	}
-	return (opCode & Op.NOT) !== 0 ? !result : result;
-}
-//#endregion
 //#region src/policy-coder.ts
-function parsePathSteps(path) {
-	const bytes = hexToBytes(path);
-	if (bytes.length % PolicyFormat.PATH_STEP_SIZE !== 0) throw new CallciumError("MALFORMED_PATH", `Path byte length ${bytes.length} is not a whole number of steps`);
-	const steps = [];
-	for (let offset = 0; offset < bytes.length; offset += PolicyFormat.PATH_STEP_SIZE) steps.push(readU16(bytes, offset));
-	return steps;
-}
 function field(value, start, end) {
 	return {
 		value,
@@ -1289,8 +1299,11 @@ function decodePolicy(blob) {
 				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);
 			}
+			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);
+			}
 			if (depthValue === 0) throw new CallciumError("EMPTY_PATH", "Rule path must have at least one step", ruleOffset);
-			if (depthValue > Limits.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depthValue} exceeds maximum ${Limits.MAX_PATH_DEPTH}`, ruleOffset);
+			if (depthValue > PolicyFormat.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depthValue} exceeds maximum ${PolicyFormat.MAX_PATH_DEPTH}`, ruleOffset);
 			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);
@@ -1357,12 +1370,12 @@ function decodePolicy(blob) {
 }
 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).");
+	for (const operator of operators) if (operator.length < 1) throw new CallciumError("INVALID_OPERATOR_BYTES", "Operator must have at least one byte (opcode)");
 	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.");
+	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 > Limits.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depth} exceeds maximum ${Limits.MAX_PATH_DEPTH}.`);
+	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,
@@ -1389,7 +1402,7 @@ function sortRules(rules) {
 }
 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.");
+	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`);
@@ -1557,6 +1570,18 @@ function hintMismatch(groupIndex, constraintIndex) {
 		message: "Hint does not match the path compiled against the descriptor"
 	};
 }
+function contextTypeMismatch(groupIndex, constraintIndex, contextId, typeCode) {
+	return {
+		severity: "error",
+		category: "typeMismatch",
+		groupIndex,
+		constraintIndex,
+		code: "CONTEXT_TYPE_MISMATCH",
+		value1: contextId,
+		value2: typeCode,
+		message: "Context property type does not match the target type"
+	};
+}
 function nonCanonicalOperand(groupIndex, constraintIndex, operand, canonical) {
 	return {
 		severity: "error",
@@ -1722,7 +1747,7 @@ function unsortedInSet(groupIndex, constraintIndex) {
 		code: "UNSORTED_IN_SET",
 		value1: ZERO,
 		value2: ZERO,
-		message: "isIn/notIn set is not strictly sorted and deduplicated."
+		message: "isIn/notIn set is not strictly sorted and deduplicated"
 	};
 }
 function emptyGroup(groupIndex) {
@@ -1734,7 +1759,7 @@ function emptyGroup(groupIndex) {
 		code: "EMPTY_GROUP",
 		value1: ZERO,
 		value2: ZERO,
-		message: "Group contains zero constraints."
+		message: "Group contains zero constraints"
 	};
 }
 function dominatedBound(isLength, groupIndex, constraintIndex, value) {
@@ -1919,7 +1944,7 @@ function negationUnderAny(groupIndex, constraintIndex, opCode) {
 }
 //#endregion
 //#region src/policy-validator.ts
-const NAVIGABILITY_CODES = new Set([
+const navigabilityCodes = new Set([
 	"EMPTY_PATH",
 	"PARAM_INDEX_OUT_OF_BOUNDS",
 	"TUPLE_FIELD_OUT_OF_BOUNDS",
@@ -2006,6 +2031,10 @@ function getIncompat(opBase, typeInfo) {
 			code: "IN_ON_BOOL",
 			message: "IN operator used on boolean type"
 		};
+		if (opBase === Op.EQ_CTX && typeCode !== TypeCode.ADDRESS && !(typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX)) return {
+			code: "CONTEXT_TYPE_MISMATCH",
+			message: "Context reference operator used on incompatible type"
+		};
 		return null;
 	}
 	if (isLengthOp(opBase)) {
@@ -2334,7 +2363,11 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 			issues.push(fromOpRule(incompat.code, incompat.message, groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
 			continue;
 		}
-		if (isValueOp(base)) {
+		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))));
+		} else if (isValueOp(base)) {
 			const typeCode = ctx.typeInfo.typeCode;
 			if (isLeftAligned(typeCode)) {
 				const nonCanonical = findNonCanonicalWord(opHex, typeCode);
@@ -2389,12 +2422,12 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 			const steps = parsePathSteps(constraint.path);
 			let typeInfo;
 			if (constraint.scope === Scope.CALLDATA) {
-				if (steps.length > Limits.MAX_PATH_DEPTH) issues.push(pathDepthExceeded(groupIndex, constraintIndex, bigintToHex(BigInt(steps.length)), bigintToHex(BigInt(Limits.MAX_PATH_DEPTH))));
+				if (steps.length > PolicyFormat.MAX_PATH_DEPTH) issues.push(pathDepthExceeded(groupIndex, constraintIndex, bigintToHex(BigInt(steps.length)), bigintToHex(BigInt(PolicyFormat.MAX_PATH_DEPTH))));
 				let walk;
 				try {
 					walk = Descriptor.walkPath(descBytes, steps);
 				} catch (error) {
-					if (error instanceof CallciumError && NAVIGABILITY_CODES.has(error.code)) {
+					if (error instanceof CallciumError && navigabilityCodes.has(error.code)) {
 						issues.push(unnavigablePath(groupIndex, constraintIndex));
 						continue;
 					}
@@ -2404,7 +2437,7 @@ function validateGroup(data, descBytes, groupIndex, issues) {
 					issues.push(nestedQuantifier(groupIndex, constraintIndex));
 					continue;
 				}
-				if (walk.quantifiedStaticLength > Limits.MAX_QUANTIFIED_ARRAY_LENGTH) issues.push(quantifierOverStaticLimit(groupIndex, constraintIndex, bigintToHex(BigInt(walk.quantifiedStaticLength)), bigintToHex(BigInt(Limits.MAX_QUANTIFIED_ARRAY_LENGTH))));
+				if (walk.quantifiedStaticLength > PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH) issues.push(quantifierOverStaticLimit(groupIndex, constraintIndex, bigintToHex(BigInt(walk.quantifiedStaticLength)), bigintToHex(BigInt(PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH))));
 				typeInfo = walk.typeInfo;
 			} else {
 				const ctxId = steps[0];
@@ -2424,7 +2457,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 <= Limits.MAX_PATH_DEPTH) {
+		if (constraint.scope === Scope.CALLDATA && constraint.hint !== void 0 && 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);
@@ -2481,14 +2514,14 @@ const SignatureParser = { parse };
 //#endregion
 //#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.");
+	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")}.`);
+	if (step > MAX_CONTEXT_PROPERTY_ID) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", `Unknown context property ID 0x${step.toString(16).padStart(4, "0")}`);
 }
 function validateCalldataPath(steps, desc) {
 	const argIndex = steps[0];
 	const paramCount = Descriptor.paramCount(desc);
-	if (argIndex >= paramCount) throw new CallciumError("PARAM_INDEX_OUT_OF_BOUNDS", `Param index ${argIndex} out of range (descriptor has ${paramCount} params).`);
+	if (argIndex >= paramCount) throw new CallciumError("PARAM_INDEX_OUT_OF_BOUNDS", `Param index ${argIndex} out of range (descriptor has ${paramCount} params)`);
 	let offset = Descriptor.paramOffset(desc, argIndex);
 	let hasQuantifier = false;
 	for (let i = 1; i < steps.length; i++) {
@@ -2496,21 +2529,21 @@ function validateCalldataPath(steps, desc) {
 		const info = Descriptor.inspect(desc, offset);
 		const isArray = info.typeCode === TypeCode.STATIC_ARRAY || info.typeCode === TypeCode.DYNAMIC_ARRAY;
 		if (isQuantifier(step)) {
-			if (!isArray) throw new CallciumError("QUANTIFIER_ON_NON_ARRAY", "Quantifier step is only valid on an array node.");
-			if (hasQuantifier) throw new CallciumError("NESTED_QUANTIFIER", "Nested quantifiers are not allowed.");
+			if (!isArray) throw new CallciumError("QUANTIFIER_ON_NON_ARRAY", "Quantifier step is only valid on an array node");
+			if (hasQuantifier) throw new CallciumError("NESTED_QUANTIFIER", "Nested quantifiers are not allowed");
 			hasQuantifier = true;
 		}
 		if (info.typeCode === TypeCode.TUPLE) {
 			const fieldCount = Descriptor.tupleFieldCount(desc, offset);
-			if (step >= fieldCount) throw new CallciumError("TUPLE_FIELD_OUT_OF_BOUNDS", `Tuple field index ${step} out of range (tuple has ${fieldCount} fields).`);
+			if (step >= fieldCount) throw new CallciumError("TUPLE_FIELD_OUT_OF_BOUNDS", `Tuple field index ${step} out of range (tuple has ${fieldCount} fields)`);
 			offset = Descriptor.tupleFieldOffset(desc, offset, step);
 		} else if (isArray) {
 			if (!isQuantifier(step) && info.typeCode === TypeCode.STATIC_ARRAY) {
 				const arrayLength = Descriptor.staticArrayLength(desc, offset);
-				if (step >= arrayLength) throw new CallciumError("STATIC_ARRAY_INDEX_OUT_OF_BOUNDS", `Array index ${step} out of range (static array has ${arrayLength} elements).`);
+				if (step >= arrayLength) throw new CallciumError("STATIC_ARRAY_INDEX_OUT_OF_BOUNDS", `Array index ${step} out of range (static array has ${arrayLength} elements)`);
 			}
 			offset = Descriptor.arrayElementOffset(offset);
-		} else throw new CallciumError("NOT_COMPOSITE", "Cannot descend into an elementary type.");
+		} else throw new CallciumError("NOT_COMPOSITE", "Cannot descend into an elementary type");
 	}
 }
 var PolicyBuilder = class PolicyBuilder {
@@ -2544,21 +2577,21 @@ var PolicyBuilder = class PolicyBuilder {
 			path: constraint.path,
 			operators: [...constraint.operators]
 		};
-		if (c.operators.length === 0) throw new CallciumError("NO_CONSTRAINT_OPERATORS", "Constraint must have at least one operator.");
+		if (c.operators.length === 0) throw new CallciumError("NO_CONSTRAINT_OPERATORS", "Constraint must have at least one operator");
 		const steps = parsePathSteps(c.path);
-		if (steps.length === 0) throw new CallciumError("EMPTY_PATH", "Path must have at least one step.");
+		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}.`);
+		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.`);
+		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);
 		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.");
+		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());
 		return this;
@@ -2580,7 +2613,7 @@ var PolicyBuilder = class PolicyBuilder {
 		return PolicyValidator.validate(policyData);
 	}
 	checkGroups() {
-		for (let i = 0; i < this.draft.groups.length; i++) if (this.draft.groups[i].length === 0) throw new CallciumError("EMPTY_GROUP", `Group ${i} is empty.`);
+		for (let i = 0; i < this.draft.groups.length; i++) if (this.draft.groups[i].length === 0) throw new CallciumError("EMPTY_GROUP", `Group ${i} is empty`);
 	}
 	toPolicyData() {
 		return {
@@ -2603,8 +2636,7 @@ function encodeWord(value) {
 		return word;
 	}
 	if (typeof value === "string") {
-		const body = addressBody(value);
-		for (let i = 0; i < 20; i++) word[12 + i] = parseInt(body.substring(i * 2, i * 2 + 2), 16);
+		word.set(hexToBytes(addressBody(value)), 12);
 		return word;
 	}
 	let bigValue = typeof value === "number" ? BigInt(value) : value;
@@ -2628,7 +2660,10 @@ function rangeOp(opCode, min, max) {
 	buffer.set(encodeWord(max), 33);
 	return bytesToHex(buffer);
 }
-const MAX_SET_MEMBERS = Limits.MAX_SET_MEMBERS;
+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;
@@ -2636,21 +2671,14 @@ function setOp(opCode, values) {
 		if (typeof v === "boolean") return v ? 1n : 0n;
 		return BigInt("0x" + addressBody(v));
 	});
-	bigs.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-	const deduped = [];
-	for (const value of bigs) if (deduped.length === 0 || deduped[deduped.length - 1] !== value) deduped.push(value);
+	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 > MAX_SET_MEMBERS) throw new CallciumError("SET_TOO_LARGE", `Set must contain at most ${MAX_SET_MEMBERS} values`);
+	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 encodePath(steps) {
-	const buffer = new Uint8Array(steps.length * 2);
-	for (let i = 0; i < steps.length; i++) writeBE16(buffer, i * 2, steps[i]);
-	return bytesToHex(buffer);
-}
 var ConstraintBuilder = class {
 	scope;
 	path;
@@ -2670,6 +2698,12 @@ var ConstraintBuilder = class {
 	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));
 	}
@@ -2762,17 +2796,14 @@ function readPointer(callData, head) {
 }
 //#endregion
 //#region src/policy-enforcer.ts
-const ABORT_VIOLATION_CODES = new Set([
+const abortViolationCodes = new Set([
 	"CALLDATA_OUT_OF_BOUNDS",
 	"ARRAY_INDEX_OUT_OF_BOUNDS",
 	"NON_CANONICAL_VALUE",
 	"QUANTIFIER_LIMIT_EXCEEDED"
 ]);
 function addressToBigInt(hex) {
-	const bytes = hexToBytes(hex);
-	const padded = new Uint8Array(32);
-	padded.set(bytes, 32 - bytes.length);
-	return toBigInt(padded, 0);
+	return BigInt(toAddress(hex));
 }
 function check(policy, callData, context) {
 	const { policy: decoded, data: policyBytes } = decodePolicy(policy);
@@ -2803,7 +2834,7 @@ function check(policy, callData, context) {
 			const violation = evaluateRule(rule, policyBytes, callDataBytes, baseOffset, groupIndex, ruleIndex, context);
 			if (violation !== null) {
 				allViolations.push(violation);
-				if (ABORT_VIOLATION_CODES.has(violation.code)) return {
+				if (abortViolationCodes.has(violation.code)) return {
 					ok: false,
 					violations: allViolations
 				};
@@ -2833,7 +2864,13 @@ function evaluateRule(rule, policyBytes, callDataBytes, baseOffset, groupIndex,
 	const operandData = fieldBytes(policyBytes, rule.data);
 	if (rule.scope.value === Scope.CONTEXT) return evaluateContextRule(fieldBytes(policyBytes, rule.path), opCode, operandData, groupIndex, ruleIndex, rule.path.value, context);
 	if (rule.hint === void 0) throw new CallciumError("MALFORMED_HINT", "Calldata rule carries no hint block");
-	return evaluateCalldataRule(fieldBytes(policyBytes, rule.hint), callDataBytes, baseOffset, opCode, operandData, groupIndex, ruleIndex, rule.path.value);
+	return evaluateCalldataRule(fieldBytes(policyBytes, rule.hint), callDataBytes, baseOffset, opCode, operandData, groupIndex, ruleIndex, rule.path.value, context);
+}
+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;
 }
 function readTargetBlock(hint, targetOffset) {
 	return {
@@ -2874,10 +2911,10 @@ function chainResolve(hint, callData, base, hopsOffset, hopCount) {
 	}
 	return base;
 }
-function evalTarget(callData, target, block, opCode, operandData) {
+function evalTarget(callData, target, block, opCode, operandData, context) {
 	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.");
+		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 stride = typeCode === TypeCode.DYNAMIC_ARRAY ? (block.targetMeta & PolicyFormat.HINT_META_STRIDE_MASK) * 32 : 1;
@@ -2888,7 +2925,7 @@ function evalTarget(callData, target, block, opCode, operandData) {
 			value: BigInt(length)
 		};
 	}
-	if (classifyTypeCode(typeCode).typeClass !== "elementary") throw new CallciumError("OPERATOR_TARGET_MISMATCH", "Operator target does not carry a scalar word.");
+	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);
@@ -2896,6 +2933,18 @@ function evalTarget(callData, target, block, opCode, operandData) {
 		error: "NON_CANONICAL_VALUE",
 		value
 	};
+	if ((opCode & ~Op.NOT) === Op.EQ_CTX) {
+		const operand = resolveContextOperand(operandData, context);
+		if (typeof operand !== "bigint") return {
+			error: "MISSING_CONTEXT",
+			ctxTypeCode: operand.ctxTypeCode
+		};
+		return {
+			passed: value === operand !== ((opCode & Op.NOT) !== 0),
+			value,
+			ctxOperand: operand
+		};
+	}
 	return {
 		passed: applyOperator(opCode, value, 32, operandData, typeCode),
 		value
@@ -2916,6 +2965,16 @@ function navigationViolation(frame, code, 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),
+			typeCode: result.ctxTypeCode
+		};
 		if (result.error === "NON_CANONICAL_VALUE") return {
 			group: frame.group,
 			rule: frame.rule,
@@ -2941,15 +3000,16 @@ function targetViolation(frame, result, elementIndex) {
 		operandData: bytesToHex(frame.operandData),
 		typeCode: frame.typeCode,
 		resolvedValue: bigintToHex(result.value),
+		...result.ctxOperand !== void 0 && { resolvedOperand: bigintToHex(result.ctxOperand) },
 		...elementIndex !== void 0 && { elementIndex }
 	};
 }
-function evaluateCalldataRule(hint, callDataBytes, baseOffset, opCode, operandData, groupIndex, ruleIndex, pathHex) {
+function evaluateCalldataRule(hint, callDataBytes, baseOffset, opCode, operandData, groupIndex, ruleIndex, pathHex, context) {
 	const header = hint[0];
 	const hopCount = header & PolicyFormat.HINT_HOP_COUNT_MASK;
 	const kind = header >> PolicyFormat.HINT_KIND_SHIFT;
 	const hopsOffset = PolicyFormat.HINT_HEADER_SIZE;
-	if (kind !== PolicyFormat.HINT_KIND_NONE) return evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, hopCount, opCode, operandData, groupIndex, ruleIndex, pathHex);
+	if (kind !== PolicyFormat.HINT_KIND_NONE) return evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, hopCount, opCode, operandData, groupIndex, ruleIndex, pathHex, context);
 	const block = readTargetBlock(hint, hopsOffset + hopCount * PolicyFormat.HINT_HOP_SIZE);
 	const frame = {
 		group: groupIndex,
@@ -2961,9 +3021,9 @@ 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));
+	return targetViolation(frame, evalTarget(callDataBytes, base + block.targetDelta, block, opCode, operandData, context));
 }
-function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, hopCount, opCode, operandData, groupIndex, ruleIndex, pathHex) {
+function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, hopCount, opCode, operandData, groupIndex, ruleIndex, pathHex, context) {
 	const frameOffset = hopsOffset + hopCount * PolicyFormat.HINT_HOP_SIZE;
 	const suffixHeaderOffset = frameOffset + PolicyFormat.HINT_FRAME_PREFIX_SIZE;
 	const suffixHopCount = hint[suffixHeaderOffset] & PolicyFormat.HINT_HOP_COUNT_MASK;
@@ -2987,7 +3047,7 @@ function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, h
 		count = length;
 		elems += 32;
 	}
-	if (count > Limits.MAX_QUANTIFIED_ARRAY_LENGTH) return {
+	if (count > PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH) return {
 		group: groupIndex,
 		rule: ruleIndex,
 		code: "QUANTIFIER_LIMIT_EXCEEDED",
@@ -3009,6 +3069,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;
 	for (let elemIndex = 0; elemIndex < count; elemIndex++) {
 		const slot = elems + elemIndex * elemStride;
 		let elem = slot;
@@ -3023,11 +3084,12 @@ 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);
+		const applied = evalTarget(callDataBytes, base + block.targetDelta, block, opCode, operandData, context);
 		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 {
@@ -3038,26 +3100,44 @@ function evaluateQuantified(hint, callDataBytes, baseOffset, kind, hopsOffset, h
 		path: pathHex,
 		opCode,
 		operandData: bytesToHex(operandData),
-		typeCode: block.typeCode
+		typeCode: block.typeCode,
+		...ctxOperand !== void 0 && { resolvedOperand: bigintToHex(ctxOperand) }
 	};
 }
 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 propInfo = lookupContextProperty(propertyId);
-	const contextValue = context?.[propInfo.contextKey];
+	const propertyInfo = lookupContextProperty(propertyId);
+	const contextValue = context?.[propertyInfo.contextKey];
 	if (contextValue === void 0) return {
 		group: groupIndex,
 		rule: ruleIndex,
 		code: "MISSING_CONTEXT",
 		scope: Scope.CONTEXT,
 		path: pathHex,
-		typeCode: propInfo.typeCode
+		typeCode: propertyInfo.typeCode
 	};
 	let value;
 	if (typeof contextValue === "string") value = addressToBigInt(contextValue);
 	else value = contextValue;
-	if (!applyOperator(opCode, value, 32, operandData, propInfo.typeCode)) return {
+	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,
+			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);
+	if (!result) return {
 		group: groupIndex,
 		rule: ruleIndex,
 		code: "VALUE_MISMATCH",
@@ -3065,8 +3145,9 @@ function evaluateContextRule(pathBytes, opCode, operandData, groupIndex, ruleInd
 		path: pathHex,
 		opCode,
 		operandData: bytesToHex(operandData),
-		typeCode: propInfo.typeCode,
-		resolvedValue: bigintToHex(value)
+		typeCode: propertyInfo.typeCode,
+		resolvedValue: bigintToHex(value),
+		...ctxOperand !== void 0 && { resolvedOperand: bigintToHex(ctxOperand) }
 	};
 	return null;
 }
@@ -3075,6 +3156,6 @@ const PolicyEnforcer = {
 	enforce
 };
 //#endregion
-export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, Limits, 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, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
 
 //# sourceMappingURL=index.js.map