@crediolabs/policy-synth 0.1.8 → 0.1.9

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