@crediolabs/policy-synth 0.2.0 → 0.3.0

package/src/synth/compose-from-recording.ts

@@ -1,85 +1,36 @@
-// src/synth/compose-from-recording.ts - facts + scope -> PolicyIR (OZ + interpreter).
+// src/synth/compose-from-recording.ts - facts + scope -> a composed rule.
 //
 // Fail-closed composition rules:
 //   - unknown top-level protocol (registry.identifyProtocol returns null) ->
-//     emit no OZ-primitive-producing IR node; scope is kept (CallContract + method)
-//     and every inferred bound surfaces as a descriptive warning. An unrecognised
-//     call never compiles to a permissive OZ primitive.
-//   - carry the recorded top-level function into `rule.scope.method` so the OZ
-//     adapter flags per-method scoping as not covered (CallContract permits every
-//     method; a per-method restriction needs the interpreter predicate).
-//   - `spending_limit` (window_spent(token, w) <= limit) is emitted ONLY when
-//     the caller supplies BOTH limit (userResponses.limitAmount) AND window
-//     (userResponses.windowSeconds). A single recorded spend does NOT authorise
-//     that amount every window, so the observed amount is NEVER used as an
-//     auto-ceiling: missing limit -> AMOUNT_BOUND_MISSING (observed amount
-//     offered as a suggestion); missing window -> DURATION_UNSPECIFIED. EVERY
+//     emit no constraint from the spend; scope is kept (contract + method) and
+//     every inferred bound surfaces as a descriptive warning. An unrecognised
+//     call never compiles to a permissive policy.
+//   - a spend cap is emitted ONLY when the caller supplies `limitAmount` AND
+//     the call carries an amount argument to bind it to. A single recorded
+//     spend does NOT authorise that amount on every call, so the observed
+//     amount is NEVER used as an auto-ceiling: without both,
+//     AMOUNT_BOUND_MISSING carries the observed amount as a suggestion. EVERY
 //     spent token is handled - none is silently dropped.
-//   - incoming-only flows emit an `invocation_count` bound ONLY when the caller
-//     supplies both the count and the window; otherwise FREQUENCY_BOUND_MISSING
-//     with no fabricated count.
-//   - the IR carries ONLY constraints justified by the recording + explicit
-//     user input. Nothing invented: no oracle price fabricated from a slippage
-//     bound, no synthetic exact-path compare. Those needs surface as warnings.
-//
-// Split rule (P3 wiring): `ComposeResult` carries BOTH `ir` (OZ-shape) and
-// `interpreterIr` (predicate-shape). Each constraint is routed to EXACTLY ONE
-// adapter:
-//   - `window_spent(token, w) <= limit` where `token === scope.contract` and
-//     protocol is known -> `ir` (OZ lowers to spending_limit).
-//   - everything else (recipient allowlists, per-method scope.method,
-//     invocation_count, eq_seq swap paths, oracle_price, AND window_spent
-//     where token != scope.contract i.e. SoroSwap input-token cap) ->
-//     `interpreterIr`.
-//
-// This prevents the interpreter adapter from emitting a duplicate
-// `window_spent` predicate leaf alongside an OZ `spending_limit` primitive
-// covering the same spend semantic - the two adapters never overlap.
+//   - the IR carries ONLY constraints justified by the recording plus an
+//     explicit bound, no synthetic exact-path compare. Other needs surface as
+//     warnings.
 //
 // Default policy is `deny_all` (OZ context rules are deny-by-default).
 
-import type { IRCompOp, IRCondition, IRPolicyRule, PolicyIR } from '../ir/types.ts'
 import { type IdentifiedProtocol, identifyProtocol } from '../registry/identify.ts'
-import type { AmbiguityPrompt, ContractInvocation, Network } from '../types.ts'
+import { getAbi } from '../registry/protocols.ts'
+import type { AmbiguityPrompt, ContractInvocation, Network, PredicateNode } from '../types.ts'
 import type { IntentFacts } from './lower.ts'
 
-/** Per-asset oracle-price bound supplied by the caller (e.g. swap allowed only
- *  if oracle_price(XLM) < 5.00 USDC). One entry per asset; the recorder never
- *  fabricates a price bound from a slippage value (different units). */
-export interface OraclePriceBound {
-  asset: string
-  operator: IRCompOp
-  value: string
-  /** Decimal basis `value` is written on. REQUIRED: oracle prices normalise to
-   *  9 dp, and a threshold silently assumed to share that basis is what let a
-   *  raw 14-dp bound permit everything. The author states it; we convert. */
-  decimals: number
-}
-
 /** Caller-supplied answers to the ambiguity prompts. Every numeric bound the
  *  synth might apply must come from here - the recording supplies observed
  *  amounts (offered only as suggestions), never authorised ceilings. */
 export interface ComposeUserResponses {
-  /** Rolling window (seconds) for a spending_limit / invocation_count. */
-  windowSeconds?: number
   /** OZ context-rule expiry (ledger sequence). */
   validUntilLedger?: number
-  /** Per-window spend ceiling (i128 decimal string). Required to emit a
-   *  spending_limit; absent -> AMOUNT_BOUND_MISSING. */
+  /** Per-call ceiling on the amount the call carries (i128 decimal string).
+   *  Required to bound the amount argument; absent -> AMOUNT_BOUND_MISSING. */
   limitAmount?: string
-  /** Max invocations per window for an incoming-only flow. Required to emit an
-   *  invocation_count bound; absent -> FREQUENCY_BOUND_MISSING. */
-  invocationLimit?: number
-  /** Per-asset oracle-price bound(s). Each entry lowers to a single
-   *  `oracle_price(asset) OP value` compare in the interpreter IR. */
-  oraclePriceBound?: OraclePriceBound[]
-  /** Minimum acceptable swap output per unit of input, as `num/den` (e.g.
-   *  `{num:'95',den:'100'}` = accept losing at most 5%). REQUIRED to be
-   *  supplied by the caller: never derived from the recording (the recorded
-   *  in/out pair is a price at one moment, and freezing it as policy would
-   *  deny ordinary trades as soon as the rate moves). Absent, no floor is
-   *  emitted and the existing unbounded-output warning stands. */
-  swapMinOutRatio?: { num: string; den: string }
   /** Recipient allowlist for a swap (call_arg[3] on SoroSwap's
    *  swap_exact_tokens_for_tokens). When supplied, REPLACES the default pin.
    *  Absent -> recipient is pinned to the recorded value (mirroring SEP-41)
@@ -92,31 +43,31 @@ export interface ComposeUserResponses {
 export interface ComposeOptions {
   network: Network
   userResponses?: ComposeUserResponses
-  /** When true, constraints the OZ adapter cannot lower are routed to
-   *  `interpreterIr` (the predicate-shape IR) so the orchestrator can compile
-   *  them via the interpreter adapter. When false (the default for callers
-   *  who have not opted in), every constraint goes to `ir` and the OZ
-   *  adapter's `uncovered` machinery generates the descriptive warnings -
-   *  today's behaviour. The orchestrator passes this flag through based on
-   *  whether `opts.interpreter` was supplied. */
-  interpreterEnabled?: boolean
 }
 
-/** Result of composition: the OZ-shape PolicyIR, the predicate-shape PolicyIR
- *  (contains the constraints the OZ adapter cannot lower; empty when
- *  `interpreterEnabled` is false), any ambiguities surfaced during inference,
- *  and descriptive warnings for needs that are NOT expressed as an IR node
- *  (so no fabricated constraint is emitted). The orchestrator carries
- *  ambiguities into `ProposedPolicy.ambiguities` and merges warnings into
+/** One composed rule: what the call must be scoped to, the constraints on it,
+ *  and how long the resulting context rule lives. The constraints are already
+ *  predicate nodes - there is one enforcement backend, so there is nothing to
+ *  translate between. */
+export interface ComposedRule {
+  scope: { contract?: string; method?: string }
+  constraints: PredicateNode[]
+  expiry?: { validUntilLedger?: number }
+}
+
+/** Result of composition: the composed rule the interpreter compiler
+ *  compiles, the ambiguities the caller must answer, and descriptive warnings
+ *  for needs that are NOT expressed as an IR node (so no fabricated constraint
+ *  is emitted). The orchestrator carries ambiguities into
+ *  `ProposedPolicy.ambiguities` and merges warnings into
  *  `ProposedPolicy.warnings`. */
 export interface ComposeResult {
-  ir: PolicyIR
-  interpreterIr: PolicyIR
+  interpreterRule: ComposedRule
   ambiguities: AmbiguityPrompt[]
   warnings: string[]
 }
 
-/** Compose a PolicyIR pair from the lowered facts + the resolved scope.
+/** Compose a rule from the lowered facts + the resolved scope.
  *  Pure (no randomness, no clock); same inputs -> byte-identical result. */
 export function composeFromRecording(
   facts: IntentFacts,
@@ -124,185 +75,106 @@ export function composeFromRecording(
   topLevel: ContractInvocation | null,
   opts: ComposeOptions
 ): ComposeResult {
-  const interpreterEnabled = opts.interpreterEnabled === true
   const ambiguities: AmbiguityPrompt[] = []
   const warnings: string[] = []
-  const ozConstraints: IRCondition[] = []
-  const interpreterConstraints: IRCondition[] = []
-  // Route to the matching IR. When the interpreter is enabled, constraints the
-  // OZ adapter cannot lower go there; otherwise they go to OZ (which flags them
-  // as uncovered) so today's warning-driven behaviour is preserved.
-  const routeToAdapter = (cond: IRCondition): void => {
-    if (interpreterEnabled) interpreterConstraints.push(cond)
-    else ozConstraints.push(cond)
-  }
+  const interpreterConstraints: PredicateNode[] = []
 
   const protocol = topLevel
     ? identifyProtocol(topLevel.contract, topLevel.fn, topLevel.args, opts.network)
     : null
   const known = protocol !== null
 
-  const windowSeconds = opts.userResponses?.windowSeconds
   const limitAmount = opts.userResponses?.limitAmount
   const spendTokens = Object.keys(facts.spendByToken)
 
-  // Outgoing spend -> one spending_limit per spent token. A single caller
-  // limit binds only an unambiguous single-token spend; a multi-token flow
-  // needs a per-token limit, so each unmatched token surfaces
-  // AMOUNT_BOUND_MISSING.
-  //
-  // Routing: a `window_spent(token, w) <= limit` constraint goes to the OZ IR
-  // only when token === scope.contract (OZ's spending_limit binds the
-  // CallContract target, not a token parameter). Otherwise it goes to the
-  // interpreter IR.
+  // Outgoing spend -> a cap on the call's own amount ARGUMENT. The interpreter
+  // is passed one authorised call, not the transaction's token movements, so a
+  // rolling per-window total is not something it can read; the enforceable
+  // shape is a bound on the amount the call itself carries. A multi-token flow
+  // has no single argument to bind, so each token surfaces AMOUNT_BOUND_MISSING.
   if (spendTokens.length > 0 && topLevel) {
-    let durationFlagged = false
     for (const token of spendTokens) {
       const observed = facts.spendByToken[token]
       if (observed === undefined) continue
 
       if (!known) {
         warnings.push(
-          `spend of ${observed} (token ${token}) not bounded: unrecognised protocol, spend cap needs the interpreter predicate`
+          `spend of ${observed} (token ${token}) not bounded: unrecognised protocol, so the amount argument cannot be located`
         )
         continue
       }
 
       const limit = spendTokens.length === 1 ? limitAmount : undefined
-      if (windowSeconds === undefined && !durationFlagged) {
-        ambiguities.push({
-          code: 'DURATION_UNSPECIFIED',
-          question: `Recording shows a ${observed}-${token} spend. What rolling window (seconds) should the spending_limit use?`,
-        })
-        durationFlagged = true
-      }
-      if (limit === undefined) {
+      const amountArgIndex = limitArgumentIndex(protocol, topLevel)
+      if (limit === undefined || amountArgIndex === null) {
         ambiguities.push({
           code: 'AMOUNT_BOUND_MISSING',
-          question: `Recording shows a ${observed}-${token} spend, but a single spend does not authorise that amount every window. What per-window spending_limit should apply? (observed amount, suggestion only: ${observed})`,
+          question: `Recording shows a ${observed}-${token} spend, but a single spend does not authorise that amount on every call. What per-call cap should apply? (observed amount, suggestion only: ${observed})`,
         })
         continue
       }
-      if (windowSeconds !== undefined) {
-        // Rolling spend cap always goes to OZ (`spending_limit` is the audited
-        // implementation). The interpreter is NOT a fallback for token !=
-        // scopeContract: on chain it sees one authorized call, not the
-        // transaction's token movements, so it has no per-call amount to
-        // accumulate and the counter would never move. OZ reports the case it
-        // cannot cover (limit pins to the context contract) - the honest
-        // outcome; the old fallback produced an interpreter predicate that
-        // silently never bound.
-        ozConstraints.push({
-          op: 'compare',
-          compare: {
-            selector: { kind: 'window_spent', token, windowSeconds },
-            operator: 'lte',
-            value: limit,
-          },
-        })
-        if (interpreterEnabled && token !== scopeContract) {
-          warnings.push(
-            `rolling spend cap on ${token} cannot be enforced on chain: OZ spending_limit pins the limit to the context contract, and the interpreter cannot observe token movements. Bound the per-call value with an argument cap plus an invocation-count limit instead.`
-          )
-        }
-      }
+      interpreterConstraints.push({
+        op: 'lte',
+        left: { kind: 'call_arg', index: amountArgIndex },
+        right: { kind: 'literal_i128', value: limit },
+      })
     }
   }
 
-  // Incoming-only / frequency intent: an invocation_count bound is emitted ONLY
-  // when the caller supplies the count AND a window - never a fabricated `<= 1`.
-  // Routed to the interpreter IR when interpreter is enabled (OZ cannot lower
-  // invocation_count); otherwise to the OZ IR (which flags it as uncovered).
+  // Incoming-only / frequency intent: the interpreter is passed one authorised
+  // call, so it cannot count prior calls - no frequency bound is emitted and
+  // never a fabricated `<= 1`. The need surfaces as a prompt plus a warning.
   //
   // A recognised swap is NOT an incoming-only flow: it has an outgoing input
   // leg whose spend simply was not attributed to the source account
   // (fee-sponsored / holder != source). Its real restrictions - exact path,
   // recipient, input-amount cap - come from the protocol-specific pass, so it
-  // does NOT get the incoming-only frequency prompt. A caller wanting to
-  // rate-limit the swap can still supply an invocationLimit + window, which
-  // lowers to an invocation_count for any flow.
+  // does NOT get the incoming-only frequency prompt.
   if (spendTokens.length === 0 && topLevel) {
-    const invocationLimit = opts.userResponses?.invocationLimit
     const isRecognisedSwap = protocol?.protocol === 'soroswap'
-    if (known && windowSeconds !== undefined && invocationLimit !== undefined) {
-      routeToAdapter({
-        op: 'compare',
-        compare: {
-          selector: { kind: 'invocation_count', windowSeconds },
-          // `lt`, not `lte`: the leaf reports the calls ALREADY made in the
-          // window, so `< N` is what permits N of them. With `lte` a limit
-          // of N let an N+1th call through.
-          operator: 'lt',
-          value: String(invocationLimit),
-        },
-      })
-    } else if (!isRecognisedSwap) {
+    if (!isRecognisedSwap) {
       ambiguities.push({
         code: 'FREQUENCY_BOUND_MISSING',
-        question: 'Incoming-only flow - what max invocations per window should the policy enforce?',
+        question:
+          'Incoming-only flow - the policy does not bound how often this call may be made. Bound it outside the policy, or scope the rule more tightly.',
       })
       warnings.push(
-        'frequency bound needed for the incoming-only flow (needs the interpreter predicate); no invocation cap inferred'
+        'incoming-only flow: call frequency is NOT bounded - the interpreter reads only the authorized call, so it cannot count prior calls'
       )
     }
   }
 
-  // Per-asset oracle-price bound(s) supplied by the caller -> one
-  // oracle_price compare per entry. Routed to the interpreter IR when enabled;
-  // otherwise to the OZ IR (which flags it as uncovered).
-  const oracleBounds = opts.userResponses?.oraclePriceBound
-  if (oracleBounds) {
-    for (const b of oracleBounds) {
-      routeToAdapter({
-        op: 'compare',
-        compare: {
-          selector: { kind: 'oracle_price', asset: b.asset },
-          operator: b.operator,
-          value: b.value,
-          valueDecimals: b.decimals,
-        },
-      })
-    }
-  }
-
-  // Observed recipient allowlist (SEP-41) is a real, recorded constraint the OZ
-  // adapter flags as not covered; the interpreter adapter lowers it to an `in`
-  // predicate. Unknown protocols emit nothing here. SoroSwap's swap recipient
-  // (arg[3]) is the source-of-truth for the swapRecipientAllowlist surface.
+  // Observed recipient allowlist (SEP-41) is a real, recorded constraint the
+  // interpreter adapter lowers to an `in` predicate. Unknown protocols emit
+  // nothing here. SoroSwap's swap recipient (arg[3]) is the source-of-truth for
+  // the swapRecipientAllowlist surface.
   if (topLevel && protocol !== null) {
-    // A SoroSwap input-amount cap binds the caller's limitAmount to call_arg[0]
-    // (the exact amount_in) ONLY when no cumulative outgoing spend was detected
-    // for the source account - i.e. the input token never moved FROM the source
+    // A SoroSwap input-amount cap binds the caller's limitAmount to the swap's
+    // input-amount argument ONLY when no outgoing spend was detected for the
+    // source account - i.e. the input token never moved FROM the source
     // (fee-sponsored swaps, or a holder != source). When a spend WAS detected,
-    // the window_spent path above already consumed the limit, so the per-call
-    // arg cap is skipped to avoid binding one limit to two different semantics.
+    // the cap above already consumed the limit, so this one is skipped to avoid
+    // binding one limit to two different args.
     const swapInputAmountCap = spendTokens.length === 0 ? limitAmount : undefined
     appendProtocolSpecificConstraints(
       interpreterConstraints,
-      routeToAdapter,
       warnings,
       ambiguities,
       facts,
       topLevel,
       protocol,
       opts.userResponses?.swapRecipientAllowlist,
-      swapInputAmountCap,
-      opts.userResponses?.swapMinOutRatio,
-      interpreterEnabled
+      swapInputAmountCap
     )
   }
 
-  // `scope.method` is carried on BOTH IRs so each adapter produces a
-  // self-consistent rule. The interpreter adapter lowers scope.method into a
-  // `call_fn == <method>` predicate leaf (a real restriction); the OZ adapter
-  // flags it as uncovered (CallContract alone permits any method on the
-  // contract).
-  const scope: IRPolicyRule['scope'] = { contract: scopeContract }
+  // The interpreter adapter lowers `scope.method` into a `call_fn == <method>`
+  // predicate leaf.
+  const scope: ComposedRule['scope'] = { contract: scopeContract }
   if (topLevel?.fn) scope.method = topLevel.fn
 
-  const buildRule = (constraints: IRCondition[]): IRPolicyRule => {
-    const rule: IRPolicyRule = {
-      roles: [],
+  const buildRule = (constraints: PredicateNode[]): ComposedRule => {
+    const rule: ComposedRule = {
       scope: { ...scope },
       constraints,
     }
@@ -312,52 +184,58 @@ export function composeFromRecording(
     return rule
   }
 
-  const ir: PolicyIR = {
-    chain: 'stellar',
-    defaultBehavior: 'deny_all',
-    rules: [buildRule(ozConstraints)],
-  }
-  const interpreterIr: PolicyIR = {
-    chain: 'stellar',
-    defaultBehavior: 'deny_all',
-    rules: [buildRule(interpreterConstraints)],
-  }
-  return { ir, interpreterIr, ambiguities, warnings }
+  return { interpreterRule: buildRule(interpreterConstraints), ambiguities, warnings }
+}
+
+/** Index of the argument a caller-supplied `limitAmount` binds to, or null when
+ *  the call carries no such argument. The interpreter is passed one authorised
+ *  call, not the transaction's token movements, so bounding an argument the
+ *  call itself carries is the only enforceable shape. */
+function limitArgumentIndex(
+  protocol: IdentifiedProtocol | null,
+  topLevel: ContractInvocation | null
+): number | null {
+  if (!protocol || !topLevel) return null
+  const named = amountArgumentIndex(protocol)
+  if (named !== null) return named
+  // SoroSwap names its input argument `amount_in` / `amount_in_max`, so the
+  // lookup by name misses it and the index is function-specific.
+  if (protocol.protocol !== 'soroswap') return null
+  const i = soroswapInputAmountArgIndex(protocol.fn)
+  // Defense in depth: identification's argsMatchAbi already pins it to i128.
+  return i !== undefined && topLevel.args[i]?.type === 'i128' ? i : null
 }
 
-/** Add the constraints justified by the recording that the OZ backend cannot
- *  express natively. Each constraint is routed to either `ozConstraints` (the
- *  OZ adapter lowers it) or `interpreterConstraints` (the interpreter adapter
- *  lowers it). When `interpreterEnabled` is false, every protocol-specific
- *  constraint is routed to `ozConstraints` (which flags it as uncovered) so
- *  callers who haven't opted in keep today's warning-driven behaviour.
- *  SoroSwap's slippage / oracle / exact-path needs come from `userResponses`
- *  (oraclePriceBound + limitAmount) + the recorded path (eq_seq on
- *  call_arg[2]). */
+/** Index of the argument the protocol ABI calls `amount`, or null when the ABI
+ *  does not name one. */
+function amountArgumentIndex(protocol: IdentifiedProtocol): number | null {
+  const abi = getAbi(protocol.protocol)[protocol.fn]
+  if (!abi) return null
+  const i = abi.args.findIndex((a) => a.name === 'amount')
+  return i >= 0 ? i : null
+}
+
+/** Add the protocol-specific constraints the recording justifies: recipient
+ *  allowlists, exact swap paths and per-call argument caps. */
 function appendProtocolSpecificConstraints(
-  interpreterConstraints: IRCondition[],
-  routeToAdapter: (cond: IRCondition) => void,
+  interpreterConstraints: PredicateNode[],
   warnings: string[],
   ambiguities: AmbiguityPrompt[],
   facts: IntentFacts,
   topLevel: ContractInvocation,
   protocol: IdentifiedProtocol,
   swapRecipientAllowlist: string[] | undefined,
-  swapInputAmountCap: string | undefined,
-  swapMinOutRatio: { num: string; den: string } | undefined,
-  interpreterEnabled: boolean
+  swapInputAmountCap: string | undefined
 ): void {
   // SEP-41 transfer / mint: the `to` arg (index 1) is the recipient. Emit a
   // single-element allowlist; the interpreter adapter lowers it to `in`.
-  // When interpreter is not enabled, route to OZ so the caller sees today's
-  // `value allowlist on arg 1` warning.
   if (protocol.protocol === 'sep41' && (protocol.fn === 'transfer' || protocol.fn === 'mint')) {
     const toArg = topLevel.args[1]
     if (toArg && toArg.type === 'address') {
-      routeToAdapter({
+      interpreterConstraints.push({
         op: 'in',
-        selector: { kind: 'arg', argIndex: 1, scalarType: 'address' },
-        values: [toArg.value],
+        needle: { kind: 'call_arg', index: 1 },
+        haystack: [{ kind: 'literal_address', value: toArg.value }],
       })
     }
   }
@@ -373,10 +251,10 @@ function appendProtocolSpecificConstraints(
     // claim(from, reserve_token_ids, to).
     const toArg = topLevel.args[2]
     if (toArg && toArg.type === 'address') {
-      routeToAdapter({
+      interpreterConstraints.push({
         op: 'in',
-        selector: { kind: 'arg', argIndex: 2, scalarType: 'address' },
-        values: [toArg.value],
+        needle: { kind: 'call_arg', index: 2 },
+        haystack: [{ kind: 'literal_address', value: toArg.value }],
       })
     }
   }
@@ -391,17 +269,14 @@ function appendProtocolSpecificConstraints(
   // -> Borrow on a different asset, any amount, then auction fills). Length
   // + per-element pinning is total; a quantifier over elements is not. If we
   // cannot emit BOTH, we surface AMBIGUITY rather than emit a partial bind.
-  if (protocol.protocol === 'blend' && protocol.fn === 'submit' && interpreterEnabled) {
+  if (protocol.protocol === 'blend' && protocol.fn === 'submit') {
     const requestsArg = topLevel.args[3]
     if (requestsArg && requestsArg.type === 'vec') {
       const elements = requestsArg.value
       interpreterConstraints.push({
-        op: 'compare',
-        compare: {
-          selector: { kind: 'arg_len', argIndex: 3 },
-          operator: 'eq',
-          value: String(elements.length),
-        },
+        op: 'eq',
+        left: { kind: 'call_arg_len', index: 3 },
+        right: { kind: 'literal_u32', value: elements.length },
       })
       for (let i = 0; i < elements.length; i++) {
         const element = elements[i]
@@ -445,46 +320,19 @@ function appendProtocolSpecificConstraints(
           continue
         }
         interpreterConstraints.push({
-          op: 'compare',
-          compare: {
-            selector: {
-              kind: 'arg_field',
-              argIndex: 3,
-              element: i,
-              field: 'request_type',
-              scalarType: 'u32',
-            },
-            operator: 'eq',
-            value: requestType,
-          },
+          op: 'eq',
+          left: { kind: 'call_arg_field', index: 3, element: i, field: 'request_type' },
+          right: { kind: 'literal_u32', value: Number.parseInt(requestType, 10) },
         })
         interpreterConstraints.push({
-          op: 'compare',
-          compare: {
-            selector: {
-              kind: 'arg_field',
-              argIndex: 3,
-              element: i,
-              field: 'address',
-              scalarType: 'address',
-            },
-            operator: 'eq',
-            value: address,
-          },
+          op: 'eq',
+          left: { kind: 'call_arg_field', index: 3, element: i, field: 'address' },
+          right: { kind: 'literal_address', value: address },
         })
         interpreterConstraints.push({
-          op: 'compare',
-          compare: {
-            selector: {
-              kind: 'arg_field',
-              argIndex: 3,
-              element: i,
-              field: 'amount',
-              scalarType: 'i128',
-            },
-            operator: 'lte',
-            value: amount,
-          },
+          op: 'lte',
+          left: { kind: 'call_arg_field', index: 3, element: i, field: 'amount' },
+          right: { kind: 'literal_i128', value: amount },
         })
       }
     }
@@ -499,18 +347,19 @@ function appendProtocolSpecificConstraints(
   if (protocol.protocol === 'soroswap') {
     const paths = facts.allowedPaths?.[topLevel.contract]
     const route = paths?.length === 1 ? paths[0] : undefined
-    if (route && route.length > 0 && interpreterEnabled) {
+    if (route && route.length > 0) {
       const pathArgIndex = 2 // SoroSwap swap_exact_tokens_for_tokens: args = [amount_in, amount_out_min, path, to, deadline]
       interpreterConstraints.push({
-        op: 'eq_seq',
-        selector: { kind: 'arg', argIndex: pathArgIndex, scalarType: 'address' },
-        values: route,
+        op: 'eq',
+        left: { kind: 'call_arg', index: pathArgIndex },
+        right: {
+          kind: 'literal_vec',
+          elements: route.map((v) => ({ kind: 'literal_address', value: v }) as const),
+        },
       })
     } else {
       const pathText = route && route.length > 0 ? `; observed path: ${route.join(' -> ')}` : ''
-      warnings.push(
-        `SoroSwap swap: slippage / oracle price bound and exact hop path need the interpreter predicate${pathText}`
-      )
+      warnings.push(`SoroSwap swap: the exact hop path needs the interpreter predicate${pathText}`)
     }
 
     // Input-amount cap: bind the caller's limitAmount to the swap's input-amount
@@ -521,12 +370,10 @@ function appendProtocolSpecificConstraints(
     // as arg[1] (its arg[0] is the exact OUTPUT, so binding arg[0] there would
     // cap the wrong value and leave the input unbounded). This is a per-call cap
     // that does NOT depend on attributing a token movement to the source account
-    // (the fee-sponsored / holder != source case, where the window_spent path
-    // detects no spend). Fail-closed: it only ever restricts the permitted input.
-    // Routed to the interpreter predicate (OZ built-ins cannot express a per-arg
-    // i128 bound); when the interpreter is not enabled it goes to OZ, which flags
-    // it uncovered (a warning). The `type === 'i128'` check is defense in depth -
-    // protocol identification's argsMatchAbi already pins the input arg to i128.
+    // (the fee-sponsored / holder != source case, where no spend is detected).
+    // Fail-closed: it only ever restricts the permitted input. The
+    // `type === 'i128'` check is defense in depth - protocol identification's
+    // argsMatchAbi already pins the input arg to i128.
     const inputArgIndex = soroswapInputAmountArgIndex(protocol.fn)
     const inputAmountArg = inputArgIndex !== undefined ? topLevel.args[inputArgIndex] : undefined
     if (
@@ -535,34 +382,10 @@ function appendProtocolSpecificConstraints(
       inputAmountArg &&
       inputAmountArg.type === 'i128'
     ) {
-      routeToAdapter({
-        op: 'compare',
-        compare: {
-          selector: { kind: 'arg', argIndex: inputArgIndex, scalarType: 'i128' },
-          operator: 'lte',
-          value: swapInputAmountCap,
-        },
-      })
-    }
-
-    // Slippage floor: `out >= in * num/den`. Only when the caller supplied the
-    // ratio - see `swapMinOutRatio`. Without it the output arg stays free,
-    // which is the case the unbounded-swap warning above describes.
-    const outMinArgIndex = soroswapMinOutArgIndex(protocol.fn)
-    const minOutRatio = swapMinOutRatio
-    if (
-      minOutRatio !== undefined &&
-      inputArgIndex !== undefined &&
-      outMinArgIndex !== undefined &&
-      inputAmountArg &&
-      inputAmountArg.type === 'i128'
-    ) {
-      routeToAdapter({
-        op: 'slippage_floor',
-        outArgIndex: outMinArgIndex,
-        inArgIndex: inputArgIndex,
-        num: minOutRatio.num,
-        den: minOutRatio.den,
+      interpreterConstraints.push({
+        op: 'lte',
+        left: { kind: 'call_arg', index: inputArgIndex },
+        right: { kind: 'literal_i128', value: swapInputAmountCap },
       })
     }
 
@@ -574,22 +397,21 @@ function appendProtocolSpecificConstraints(
     // it unconstrained would permit an arbitrary recipient (an evil twin with
     // call_arg[3] = attacker_wallet). RECIPIENT_ALLOWLIST_EMPTY is still
     // surfaced, but as INFORMATIONAL (the recipient was pinned; here is how to
-    // widen it), never as a silent free pass. The recipient is only enforceable
-    // via the interpreter predicate, so the pin (and the ambiguity) apply only
-    // when the interpreter is enabled - otherwise the swap recipient is ignored
-    // (today's behaviour, matching the other SoroSwap constraints).
+    // widen it), never as a silent free pass.
     const recipientArg = topLevel.args[3]
     if (swapRecipientAllowlist && swapRecipientAllowlist.length > 0) {
-      routeToAdapter({
+      interpreterConstraints.push({
         op: 'in',
-        selector: { kind: 'arg', argIndex: 3, scalarType: 'address' },
-        values: [...swapRecipientAllowlist],
+        needle: { kind: 'call_arg', index: 3 },
+        haystack: swapRecipientAllowlist.map(
+          (v) => ({ kind: 'literal_address', value: v }) as const
+        ),
       })
-    } else if (interpreterEnabled && recipientArg && recipientArg.type === 'address') {
+    } else if (recipientArg && recipientArg.type === 'address') {
       interpreterConstraints.push({
         op: 'in',
-        selector: { kind: 'arg', argIndex: 3, scalarType: 'address' },
-        values: [recipientArg.value],
+        needle: { kind: 'call_arg', index: 3 },
+        haystack: [{ kind: 'literal_address', value: recipientArg.value }],
       })
       ambiguities.push({
         code: 'RECIPIENT_ALLOWLIST_EMPTY',
@@ -599,27 +421,6 @@ function appendProtocolSpecificConstraints(
   }
 }
 
-/** Positional index of the input-amount argument for a recognized SoroSwap swap
- *  function. `swap_exact_tokens_for_tokens` and `swap_exact_in_for_tokens` take
- *  the exact input as arg[0]; `swap_tokens_for_exact_tokens` takes the maximum
- *  input (`amount_in_max`) as arg[1] - its arg[0] is the exact OUTPUT. Any other
- *  function has no positional input-amount argument -> undefined (no cap bound). */
-/** The argument carrying the swap's MINIMUM ACCEPTABLE OUTPUT.
- *
- *  Only the exact-input entrypoints have one: `swap_tokens_for_exact_tokens`
- *  fixes the output and varies the input, so its output needs no floor (its
- *  arg[1] is `amount_in_max`, already bounded by the input cap). Returning
- *  undefined there keeps a floor from being pinned to the wrong argument. */
-function soroswapMinOutArgIndex(fn: string): number | undefined {
-  switch (fn) {
-    case 'swap_exact_tokens_for_tokens':
-    case 'swap_exact_in_for_tokens':
-      return 1
-    default:
-      return undefined
-  }
-}
-
 function soroswapInputAmountArgIndex(fn: string): number | undefined {
   switch (fn) {
     case 'swap_exact_tokens_for_tokens':