@callcium/sdk 0.8.0 → 0.10.0

package/src/types.ts

@@ -52,8 +52,8 @@ export type SelectorMismatchViolation = {
 };
 
 /**
- * A context-scoped rule referenced a property not supplied in the execution context.
-
+ * A rule referenced a context property not supplied in the execution context — a context-scoped
+ * subject, or an `EQ_CTX` operand on either scope.
  */
 export type MissingContextViolation = {
   code: "MISSING_CONTEXT";
@@ -63,7 +63,9 @@ export type MissingContextViolation = {
   path: Hex;
   /** Declared type of the missing context property. */
   typeCode: number;
+  /** Operator code with the `Op.NOT` bit intact; absent for a context-scoped subject. */
   opCode?: number;
+  /** Operator payload; absent for a context-scoped subject. */
   operandData?: Hex;
 };
 
@@ -92,6 +94,11 @@ export type ValueMismatchViolation = {
   /** Type code of the failing value's leaf. */
   typeCode: number;
   resolvedValue?: Hex;
+  /**
+   * Resolved runtime value of a reference operand as a 32-byte word; present when the
+   * operator's operand names a reference resolved at enforcement, not a literal.
+   */
+  resolvedOperand?: Hex;
   elementIndex?: number;
 };
 
@@ -123,7 +130,7 @@ export type CalldataNavigationViolation =
   | CalldataNavigationVariant<"CALLDATA_OUT_OF_BOUNDS">
   | CalldataNavigationVariant<"ARRAY_INDEX_OUT_OF_BOUNDS">;
 
-/** A quantified array exceeded `Limits.MAX_QUANTIFIED_ARRAY_LENGTH`. */
+/** A quantified array exceeded `PolicyFormat.MAX_QUANTIFIED_ARRAY_LENGTH`. */
 export type QuantifierLimitExceededViolation = {
   code: "QUANTIFIER_LIMIT_EXCEEDED";
   group: number;
@@ -135,7 +142,7 @@ export type QuantifierLimitExceededViolation = {
 };
 
 /**
- * A resolved word is not the canonical encoding of its declared type (spec §7.4).
+ * A resolved word is not the canonical encoding of its declared type.
  *
  * `resolvedValue` is the raw 32-byte word as it appeared in calldata, before any masking.
  */
@@ -267,13 +274,80 @@ export type IssueSeverity = "info" | "warning" | "error";
 /** Category of a validation issue. */
 export type IssueCategory = "typeMismatch" | "contradiction" | "redundancy" | "vacuity" | "compatibility";
 
+/**
+ * Machine-readable code for a policy validation issue.
+ *
+ * Each code names one finding of the semantic validator and matches the constant of the same
+ * name in the Solidity `IssueCode` library.
+ */
+export type IssueCode =
+  // Type mismatch.
+  | "VALUE_OP_ON_DYNAMIC"
+  | "VALUE_OP_ON_COMPOSITE"
+  | "NUMERIC_OP_ON_NON_NUMERIC"
+  | "BITMASK_ON_INVALID"
+  | "IN_ON_BOOL"
+  | "LENGTH_ON_STATIC"
+  | "CONTEXT_TYPE_MISMATCH"
+  | "UNKNOWN_OPERATOR"
+  | "NON_CANONICAL_OPERAND"
+  | "UNNAVIGABLE_PATH"
+  | "NESTED_QUANTIFIER"
+  | "HINT_MISMATCH"
+  // Contradiction.
+  | "EQ_NEQ_CONTRADICTION"
+  | "CONFLICTING_EQUALITY"
+  | "OUT_OF_PHYSICAL_BOUNDS"
+  | "IMPOSSIBLE_GT"
+  | "IMPOSSIBLE_LT"
+  | "BOUNDS_EXCLUDE_EQUALITY"
+  | "IMPOSSIBLE_RANGE"
+  | "SET_EXCLUDES_EQUALITY"
+  | "EMPTY_SET_INTERSECTION"
+  | "SET_FULLY_EXCLUDED"
+  | "LENGTH_EQ_NEQ_CONTRADICTION"
+  | "CONFLICTING_LENGTH"
+  | "BOUNDS_EXCLUDE_LENGTH"
+  | "IMPOSSIBLE_LENGTH_RANGE"
+  | "OUT_OF_PHYSICAL_LENGTH_BOUNDS"
+  | "IMPOSSIBLE_LENGTH_GT"
+  | "IMPOSSIBLE_LENGTH_LT"
+  | "BITMASK_CONTRADICTION"
+  | "BITMASK_ANY_IMPOSSIBLE"
+  | "UNSORTED_IN_SET"
+  | "EMPTY_GROUP"
+  // Redundancy.
+  | "DOMINATED_BOUND"
+  | "REDUNDANT_BOUND"
+  | "SET_REDUCTION"
+  | "SET_REDUNDANCY"
+  | "SET_PARTIALLY_EXCLUDED"
+  | "DOMINATED_LENGTH_BOUND"
+  | "REDUNDANT_LENGTH_BOUND"
+  | "REDUNDANT_BITMASK"
+  | "DUPLICATE_CONSTRAINT"
+  | "FUSIBLE_RANGE"
+  | "FUSIBLE_LENGTH_RANGE"
+  // Vacuity.
+  | "VACUOUS_GTE"
+  | "VACUOUS_LTE"
+  | "VACUOUS_LENGTH_GTE"
+  | "VACUOUS_LENGTH_LTE"
+  | "VACUOUS_NEGATED_RANGE"
+  | "VACUOUS_NEGATED_LENGTH_RANGE"
+  // Compatibility.
+  | "PATH_DEPTH_EXCEEDED"
+  | "QUANTIFIER_OVER_STATIC_LIMIT"
+  | "UNKNOWN_CONTEXT_PROPERTY"
+  | "NEGATION_UNDER_ANY";
+
 /** A single validation issue found during policy analysis. */
 export type Issue = {
   severity: IssueSeverity;
   category: IssueCategory;
   groupIndex: number;
   constraintIndex: number;
-  code: string;
+  code: IssueCode;
   value1: Hex;
   value2: Hex;
   message: string;

package/src/validation-issue.ts

@@ -1,4 +1,4 @@
-import type { Hex, Issue } from "./types";
+import type { Hex, Issue, IssueCode } from "./types";
 
 ///////////////////////////////////////////////////////////////////////////
 // Constants
@@ -12,7 +12,7 @@ const ZERO: Hex = `0x${"0".repeat(64)}`;
 
 /** Create an issue from operator compatibility results. */
 export function fromOpRule(
-  code: string,
+  code: IssueCode,
   message: string,
   groupIndex: number,
   constraintIndex: number,
@@ -72,6 +72,20 @@ export function hintMismatch(groupIndex: number, constraintIndex: number): Issue
   };
 }
 
+/** Issue for a context reference whose property cannot match the target type. */
+export function contextTypeMismatch(groupIndex: number, constraintIndex: number, contextId: Hex, typeCode: Hex): Issue {
+  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",
+  };
+}
+
 /** Issue for an operand that is not canonically encoded for the declared type. */
 export function nonCanonicalOperand(groupIndex: number, constraintIndex: number, operand: Hex, canonical: Hex): Issue {
   return {
@@ -290,7 +304,7 @@ export function unsortedInSet(groupIndex: number, constraintIndex: number): Issu
     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",
   };
 }
 
@@ -304,7 +318,7 @@ export function emptyGroup(groupIndex: number): Issue {
     code: "EMPTY_GROUP",
     value1: ZERO,
     value2: ZERO,
-    message: "Group contains zero constraints.",
+    message: "Group contains zero constraints",
   };
 }