@callcium/sdk 0.8.0 → 0.10.0

package/src/policy-enforcer.ts

@@ -1,16 +1,8 @@
-import { hexToBytes, bytesToHex, readU16, readU32, bigintToHex } from "./bytes";
+import { hexToBytes, bytesToHex, readU16, readU32, bigintToHex, toAddress } from "./bytes";
 import { loadWord, readPointer } from "./calldata-reader";
-import {
-  PolicyFormat as PF,
-  Scope,
-  MAX_CONTEXT_PROPERTY_ID,
-  Limits,
-  TypeCode,
-  classifyTypeCode,
-  lookupContextProperty,
-} from "./constants";
+import { PolicyFormat as PF, Scope, MAX_CONTEXT_PROPERTY_ID, Op, TypeCode, lookupContextProperty } from "./constants";
 import { CallciumError, PolicyViolationError } from "./errors";
-import { applyOperator, toBigInt, isLengthOp, isLengthValidType, canonicalize } from "./operators";
+import { applyOperator, toBigInt, isLengthOp, isLengthValidType, canonicalize, classifyTypeCode } from "./operators";
 import { decodePolicy } from "./policy-coder";
 
 import type { ReadResult } from "./calldata-reader";
@@ -29,20 +21,17 @@ import type {
 // Helpers
 ///////////////////////////////////////////////////////////////////////////
 
-/** Violations that abort evaluation instead of failing only their group (spec §9.3). */
-const ABORT_VIOLATION_CODES: ReadonlySet<ViolationCode> = new Set<ViolationCode>([
+/** Violations that abort evaluation instead of failing only their group. */
+const abortViolationCodes: ReadonlySet<ViolationCode> = new Set<ViolationCode>([
   "CALLDATA_OUT_OF_BOUNDS",
   "ARRAY_INDEX_OUT_OF_BOUNDS",
   "NON_CANONICAL_VALUE",
   "QUANTIFIER_LIMIT_EXCEEDED",
 ]);
 
-/** Convert a hex address to a 256-bit bigint (zero-padded to 32 bytes). */
+/** Validate a hex address and read it as a 256-bit bigint. */
 function addressToBigInt(hex: string): bigint {
-  const bytes = hexToBytes(hex);
-  const padded = new Uint8Array(32);
-  padded.set(bytes, 32 - bytes.length);
-  return toBigInt(padded, 0);
+  return BigInt(toAddress(hex));
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -99,8 +88,8 @@ function check(policy: Hex, callData: Hex, context?: Context): EnforceResult {
       const violation = evaluateRule(rule, policyBytes, callDataBytes, baseOffset, groupIndex, ruleIndex, context);
       if (violation !== null) {
         allViolations.push(violation);
-        if (ABORT_VIOLATION_CODES.has(violation.code)) {
-          // Abort violations reject the policy outright; later groups are not consulted (spec §9.3).
+        if (abortViolationCodes.has(violation.code)) {
+          // Abort violations reject the policy outright; later groups are not consulted.
           return { ok: false, violations: allViolations };
         }
         groupFailed = true;
@@ -172,9 +161,21 @@ function evaluateRule(
     groupIndex,
     ruleIndex,
     rule.path.value,
+    context,
   );
 }
 
+/**
+ * Resolve an EQ_CTX operand word to the referenced context property's value as a raw word.
+ * Returns the missing property's type code when the context does not supply it.
+ */
+function resolveContextOperand(operandData: Uint8Array, context?: Context): bigint | { ctxTypeCode: number } {
+  const propertyInfo = lookupContextProperty(Number(toBigInt(operandData, 0)));
+  const value = context?.[propertyInfo.contextKey];
+  if (value === undefined) return { ctxTypeCode: propertyInfo.typeCode };
+  return typeof value === "string" ? addressToBigInt(value) : value;
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Hint chain resolution
 ///////////////////////////////////////////////////////////////////////////
@@ -247,9 +248,10 @@ function chainResolve(
 ///////////////////////////////////////////////////////////////////////////
 
 type TargetResult =
-  | { passed: boolean; value: bigint }
+  | { passed: boolean; value: bigint; ctxOperand?: bigint }
   | { error: NavigationViolationCode }
-  | { error: "NON_CANONICAL_VALUE"; value: bigint };
+  | { error: "NON_CANONICAL_VALUE"; value: bigint }
+  | { error: "MISSING_CONTEXT"; ctxTypeCode: number };
 
 /**
  * Load the value at a resolved target offset and apply the operator.
@@ -264,13 +266,14 @@ function evalTarget(
   block: TargetBlock,
   opCode: number,
   operandData: Uint8Array,
+  context?: Context,
 ): TargetResult {
   const typeCode = block.typeCode;
 
   // A dynamic target's chain ends at its payload, so the word there is the declared length.
   if (isLengthValidType(typeCode)) {
     if (!isLengthOp(opCode)) {
-      throw new CallciumError("OPERATOR_TARGET_MISMATCH", "Value operator on a target without a scalar word.");
+      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 };
@@ -285,7 +288,7 @@ function evalTarget(
   }
 
   if (classifyTypeCode(typeCode).typeClass !== "elementary") {
-    throw new CallciumError("OPERATOR_TARGET_MISMATCH", "Operator target does not carry a scalar word.");
+    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 };
@@ -295,6 +298,13 @@ function evalTarget(
     return { 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 };
+    const passed = (value === operand) !== ((opCode & Op.NOT) !== 0);
+    return { passed, value, ctxOperand: operand };
+  }
+
   const passed = applyOperator(opCode, value, 32, operandData, typeCode);
   return { passed, value };
 }
@@ -331,6 +341,18 @@ function navigationViolation(frame: RuleFrame, code: NavigationViolationCode, el
 /** Convert a failed or erroring target result into its violation. Passing results map to null. */
 function targetViolation(frame: RuleFrame, result: TargetResult, elementIndex?: number): Violation | null {
   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,
@@ -359,6 +381,7 @@ function targetViolation(frame: RuleFrame, result: TargetResult, elementIndex?:
     operandData: bytesToHex(frame.operandData),
     typeCode: frame.typeCode,
     resolvedValue: bigintToHex(result.value),
+    ...(result.ctxOperand !== undefined && { resolvedOperand: bigintToHex(result.ctxOperand) }),
     ...(elementIndex !== undefined && { elementIndex }),
   };
 }
@@ -373,6 +396,7 @@ function evaluateCalldataRule(
   groupIndex: number,
   ruleIndex: number,
   pathHex: Hex,
+  context?: Context,
 ): Violation | null {
   const header = hint[0]!;
   const hopCount = header & PF.HINT_HOP_COUNT_MASK;
@@ -392,6 +416,7 @@ function evaluateCalldataRule(
       groupIndex,
       ruleIndex,
       pathHex,
+      context,
     );
   }
 
@@ -408,7 +433,10 @@ function evaluateCalldataRule(
   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),
+  );
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -428,6 +456,7 @@ function evaluateQuantified(
   groupIndex: number,
   ruleIndex: number,
   pathHex: Hex,
+  context?: Context,
 ): Violation | null {
   const frameOffset = hopsOffset + hopCount * PF.HINT_HOP_SIZE;
   const suffixHeaderOffset = frameOffset + PF.HINT_FRAME_PREFIX_SIZE;
@@ -459,7 +488,7 @@ function evaluateQuantified(
     elems += 32;
   }
 
-  if (count > Limits.MAX_QUANTIFIED_ARRAY_LENGTH) {
+  if (count > PF.MAX_QUANTIFIED_ARRAY_LENGTH) {
     return {
       group: groupIndex,
       rule: ruleIndex,
@@ -486,13 +515,15 @@ function evaluateQuantified(
   const elemStride = (meta & PF.HINT_META_STRIDE_MASK) * 32;
   const elemIsDynamic = (meta & PF.HINT_META_ELEM_DYNAMIC) !== 0;
 
+  // A reference operand resolves identically for every element; any element's result carries it.
+  let ctxOperand: bigint | undefined;
   for (let elemIndex = 0; elemIndex < count; elemIndex++) {
     const slot = elems + elemIndex * elemStride;
     let elem: number = slot;
     if (elemIsDynamic) {
       const followed = follow(callDataBytes, elems, slot);
       // Navigation failures abort under every quantifier: calldata the enforcer cannot read is
-      // not an element that merely fails the operator (spec §9.3).
+      // not an element that merely fails the operator.
       if (typeof followed !== "number") return navigationViolation(frame, followed.code, elemIndex);
       elem = followed;
     }
@@ -504,10 +535,11 @@ function evaluateQuantified(
       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) {
-      // An abort-effect violation ends evaluation whatever the quantifier; a later element cannot
-      // rescue calldata the enforcer cannot read (spec §9.3).
+      // Error results end the rule whatever the quantifier: a later element cannot rescue
+      // calldata the enforcer cannot read (an abort effect), and a missing context
+      // property is missing for every element alike (group-local).
       return targetViolation(frame, applied, elemIndex);
     }
 
@@ -517,6 +549,7 @@ function evaluateQuantified(
     } else if (isUniversal) {
       return targetViolation(frame, applied, elemIndex);
     }
+    ctxOperand = applied.ctxOperand;
   }
 
   if (isUniversal) return null;
@@ -530,6 +563,7 @@ function evaluateQuantified(
     opCode,
     operandData: bytesToHex(operandData),
     typeCode: block.typeCode,
+    ...(ctxOperand !== undefined && { resolvedOperand: bigintToHex(ctxOperand) }),
   };
 }
 
@@ -556,8 +590,8 @@ function evaluateContextRule(
     );
   }
 
-  const propInfo = lookupContextProperty(propertyId);
-  const contextValue = context?.[propInfo.contextKey];
+  const propertyInfo = lookupContextProperty(propertyId);
+  const contextValue = context?.[propertyInfo.contextKey];
 
   if (contextValue === undefined) {
     return {
@@ -566,7 +600,7 @@ function evaluateContextRule(
       code: "MISSING_CONTEXT",
       scope: Scope.CONTEXT,
       path: pathHex,
-      typeCode: propInfo.typeCode,
+      typeCode: propertyInfo.typeCode,
     };
   }
 
@@ -577,7 +611,27 @@ function evaluateContextRule(
     value = contextValue;
   }
 
-  const result = applyOperator(opCode, value, 32, operandData, propInfo.typeCode);
+  let result: boolean;
+  let ctxOperand: bigint | undefined;
+  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 {
@@ -588,8 +642,9 @@ function evaluateContextRule(
       path: pathHex,
       opCode,
       operandData: bytesToHex(operandData),
-      typeCode: propInfo.typeCode,
+      typeCode: propertyInfo.typeCode,
       resolvedValue: bigintToHex(value),
+      ...(ctxOperand !== undefined && { resolvedOperand: bigintToHex(ctxOperand) }),
     };
   }
 

package/src/policy-validator.ts

@@ -1,31 +1,28 @@
 import { bigintToHex, bytesToHex, hexToBytes } from "./bytes";
-import {
-  classifyTypeCode,
-  isQuantifier,
-  isValidOperatorData,
-  Limits,
-  lookupContextProperty,
-  MAX_CONTEXT_PROPERTY_ID,
-  Op,
-  Quantifier,
-  Scope,
-  TypeCode,
-} from "./constants";
+import { PolicyFormat, lookupContextProperty, MAX_CONTEXT_PROPERTY_ID, Op, Scope, TypeCode } from "./constants";
 import { Descriptor, type TypeInfo } from "./descriptor";
 import { decodeDescriptor } from "./descriptor-coder";
 import { CallciumError, type CallciumErrorCode } from "./errors";
-import { canonicalize, isLeftAligned, isSigned, isLengthOp, isLengthValidType } from "./operators";
-import { parsePathSteps } from "./policy-coder";
+import {
+  canonicalize,
+  isLeftAligned,
+  isSigned,
+  isLengthOp,
+  isLengthValidType,
+  classifyTypeCode,
+  isValidOperatorData,
+} from "./operators";
+import { Quantifier, isQuantifier, parsePathSteps } from "./path";
 import * as ValidationIssue from "./validation-issue";
 
-import type { Constraint, Hex, Issue, PolicyData } from "./types";
+import type { Constraint, Hex, Issue, IssueCode, PolicyData } from "./types";
 
 ///////////////////////////////////////////////////////////////////////////
 // Internal types
 ///////////////////////////////////////////////////////////////////////////
 
 /** Codes a path walk raises when the path does not navigate the descriptor (PV-1). */
-const NAVIGABILITY_CODES: ReadonlySet<CallciumErrorCode> = new Set<CallciumErrorCode>([
+const navigabilityCodes: ReadonlySet<CallciumErrorCode> = new Set<CallciumErrorCode>([
   "EMPTY_PATH",
   "PARAM_INDEX_OUT_OF_BOUNDS",
   "TUPLE_FIELD_OUT_OF_BOUNDS",
@@ -139,7 +136,7 @@ function getDomainLimits(typeCode: number): { min: bigint; max: bigint } {
 // Operator classification
 ///////////////////////////////////////////////////////////////////////////
 
-/** True for EQ, GT, LT, GTE, LTE, BETWEEN, IN, BITMASK_*. */
+/** True for EQ, GT, LT, GTE, LTE, BETWEEN, IN, EQ_CTX, BITMASK_*. */
 function isValueOp(opBase: number): boolean {
   return opBase <= Op.BITMASK_NONE;
 }
@@ -159,7 +156,7 @@ function isBitmaskOp(opBase: number): boolean {
 ///////////////////////////////////////////////////////////////////////////
 
 /** Return the incompatibility reason, or null if the operator is allowed. */
-function getIncompat(opBase: number, typeInfo: TypeInfo): { code: string; message: string } | null {
+function getIncompat(opBase: number, typeInfo: TypeInfo): { code: IssueCode; message: string } | null {
   const { typeCode, isDynamic, staticSize } = typeInfo;
   if (isValueOp(opBase)) {
     if (isDynamic || staticSize !== 32) {
@@ -178,6 +175,14 @@ function getIncompat(opBase: number, typeInfo: TypeInfo): { code: string; messag
     if (opBase === Op.IN && typeCode === TypeCode.BOOL) {
       return { code: "IN_ON_BOOL", message: "IN operator used on boolean type" };
     }
+    // Context properties are addresses or uint256, so only those target classes can match.
+    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)) {
@@ -890,7 +895,35 @@ function validateConstraint(
       continue;
     }
 
-    if (isValueOp(base)) {
+    if (base === Op.EQ_CTX) {
+      // The operand names a context property, not a value: nothing to fold into a domain.
+      const ctxOperand = readValue(opHex);
+      if (ctxOperand > BigInt(MAX_CONTEXT_PROPERTY_ID)) {
+        issues.push(
+          ValidationIssue.unknownContextProperty(
+            groupIndex,
+            constraintIndex,
+            bigintToHex(ctxOperand),
+            bigintToHex(BigInt(MAX_CONTEXT_PROPERTY_ID)),
+          ),
+        );
+      } else {
+        // Compatibility has already narrowed the target to an address or unsigned type,
+        // so the pairing reduces to whether both sides are addresses.
+        const propertyIsAddress = lookupContextProperty(Number(ctxOperand)).typeCode === TypeCode.ADDRESS;
+        const targetIsAddress = ctx.typeInfo.typeCode === TypeCode.ADDRESS;
+        if (propertyIsAddress !== targetIsAddress) {
+          issues.push(
+            ValidationIssue.contextTypeMismatch(
+              groupIndex,
+              constraintIndex,
+              bigintToHex(ctxOperand),
+              bigintToHex(BigInt(ctx.typeInfo.typeCode)),
+            ),
+          );
+        }
+      }
+    } else if (isValueOp(base)) {
       // A non-canonical operand can never equal a canonicalized runtime value (PC-1, spec
       // section 4.5), so the rule is unsatisfiable or vacuous; skip analyzing the garbage
       // word. Scoped to the left-aligned types: numeric, address, and bool operands are
@@ -1000,13 +1033,13 @@ function validateGroup(data: PolicyData, descBytes: Uint8Array, groupIndex: numb
       let typeInfo: TypeInfo;
       if (constraint.scope === Scope.CALLDATA) {
         // Compatibility warnings against the limits the spec fixes (PWF-17, PV-7).
-        if (steps.length > Limits.MAX_PATH_DEPTH) {
+        if (steps.length > PolicyFormat.MAX_PATH_DEPTH) {
           issues.push(
             ValidationIssue.pathDepthExceeded(
               groupIndex,
               constraintIndex,
               bigintToHex(BigInt(steps.length)),
-              bigintToHex(BigInt(Limits.MAX_PATH_DEPTH)),
+              bigintToHex(BigInt(PolicyFormat.MAX_PATH_DEPTH)),
             ),
           );
         }
@@ -1015,7 +1048,7 @@ function validateGroup(data: PolicyData, descBytes: Uint8Array, groupIndex: numb
           walk = Descriptor.walkPath(descBytes, steps);
         } catch (error) {
           // Navigability faults become issues; anything else propagates.
-          if (error instanceof CallciumError && NAVIGABILITY_CODES.has(error.code)) {
+          if (error instanceof CallciumError && navigabilityCodes.has(error.code)) {
             issues.push(ValidationIssue.unnavigablePath(groupIndex, constraintIndex));
             continue;
           }
@@ -1026,13 +1059,13 @@ function validateGroup(data: PolicyData, descBytes: Uint8Array, groupIndex: numb
           issues.push(ValidationIssue.nestedQuantifier(groupIndex, constraintIndex));
           continue;
         }
-        if (walk.quantifiedStaticLength > Limits.MAX_QUANTIFIED_ARRAY_LENGTH) {
+        if (walk.quantifiedStaticLength > PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH) {
           issues.push(
             ValidationIssue.quantifierOverStaticLimit(
               groupIndex,
               constraintIndex,
               bigintToHex(BigInt(walk.quantifiedStaticLength)),
-              bigintToHex(BigInt(Limits.MAX_QUANTIFIED_ARRAY_LENGTH)),
+              bigintToHex(BigInt(PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH)),
             ),
           );
         }
@@ -1067,7 +1100,7 @@ function validateGroup(data: PolicyData, descBytes: Uint8Array, groupIndex: numb
     if (
       constraint.scope === Scope.CALLDATA &&
       constraint.hint !== undefined &&
-      ctx.steps.length <= Limits.MAX_PATH_DEPTH
+      ctx.steps.length <= PolicyFormat.MAX_PATH_DEPTH
     ) {
       const compiled = bytesToHex(Descriptor.compileHint(descBytes, ctx.steps));
       if (compiled !== constraint.hint.toLowerCase()) {

package/src/type-desc.ts

@@ -48,7 +48,7 @@ export function function_(): Uint8Array {
  */
 export function uintN(bits: number): Uint8Array {
   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.`);
+    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)]);
 }
@@ -60,7 +60,7 @@ export function uintN(bits: number): Uint8Array {
  */
 export function intN(bits: number): Uint8Array {
   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.`);
+    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)]);
 }
@@ -82,7 +82,7 @@ export function string_(): Uint8Array {
  */
 export function bytesN(n: number): Uint8Array {
   if (n < 1 || n > 32) {
-    throw new CallciumError("UNKNOWN_TYPE", `Invalid bytesN size: ${n}. Must be 1–32.`);
+    throw new CallciumError("UNKNOWN_TYPE", `Invalid bytesN size: ${n}. Must be 1–32`);
   }
   return new Uint8Array([TypeCode.FIXED_BYTES_MIN + (n - 1)]);
 }
@@ -108,7 +108,7 @@ export function array(elemDesc: Uint8Array, length?: number): Uint8Array {
     if (nodeLength > DF.MAX_NODE_LENGTH) {
       throw new CallciumError(
         "NODE_LENGTH_TOO_LARGE",
-        `Dynamic array node length ${nodeLength} exceeds maximum ${DF.MAX_NODE_LENGTH}.`,
+        `Dynamic array node length ${nodeLength} exceeds maximum ${DF.MAX_NODE_LENGTH}`,
       );
     }
     const meta24 = (0 << DF.META_STATIC_WORDS_SHIFT) | nodeLength;
@@ -123,14 +123,14 @@ export function array(elemDesc: Uint8Array, length?: number): Uint8Array {
   if (length <= 0 || length > DF.MAX_STATIC_ARRAY_LENGTH) {
     throw new CallciumError(
       "INVALID_ARRAY_LENGTH",
-      `Static array length ${length} out of range. Must be 1–${DF.MAX_STATIC_ARRAY_LENGTH}.`,
+      `Static array length ${length} out of range. Must be 1–${DF.MAX_STATIC_ARRAY_LENGTH}`,
     );
   }
   const nodeLength = DF.ARRAY_HEADER_SIZE + elemDesc.length + DF.ARRAY_LENGTH_SIZE;
   if (nodeLength > DF.MAX_NODE_LENGTH) {
     throw new CallciumError(
       "NODE_LENGTH_TOO_LARGE",
-      `Static array node length ${nodeLength} exceeds maximum ${DF.MAX_NODE_LENGTH}.`,
+      `Static array node length ${nodeLength} exceeds maximum ${DF.MAX_NODE_LENGTH}`,
     );
   }
   const elemStaticWords = extractStaticWords(elemDesc);
@@ -138,7 +138,7 @@ export function array(elemDesc: Uint8Array, length?: number): Uint8Array {
   if (staticWords > DF.MAX_STATIC_WORDS) {
     throw new CallciumError(
       "STATIC_WORDS_TOO_LARGE",
-      `Static array static words ${staticWords} exceeds maximum ${DF.MAX_STATIC_WORDS}.`,
+      `Static array static words ${staticWords} exceeds maximum ${DF.MAX_STATIC_WORDS}`,
     );
   }
   const meta24 = (staticWords << DF.META_STATIC_WORDS_SHIFT) | nodeLength;
@@ -162,7 +162,7 @@ export function tuple(fieldDescs: Uint8Array[]): Uint8Array {
   if (fieldDescs.length === 0 || fieldDescs.length > DF.MAX_TUPLE_FIELDS) {
     throw new CallciumError(
       "INVALID_TUPLE_FIELD_COUNT",
-      `Tuple field count ${fieldDescs.length} out of range. Must be 1–${DF.MAX_TUPLE_FIELDS}.`,
+      `Tuple field count ${fieldDescs.length} out of range. Must be 1–${DF.MAX_TUPLE_FIELDS}`,
     );
   }
   const totalFieldBytes = fieldDescs.reduce((sum, f) => sum + f.length, 0);
@@ -170,7 +170,7 @@ export function tuple(fieldDescs: Uint8Array[]): Uint8Array {
   if (nodeLength > DF.MAX_NODE_LENGTH) {
     throw new CallciumError(
       "NODE_LENGTH_TOO_LARGE",
-      `Tuple node length ${nodeLength} exceeds maximum ${DF.MAX_NODE_LENGTH}.`,
+      `Tuple node length ${nodeLength} exceeds maximum ${DF.MAX_NODE_LENGTH}`,
     );
   }
 
@@ -187,7 +187,7 @@ export function tuple(fieldDescs: Uint8Array[]): Uint8Array {
   if (staticWords > DF.MAX_STATIC_WORDS) {
     throw new CallciumError(
       "STATIC_WORDS_TOO_LARGE",
-      `Tuple static words ${staticWords} exceeds maximum ${DF.MAX_STATIC_WORDS}.`,
+      `Tuple static words ${staticWords} exceeds maximum ${DF.MAX_STATIC_WORDS}`,
     );
   }
   const meta24 = (staticWords << DF.META_STATIC_WORDS_SHIFT) | nodeLength;