@callcium/sdk 0.12.0 → 0.13.0

package/src/operators.ts

@@ -1,8 +1,20 @@
-import { hexToBytes } from "./bytes";
-import { DescriptorFormat as DF, formatCode, Op, PolicyFormat as PF, TypeCode, operandsOf } from "./constants";
+import { bigintToHex, readU16 } from "./bytes";
+import {
+  comparisonOf,
+  ContextProperty,
+  DescriptorFormat as DF,
+  formatCode,
+  isComparisonCode,
+  isSourceCode,
+  Op,
+  PolicyFormat as PF,
+  Source,
+  sourceOf,
+  TypeCode,
+} from "./constants";
 import { CallciumError } from "./errors";
 
-import type { Hex } from "./types";
+import type { DecodedOperator, Hex } from "./types";
 
 /** Read a big-endian 256-bit unsigned integer from a 32-byte window. */
 export function toBigInt(bytes: Uint8Array, offset = 0): bigint {
@@ -15,6 +27,74 @@ export function toBigInt(bytes: Uint8Array, offset = 0): bigint {
   );
 }
 
+/** Type code of the type a length compares as, `uint32`. */
+export const LENGTH_TYPE = 0x04;
+
+/** Return true when the operator code (with or without NOT flag) is a LENGTH_* variant. */
+export function isLengthOp(opCode: number): boolean {
+  const base = comparisonOf(opCode);
+  return base >= Op.LENGTH_EQ && base <= Op.LENGTH_BETWEEN;
+}
+
+/** Return true when the operator admits a context property operand: EQ, GT, LT, GTE or LTE. */
+export function acceptsContextSource(opBase: number): boolean {
+  return opBase >= Op.EQ && opBase <= Op.LTE;
+}
+
+/** Return true when the type code has its length encoded in calldata (bytes, string, or dynamic array). */
+export function hasCalldataLength(typeCode: number): boolean {
+  return typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING || typeCode === TypeCode.DYNAMIC_ARRAY;
+}
+
+/**
+ * Return the byte width of a value of a static elementary type.
+ * @param typeCode - A single-byte descriptor type code.
+ * @returns The width in bytes, or undefined when the code names no static elementary type.
+ */
+export function operandWidth(typeCode: number): number | undefined {
+  if (typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX) return typeCode - TypeCode.UINT_MIN + 1;
+  if (typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX) return typeCode - TypeCode.INT_MIN + 1;
+  if (typeCode === TypeCode.ADDRESS) return 20;
+  if (typeCode === TypeCode.BOOL) return 1;
+  if (typeCode === TypeCode.FUNCTION) return 24;
+  if (typeCode >= TypeCode.FIXED_BYTES_MIN && typeCode <= TypeCode.FIXED_BYTES_MAX) {
+    return typeCode - TypeCode.FIXED_BYTES_MIN + 1;
+  }
+  return undefined;
+}
+
+/** Return the type code a context property carries: `address` for msg.sender and tx.origin, `uint256` otherwise. */
+export function contextPropertyType(contextPropertyId: number): number {
+  const isAddress = contextPropertyId === ContextProperty.MSG_SENDER || contextPropertyId === ContextProperty.TX_ORIGIN;
+  return isAddress ? TypeCode.ADDRESS : TypeCode.UINT_MAX;
+}
+
+/**
+ * Return the type a comparison's constants take against a target type. A length comparison compares a type with a
+ * calldata length as `LENGTH_TYPE`, any other comparison a static elementary type as itself.
+ * @param comparison - Comparison bits of the operator code.
+ * @param typeCode - The target's type code.
+ * @returns The operand type code, or undefined where the comparison does not apply to the target.
+ */
+export function operandTypeOf(comparison: number, typeCode: number): number | undefined {
+  if (isLengthOp(comparison)) return hasCalldataLength(typeCode) ? LENGTH_TYPE : undefined;
+  return operandWidth(typeCode) === undefined ? undefined : typeCode;
+}
+
+/**
+ * Check whether an operator's data payload has the correct length.
+ * @param opBase - Comparison bits of the operator code, a defined comparison.
+ * @param dataLength - Byte length of the operator's data payload.
+ * @param width - Byte width of one operand, at least one.
+ * @returns True if the data length is valid for the given operator.
+ */
+export function isValidPayloadSize(opBase: number, dataLength: number, width: number): boolean {
+  // Range operators carry a lower and an upper operand; IN carries one or more; every other operator one.
+  if (opBase === Op.BETWEEN || opBase === Op.LENGTH_BETWEEN) return dataLength === 2 * width;
+  if (opBase === Op.IN) return dataLength > 0 && dataLength % width === 0;
+  return dataLength === width;
+}
+
 /** Return true when the type code represents a signed integer (int8 through int256). */
 export function isSigned(typeCode: number): boolean {
   return typeCode >= TypeCode.INT_MIN && typeCode <= TypeCode.INT_MAX;
@@ -40,7 +120,7 @@ export function isLeftAligned(typeCode: number): boolean {
 export function canonicalize(value: bigint, typeCode: number): bigint {
   // Unsigned integers: mask to the low N bits.
   if (typeCode >= TypeCode.UINT_MIN && typeCode <= TypeCode.UINT_MAX) {
-    const bits = BigInt(typeCode * 8);
+    const bits = BigInt((typeCode - TypeCode.UINT_MIN + 1) * 8);
     return bits === 256n ? value : value & ((1n << bits) - 1n);
   }
 
@@ -61,208 +141,81 @@ export function canonicalize(value: bigint, typeCode: number): bigint {
 
   // Fixed bytes: left-aligned, clear the low (32 - N) padding bytes.
   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);
+    const width = typeCode - TypeCode.FIXED_BYTES_MIN + 1;
+    if (width === 32) return value;
+    const padBits = BigInt((32 - width) * 8);
     return (value >> padBits) << padBits;
   }
 
   return value;
 }
 
-/** Return true when the operator code (with or without NOT flag) is a LENGTH_* variant. */
-export function isLengthOp(opCode: number): boolean {
-  const base = opCode & ~Op.NOT;
-  return base >= Op.LENGTH_EQ && base <= Op.LENGTH_BETWEEN;
-}
-
-/** Return true when the operator code (with or without NOT flag) is a *_CTX variant. */
-export function isContextOp(opCode: number): boolean {
-  const base = opCode & ~Op.NOT;
-  return base >= Op.EQ_CTX && base <= Op.LTE_CTX;
-}
-
-/** Return true when LENGTH_* operators are valid for the given type code (bytes, string, or dynamic array). */
-export function isLengthValidType(typeCode: number): boolean {
-  return typeCode === TypeCode.BYTES || typeCode === TypeCode.STRING || typeCode === TypeCode.DYNAMIC_ARRAY;
-}
-
-/** Compare two 256-bit values, using two's complement interpretation for signed type codes. */
-function compareTyped(a: bigint, b: bigint, typeCode: number): number {
-  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;
+/** Read the `width`-byte big-endian member at `offset`. */
+export function readMember(data: Uint8Array, offset: number, width: number): bigint {
+  let value = 0n;
+  for (let index = 0; index < width; index++) value = (value << 8n) | BigInt(data[offset + index]!);
+  return value;
 }
 
-/** Binary search over a sorted array of 32-byte words. Comparison is always unsigned. */
-function isIn(value: bigint, data: Uint8Array): boolean {
-  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;
+/**
+ * Return the word an operand of a static elementary type loads to: placed at its type's alignment, and sign-extended
+ * for a signed integer.
+ * @param data - The bytes containing the operand.
+ * @param offset - Byte offset of the operand.
+ * @param typeCode - Type code of the operand.
+ * @returns The loaded 256-bit word.
+ * @throws {CallciumError} If the type code names no static elementary type.
+ */
+export function loadOperand(data: Uint8Array, offset: number, typeCode: number): bigint {
+  const width = operandWidth(typeCode);
+  if (width === undefined) throw new CallciumError("MALFORMED_HINT", "Target type code addresses no value");
+  const member = readMember(data, offset, width);
+  if (isLeftAligned(typeCode)) return member << BigInt(256 - 8 * width);
+  if (isSigned(typeCode)) return BigInt.asUintN(256, BigInt.asIntN(8 * width, member));
+  return member;
 }
 
 /**
- * Apply a single operator against a value and operand data. Handles the NOT flag by inverting the base result.
- * @param opCode - Operator code, potentially OR'd with the NOT flag.
- * @param value - The 256-bit value to test (ignored for LENGTH_* operators).
- * @param valueLength - Runtime byte or element count, only meaningful for LENGTH_* operators.
- * @param operandData - Raw operand bytes (32 per operand, 64 for range operators); for a context reference operator,
- *   the referenced property's value as one word.
- * @param typeCode - ABI type code, used to select signed vs. unsigned comparison.
- * @returns Whether the value satisfies the operator.
+ * Read the operator at `opOffset` of a policy, applied to a target of `typeCode`.
+ * @param data - A policy blob storage validation accepts.
+ * @param opOffset - Byte offset of the operator code.
+ * @param typeCode - The target's type code.
+ * @returns The operator with its comparison, its polarity and its operands, each constant loaded to its 32-byte word.
+ * @throws {CallciumError} If the operator code names no defined comparison or source.
  */
-export function applyOperator(
-  opCode: number,
-  value: bigint,
-  valueLength: bigint,
-  operandData: Uint8Array,
-  typeCode: number,
-): boolean {
-  const base = opCode & ~Op.NOT;
-  let result: boolean;
-
-  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;
+export function readOperator(data: Uint8Array, opOffset: number, typeCode: number): DecodedOperator {
+  const opCode = data[opOffset]!;
+  const comparison = comparisonOf(opCode);
+  const source = sourceOf(opCode);
+  if (!isComparisonCode(comparison) || !isSourceCode(source)) {
+    throw new CallciumError(
+      "UNKNOWN_OPERATOR",
+      `Unknown operator code ${formatCode(opCode & ~Op.NOT, PF.RULE_OPCODE_SIZE)}`,
+      opOffset,
+    );
+  }
+  const negated = (opCode & Op.NOT) !== 0;
+  const dataLength = readU16(data, opOffset + PF.RULE_OPCODE_SIZE);
+  const dataOffset = opOffset + PF.RULE_OPCODE_SIZE + PF.RULE_DATALENGTH_SIZE;
+
+  switch (source) {
+    case Source.CONTEXT: {
+      const contextPropertyId = readU16(data, dataOffset);
+      const operandType = contextPropertyType(contextPropertyId);
+      return { opCode, comparison, negated, operandType, source, contextPropertyId };
     }
-
-    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 Source.CONSTANT: {
+      const operandType = operandTypeOf(comparison, typeCode)!;
+      const width = operandWidth(operandType)!;
+      const values: Hex[] = [];
+      for (let offset = 0; offset < dataLength; offset += width) {
+        values.push(bigintToHex(loadOperand(data, dataOffset + offset, operandType)));
+      }
+      return { opCode, comparison, negated, operandType, source, values };
     }
-
-    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, PF.RULE_OPCODE_SIZE)}`);
+      return source satisfies never;
   }
-
-  const negate = (opCode & Op.NOT) !== 0;
-  return negate ? !result : result;
-}
-
-/**
- * Check whether an operator's data payload has the correct length.
- * @param opBase - Base operator code with the NOT flag stripped.
- * @param dataLength - Byte length of the operator's data payload.
- * @returns True if the data length is valid for the given operator.
- */
-export function isValidOperatorData(opBase: number, dataLength: number): boolean {
-  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;
-}
-
-/**
- * Read an operator's encoding as bytes: one opcode byte followed by its data payload.
- * @param operator - 0x-prefixed hex string holding a single operator.
- * @returns The operator's bytes, opcode first.
- * @throws {CallciumError} If the hex is malformed or carries no opcode byte.
- */
-export function toOperatorBytes(operator: Hex): Uint8Array {
-  const bytes = hexToBytes(operator);
-  if (bytes.length < 1) {
-    throw new CallciumError("INVALID_OPERATOR_BYTES", "Operator must have at least one byte (opcode)");
-  }
-  return bytes;
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -278,86 +231,32 @@ export type TypeClassInfo = { typeClass: TypeClass; isDynamic: boolean };
 /** Display metadata for a descriptor type code. */
 export type TypeCodeInfo = TypeClassInfo & { label: string };
 
-/** Throw an UNKNOWN_TYPE_CODE error. */
-function unknownTypeCode(code: number): never {
-  throw new CallciumError("UNKNOWN_TYPE_CODE", `Unknown type code ${formatCode(code, DF.TYPECODE_SIZE)}`);
-}
-
-// Pre-allocated constant objects for fixed type codes (avoids per-call allocation).
-const ELEMENTARY = { typeClass: "elementary", isDynamic: false } as const;
-const ELEMENTARY_DYNAMIC = { typeClass: "elementary", isDynamic: true } as const;
-const STATIC_ARR = { typeClass: "staticArray", isDynamic: false } as const;
-const DYNAMIC_ARR = { typeClass: "dynamicArray", isDynamic: true } as const;
-const TUPLE = { typeClass: "tuple", isDynamic: false } as const;
-
-/**
- * Classify a type code into its structural category and dynamism. A `lookupTypeCode` variant without labels.
- * @param code - A single-byte descriptor type code.
- * @returns Type class, and whether the code alone implies ABI dynamism (false for tuples and static arrays).
- * @throws {CallciumError} If the code is not a recognised type code.
- */
-export function classifyTypeCode(code: number): TypeClassInfo {
-  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 >= 0x44 && code <= 0x4f) 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 >= 0x72 && code <= 0x7f) unknownTypeCode(code);
-  if (code === TypeCode.STATIC_ARRAY) return STATIC_ARR;
-  if (code === TypeCode.DYNAMIC_ARRAY) return DYNAMIC_ARR;
-  if (code >= 0x82 && code <= 0x8f) unknownTypeCode(code);
-  if (code === TypeCode.TUPLE) return TUPLE;
-  unknownTypeCode(code);
-}
-
-/**
- * Determine whether a type code names an elementary type.
- * @param code - A single-byte descriptor type code.
- * @returns True for an elementary code; false for a composite or unassigned one.
- */
-export function isElementary(code: number): boolean {
-  try {
-    // An undefined code is reported by a throw, and names no elementary type either way.
-    return classifyTypeCode(code).typeClass === "elementary";
-  } catch {
-    return false;
+/** Each defined type code's ABI type label, structural category, and dynamism. */
+function typeCodeEntries(): [number, TypeCodeInfo][] {
+  const entries: [number, TypeCodeInfo][] = [];
+  const add = (code: number, label: string, typeClass: TypeClass, isDynamic: boolean) =>
+    entries.push([code, { label, typeClass, isDynamic }]);
+  for (let code = TypeCode.UINT_MIN; code <= TypeCode.UINT_MAX; code++) {
+    add(code, `uint${(code - TypeCode.UINT_MIN + 1) * 8}`, "elementary", false);
   }
-}
-
-/**
- * Determine whether a type code names a value an operator can read: a scalar word or a declared length. Tuples, static
- * arrays, and undefined codes address nothing.
- * @param code - A single-byte descriptor type code.
- * @returns True when an operator can be applied to a target of this type.
- */
-export function isAddressableTarget(code: number): boolean {
-  let info: TypeClassInfo;
-  try {
-    // An undefined code is reported by a throw, and addresses nothing either way.
-    info = classifyTypeCode(code);
-  } catch {
-    return false;
+  for (let code = TypeCode.INT_MIN; code <= TypeCode.INT_MAX; code++) {
+    add(code, `int${(code - TypeCode.INT_MIN + 1) * 8}`, "elementary", false);
+  }
+  add(TypeCode.ADDRESS, "address", "elementary", false);
+  add(TypeCode.BOOL, "bool", "elementary", false);
+  add(TypeCode.FUNCTION, "function", "elementary", false);
+  for (let code = TypeCode.FIXED_BYTES_MIN; code <= TypeCode.FIXED_BYTES_MAX; code++) {
+    add(code, `bytes${code - TypeCode.FIXED_BYTES_MIN + 1}`, "elementary", false);
   }
-  return info.typeClass === "elementary" || info.typeClass === "dynamicArray";
+  add(TypeCode.BYTES, "bytes", "elementary", true);
+  add(TypeCode.STRING, "string", "elementary", true);
+  add(TypeCode.STATIC_ARRAY, "T[k]", "staticArray", false);
+  add(TypeCode.DYNAMIC_ARRAY, "T[]", "dynamicArray", true);
+  add(TypeCode.TUPLE, "tuple", "tuple", false);
+  return entries;
 }
 
-/** Compute the ABI type label for a type code. */
-function typeCodeLabel(code: number): string {
-  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")}`;
-}
+const typeCodeByCode: ReadonlyMap<number, TypeCodeInfo> = new Map<number, TypeCodeInfo>(typeCodeEntries());
 
 /**
  * Map a raw type code byte to its ABI type label, structural category, and dynamism.
@@ -366,5 +265,7 @@ function typeCodeLabel(code: number): string {
  * @throws {CallciumError} If the code is not a recognised type code.
  */
 export function lookupTypeCode(code: number): TypeCodeInfo {
-  return { label: typeCodeLabel(code), ...classifyTypeCode(code) };
+  const info = typeCodeByCode.get(code);
+  if (!info) throw new CallciumError("UNKNOWN_TYPE_CODE", `Unknown type code ${formatCode(code, DF.TYPECODE_SIZE)}`);
+  return info;
 }

package/src/path.ts

@@ -1,5 +1,5 @@
 import { bytesToHex, hexToBytes, readU16, writeBE16 } from "./bytes";
-import { buildCodeMap, formatCode, PolicyFormat as PF } from "./constants";
+import { buildCodeMap, fieldMax, PolicyFormat as PF } from "./constants";
 import { CallciumError } from "./errors";
 
 import type { Hex } from "./types";
@@ -9,51 +9,27 @@ import type { Hex } from "./types";
 ///////////////////////////////////////////////////////////////////////////
 
 const QUANTIFIER_TABLE = [
-  { key: "ALL", code: 0xffff, label: "all" },
-  { key: "ANY", code: 0xfffe, label: "any" },
+  { key: "ALL", code: 0xffff },
+  { key: "ANY", code: 0xfffe },
 ] as const;
 
-/** Reserved path step values that trigger quantified evaluation over array elements. */
+/** Path steps that quantify over the array before them: `ALL` over every element, `ANY` over some element. */
 export const Quantifier = buildCodeMap(QUANTIFIER_TABLE);
 
-/** Display metadata for a quantifier step. */
-export type QuantifierInfo = { label: string };
-
-const quantifierByCode: ReadonlyMap<number, QuantifierInfo> = new Map<number, QuantifierInfo>(
-  QUANTIFIER_TABLE.map((entry) => [entry.code, { label: entry.label }]),
-);
-
-/** Check whether a path step is a quantifier (ALL or ANY). */
-export function isQuantifier(step: number): boolean {
-  return step >= Quantifier.ANY;
-}
-
-/**
- * Map a quantifier path step to its display label.
- * @param code - Quantifier step value.
- * @returns Display metadata for the quantifier.
- * @throws {CallciumError} If the code is not a recognised quantifier.
- */
-export function lookupQuantifier(code: number): QuantifierInfo {
-  const info = quantifierByCode.get(code);
-  if (!info)
-    throw new CallciumError("UNKNOWN_QUANTIFIER", `Unknown quantifier step ${formatCode(code, PF.PATH_STEP_SIZE)}`);
-  return info;
-}
-
 ///////////////////////////////////////////////////////////////////////////
 // Path steps
 ///////////////////////////////////////////////////////////////////////////
 
 /**
  * Encode a sequence of uint16 path steps as a big-endian hex string.
- * @throws {CallciumError} When a step is not an integer the field holds; a wrapped step addresses another argument.
+ * @throws {CallciumError} When a step is not an integer the field can represent.
+ * A wrapped step addresses another argument.
  */
 export function encodePath(steps: readonly number[]): Hex {
   const buffer = new Uint8Array(steps.length * PF.PATH_STEP_SIZE);
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i]!;
-    if (!Number.isInteger(step) || step < 0 || step > PF.PATH_STEP_MAX) {
+    if (!Number.isInteger(step) || step < 0 || step > fieldMax(PF.PATH_STEP_SIZE)) {
       throw new CallciumError("PATH_STEP_OVERFLOW", `Path step ${step} is outside the path step field`);
     }
     writeBE16(buffer, i * PF.PATH_STEP_SIZE, step);