@crediolabs/policy-synth 0.1.7 → 0.1.9

package/src/synth/deny-cases.ts

@@ -51,6 +51,15 @@ const ADJACENT_ASSETS = [
 const OVERPERMISSIVE_DIMENSIONS = ['argument_reorder'] as const
 
 // The 15 dimensions the synth pipeline uses for self-verify and minimise.
+// Phase 1 grammar extension: `vec_append` and `map_field_flip` are listed below
+// alongside the existing dimensions so the per-element binds emitted for
+// Blend `submit` (call_arg_len + 3 call_arg_field per element) survive
+// minimise. Without these, no deny case exercises the new leaves and the
+// minimise pass drops them as "redundant" - reopening the element-append
+// hole they were added to close. Both dimensions are no-ops for any fixture
+// whose predicate has no `call_arg_len` / `call_arg_field` leaves (the
+// generator short-circuits on leaf-kind), so they cannot make production
+// synthesis refuse for fixtures that do not exercise the new grammar.
 const ORIGINAL_DIMENSIONS: string[] = [
   'amount',
   'asset',
@@ -67,6 +76,8 @@ const ORIGINAL_DIMENSIONS: string[] = [
   'oracle_deviation_exceeded',
   'oracle_paused',
   'soroswap_allowed_path',
+  'vec_append',
+  'map_field_flip',
 ]
 
 export { ORIGINAL_DIMENSIONS, OVERPERMISSIVE_DIMENSIONS }
@@ -263,7 +274,9 @@ export function generateCases(
     hasConstrainedArg &&
     permitCtx.args.length >= 2 &&
     permitCtx.args[0]?.type === 'address' &&
-    permitCtx.args[1]?.type === 'address'
+    permitCtx.args[1]?.type === 'address' &&
+    (permitCtx.args[0] as { type: 'address'; value: string }).value !==
+      (permitCtx.args[1] as { type: 'address'; value: string }).value
   ) {
     const ctx = cloneContext(permitCtx)
     // Guard above guarantees args[0] and args[1] exist and are address-typed.
@@ -274,6 +287,55 @@ export function generateCases(
     denies.push({ dimension: 'argument_reorder', ctx })
   }
 
+  // --- map_field_flip: flip a bound map field to a different valid value of
+  // the same type. Mirrors argument_reorder: OPT-IN only, never ORIGINAL.
+  // Targets each `call_arg_field` leaf and produces a ctx whose vec element
+  // has a different value of the recorded field (different request_type,
+  // different amount, different address). The blend-submit case uses this
+  // to detect a missing request_type pin. ---
+  if (!dimensions || dimensions.includes('map_field_flip')) {
+    for (const comparison of facts.comparisons) {
+      const sel = comparison.left
+      if (sel.kind !== 'call_arg_field') continue
+      const arg = permitCtx.args[sel.index]
+      if (!arg || arg.type !== 'vec') continue
+      const element = arg.value[sel.element]
+      if (!element || element.type !== 'map' || !Array.isArray(element.value)) continue
+      const entry = element.value.find((e) => e.key === sel.field)
+      if (!entry) continue
+      const flipped = flipFieldValue(entry.val)
+      if (flipped === null) continue
+      const ctx = cloneContext(permitCtx)
+      const clonedVec = arg.value.map(cloneScVal)
+      const clonedElement = clonedVec[sel.element]
+      if (clonedElement?.type !== 'map' || !Array.isArray(clonedElement.value)) continue
+      clonedElement.value = clonedElement.value.map((e) =>
+        e.key === sel.field ? { key: e.key, val: flipped } : e
+      )
+      clonedVec[sel.element] = clonedElement
+      ctx.args[sel.index] = { type: 'vec', value: clonedVec }
+      denies.push({ dimension: 'map_field_flip', ctx })
+    }
+  }
+
+  // --- vec_append: append a new element to a bound vec. Mirrors map_field_flip:
+  // OPT-IN only, never ORIGINAL. Targets every `call_arg_len` leaf; without the
+  // length pin a caller can append an extra element to defeat per-element binds. ---
+  if (!dimensions || dimensions.includes('vec_append')) {
+    for (const comparison of facts.comparisons) {
+      const sel = comparison.left
+      if (sel.kind !== 'call_arg_len') continue
+      const arg = permitCtx.args[sel.index]
+      if (!arg || arg.type !== 'vec') continue
+      const ctx = cloneContext(permitCtx)
+      ctx.args[sel.index] = {
+        type: 'vec',
+        value: [...arg.value, { type: 'other', value: 'deny-case-vec-append' }],
+      }
+      denies.push({ dimension: 'vec_append', ctx })
+    }
+  }
+
   // Version mismatch, malformed predicates, master authorization, and nonce replay are install-time checks and are intentionally omitted from model-evaluated cases.
   return { permit: cloneContext(permitCtx), denies }
 }
@@ -528,3 +590,26 @@ function cloneDepthError(value: ScVal): never {
   err.depthContext = value.type
   throw err
 }
+
+/** Build a value of the SAME ScVal type that differs from the recorded one,
+ *  used by the `map_field_flip` mutation to defeat a per-element pin without
+ *  changing the wire type (a type/arity change is rejected by host dispatch
+ *  before Policy::enforce, so it is not the predicate's job). Returns null
+ *  when the ScVal type has no obvious different value (e.g. opaque/other). */
+function flipFieldValue(val: ScVal): ScVal | null {
+  switch (val.type) {
+    case 'address': {
+      const a = 'GBFKRGJYZXLTDEI36ZCQEIM225NMOCR2VDBOIHJTXJ54FEFFVL2FKALE'
+      const b = 'GD6XSMQJ47EHHJOWXQOND5YDVZC37JWZJHYHBKE6QJFSLLJ5KQXM5QS5'
+      return { type: 'address', value: val.value === a ? b : a }
+    }
+    case 'i128':
+    case 'u64':
+    case 'u32':
+      return { type: val.type, value: String(BigInt(val.value) + 1n) }
+    case 'symbol':
+      return { type: 'symbol', value: `${val.value}x` }
+    default:
+      return null
+  }
+}

package/src/synth/evaluate.ts

@@ -216,6 +216,33 @@ function evalCompare(
     return evalArgEq(op, actual, right, ctx)
   }
 
+  // --- step 4c: call_arg_len: the length of a vec-typed argument as a u32.
+  // Fails closed on a non-vec arg, an absent arg, or a non-u32 literal.
+  if (left.kind === 'call_arg_len') {
+    const actual = ctx.args[left.index]
+    if (!actual || actual.type !== 'vec') return { permit: false, reason: 'ARG_MISMATCH' }
+    if (right.kind !== 'literal_u32') return { permit: false, reason: 'ARG_MISMATCH' }
+    return actual.value.length === right.value
+      ? { permit: true }
+      : { permit: false, reason: 'ARG_MISMATCH' }
+  }
+
+  // --- step 4d: call_arg_field: the value of a field in the map at element i
+  // of the vec at argument index. Fails closed on a non-vec arg, an
+  // out-of-range element, a missing field, a non-map element, or a type
+  // mismatch between the field ScVal and the literal leaf.
+  if (left.kind === 'call_arg_field') {
+    const actual = ctx.args[left.index]
+    if (!actual || actual.type !== 'vec') return { permit: false, reason: 'ARG_MISMATCH' }
+    const element = actual.value[left.element]
+    if (!element || element.type !== 'map') return { permit: false, reason: 'ARG_MISMATCH' }
+    if (!Array.isArray(element.value)) return { permit: false, reason: 'ARG_MISMATCH' }
+    const entry = element.value.find((e) => e.key === left.field)
+    if (!entry) return { permit: false, reason: 'ARG_MISMATCH' }
+    if (op === 'eq') return evalArgEq(op, entry.val, right, ctx)
+    return evalArgOrderedCompare(op, entry.val, right)
+  }
+
   // --- step 6: AMOUNT_BOUND ---
   if (left.kind === 'amount' && op !== 'eq') {
     return evalAmountCompare(op, left.token, right, ctx)
@@ -383,6 +410,20 @@ function resolveLeaf(leaf: PredicateLeaf, ctx: EvalContext): ScVal | undefined {
       return { type: 'symbol', value: ctx.fn }
     case 'call_arg':
       return ctx.args[leaf.index]
+    case 'call_arg_len':
+      // No direct ScVal projection: the length is an integer the comparator
+      // resolves against the right-hand literal. Returning undefined keeps
+      // the `in` membership path structurally informed (no haystack match).
+      return undefined
+    case 'call_arg_field': {
+      const actual = ctx.args[leaf.index]
+      if (!actual || actual.type !== 'vec') return undefined
+      const element = actual.value[leaf.element]
+      if (!element || element.type !== 'map') return undefined
+      if (!Array.isArray(element.value)) return undefined
+      const entry = element.value.find((e) => e.key === leaf.field)
+      return entry ? entry.val : undefined
+    }
     case 'amount':
     case 'window_spent':
     case 'oracle_price':

package/src/types.ts

@@ -145,6 +145,16 @@ export type PredicateLeaf =
   | { kind: 'call_contract' }
   | { kind: 'call_fn' }
   | { kind: 'call_arg'; index: number }
+  // Length of a vec-typed argument as a u32. Binds the OUTER vec length so
+  // a caller cannot append a new element to defeat a per-element pin.
+  // Paired with `call_arg_field` per element - pinning only the field leaves
+  // an element-append vulnerability; this leaf closes it.
+  | { kind: 'call_arg_len'; index: number }
+  // Value of `field` in the map at `element` of the vec at argument `index`.
+  // Fixed-arity: index, element, field. The leaf is resolved against the
+  // recorded ScVal type. A non-vec arg, missing element, missing field, or
+  // type mismatch all DENY (fail-closed).
+  | { kind: 'call_arg_field'; index: number; element: number; field: string }
   // `call_sub_invocation[i]` is NOT in v1 grammar. OZ `Policy::enforce`
   // receives one `Context`, not a sub-invocation tree; sub-invocations live under
   // `InvokerContractAuthEntry::Contract(SubContractInvocation)`, not in the