@crediolabs/policy-synth 0.2.0 → 0.3.0

package/dist/synth/compose-from-recording.d.ts

@@ -1,45 +1,14 @@
-import type { IRCompOp, PolicyIR } from '../ir/types.ts';
-import type { AmbiguityPrompt, ContractInvocation, Network } from '../types.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)
@@ -51,28 +20,32 @@ 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 declare function composeFromRecording(facts: IntentFacts, scopeContract: string, topLevel: ContractInvocation | null, opts: ComposeOptions): ComposeResult;