@crediolabs/policy-synth 0.2.0 → 0.3.1

package/dist/synth/compose-from-recording.js

@@ -1,202 +1,105 @@
-// 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 { identifyProtocol } from "../registry/identify.js";
-/** Compose a PolicyIR pair from the lowered facts + the resolved scope.
+import { getAbi } from "../registry/protocols.js";
+/** Compose a rule from the lowered facts + the resolved scope.
  *  Pure (no randomness, no clock); same inputs -> byte-identical result. */
 export function composeFromRecording(facts, scopeContract, topLevel, opts) {
-    const interpreterEnabled = opts.interpreterEnabled === true;
     const ambiguities = [];
     const warnings = [];
-    const ozConstraints = [];
     const interpreterConstraints = [];
-    // 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) => {
-        if (interpreterEnabled)
-            interpreterConstraints.push(cond);
-        else
-            ozConstraints.push(cond);
-    };
     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`);
+                warnings.push(`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');
+            warnings.push('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);
+        appendProtocolSpecificConstraints(interpreterConstraints, warnings, ambiguities, facts, topLevel, protocol, opts.userResponses?.swapRecipientAllowlist, 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).
+    // The interpreter adapter lowers `scope.method` into a `call_fn == <method>`
+    // predicate leaf.
     const scope = { contract: scopeContract };
     if (topLevel?.fn)
         scope.method = topLevel.fn;
     const buildRule = (constraints) => {
         const rule = {
-            roles: [],
             scope: { ...scope },
             constraints,
         };
@@ -205,39 +108,47 @@ export function composeFromRecording(facts, scopeContract, topLevel, opts) {
         }
         return rule;
     };
-    const ir = {
-        chain: 'stellar',
-        defaultBehavior: 'deny_all',
-        rules: [buildRule(ozConstraints)],
-    };
-    const interpreterIr = {
-        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, topLevel) {
+    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]). */
-function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapter, warnings, ambiguities, facts, topLevel, protocol, swapRecipientAllowlist, swapInputAmountCap, swapMinOutRatio, interpreterEnabled) {
+/** Index of the argument the protocol ABI calls `amount`, or null when the ABI
+ *  does not name one. */
+function amountArgumentIndex(protocol) {
+    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, warnings, ambiguities, facts, topLevel, protocol, swapRecipientAllowlist, swapInputAmountCap) {
     // 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 }],
             });
         }
     }
@@ -252,10 +163,10 @@ function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapte
         // 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 }],
             });
         }
     }
@@ -269,17 +180,14 @@ function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapte
     // -> 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];
@@ -320,46 +228,19 @@ function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapte
                     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 },
                 });
             }
         }
@@ -373,17 +254,20 @@ function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapte
     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 })),
+                },
             });
         }
         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
         // argument as `call_arg[i] <= limit`. The index is function-specific -
@@ -393,43 +277,20 @@ function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapte
         // 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 (swapInputAmountCap !== undefined &&
             inputArgIndex !== undefined &&
             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 },
             });
         }
         // Swap recipient (call_arg[3]): when the caller supplies
@@ -440,23 +301,20 @@ function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapte
         // 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 })),
             });
         }
-        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',
@@ -465,26 +323,6 @@ function appendProtocolSpecificConstraints(interpreterConstraints, routeToAdapte
         }
     }
 }
-/** 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) {
-    switch (fn) {
-        case 'swap_exact_tokens_for_tokens':
-        case 'swap_exact_in_for_tokens':
-            return 1;
-        default:
-            return undefined;
-    }
-}
 function soroswapInputAmountArgIndex(fn) {
     switch (fn) {
         case 'swap_exact_tokens_for_tokens':

package/dist/synth/index.d.ts

@@ -1,10 +1,5 @@
 export { isStellarAddress } from './address.ts';
 export { type ComposeOptions, type ComposeResult, composeFromRecording, } from './compose-from-recording.ts';
-export { type DenyCase, type GeneratedCases, generateCases, } from './deny-cases.ts';
-export { type EvalContext, type EvalResult, evaluate } from './evaluate.ts';
-export { type HarnessFailure, type HarnessResult, runHarness, } from './harness.ts';
 export { type IntentFacts, lower } from './lower.ts';
-export { minimize } from './minimize.ts';
 export { type DecideScopeOptions, decideScope, type ScopeDecision, scopeToContextRuleType, } from './scope.ts';
-export { synthesizeFromMandate } from './synthesize-from-mandate.ts';
 export { type __TestInterpreterAdapterOptions, type SynthesizeFromRecordingOptions, synthesizeFromRecording, } from './synthesize-from-recording.ts';

package/dist/synth/index.js

@@ -4,11 +4,6 @@
 // and re-deriving it elsewhere means a second address check that can drift.
 export { isStellarAddress } from "./address.js";
 export { composeFromRecording, } from "./compose-from-recording.js";
-export { generateCases, } from "./deny-cases.js";
-export { evaluate } from "./evaluate.js";
-export { runHarness, } from "./harness.js";
 export { lower } from "./lower.js";
-export { minimize } from "./minimize.js";
 export { decideScope, scopeToContextRuleType, } from "./scope.js";
-export { synthesizeFromMandate } from "./synthesize-from-mandate.js";
 export { synthesizeFromRecording, } from "./synthesize-from-recording.js";