@hazbase/simplicity 0.0.4 → 0.0.5

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,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineBond = defineBond;
 exports.verifyBond = verifyBond;
 exports.loadBond = loadBond;
+exports.buildBondPayload = buildBondPayload;
+exports.redeemBond = redeemBond;
+exports.buildBondTransitionPayload = buildBondTransitionPayload;
+exports.buildBondSettlementDescriptor = buildBondSettlementDescriptor;
+exports.verifyBondSettlementDescriptor = verifyBondSettlementDescriptor;
+exports.buildBondSettlementPayload = buildBondSettlementPayload;
+exports.compileBondTransition = compileBondTransition;
+exports.verifyBondRedemptionMachineArtifact = verifyBondRedemptionMachineArtifact;
+exports.compileBondRedemptionMachine = compileBondRedemptionMachine;
+exports.buildBondRedemption = buildBondRedemption;
+exports.verifyBondTransition = verifyBondTransition;
+exports.buildBondRolloverPlan = buildBondRolloverPlan;
+exports.buildBondMachineRolloverPlan = buildBondMachineRolloverPlan;
+exports.buildBondMachineSettlementPlan = buildBondMachineSettlementPlan;
+exports.inspectBondStateRollover = inspectBondStateRollover;
+exports.inspectBondMachineRollover = inspectBondMachineRollover;
+exports.inspectBondMachineSettlement = inspectBondMachineSettlement;
+exports.executeBondStateRollover = executeBondStateRollover;
+exports.executeBondMachineRollover = executeBondMachineRollover;
+exports.executeBondMachineSettlement = executeBondMachineSettlement;
 const node_path_1 = __importDefault(require("node:path"));
+const summary_1 = require("../core/summary");
+const bondSettlementValidation_1 = require("./bondSettlementValidation");
 const bondValidation_1 = require("./bondValidation");
 function resolveValueOrPath(options) {
     if (options.pathValue)
@@ -126,3 +181,862 @@ 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;
+        default: {
+            const exhaustiveCheck = status;
+            throw new Error(`Unsupported bond status: ${exhaustiveCheck}`);
+        }
+    }
+}
+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 ?? node_path_1.default.resolve(process.cwd(), "docs/definitions/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 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,
+        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,
+        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,
+    });
+    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,
+    };
+}
+async function buildBondSettlementPayload(sdk, input) {
+    const result = await buildBondSettlementDescriptor(sdk, input);
+    return {
+        descriptor: result.descriptor,
+        descriptorHash: result.hash,
+        previousStateHash: result.descriptor.previousStateHash,
+        nextStateHash: result.descriptor.nextStateHash,
+        nextContractAddress: result.descriptor.nextContractAddress,
+        nextAmountSat: result.descriptor.nextAmountSat,
+        maxFeeSat: result.descriptor.maxFeeSat,
+    };
+}
+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 ?? node_path_1.default.resolve(process.cwd(), "docs/definitions/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,
+    });
+    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 ?? ""),
+        settlementDescriptorHash256: String(templateVars.SETTLEMENT_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,
+        settlementDescriptorCommitted: committed.settlementDescriptorHash256 === expectedSettlement.hash,
+    };
+    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,
+        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,
+    });
+    const simfPath = input.simfPath ?? node_path_1.default.resolve(process.cwd(), "docs/definitions/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,
+        },
+        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,
+        },
+    };
+}
+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 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 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 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 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 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 };
+}