@crediolabs/policy-synth 0.1.18 → 0.3.0

package/dist-cjs/run/index.js

@@ -18,13 +18,13 @@
 // No business logic. No retries. No session state. The same call shape can
 // drive the CLI (which calls into the same core directly without MCP).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VerifyPolicyInputSchema = exports.ToolErrorSchema = exports.TESTNET_RPC_URL = exports.SynthesizePolicyInputSchema = exports.SimulatePolicyInputSchema = exports.RPC_URL_BY_NETWORK = exports.RevokePolicyInputSchema = exports.RecordTransactionInputSchema = exports.RecordedTransactionSchema = exports.PredicateNodeSchema = exports.PredicateLeafSchema = exports.PINNED_INTERPRETER_WASM_SHA256 = exports.PINNED_INTERPRETER_TESTNET_ADDRESS = exports.PINNED_INTERPRETER_MAINNET_ADDRESS = exports.PINNED_INTERPRETER_GRAMMAR_VERSION = exports.PINNED_INTERPRETER_ADDRESS_BY_NETWORK = exports.OzAdapterConfigSchema = exports.OraclePriceFixtureSchema = exports.NetworkSchema = exports.MandateSpecSchema = exports.MAINNET_RPC_URL = exports.InterpreterOptionsSchema = exports.InstallPolicyInputSchema = exports.GetInterpreterInfoInputSchema = exports.ComposeUserResponsesSchema = void 0;
+exports.ToolErrorSchema = exports.TESTNET_RPC_URL = exports.SynthesizePolicyInputSchema = exports.RPC_URL_BY_NETWORK = exports.RevokePolicyInputSchema = exports.RecordTransactionInputSchema = exports.RecordedTransactionSchema = exports.PredicateNodeSchema = exports.PredicateLeafSchema = exports.PINNED_INTERPRETER_WASM_SHA256 = exports.PINNED_INTERPRETER_TESTNET_ADDRESS = exports.PINNED_INTERPRETER_MAINNET_ADDRESS = exports.PINNED_INTERPRETER_GRAMMAR_VERSION = exports.PINNED_INTERPRETER_ADDRESS_BY_NETWORK = exports.NetworkSchema = exports.MAINNET_RPC_URL = exports.InterpreterOptionsSchema = exports.InstallPolicyInputSchema = exports.GetInterpreterInfoInputSchema = exports.ComposeUserResponsesSchema = void 0;
 exports.runRecordTransaction = runRecordTransaction;
 exports.runSynthesizePolicy = runSynthesizePolicy;
-exports.runSimulatePolicy = runSimulatePolicy;
-exports.runVerifyPolicy = runVerifyPolicy;
 exports.runInstallPolicy = runInstallPolicy;
 exports.runRevokePolicy = runRevokePolicy;
+exports.runSimulatePolicy = runSimulatePolicy;
+exports.runVerifyPolicy = runVerifyPolicy;
 exports.runGetInterpreterInfo = runGetInterpreterInfo;
 exports.caughtError = caughtError;
 const node_crypto_1 = require("node:crypto");
@@ -32,7 +32,7 @@ const stellar_sdk_1 = require("@stellar/stellar-sdk");
 const index_ts_1 = require("../index.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 index_ts_2 = require("../verify/index.js");
+const index_ts_2 = require("../simulate/index.js");
 const schemas_ts_1 = require("./schemas.js");
 // Re-export the underlying Zod schemas so the MCP package (and any other
 // downstream consumer) can import the canonical input shapes from the same
@@ -44,10 +44,7 @@ Object.defineProperty(exports, "GetInterpreterInfoInputSchema", { enumerable: tr
 Object.defineProperty(exports, "InstallPolicyInputSchema", { enumerable: true, get: function () { return schemas_ts_2.InstallPolicyInputSchema; } });
 Object.defineProperty(exports, "InterpreterOptionsSchema", { enumerable: true, get: function () { return schemas_ts_2.InterpreterOptionsSchema; } });
 Object.defineProperty(exports, "MAINNET_RPC_URL", { enumerable: true, get: function () { return schemas_ts_2.MAINNET_RPC_URL; } });
-Object.defineProperty(exports, "MandateSpecSchema", { enumerable: true, get: function () { return schemas_ts_2.MandateSpecSchema; } });
 Object.defineProperty(exports, "NetworkSchema", { enumerable: true, get: function () { return schemas_ts_2.NetworkSchema; } });
-Object.defineProperty(exports, "OraclePriceFixtureSchema", { enumerable: true, get: function () { return schemas_ts_2.OraclePriceFixtureSchema; } });
-Object.defineProperty(exports, "OzAdapterConfigSchema", { enumerable: true, get: function () { return schemas_ts_2.OzAdapterConfigSchema; } });
 Object.defineProperty(exports, "PINNED_INTERPRETER_ADDRESS_BY_NETWORK", { enumerable: true, get: function () { return schemas_ts_2.PINNED_INTERPRETER_ADDRESS_BY_NETWORK; } });
 Object.defineProperty(exports, "PINNED_INTERPRETER_GRAMMAR_VERSION", { enumerable: true, get: function () { return schemas_ts_2.PINNED_INTERPRETER_GRAMMAR_VERSION; } });
 Object.defineProperty(exports, "PINNED_INTERPRETER_MAINNET_ADDRESS", { enumerable: true, get: function () { return schemas_ts_2.PINNED_INTERPRETER_MAINNET_ADDRESS; } });
@@ -59,11 +56,9 @@ Object.defineProperty(exports, "RecordedTransactionSchema", { enumerable: true,
 Object.defineProperty(exports, "RecordTransactionInputSchema", { enumerable: true, get: function () { return schemas_ts_2.RecordTransactionInputSchema; } });
 Object.defineProperty(exports, "RevokePolicyInputSchema", { enumerable: true, get: function () { return schemas_ts_2.RevokePolicyInputSchema; } });
 Object.defineProperty(exports, "RPC_URL_BY_NETWORK", { enumerable: true, get: function () { return schemas_ts_2.RPC_URL_BY_NETWORK; } });
-Object.defineProperty(exports, "SimulatePolicyInputSchema", { enumerable: true, get: function () { return schemas_ts_2.SimulatePolicyInputSchema; } });
 Object.defineProperty(exports, "SynthesizePolicyInputSchema", { enumerable: true, get: function () { return schemas_ts_2.SynthesizePolicyInputSchema; } });
 Object.defineProperty(exports, "TESTNET_RPC_URL", { enumerable: true, get: function () { return schemas_ts_2.TESTNET_RPC_URL; } });
 Object.defineProperty(exports, "ToolErrorSchema", { enumerable: true, get: function () { return schemas_ts_2.ToolErrorSchema; } });
-Object.defineProperty(exports, "VerifyPolicyInputSchema", { enumerable: true, get: function () { return schemas_ts_2.VerifyPolicyInputSchema; } });
 /** Map every tool name to its canonical domain error code. Replaces a 7-way
  *  if/else so adding a tool adds one line here rather than a new branch in
  *  each envelope call. */
@@ -90,10 +85,7 @@ const TOOL_ERROR_CODE = {
 async function runRecordTransaction(raw) {
     const parsed = schemas_ts_1.RecordTransactionInputSchema.safeParse(raw);
     if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('record_transaction', parsed.error.issues),
-        };
+        return { ok: false, error: validationError('record_transaction', parsed.error.issues) };
     }
     const input = parsed.data;
     // Strip the wire-only `confidenceOverride` and pass the rest straight through.
@@ -109,14 +101,10 @@ async function runRecordTransaction(raw) {
         return await (0, index_ts_1.recordTransaction)(coreInput);
     }
     catch (e) {
-        return {
-            ok: false,
-            error: caughtError('record_transaction', 'RECORDING_FAILED', e),
-        };
+        return toolFailure('record_transaction', e);
     }
 }
 /** `synthesize_policy` body - discriminated union on `source`:
- *    - `mandate`   -> synthesizeFromMandate
  *    - `recording` -> synthesizeFromRecording
  *  Exposing BOTH front-ends through ONE tool keeps the MCP surface tiny while
  *  letting the agent pick the deterministic or the inferred path. The CLI
@@ -130,21 +118,10 @@ async function runRecordTransaction(raw) {
 async function runSynthesizePolicy(raw) {
     const parsed = schemas_ts_1.SynthesizePolicyInputSchema.safeParse(raw);
     if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('synthesize_policy', parsed.error.issues),
-        };
+        return { ok: false, error: validationError('synthesize_policy', parsed.error.issues) };
     }
     const input = parsed.data;
-    const ozConfig = resolveOzConfig(input);
     try {
-        if (input.source === 'mandate') {
-            // Zod's optional fields widen to `T | undefined`, which the core's
-            // exact-optional MandateSpec rejects; the schema already validated the
-            // shape, so assert it (same pattern as the recordedTx cast below).
-            return await (0, index_ts_1.synthesizeFromMandate)(input.mandate, ozConfig, input.explain === true ? { explain: true } : {});
-        }
-        // recording source
         const recorded = input.recordedTx;
         return await (0, index_ts_1.synthesizeFromRecording)(recorded, {
             network: input.network,
@@ -154,112 +131,16 @@ async function runSynthesizePolicy(raw) {
                 : {}),
             ...(input.interpreter !== undefined ? { interpreter: input.interpreter } : {}),
             ...(input.explain === true ? { explain: true } : {}),
-        }, ozConfig);
-    }
-    catch (e) {
-        return {
-            ok: false,
-            error: caughtError('synthesize_policy', 'SYNTHESIS_ERROR', e),
-        };
-    }
-}
-function resolveOzConfig(input) {
-    if (input.ozConfig)
-        return input.ozConfig;
-    // The mandate path is network-agnostic; fall back to mainnet so the
-    // placeholder OZ instance addresses are deterministic.
-    return (0, index_ts_1.placeholderOzConfig)('mainnet');
-}
-/** `simulate_policy` body - thin wrapper over `simulatePolicy`. The engine
- *  already returns fail-closed `{ok:false, error}` for runtime failures
- *  (SIMULATION_ERROR), so the try/catch envelope is for raw SDK throws
- *  only - same pattern as the other two wrappers. The predicate is
- *  passed inline (stateless by design; no `proposed_policy_id` lookup). */
-async function runSimulatePolicy(raw) {
-    const parsed = schemas_ts_1.SimulatePolicyInputSchema.safeParse(raw);
-    if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('simulate_policy', parsed.error.issues),
-        };
-    }
-    const input = parsed.data;
-    try {
-        // The recursive PredicateNodeSchema + ContractInvocationSchema are
-        // typed `z.ZodType<unknown>` to survive TS's circular inference; the
-        // engine wants typed `PredicateNode | null` + `RecordedTransaction`.
-        // The schema already validated the shape, so assert through the
-        // unknown back to the core types. Same pattern as the recordedTx
-        // cast in `runSynthesizePolicy`.
-        return (0, index_ts_2.simulatePolicy)(input.predicate, input.permitTx, {
-            ...(input.validUntilLedger !== undefined
-                ? { validUntilLedger: input.validUntilLedger }
-                : {}),
-            ...(input.oraclePricesByAsset !== undefined
-                ? { oraclePricesByAsset: input.oraclePricesByAsset }
-                : {}),
-        });
-    }
-    catch (e) {
-        return {
-            ok: false,
-            error: caughtError('simulate_policy', 'SIMULATION_ERROR', e),
-        };
-    }
-}
-/** `verify_policy` body - thin wrapper over `verifyPolicy`. The engine
- *  already returns `{ok:false, error}` with code VERIFICATION_FAILED when
- *  the minimality check fails; the try/catch envelope is for raw SDK
- *  throws only. Mirrors `runSimulatePolicy` exactly. */
-async function runVerifyPolicy(raw) {
-    const parsed = schemas_ts_1.VerifyPolicyInputSchema.safeParse(raw);
-    if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('verify_policy', parsed.error.issues),
-        };
-    }
-    const input = parsed.data;
-    try {
-        // Same cast as runSimulatePolicy: the recursive schemas are typed
-        // `unknown`; the engine wants typed `PredicateNode` +
-        // `RecordedTransaction`. The schema already validated the shape.
-        return (0, index_ts_2.verifyPolicy)(input.predicate, input.permitTx, {
-            ...(input.validUntilLedger !== undefined ? { validUntilLedger: input.validUntilLedger } : {}),
-            ...(input.oraclePricesByAsset !== undefined
-                ? { oraclePricesByAsset: input.oraclePricesByAsset }
-                : {}),
         });
     }
     catch (e) {
-        return {
-            ok: false,
-            error: caughtError('verify_policy', 'VERIFICATION_FAILED', e),
-        };
+        return toolFailure('synthesize_policy', e);
     }
 }
-/** `install_policy` body - thin wrapper over `buildInstallPolicyXdr`.
- *  Returns the unsigned Soroban transaction envelope (base64 XDR) the
- *  wallet signs. The wallet signature IS the user-confirmation step - no
- *  `action_id` two-call pair (the server is stateless, see server.ts:10-12).
- *  One call installs the policy outright: `add_context_rule` carries the
- *  predicate to the interpreter in its `policies` install_param, so no
- *  separate `interpreter.install` call is needed or possible.
- *
- *  Default-deny: an interpreter policy address other than the pinned
- *  interpreter for the selected network is REFUSED (the smart account
- *  would delegate to an interpreter the caller controls); the same
- *  applies to a non-pinned RPC URL (the auth nonce the wallet signs
- *  comes from the RPC). Both gates accept an explicit opt-in flag.
- *  Pin selection follows `input.network` (defaults to `testnet` so the
- *  pre-mainnet callers keep working unchanged). */
 async function runInstallPolicy(raw) {
     const parsed = schemas_ts_1.InstallPolicyInputSchema.safeParse(raw);
     if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('install_policy', parsed.error.issues),
-        };
+        return { ok: false, error: validationError('install_policy', parsed.error.issues) };
     }
     const input = parsed.data;
     const network = input.network ?? 'testnet';
@@ -279,10 +160,7 @@ async function runInstallPolicy(raw) {
         rpcClient = buildRpcClientFromInput(input.rpcUrl, network);
     }
     catch (e) {
-        return {
-            ok: false,
-            error: caughtError('install_policy', 'INSTALL_BUILD_FAILED', e),
-        };
+        return toolFailure('install_policy', e);
     }
     try {
         const interpreterPolicy = input.rule.policies.find((p) => p.kind === 'interpreter');
@@ -304,10 +182,7 @@ async function runInstallPolicy(raw) {
         return { ok: true, data: result };
     }
     catch (e) {
-        return {
-            ok: false,
-            error: caughtError('install_policy', 'INSTALL_BUILD_FAILED', e),
-        };
+        return toolFailure('install_policy', e);
     }
 }
 /** `revoke_policy` body - thin wrapper over `buildRevokePolicyXdr`.
@@ -322,10 +197,7 @@ async function runInstallPolicy(raw) {
 async function runRevokePolicy(raw) {
     const parsed = schemas_ts_1.RevokePolicyInputSchema.safeParse(raw);
     if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('revoke_policy', parsed.error.issues),
-        };
+        return { ok: false, error: validationError('revoke_policy', parsed.error.issues) };
     }
     const input = parsed.data;
     const network = input.network ?? 'testnet';
@@ -339,10 +211,7 @@ async function runRevokePolicy(raw) {
         rpcClient = buildRpcClientFromInput(input.rpcUrl, network);
     }
     catch (e) {
-        return {
-            ok: false,
-            error: caughtError('revoke_policy', 'REVOKE_BUILD_FAILED', e),
-        };
+        return toolFailure('revoke_policy', e);
     }
     try {
         const result = await (0, build_install_policy_ts_1.buildRevokePolicyXdr)({
@@ -356,10 +225,7 @@ async function runRevokePolicy(raw) {
         return { ok: true, data: result };
     }
     catch (e) {
-        return {
-            ok: false,
-            error: caughtError('revoke_policy', 'REVOKE_BUILD_FAILED', e),
-        };
+        return toolFailure('revoke_policy', e);
     }
 }
 /** `get_interpreter_info` body - thin wrapper over `getInterpreterInfo`.
@@ -381,14 +247,105 @@ async function runRevokePolicy(raw) {
  *  a non-pinned `rpcUrl` would silently bind the caller to a host they
  *  picked. The pin is enforced here too, with the same `allowUnpinnedRpcUrl`
  *  opt-in as install/revoke. */
-async function runGetInterpreterInfo(raw) {
-    const parsed = schemas_ts_1.GetInterpreterInfoInputSchema.safeParse(raw);
+/** The call a predicate is evaluated against: the single top-level invocation
+ *  the smart account authorises. `Policy::enforce` receives one `Context`, not
+ *  a sub-invocation tree, so simulating anything deeper would claim a
+ *  guarantee the contract does not make. */
+function evalContextFromRecording(tx) {
+    const top = tx.invocations[0];
+    if (!top)
+        return null;
+    return { contract: top.contract, fn: top.fn, args: top.args };
+}
+/** Both `simulate_policy` and `verify_policy` evaluate against a context derived
+ *  from `permitTx`; neither has anything to evaluate when the recording carries
+ *  no top-level invocation. */
+function noInvocationError(toolName) {
+    return {
+        code: TOOL_ERROR_CODE[toolName],
+        message: `${toolName}: permitTx carries no invocation to evaluate`,
+        severity: 'error',
+        retryable: false,
+    };
+}
+/** `simulate_policy` body - evaluate a predicate against one recorded call.
+ *
+ *  The evaluator is a second implementation of the on-chain semantics, and the
+ *  conformance harness asserts it agrees with the Rust interpreter case for
+ *  case. A verdict here is therefore a claim about what the contract would do,
+ *  not a guess. */
+function runSimulatePolicy(raw) {
+    const parsed = schemas_ts_1.SimulatePolicyInputSchema.safeParse(raw);
+    if (!parsed.success) {
+        return { ok: false, error: validationError('simulate_policy', parsed.error.issues) };
+    }
+    const input = parsed.data;
+    const ctx = evalContextFromRecording(input.permitTx);
+    if (!ctx)
+        return { ok: false, error: noInvocationError('simulate_policy') };
+    try {
+        const res = (0, index_ts_2.evaluate)(input.predicate, ctx);
+        return {
+            ok: true,
+            data: {
+                permitted: res.permit,
+                reason: res.permit ? null : res.reason,
+                call: { contract: ctx.contract, fn: ctx.fn, argCount: ctx.args.length },
+            },
+        };
+    }
+    catch (e) {
+        return toolFailure('simulate_policy', e);
+    }
+}
+/** `verify_policy` body - the permit case plus a generated deny case per
+ *  dimension.
+ *
+ *  Two failure modes are being checked, and they are not the same thing. A
+ *  permit case that denies means the policy is too STRICT: it would refuse the
+ *  very transaction it was synthesised from. A deny case that permits means it
+ *  is too LOOSE: some mutation of that transaction still gets through. `ok` is
+ *  true only when neither holds. */
+function runVerifyPolicy(raw) {
+    const parsed = schemas_ts_1.VerifyPolicyInputSchema.safeParse(raw);
     if (!parsed.success) {
+        return { ok: false, error: validationError('verify_policy', parsed.error.issues) };
+    }
+    const input = parsed.data;
+    const ctx = evalContextFromRecording(input.permitTx);
+    if (!ctx)
+        return { ok: false, error: noInvocationError('verify_policy') };
+    try {
+        const predicate = input.predicate;
+        const cases = (0, index_ts_2.generateCases)(predicate, ctx);
+        const permitRes = (0, index_ts_2.evaluate)(predicate, cases.permit);
+        const denies = cases.denies.map((d) => {
+            const r = (0, index_ts_2.evaluate)(predicate, d.ctx);
+            return {
+                dimension: d.dimension,
+                denied: !r.permit,
+                reason: r.permit ? null : r.reason,
+            };
+        });
         return {
-            ok: false,
-            error: validationError('get_interpreter_info', parsed.error.issues),
+            ok: true,
+            data: {
+                ok: permitRes.permit && denies.every((d) => d.denied),
+                permit: { permitted: permitRes.permit, reason: permitRes.permit ? null : permitRes.reason },
+                denies,
+                dimensionsCovered: denies.length,
+            },
         };
     }
+    catch (e) {
+        return toolFailure('verify_policy', e);
+    }
+}
+async function runGetInterpreterInfo(raw) {
+    const parsed = schemas_ts_1.GetInterpreterInfoInputSchema.safeParse(raw);
+    if (!parsed.success) {
+        return { ok: false, error: validationError('get_interpreter_info', parsed.error.issues) };
+    }
     const input = parsed.data;
     const network = input.network ?? 'testnet';
     const expectedRpc = schemas_ts_1.RPC_URL_BY_NETWORK[network];
@@ -421,10 +378,7 @@ async function runGetInterpreterInfo(raw) {
         return { ok: true, data: info };
     }
     catch (e) {
-        return {
-            ok: false,
-            error: caughtError('get_interpreter_info', 'RECORDING_FAILED', e),
-        };
+        return toolFailure('get_interpreter_info', e);
     }
 }
 /** Build an InstallRpcClient from an optional URL override + selected
@@ -478,13 +432,8 @@ function enforceInterpreterPin(policies, allowUnpinned, expectedInterpreterAddre
 function enforceRpcPin(toolName, rpcUrl, allowUnpinned, expectedRpc, network) {
     if (!rpcUrl || rpcUrl === expectedRpc || allowUnpinned === true)
         return null;
-    const code = toolName === 'install_policy'
-        ? 'INSTALL_BUILD_FAILED'
-        : toolName === 'revoke_policy'
-            ? 'REVOKE_BUILD_FAILED'
-            : 'RECORDING_FAILED';
     return {
-        code,
+        code: TOOL_ERROR_CODE[toolName],
         message: `${toolName}: rpcUrl must equal the pinned ${expectedRpc} (${network}); set allowUnpinnedRpcUrl: true to opt in to a custom endpoint`,
         severity: 'error',
         retryable: false,
@@ -511,6 +460,11 @@ function validationError(toolName, issues) {
  *  error in `details` for the agent to inspect. Exported as a test-only seam
  *  so the suite in run/index.test.ts can drive the envelope path without
  *  standing up a full recordTransaction pipeline. */
+/** The fail-closed return every tool body uses in its `catch`. Taking only the
+ *  tool name keeps the tool -> error-code mapping in TOOL_ERROR_CODE alone. */
+function toolFailure(toolName, e) {
+    return { ok: false, error: caughtError(toolName, TOOL_ERROR_CODE[toolName], e) };
+}
 function caughtError(toolName, code, e) {
     return {
         code,