@hazbase/simplicity 0.0.5 → 0.2.0

package/dist/domain/policies.d.ts

@@ -0,0 +1,1064 @@
+import type { SimplicityClient } from "../client/SimplicityClient";
+import type { BondOutputBindingMode, OutputRawFields, PolicyOutputAmountForm, PolicyOutputAssetForm, PolicyEvidenceBundle, PolicyEvidenceBundleSchemaVersion, PolicyOutputBindingReasonCode, PolicyOutputBindingSupportedForm, PolicyOutputDescriptor, PolicyOutputNonceForm, PolicyReceiver, PolicyOutputRangeProofForm, PolicyState, PolicyTemplateDocument, PolicyTemplateManifest, PolicyTemplateManifestValidationResult, PolicyTemplateManifestVersion, PolicyTemplateInput, PolicyTransferDescriptor, PolicyVerificationReportSchemaVersion, PropagationMode, SimplicityArtifact } from "../core/types";
+export declare const POLICY_TEMPLATE_MANIFEST_SCHEMA_VERSION: PolicyTemplateManifestVersion;
+export declare const POLICY_VERIFICATION_REPORT_SCHEMA_VERSION: PolicyVerificationReportSchemaVersion;
+export declare const POLICY_EVIDENCE_BUNDLE_SCHEMA_VERSION: PolicyEvidenceBundleSchemaVersion;
+export declare function listPolicyTemplates(): PolicyTemplateManifest[];
+export declare function describePolicyTemplate(input: {
+    templateId: string;
+    propagationMode?: PropagationMode;
+}): PolicyTemplateManifest;
+export declare function validatePolicyTemplateManifest(input: {
+    manifestValue: unknown;
+}): PolicyTemplateManifestValidationResult;
+export declare function loadPolicyTemplateManifest(input: {
+    templateId?: string;
+    propagationMode?: PropagationMode;
+    manifestPath?: string;
+    manifestValue?: unknown;
+}): Promise<PolicyTemplateManifest>;
+export declare function validatePolicyTemplateParams(input: {
+    templateId?: string;
+    manifestValue?: PolicyTemplateManifest;
+    params?: Record<string, string | number | boolean>;
+    propagationMode?: PropagationMode;
+}): Record<string, string | number | boolean>;
+export declare function summarizePolicyState(state: PolicyState): {
+    canonicalJson: string;
+    hash: string;
+};
+export declare function validatePolicyState(state: PolicyState): PolicyState;
+export declare function summarizePolicyOutputDescriptor(descriptor: PolicyOutputDescriptor): {
+    canonicalJson: string;
+    hash: string;
+};
+export declare function validatePolicyOutputDescriptor(descriptor: PolicyOutputDescriptor): PolicyOutputDescriptor;
+export declare function summarizePolicyTransferDescriptor(descriptor: PolicyTransferDescriptor): {
+    canonicalJson: string;
+    hash: string;
+};
+export declare function validatePolicyTransferDescriptor(descriptor: PolicyTransferDescriptor): PolicyTransferDescriptor;
+export declare function compilePolicyStateContract(sdk: SimplicityClient, input: {
+    template: PolicyTemplateInput;
+    stateValue: PolicyState;
+    artifactPath?: string;
+}): Promise<import("..").CompiledContract>;
+export declare function issue(sdk: SimplicityClient, input: {
+    recipient: PolicyReceiver;
+    template: PolicyTemplateInput;
+    params?: Record<string, string | number | boolean>;
+    amountSat: number;
+    assetId: string;
+    propagationMode?: PropagationMode;
+    artifactPath?: string;
+}): Promise<{
+    compiled: import("..").CompiledContract;
+    state: PolicyState;
+    policyTemplate: PolicyTemplateDocument;
+    policyHash: string;
+}>;
+export declare function verifyState(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    template?: PolicyTemplateInput;
+    statePath?: string;
+    stateValue?: PolicyState;
+}): Promise<{
+    ok: boolean;
+    reason: string | undefined;
+    artifact: SimplicityArtifact;
+    template: import("../core/types").DefinitionVerificationResult;
+    state: import("../core/types").StateVerificationResult;
+    stateValue: PolicyState;
+    policyHashMatches: boolean;
+    report: {
+        schemaVersion: "policy-verification-report/v1";
+        templateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        stateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        propagationMode: PropagationMode;
+        nextPolicyRequired: boolean;
+        nextPolicyPresent: false;
+        plainExitAllowed: boolean;
+        enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+    };
+    trustSummary: import("../core/types").VerificationTrustSummary;
+}>;
+export declare function buildPolicyOutputDescriptor(sdk: SimplicityClient, input: {
+    nextCompiledContractAddress: string;
+    nextAmountSat: number;
+    assetId: string;
+    maxFeeSat?: number;
+    nextOutputIndex?: number;
+    feeIndex?: number;
+    nextOutputHash?: string;
+    outputForm?: {
+        assetForm?: PolicyOutputAssetForm;
+        amountForm?: PolicyOutputAmountForm;
+        nonceForm?: PolicyOutputNonceForm;
+        rangeProofForm?: PolicyOutputRangeProofForm;
+    };
+    rawOutput?: Partial<OutputRawFields>;
+    outputBindingMode?: BondOutputBindingMode;
+}): Promise<{
+    descriptor: PolicyOutputDescriptor;
+    summary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    supportedForm: import("../core/types").OutputBindingSupportedForm;
+    autoDerivedNextOutputHash: boolean;
+    reasonCode: import("../core/types").OutputBindingReasonCode;
+    fallbackReason: string | undefined;
+    bindingInputs: {
+        rawOutputComponents?: {
+            scriptPubKey: "raw-bytes" | "hash";
+            rangeProof: "raw-bytes" | "hash";
+        } | undefined;
+        assetId: string;
+        assetForm: import("../core/types").OutputAssetForm;
+        amountForm: import("../core/types").OutputAmountForm;
+        nonceForm: import("../core/types").OutputNonceForm;
+        rangeProofForm: import("../core/types").OutputRangeProofForm;
+        nextAmountSat: number;
+        nextOutputIndex: number;
+        feeIndex: number;
+        maxFeeSat: number;
+    };
+}>;
+export declare function prepareTransfer(sdk: SimplicityClient, input: {
+    currentArtifactPath?: string;
+    currentArtifact?: SimplicityArtifact;
+    template: PolicyTemplateInput;
+    currentStatePath?: string;
+    currentStateValue?: PolicyState;
+    nextReceiver: PolicyReceiver;
+    nextAmountSat: number;
+    nextParams?: Record<string, string | number | boolean>;
+    propagationMode?: PropagationMode;
+    nextArtifactPath?: string;
+    machineArtifactPath?: string;
+    nextOutputHash?: string;
+    nextOutputForm?: {
+        assetForm?: PolicyOutputAssetForm;
+        amountForm?: PolicyOutputAmountForm;
+        nonceForm?: PolicyOutputNonceForm;
+        rangeProofForm?: PolicyOutputRangeProofForm;
+    };
+    nextRawOutput?: Partial<OutputRawFields>;
+    outputBindingMode?: BondOutputBindingMode;
+}): Promise<{
+    current: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact;
+        template: import("../core/types").DefinitionVerificationResult;
+        state: import("../core/types").StateVerificationResult;
+        stateValue: PolicyState;
+        policyHashMatches: boolean;
+        report: {
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+            nextPolicyPresent: false;
+            plainExitAllowed: boolean;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        };
+        trustSummary: import("../core/types").VerificationTrustSummary;
+    };
+    nextState: null;
+    nextCompiled: null;
+    machineArtifact: null;
+    transferDescriptor: PolicyTransferDescriptor;
+    transferSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    verificationReport: {
+        nextPolicyPresent: false;
+        plainExitAllowed: true;
+        enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        schemaVersion: "policy-verification-report/v1";
+        templateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        stateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        propagationMode: PropagationMode;
+        nextPolicyRequired: boolean;
+    };
+} | {
+    current: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact;
+        template: import("../core/types").DefinitionVerificationResult;
+        state: import("../core/types").StateVerificationResult;
+        stateValue: PolicyState;
+        policyHashMatches: boolean;
+        report: {
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+            nextPolicyPresent: false;
+            plainExitAllowed: boolean;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        };
+        trustSummary: import("../core/types").VerificationTrustSummary;
+    };
+    nextState: PolicyState;
+    nextCompiled: import("..").CompiledContract;
+    machineArtifact: null;
+    transferDescriptor: PolicyTransferDescriptor;
+    transferSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    verificationReport: {
+        nextPolicyPresent: true;
+        outputBinding: {
+            mode: BondOutputBindingMode;
+            supportedForm: PolicyOutputBindingSupportedForm;
+            committed: boolean;
+            runtimeBound: boolean;
+            sdkVerified: boolean;
+            amountRuntimeBound: boolean;
+            nextOutputHashRuntimeBound: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            reasonCode: PolicyOutputBindingReasonCode;
+            nextOutputHash?: string;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: import("../core/types").OutputBindingInputs;
+        } | undefined;
+        enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        schemaVersion: "policy-verification-report/v1";
+        templateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        stateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        propagationMode: PropagationMode;
+        nextPolicyRequired: boolean;
+        plainExitAllowed: boolean;
+    };
+}>;
+export declare function prepareDirectTransfer(sdk: SimplicityClient, input: {
+    currentArtifactPath?: string;
+    currentArtifact?: SimplicityArtifact;
+    template: PolicyTemplateInput;
+    currentStatePath?: string;
+    currentStateValue?: PolicyState;
+    nextReceiver: PolicyReceiver;
+    nextAmountSat: number;
+    nextParams?: Record<string, string | number | boolean>;
+    propagationMode?: PropagationMode;
+    nextArtifactPath?: string;
+    nextOutputHash?: string;
+    nextOutputForm?: {
+        assetForm?: PolicyOutputAssetForm;
+        amountForm?: PolicyOutputAmountForm;
+        nonceForm?: PolicyOutputNonceForm;
+        rangeProofForm?: PolicyOutputRangeProofForm;
+    };
+    nextRawOutput?: Partial<OutputRawFields>;
+    outputBindingMode?: BondOutputBindingMode;
+}): Promise<{
+    current: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact;
+        template: import("../core/types").DefinitionVerificationResult;
+        state: import("../core/types").StateVerificationResult;
+        stateValue: PolicyState;
+        policyHashMatches: boolean;
+        report: {
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+            nextPolicyPresent: false;
+            plainExitAllowed: boolean;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        };
+        trustSummary: import("../core/types").VerificationTrustSummary;
+    };
+    nextState: PolicyState;
+    nextCompiled: import("..").CompiledContract;
+    machineArtifact: null;
+    transferDescriptor: PolicyTransferDescriptor;
+    transferSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    verificationReport: {
+        nextPolicyPresent: true;
+        plainExitAllowed: false;
+        outputBinding: {
+            mode: BondOutputBindingMode;
+            supportedForm: PolicyOutputBindingSupportedForm;
+            committed: boolean;
+            runtimeBound: boolean;
+            sdkVerified: boolean;
+            amountRuntimeBound: boolean;
+            nextOutputHashRuntimeBound: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            reasonCode: PolicyOutputBindingReasonCode;
+            nextOutputHash?: string;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: import("../core/types").OutputBindingInputs;
+        } | undefined;
+        enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        schemaVersion: "policy-verification-report/v1";
+        templateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        stateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        propagationMode: PropagationMode;
+        nextPolicyRequired: boolean;
+    };
+}>;
+export declare function verifyDirectTransfer(sdk: SimplicityClient, input: {
+    template: PolicyTemplateInput;
+    currentArtifactPath?: string;
+    currentArtifact?: SimplicityArtifact;
+    currentStatePath?: string;
+    currentStateValue?: PolicyState;
+    transferDescriptorValue?: PolicyTransferDescriptor;
+    nextStatePath?: string;
+    nextStateValue?: PolicyState;
+}): Promise<{
+    ok: boolean;
+    reason: string | undefined;
+    current: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact;
+        template: import("../core/types").DefinitionVerificationResult;
+        state: import("../core/types").StateVerificationResult;
+        stateValue: PolicyState;
+        policyHashMatches: boolean;
+        report: {
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+            nextPolicyPresent: false;
+            plainExitAllowed: boolean;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        };
+        trustSummary: import("../core/types").VerificationTrustSummary;
+    };
+    transfer: PolicyTransferDescriptor | undefined;
+    transferSummary: {
+        canonicalJson: string;
+        hash: string;
+    } | undefined;
+    nextState: PolicyState | undefined;
+    verificationReport: {
+        nextPolicyPresent: boolean;
+        plainExitAllowed: false;
+        outputBinding: {
+            mode: BondOutputBindingMode;
+            supportedForm: PolicyOutputBindingSupportedForm;
+            committed: boolean;
+            runtimeBound: boolean;
+            sdkVerified: boolean;
+            amountRuntimeBound: boolean;
+            nextOutputHashRuntimeBound: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            reasonCode: PolicyOutputBindingReasonCode;
+            nextOutputHash?: string;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: import("../core/types").OutputBindingInputs;
+        } | undefined;
+        enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        schemaVersion: "policy-verification-report/v1";
+        templateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        stateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        propagationMode: PropagationMode;
+        nextPolicyRequired: boolean;
+    };
+}>;
+export declare function inspectDirectTransfer(sdk: SimplicityClient, input: Parameters<typeof executeDirectTransfer>[1]): Promise<{
+    mode: "direct-hop";
+    prepared: {
+        current: {
+            ok: boolean;
+            reason: string | undefined;
+            artifact: SimplicityArtifact;
+            template: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+            stateValue: PolicyState;
+            policyHashMatches: boolean;
+            report: {
+                schemaVersion: "policy-verification-report/v1";
+                templateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                stateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                propagationMode: PropagationMode;
+                nextPolicyRequired: boolean;
+                nextPolicyPresent: false;
+                plainExitAllowed: boolean;
+                enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            };
+            trustSummary: import("../core/types").VerificationTrustSummary;
+        };
+        nextState: PolicyState;
+        nextCompiled: import("..").CompiledContract;
+        machineArtifact: null;
+        transferDescriptor: PolicyTransferDescriptor;
+        transferSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        verificationReport: {
+            nextPolicyPresent: true;
+            plainExitAllowed: false;
+            outputBinding: {
+                mode: BondOutputBindingMode;
+                supportedForm: PolicyOutputBindingSupportedForm;
+                committed: boolean;
+                runtimeBound: boolean;
+                sdkVerified: boolean;
+                amountRuntimeBound: boolean;
+                nextOutputHashRuntimeBound: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                reasonCode: PolicyOutputBindingReasonCode;
+                nextOutputHash?: string;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: import("../core/types").OutputBindingInputs;
+            } | undefined;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+        };
+    };
+    inspect: import("../core/types").InspectResult;
+}>;
+export declare function executeDirectTransfer(sdk: SimplicityClient, input: {
+    currentArtifactPath?: string;
+    currentArtifact?: SimplicityArtifact;
+    template: PolicyTemplateInput;
+    currentStatePath?: string;
+    currentStateValue?: PolicyState;
+    nextReceiver: PolicyReceiver;
+    nextAmountSat: number;
+    nextParams?: Record<string, string | number | boolean>;
+    propagationMode?: PropagationMode;
+    nextArtifactPath?: string;
+    nextOutputHash?: string;
+    nextOutputForm?: {
+        assetForm?: PolicyOutputAssetForm;
+        amountForm?: PolicyOutputAmountForm;
+        nonceForm?: PolicyOutputNonceForm;
+        rangeProofForm?: PolicyOutputRangeProofForm;
+    };
+    nextRawOutput?: Partial<OutputRawFields>;
+    outputBindingMode?: BondOutputBindingMode;
+    wallet: string;
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    broadcast?: boolean;
+    feeSat?: number;
+    utxoPolicy?: "smallest_over" | "largest" | "newest";
+}): Promise<{
+    mode: "direct-hop";
+    prepared: {
+        current: {
+            ok: boolean;
+            reason: string | undefined;
+            artifact: SimplicityArtifact;
+            template: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+            stateValue: PolicyState;
+            policyHashMatches: boolean;
+            report: {
+                schemaVersion: "policy-verification-report/v1";
+                templateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                stateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                propagationMode: PropagationMode;
+                nextPolicyRequired: boolean;
+                nextPolicyPresent: false;
+                plainExitAllowed: boolean;
+                enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            };
+            trustSummary: import("../core/types").VerificationTrustSummary;
+        };
+        nextState: PolicyState;
+        nextCompiled: import("..").CompiledContract;
+        machineArtifact: null;
+        transferDescriptor: PolicyTransferDescriptor;
+        transferSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        verificationReport: {
+            nextPolicyPresent: true;
+            plainExitAllowed: false;
+            outputBinding: {
+                mode: BondOutputBindingMode;
+                supportedForm: PolicyOutputBindingSupportedForm;
+                committed: boolean;
+                runtimeBound: boolean;
+                sdkVerified: boolean;
+                amountRuntimeBound: boolean;
+                nextOutputHashRuntimeBound: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                reasonCode: PolicyOutputBindingReasonCode;
+                nextOutputHash?: string;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: import("../core/types").OutputBindingInputs;
+            } | undefined;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+        };
+    };
+    execution: import("../core/types").ExecuteResult;
+}>;
+export declare function verifyTransfer(sdk: SimplicityClient, input: {
+    template: PolicyTemplateInput;
+    currentArtifactPath?: string;
+    currentArtifact?: SimplicityArtifact;
+    currentStatePath?: string;
+    currentStateValue?: PolicyState;
+    transferDescriptorValue?: PolicyTransferDescriptor;
+    nextStatePath?: string;
+    nextStateValue?: PolicyState;
+}): Promise<{
+    ok: boolean;
+    reason: string | undefined;
+    current: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact;
+        template: import("../core/types").DefinitionVerificationResult;
+        state: import("../core/types").StateVerificationResult;
+        stateValue: PolicyState;
+        policyHashMatches: boolean;
+        report: {
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+            nextPolicyPresent: false;
+            plainExitAllowed: boolean;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        };
+        trustSummary: import("../core/types").VerificationTrustSummary;
+    };
+    transfer: PolicyTransferDescriptor | undefined;
+    transferSummary: {
+        canonicalJson: string;
+        hash: string;
+    } | undefined;
+    nextState: PolicyState | undefined;
+    verificationReport: {
+        nextPolicyPresent: boolean;
+        plainExitAllowed: boolean;
+        outputBinding: {
+            mode: BondOutputBindingMode;
+            supportedForm: PolicyOutputBindingSupportedForm;
+            committed: boolean;
+            runtimeBound: boolean;
+            sdkVerified: boolean;
+            amountRuntimeBound: boolean;
+            nextOutputHashRuntimeBound: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            reasonCode: PolicyOutputBindingReasonCode;
+            nextOutputHash?: string;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: import("../core/types").OutputBindingInputs;
+        } | undefined;
+        enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+        schemaVersion: "policy-verification-report/v1";
+        templateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        stateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+        propagationMode: PropagationMode;
+        nextPolicyRequired: boolean;
+    };
+    trustSummary: import("../core/types").VerificationTrustSummary;
+}>;
+export declare function inspectTransfer(sdk: SimplicityClient, input: Parameters<typeof executeTransfer>[1] & {
+    utxoPolicy?: "smallest_over" | "largest" | "newest";
+}): Promise<{
+    mode: "plain-exit";
+    prepared: {
+        current: {
+            ok: boolean;
+            reason: string | undefined;
+            artifact: SimplicityArtifact;
+            template: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+            stateValue: PolicyState;
+            policyHashMatches: boolean;
+            report: {
+                schemaVersion: "policy-verification-report/v1";
+                templateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                stateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                propagationMode: PropagationMode;
+                nextPolicyRequired: boolean;
+                nextPolicyPresent: false;
+                plainExitAllowed: boolean;
+                enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            };
+            trustSummary: import("../core/types").VerificationTrustSummary;
+        };
+        nextState: null;
+        nextCompiled: null;
+        machineArtifact: null;
+        transferDescriptor: PolicyTransferDescriptor;
+        transferSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        verificationReport: {
+            nextPolicyPresent: false;
+            plainExitAllowed: true;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+        };
+    };
+    inspect: import("../core/types").InspectResult;
+} | {
+    mode: "sdk-path" | "conditional-hop" | "direct-hop";
+    prepared: {
+        current: {
+            ok: boolean;
+            reason: string | undefined;
+            artifact: SimplicityArtifact;
+            template: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+            stateValue: PolicyState;
+            policyHashMatches: boolean;
+            report: {
+                schemaVersion: "policy-verification-report/v1";
+                templateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                stateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                propagationMode: PropagationMode;
+                nextPolicyRequired: boolean;
+                nextPolicyPresent: false;
+                plainExitAllowed: boolean;
+                enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            };
+            trustSummary: import("../core/types").VerificationTrustSummary;
+        };
+        nextState: PolicyState;
+        nextCompiled: import("..").CompiledContract;
+        machineArtifact: null;
+        transferDescriptor: PolicyTransferDescriptor;
+        transferSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        verificationReport: {
+            nextPolicyPresent: true;
+            outputBinding: {
+                mode: BondOutputBindingMode;
+                supportedForm: PolicyOutputBindingSupportedForm;
+                committed: boolean;
+                runtimeBound: boolean;
+                sdkVerified: boolean;
+                amountRuntimeBound: boolean;
+                nextOutputHashRuntimeBound: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                reasonCode: PolicyOutputBindingReasonCode;
+                nextOutputHash?: string;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: import("../core/types").OutputBindingInputs;
+            } | undefined;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+            plainExitAllowed: boolean;
+        };
+    };
+    inspect: import("../core/types").InspectResult;
+}>;
+export declare function executeTransfer(sdk: SimplicityClient, input: {
+    currentArtifactPath?: string;
+    currentArtifact?: SimplicityArtifact;
+    template: PolicyTemplateInput;
+    currentStatePath?: string;
+    currentStateValue?: PolicyState;
+    nextReceiver: PolicyReceiver;
+    nextAmountSat: number;
+    nextParams?: Record<string, string | number | boolean>;
+    propagationMode?: PropagationMode;
+    nextArtifactPath?: string;
+    nextOutputHash?: string;
+    nextOutputForm?: {
+        assetForm?: PolicyOutputAssetForm;
+        amountForm?: PolicyOutputAmountForm;
+        nonceForm?: PolicyOutputNonceForm;
+        rangeProofForm?: PolicyOutputRangeProofForm;
+    };
+    nextRawOutput?: Partial<OutputRawFields>;
+    outputBindingMode?: BondOutputBindingMode;
+    wallet: string;
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    broadcast?: boolean;
+    feeSat?: number;
+    utxoPolicy?: "smallest_over" | "largest" | "newest";
+}): Promise<{
+    mode: "plain-exit";
+    prepared: {
+        current: {
+            ok: boolean;
+            reason: string | undefined;
+            artifact: SimplicityArtifact;
+            template: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+            stateValue: PolicyState;
+            policyHashMatches: boolean;
+            report: {
+                schemaVersion: "policy-verification-report/v1";
+                templateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                stateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                propagationMode: PropagationMode;
+                nextPolicyRequired: boolean;
+                nextPolicyPresent: false;
+                plainExitAllowed: boolean;
+                enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            };
+            trustSummary: import("../core/types").VerificationTrustSummary;
+        };
+        nextState: null;
+        nextCompiled: null;
+        machineArtifact: null;
+        transferDescriptor: PolicyTransferDescriptor;
+        transferSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        verificationReport: {
+            nextPolicyPresent: false;
+            plainExitAllowed: true;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+        };
+    };
+    execution: import("../core/types").ExecuteResult;
+} | {
+    mode: "sdk-path" | "conditional-hop" | "direct-hop";
+    prepared: {
+        current: {
+            ok: boolean;
+            reason: string | undefined;
+            artifact: SimplicityArtifact;
+            template: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+            stateValue: PolicyState;
+            policyHashMatches: boolean;
+            report: {
+                schemaVersion: "policy-verification-report/v1";
+                templateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                stateTrust: {
+                    artifactMatch: boolean;
+                    onChainAnchorPresent: boolean;
+                    onChainAnchorVerified: boolean;
+                    effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+                };
+                propagationMode: PropagationMode;
+                nextPolicyRequired: boolean;
+                nextPolicyPresent: false;
+                plainExitAllowed: boolean;
+                enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            };
+            trustSummary: import("../core/types").VerificationTrustSummary;
+        };
+        nextState: PolicyState;
+        nextCompiled: import("..").CompiledContract;
+        machineArtifact: null;
+        transferDescriptor: PolicyTransferDescriptor;
+        transferSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        verificationReport: {
+            nextPolicyPresent: true;
+            outputBinding: {
+                mode: BondOutputBindingMode;
+                supportedForm: PolicyOutputBindingSupportedForm;
+                committed: boolean;
+                runtimeBound: boolean;
+                sdkVerified: boolean;
+                amountRuntimeBound: boolean;
+                nextOutputHashRuntimeBound: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                reasonCode: PolicyOutputBindingReasonCode;
+                nextOutputHash?: string;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: import("../core/types").OutputBindingInputs;
+            } | undefined;
+            enforcement: "sdk-path" | "conditional-hop" | "direct-hop";
+            schemaVersion: "policy-verification-report/v1";
+            templateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            stateTrust: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            propagationMode: PropagationMode;
+            nextPolicyRequired: boolean;
+            plainExitAllowed: boolean;
+        };
+    };
+    execution: import("../core/types").ExecuteResult;
+}>;
+export declare function exportEvidence(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    template: PolicyTemplateInput;
+    statePath?: string;
+    stateValue?: PolicyState;
+    transferDescriptorValue?: PolicyTransferDescriptor;
+}): Promise<PolicyEvidenceBundle>;