@callcium/sdk 0.11.1 → 0.12.0

package/dist/index.js

@@ -1,5 +1,5 @@
+import { bytesToHex as bytesToHex$1, concatBytes, hexToBytes as hexToBytes$1, utf8ToBytes } from "@noble/hashes/utils.js";
 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;
@@ -36,29 +36,17 @@ function formatDiagnostic(violation) {
 //#endregion
 //#region src/bytes.ts
 const hexBodyPattern = /^[0-9a-fA-F]*$/;
-const HEX_DIGITS = "0123456789abcdef";
-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;
-}
 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;
-		if (high < 0 || low < 0) throw new CallciumError("INVALID_HEX", "Invalid hex characters");
-		bytes[i] = high << 4 | low;
+	try {
+		return hexToBytes$1(clean);
+	} catch {
+		throw new CallciumError("INVALID_HEX", "Invalid hex characters");
 	}
-	return bytes;
 }
-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 += hexPairs[bytes[i]];
-	return `0x${body}`;
+	return `0x${bytesToHex$1(bytes)}`;
 }
 function toHex(data, start, end) {
 	return bytesToHex(data.subarray(start, end));
@@ -335,6 +323,30 @@ const OP_TABLE = [
 		label: "== ctx",
 		operands: "single"
 	},
+	{
+		key: "GT_CTX",
+		code: 9,
+		label: "> ctx",
+		operands: "single"
+	},
+	{
+		key: "LT_CTX",
+		code: 10,
+		label: "< ctx",
+		operands: "single"
+	},
+	{
+		key: "GTE_CTX",
+		code: 11,
+		label: ">= ctx",
+		operands: "single"
+	},
+	{
+		key: "LTE_CTX",
+		code: 12,
+		label: "<= ctx",
+		operands: "single"
+	},
 	{
 		key: "BITMASK_ALL",
 		code: 16,
@@ -544,6 +556,18 @@ var ConstraintBuilder = class {
 	neqCtx(contextPropertyId) {
 		return this.push(singleOp(Op.EQ_CTX | Op.NOT, contextOperand(contextPropertyId)));
 	}
+	gtCtx(contextPropertyId) {
+		return this.push(singleOp(Op.GT_CTX, contextOperand(contextPropertyId)));
+	}
+	ltCtx(contextPropertyId) {
+		return this.push(singleOp(Op.LT_CTX, contextOperand(contextPropertyId)));
+	}
+	gteCtx(contextPropertyId) {
+		return this.push(singleOp(Op.GTE_CTX, contextOperand(contextPropertyId)));
+	}
+	lteCtx(contextPropertyId) {
+		return this.push(singleOp(Op.LTE_CTX, contextOperand(contextPropertyId)));
+	}
 	gt(bound) {
 		return this.push(singleOp(Op.GT, bound), [bound]);
 	}
@@ -656,13 +680,9 @@ 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 isContextOp(opCode) {
+	const base = opCode & ~Op.NOT;
+	return base >= Op.EQ_CTX && base <= Op.LTE_CTX;
 }
 function isLengthValidType(typeCode) {
 	return typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING || typeCode === TypeCode.DYNAMIC_ARRAY;
@@ -689,12 +709,7 @@ function isIn(value, data) {
 	return false;
 }
 function applyOperator(opCode, value, valueLength, operandData, typeCode) {
-	let base = opCode & ~Op.NOT;
-	if (isLengthOp(base)) {
-		value = valueLength;
-		typeCode = TypeCode.UINT_MAX;
-		base = lengthToValueOp(base);
-	}
+	const base = opCode & ~Op.NOT;
 	let result;
 	switch (base) {
 		case Op.EQ:
@@ -726,16 +741,48 @@ function applyOperator(opCode, value, valueLength, operandData, typeCode) {
 			result = (value & mask) === mask;
 			break;
 		}
-		case Op.BITMASK_ANY: {
-			const mask = toBigInt(operandData, 0);
-			result = (value & mask) !== 0n;
+		case Op.BITMASK_ANY:
+			result = (value & toBigInt(operandData, 0)) !== 0n;
 			break;
-		}
-		case Op.BITMASK_NONE: {
-			const mask = toBigInt(operandData, 0);
-			result = (value & mask) === 0n;
+		case Op.BITMASK_NONE:
+			result = (value & toBigInt(operandData, 0)) === 0n;
+			break;
+		case Op.LENGTH_EQ:
+			result = valueLength === toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_GT:
+			result = valueLength > toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_LT:
+			result = valueLength < toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_GTE:
+			result = valueLength >= toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_LTE:
+			result = valueLength <= toBigInt(operandData, 0);
+			break;
+		case Op.LENGTH_BETWEEN: {
+			const lower = toBigInt(operandData, 0);
+			const upper = toBigInt(operandData, 32);
+			result = valueLength >= lower && valueLength <= upper;
 			break;
 		}
+		case Op.EQ_CTX:
+			result = value === toBigInt(operandData, 0);
+			break;
+		case Op.GT_CTX:
+			result = value > toBigInt(operandData, 0);
+			break;
+		case Op.LT_CTX:
+			result = value < toBigInt(operandData, 0);
+			break;
+		case Op.GTE_CTX:
+			result = value >= toBigInt(operandData, 0);
+			break;
+		case Op.LTE_CTX:
+			result = value <= toBigInt(operandData, 0);
+			break;
 		default: throw new CallciumError("UNKNOWN_OPERATOR", `Unknown operator code ${formatCode(base, PolicyFormat.RULE_OPCODE_SIZE)}`);
 	}
 	return (opCode & Op.NOT) !== 0 ? !result : result;
@@ -1238,15 +1285,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}`);
-	const totalBytes = paramDescs.reduce((sum, d) => sum + d.length, 0);
-	const result = new Uint8Array(DescriptorFormat.HEADER_SIZE + totalBytes);
-	result[0] = DescriptorFormat.VERSION;
-	result[1] = paramDescs.length;
-	let offset = DescriptorFormat.HEADER_SIZE;
-	for (const desc of paramDescs) {
-		result.set(desc, offset);
-		offset += desc.length;
-	}
+	const result = concatBytes(Uint8Array.of(DescriptorFormat.VERSION, paramDescs.length), ...paramDescs);
 	decodeDescriptor(result);
 	return result;
 }
@@ -1532,8 +1571,8 @@ function decodePolicy(blob) {
 					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);
+			if (isContextOp(opBase)) {
+				if (toBigInt(data, dataStart) > BigInt(MAX_CONTEXT_PROPERTY_ID)) throw new CallciumError("UNKNOWN_CONTEXT_PROPERTY", "Context reference 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 > PolicyFormat.MAX_PATH_DEPTH) throw new CallciumError("PATH_TOO_DEEP", `Path depth ${depthValue} exceeds maximum ${PolicyFormat.MAX_PATH_DEPTH}`, ruleOffset);
@@ -1669,15 +1708,7 @@ function encodeRule(rule) {
 	return buf;
 }
 function encodeGroupRules(rules) {
-	const parts = rules.map(encodeRule);
-	const totalSize = parts.reduce((sum, p) => sum + p.length, 0);
-	const buf = new Uint8Array(totalSize);
-	let offset = 0;
-	for (const part of parts) {
-		buf.set(part, offset);
-		offset += part.length;
-	}
-	return buf;
+	return concatBytes(...rules.map(encodeRule));
 }
 function buildOperatorHex(rule) {
 	return `0x${rule.opCode.value.toString(16).padStart(2, "0")}${rule.data.value.slice(2)}`;
@@ -2259,7 +2290,7 @@ function isComparisonOp(opBase) {
 function isBitmaskOp(opBase) {
 	return opBase >= Op.BITMASK_ALL && opBase <= Op.BITMASK_NONE;
 }
-function getIncompat(opBase, typeInfo) {
+function checkCompatibility(opBase, typeInfo) {
 	const { typeCode, isDynamic, staticSize } = typeInfo;
 	if (isValueOp(opBase)) {
 		if (isDynamic || staticSize !== 32) return {
@@ -2282,7 +2313,7 @@ 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 {
+		if (isContextOp(opBase) && !(typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX) && !(opBase === Op.EQ_CTX && typeCode === TypeCode.ADDRESS)) return {
 			code: "CONTEXT_TYPE_MISMATCH",
 			message: "Context reference operator used on incompatible type"
 		};
@@ -2301,7 +2332,8 @@ function getIncompat(opBase, typeInfo) {
 	};
 }
 function isOpAllowed(opCode, typeInfo) {
-	return getIncompat(opCode & ~Op.NOT, typeInfo) === null;
+	const opBase = opCode & ~Op.NOT;
+	return operandsOf(opBase) !== void 0 && checkCompatibility(opBase, typeInfo) === null;
 }
 function readValue(opHex) {
 	return BigInt(`0x${opHex.slice(4)}`);
@@ -2571,9 +2603,9 @@ function checkDuplicates(issues, operators, groupIndex, constraintIndex) {
 }
 function checkFusibleRange(ctx, operators, groupIndex, constraintIndex, issues) {
 	const numericPair = findLonePair(operators, Op.GTE, Op.LTE);
-	if (numericPair && getIncompat(Op.GTE, ctx.typeInfo) === null && signedCompare(numericPair.low, numericPair.high, ctx.numeric.isSigned) <= 0n) issues.push(fusibleRange(false, groupIndex, constraintIndex, bigintToHex(numericPair.low), bigintToHex(numericPair.high)));
+	if (numericPair && checkCompatibility(Op.GTE, ctx.typeInfo) === null && signedCompare(numericPair.low, numericPair.high, ctx.numeric.isSigned) <= 0n) issues.push(fusibleRange(false, groupIndex, constraintIndex, bigintToHex(numericPair.low), bigintToHex(numericPair.high)));
 	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)));
+	if (lengthPair && checkCompatibility(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);
@@ -2613,12 +2645,12 @@ function validateConstraint(ctx, constraint, groupIndex, constraintIndex, issues
 		}
 		const isNegated = (opCode & Op.NOT) !== 0;
 		if (underAny && isNegated) issues.push(negationUnderAny(groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
-		const incompat = getIncompat(base, ctx.typeInfo);
-		if (incompat) {
-			issues.push(fromOpRule(incompat.code, incompat.message, groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
+		const incompatibility = checkCompatibility(base, ctx.typeInfo);
+		if (incompatibility) {
+			issues.push(fromOpRule(incompatibility.code, incompatibility.message, groupIndex, constraintIndex, bigintToHex(BigInt(opCode))));
 			continue;
 		}
-		if (base === Op.EQ_CTX) {
+		if (isContextOp(base)) {
 			const ctxOperand = readValue(opHex);
 			const property = findContextProperty(Number(ctxOperand));
 			if (!property) issues.push(unknownContextProperty(groupIndex, constraintIndex, bigintToHex(ctxOperand), bigintToHex(BigInt(MAX_CONTEXT_PROPERTY_ID))));
@@ -3002,7 +3034,7 @@ function resolveContextOperand(operandData, context) {
 	return contextValueToWord(value);
 }
 function referenceOperand(opCode, operandData, context) {
-	if ((opCode & ~Op.NOT) !== Op.EQ_CTX) return void 0;
+	if (!isContextOp(opCode)) return void 0;
 	return resolveContextOperand(operandData, context);
 }
 function readTargetBlock(hint, targetOffset) {
@@ -3071,7 +3103,7 @@ function evalTarget(callData, target, block, opCode, operandData, ctxOperand) {
 			ctxTypeCode: ctxOperand.ctxTypeCode
 		};
 		return {
-			passed: value === ctxOperand !== ((opCode & Op.NOT) !== 0),
+			passed: applyOperator(opCode, value, 32n, hexToBytes(bigintToHex(ctxOperand)), typeCode),
 			value,
 			ctxOperand
 		};
@@ -3233,7 +3265,7 @@ function evaluateContextRule(pathBytes, opCode, operandData, groupIndex, ruleInd
 	const value = contextValueToWord(contextValue);
 	let result;
 	let ctxOperand;
-	if ((opCode & ~Op.NOT) === Op.EQ_CTX) {
+	if (isContextOp(opCode)) {
 		const operand = resolveContextOperand(operandData, context);
 		if (typeof operand !== "bigint") return {
 			code: "MISSING_CONTEXT",
@@ -3242,7 +3274,7 @@ function evaluateContextRule(pathBytes, opCode, operandData, groupIndex, ruleInd
 			operandData: bytesToHex(operandData),
 			typeCode: operand.ctxTypeCode
 		};
-		result = value === operand !== ((opCode & Op.NOT) !== 0);
+		result = applyOperator(opCode, value, 32n, hexToBytes(bigintToHex(operand)), propertyInfo.typeCode);
 		ctxOperand = operand;
 	} else result = applyOperator(opCode, value, 32n, operandData, propertyInfo.typeCode);
 	if (!result) return {
@@ -3261,6 +3293,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, findContextProperty, gasPrice, hexToBytes, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, toAddress, txOrigin };
+export { CallciumError, ContextProperty, Descriptor, DescriptorCoder, Op, PolicyBuilder, PolicyCoder, PolicyEnforcer, PolicyFormat, PolicyValidator, PolicyViolationError, Quantifier, Scope, TypeCode, ValidationError, arg, baseFee, blockNumber, blockTimestamp, bytesToHex, chainId, findContextProperty, gasPrice, hexToBytes, isContextOp, isLengthOp, isOpAllowed, isQuantifier, lookupContextProperty, lookupOp, lookupQuantifier, lookupScope, lookupTypeCode, msgSender, msgValue, parsePathSteps, txOrigin };
 
 //# sourceMappingURL=index.js.map