@crediolabs/policy-synth 0.4.0 → 0.5.0

package/dist-cjs/run/index.js

@@ -34,6 +34,7 @@ const index_ts_1 = require("../index.js");
 const authority_overlap_ts_1 = require("../install/authority-overlap.js");
 const build_install_policy_ts_1 = require("../install/build-install-policy.js");
 const get_interpreter_info_ts_1 = require("../install/get-interpreter-info.js");
+const read_account_rules_ts_1 = require("../install/read-account-rules.js");
 const decode_ts_1 = require("../predicate/decode.js");
 const index_ts_2 = require("../simulate/index.js");
 const schemas_ts_1 = require("./schemas.js");
@@ -184,11 +185,18 @@ async function runInstallPolicy(raw) {
             rpc: rpcClient,
             ...(input.baseFee !== undefined ? { baseFee: input.baseFee } : {}),
         });
-        // Cross-rule scan, when the caller supplied what else is on the account.
-        // ABSENT is reported as `null` rather than an empty list: "we did not
-        // look" and "we looked and found nothing" are different answers, and
-        // collapsing them would let a caller read silence as safety.
-        const authorityScan = input.existingRules === undefined
+        // Cross-rule scan. The caller may supply `existingRules` (useful offline,
+        // and for testing); otherwise the account is READ, so the answer describes
+        // what is actually installed rather than what the caller happened to
+        // mention.
+        //
+        // `null` means NOT CHECKED and is returned whenever the scan cannot be
+        // trusted to be complete - the read failed, or it stopped before
+        // accounting for every live rule. An empty list would say "checked,
+        // nothing found", and a partial scan that reported `[]` would be claiming
+        // a safety it never established.
+        const observed = await resolveExistingRules(input, network, expectedInterpreter);
+        const authorityScan = observed === null
             ? null
             : (0, authority_overlap_ts_1.findAuthorityOverlaps)({
                 intended: {
@@ -200,9 +208,7 @@ async function runInstallPolicy(raw) {
                     signers: input.rule.signers,
                     predicate: (0, decode_ts_1.decodePredicate)(encodedPredicate),
                 },
-                // The schema types `predicate` loosely (it is the shared
-                // PredicateNodeSchema); the shape is already validated.
-                existing: input.existingRules,
+                existing: observed,
             });
         return { ok: true, data: { ...result, authorityScan } };
     }
@@ -353,6 +359,7 @@ function runDeclarePolicy(raw) {
             ...(d.recipients !== undefined ? { recipients: d.recipients } : {}),
             ...(d.recipientArgIndex !== undefined ? { recipientArgIndex: d.recipientArgIndex } : {}),
             ...(d.allowZeroCap !== undefined ? { allowZeroCap: d.allowZeroCap } : {}),
+            ...(d.minOutputRatio !== undefined ? { minOutputRatio: d.minOutputRatio } : {}),
         });
         const { encodedPredicate, predicateHash } = (0, index_ts_1.encodePredicate)(predicate);
         return { ok: true, data: { predicate, encodedPredicate, predicateHash, warnings } };
@@ -448,6 +455,42 @@ async function runGetInterpreterInfo(raw) {
  *  network, falling back to the pinned RPC for the network. The caller
  *  has already been gated against the pinned URL elsewhere, so the
  *  fallback here only ever picks from a finite, audited pair. */
+/** The account's other context rules, or `null` when they could not be
+ *  established completely.
+ *
+ *  Caller-supplied `existingRules` win: they let the scan run offline, and a
+ *  caller who passes them has said what to compare against. Otherwise the
+ *  account is read over RPC.
+ *
+ *  Every failure path returns `null` rather than a short list. A read that
+ *  threw, or one that stopped before accounting for every live rule, has not
+ *  ruled anything out - and reporting `[]` there would turn "we could not
+ *  check" into "there is nothing to worry about". */
+async function resolveExistingRules(input, network, interpreterAddress) {
+    if (input.existingRules !== undefined) {
+        // The schema types `predicate` loosely (it is the shared
+        // PredicateNodeSchema); the shape is already validated.
+        return input.existingRules;
+    }
+    try {
+        const url = input.rpcUrl ?? schemas_ts_1.RPC_URL_BY_NETWORK[network];
+        const server = new stellar_sdk_1.rpc.Server(url, { allowHttp: false });
+        const collected = await (0, read_account_rules_ts_1.collectObservedRules)({
+            reader: (0, read_account_rules_ts_1.accountRuleReaderFromServer)(server, schemas_ts_1.NETWORK_PASSPHRASES[network]),
+            smartAccount: input.smartAccount,
+            interpreterAddress,
+        });
+        if (collected.incomplete)
+            return null;
+        return collected.rules;
+    }
+    catch {
+        // The install itself is unaffected: the scan is advisory, so a failed
+        // read must not block a policy the user asked for. It just cannot be
+        // reported as a clean scan.
+        return null;
+    }
+}
 function buildRpcClientFromInput(urlOverride, network) {
     const url = urlOverride ?? schemas_ts_1.RPC_URL_BY_NETWORK[network];
     const passphrase = schemas_ts_1.NETWORK_PASSPHRASES[network];

package/dist-cjs/run/schemas.d.ts

@@ -1559,6 +1559,7 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         keyBytes: string;
     })[];
     id: number;
+    policyAddresses: string[];
     contextType: {
         kind: "default";
     } | {
@@ -1568,7 +1569,6 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         kind: "create_contract";
         wasmHash: string;
     };
-    policyAddresses: string[];
     predicate?: unknown;
 }, {
     signers: ({
@@ -1580,6 +1580,7 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         keyBytes: string;
     })[];
     id: number;
+    policyAddresses: string[];
     contextType: {
         kind: "default";
     } | {
@@ -1589,28 +1590,27 @@ export declare const ObservedRuleSchema: z.ZodObject<{
         kind: "create_contract";
         wasmHash: string;
     };
-    policyAddresses: string[];
     predicate?: unknown;
 }>;
 /** Pinned interpreter address (testnet).
  *  Single source for the MCP layer; do not embed elsewhere. */
-export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CCL336TCK2Y5OFNRCMN2M3HVPBCEX4PW5H6EQ5VW5NPMXOCP4ESB5XR4";
-/** Pinned interpreter address (mainnet), redeployed 2026-08-22 from a reproducible build. The mainnet
+export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CCBHVZ6HGGV7C4SNHCZ3S5665Z2WEMHTMBAEPO4XW6PKON464BEBANU5";
+/** Pinned interpreter address (mainnet), redeployed 2026-08-22 for grammar 4, from a reproducible build. The mainnet
  *  interpreter IS the binary exercised on testnet - both instances were created
  *  from the same uploaded wasm hash (see PINNED_INTERPRETER_WASM_SHA256), and
- *  both were read back with `grammar_version()` returning 3. The address differs
+ *  both were read back with `grammar_version()` returning 4. The address differs
  *  because instance ids are network-scoped. UNAUDITED at the time of writing.
  *
  *  These four constants move together or not at all. The grammar version and
  *  wasm hash are single values covering BOTH networks, so re-pinning one network
  *  alone would have the builder emit a version the other network refuses - with
  *  a green test run, since `grammar-version-parity.test.ts` would then pass. */
-export declare const PINNED_INTERPRETER_MAINNET_ADDRESS = "CBZXLSTQUITBFZHQH6XRXF3XIVRQR4RHRI64Q5WELS5KGY3ZKJPFWDPF";
+export declare const PINNED_INTERPRETER_MAINNET_ADDRESS = "CDN755TDYZM3ZQ5OXTJ6TIBUBWZV2KRI2BYJPBXD2MVWED4STT3VBN52";
 /** Pinned interpreter wasm sha256 (hex). */
-export declare const PINNED_INTERPRETER_WASM_SHA256 = "a2b36e8ac5a61caf3757af26aa79e83f2995b451099f44772383806a55fe3414";
+export declare const PINNED_INTERPRETER_WASM_SHA256 = "b5ba1e35ccf20cd8c13c3a2c3098bf337033a92bcaf475d63c03ddc0cba0fcae";
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
  *  contracts/policy-interpreter/src/version.rs). */
-export declare const PINNED_INTERPRETER_GRAMMAR_VERSION = 3;
+export declare const PINNED_INTERPRETER_GRAMMAR_VERSION = 4;
 /** Default Soroban RPC for the install / revoke / info tools. The recorder
  *  keeps its own copy in record/rpc.ts because it hands back a fetcher rather
  *  than a Server; the two are deliberately different surfaces, so this is
@@ -1641,6 +1641,25 @@ export declare const DeclarePolicyInputSchema: z.ZodObject<{
     recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     recipientArgIndex: z.ZodOptional<z.ZodNumber>;
     allowZeroCap: z.ZodOptional<z.ZodBoolean>;
+    /** Minimum output as a ratio of the call's own input. num/den are decimal
+     *  STRINGS for the same reason maxAmount is: an i128 ratio does not
+     *  survive a JS number. */
+    minOutputRatio: z.ZodOptional<z.ZodObject<{
+        num: z.ZodString;
+        den: z.ZodString;
+        inputArgIndex: z.ZodNumber;
+        outputArgIndex: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    }, {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     fn: string;
     contract?: string | undefined;
@@ -1649,6 +1668,12 @@ export declare const DeclarePolicyInputSchema: z.ZodObject<{
     recipients?: string[] | undefined;
     recipientArgIndex?: number | undefined;
     allowZeroCap?: boolean | undefined;
+    minOutputRatio?: {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    } | undefined;
 }, {
     fn: string;
     contract?: string | undefined;
@@ -1657,6 +1682,12 @@ export declare const DeclarePolicyInputSchema: z.ZodObject<{
     recipients?: string[] | undefined;
     recipientArgIndex?: number | undefined;
     allowZeroCap?: boolean | undefined;
+    minOutputRatio?: {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    } | undefined;
 }>;
 export type DeclarePolicyInput = z.infer<typeof DeclarePolicyInputSchema>;
 export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
@@ -1726,6 +1757,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -1735,7 +1767,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }, {
         signers: ({
@@ -1747,6 +1778,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -1756,7 +1788,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }>, "many">>;
     /** The smart account contract address (C...) that will receive the rule. */
@@ -2153,6 +2184,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2162,7 +2194,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;
@@ -2212,6 +2243,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2221,7 +2253,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;
@@ -2271,6 +2302,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2280,7 +2312,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;
@@ -2330,6 +2361,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             keyBytes: string;
         })[];
         id: number;
+        policyAddresses: string[];
         contextType: {
             kind: "default";
         } | {
@@ -2339,7 +2371,6 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "create_contract";
             wasmHash: string;
         };
-        policyAddresses: string[];
         predicate?: unknown;
     }[] | undefined;
     rpcUrl?: string | undefined;

package/dist-cjs/run/schemas.js

@@ -180,6 +180,15 @@ exports.PredicateLeafSchema = zod_1.z.lazy(() => zod_1.z.union([
         element: zod_1.z.number().int().nonnegative(),
         field: zod_1.z.string(),
     }),
+    // num/den are i128 decimal strings, matching `literal_i128`. The regex
+    // is the boundary guard; the ratio's SIGN is checked at encode, where
+    // the message can explain that a negative ratio inverts the comparison.
+    zod_1.z.object({
+        kind: zod_1.z.literal('call_arg_scaled'),
+        index: zod_1.z.number().int().nonnegative(),
+        num: zod_1.z.string().regex(/^-?[0-9]+$/),
+        den: zod_1.z.string().regex(/^-?[0-9]+$/),
+    }),
     zod_1.z.object({ kind: zod_1.z.literal('literal_address'), value: zod_1.z.string() }),
     zod_1.z.object({ kind: zod_1.z.literal('literal_i128'), value: zod_1.z.string().regex(/^-?[0-9]+$/) }),
     zod_1.z.object({ kind: zod_1.z.literal('literal_symbol'), value: zod_1.z.string() }),
@@ -198,16 +207,32 @@ exports.PredicateLeafSchema = zod_1.z.lazy(() => zod_1.z.union([
  *  `and`; the lazy + annotation pattern keeps the recursion type-safe. */
 exports.PredicateNodeSchema = zod_1.z.lazy(() => zod_1.z.union([
     zod_1.z.object({ op: zod_1.z.literal('and'), children: zod_1.z.array(exports.PredicateNodeSchema) }),
+    zod_1.z.object({ op: zod_1.z.literal('or'), children: zod_1.z.array(exports.PredicateNodeSchema) }),
     zod_1.z.object({
         op: zod_1.z.literal('eq'),
         left: exports.PredicateLeafSchema,
         right: exports.PredicateLeafSchema,
     }),
+    zod_1.z.object({
+        op: zod_1.z.literal('lt'),
+        left: exports.PredicateLeafSchema,
+        right: exports.PredicateLeafSchema,
+    }),
     zod_1.z.object({
         op: zod_1.z.literal('lte'),
         left: exports.PredicateLeafSchema,
         right: exports.PredicateLeafSchema,
     }),
+    zod_1.z.object({
+        op: zod_1.z.literal('gt'),
+        left: exports.PredicateLeafSchema,
+        right: exports.PredicateLeafSchema,
+    }),
+    zod_1.z.object({
+        op: zod_1.z.literal('gte'),
+        left: exports.PredicateLeafSchema,
+        right: exports.PredicateLeafSchema,
+    }),
     zod_1.z.object({
         op: zod_1.z.literal('in'),
         needle: exports.PredicateLeafSchema,
@@ -303,23 +328,23 @@ const ContextRuleDraftSchema = zod_1.z
 // existing four.
 /** Pinned interpreter address (testnet).
  *  Single source for the MCP layer; do not embed elsewhere. */
-exports.PINNED_INTERPRETER_TESTNET_ADDRESS = 'CCL336TCK2Y5OFNRCMN2M3HVPBCEX4PW5H6EQ5VW5NPMXOCP4ESB5XR4';
-/** Pinned interpreter address (mainnet), redeployed 2026-08-22 from a reproducible build. The mainnet
+exports.PINNED_INTERPRETER_TESTNET_ADDRESS = 'CCBHVZ6HGGV7C4SNHCZ3S5665Z2WEMHTMBAEPO4XW6PKON464BEBANU5';
+/** Pinned interpreter address (mainnet), redeployed 2026-08-22 for grammar 4, from a reproducible build. The mainnet
  *  interpreter IS the binary exercised on testnet - both instances were created
  *  from the same uploaded wasm hash (see PINNED_INTERPRETER_WASM_SHA256), and
- *  both were read back with `grammar_version()` returning 3. The address differs
+ *  both were read back with `grammar_version()` returning 4. The address differs
  *  because instance ids are network-scoped. UNAUDITED at the time of writing.
  *
  *  These four constants move together or not at all. The grammar version and
  *  wasm hash are single values covering BOTH networks, so re-pinning one network
  *  alone would have the builder emit a version the other network refuses - with
  *  a green test run, since `grammar-version-parity.test.ts` would then pass. */
-exports.PINNED_INTERPRETER_MAINNET_ADDRESS = 'CBZXLSTQUITBFZHQH6XRXF3XIVRQR4RHRI64Q5WELS5KGY3ZKJPFWDPF';
+exports.PINNED_INTERPRETER_MAINNET_ADDRESS = 'CDN755TDYZM3ZQ5OXTJ6TIBUBWZV2KRI2BYJPBXD2MVWED4STT3VBN52';
 /** Pinned interpreter wasm sha256 (hex). */
-exports.PINNED_INTERPRETER_WASM_SHA256 = 'a2b36e8ac5a61caf3757af26aa79e83f2995b451099f44772383806a55fe3414';
+exports.PINNED_INTERPRETER_WASM_SHA256 = 'b5ba1e35ccf20cd8c13c3a2c3098bf337033a92bcaf475d63c03ddc0cba0fcae';
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
  *  contracts/policy-interpreter/src/version.rs). */
-exports.PINNED_INTERPRETER_GRAMMAR_VERSION = 3;
+exports.PINNED_INTERPRETER_GRAMMAR_VERSION = 4;
 /** Default Soroban RPC for the install / revoke / info tools. The recorder
  *  keeps its own copy in record/rpc.ts because it hands back a fetcher rather
  *  than a Server; the two are deliberately different surfaces, so this is
@@ -382,6 +407,18 @@ exports.DeclarePolicyInputSchema = zod_1.z
     recipients: zod_1.z.array(zod_1.z.string()).min(1, 'recipients must not be empty').optional(),
     recipientArgIndex: zod_1.z.number().int().nonnegative().max(U32_MAX).optional(),
     allowZeroCap: zod_1.z.boolean().optional(),
+    /** Minimum output as a ratio of the call's own input. num/den are decimal
+     *  STRINGS for the same reason maxAmount is: an i128 ratio does not
+     *  survive a JS number. */
+    minOutputRatio: zod_1.z
+        .object({
+        num: zod_1.z.string().regex(/^[0-9]+$/, 'num must be an unsigned integer'),
+        den: zod_1.z.string().regex(/^[0-9]+$/, 'den must be an unsigned integer'),
+        inputArgIndex: zod_1.z.number().int().nonnegative().max(U32_MAX),
+        outputArgIndex: zod_1.z.number().int().nonnegative().max(U32_MAX),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 exports.InstallPolicyInputSchema = zod_1.z

package/dist-cjs/simulate/deny-cases.js

@@ -205,11 +205,22 @@ function visit(node, facts) {
             for (const child of node.children)
                 visit(child, facts);
             return;
+        // NOT descended into. A deny case works by violating ONE constraint and
+        // asserting the predicate refuses the call. Violating one branch of an
+        // `or` proves nothing, because another branch can still permit, so the
+        // generated case would either fail or pass for the wrong reason. A sound
+        // deny case for a disjunction must violate EVERY branch at once, which
+        // this generator does not construct - so it emits none.
+        case 'or':
+            return;
         case 'in':
             facts.memberships.push(node);
             return;
         case 'eq':
+        case 'lt':
         case 'lte':
+        case 'gt':
+        case 'gte':
             facts.comparisons.push(node);
     }
 }

package/dist-cjs/simulate/evaluate.js

@@ -1,5 +1,5 @@
 "use strict";
-// src/simulate/evaluate.ts - TypeScript reference evaluator for grammar version 3.
+// src/simulate/evaluate.ts - TypeScript reference evaluator for grammar version 4.
 //
 // Pure function. Determinism: same `(predicate, ctx)` -> byte-identical result,
 // no clock, no randomness. Deny order (deny on FIRST violation, stable reason):
@@ -9,12 +9,13 @@
 //   3. `in` membership; empty haystack ALWAYS denies         -> 'NOT_IN_ALLOWLIST'
 //   4. otherwise permit.
 //
-// Grammar version 3 nodes: and, eq, lte
-// Grammar version 3 leaves: call_contract, call_fn, call_arg(i),
+// Grammar version 4 nodes: and, or, eq, lt, lte, gt, gte, in
+// Grammar version 4 leaves: call_contract, call_fn, call_arg(i),
 //   call_arg_len(i), call_arg_field(i, element, field),
+//   call_arg_scaled(i, num, den),
 //   literal_address, literal_i128, literal_symbol, literal_u32, literal_vec
-// Grammar version 3 deny reasons: ARG_MISMATCH, CONTRACT_SCOPE,
-//   UNSUPPORTED_NODE, NOT_IN_ALLOWLIST
+// Grammar version 4 deny reasons: ARG_MISMATCH, CONTRACT_SCOPE,
+//   ARITHMETIC_OVERFLOW, UNSUPPORTED_NODE, NOT_IN_ALLOWLIST, SLIPPAGE_FLOOR
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluate = evaluate;
 /** Evaluate a `PredicateNode` against the candidate call described by `ctx`.
@@ -36,8 +37,25 @@ function walk(node, ctx) {
             }
             return lastDeny ?? { permit: true };
         }
+        // Permits on the first branch that holds; when none does, reports the
+        // FIRST branch's reason. Mirrors `Node::Or` in the Rust evaluator, which
+        // the conformance suite pins.
+        case 'or': {
+            let firstDeny = null;
+            for (const child of node.children) {
+                const r = walk(child, ctx);
+                if (r.permit)
+                    return r;
+                if (firstDeny === null)
+                    firstDeny = r;
+            }
+            return firstDeny ?? { permit: false, reason: 'UNSUPPORTED_NODE' };
+        }
         case 'eq':
+        case 'lt':
         case 'lte':
+        case 'gt':
+        case 'gte':
             return evalCompare(node.op, node.left, node.right, ctx);
         case 'in':
             return evalIn(node.needle, node.haystack, ctx);
@@ -45,6 +63,16 @@ function walk(node, ctx) {
 }
 /** Comparison leaf evaluation. */
 function evalCompare(op, left, right, ctx) {
+    // Scaled operands first, so the dedicated reasons reach the caller instead
+    // of a generic mismatch. Right-hand dispatch leads because
+    // `out >= in * num / den` is the canonical swap form. Mirrors the order in
+    // `eval_compare` on the Rust side.
+    if (right.kind === 'call_arg_scaled') {
+        return evalScaledCompare(op, left, right, true, ctx);
+    }
+    if (left.kind === 'call_arg_scaled') {
+        return evalScaledCompare(op, right, left, false, ctx);
+    }
     // CONTRACT_SCOPE on call_contract eq
     if (left.kind === 'call_contract' && op === 'eq') {
         if (right.kind !== 'literal_address')
@@ -99,6 +127,53 @@ function evalCompare(op, left, right, ctx) {
     // Unknown leaf/op combination - structural fail-closed.
     return { permit: false, reason: 'UNSUPPORTED_NODE' };
 }
+/** i128 bounds. The contract computes in i128 and denies on overflow, so the
+ *  reference has to draw the same line or the two layers disagree on inputs
+ *  near the boundary. */
+const I128_MIN = -(2n ** 127n);
+const I128_MAX = 2n ** 127n - 1n;
+/** Comparison where one side is `call_arg_scaled`. Mirrors
+ *  `eval_scaled_arg_compare`: `args[index] * num / den` truncating toward
+ *  zero, ARITHMETIC_OVERFLOW on arithmetic that does not fit or a zero
+ *  denominator, SLIPPAGE_FLOOR on a comparison that simply fails. */
+function evalScaledCompare(op, other, scaled, scaledOnRight, ctx) {
+    // Chaining two computed operands has no meaning a review card could state.
+    if (other.kind === 'call_arg_scaled')
+        return { permit: false, reason: 'UNSUPPORTED_NODE' };
+    // Could not READ the operand is a different failure from read-and-missed.
+    const input = argNumericBigInt(ctx.args[scaled.index]);
+    if (input === null)
+        return { permit: false, reason: 'ARG_MISMATCH' };
+    let num;
+    let den;
+    try {
+        num = BigInt(scaled.num);
+        den = BigInt(scaled.den);
+    }
+    catch {
+        return { permit: false, reason: 'ARG_MISMATCH' };
+    }
+    if (den === 0n)
+        return { permit: false, reason: 'ARITHMETIC_OVERFLOW' };
+    const product = input * num;
+    if (product < I128_MIN || product > I128_MAX) {
+        return { permit: false, reason: 'ARITHMETIC_OVERFLOW' };
+    }
+    // BigInt division already truncates toward zero, matching i128 semantics.
+    const quotient = product / den;
+    if (quotient < I128_MIN || quotient > I128_MAX) {
+        return { permit: false, reason: 'ARITHMETIC_OVERFLOW' };
+    }
+    const otherVal = other.kind === 'call_arg'
+        ? argNumericBigInt(ctx.args[other.index])
+        : literalNumericBigInt(other);
+    if (otherVal === null)
+        return { permit: false, reason: 'ARG_MISMATCH' };
+    const [a, b] = scaledOnRight ? [otherVal, quotient] : [quotient, otherVal];
+    return bigintCmp(op, a.toString(), b.toString())
+        ? { permit: true }
+        : { permit: false, reason: 'SLIPPAGE_FLOOR' };
+}
 /** Per-ScVal equality. Handles literal_vec as an EXACT ordered sequence:
  *  compare element-by-element in order; deny if length or any element differs.
  *  Opaque args (`type: 'other'`) fail closed. */
@@ -268,7 +343,13 @@ function bigintCmp(op, aStr, bStr) {
     switch (op) {
         case 'eq':
             return a === b;
+        case 'lt':
+            return a < b;
         case 'lte':
             return a <= b;
+        case 'gt':
+            return a > b;
+        case 'gte':
+            return a >= b;
     }
 }

package/dist-cjs/synth/declare.d.ts

@@ -18,6 +18,19 @@ export interface PolicyDeclaration {
      *  explicitly. A rule that permits nothing is a plausible thing to want and
      *  an implausible thing to want by accident. */
     allowZeroCap?: boolean;
+    /** Minimum output as a ratio of the call's own input: the output argument
+     *  must be at least `input * num / den`.
+     *
+     *  A swap's acceptable output depends on the size of the trade, so a fixed
+     *  floor would pin the policy to one trade size. The ratio is DECLARED, never
+     *  inferred from a recording: a recorded rate is a price at one moment, and
+     *  freezing it as policy would deny ordinary trades later. */
+    minOutputRatio?: {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    };
 }
 export interface DeclaredPredicate {
     predicate: PredicateNode;

package/dist-cjs/synth/declare.js

@@ -16,11 +16,12 @@
 // first: it constrains the amount in THIS call rather than implying a rolling
 // total nothing tracks.
 //
-// What a declaration can say maps one-to-one onto grammar 3:
-//   fn         -> eq(call_fn, literal_symbol)
-//   contract   -> eq(call_contract, literal_address)
-//   maxAmount  -> lte(call_arg(i), literal_i128)
-//   recipients -> in(call_arg(j), [literal_address, ...])
+// What a declaration can say maps one-to-one onto grammar 4:
+//   fn            -> eq(call_fn, literal_symbol)
+//   contract      -> eq(call_contract, literal_address)
+//   maxAmount     -> lte(call_arg(i), literal_i128)
+//   recipients    -> in(call_arg(j), [literal_address, ...])
+//   minOutputRatio-> gte(call_arg(out), call_arg_scaled(in, num, den))
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.declarePredicate = declarePredicate;
 const address_ts_1 = require("./address.js");
@@ -87,6 +88,34 @@ function declarePredicate(d) {
             right: { kind: 'literal_i128', value: d.maxAmount },
         });
     }
+    if (d.minOutputRatio !== undefined) {
+        const { num, den, inputArgIndex, outputArgIndex } = d.minOutputRatio;
+        if (!/^[0-9]+$/.test(num) || !/^[0-9]+$/.test(den)) {
+            throw declareError('SYNTHESIS_ERROR', `minOutputRatio num/den must be unsigned integers, got "${num}"/"${den}" (a 1% slippage tolerance is num "99", den "100")`);
+        }
+        // Both are refused on chain at install (INVALID_SCALED_RATIO). Refusing
+        // here too means the caller learns before a transaction is built.
+        if (den === '0') {
+            throw declareError('SYNTHESIS_ERROR', 'minOutputRatio.den is zero: the ratio has no value');
+        }
+        if (num === '0') {
+            throw declareError('SYNTHESIS_ERROR', 'minOutputRatio.num is zero: the floor would be zero, which constrains nothing. Omit it instead.');
+        }
+        if (inputArgIndex === outputArgIndex) {
+            throw declareError('SYNTHESIS_ERROR', `minOutputRatio bounds arg[${inputArgIndex}] against itself, which is true for any ratio at or below 1 and false above it - never a slippage floor. Pass the distinct input and output positions.`);
+        }
+        if (BigInt(num) > BigInt(den)) {
+            // Demanding MORE out than went in is not slippage protection; it is a
+            // rule that denies every honest trade. Loud beats a policy that never
+            // permits.
+            warnings.push(`minOutputRatio ${num}/${den} is above 1: it requires the output to EXCEED the input, which no ordinary swap satisfies. Check the ratio is not inverted.`);
+        }
+        children.push({
+            op: 'gte',
+            left: { kind: 'call_arg', index: outputArgIndex },
+            right: { kind: 'call_arg_scaled', index: inputArgIndex, num, den },
+        });
+    }
     // A single conjunct is emitted bare. `and` with one child encodes to
     // different bytes than the child alone, and the extra node buys nothing.
     const predicate = children.length === 1 ? children[0] : { op: 'and', children };

package/dist-cjs/synth/synthesize-from-recording.js

@@ -2,7 +2,7 @@
 // src/synth/synthesize-from-recording.ts - recording-path orchestrator.
 //
 // `synthesizeFromRecording` INFERS a bounded policy from a `RecordedTransaction`
-// via the `PolicyIR` + interpreter adapter pair.
+// via the composer + interpreter adapter pair.
 // Flow: validate -> parseConfidence gate -> lower -> decideScope -> composeFromRecording
 // -> interpreter compile + self-verify.
 // Same (tx, opts) -> byte-identical ProposedPolicy (no randomness, clock, globals).