@crediolabs/policy-synth 0.3.1 → 0.5.0

package/dist-cjs/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-cjs/run/index.js

@@ -18,20 +18,24 @@
 // 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.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.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.DeclarePolicyInputSchema = exports.ComposeUserResponsesSchema = void 0;
 exports.runRecordTransaction = runRecordTransaction;
 exports.runSynthesizePolicy = runSynthesizePolicy;
 exports.runInstallPolicy = runInstallPolicy;
 exports.runRevokePolicy = runRevokePolicy;
 exports.runSimulatePolicy = runSimulatePolicy;
+exports.runDeclarePolicy = runDeclarePolicy;
 exports.runVerifyPolicy = runVerifyPolicy;
 exports.runGetInterpreterInfo = runGetInterpreterInfo;
 exports.caughtError = caughtError;
 const node_crypto_1 = require("node:crypto");
 const stellar_sdk_1 = require("@stellar/stellar-sdk");
 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");
 // Re-export the underlying Zod schemas so the MCP package (and any other
@@ -40,6 +44,7 @@ const schemas_ts_1 = require("./schemas.js");
 // truth - MCP tool shapes are derived from them.
 var schemas_ts_2 = require("./schemas.js");
 Object.defineProperty(exports, "ComposeUserResponsesSchema", { enumerable: true, get: function () { return schemas_ts_2.ComposeUserResponsesSchema; } });
+Object.defineProperty(exports, "DeclarePolicyInputSchema", { enumerable: true, get: function () { return schemas_ts_2.DeclarePolicyInputSchema; } });
 Object.defineProperty(exports, "GetInterpreterInfoInputSchema", { enumerable: true, get: function () { return schemas_ts_2.GetInterpreterInfoInputSchema; } });
 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; } });
@@ -65,6 +70,7 @@ Object.defineProperty(exports, "ToolErrorSchema", { enumerable: true, get: funct
 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',
@@ -179,7 +185,32 @@ async function runInstallPolicy(raw) {
             rpc: rpcClient,
             ...(input.baseFee !== undefined ? { baseFee: input.baseFee } : {}),
         });
-        return { ok: true, data: result };
+        // 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: {
+                    // `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: (0, decode_ts_1.decodePredicate)(encodedPredicate),
+                },
+                existing: observed,
+            });
+        return { ok: true, data: { ...result, authorityScan } };
     }
     catch (e) {
         return toolFailure('install_policy', e);
@@ -298,6 +329,45 @@ 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. */
+function runDeclarePolicy(raw) {
+    const parsed = schemas_ts_1.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 } = (0, index_ts_1.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 } : {}),
+            ...(d.minOutputRatio !== undefined ? { minOutputRatio: d.minOutputRatio } : {}),
+        });
+        const { encodedPredicate, predicateHash } = (0, index_ts_1.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.
  *
@@ -385,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

@@ -1494,25 +1494,123 @@ 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;
+    policyAddresses: string[];
+    contextType: {
+        kind: "default";
+    } | {
+        kind: "call_contract";
+        contract: string;
+    } | {
+        kind: "create_contract";
+        wasmHash: string;
+    };
+    predicate?: unknown;
+}, {
+    signers: ({
+        address: string;
+        kind: "delegated";
+    } | {
+        kind: "external";
+        verifier: string;
+        keyBytes: string;
+    })[];
+    id: number;
+    policyAddresses: string[];
+    contextType: {
+        kind: "default";
+    } | {
+        kind: "call_contract";
+        contract: string;
+    } | {
+        kind: "create_contract";
+        wasmHash: 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
@@ -1533,7 +1631,165 @@ 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>;
+    /** 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;
+    maxAmount?: string | undefined;
+    amountArgIndex?: number | undefined;
+    recipients?: string[] | undefined;
+    recipientArgIndex?: number | undefined;
+    allowZeroCap?: boolean | undefined;
+    minOutputRatio?: {
+        num: string;
+        den: string;
+        inputArgIndex: number;
+        outputArgIndex: number;
+    } | undefined;
+}, {
+    fn: string;
+    contract?: string | undefined;
+    maxAmount?: string | undefined;
+    amountArgIndex?: number | undefined;
+    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<{
+    /** 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;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }, {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: 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 +2174,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;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -1955,6 +2233,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;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -1992,6 +2292,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;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -2029,6 +2351,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;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;