@crediolabs/policy-synth 0.3.0 → 0.4.0

package/dist/registry/on-chain-spec.js

@@ -0,0 +1,152 @@
+// src/registry/on-chain-spec.ts - read a contract's own interface off chain.
+//
+// The compiled-in registry covers the protocols we pinned by hand. Everything
+// else was reported as `no-abi`, which read as "this contract does not
+// describe itself" when it almost always does: a Soroban contract embeds a
+// typed spec in its wasm, and the network will hand it over. The recorder was
+// refusing calls whose interface was one RPC round-trip away.
+//
+// What this buys is NARROW and deliberately so. A fetched spec says what the
+// contract's arguments ARE, not what they MEAN. So a call verified against it
+// is recognised - the decode is trustworthy, the confidence gate stops
+// refusing it - but the arguments carry the contract's own parameter NAMES
+// rather than a curated meaning, and nothing here infers which argument is a
+// spend or a recipient. A pinned protocol still outranks a fetched spec for
+// exactly that reason, and `identifyProtocol` is consulted first.
+import { contract as sdkContract } from '@stellar/stellar-sdk';
+import { argsMatchAbi } from "./identify.js";
+/** Map an XDR spec type to the ScVal subset vocabulary the matcher uses.
+ *
+ *  Returns null for a type the recorder's ScVal subset cannot represent. That
+ *  is deliberate: an argument we cannot type is an argument we cannot check,
+ *  and claiming a match on it would be the fail-OPEN direction. A function
+ *  with any such argument is dropped from the derived ABI, so a call to it
+ *  stays unrecognised rather than being waved through. */
+export function abiTypeFromSpecType(specTypeName) {
+    switch (specTypeName) {
+        case 'scSpecTypeAddress':
+            return 'address';
+        case 'scSpecTypeI128':
+            return 'i128';
+        case 'scSpecTypeU64':
+        case 'scSpecTypeI64':
+            return 'u64';
+        case 'scSpecTypeU32':
+        case 'scSpecTypeI32':
+            return 'u32';
+        case 'scSpecTypeSymbol':
+            return 'symbol';
+        case 'scSpecTypeVec':
+            return 'vec';
+        case 'scSpecTypeBytes':
+        case 'scSpecTypeBytesN':
+            return 'bytes';
+        case 'scSpecTypeMap':
+            return 'map';
+        default:
+            return null;
+    }
+}
+/** Build a `SpecFetcher` over the SDK's contract client. */
+export function specFetcherFromRpc(rpcUrl, networkPassphrase) {
+    return {
+        async contractSpec(contractId) {
+            try {
+                const client = await sdkContract.Client.from({ contractId, networkPassphrase, rpcUrl });
+                return client.spec ?? null;
+            }
+            catch {
+                // A contract with no spec, an unreachable RPC and a bad address all
+                // land here and all mean the same thing to the caller: no interface
+                // was obtained, so the contract stays unrecognised. Fail closed.
+                return null;
+            }
+        },
+    };
+}
+/** Convert a fetched spec into the ABI shape `identifyProtocol` already
+ *  matches against. Functions with an argument outside the ScVal subset are
+ *  OMITTED rather than partially typed. */
+export function abiFromSpec(spec) {
+    const abi = {};
+    for (const fn of spec.funcs()) {
+        const name = fn.name().toString();
+        // The constructor is not callable after deployment, so a recorded
+        // invocation can never be one. Keeping it would only widen the surface.
+        if (name === '__constructor')
+            continue;
+        const args = [];
+        let usable = true;
+        for (const input of fn.inputs()) {
+            const type = abiTypeFromSpecType(input.type().switch().name);
+            if (type === null) {
+                usable = false;
+                break;
+            }
+            const argName = input.name().toString();
+            args.push({
+                name: argName,
+                type,
+                // The contract's own parameter name is the honest description. It is
+                // NOT a curated meaning - nothing here knows whether `value` is a
+                // spend - so downstream must not treat it as one.
+                meaning: `${argName} (from the contract's on-chain interface)`,
+            });
+        }
+        if (usable)
+            abi[name] = { args };
+    }
+    return abi;
+}
+/** Fetch and convert in one step. Returns null when no usable interface was
+ *  obtained, which the caller must treat as "unrecognised". */
+export async function fetchContractAbi(contractId, fetcher) {
+    const spec = await fetcher.contractSpec(contractId);
+    if (spec === null)
+        return null;
+    const abi = abiFromSpec(spec);
+    return Object.keys(abi).length === 0 ? null : abi;
+}
+/** Every contract invoked anywhere in the tree, with the calls made on it. */
+function callsByContract(invocations) {
+    const out = new Map();
+    const walk = (inv) => {
+        const list = out.get(inv.contract) ?? [];
+        list.push({ fn: inv.fn, args: inv.args });
+        out.set(inv.contract, list);
+        for (const sub of inv.subInvocations)
+            walk(sub);
+    };
+    for (const inv of invocations)
+        walk(inv);
+    return out;
+}
+/** Contracts whose EVERY recorded call matches their own published interface.
+ *
+ *  All-or-nothing per contract, deliberately. A contract where one call
+ *  verifies and another does not is a contract we do not understand, and
+ *  marking it recognised would raise confidence on the strength of the call
+ *  we happened to check. The unverified call is the one that matters.
+ *
+ *  A contract with no fetchable spec, or a call naming a function absent from
+ *  it, simply stays unknown - this only ever ADDS recognition, so a failure
+ *  here degrades to today's behaviour rather than to a wrong answer. */
+export async function resolveContractsByOnChainSpec(invocations, candidates, fetcher) {
+    const resolved = new Set();
+    const calls = callsByContract(invocations);
+    for (const contract of new Set(candidates)) {
+        const made = calls.get(contract);
+        if (!made || made.length === 0)
+            continue;
+        const abi = await fetchContractAbi(contract, fetcher);
+        if (abi === null)
+            continue;
+        const everyCallVerifies = made.every((c) => {
+            const entry = abi[c.fn];
+            return entry !== undefined && argsMatchAbi(entry.args, c.args);
+        });
+        if (everyCallVerifies)
+            resolved.add(contract);
+    }
+    return resolved;
+}

package/dist/run/index.d.ts

@@ -1,14 +1,15 @@
 import { type ErrorCode, type PredicateNode, type ProposedPolicy, type RecordedTransaction, type ToolError, type ToolResponse } from '../index.ts';
+import { type AuthorityOverlap } from '../install/authority-overlap.ts';
 import { type BuildInstallPolicyResult, type BuildRevokePolicyResult } from '../install/build-install-policy.ts';
 import { getInterpreterInfo } from '../install/get-interpreter-info.ts';
 import { type RecordTransactionInput, type SimulatePolicyInput, type SynthesizePolicyInput, type VerifyPolicyInput } from './schemas.ts';
-export type { GetInterpreterInfoInput, InstallPolicyInput, RecordTransactionInput, RevokePolicyInput, SimulatePolicyInput, SynthesizePolicyInput, VerifyPolicyInput, } from './schemas.ts';
-export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MAINNET_RPC_URL, NetworkSchema, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_MAINNET_ADDRESS, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SynthesizePolicyInputSchema, TESTNET_RPC_URL, ToolErrorSchema, } from './schemas.ts';
+export type { DeclarePolicyInput, GetInterpreterInfoInput, InstallPolicyInput, RecordTransactionInput, RevokePolicyInput, SimulatePolicyInput, SynthesizePolicyInput, VerifyPolicyInput, } from './schemas.ts';
+export { ComposeUserResponsesSchema, DeclarePolicyInputSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MAINNET_RPC_URL, NetworkSchema, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_MAINNET_ADDRESS, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SynthesizePolicyInputSchema, TESTNET_RPC_URL, ToolErrorSchema, } from './schemas.ts';
 export type RunRecordTransactionInput = RecordTransactionInput;
 export type RunSynthesizePolicyInput = SynthesizePolicyInput;
 export type RunSimulatePolicyInput = SimulatePolicyInput;
 export type RunVerifyPolicyInput = VerifyPolicyInput;
-type RunToolName = 'record_transaction' | 'synthesize_policy' | 'simulate_policy' | 'verify_policy' | 'install_policy' | 'revoke_policy' | 'get_interpreter_info';
+type RunToolName = 'record_transaction' | 'synthesize_policy' | 'declare_policy' | 'simulate_policy' | 'verify_policy' | 'install_policy' | 'revoke_policy' | 'get_interpreter_info';
 /** `record_transaction` body - wraps `recordTransaction`. The tool input
  *  matches the core RecordInput minus the injected `fetcher` (the transport
  *  layer does not own the RPC). Returns the core ToolResponse unchanged.
@@ -37,7 +38,9 @@ export declare function runSynthesizePolicy(raw: unknown): Promise<ToolResponse<
         predicateTree: PredicateNode | null;
     };
 }>;
-export declare function runInstallPolicy(raw: unknown): Promise<ToolResponse<BuildInstallPolicyResult>>;
+export declare function runInstallPolicy(raw: unknown): Promise<ToolResponse<BuildInstallPolicyResult & {
+    authorityScan: AuthorityOverlap[] | null;
+}>>;
 /** `revoke_policy` body - thin wrapper over `buildRevokePolicyXdr`.
  *  Emits an unsigned XDR for `account.remove_context_rule(ruleId)`; the
  *  smart account itself handles uninstalling each attached policy. Auth
@@ -63,6 +66,24 @@ export declare function runSimulatePolicy(raw: unknown): ToolResponse<{
         argCount: number;
     };
 }>;
+/** `declare_policy` body - the DECLARATIVE front-end.
+ *
+ *  `synthesize_policy` infers a predicate from a transaction that happened;
+ *  this takes the constraint stated outright. No RPC, no decoding and no
+ *  parseConfidence, so nothing here can be refused for a contract the registry
+ *  does not recognise - which is most of the point of having it.
+ *
+ *  The returned `warnings` are load-bearing, not decoration. An argument index
+ *  the caller did not supply is DEFAULTED to the SEP-41 position, and a bound
+ *  on the wrong argument constrains something the caller did not mean without
+ *  ever announcing itself, so a caller that ignores warnings can install a
+ *  predicate that reads correctly and binds nothing. */
+export declare function runDeclarePolicy(raw: unknown): ToolResponse<{
+    predicate: PredicateNode;
+    encodedPredicate: string;
+    predicateHash: string;
+    warnings: string[];
+}>;
 /** `verify_policy` body - the permit case plus a generated deny case per
  *  dimension.
  *

package/dist/run/index.js

@@ -18,22 +18,25 @@
 // drive the CLI (which calls into the same core directly without MCP).
 import { createHash } from 'node:crypto';
 import { rpc } from '@stellar/stellar-sdk';
-import { recordTransaction, synthesizeFromRecording, } from "../index.js";
+import { declarePredicate, encodePredicate, recordTransaction, synthesizeFromRecording, } from "../index.js";
+import { findAuthorityOverlaps, } from "../install/authority-overlap.js";
 import { buildInstallPolicyXdr, buildRevokePolicyXdr, rpcClientFromServer, } from "../install/build-install-policy.js";
 import { getInterpreterInfo } from "../install/get-interpreter-info.js";
+import { decodePredicate } from "../predicate/decode.js";
 import { evaluate, generateCases } from "../simulate/index.js";
-import { GetInterpreterInfoInputSchema, InstallPolicyInputSchema, NETWORK_PASSPHRASES, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_WASM_SHA256, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, VerifyPolicyInputSchema, } from "./schemas.js";
+import { DeclarePolicyInputSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, NETWORK_PASSPHRASES, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_WASM_SHA256, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, VerifyPolicyInputSchema, } from "./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
 // module that owns the tool-body glue. The strict schemas are the source of
 // truth - MCP tool shapes are derived from them.
-export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MAINNET_RPC_URL, NetworkSchema, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_MAINNET_ADDRESS, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SynthesizePolicyInputSchema, TESTNET_RPC_URL, ToolErrorSchema, } from "./schemas.js";
+export { ComposeUserResponsesSchema, DeclarePolicyInputSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MAINNET_RPC_URL, NetworkSchema, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_MAINNET_ADDRESS, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SynthesizePolicyInputSchema, TESTNET_RPC_URL, ToolErrorSchema, } from "./schemas.js";
 /** 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. */
 const TOOL_ERROR_CODE = {
     record_transaction: 'RECORDING_FAILED',
     synthesize_policy: 'SYNTHESIS_ERROR',
+    declare_policy: 'SYNTHESIS_ERROR',
     simulate_policy: 'SIMULATION_ERROR',
     verify_policy: 'VERIFICATION_FAILED',
     install_policy: 'INSTALL_BUILD_FAILED',
@@ -148,7 +151,27 @@ export async function runInstallPolicy(raw) {
             rpc: rpcClient,
             ...(input.baseFee !== undefined ? { baseFee: input.baseFee } : {}),
         });
-        return { ok: true, data: result };
+        // 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
+            ? null
+            : findAuthorityOverlaps({
+                intended: {
+                    // `add_context_rule` gets its id FROM the account, so there is
+                    // no existing rule this install replaces. A sentinel no real id
+                    // can equal keeps every observed rule in scope.
+                    ruleId: -1,
+                    contextType: input.rule.contextRuleType,
+                    signers: input.rule.signers,
+                    predicate: decodePredicate(encodedPredicate),
+                },
+                // The schema types `predicate` loosely (it is the shared
+                // PredicateNodeSchema); the shape is already validated.
+                existing: input.existingRules,
+            });
+        return { ok: true, data: { ...result, authorityScan } };
     }
     catch (e) {
         return toolFailure('install_policy', e);
@@ -267,6 +290,44 @@ export function runSimulatePolicy(raw) {
         return toolFailure('simulate_policy', e);
     }
 }
+/** `declare_policy` body - the DECLARATIVE front-end.
+ *
+ *  `synthesize_policy` infers a predicate from a transaction that happened;
+ *  this takes the constraint stated outright. No RPC, no decoding and no
+ *  parseConfidence, so nothing here can be refused for a contract the registry
+ *  does not recognise - which is most of the point of having it.
+ *
+ *  The returned `warnings` are load-bearing, not decoration. An argument index
+ *  the caller did not supply is DEFAULTED to the SEP-41 position, and a bound
+ *  on the wrong argument constrains something the caller did not mean without
+ *  ever announcing itself, so a caller that ignores warnings can install a
+ *  predicate that reads correctly and binds nothing. */
+export function runDeclarePolicy(raw) {
+    const parsed = DeclarePolicyInputSchema.safeParse(raw);
+    if (!parsed.success) {
+        return { ok: false, error: validationError('declare_policy', parsed.error.issues) };
+    }
+    try {
+        // Rebuilt field-by-field rather than passed through: the schema's
+        // optionals are `T | undefined` and `PolicyDeclaration`'s are absent-or-T,
+        // which `exactOptionalPropertyTypes` treats as different.
+        const d = parsed.data;
+        const { predicate, warnings } = declarePredicate({
+            fn: d.fn,
+            ...(d.contract !== undefined ? { contract: d.contract } : {}),
+            ...(d.maxAmount !== undefined ? { maxAmount: d.maxAmount } : {}),
+            ...(d.amountArgIndex !== undefined ? { amountArgIndex: d.amountArgIndex } : {}),
+            ...(d.recipients !== undefined ? { recipients: d.recipients } : {}),
+            ...(d.recipientArgIndex !== undefined ? { recipientArgIndex: d.recipientArgIndex } : {}),
+            ...(d.allowZeroCap !== undefined ? { allowZeroCap: d.allowZeroCap } : {}),
+        });
+        const { encodedPredicate, predicateHash } = encodePredicate(predicate);
+        return { ok: true, data: { predicate, encodedPredicate, predicateHash, warnings } };
+    }
+    catch (e) {
+        return toolFailure('declare_policy', e);
+    }
+}
 /** `verify_policy` body - the permit case plus a generated deny case per
  *  dimension.
  *

package/dist/run/schemas.d.ts

@@ -1494,6 +1494,104 @@ export declare const VerifyPolicyInputSchema: z.ZodObject<{
     predicate?: unknown;
 }>;
 export type VerifyPolicyInput = z.infer<typeof VerifyPolicyInputSchema>;
+/** A rule ALREADY on the account, as the caller observed it. Supplying these
+ *  turns on the cross-rule authority scan: a signer belonging to several rules
+ *  picks which one applies, so a predicate only constrains a key when the
+ *  policed rule is the only rule that key is on. */
+export declare const ObservedRuleSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    contextType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"default">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "default";
+    }, {
+        kind: "default";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"call_contract">;
+        contract: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "call_contract";
+        contract: string;
+    }, {
+        kind: "call_contract";
+        contract: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"create_contract">;
+        wasmHash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "create_contract";
+        wasmHash: string;
+    }, {
+        kind: "create_contract";
+        wasmHash: string;
+    }>]>;
+    signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"delegated">;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        kind: "delegated";
+    }, {
+        address: string;
+        kind: "delegated";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        verifier: z.ZodString;
+        keyBytes: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "external";
+        verifier: string;
+        keyBytes: string;
+    }, {
+        kind: "external";
+        verifier: string;
+        keyBytes: string;
+    }>]>, "many">;
+    policyAddresses: z.ZodArray<z.ZodString, "many">;
+    predicate: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+}, "strip", z.ZodTypeAny, {
+    signers: ({
+        address: string;
+        kind: "delegated";
+    } | {
+        kind: "external";
+        verifier: string;
+        keyBytes: string;
+    })[];
+    id: number;
+    contextType: {
+        kind: "default";
+    } | {
+        kind: "call_contract";
+        contract: string;
+    } | {
+        kind: "create_contract";
+        wasmHash: string;
+    };
+    policyAddresses: string[];
+    predicate?: unknown;
+}, {
+    signers: ({
+        address: string;
+        kind: "delegated";
+    } | {
+        kind: "external";
+        verifier: string;
+        keyBytes: string;
+    })[];
+    id: number;
+    contextType: {
+        kind: "default";
+    } | {
+        kind: "call_contract";
+        contract: string;
+    } | {
+        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";
@@ -1533,7 +1631,134 @@ export declare const RPC_URL_BY_NETWORK: Record<Network, string>;
  *  matching passphrase when the wallet signs (a mismatch yields invalid
  *  hashes). */
 export declare const NETWORK_PASSPHRASES: Record<Network, string>;
+export declare const DeclarePolicyInputSchema: z.ZodObject<{
+    fn: z.ZodString;
+    contract: z.ZodOptional<z.ZodString>;
+    /** Smallest unit, unsigned decimal STRING - an i128 is wider than
+     *  Number.MAX_SAFE_INTEGER, so a number here would silently round. */
+    maxAmount: z.ZodOptional<z.ZodString>;
+    amountArgIndex: z.ZodOptional<z.ZodNumber>;
+    recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    recipientArgIndex: z.ZodOptional<z.ZodNumber>;
+    allowZeroCap: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    fn: string;
+    contract?: string | undefined;
+    maxAmount?: string | undefined;
+    amountArgIndex?: number | undefined;
+    recipients?: string[] | undefined;
+    recipientArgIndex?: number | undefined;
+    allowZeroCap?: boolean | undefined;
+}, {
+    fn: string;
+    contract?: string | undefined;
+    maxAmount?: string | undefined;
+    amountArgIndex?: number | undefined;
+    recipients?: string[] | undefined;
+    recipientArgIndex?: number | undefined;
+    allowZeroCap?: boolean | undefined;
+}>;
+export type DeclarePolicyInput = z.infer<typeof DeclarePolicyInputSchema>;
 export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
+    /** Rules already on the account. Supplying them turns on the cross-rule
+     *  authority scan, which reports every existing rule a signer of this
+     *  install could name INSTEAD - including an unpoliced one, against which
+     *  the predicate never runs. Absent means the scan is skipped, and the
+     *  result says so rather than reporting "no overlaps found". */
+    existingRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        contextType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "default";
+        }, {
+            kind: "default";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"call_contract">;
+            contract: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "call_contract";
+            contract: string;
+        }, {
+            kind: "call_contract";
+            contract: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"create_contract">;
+            wasmHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "create_contract";
+            wasmHash: string;
+        }, {
+            kind: "create_contract";
+            wasmHash: string;
+        }>]>;
+        signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"delegated">;
+            address: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            kind: "delegated";
+        }, {
+            address: string;
+            kind: "delegated";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }>]>, "many">;
+        policyAddresses: z.ZodArray<z.ZodString, "many">;
+        predicate: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+    }, "strip", z.ZodTypeAny, {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        policyAddresses: string[];
+        predicate?: unknown;
+    }, {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        policyAddresses: string[];
+        predicate?: unknown;
+    }>, "many">>;
     /** The smart account contract address (C...) that will receive the rule. */
     smartAccount: z.ZodString;
     /** The signer that authorises the install (G... wallet). Used only for
@@ -1918,6 +2143,28 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
         [k: string]: unknown;
     };
     network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        policyAddresses: string[];
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -1955,6 +2202,28 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
         [k: string]: unknown;
     };
     network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        policyAddresses: string[];
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -1992,6 +2261,28 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
         [k: string]: unknown;
     };
     network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        policyAddresses: string[];
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -2029,6 +2320,28 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
         [k: string]: unknown;
     };
     network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        policyAddresses: string[];
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;