@hazbase/simplicity 0.0.4 → 0.1.1

package/dist/domain/bond.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,7 +39,77 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineBond = defineBond;
 exports.verifyBond = verifyBond;
 exports.loadBond = loadBond;
+exports.buildBondPayload = buildBondPayload;
+exports.summarizeExpectedOutputDescriptor = summarizeExpectedOutputDescriptor;
+exports.validateExpectedOutputDescriptor = validateExpectedOutputDescriptor;
+exports.buildExpectedOutputDescriptor = buildExpectedOutputDescriptor;
+exports.verifyExpectedOutputDescriptor = verifyExpectedOutputDescriptor;
+exports.redeemBond = redeemBond;
+exports.buildBondTransitionPayload = buildBondTransitionPayload;
+exports.buildBondSettlementDescriptor = buildBondSettlementDescriptor;
+exports.verifyBondSettlementDescriptor = verifyBondSettlementDescriptor;
+exports.buildBondSettlementPayload = buildBondSettlementPayload;
+exports.buildBondClosing = buildBondClosing;
+exports.verifyBondClosing = verifyBondClosing;
+exports.buildEvidenceBundle = buildEvidenceBundle;
+exports.verifyEvidenceBundle = verifyEvidenceBundle;
+exports.issueBond = issueBond;
+exports.prepareRedemption = prepareRedemption;
+exports.finalizeRedemption = finalizeRedemption;
+exports.prepareClosing = prepareClosing;
+exports.exportFinalityPayload = exportFinalityPayload;
+exports.define = define;
+exports.verify = verify;
+exports.load = load;
+exports.issue = issue;
+exports.buildSettlement = buildSettlement;
+exports.verifySettlement = verifySettlement;
+exports.inspectRedemption = inspectRedemption;
+exports.executeRedemption = executeRedemption;
+exports.verifyRedemption = verifyRedemption;
+exports.inspectClosing = inspectClosing;
+exports.executeClosing = executeClosing;
+exports.verifyClosing = verifyClosing;
+exports.exportEvidence = exportEvidence;
+exports.compileBondTransition = compileBondTransition;
+exports.verifyBondRedemptionMachineArtifact = verifyBondRedemptionMachineArtifact;
+exports.compileBondRedemptionMachine = compileBondRedemptionMachine;
+exports.compileBondScriptBoundSettlementMachine = compileBondScriptBoundSettlementMachine;
+exports.verifyBondScriptBoundSettlementMachineArtifact = verifyBondScriptBoundSettlementMachineArtifact;
+exports.compileBondDescriptorBoundSettlementMachine = compileBondDescriptorBoundSettlementMachine;
+exports.verifyBondDescriptorBoundSettlementMachineArtifact = verifyBondDescriptorBoundSettlementMachineArtifact;
+exports.compileBondClosingMachine = compileBondClosingMachine;
+exports.buildBondRedemption = buildBondRedemption;
+exports.verifyBondTransition = verifyBondTransition;
+exports.buildBondRolloverPlan = buildBondRolloverPlan;
+exports.buildBondMachineRolloverPlan = buildBondMachineRolloverPlan;
+exports.buildBondScriptBoundMachineRolloverPlan = buildBondScriptBoundMachineRolloverPlan;
+exports.buildBondDescriptorBoundMachineRolloverPlan = buildBondDescriptorBoundMachineRolloverPlan;
+exports.buildBondMachineSettlementPlan = buildBondMachineSettlementPlan;
+exports.buildBondScriptBoundMachineSettlementPlan = buildBondScriptBoundMachineSettlementPlan;
+exports.buildBondDescriptorBoundMachineSettlementPlan = buildBondDescriptorBoundMachineSettlementPlan;
+exports.inspectBondStateRollover = inspectBondStateRollover;
+exports.inspectBondMachineRollover = inspectBondMachineRollover;
+exports.inspectBondScriptBoundMachineRollover = inspectBondScriptBoundMachineRollover;
+exports.inspectBondDescriptorBoundMachineRollover = inspectBondDescriptorBoundMachineRollover;
+exports.inspectBondMachineSettlement = inspectBondMachineSettlement;
+exports.inspectBondScriptBoundMachineSettlement = inspectBondScriptBoundMachineSettlement;
+exports.inspectBondDescriptorBoundMachineSettlement = inspectBondDescriptorBoundMachineSettlement;
+exports.buildBondClosingPlan = buildBondClosingPlan;
+exports.executeBondStateRollover = executeBondStateRollover;
+exports.executeBondMachineRollover = executeBondMachineRollover;
+exports.executeBondScriptBoundMachineRollover = executeBondScriptBoundMachineRollover;
+exports.executeBondDescriptorBoundMachineRollover = executeBondDescriptorBoundMachineRollover;
+exports.executeBondMachineSettlement = executeBondMachineSettlement;
+exports.executeBondScriptBoundMachineSettlement = executeBondScriptBoundMachineSettlement;
+exports.executeBondDescriptorBoundMachineSettlement = executeBondDescriptorBoundMachineSettlement;
+exports.inspectBondClosing = inspectBondClosing;
+exports.executeBondClosing = executeBondClosing;
+const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const summary_1 = require("../core/summary");
+const outputBinding_1 = require("../core/outputBinding");
+const bondSettlementValidation_1 = require("./bondSettlementValidation");
 const bondValidation_1 = require("./bondValidation");
 function resolveValueOrPath(options) {
     if (options.pathValue)
@@ -15,6 +118,18 @@ function resolveValueOrPath(options) {
         return { value: options.objectValue };
     return {};
 }
+function resolveBondDocsAsset(filename) {
+    const cwdCandidate = node_path_1.default.resolve(process.cwd(), "docs/definitions", filename);
+    if ((0, node_fs_1.existsSync)(cwdCandidate)) {
+        return cwdCandidate;
+    }
+    // In published packages we copy bond example contracts into dist/docs/definitions.
+    const bundledCandidate = node_path_1.default.resolve(__dirname, "../docs/definitions", filename);
+    if ((0, node_fs_1.existsSync)(bundledCandidate)) {
+        return bundledCandidate;
+    }
+    return cwdCandidate;
+}
 async function defineBond(sdk, input) {
     const definitionSource = resolveValueOrPath({
         pathValue: input.definitionPath,
@@ -47,7 +162,7 @@ async function defineBond(sdk, input) {
         ...(issuanceSource.jsonPath ? { jsonPath: issuanceSource.jsonPath } : { value: issuance }),
     });
     (0, bondValidation_1.validateBondCrossChecks)(definition, issuance);
-    const simfPath = input.simfPath ?? node_path_1.default.resolve(process.cwd(), "docs/definitions/bond-issuance-anchor.simf");
+    const simfPath = input.simfPath ?? resolveBondDocsAsset("bond-issuance-anchor.simf");
     return sdk.compileFromFile({
         simfPath,
         templateVars: {
@@ -126,3 +241,2043 @@ async function loadBond(sdk, input) {
         },
     };
 }
+async function buildBondPayload(sdk, input) {
+    const verification = await verifyBond(sdk, input);
+    const definitionValue = (0, bondValidation_1.validateBondDefinition)(JSON.parse(verification.definition.definition.canonicalJson));
+    const issuanceValue = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(verification.issuance.state.canonicalJson));
+    const issuanceSummary = (0, bondValidation_1.summarizeBondIssuanceState)(issuanceValue);
+    return {
+        artifact: verification.artifact,
+        payload: {
+            bondId: definitionValue.bondId,
+            issuanceId: issuanceValue.issuanceId,
+            definitionHash: verification.definition.definition.hash,
+            issuanceStateHash: issuanceSummary.hash,
+            previousStateHash: issuanceValue.previousStateHash ?? null,
+            contractAddress: verification.artifact.compiled.contractAddress,
+            cmr: verification.artifact.compiled.cmr,
+            anchorModes: {
+                definition: verification.artifact.definition?.anchorMode ?? "none",
+                state: verification.artifact.state?.anchorMode ?? "none",
+            },
+            status: issuanceValue.status,
+            lastTransition: issuanceValue.lastTransition
+                ? {
+                    type: issuanceValue.lastTransition.type,
+                    amount: issuanceValue.lastTransition.amount,
+                    at: issuanceValue.lastTransition.at,
+                }
+                : null,
+            principal: {
+                issued: issuanceValue.issuedPrincipal,
+                outstanding: issuanceValue.outstandingPrincipal,
+                redeemed: issuanceValue.redeemedPrincipal,
+            },
+            crossChecks: verification.crossChecks,
+        },
+        trust: {
+            definitionTrust: verification.definition.trust,
+            issuanceTrust: verification.issuance.trust,
+        },
+    };
+}
+function detectPreviousStateAnchor(simfSource) {
+    const source = simfSource.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+    if (!source.includes("{{PREVIOUS_STATE_HASH}}")) {
+        return { sourceVerified: false, reason: "PREVIOUS_STATE_HASH placeholder is missing" };
+    }
+    if (!source.includes("fn require_previous_state_anchor()")) {
+        return { sourceVerified: false, reason: "require_previous_state_anchor helper is missing" };
+    }
+    if (!source.includes("let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};")) {
+        return { sourceVerified: false, reason: "previous_state_hash assignment is missing" };
+    }
+    if (!source.includes("require_previous_state_anchor();")) {
+        return { sourceVerified: false, reason: "require_previous_state_anchor() is not called from main" };
+    }
+    if (!source.includes("require_distinct_transition_state();")) {
+        return { sourceVerified: false, reason: "require_distinct_transition_state() is not called from main" };
+    }
+    return { sourceVerified: true };
+}
+function toUint256Hex(value) {
+    if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+        throw new Error(`Expected a non-negative integer for uint256 conversion, got: ${value}`);
+    }
+    return value.toString(16).padStart(64, "0");
+}
+function toUint32Hex(value) {
+    if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value) || value > 0xffffffff) {
+        throw new Error(`Expected a u32-compatible non-negative integer, got: ${value}`);
+    }
+    return value.toString(16).padStart(8, "0");
+}
+function hashContractAddressToUint256Hex(address) {
+    return (0, summary_1.sha256HexUtf8)(address);
+}
+function bondStatusToCode(status) {
+    switch (status) {
+        case "ISSUED":
+            return 1;
+        case "PARTIALLY_REDEEMED":
+            return 2;
+        case "REDEEMED":
+            return 3;
+        case "CLOSED":
+            return 4;
+        default: {
+            const exhaustiveCheck = status;
+            throw new Error(`Unsupported bond status: ${exhaustiveCheck}`);
+        }
+    }
+}
+function closingReasonToCode(reason) {
+    switch (reason) {
+        case "REDEEMED":
+            return 1;
+        case "CANCELLED":
+            return 2;
+        case "MATURED_OUT":
+            return 3;
+        default: {
+            const exhaustiveCheck = reason;
+            throw new Error(`Unsupported closing reason: ${exhaustiveCheck}`);
+        }
+    }
+}
+function summarizeExpectedOutputDescriptor(descriptor) {
+    const canonicalJson = (0, summary_1.stableStringify)({
+        assetId: descriptor.assetId,
+        feeIndex: descriptor.feeIndex,
+        maxFeeSat: descriptor.maxFeeSat,
+        nextAmountSat: descriptor.nextAmountSat,
+        nextContractAddress: descriptor.nextContractAddress,
+        nextOutputHash: descriptor.nextOutputHash ?? null,
+        nextOutputScriptHash: descriptor.nextOutputScriptHash ?? null,
+        nextOutputIndex: descriptor.nextOutputIndex,
+        requestedOutputBindingMode: descriptor.requestedOutputBindingMode ?? descriptor.outputBindingMode ?? "none",
+        outputForm: descriptor.outputForm ?? (0, outputBinding_1.normalizeOutputForm)(),
+        rawOutput: (0, outputBinding_1.normalizeOutputRawFields)(descriptor.rawOutput) ?? null,
+        outputBindingMode: descriptor.outputBindingMode ?? "none",
+    });
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function validateExpectedOutputDescriptor(descriptor) {
+    if (!descriptor.nextContractAddress || descriptor.nextContractAddress.trim().length === 0) {
+        throw new Error("nextContractAddress must be a non-empty string");
+    }
+    if (!descriptor.assetId || descriptor.assetId.trim().length === 0) {
+        throw new Error("assetId must be a non-empty string");
+    }
+    if (descriptor.nextOutputScriptHash !== undefined && descriptor.nextOutputScriptHash !== null) {
+        if (!/^[0-9a-f]{64}$/i.test(descriptor.nextOutputScriptHash)) {
+            throw new Error("nextOutputScriptHash must be a 64-character hex string");
+        }
+    }
+    if (descriptor.nextOutputHash !== undefined && descriptor.nextOutputHash !== null) {
+        if (!/^[0-9a-f]{64}$/i.test(descriptor.nextOutputHash)) {
+            throw new Error("nextOutputHash must be a 64-character hex string");
+        }
+    }
+    if (!Number.isInteger(descriptor.nextAmountSat) || descriptor.nextAmountSat <= 0) {
+        throw new Error("nextAmountSat must be a positive integer");
+    }
+    if (!Number.isInteger(descriptor.maxFeeSat) || descriptor.maxFeeSat < 0) {
+        throw new Error("maxFeeSat must be a non-negative integer");
+    }
+    if (!Number.isInteger(descriptor.nextOutputIndex) || descriptor.nextOutputIndex < 0) {
+        throw new Error("nextOutputIndex must be a non-negative integer");
+    }
+    if (!Number.isInteger(descriptor.feeIndex) || descriptor.feeIndex < 0) {
+        throw new Error("feeIndex must be a non-negative integer");
+    }
+    if (descriptor.requestedOutputBindingMode
+        && descriptor.requestedOutputBindingMode !== "none"
+        && descriptor.requestedOutputBindingMode !== "script-bound"
+        && descriptor.requestedOutputBindingMode !== "descriptor-bound") {
+        throw new Error("requestedOutputBindingMode must be none, script-bound, or descriptor-bound");
+    }
+    if (descriptor.outputBindingMode !== "none"
+        && descriptor.outputBindingMode !== "script-bound"
+        && descriptor.outputBindingMode !== "descriptor-bound") {
+        throw new Error("outputBindingMode must be none, script-bound, or descriptor-bound");
+    }
+    descriptor.rawOutput = (0, outputBinding_1.normalizeOutputRawFields)(descriptor.rawOutput);
+    descriptor.outputForm = (0, outputBinding_1.normalizeOutputForm)(descriptor.outputForm);
+    descriptor.requestedOutputBindingMode = descriptor.requestedOutputBindingMode ?? descriptor.outputBindingMode ?? "none";
+    return descriptor;
+}
+async function buildExpectedOutputDescriptor(sdk, input) {
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const nextSource = resolveValueOrPath({
+        pathValue: input.nextIssuancePath,
+        objectValue: input.nextIssuanceValue,
+    });
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: input.definitionValue?.bondId ?? "BOND-2026-001",
+        ...definitionSource,
+    });
+    const nextDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.nextIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...nextSource,
+    });
+    const definition = (0, bondValidation_1.validateBondDefinition)(JSON.parse(definitionDescriptor.canonicalJson));
+    const next = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(nextDescriptor.canonicalJson));
+    (0, bondValidation_1.validateBondCrossChecks)(definition, next);
+    const nextStateCompiled = await defineBond(sdk, {
+        definitionValue: definition,
+        issuanceValue: next,
+        simfPath: input.nextStateSimfPath,
+    });
+    const nextScriptPubKeyHex = await (0, outputBinding_1.getScriptPubKeyHexViaRpc)(sdk, nextStateCompiled.deployment().contractAddress);
+    const nextOutputScriptHash = (0, outputBinding_1.hashHexBytes)(nextScriptPubKeyHex);
+    const requestedBindingMode = input.outputBindingMode ?? "script-bound";
+    const outputForm = (0, outputBinding_1.normalizeOutputForm)(input.outputForm);
+    const rawOutput = (0, outputBinding_1.normalizeOutputRawFields)(input.rawOutput);
+    const rawOutputAnalysis = (0, outputBinding_1.analyzeOutputRawFields)(rawOutput);
+    const explicitAssetHex = requestedBindingMode !== "none" && (0, outputBinding_1.isExplicitV1OutputForm)(outputForm)
+        ? await (0, outputBinding_1.resolveExplicitAssetHex)(sdk, definition.currencyAssetId)
+        : undefined;
+    const autoDerivedNextOutputHash = requestedBindingMode === "descriptor-bound" && !input.nextOutputHash
+        ? rawOutputAnalysis.valid && rawOutputAnalysis.normalized
+            ? (0, outputBinding_1.computeRawOutputV1Hash)(rawOutputAnalysis.normalized)
+            : explicitAssetHex
+                ? (0, outputBinding_1.computeExplicitV1OutputHash)({
+                    assetHex: explicitAssetHex,
+                    nextAmountSat: input.nextAmountSat,
+                    nextOutputScriptHash,
+                })
+                : undefined
+        : undefined;
+    const nextOutputHash = input.nextOutputHash ?? autoDerivedNextOutputHash;
+    const bindingDecision = (0, outputBinding_1.resolveOutputBindingDecision)({
+        requestedBindingMode,
+        nextOutputHash,
+        nextOutputScriptHash,
+        autoDerivedNextOutputHash: Boolean(autoDerivedNextOutputHash && !input.nextOutputHash),
+        explicitAssetSupported: Boolean(explicitAssetHex),
+        outputForm,
+        rawOutput,
+    });
+    const descriptor = validateExpectedOutputDescriptor({
+        nextContractAddress: nextStateCompiled.deployment().contractAddress,
+        nextOutputHash: bindingDecision.outputBindingMode === "descriptor-bound" ? nextOutputHash : undefined,
+        nextOutputScriptHash: bindingDecision.outputBindingMode !== "none" ? nextOutputScriptHash : undefined,
+        nextAmountSat: input.nextAmountSat,
+        assetId: definition.currencyAssetId,
+        requestedOutputBindingMode: requestedBindingMode,
+        outputForm,
+        rawOutput,
+        feeIndex: input.feeIndex ?? 1,
+        nextOutputIndex: input.nextOutputIndex ?? 0,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        outputBindingMode: bindingDecision.outputBindingMode,
+    });
+    const summary = summarizeExpectedOutputDescriptor(descriptor);
+    return {
+        descriptor,
+        canonicalJson: summary.canonicalJson,
+        hash: summary.hash,
+        supportedForm: bindingDecision.supportedForm,
+        reasonCode: bindingDecision.reasonCode,
+        autoDerivedNextOutputHash: bindingDecision.autoDerived,
+        fallbackReason: bindingDecision.fallbackReason,
+        bindingInputs: {
+            assetId: descriptor.assetId,
+            assetForm: descriptor.outputForm?.assetForm ?? "explicit",
+            amountForm: descriptor.outputForm?.amountForm ?? "explicit",
+            nonceForm: descriptor.outputForm?.nonceForm ?? "null",
+            rangeProofForm: descriptor.outputForm?.rangeProofForm ?? "empty",
+            nextAmountSat: descriptor.nextAmountSat,
+            nextOutputIndex: descriptor.nextOutputIndex,
+            feeIndex: descriptor.feeIndex,
+            maxFeeSat: descriptor.maxFeeSat,
+            ...(rawOutputAnalysis.valid && rawOutputAnalysis.normalized
+                ? {
+                    rawOutputComponents: {
+                        scriptPubKey: rawOutputAnalysis.normalized.scriptComponentSource,
+                        rangeProof: rawOutputAnalysis.normalized.rangeProofComponentSource,
+                    },
+                }
+                : {}),
+        },
+    };
+}
+async function verifyExpectedOutputDescriptor(sdk, input) {
+    const actual = validateExpectedOutputDescriptor(input.descriptorValue);
+    const expected = await buildExpectedOutputDescriptor(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? actual.nextAmountSat,
+        maxFeeSat: input.maxFeeSat ?? actual.maxFeeSat,
+        nextOutputIndex: input.nextOutputIndex ?? actual.nextOutputIndex,
+        feeIndex: input.feeIndex ?? actual.feeIndex,
+        nextOutputHash: input.nextOutputHash ?? actual.nextOutputHash,
+        outputForm: input.outputForm ?? actual.outputForm,
+        rawOutput: input.rawOutput ?? actual.rawOutput,
+        outputBindingMode: input.outputBindingMode ?? actual.outputBindingMode,
+    });
+    const actualSummary = summarizeExpectedOutputDescriptor(actual);
+    return {
+        ok: actualSummary.hash === expected.hash,
+        reason: actualSummary.hash === expected.hash ? undefined : "Expected output descriptor hash mismatch",
+        descriptor: actual,
+        expected: expected.descriptor,
+        hash: actualSummary.hash,
+        expectedHash: expected.hash,
+        supportedForm: expected.supportedForm,
+        reasonCode: expected.reasonCode,
+        autoDerivedNextOutputHash: expected.autoDerivedNextOutputHash,
+        fallbackReason: expected.fallbackReason,
+        bindingInputs: expected.bindingInputs,
+    };
+}
+async function redeemBond(sdk, input) {
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const previousSource = resolveValueOrPath({
+        pathValue: input.previousIssuancePath,
+        objectValue: input.previousIssuanceValue,
+    });
+    const initialDefinitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: input.definitionValue?.bondId ?? "BOND-2026-001",
+        ...definitionSource,
+    });
+    const definition = (0, bondValidation_1.validateBondDefinition)(JSON.parse(initialDefinitionDescriptor.canonicalJson));
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: definition.bondId,
+        ...(definitionSource.jsonPath ? { jsonPath: definitionSource.jsonPath } : { value: definition }),
+    });
+    const initialPreviousStateDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.previousIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...previousSource,
+    });
+    const previousIssuance = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(initialPreviousStateDescriptor.canonicalJson));
+    (0, bondValidation_1.validateBondCrossChecks)(definition, previousIssuance);
+    const nextIssuance = (0, bondValidation_1.buildRedeemedBondIssuanceState)({
+        previous: previousIssuance,
+        amount: input.amount,
+        redeemedAt: input.redeemedAt,
+    });
+    (0, bondValidation_1.validateBondStateTransition)(previousIssuance, nextIssuance);
+    const stateDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: nextIssuance.issuanceId,
+        value: nextIssuance,
+    });
+    const simfPath = input.simfPath ?? resolveBondDocsAsset("bond-issuance-anchor.simf");
+    return sdk.compileFromFile({
+        simfPath,
+        templateVars: {
+            MIN_HEIGHT: definition.maturityDate,
+            SIGNER_XONLY: definition.controllerXonly,
+        },
+        definition: {
+            type: definitionDescriptor.definitionType,
+            id: definitionDescriptor.definitionId,
+            schemaVersion: definitionDescriptor.schemaVersion,
+            ...(definitionDescriptor.sourcePath ? { jsonPath: definitionDescriptor.sourcePath } : { value: definition }),
+            anchorMode: "on-chain-constant-committed",
+        },
+        state: {
+            type: stateDescriptor.stateType,
+            id: stateDescriptor.stateId,
+            schemaVersion: stateDescriptor.schemaVersion,
+            value: nextIssuance,
+            anchorMode: "on-chain-constant-committed",
+        },
+        artifactPath: input.artifactPath,
+    });
+}
+async function buildBondTransitionPayload(sdk, input) {
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const previousSource = resolveValueOrPath({
+        pathValue: input.previousIssuancePath,
+        objectValue: input.previousIssuanceValue,
+    });
+    const nextSource = resolveValueOrPath({
+        pathValue: input.nextIssuancePath,
+        objectValue: input.nextIssuanceValue,
+    });
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: input.definitionValue?.bondId ?? "BOND-2026-001",
+        ...definitionSource,
+    });
+    const previousDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.previousIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...previousSource,
+    });
+    const nextDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.nextIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...nextSource,
+    });
+    const definition = (0, bondValidation_1.validateBondDefinition)(JSON.parse(definitionDescriptor.canonicalJson));
+    const previous = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(previousDescriptor.canonicalJson));
+    const next = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(nextDescriptor.canonicalJson));
+    const previousCrossChecks = (0, bondValidation_1.validateBondCrossChecks)(definition, previous);
+    const nextCrossChecks = (0, bondValidation_1.validateBondCrossChecks)(definition, next);
+    const transition = (0, bondValidation_1.validateBondStateTransition)(previous, next);
+    return {
+        definition,
+        previous,
+        next,
+        payload: {
+            bondId: definition.bondId,
+            issuanceId: previous.issuanceId,
+            definitionHash: definitionDescriptor.hash,
+            previousStateHash: previousDescriptor.hash,
+            nextStateHash: nextDescriptor.hash,
+            previousStatus: previous.status,
+            nextStatus: next.status,
+            previousStatusCode: bondStatusToCode(previous.status),
+            nextStatusCode: bondStatusToCode(next.status),
+            transitionKind: next.lastTransition?.type ?? null,
+            redeemAmount: next.lastTransition?.type === "REDEEM" ? next.lastTransition.amount : null,
+            transitionAt: next.lastTransition?.at ?? null,
+            principal: {
+                issued: previous.issuedPrincipal,
+                previousOutstanding: previous.outstandingPrincipal,
+                nextOutstanding: next.outstandingPrincipal,
+                previousRedeemed: previous.redeemedPrincipal,
+                nextRedeemed: next.redeemedPrincipal,
+                outstandingDelta: previous.outstandingPrincipal - next.outstandingPrincipal,
+                redeemedDelta: next.redeemedPrincipal - previous.redeemedPrincipal,
+            },
+            crossChecks: {
+                previous: previousCrossChecks,
+                next: nextCrossChecks,
+                transition,
+            },
+        },
+    };
+}
+async function buildBondSettlementDescriptor(sdk, input) {
+    const transition = await buildBondTransitionPayload(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+    });
+    const nextStateCompiled = await defineBond(sdk, {
+        definitionValue: transition.definition,
+        issuanceValue: transition.next,
+        simfPath: input.nextStateSimfPath,
+    });
+    const expectedOutputDescriptor = await buildExpectedOutputDescriptor(sdk, {
+        definitionValue: transition.definition,
+        nextIssuanceValue: transition.next,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.outputForm,
+        rawOutput: input.rawOutput,
+        outputBindingMode: input.outputBindingMode,
+    });
+    const nextContractAddress = nextStateCompiled.deployment().contractAddress;
+    const descriptor = (0, bondSettlementValidation_1.validateBondSettlementDescriptor)({
+        settlementId: `${transition.previous.issuanceId}-SETTLEMENT-${transition.payload.nextStatus}`,
+        bondId: transition.definition.bondId,
+        issuanceId: transition.previous.issuanceId,
+        definitionHash: transition.payload.definitionHash,
+        previousStateHash: transition.payload.previousStateHash,
+        nextStateHash: transition.payload.nextStateHash,
+        previousStatus: transition.payload.previousStatus,
+        nextStatus: transition.payload.nextStatus,
+        transitionKind: "REDEEM",
+        redeemAmount: transition.payload.redeemAmount ?? 0,
+        transitionAt: transition.payload.transitionAt ?? transition.next.lastTransition?.at ?? transition.next.issuedAt,
+        assetId: transition.definition.currencyAssetId,
+        nextContractAddress,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        expectedOutputDescriptorHash: expectedOutputDescriptor.hash,
+        outputBindingMode: expectedOutputDescriptor.descriptor.outputBindingMode ?? "none",
+        principal: {
+            issued: transition.payload.principal.issued,
+            previousOutstanding: transition.payload.principal.previousOutstanding,
+            nextOutstanding: transition.payload.principal.nextOutstanding,
+            previousRedeemed: transition.payload.principal.previousRedeemed,
+            nextRedeemed: transition.payload.principal.nextRedeemed,
+        },
+    });
+    const summary = (0, bondSettlementValidation_1.summarizeBondSettlementDescriptor)(descriptor);
+    return {
+        definition: transition.definition,
+        previous: transition.previous,
+        next: transition.next,
+        transition: transition.payload.crossChecks.transition,
+        nextContractAddress,
+        descriptor,
+        expectedOutputDescriptor: expectedOutputDescriptor.descriptor,
+        expectedOutputDescriptorHash: expectedOutputDescriptor.hash,
+        expectedOutputBindingSupportedForm: expectedOutputDescriptor.supportedForm,
+        expectedOutputBindingReasonCode: expectedOutputDescriptor.reasonCode,
+        expectedOutputBindingAutoDerived: expectedOutputDescriptor.autoDerivedNextOutputHash,
+        expectedOutputBindingFallbackReason: expectedOutputDescriptor.fallbackReason,
+        expectedOutputBindingInputs: expectedOutputDescriptor.bindingInputs,
+        canonicalJson: summary.canonicalJson,
+        hash: summary.hash,
+    };
+}
+async function verifyBondSettlementDescriptor(sdk, input) {
+    const descriptorSource = resolveValueOrPath({
+        pathValue: input.descriptorPath,
+        objectValue: input.descriptorValue,
+    });
+    const descriptor = (0, bondSettlementValidation_1.validateBondSettlementDescriptor)(descriptorSource.jsonPath
+        ? JSON.parse(await Promise.resolve().then(() => __importStar(require("node:fs/promises"))).then((fs) => fs.readFile(descriptorSource.jsonPath, "utf8")))
+        : descriptorSource.value);
+    const expected = await buildBondSettlementDescriptor(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? descriptor.nextAmountSat,
+        maxFeeSat: input.maxFeeSat ?? descriptor.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.outputForm,
+        rawOutput: input.rawOutput,
+        outputBindingMode: descriptor.outputBindingMode,
+    });
+    const actualSummary = (0, bondSettlementValidation_1.summarizeBondSettlementDescriptor)(descriptor);
+    const matches = (0, bondSettlementValidation_1.validateBondSettlementMatchesExpected)(descriptor, expected.descriptor);
+    return {
+        ok: actualSummary.hash === expected.hash,
+        reason: actualSummary.hash === expected.hash ? undefined : "Bond settlement descriptor hash mismatch",
+        descriptor,
+        expected: expected.descriptor,
+        hash: actualSummary.hash,
+        expectedHash: expected.hash,
+        matches,
+        supportedForm: expected.expectedOutputBindingSupportedForm,
+        reasonCode: expected.expectedOutputBindingReasonCode,
+        autoDerivedNextOutputHash: expected.expectedOutputBindingAutoDerived,
+        fallbackReason: expected.expectedOutputBindingFallbackReason,
+        bindingInputs: expected.expectedOutputBindingInputs,
+    };
+}
+async function buildBondSettlementPayload(sdk, input) {
+    const result = await buildBondSettlementDescriptor(sdk, input);
+    return {
+        descriptor: result.descriptor,
+        descriptorHash: result.hash,
+        expectedOutputDescriptor: result.expectedOutputDescriptor,
+        expectedOutputDescriptorHash: result.expectedOutputDescriptorHash,
+        supportedForm: result.expectedOutputBindingSupportedForm,
+        reasonCode: result.expectedOutputBindingReasonCode,
+        autoDerivedNextOutputHash: result.expectedOutputBindingAutoDerived,
+        fallbackReason: result.expectedOutputBindingFallbackReason,
+        bindingInputs: result.expectedOutputBindingInputs,
+        previousStateHash: result.descriptor.previousStateHash,
+        nextStateHash: result.descriptor.nextStateHash,
+        nextContractAddress: result.descriptor.nextContractAddress,
+        nextAmountSat: result.descriptor.nextAmountSat,
+        maxFeeSat: result.descriptor.maxFeeSat,
+    };
+}
+async function buildBondClosing(sdk, input) {
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const issuanceSource = resolveValueOrPath({
+        pathValue: input.redeemedIssuancePath,
+        objectValue: input.redeemedIssuanceValue,
+    });
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: input.definitionValue?.bondId ?? "BOND-2026-001",
+        ...definitionSource,
+    });
+    const issuanceDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.redeemedIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...issuanceSource,
+    });
+    const definition = (0, bondValidation_1.validateBondDefinition)(JSON.parse(definitionDescriptor.canonicalJson));
+    const redeemed = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(issuanceDescriptor.canonicalJson));
+    (0, bondValidation_1.validateBondCrossChecks)(definition, redeemed);
+    const settlementVerification = await verifyBondSettlementDescriptor(sdk, {
+        descriptorPath: input.settlementDescriptorPath,
+        descriptorValue: input.settlementDescriptorValue,
+        definitionValue: definition,
+        previousIssuanceValue: undefined,
+        nextIssuanceValue: redeemed,
+        nextAmountSat: input.settlementDescriptorValue?.nextAmountSat,
+        maxFeeSat: input.settlementDescriptorValue?.maxFeeSat,
+    }).catch(() => undefined);
+    const finalSettlementDescriptorHash = settlementVerification?.hash
+        ?? (input.settlementDescriptorValue
+            ? (0, bondSettlementValidation_1.summarizeBondSettlementDescriptor)(input.settlementDescriptorValue).hash
+            : undefined);
+    if (!finalSettlementDescriptorHash) {
+        throw new Error("A valid settlement descriptor is required to build a closing state");
+    }
+    const closed = (0, bondValidation_1.buildClosedBondIssuanceState)({
+        previous: redeemed,
+        closedAt: input.closedAt,
+        closingReason: input.closingReason ?? "REDEEMED",
+        finalSettlementDescriptorHash,
+    });
+    const closing = {
+        closingId: `${closed.issuanceId}-CLOSE`,
+        bondId: definition.bondId,
+        issuanceId: closed.issuanceId,
+        finalStatus: "CLOSED",
+        definitionHash: definitionDescriptor.hash,
+        previousStateHash: (0, bondValidation_1.summarizeBondIssuanceState)(redeemed).hash,
+        closedStateHash: (0, bondValidation_1.summarizeBondIssuanceState)(closed).hash,
+        stateHash: (0, bondValidation_1.summarizeBondIssuanceState)(closed).hash,
+        closedAt: input.closedAt,
+        closingReason: input.closingReason ?? "REDEEMED",
+        finalSettlementDescriptorHash,
+    };
+    return {
+        definition,
+        previous: redeemed,
+        closed,
+        closing,
+        closingHash: (0, summary_1.sha256HexUtf8)((0, summary_1.stableStringify)(closing)),
+    };
+}
+async function verifyBondClosing(sdk, input) {
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const redeemedSource = resolveValueOrPath({
+        pathValue: input.redeemedIssuancePath,
+        objectValue: input.redeemedIssuanceValue,
+    });
+    const closedSource = resolveValueOrPath({
+        pathValue: input.closedIssuancePath,
+        objectValue: input.closedIssuanceValue,
+    });
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: input.definitionValue?.bondId ?? "BOND-2026-001",
+        ...definitionSource,
+    });
+    const redeemedDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.redeemedIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...redeemedSource,
+    });
+    const closedDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.closedIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...closedSource,
+    });
+    const definition = (0, bondValidation_1.validateBondDefinition)(JSON.parse(definitionDescriptor.canonicalJson));
+    const redeemed = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(redeemedDescriptor.canonicalJson));
+    const closed = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(closedDescriptor.canonicalJson));
+    (0, bondValidation_1.validateBondCrossChecks)(definition, redeemed);
+    (0, bondValidation_1.validateBondCrossChecks)(definition, closed);
+    const settlementHash = input.settlementDescriptorValue
+        ? (0, bondSettlementValidation_1.summarizeBondSettlementDescriptor)(input.settlementDescriptorValue).hash
+        : input.settlementDescriptorPath
+            ? (0, bondSettlementValidation_1.summarizeBondSettlementDescriptor)(JSON.parse(await Promise.resolve().then(() => __importStar(require("node:fs/promises"))).then((fs) => fs.readFile(input.settlementDescriptorPath, "utf8")))).hash
+            : "";
+    const checks = {
+        redeemedStateMatch: redeemed.status === "REDEEMED",
+        closedStateMatch: closed.status === "CLOSED",
+        previousStateHashMatch: closed.previousStateHash === (0, bondValidation_1.summarizeBondIssuanceState)(redeemed).hash,
+        finalSettlementDescriptorHashMatch: closed.finalSettlementDescriptorHash === settlementHash,
+        closingReasonPresent: !!closed.closingReason,
+        closedAtPresent: !!closed.closedAt,
+    };
+    return {
+        definition,
+        redeemed,
+        closed,
+        checks,
+        verified: Object.values(checks).every(Boolean),
+    };
+}
+async function buildEvidenceBundle(sdk, input) {
+    const artifact = input.artifact ?? (input.artifactPath ? (await sdk.loadArtifact(input.artifactPath)).artifact : undefined);
+    if (!artifact)
+        throw new Error("artifactPath or artifact is required");
+    const verification = await verifyBond(sdk, {
+        artifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        issuancePath: input.issuancePath,
+        issuanceValue: input.issuanceValue,
+    });
+    const definition = verification.definition.definition;
+    const issuance = verification.issuance.state;
+    const settlementCanonicalJson = input.settlementDescriptorValue
+        ? (0, bondSettlementValidation_1.summarizeBondSettlementDescriptor)(input.settlementDescriptorValue).canonicalJson
+        : null;
+    const settlementHash = input.settlementDescriptorValue
+        ? (0, bondSettlementValidation_1.summarizeBondSettlementDescriptor)(input.settlementDescriptorValue).hash
+        : null;
+    const closingCanonicalJson = input.closingDescriptorValue
+        ? (0, summary_1.stableStringify)(input.closingDescriptorValue)
+        : null;
+    const closingHash = closingCanonicalJson
+        ? (0, summary_1.sha256HexUtf8)(closingCanonicalJson)
+        : null;
+    const sourcePath = artifact.source.mode === "file" ? artifact.source.simfPath : undefined;
+    const renderedSourceHash = sourcePath && (0, node_fs_1.existsSync)(sourcePath)
+        ? (0, summary_1.sha256HexUtf8)(await Promise.resolve().then(() => __importStar(require("node:fs/promises"))).then((fs) => fs.readFile(sourcePath, "utf8")))
+        : null;
+    return {
+        artifact,
+        definition: {
+            canonicalJson: definition.canonicalJson,
+            hash: definition.hash,
+        },
+        issuance: {
+            canonicalJson: issuance.canonicalJson,
+            hash: issuance.hash,
+        },
+        transition: input.transitionValue
+            ? {
+                canonicalJson: (0, summary_1.stableStringify)(input.transitionValue),
+                hash: (0, summary_1.sha256HexUtf8)((0, summary_1.stableStringify)(input.transitionValue)),
+            }
+            : undefined,
+        settlement: settlementCanonicalJson && settlementHash
+            ? {
+                canonicalJson: settlementCanonicalJson,
+                hash: settlementHash,
+            }
+            : undefined,
+        closing: closingCanonicalJson && closingHash
+            ? {
+                canonicalJson: closingCanonicalJson,
+                hash: closingHash,
+            }
+            : undefined,
+        trust: {
+            artifactTrust: {
+                definition: verification.definition.trust,
+                state: verification.issuance.trust,
+            },
+            stateTrust: verification.issuance.trust,
+            settlementTrust: input.settlementDescriptorValue
+                ? {
+                    descriptorHashMatch: true,
+                    outputBindingMode: input.settlementDescriptorValue.outputBindingMode ?? "none",
+                }
+                : undefined,
+        },
+        renderedSourceHash: renderedSourceHash ?? undefined,
+        sourceVerificationMode: renderedSourceHash ? "source-reloaded" : "artifact-only",
+        compiled: {
+            program: artifact.compiled.program,
+            cmr: artifact.compiled.cmr,
+            contractAddress: artifact.compiled.contractAddress,
+        },
+    };
+}
+async function verifyEvidenceBundle(sdk, input) {
+    const expected = await buildEvidenceBundle(sdk, {
+        artifact: input.bundleValue.artifact,
+        definitionPath: input.definitionPath,
+        issuancePath: input.issuancePath,
+        settlementDescriptorValue: input.settlementDescriptorValue,
+        closingDescriptorValue: input.closingDescriptorValue,
+    });
+    const checks = {
+        definitionHashMatch: input.bundleValue.definition.hash === expected.definition.hash,
+        issuanceHashMatch: input.bundleValue.issuance.hash === expected.issuance.hash,
+        settlementHashMatch: (input.bundleValue.settlement?.hash ?? null) === (expected.settlement?.hash ?? null),
+        closingHashMatch: (input.bundleValue.closing?.hash ?? null) === (expected.closing?.hash ?? null),
+        renderedSourceHashMatch: input.bundleValue.renderedSourceHash === expected.renderedSourceHash,
+        cmrMatch: input.bundleValue.compiled.cmr === expected.compiled.cmr,
+        contractAddressMatch: input.bundleValue.compiled.contractAddress === expected.compiled.contractAddress,
+    };
+    return {
+        expected,
+        checks,
+        verified: Object.values(checks).every(Boolean),
+    };
+}
+async function issueBond(sdk, input) {
+    return defineBond(sdk, input);
+}
+async function prepareRedemption(sdk, input) {
+    const preview = await buildBondRedemption(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        amount: input.amount,
+        redeemedAt: input.redeemedAt,
+    });
+    const settlement = await buildBondSettlementPayload(sdk, {
+        definitionValue: preview.definition,
+        previousIssuanceValue: preview.previous,
+        nextIssuanceValue: preview.next,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+        rawOutput: input.rawOutput,
+        outputBindingMode: input.outputBindingMode,
+    });
+    return { preview, settlement };
+}
+async function finalizeRedemption(sdk, input) {
+    return buildBondMachineSettlementPlan(sdk, input);
+}
+async function prepareClosing(sdk, input) {
+    return buildBondClosing(sdk, input);
+}
+async function exportFinalityPayload(sdk, input) {
+    const bondPayload = await buildBondPayload(sdk, input);
+    const evidence = await buildEvidenceBundle(sdk, input);
+    return {
+        payload: bondPayload.payload,
+        bindingMode: input.settlementDescriptorValue?.outputBindingMode ?? "none",
+        trust: bondPayload.trust,
+        trustSummary: {
+            definition: bondPayload.trust.definitionTrust,
+            issuance: bondPayload.trust.issuanceTrust,
+            bindingMode: input.settlementDescriptorValue?.outputBindingMode ?? "none",
+        },
+        evidenceSummary: {
+            definitionHash: evidence.definition.hash,
+            issuanceHash: evidence.issuance.hash,
+            settlementHash: evidence.settlement?.hash ?? null,
+            closingHash: evidence.closing?.hash ?? null,
+            renderedSourceHash: evidence.renderedSourceHash,
+            sourceVerificationMode: evidence.sourceVerificationMode,
+        },
+    };
+}
+async function define(sdk, input) {
+    return defineBond(sdk, input);
+}
+async function verify(sdk, input) {
+    return verifyBond(sdk, input);
+}
+async function load(sdk, input) {
+    return loadBond(sdk, input);
+}
+async function issue(sdk, input) {
+    return issueBond(sdk, input);
+}
+async function buildSettlement(sdk, input) {
+    return buildBondSettlementPayload(sdk, input);
+}
+async function verifySettlement(sdk, input) {
+    return verifyBondSettlementDescriptor(sdk, input);
+}
+function resolveRedemptionBindingMode(settlement) {
+    return settlement.descriptor?.outputBindingMode ?? "none";
+}
+async function inspectRedemption(sdk, input) {
+    const settlement = await buildBondSettlementPayload(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? 1900,
+        maxFeeSat: input.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.outputForm,
+        rawOutput: input.rawOutput,
+        outputBindingMode: input.outputBindingMode,
+    });
+    const mode = resolveRedemptionBindingMode(settlement);
+    if (mode === "descriptor-bound") {
+        const result = await inspectBondDescriptorBoundMachineRollover(sdk, {
+            ...input,
+            nextAmountSat: input.nextAmountSat,
+            maxFeeSat: input.maxFeeSat,
+            nextOutputHash: input.nextOutputHash,
+        });
+        return { mode, settlement, ...result };
+    }
+    if (mode === "script-bound") {
+        const result = await inspectBondScriptBoundMachineRollover(sdk, {
+            ...input,
+            nextAmountSat: input.nextAmountSat,
+            maxFeeSat: input.maxFeeSat,
+        });
+        return { mode, settlement, ...result };
+    }
+    const result = await inspectBondMachineRollover(sdk, input);
+    return { mode, settlement, ...result };
+}
+async function executeRedemption(sdk, input) {
+    const settlement = await buildBondSettlementPayload(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? 1900,
+        maxFeeSat: input.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.outputForm,
+        rawOutput: input.rawOutput,
+        outputBindingMode: input.outputBindingMode,
+    });
+    const mode = resolveRedemptionBindingMode(settlement);
+    if (mode === "descriptor-bound") {
+        const result = await executeBondDescriptorBoundMachineRollover(sdk, {
+            ...input,
+            nextAmountSat: input.nextAmountSat,
+            maxFeeSat: input.maxFeeSat,
+            nextOutputHash: input.nextOutputHash,
+        });
+        return { mode, settlement, ...result };
+    }
+    if (mode === "script-bound") {
+        const result = await executeBondScriptBoundMachineRollover(sdk, {
+            ...input,
+            nextAmountSat: input.nextAmountSat,
+            maxFeeSat: input.maxFeeSat,
+        });
+        return { mode, settlement, ...result };
+    }
+    const result = await executeBondMachineRollover(sdk, input);
+    return { mode, settlement, ...result };
+}
+async function verifyRedemption(sdk, input) {
+    const settlement = await buildBondSettlementPayload(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? 1900,
+        maxFeeSat: input.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.outputForm,
+        rawOutput: input.rawOutput,
+        outputBindingMode: input.outputBindingMode,
+    });
+    const mode = resolveRedemptionBindingMode(settlement);
+    if (mode === "descriptor-bound") {
+        const result = await verifyBondDescriptorBoundSettlementMachineArtifact(sdk, {
+            ...input,
+            nextAmountSat: input.nextAmountSat,
+            maxFeeSat: input.maxFeeSat,
+            nextOutputHash: input.nextOutputHash,
+            outputForm: input.outputForm,
+        });
+        return { mode, settlement, ...result };
+    }
+    if (mode === "script-bound") {
+        const result = await verifyBondScriptBoundSettlementMachineArtifact(sdk, {
+            ...input,
+            nextAmountSat: input.nextAmountSat,
+            maxFeeSat: input.maxFeeSat,
+            outputForm: input.outputForm,
+        });
+        return { mode, settlement, ...result };
+    }
+    const result = await verifyBondRedemptionMachineArtifact(sdk, {
+        ...input,
+        outputForm: input.outputForm,
+    });
+    return { mode, settlement, ...result };
+}
+async function inspectClosing(sdk, input) {
+    return inspectBondClosing(sdk, input);
+}
+async function executeClosing(sdk, input) {
+    return executeBondClosing(sdk, input);
+}
+async function verifyClosing(sdk, input) {
+    return verifyBondClosing(sdk, input);
+}
+async function exportEvidence(sdk, input) {
+    return buildEvidenceBundle(sdk, input);
+}
+async function compileBondTransition(sdk, input) {
+    const transitionPayload = await buildBondTransitionPayload(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+    });
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const nextSource = resolveValueOrPath({
+        pathValue: input.nextIssuancePath,
+        objectValue: input.nextIssuanceValue,
+    });
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: transitionPayload.definition.bondId,
+        ...definitionSource,
+    });
+    const nextDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: transitionPayload.next.issuanceId,
+        ...nextSource,
+    });
+    const simfPath = input.simfPath ?? resolveBondDocsAsset("bond-redemption-transition.simf");
+    const rawSource = await Promise.resolve().then(() => __importStar(require("node:fs/promises"))).then((fs) => fs.readFile(simfPath, "utf8"));
+    const previousAnchor = detectPreviousStateAnchor(rawSource);
+    if (!previousAnchor.sourceVerified) {
+        throw new Error(`Transition contract source is missing required previous-state anchor pattern: ${previousAnchor.reason}`);
+    }
+    const compiled = await sdk.compileFromFile({
+        simfPath,
+        templateVars: {
+            MIN_HEIGHT: transitionPayload.definition.maturityDate,
+            SIGNER_XONLY: transitionPayload.definition.controllerXonly,
+            PREVIOUS_STATE_HASH: transitionPayload.payload.previousStateHash,
+        },
+        definition: {
+            type: definitionDescriptor.definitionType,
+            id: definitionDescriptor.definitionId,
+            schemaVersion: definitionDescriptor.schemaVersion,
+            ...(definitionDescriptor.sourcePath ? { jsonPath: definitionDescriptor.sourcePath } : { value: transitionPayload.definition }),
+            anchorMode: "on-chain-constant-committed",
+        },
+        state: {
+            type: nextDescriptor.stateType,
+            id: nextDescriptor.stateId,
+            schemaVersion: nextDescriptor.schemaVersion,
+            ...(nextDescriptor.sourcePath ? { jsonPath: nextDescriptor.sourcePath } : { value: transitionPayload.next }),
+            anchorMode: "on-chain-constant-committed",
+        },
+        artifactPath: input.artifactPath,
+    });
+    return {
+        compiled,
+        previousHash: transitionPayload.payload.previousStateHash,
+        nextHash: transitionPayload.payload.nextStateHash,
+        transition: transitionPayload.payload.crossChecks.transition,
+        payload: transitionPayload.payload,
+    };
+}
+async function verifyBondRedemptionMachineArtifact(sdk, input) {
+    const artifact = input.artifact ?? (input.artifactPath ? (await sdk.loadArtifact(input.artifactPath)).artifact : undefined);
+    if (!artifact) {
+        throw new Error("artifactPath or artifact is required");
+    }
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const nextSource = resolveValueOrPath({
+        pathValue: input.nextIssuancePath,
+        objectValue: input.nextIssuanceValue,
+    });
+    const definitionVerification = await sdk.verifyDefinitionAgainstArtifact({
+        artifact,
+        type: "bond",
+        id: artifact.definition?.definitionId,
+        ...definitionSource,
+    });
+    const nextStateVerification = await sdk.verifyStateAgainstArtifact({
+        artifact,
+        type: "bond-issuance",
+        id: artifact.state?.stateId,
+        ...nextSource,
+    });
+    const expected = await buildBondTransitionPayload(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+    });
+    const expectedNextCompiled = await defineBond(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: expected.definition,
+        issuanceValue: expected.next,
+        simfPath: input.nextStateSimfPath,
+    });
+    const expectedNextContractAddress = expectedNextCompiled.deployment().contractAddress;
+    const expectedNextContractAddressHash = hashContractAddressToUint256Hex(expectedNextContractAddress);
+    const expectedSettlement = await buildBondSettlementDescriptor(sdk, {
+        definitionValue: expected.definition,
+        previousIssuanceValue: expected.previous,
+        nextIssuanceValue: expected.next,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? 1900,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.outputForm,
+        rawOutput: input.rawOutput,
+        outputBindingMode: input.outputBindingMode,
+    });
+    const templateVars = artifact.source.templateVars ?? {};
+    const committed = {
+        previousStateHash: String(templateVars.PREVIOUS_STATE_HASH ?? ""),
+        redeemAmount256: String(templateVars.REDEEM_AMOUNT_256 ?? ""),
+        transitionKind256: String(templateVars.TRANSITION_KIND_256 ?? ""),
+        redeemAmount32: String(templateVars.REDEEM_AMOUNT_32 ?? ""),
+        previousStatus32: String(templateVars.PREVIOUS_STATUS_32 ?? ""),
+        nextStatus32: String(templateVars.NEXT_STATUS_32 ?? ""),
+        previousOutstanding32: String(templateVars.PREVIOUS_OUTSTANDING_32 ?? ""),
+        previousRedeemed32: String(templateVars.PREVIOUS_REDEEMED_32 ?? ""),
+        nextOutstanding32: String(templateVars.NEXT_OUTSTANDING_32 ?? ""),
+        nextRedeemed32: String(templateVars.NEXT_REDEEMED_32 ?? ""),
+        nextContractAddressHash256: String(templateVars.NEXT_CONTRACT_ADDRESS_HASH_256 ?? ""),
+        expectedNextOutputHash256: String(templateVars.EXPECTED_NEXT_OUTPUT_HASH_256 ?? ""),
+        expectedNextOutputScriptHash256: String(templateVars.EXPECTED_NEXT_OUTPUT_SCRIPT_HASH_256 ?? ""),
+        settlementDescriptorHash256: String(templateVars.SETTLEMENT_DESCRIPTOR_HASH ?? ""),
+        expectedOutputDescriptorHash256: String(templateVars.EXPECTED_OUTPUT_DESCRIPTOR_HASH ?? ""),
+    };
+    const checks = {
+        previousStateHashCommitted: committed.previousStateHash === expected.payload.previousStateHash,
+        redeemAmountCommitted: committed.redeemAmount256 === toUint256Hex(expected.payload.redeemAmount ?? 0)
+            && committed.redeemAmount32 === toUint32Hex(expected.payload.redeemAmount ?? 0),
+        transitionKindCommitted: committed.transitionKind256 === toUint256Hex(expected.payload.transitionKind === "REDEEM" ? 1 : 0),
+        statusCodesCommitted: committed.previousStatus32 === toUint32Hex(expected.payload.previousStatusCode)
+            && committed.nextStatus32 === toUint32Hex(expected.payload.nextStatusCode),
+        principalArithmeticCommitted: committed.previousOutstanding32 === toUint32Hex(expected.payload.principal.previousOutstanding)
+            && committed.previousRedeemed32 === toUint32Hex(expected.payload.principal.previousRedeemed)
+            && committed.nextOutstanding32 === toUint32Hex(expected.payload.principal.nextOutstanding)
+            && committed.nextRedeemed32 === toUint32Hex(expected.payload.principal.nextRedeemed),
+        nextContractAddressCommitted: committed.nextContractAddressHash256 === expectedNextContractAddressHash,
+        nextOutputHashCommitted: !expectedSettlement.expectedOutputDescriptor?.nextOutputHash
+            || committed.expectedNextOutputHash256 === expectedSettlement.expectedOutputDescriptor.nextOutputHash,
+        nextOutputScriptCommitted: !expectedSettlement.expectedOutputDescriptor?.nextOutputScriptHash
+            || committed.expectedNextOutputScriptHash256
+                === expectedSettlement.expectedOutputDescriptor.nextOutputScriptHash,
+        settlementDescriptorCommitted: committed.settlementDescriptorHash256 === expectedSettlement.hash,
+        expectedOutputDescriptorCommitted: !expectedSettlement.expectedOutputDescriptorHash
+            || committed.expectedOutputDescriptorHash256 === expectedSettlement.expectedOutputDescriptorHash,
+    };
+    const allChecks = Object.values(checks).every(Boolean);
+    return {
+        artifact,
+        definition: definitionVerification,
+        issuance: nextStateVerification,
+        expectedPayload: {
+            ...expected.payload,
+            nextStateContractAddress: expectedNextContractAddress,
+            nextStateContractAddressHash: expectedNextContractAddressHash,
+        },
+        expectedSettlementDescriptor: expectedSettlement.descriptor,
+        expectedSettlementDescriptorHash: expectedSettlement.hash,
+        outputBindingMetadata: {
+            requestedMode: expectedSettlement.expectedOutputDescriptor?.requestedOutputBindingMode
+                ?? expectedSettlement.descriptor.outputBindingMode
+                ?? "none",
+            supportedForm: expectedSettlement.expectedOutputBindingSupportedForm,
+            reasonCode: expectedSettlement.expectedOutputBindingReasonCode,
+            autoDerived: expectedSettlement.expectedOutputBindingAutoDerived,
+            fallbackReason: expectedSettlement.expectedOutputBindingFallbackReason,
+            bindingInputs: expectedSettlement.expectedOutputBindingInputs,
+        },
+        expectedNextContractAddress,
+        expectedNextContractAddressHash,
+        committed,
+        checks,
+        verified: definitionVerification.ok
+            && nextStateVerification.ok
+            && definitionVerification.trust.onChainAnchorVerified
+            && nextStateVerification.trust.onChainAnchorVerified
+            && allChecks,
+    };
+}
+async function compileBondRedemptionMachine(sdk, input) {
+    const transitionResult = await compileBondTransition(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+    });
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const nextSource = resolveValueOrPath({
+        pathValue: input.nextIssuancePath,
+        objectValue: input.nextIssuanceValue,
+    });
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: transitionResult.compiled.definition()?.definitionId ?? "BOND-2026-001",
+        ...definitionSource,
+    });
+    const nextDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: transitionResult.compiled.state()?.stateId ?? "BOND-2026-001-ISSUE-1",
+        ...nextSource,
+    });
+    const definition = (0, bondValidation_1.validateBondDefinition)(JSON.parse(definitionDescriptor.canonicalJson));
+    const next = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(nextDescriptor.canonicalJson));
+    const nextStateCompiled = await defineBond(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: definition,
+        issuanceValue: next,
+        simfPath: input.nextStateSimfPath,
+    });
+    const nextStateContractAddress = nextStateCompiled.deployment().contractAddress;
+    const nextStateContractAddressHash = hashContractAddressToUint256Hex(nextStateContractAddress);
+    const settlementDescriptor = await buildBondSettlementDescriptor(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue ?? definition,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue ?? next,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? 1900,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.outputForm,
+        rawOutput: input.rawOutput,
+        outputBindingMode: input.outputBindingMode,
+    });
+    const simfPath = input.simfPath ?? resolveBondDocsAsset("bond-redemption-state-machine.simf");
+    const compiled = await sdk.compileFromFile({
+        simfPath,
+        templateVars: {
+            MIN_HEIGHT: definition.maturityDate,
+            SIGNER_XONLY: definition.controllerXonly,
+            PREVIOUS_STATE_HASH: transitionResult.previousHash,
+            REDEEM_AMOUNT_256: toUint256Hex(next.lastTransition?.amount ?? 0),
+            TRANSITION_KIND_256: toUint256Hex(1),
+            REDEEM_AMOUNT_32: toUint32Hex(next.lastTransition?.amount ?? 0),
+            PREVIOUS_STATUS_32: toUint32Hex(bondStatusToCode(transitionResult.payload.previousStatus)),
+            NEXT_STATUS_32: toUint32Hex(bondStatusToCode(transitionResult.payload.nextStatus)),
+            PREVIOUS_OUTSTANDING_32: toUint32Hex(transitionResult.payload.principal.previousOutstanding),
+            PREVIOUS_REDEEMED_32: toUint32Hex(transitionResult.payload.principal.previousRedeemed),
+            NEXT_OUTSTANDING_32: toUint32Hex(transitionResult.payload.principal.nextOutstanding),
+            NEXT_REDEEMED_32: toUint32Hex(transitionResult.payload.principal.nextRedeemed),
+            NEXT_CONTRACT_ADDRESS_HASH_256: nextStateContractAddressHash,
+            SETTLEMENT_DESCRIPTOR_HASH: settlementDescriptor.hash,
+            ...(input.expectedOutputDescriptorHash
+                ? { EXPECTED_OUTPUT_DESCRIPTOR_HASH: input.expectedOutputDescriptorHash }
+                : {}),
+            ...(settlementDescriptor.expectedOutputDescriptor?.nextOutputHash
+                ? { EXPECTED_NEXT_OUTPUT_HASH_256: settlementDescriptor.expectedOutputDescriptor.nextOutputHash }
+                : {}),
+            ...(settlementDescriptor.expectedOutputDescriptor?.nextOutputScriptHash
+                ? { EXPECTED_NEXT_OUTPUT_SCRIPT_HASH_256: settlementDescriptor.expectedOutputDescriptor.nextOutputScriptHash }
+                : {}),
+        },
+        definition: {
+            type: definitionDescriptor.definitionType,
+            id: definitionDescriptor.definitionId,
+            schemaVersion: definitionDescriptor.schemaVersion,
+            ...(definitionDescriptor.sourcePath ? { jsonPath: definitionDescriptor.sourcePath } : { value: definition }),
+            anchorMode: "on-chain-constant-committed",
+        },
+        state: {
+            type: nextDescriptor.stateType,
+            id: nextDescriptor.stateId,
+            schemaVersion: nextDescriptor.schemaVersion,
+            ...(nextDescriptor.sourcePath ? { jsonPath: nextDescriptor.sourcePath } : { value: next }),
+            anchorMode: "on-chain-constant-committed",
+        },
+        artifactPath: input.artifactPath,
+    });
+    return {
+        compiled,
+        previousHash: transitionResult.previousHash,
+        nextHash: transitionResult.nextHash,
+        transition: transitionResult.transition,
+        redeemAmount: next.lastTransition?.amount ?? 0,
+        transitionKind: "REDEEM",
+        nextStateContractAddress,
+        nextStateContractAddressHash,
+        settlementDescriptor: settlementDescriptor.descriptor,
+        settlementDescriptorHash: settlementDescriptor.hash,
+        payload: {
+            ...transitionResult.payload,
+            transitionKind: "REDEEM",
+            redeemAmount: next.lastTransition?.amount ?? 0,
+            previousStatusCode: bondStatusToCode(transitionResult.payload.previousStatus),
+            nextStatusCode: bondStatusToCode(transitionResult.payload.nextStatus),
+            contractAddress: compiled.artifact.compiled.contractAddress,
+            cmr: compiled.artifact.compiled.cmr,
+            anchorModes: {
+                definition: compiled.artifact.definition?.anchorMode ?? "none",
+                state: compiled.artifact.state?.anchorMode ?? "none",
+            },
+            nextStateContractAddress,
+            nextStateContractAddressHash,
+            settlementDescriptor: settlementDescriptor.descriptor,
+            settlementDescriptorHash: settlementDescriptor.hash,
+            outputBindingMode: settlementDescriptor.descriptor.outputBindingMode ?? "none",
+        },
+    };
+}
+async function compileBondScriptBoundSettlementMachine(sdk, input) {
+    const settlement = await buildBondSettlementDescriptor(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? 1900,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        rawOutput: input.rawOutput,
+        outputBindingMode: "script-bound",
+    });
+    const base = await compileBondRedemptionMachine(sdk, {
+        ...input,
+        outputBindingMode: "script-bound",
+        expectedOutputDescriptorHash: settlement.expectedOutputDescriptorHash,
+        simfPath: input.simfPath ?? resolveBondDocsAsset("bond-script-bound-settlement-machine.simf"),
+    });
+    return {
+        ...base,
+        expectedOutputDescriptor: settlement.expectedOutputDescriptor,
+        expectedOutputDescriptorHash: settlement.expectedOutputDescriptorHash,
+        outputBindingMode: "script-bound",
+    };
+}
+async function verifyBondScriptBoundSettlementMachineArtifact(sdk, input) {
+    const base = await verifyBondRedemptionMachineArtifact(sdk, {
+        ...input,
+        outputBindingMode: "script-bound",
+    });
+    return {
+        ...base,
+        outputBindingTrust: {
+            mode: "script-bound",
+            requestedMode: base.outputBindingMetadata.requestedMode,
+            supportedForm: base.outputBindingMetadata.supportedForm,
+            outputCountRuntimeBound: true,
+            feeIndexRuntimeBound: true,
+            settlementDescriptorCommitted: base.checks.settlementDescriptorCommitted,
+            nextContractAddressCommitted: base.checks.nextContractAddressCommitted,
+            nextOutputHashRuntimeBound: false,
+            nextOutputScriptRuntimeBound: true,
+            amountRuntimeBound: false,
+            reasonCode: base.outputBindingMetadata.reasonCode,
+            autoDerived: base.outputBindingMetadata.autoDerived,
+            fallbackReason: base.outputBindingMetadata.fallbackReason,
+            bindingInputs: base.outputBindingMetadata.bindingInputs,
+        },
+    };
+}
+async function compileBondDescriptorBoundSettlementMachine(sdk, input) {
+    const settlement = await buildBondSettlementDescriptor(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat ?? 1900,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        nextOutputHash: input.nextOutputHash,
+        rawOutput: input.rawOutput,
+        outputBindingMode: "descriptor-bound",
+    });
+    if (settlement.descriptor.outputBindingMode !== "descriptor-bound") {
+        const fallback = await compileBondScriptBoundSettlementMachine(sdk, input);
+        return {
+            ...fallback,
+            requestedOutputBindingMode: "descriptor-bound",
+            outputBindingMode: fallback.outputBindingMode,
+        };
+    }
+    const base = await compileBondRedemptionMachine(sdk, {
+        ...input,
+        nextOutputHash: settlement.expectedOutputDescriptor?.nextOutputHash,
+        outputBindingMode: "descriptor-bound",
+        expectedOutputDescriptorHash: settlement.expectedOutputDescriptorHash,
+        simfPath: input.simfPath ?? resolveBondDocsAsset("bond-descriptor-bound-settlement-machine.simf"),
+    });
+    return {
+        ...base,
+        expectedOutputDescriptor: settlement.expectedOutputDescriptor,
+        expectedOutputDescriptorHash: settlement.expectedOutputDescriptorHash,
+        requestedOutputBindingMode: "descriptor-bound",
+        outputBindingMode: "descriptor-bound",
+    };
+}
+async function verifyBondDescriptorBoundSettlementMachineArtifact(sdk, input) {
+    const base = await verifyBondRedemptionMachineArtifact(sdk, {
+        ...input,
+        outputBindingMode: "descriptor-bound",
+    });
+    const mode = base.expectedSettlementDescriptor.outputBindingMode === "descriptor-bound" && base.checks.nextOutputHashCommitted
+        ? "descriptor-bound"
+        : "script-bound";
+    return {
+        ...base,
+        outputBindingTrust: {
+            mode,
+            requestedMode: base.outputBindingMetadata.requestedMode,
+            supportedForm: base.outputBindingMetadata.supportedForm,
+            outputCountRuntimeBound: true,
+            feeIndexRuntimeBound: true,
+            settlementDescriptorCommitted: base.checks.settlementDescriptorCommitted,
+            nextContractAddressCommitted: base.checks.nextContractAddressCommitted,
+            nextOutputHashRuntimeBound: mode === "descriptor-bound",
+            nextOutputScriptRuntimeBound: mode !== "descriptor-bound",
+            amountRuntimeBound: false,
+            reasonCode: base.outputBindingMetadata.reasonCode,
+            autoDerived: base.outputBindingMetadata.autoDerived,
+            fallbackReason: base.outputBindingMetadata.fallbackReason,
+            bindingInputs: base.outputBindingMetadata.bindingInputs,
+        },
+    };
+}
+async function compileBondClosingMachine(sdk, input) {
+    const closing = await buildBondClosing(sdk, input);
+    const result = await defineBond(sdk, {
+        definitionValue: closing.definition,
+        issuanceValue: closing.closed,
+        simfPath: input.simfPath ?? resolveBondDocsAsset("bond-issuance-anchor.simf"),
+        artifactPath: input.artifactPath,
+    });
+    return {
+        compiled: result,
+        closing: closing.closing,
+        closingHash: closing.closingHash,
+        closedState: closing.closed,
+    };
+}
+async function buildBondRedemption(sdk, input) {
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const previousSource = resolveValueOrPath({
+        pathValue: input.previousIssuancePath,
+        objectValue: input.previousIssuanceValue,
+    });
+    const definitionDescriptor = await sdk.loadDefinition({
+        type: "bond",
+        id: input.definitionValue?.bondId ?? "BOND-2026-001",
+        ...definitionSource,
+    });
+    const previousDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.previousIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...previousSource,
+    });
+    const definition = (0, bondValidation_1.validateBondDefinition)(JSON.parse(definitionDescriptor.canonicalJson));
+    const previous = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(previousDescriptor.canonicalJson));
+    (0, bondValidation_1.validateBondCrossChecks)(definition, previous);
+    const next = (0, bondValidation_1.buildRedeemedBondIssuanceState)({
+        previous,
+        amount: input.amount,
+        redeemedAt: input.redeemedAt,
+    });
+    const transition = (0, bondValidation_1.validateBondStateTransition)(previous, next);
+    return {
+        definition,
+        previous,
+        next,
+        previousHash: previousDescriptor.hash,
+        nextHash: (0, bondValidation_1.summarizeBondIssuanceState)(next).hash,
+        transition,
+    };
+}
+async function verifyBondTransition(sdk, input) {
+    const previousSource = resolveValueOrPath({
+        pathValue: input.previousIssuancePath,
+        objectValue: input.previousIssuanceValue,
+    });
+    const nextSource = resolveValueOrPath({
+        pathValue: input.nextIssuancePath,
+        objectValue: input.nextIssuanceValue,
+    });
+    const previousDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.previousIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...previousSource,
+    });
+    const nextDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.nextIssuanceValue?.issuanceId ?? "BOND-2026-001-ISSUE-1",
+        ...nextSource,
+    });
+    const previous = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(previousDescriptor.canonicalJson));
+    const next = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(nextDescriptor.canonicalJson));
+    const transition = (0, bondValidation_1.validateBondStateTransition)(previous, next);
+    return {
+        previous,
+        next,
+        previousHash: previousDescriptor.hash,
+        nextHash: nextDescriptor.hash,
+        transition,
+    };
+}
+async function buildBondRolloverPlan(sdk, input) {
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new Error("currentArtifactPath or currentArtifact is required");
+    }
+    const currentVerification = await verifyBond(sdk, {
+        artifact: currentArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        issuancePath: input.previousIssuancePath,
+        issuanceValue: input.previousIssuanceValue,
+    });
+    const definitionValue = (0, bondValidation_1.validateBondDefinition)(JSON.parse(currentVerification.definition.definition.canonicalJson));
+    const nextIssuanceSource = resolveValueOrPath({
+        pathValue: input.nextIssuancePath,
+        objectValue: input.nextIssuanceValue,
+    });
+    const nextInitialStateDescriptor = await sdk.loadStateDocument({
+        type: "bond-issuance",
+        id: input.nextIssuanceValue?.issuanceId ?? currentArtifact.state?.stateId ?? "BOND-2026-001-ISSUE-1",
+        ...nextIssuanceSource,
+    });
+    const nextIssuance = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(nextInitialStateDescriptor.canonicalJson));
+    (0, bondValidation_1.validateBondCrossChecks)(definitionValue, nextIssuance);
+    const transitionPayload = await buildBondTransitionPayload(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: currentVerification.issuance
+            ? (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(currentVerification.issuance.state.canonicalJson))
+            : input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: nextIssuance,
+    });
+    const nextCompiled = await defineBond(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue,
+        issuanceValue: nextIssuance,
+        simfPath: input.nextSimfPath,
+        artifactPath: input.nextArtifactPath,
+    });
+    return {
+        currentArtifact,
+        currentVerification,
+        nextCompiled,
+        nextContractAddress: nextCompiled.deployment().contractAddress,
+        transitionPayload: transitionPayload.payload,
+    };
+}
+async function buildBondMachineRolloverPlan(sdk, input) {
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new Error("currentArtifactPath or currentArtifact is required");
+    }
+    const currentVerification = await verifyBond(sdk, {
+        artifact: currentArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        issuancePath: input.previousIssuancePath,
+        issuanceValue: input.previousIssuanceValue,
+    });
+    const machineCompiled = await compileBondRedemptionMachine(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        simfPath: input.machineSimfPath,
+        artifactPath: input.machineArtifactPath,
+    });
+    const machineVerification = await verifyBondRedemptionMachineArtifact(sdk, {
+        artifact: machineCompiled.compiled.artifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+    });
+    return {
+        currentArtifact,
+        currentVerification,
+        machineCompiled,
+        machineVerification,
+        nextContractAddress: machineCompiled.compiled.deployment().contractAddress,
+        transitionPayload: machineCompiled.payload,
+    };
+}
+async function buildBondScriptBoundMachineRolloverPlan(sdk, input) {
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new Error("currentArtifactPath or currentArtifact is required");
+    }
+    const currentVerification = await verifyBond(sdk, {
+        artifact: currentArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        issuancePath: input.previousIssuancePath,
+        issuanceValue: input.previousIssuanceValue,
+    });
+    const machineCompiled = await compileBondScriptBoundSettlementMachine(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat,
+        simfPath: input.machineSimfPath,
+        artifactPath: input.machineArtifactPath,
+    });
+    const machineVerification = await verifyBondScriptBoundSettlementMachineArtifact(sdk, {
+        artifact: machineCompiled.compiled.artifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat,
+    });
+    return {
+        currentArtifact,
+        currentVerification,
+        machineCompiled,
+        machineVerification,
+        nextContractAddress: machineCompiled.compiled.deployment().contractAddress,
+        transitionPayload: machineCompiled.payload,
+    };
+}
+async function buildBondDescriptorBoundMachineRolloverPlan(sdk, input) {
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new Error("currentArtifactPath or currentArtifact is required");
+    }
+    const currentVerification = await verifyBond(sdk, {
+        artifact: currentArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        issuancePath: input.previousIssuancePath,
+        issuanceValue: input.previousIssuanceValue,
+    });
+    const machineCompiled = await compileBondDescriptorBoundSettlementMachine(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+        simfPath: input.machineSimfPath,
+        artifactPath: input.machineArtifactPath,
+    });
+    const machineVerification = await verifyBondDescriptorBoundSettlementMachineArtifact(sdk, {
+        artifact: machineCompiled.compiled.artifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextStateSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+    });
+    return {
+        currentArtifact,
+        currentVerification,
+        machineCompiled,
+        machineVerification,
+        nextContractAddress: machineCompiled.compiled.deployment().contractAddress,
+        transitionPayload: machineCompiled.payload,
+    };
+}
+async function buildBondMachineSettlementPlan(sdk, input) {
+    const currentMachineArtifact = input.currentMachineArtifact
+        ?? (input.currentMachineArtifactPath ? (await sdk.loadArtifact(input.currentMachineArtifactPath)).artifact : undefined);
+    if (!currentMachineArtifact) {
+        throw new Error("currentMachineArtifactPath or currentMachineArtifact is required");
+    }
+    const machineVerification = await verifyBondRedemptionMachineArtifact(sdk, {
+        artifact: currentMachineArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextSimfPath,
+    });
+    const definitionValue = (0, bondValidation_1.validateBondDefinition)(JSON.parse(machineVerification.definition.definition.canonicalJson));
+    const nextStateValue = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(machineVerification.issuance.state.canonicalJson));
+    const nextCompiled = await defineBond(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue,
+        issuanceValue: nextStateValue,
+        simfPath: input.nextSimfPath,
+        artifactPath: input.nextArtifactPath,
+    });
+    return {
+        currentMachineArtifact,
+        machineVerification,
+        nextCompiled,
+        nextContractAddress: nextCompiled.deployment().contractAddress,
+        transitionPayload: machineVerification.expectedPayload,
+        nextContractAddressMatchesMachineCommitment: nextCompiled.deployment().contractAddress === machineVerification.expectedNextContractAddress,
+    };
+}
+async function buildBondScriptBoundMachineSettlementPlan(sdk, input) {
+    const currentMachineArtifact = input.currentMachineArtifact
+        ?? (input.currentMachineArtifactPath ? (await sdk.loadArtifact(input.currentMachineArtifactPath)).artifact : undefined);
+    if (!currentMachineArtifact) {
+        throw new Error("currentMachineArtifactPath or currentMachineArtifact is required");
+    }
+    const machineVerification = await verifyBondScriptBoundSettlementMachineArtifact(sdk, {
+        artifact: currentMachineArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat,
+    });
+    const definitionValue = (0, bondValidation_1.validateBondDefinition)(JSON.parse(machineVerification.definition.definition.canonicalJson));
+    const nextStateValue = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(machineVerification.issuance.state.canonicalJson));
+    const nextCompiled = await defineBond(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue,
+        issuanceValue: nextStateValue,
+        simfPath: input.nextSimfPath,
+        artifactPath: input.nextArtifactPath,
+    });
+    return {
+        currentMachineArtifact,
+        machineVerification,
+        nextCompiled,
+        nextContractAddress: nextCompiled.deployment().contractAddress,
+        transitionPayload: machineVerification.expectedPayload,
+        nextContractAddressMatchesMachineCommitment: nextCompiled.deployment().contractAddress === machineVerification.expectedNextContractAddress,
+    };
+}
+async function buildBondDescriptorBoundMachineSettlementPlan(sdk, input) {
+    const currentMachineArtifact = input.currentMachineArtifact
+        ?? (input.currentMachineArtifactPath ? (await sdk.loadArtifact(input.currentMachineArtifactPath)).artifact : undefined);
+    if (!currentMachineArtifact) {
+        throw new Error("currentMachineArtifactPath or currentMachineArtifact is required");
+    }
+    const machineVerification = await verifyBondDescriptorBoundSettlementMachineArtifact(sdk, {
+        artifact: currentMachineArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        previousIssuancePath: input.previousIssuancePath,
+        previousIssuanceValue: input.previousIssuanceValue,
+        nextIssuancePath: input.nextIssuancePath,
+        nextIssuanceValue: input.nextIssuanceValue,
+        nextStateSimfPath: input.nextSimfPath,
+        nextAmountSat: input.nextAmountSat,
+        maxFeeSat: input.maxFeeSat,
+        nextOutputHash: input.nextOutputHash,
+    });
+    const definitionValue = (0, bondValidation_1.validateBondDefinition)(JSON.parse(machineVerification.definition.definition.canonicalJson));
+    const nextStateValue = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(machineVerification.issuance.state.canonicalJson));
+    const nextCompiled = await defineBond(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue,
+        issuanceValue: nextStateValue,
+        simfPath: input.nextSimfPath,
+        artifactPath: input.nextArtifactPath,
+    });
+    return {
+        currentMachineArtifact,
+        machineVerification,
+        nextCompiled,
+        nextContractAddress: nextCompiled.deployment().contractAddress,
+        transitionPayload: machineVerification.expectedPayload,
+        nextContractAddressMatchesMachineCommitment: nextCompiled.deployment().contractAddress === machineVerification.expectedNextContractAddress,
+    };
+}
+async function inspectBondStateRollover(sdk, input) {
+    const plan = await buildBondRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function inspectBondMachineRollover(sdk, input) {
+    const plan = await buildBondMachineRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function inspectBondScriptBoundMachineRollover(sdk, input) {
+    const plan = await buildBondScriptBoundMachineRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function inspectBondDescriptorBoundMachineRollover(sdk, input) {
+    const plan = await buildBondDescriptorBoundMachineRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function inspectBondMachineSettlement(sdk, input) {
+    const plan = await buildBondMachineSettlementPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentMachineArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function inspectBondScriptBoundMachineSettlement(sdk, input) {
+    const plan = await buildBondScriptBoundMachineSettlementPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentMachineArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function inspectBondDescriptorBoundMachineSettlement(sdk, input) {
+    const plan = await buildBondDescriptorBoundMachineSettlementPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentMachineArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function buildBondClosingPlan(sdk, input) {
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new Error("currentArtifactPath or currentArtifact is required");
+    }
+    const currentVerification = await verifyBond(sdk, {
+        artifact: currentArtifact,
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        issuancePath: input.redeemedIssuancePath,
+        issuanceValue: input.redeemedIssuanceValue,
+    });
+    const closingCompiled = await compileBondClosingMachine(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        redeemedIssuancePath: input.redeemedIssuancePath,
+        redeemedIssuanceValue: input.redeemedIssuanceValue,
+        settlementDescriptorPath: input.settlementDescriptorPath,
+        settlementDescriptorValue: input.settlementDescriptorValue,
+        closedAt: input.closedAt,
+        closingReason: input.closingReason,
+        simfPath: input.closedIssuanceSimfPath,
+        artifactPath: input.closingArtifactPath,
+    });
+    const closingVerification = await verifyBondClosing(sdk, {
+        definitionPath: input.definitionPath,
+        definitionValue: input.definitionValue,
+        redeemedIssuancePath: input.redeemedIssuancePath,
+        redeemedIssuanceValue: input.redeemedIssuanceValue,
+        closedIssuanceValue: closingCompiled.closedState,
+        settlementDescriptorPath: input.settlementDescriptorPath,
+        settlementDescriptorValue: input.settlementDescriptorValue,
+        closingDescriptorValue: closingCompiled.closing,
+    });
+    return {
+        currentArtifact,
+        currentVerification,
+        closingCompiled,
+        closingVerification,
+        nextContractAddress: closingCompiled.compiled.deployment().contractAddress,
+        closingDescriptor: closingCompiled.closing,
+        closingHash: closingCompiled.closingHash,
+        closedState: closingCompiled.closedState,
+    };
+}
+async function executeBondStateRollover(sdk, input) {
+    const plan = await buildBondRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}
+async function executeBondMachineRollover(sdk, input) {
+    const plan = await buildBondMachineRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}
+async function executeBondScriptBoundMachineRollover(sdk, input) {
+    const plan = await buildBondScriptBoundMachineRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}
+async function executeBondDescriptorBoundMachineRollover(sdk, input) {
+    const plan = await buildBondDescriptorBoundMachineRolloverPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}
+async function executeBondMachineSettlement(sdk, input) {
+    const plan = await buildBondMachineSettlementPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentMachineArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}
+async function executeBondScriptBoundMachineSettlement(sdk, input) {
+    const plan = await buildBondScriptBoundMachineSettlementPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentMachineArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}
+async function executeBondDescriptorBoundMachineSettlement(sdk, input) {
+    const plan = await buildBondDescriptorBoundMachineSettlementPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentMachineArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}
+async function inspectBondClosing(sdk, input) {
+    const plan = await buildBondClosingPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const inspect = await contract.inspectCall({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+    });
+    return { plan, inspect };
+}
+async function executeBondClosing(sdk, input) {
+    const plan = await buildBondClosingPlan(sdk, input);
+    const contract = sdk.fromArtifact(plan.currentArtifact);
+    const execution = await contract.execute({
+        wallet: input.wallet,
+        toAddress: plan.nextContractAddress,
+        signer: input.signer,
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        broadcast: input.broadcast,
+    });
+    return { plan, execution };
+}