@hazbase/simplicity 0.0.5 → 0.2.0

package/dist/domain/bond.js

@@ -40,27 +40,77 @@ exports.defineBond = defineBond;
 exports.verifyBond = verifyBond;
 exports.loadBond = loadBond;
 exports.buildBondPayload = buildBondPayload;
+exports.verifyIssuanceHistory = verifyIssuanceHistory;
+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 reporting_1 = require("../core/reporting");
 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) {
@@ -70,6 +120,106 @@ 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 loadIssuanceHistoryDocuments(sdk, input) {
+    const results = [];
+    for (const issuancePath of input.issuanceHistoryPaths ?? []) {
+        const state = await sdk.loadStateDocument({
+            type: "bond-issuance",
+            id: "BOND-ISSUANCE-HISTORY",
+            jsonPath: issuancePath,
+        });
+        const value = (0, bondValidation_1.validateBondIssuanceState)(JSON.parse(state.canonicalJson));
+        results.push({
+            state,
+            value,
+            summary: (0, bondValidation_1.summarizeBondIssuanceState)(value),
+        });
+    }
+    for (const issuanceValue of input.issuanceHistoryValues ?? []) {
+        const value = (0, bondValidation_1.validateBondIssuanceState)(issuanceValue);
+        const state = await sdk.loadStateDocument({
+            type: "bond-issuance",
+            id: value.issuanceId,
+            value,
+        });
+        results.push({
+            state,
+            value,
+            summary: (0, bondValidation_1.summarizeBondIssuanceState)(value),
+        });
+    }
+    return results;
+}
+function buildBondIssuanceLineageTrust(checks) {
+    const identityConsistent = checks.issuanceIdConsistent
+        && checks.bondIdConsistent
+        && checks.currencyConsistent
+        && checks.controllerConsistent
+        && checks.issuerEntityConsistent
+        && checks.issuedPrincipalConsistent
+        && checks.allTransitionIdentitiesMatch;
+    return {
+        ...(0, reporting_1.buildLineageTrustBase)({
+            lineageKind: "state-history",
+            chainLength: checks.chainLength,
+            latestOrdinal: Math.max(0, checks.chainLength - 1),
+            allHashLinksVerified: checks.previousStateHashLinked && checks.allPreviousStateHashMatch,
+            identityConsistent,
+            fullLineageVerified: checks.fullHistoryVerified,
+        }),
+        latestStatus: checks.latestStatus,
+        startsAtGenesis: checks.startsAtGenesis,
+        previousStateHashLinked: checks.previousStateHashLinked,
+        issuanceIdConsistent: checks.issuanceIdConsistent,
+        bondIdConsistent: checks.bondIdConsistent,
+        currencyConsistent: checks.currencyConsistent,
+        controllerConsistent: checks.controllerConsistent,
+        issuerEntityConsistent: checks.issuerEntityConsistent,
+        issuedPrincipalConsistent: checks.issuedPrincipalConsistent,
+        allPreviousStateHashMatch: checks.allPreviousStateHashMatch,
+        allRedemptionArithmeticValid: checks.allRedemptionArithmeticValid,
+        allStatusProgressionValid: checks.allStatusProgressionValid,
+        allTransitionIdentitiesMatch: checks.allTransitionIdentitiesMatch,
+        fullHistoryVerified: checks.fullHistoryVerified,
+    };
+}
+function buildEmptyBondDefinitionTrust() {
+    return {
+        artifactMatch: false,
+        onChainAnchorPresent: false,
+        onChainAnchorVerified: false,
+        effectiveMode: "none",
+    };
+}
+function buildEmptyBondStateTrust() {
+    return {
+        artifactMatch: false,
+        onChainAnchorPresent: false,
+        onChainAnchorVerified: false,
+        effectiveMode: "none",
+    };
+}
+function buildBaseBondReport(input) {
+    return (0, reporting_1.buildVerificationTrustSections)({
+        definitionTrust: input?.definitionTrust,
+        stateTrust: input?.stateTrust,
+        requireArtifactTrust: input?.requireArtifactTrust,
+        emptyDefinitionTrust: buildEmptyBondDefinitionTrust(),
+        emptyStateTrust: buildEmptyBondStateTrust(),
+    });
+}
 async function defineBond(sdk, input) {
     const definitionSource = resolveValueOrPath({
         pathValue: input.definitionPath,
@@ -102,7 +252,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: {
@@ -186,6 +336,15 @@ async function buildBondPayload(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);
+    const issuanceHistory = input.issuanceHistoryPaths || input.issuanceHistoryValues
+        ? await loadIssuanceHistoryDocuments(sdk, {
+            issuanceHistoryPaths: input.issuanceHistoryPaths,
+            issuanceHistoryValues: input.issuanceHistoryValues,
+        })
+        : [];
+    const lineageChecks = issuanceHistory.length > 0
+        ? (0, bondValidation_1.verifyBondIssuanceHistory)({ history: issuanceHistory.map((entry) => entry.value) })
+        : undefined;
     return {
         artifact: verification.artifact,
         payload: {
@@ -218,6 +377,45 @@ async function buildBondPayload(sdk, input) {
         trust: {
             definitionTrust: verification.definition.trust,
             issuanceTrust: verification.issuance.trust,
+            issuanceLineageTrust: lineageChecks ? buildBondIssuanceLineageTrust(lineageChecks) : undefined,
+        },
+        ...(issuanceHistory.length > 0
+            ? {
+                issuanceHistory: issuanceHistory.map((entry) => entry.state),
+                issuanceHistoryValues: issuanceHistory.map((entry) => entry.value),
+                issuanceHistorySummaries: issuanceHistory.map((entry) => entry.summary),
+            }
+            : {}),
+    };
+}
+async function verifyIssuanceHistory(sdk, input) {
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.definitionPath,
+        objectValue: input.definitionValue,
+    });
+    const definition = input.definitionPath || input.definitionValue
+        ? await sdk.loadDefinition({
+            type: "bond",
+            id: input.definitionValue?.bondId ?? "BOND-2026-001",
+            ...definitionSource,
+        })
+        : undefined;
+    const definitionValue = definition ? (0, bondValidation_1.validateBondDefinition)(JSON.parse(definition.canonicalJson)) : undefined;
+    const issuanceHistory = await loadIssuanceHistoryDocuments(sdk, input);
+    const checks = (0, bondValidation_1.verifyBondIssuanceHistory)({ history: issuanceHistory.map((entry) => entry.value) });
+    if (definitionValue) {
+        (0, bondValidation_1.validateBondCrossChecks)(definitionValue, issuanceHistory.at(-1).value);
+    }
+    return {
+        verified: checks.fullHistoryVerified,
+        ...(definition ? { definition, definitionValue } : {}),
+        issuanceHistory: issuanceHistory.map((entry) => entry.state),
+        issuanceHistoryValues: issuanceHistory.map((entry) => entry.value),
+        issuanceHistorySummaries: issuanceHistory.map((entry) => entry.summary),
+        checks,
+        report: {
+            ...buildBaseBondReport({ requireArtifactTrust: true }),
+            issuanceLineageTrust: buildBondIssuanceLineageTrust(checks),
         },
     };
 }
@@ -263,12 +461,223 @@ function bondStatusToCode(status) {
             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,
@@ -307,7 +716,7 @@ async function redeemBond(sdk, input) {
         id: nextIssuance.issuanceId,
         value: nextIssuance,
     });
-    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: {
@@ -413,6 +822,17 @@ async function buildBondSettlementDescriptor(sdk, input) {
         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}`,
@@ -430,6 +850,8 @@ async function buildBondSettlementDescriptor(sdk, input) {
         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,
@@ -446,6 +868,13 @@ async function buildBondSettlementDescriptor(sdk, input) {
         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,
     };
@@ -468,6 +897,10 @@ async function verifyBondSettlementDescriptor(sdk, input) {
         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);
@@ -479,6 +912,11 @@ async function verifyBondSettlementDescriptor(sdk, input) {
         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) {
@@ -486,6 +924,13 @@ async function buildBondSettlementPayload(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,
@@ -493,6 +938,440 @@ async function buildBondSettlementPayload(sdk, input) {
         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 issuanceHistory = input.issuanceHistoryPaths || input.issuanceHistoryValues
+        ? await loadIssuanceHistoryDocuments(sdk, {
+            issuanceHistoryPaths: input.issuanceHistoryPaths,
+            issuanceHistoryValues: input.issuanceHistoryValues,
+        })
+        : [];
+    const lineageChecks = issuanceHistory.length > 0
+        ? (0, bondValidation_1.verifyBondIssuanceHistory)({ history: issuanceHistory.map((entry) => entry.value) })
+        : undefined;
+    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: {
+            ...buildBaseBondReport({
+                definitionTrust: verification.definition.trust,
+                stateTrust: verification.issuance.trust,
+            }),
+            issuanceLineageTrust: lineageChecks ? buildBondIssuanceLineageTrust(lineageChecks) : undefined,
+            settlementTrust: input.settlementDescriptorValue
+                ? {
+                    descriptorHashMatch: true,
+                    outputBindingMode: input.settlementDescriptorValue.outputBindingMode ?? "none",
+                }
+                : undefined,
+        },
+        trustSummary: (0, reporting_1.buildVerificationTrustSummary)({
+            definitionTrust: verification.definition.trust,
+            stateTrust: verification.issuance.trust,
+            bindingMode: input.settlementDescriptorValue?.outputBindingMode ?? "none",
+            lineageTrust: lineageChecks ? buildBondIssuanceLineageTrust(lineageChecks) : 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: evidence.trustSummary,
+        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,
@@ -520,7 +1399,7 @@ async function compileBondTransition(sdk, input) {
         id: transitionPayload.next.issuanceId,
         ...nextSource,
     });
-    const simfPath = input.simfPath ?? node_path_1.default.resolve(process.cwd(), "docs/definitions/bond-redemption-transition.simf");
+    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) {
@@ -605,6 +1484,10 @@ async function verifyBondRedemptionMachineArtifact(sdk, input) {
         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 = {
@@ -619,7 +1502,10 @@ async function verifyBondRedemptionMachineArtifact(sdk, input) {
         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,
@@ -633,7 +1519,14 @@ async function verifyBondRedemptionMachineArtifact(sdk, input) {
             && 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 {
@@ -647,6 +1540,16 @@ async function verifyBondRedemptionMachineArtifact(sdk, input) {
         },
         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,
@@ -705,8 +1608,12 @@ async function compileBondRedemptionMachine(sdk, input) {
         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 ?? node_path_1.default.resolve(process.cwd(), "docs/definitions/bond-redemption-state-machine.simf");
+    const simfPath = input.simfPath ?? resolveBondDocsAsset("bond-redemption-state-machine.simf");
     const compiled = await sdk.compileFromFile({
         simfPath,
         templateVars: {
@@ -724,6 +1631,15 @@ async function compileBondRedemptionMachine(sdk, input) {
             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,
@@ -768,13 +1684,147 @@ async function compileBondRedemptionMachine(sdk, input) {
             nextStateContractAddressHash,
             settlementDescriptor: settlementDescriptor.descriptor,
             settlementDescriptorHash: settlementDescriptor.hash,
+            outputBindingMode: settlementDescriptor.descriptor.outputBindingMode ?? "none",
         },
     };
 }
-async function buildBondRedemption(sdk, input) {
-    const definitionSource = resolveValueOrPath({
-        pathValue: input.definitionPath,
-        objectValue: input.definitionValue,
+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,
@@ -931,6 +1981,102 @@ async function buildBondMachineRolloverPlan(sdk, input) {
         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);
@@ -965,6 +2111,79 @@ async function buildBondMachineSettlementPlan(sdk, input) {
         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);
@@ -989,6 +2208,30 @@ async function inspectBondMachineRollover(sdk, input) {
     });
     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);
@@ -1001,6 +2244,76 @@ async function inspectBondMachineSettlement(sdk, input) {
     });
     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);
@@ -1027,6 +2340,32 @@ async function executeBondMachineRollover(sdk, input) {
     });
     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);
@@ -1040,3 +2379,54 @@ async function executeBondMachineSettlement(sdk, input) {
     });
     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 };
+}