@hazbase/simplicity 0.0.3 → 0.0.5

package/dist/domain/bondSettlementValidation.d.ts

@@ -0,0 +1,18 @@
+import { BondSettlementDescriptor } from "../core/types";
+export declare function summarizeBondSettlementDescriptor(descriptor: BondSettlementDescriptor): {
+    canonicalJson: string;
+    hash: string;
+};
+export declare function validateBondSettlementDescriptor(value: unknown): BondSettlementDescriptor;
+export declare function validateBondSettlementMatchesExpected(actual: BondSettlementDescriptor, expected: BondSettlementDescriptor): {
+    bondIdMatch: boolean;
+    issuanceIdMatch: boolean;
+    definitionHashMatch: boolean;
+    previousStateHashMatch: boolean;
+    nextStateHashMatch: boolean;
+    nextContractAddressMatch: boolean;
+    redeemAmountMatch: boolean;
+    assetIdMatch: boolean;
+    nextAmountSatMatch: boolean;
+    maxFeeSatMatch: boolean;
+};

package/dist/domain/bondSettlementValidation.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeBondSettlementDescriptor = summarizeBondSettlementDescriptor;
+exports.validateBondSettlementDescriptor = validateBondSettlementDescriptor;
+exports.validateBondSettlementMatchesExpected = validateBondSettlementMatchesExpected;
+const summary_1 = require("../core/summary");
+const errors_1 = require("../core/errors");
+function assertNonEmptyString(value, code, message) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new errors_1.ValidationError(message, { code });
+    }
+}
+function assertFiniteNumber(value, code, message) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new errors_1.ValidationError(message, { code });
+    }
+}
+function summarizeBondSettlementDescriptor(descriptor) {
+    const canonicalJson = (0, summary_1.stableStringify)(descriptor);
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function validateBondSettlementDescriptor(value) {
+    const descriptor = value;
+    assertNonEmptyString(descriptor?.settlementId, "BOND_SETTLEMENT_ID_INVALID", "settlementId must be a non-empty string");
+    assertNonEmptyString(descriptor?.bondId, "BOND_SETTLEMENT_BOND_ID_INVALID", "bondId must be a non-empty string");
+    assertNonEmptyString(descriptor?.issuanceId, "BOND_SETTLEMENT_ISSUANCE_ID_INVALID", "issuanceId must be a non-empty string");
+    assertNonEmptyString(descriptor?.definitionHash, "BOND_SETTLEMENT_DEFINITION_HASH_INVALID", "definitionHash must be a non-empty string");
+    assertNonEmptyString(descriptor?.previousStateHash, "BOND_SETTLEMENT_PREVIOUS_STATE_HASH_INVALID", "previousStateHash must be a non-empty string");
+    assertNonEmptyString(descriptor?.nextStateHash, "BOND_SETTLEMENT_NEXT_STATE_HASH_INVALID", "nextStateHash must be a non-empty string");
+    assertNonEmptyString(descriptor?.transitionAt, "BOND_SETTLEMENT_TRANSITION_AT_INVALID", "transitionAt must be a non-empty string");
+    assertNonEmptyString(descriptor?.assetId, "BOND_SETTLEMENT_ASSET_INVALID", "assetId must be a non-empty string");
+    assertNonEmptyString(descriptor?.nextContractAddress, "BOND_SETTLEMENT_NEXT_CONTRACT_INVALID", "nextContractAddress must be a non-empty string");
+    assertFiniteNumber(descriptor?.redeemAmount, "BOND_SETTLEMENT_REDEEM_AMOUNT_INVALID", "redeemAmount must be a finite number");
+    assertFiniteNumber(descriptor?.nextAmountSat, "BOND_SETTLEMENT_AMOUNT_INVALID", "nextAmountSat must be a finite number");
+    assertFiniteNumber(descriptor?.maxFeeSat, "BOND_SETTLEMENT_MAX_FEE_INVALID", "maxFeeSat must be a finite number");
+    assertFiniteNumber(descriptor?.principal?.issued, "BOND_SETTLEMENT_PRINCIPAL_INVALID", "principal.issued must be a finite number");
+    assertFiniteNumber(descriptor?.principal?.previousOutstanding, "BOND_SETTLEMENT_PRINCIPAL_INVALID", "principal.previousOutstanding must be a finite number");
+    assertFiniteNumber(descriptor?.principal?.nextOutstanding, "BOND_SETTLEMENT_PRINCIPAL_INVALID", "principal.nextOutstanding must be a finite number");
+    assertFiniteNumber(descriptor?.principal?.previousRedeemed, "BOND_SETTLEMENT_PRINCIPAL_INVALID", "principal.previousRedeemed must be a finite number");
+    assertFiniteNumber(descriptor?.principal?.nextRedeemed, "BOND_SETTLEMENT_PRINCIPAL_INVALID", "principal.nextRedeemed must be a finite number");
+    if (descriptor.transitionKind !== "REDEEM") {
+        throw new errors_1.ValidationError("transitionKind must be REDEEM", {
+            code: "BOND_SETTLEMENT_TRANSITION_KIND_INVALID",
+        });
+    }
+    if (descriptor.redeemAmount <= 0) {
+        throw new errors_1.ValidationError("redeemAmount must be greater than 0", {
+            code: "BOND_SETTLEMENT_REDEEM_AMOUNT_INVALID",
+        });
+    }
+    if (descriptor.nextAmountSat <= 0) {
+        throw new errors_1.ValidationError("nextAmountSat must be greater than 0", {
+            code: "BOND_SETTLEMENT_AMOUNT_INVALID",
+        });
+    }
+    if (descriptor.maxFeeSat < 0) {
+        throw new errors_1.ValidationError("maxFeeSat must not be negative", {
+            code: "BOND_SETTLEMENT_MAX_FEE_INVALID",
+        });
+    }
+    if (Number.isNaN(Date.parse(descriptor.transitionAt))) {
+        throw new errors_1.ValidationError("transitionAt must be an ISO8601 string", {
+            code: "BOND_SETTLEMENT_TRANSITION_AT_INVALID",
+        });
+    }
+    return descriptor;
+}
+function validateBondSettlementMatchesExpected(actual, expected) {
+    const result = {
+        bondIdMatch: actual.bondId === expected.bondId,
+        issuanceIdMatch: actual.issuanceId === expected.issuanceId,
+        definitionHashMatch: actual.definitionHash === expected.definitionHash,
+        previousStateHashMatch: actual.previousStateHash === expected.previousStateHash,
+        nextStateHashMatch: actual.nextStateHash === expected.nextStateHash,
+        nextContractAddressMatch: actual.nextContractAddress === expected.nextContractAddress,
+        redeemAmountMatch: actual.redeemAmount === expected.redeemAmount,
+        assetIdMatch: actual.assetId === expected.assetId,
+        nextAmountSatMatch: actual.nextAmountSat === expected.nextAmountSat,
+        maxFeeSatMatch: actual.maxFeeSat === expected.maxFeeSat,
+    };
+    if (!result.bondIdMatch) {
+        throw new errors_1.ValidationError("Bond settlement bondId does not match expected value", {
+            code: "BOND_SETTLEMENT_BOND_ID_MISMATCH",
+        });
+    }
+    if (!result.issuanceIdMatch) {
+        throw new errors_1.ValidationError("Bond settlement issuanceId does not match expected value", {
+            code: "BOND_SETTLEMENT_ISSUANCE_ID_MISMATCH",
+        });
+    }
+    if (!result.definitionHashMatch) {
+        throw new errors_1.ValidationError("Bond settlement definitionHash does not match expected value", {
+            code: "BOND_SETTLEMENT_DEFINITION_HASH_MISMATCH",
+        });
+    }
+    if (!result.previousStateHashMatch || !result.nextStateHashMatch) {
+        throw new errors_1.ValidationError("Bond settlement state hashes do not match expected values", {
+            code: "BOND_SETTLEMENT_STATE_HASH_MISMATCH",
+        });
+    }
+    if (!result.nextContractAddressMatch) {
+        throw new errors_1.ValidationError("Bond settlement nextContractAddress does not match expected value", {
+            code: "BOND_SETTLEMENT_NEXT_CONTRACT_MISMATCH",
+        });
+    }
+    if (!result.redeemAmountMatch) {
+        throw new errors_1.ValidationError("Bond settlement redeemAmount does not match expected value", {
+            code: "BOND_SETTLEMENT_REDEEM_AMOUNT_MISMATCH",
+        });
+    }
+    if (!result.assetIdMatch) {
+        throw new errors_1.ValidationError("Bond settlement assetId does not match expected value", {
+            code: "BOND_SETTLEMENT_ASSET_MISMATCH",
+        });
+    }
+    if (!result.nextAmountSatMatch || !result.maxFeeSatMatch) {
+        throw new errors_1.ValidationError("Bond settlement amount constraints do not match expected values", {
+            code: "BOND_SETTLEMENT_AMOUNT_INVALID",
+        });
+    }
+    return result;
+}

package/dist/domain/bondValidation.d.ts

@@ -0,0 +1,29 @@
+import { BondDefinition, BondIssuanceState } from "../core/types";
+export declare function summarizeBondIssuanceState(state: BondIssuanceState): {
+    canonicalJson: string;
+    hash: string;
+};
+export declare function validateBondDefinition(value: unknown): BondDefinition;
+export declare function validateBondIssuanceState(value: unknown): BondIssuanceState;
+export declare function validateBondCrossChecks(definition: BondDefinition, issuance: BondIssuanceState): {
+    bondIdMatch: boolean;
+    currencyMatch: boolean;
+    controllerMatch: boolean;
+    principalInvariantValid: boolean;
+};
+export declare function validateBondStateTransition(previous: BondIssuanceState, next: BondIssuanceState): {
+    issuanceIdMatch: boolean;
+    bondIdMatch: boolean;
+    currencyMatch: boolean;
+    controllerMatch: boolean;
+    issuerEntityMatch: boolean;
+    issuedPrincipalMatch: boolean;
+    previousStateHashMatch: boolean;
+    redemptionArithmeticValid: boolean;
+    statusProgressionValid: boolean;
+};
+export declare function buildRedeemedBondIssuanceState(input: {
+    previous: BondIssuanceState;
+    amount: number;
+    redeemedAt: string;
+}): BondIssuanceState;

package/dist/domain/bondValidation.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeBondIssuanceState = summarizeBondIssuanceState;
+exports.validateBondDefinition = validateBondDefinition;
+exports.validateBondIssuanceState = validateBondIssuanceState;
+exports.validateBondCrossChecks = validateBondCrossChecks;
+exports.validateBondStateTransition = validateBondStateTransition;
+exports.buildRedeemedBondIssuanceState = buildRedeemedBondIssuanceState;
+const summary_1 = require("../core/summary");
+const errors_1 = require("../core/errors");
+function assertNonEmptyString(value, code, message) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new errors_1.ValidationError(message, { code });
+    }
+}
+function assertFiniteNumber(value, code, message) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new errors_1.ValidationError(message, { code });
+    }
+}
+function assertValidStatus(status) {
+    if (status !== "ISSUED" && status !== "PARTIALLY_REDEEMED" && status !== "REDEEMED") {
+        throw new errors_1.ValidationError("status must be ISSUED, PARTIALLY_REDEEMED, or REDEEMED", {
+            code: "BOND_STATUS_INVALID",
+        });
+    }
+}
+function validateBondTransition(value) {
+    const transition = value;
+    if (transition.type !== "ISSUE" && transition.type !== "REDEEM") {
+        throw new errors_1.ValidationError("lastTransition.type must be ISSUE or REDEEM", {
+            code: "BOND_TRANSITION_TYPE_INVALID",
+        });
+    }
+    assertFiniteNumber(transition.amount, "BOND_TRANSITION_AMOUNT_INVALID", "lastTransition.amount must be a finite number");
+    if (transition.amount <= 0) {
+        throw new errors_1.ValidationError("lastTransition.amount must be greater than 0", {
+            code: "BOND_TRANSITION_AMOUNT_INVALID",
+        });
+    }
+    assertNonEmptyString(transition.at, "BOND_TRANSITION_AT_INVALID", "lastTransition.at must be a non-empty string");
+    if (Number.isNaN(Date.parse(transition.at))) {
+        throw new errors_1.ValidationError("lastTransition.at must be an ISO8601 string", {
+            code: "BOND_TRANSITION_AT_INVALID",
+        });
+    }
+    return transition;
+}
+function summarizeBondIssuanceState(state) {
+    const canonicalJson = (0, summary_1.stableStringify)(state);
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function validateBondDefinition(value) {
+    const definition = value;
+    assertNonEmptyString(definition?.bondId, "BOND_ID_INVALID", "bondId must be a non-empty string");
+    assertNonEmptyString(definition?.issuer, "BOND_ISSUER_INVALID", "issuer must be a non-empty string");
+    assertFiniteNumber(definition?.faceValue, "BOND_FACE_VALUE_INVALID", "faceValue must be a finite number");
+    assertFiniteNumber(definition?.couponBps, "BOND_COUPON_INVALID", "couponBps must be a finite number");
+    assertNonEmptyString(definition?.issueDate, "BOND_ISSUE_DATE_INVALID", "issueDate must be a non-empty string");
+    assertFiniteNumber(definition?.maturityDate, "BOND_MATURITY_DATE_INVALID", "maturityDate must be a finite number");
+    assertNonEmptyString(definition?.currencyAssetId, "BOND_CURRENCY_INVALID", "currencyAssetId must be a non-empty string");
+    assertNonEmptyString(definition?.controllerXonly, "BOND_CONTROLLER_INVALID", "controllerXonly must be a non-empty string");
+    return definition;
+}
+function validateBondIssuanceState(value) {
+    const issuance = value;
+    assertNonEmptyString(issuance?.issuanceId, "BOND_ISSUANCE_ID_INVALID", "issuanceId must be a non-empty string");
+    assertNonEmptyString(issuance?.bondId, "BOND_ID_INVALID", "bondId must be a non-empty string");
+    assertNonEmptyString(issuance?.issuerEntityId, "BOND_ISSUER_ENTITY_INVALID", "issuerEntityId must be a non-empty string");
+    assertFiniteNumber(issuance?.issuedPrincipal, "BOND_ISSUED_PRINCIPAL_INVALID", "issuedPrincipal must be a finite number");
+    assertFiniteNumber(issuance?.outstandingPrincipal, "BOND_OUTSTANDING_PRINCIPAL_INVALID", "outstandingPrincipal must be a finite number");
+    assertFiniteNumber(issuance?.redeemedPrincipal, "BOND_REDEEMED_PRINCIPAL_INVALID", "redeemedPrincipal must be a finite number");
+    assertNonEmptyString(issuance?.currencyAssetId, "BOND_CURRENCY_INVALID", "currencyAssetId must be a non-empty string");
+    assertNonEmptyString(issuance?.controllerXonly, "BOND_CONTROLLER_INVALID", "controllerXonly must be a non-empty string");
+    assertNonEmptyString(issuance?.issuedAt, "BOND_ISSUED_AT_INVALID", "issuedAt must be a non-empty string");
+    assertValidStatus(issuance.status);
+    if (issuance.issuedPrincipal <= 0) {
+        throw new errors_1.ValidationError("issuedPrincipal must be greater than 0", { code: "BOND_PRINCIPAL_INVARIANT_INVALID" });
+    }
+    if (issuance.outstandingPrincipal < 0 || issuance.redeemedPrincipal < 0) {
+        throw new errors_1.ValidationError("principal values must not be negative", { code: "BOND_PRINCIPAL_INVARIANT_INVALID" });
+    }
+    if (issuance.issuedPrincipal !== issuance.outstandingPrincipal + issuance.redeemedPrincipal) {
+        throw new errors_1.ValidationError("issuedPrincipal must equal outstandingPrincipal + redeemedPrincipal", {
+            code: "BOND_PRINCIPAL_INVARIANT_INVALID",
+        });
+    }
+    if (Number.isNaN(Date.parse(issuance.issuedAt))) {
+        throw new errors_1.ValidationError("issuedAt must be an ISO8601 string", { code: "BOND_ISSUED_AT_INVALID" });
+    }
+    if (issuance.previousStateHash !== undefined && issuance.previousStateHash !== null) {
+        assertNonEmptyString(issuance.previousStateHash, "BOND_PREVIOUS_STATE_HASH_INVALID", "previousStateHash must be a non-empty string when provided");
+        if (!/^[0-9a-f]{64}$/i.test(issuance.previousStateHash)) {
+            throw new errors_1.ValidationError("previousStateHash must be a 64-character hex string", {
+                code: "BOND_PREVIOUS_STATE_HASH_INVALID",
+            });
+        }
+    }
+    const transition = issuance.lastTransition ? validateBondTransition(issuance.lastTransition) : undefined;
+    if (issuance.status === "ISSUED") {
+        if (issuance.redeemedPrincipal !== 0 || issuance.outstandingPrincipal !== issuance.issuedPrincipal) {
+            throw new errors_1.ValidationError("ISSUED state must have full outstanding principal and zero redeemed principal", {
+                code: "BOND_STATUS_TRANSITION_INVALID",
+            });
+        }
+        if (issuance.previousStateHash) {
+            throw new errors_1.ValidationError("ISSUED state must not set previousStateHash", {
+                code: "BOND_PREVIOUS_STATE_HASH_INVALID",
+            });
+        }
+        if (transition && transition.type !== "ISSUE") {
+            throw new errors_1.ValidationError("ISSUED state may only carry an ISSUE transition", {
+                code: "BOND_TRANSITION_TYPE_INVALID",
+            });
+        }
+    }
+    if (issuance.status === "PARTIALLY_REDEEMED") {
+        if (issuance.redeemedPrincipal <= 0 || issuance.outstandingPrincipal <= 0) {
+            throw new errors_1.ValidationError("PARTIALLY_REDEEMED state must have both redeemed and outstanding principal", {
+                code: "BOND_STATUS_TRANSITION_INVALID",
+            });
+        }
+        if (!issuance.previousStateHash) {
+            throw new errors_1.ValidationError("PARTIALLY_REDEEMED state must set previousStateHash", {
+                code: "BOND_PREVIOUS_STATE_HASH_INVALID",
+            });
+        }
+        if (!transition || transition.type !== "REDEEM") {
+            throw new errors_1.ValidationError("PARTIALLY_REDEEMED state must carry a REDEEM transition", {
+                code: "BOND_TRANSITION_TYPE_INVALID",
+            });
+        }
+    }
+    if (issuance.status === "REDEEMED") {
+        if (issuance.outstandingPrincipal !== 0 || issuance.redeemedPrincipal !== issuance.issuedPrincipal) {
+            throw new errors_1.ValidationError("REDEEMED state must have zero outstanding principal and full redeemed principal", {
+                code: "BOND_STATUS_TRANSITION_INVALID",
+            });
+        }
+        if (issuance.redeemedPrincipal <= 0) {
+            throw new errors_1.ValidationError("REDEEMED state must have positive redeemed principal", {
+                code: "BOND_STATUS_TRANSITION_INVALID",
+            });
+        }
+        if (!issuance.previousStateHash) {
+            throw new errors_1.ValidationError("REDEEMED state must set previousStateHash", {
+                code: "BOND_PREVIOUS_STATE_HASH_INVALID",
+            });
+        }
+        if (!transition || transition.type !== "REDEEM") {
+            throw new errors_1.ValidationError("REDEEMED state must carry a REDEEM transition", {
+                code: "BOND_TRANSITION_TYPE_INVALID",
+            });
+        }
+    }
+    return issuance;
+}
+function validateBondCrossChecks(definition, issuance) {
+    const result = {
+        bondIdMatch: definition.bondId === issuance.bondId,
+        currencyMatch: definition.currencyAssetId === issuance.currencyAssetId,
+        controllerMatch: definition.controllerXonly === issuance.controllerXonly,
+        principalInvariantValid: issuance.issuedPrincipal > 0 &&
+            issuance.outstandingPrincipal >= 0 &&
+            issuance.redeemedPrincipal >= 0 &&
+            issuance.issuedPrincipal === issuance.outstandingPrincipal + issuance.redeemedPrincipal,
+    };
+    if (!result.bondIdMatch) {
+        throw new errors_1.ValidationError("Bond definition and issuance state bondId do not match", {
+            code: "BOND_ID_MISMATCH",
+        });
+    }
+    if (!result.currencyMatch) {
+        throw new errors_1.ValidationError("Bond definition and issuance state currencyAssetId do not match", {
+            code: "BOND_CURRENCY_MISMATCH",
+        });
+    }
+    if (!result.controllerMatch) {
+        throw new errors_1.ValidationError("Bond definition and issuance state controllerXonly do not match", {
+            code: "BOND_CONTROLLER_MISMATCH",
+        });
+    }
+    if (!result.principalInvariantValid) {
+        throw new errors_1.ValidationError("Bond issuance principal invariants are invalid", {
+            code: "BOND_PRINCIPAL_INVARIANT_INVALID",
+        });
+    }
+    return result;
+}
+function validateBondStateTransition(previous, next) {
+    const previousHash = summarizeBondIssuanceState(previous).hash;
+    const result = {
+        issuanceIdMatch: previous.issuanceId === next.issuanceId,
+        bondIdMatch: previous.bondId === next.bondId,
+        currencyMatch: previous.currencyAssetId === next.currencyAssetId,
+        controllerMatch: previous.controllerXonly === next.controllerXonly,
+        issuerEntityMatch: previous.issuerEntityId === next.issuerEntityId,
+        issuedPrincipalMatch: previous.issuedPrincipal === next.issuedPrincipal,
+        previousStateHashMatch: next.previousStateHash === previousHash,
+        redemptionArithmeticValid: false,
+        statusProgressionValid: false,
+    };
+    if (!result.issuanceIdMatch) {
+        throw new errors_1.ValidationError("Bond issuance transition issuanceId does not match", {
+            code: "BOND_ISSUANCE_ID_MISMATCH",
+        });
+    }
+    if (!result.bondIdMatch) {
+        throw new errors_1.ValidationError("Bond issuance transition bondId does not match", {
+            code: "BOND_ID_MISMATCH",
+        });
+    }
+    if (!result.currencyMatch) {
+        throw new errors_1.ValidationError("Bond issuance transition currencyAssetId does not match", {
+            code: "BOND_CURRENCY_MISMATCH",
+        });
+    }
+    if (!result.controllerMatch) {
+        throw new errors_1.ValidationError("Bond issuance transition controllerXonly does not match", {
+            code: "BOND_CONTROLLER_MISMATCH",
+        });
+    }
+    if (!result.issuerEntityMatch) {
+        throw new errors_1.ValidationError("Bond issuance transition issuerEntityId does not match", {
+            code: "BOND_ISSUER_ENTITY_MISMATCH",
+        });
+    }
+    if (!result.issuedPrincipalMatch) {
+        throw new errors_1.ValidationError("Bond issuance transition issuedPrincipal must remain constant", {
+            code: "BOND_ISSUED_PRINCIPAL_MISMATCH",
+        });
+    }
+    if (!result.previousStateHashMatch) {
+        throw new errors_1.ValidationError("Bond issuance transition previousStateHash does not match the prior state hash", {
+            code: "BOND_PREVIOUS_STATE_HASH_MISMATCH",
+        });
+    }
+    const transition = next.lastTransition;
+    if (!transition || transition.type !== "REDEEM") {
+        throw new errors_1.ValidationError("Bond issuance transition must be a REDEEM transition", {
+            code: "BOND_TRANSITION_TYPE_INVALID",
+        });
+    }
+    const expectedOutstanding = previous.outstandingPrincipal - transition.amount;
+    const expectedRedeemed = previous.redeemedPrincipal + transition.amount;
+    result.redemptionArithmeticValid =
+        expectedOutstanding >= 0 &&
+            next.outstandingPrincipal === expectedOutstanding &&
+            next.redeemedPrincipal === expectedRedeemed;
+    if (!result.redemptionArithmeticValid) {
+        throw new errors_1.ValidationError("Bond issuance redemption arithmetic is invalid", {
+            code: "BOND_REDEMPTION_ARITHMETIC_INVALID",
+        });
+    }
+    result.statusProgressionValid =
+        (previous.status === "ISSUED" || previous.status === "PARTIALLY_REDEEMED") &&
+            ((next.status === "PARTIALLY_REDEEMED" && next.outstandingPrincipal > 0) ||
+                (next.status === "REDEEMED" && next.outstandingPrincipal === 0));
+    if (!result.statusProgressionValid) {
+        throw new errors_1.ValidationError("Bond issuance status progression is invalid", {
+            code: "BOND_STATUS_TRANSITION_INVALID",
+        });
+    }
+    return result;
+}
+function buildRedeemedBondIssuanceState(input) {
+    assertFiniteNumber(input.amount, "BOND_TRANSITION_AMOUNT_INVALID", "amount must be a finite number");
+    if (input.amount <= 0) {
+        throw new errors_1.ValidationError("amount must be greater than 0", { code: "BOND_TRANSITION_AMOUNT_INVALID" });
+    }
+    assertNonEmptyString(input.redeemedAt, "BOND_TRANSITION_AT_INVALID", "redeemedAt must be a non-empty string");
+    if (Number.isNaN(Date.parse(input.redeemedAt))) {
+        throw new errors_1.ValidationError("redeemedAt must be an ISO8601 string", {
+            code: "BOND_TRANSITION_AT_INVALID",
+        });
+    }
+    const previous = validateBondIssuanceState(input.previous);
+    if (previous.status === "REDEEMED") {
+        throw new errors_1.ValidationError("Cannot redeem an already redeemed bond issuance state", {
+            code: "BOND_ALREADY_REDEEMED",
+        });
+    }
+    if (input.amount > previous.outstandingPrincipal) {
+        throw new errors_1.ValidationError("Redeem amount must not exceed outstandingPrincipal", {
+            code: "BOND_REDEEM_AMOUNT_EXCEEDS_OUTSTANDING",
+        });
+    }
+    const nextOutstanding = previous.outstandingPrincipal - input.amount;
+    const nextRedeemed = previous.redeemedPrincipal + input.amount;
+    const next = {
+        ...previous,
+        outstandingPrincipal: nextOutstanding,
+        redeemedPrincipal: nextRedeemed,
+        previousStateHash: summarizeBondIssuanceState(previous).hash,
+        status: nextOutstanding === 0 ? "REDEEMED" : "PARTIALLY_REDEEMED",
+        lastTransition: {
+            type: "REDEEM",
+            amount: input.amount,
+            at: input.redeemedAt,
+        },
+    };
+    return validateBondIssuanceState(next);
+}

package/dist/index.d.ts

@@ -7,3 +7,7 @@ export * from "./core/errors";
 export { listPresets, getPresetOrThrow } from "./core/presets";
 export { loadArtifact, saveArtifact, normalizeArtifact } from "./core/artifact";
 export { loadDefinitionInput, buildArtifactDefinitionMetadata, verifyDefinitionAgainstArtifact, verifyDefinitionDescriptorAgainstArtifact, } from "./core/definition";
+export { loadStateInput, buildArtifactStateMetadata, verifyStateAgainstArtifact, verifyStateDescriptorAgainstArtifact, } from "./core/state";
+export { defineBond, verifyBond, loadBond, redeemBond, verifyBondTransition, buildBondRedemption, buildBondPayload, buildBondSettlementDescriptor, buildBondSettlementPayload, buildBondTransitionPayload, buildBondRolloverPlan, buildBondMachineRolloverPlan, buildBondMachineSettlementPlan, compileBondTransition, compileBondRedemptionMachine, inspectBondMachineRollover, inspectBondMachineSettlement, inspectBondStateRollover, executeBondStateRollover, executeBondMachineRollover, executeBondMachineSettlement, verifyBondRedemptionMachineArtifact, verifyBondSettlementDescriptor, } from "./domain/bond";
+export { validateBondDefinition, validateBondIssuanceState, validateBondCrossChecks, validateBondStateTransition, buildRedeemedBondIssuanceState, summarizeBondIssuanceState, } from "./domain/bondValidation";
+export { summarizeBondSettlementDescriptor, validateBondSettlementDescriptor, validateBondSettlementMatchesExpected, } from "./domain/bondSettlementValidation";

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyDefinitionDescriptorAgainstArtifact = exports.verifyDefinitionAgainstArtifact = exports.buildArtifactDefinitionMetadata = exports.loadDefinitionInput = exports.normalizeArtifact = exports.saveArtifact = exports.loadArtifact = exports.getPresetOrThrow = exports.listPresets = exports.RelayerClient = exports.DeployedContract = exports.CompiledContract = exports.SimplicityClient = exports.createSimplicityClient = void 0;
+exports.validateBondSettlementMatchesExpected = exports.validateBondSettlementDescriptor = exports.summarizeBondSettlementDescriptor = exports.summarizeBondIssuanceState = exports.buildRedeemedBondIssuanceState = exports.validateBondStateTransition = exports.validateBondCrossChecks = exports.validateBondIssuanceState = exports.validateBondDefinition = exports.verifyBondSettlementDescriptor = exports.verifyBondRedemptionMachineArtifact = exports.executeBondMachineSettlement = exports.executeBondMachineRollover = exports.executeBondStateRollover = exports.inspectBondStateRollover = exports.inspectBondMachineSettlement = exports.inspectBondMachineRollover = exports.compileBondRedemptionMachine = exports.compileBondTransition = exports.buildBondMachineSettlementPlan = exports.buildBondMachineRolloverPlan = exports.buildBondRolloverPlan = exports.buildBondTransitionPayload = exports.buildBondSettlementPayload = exports.buildBondSettlementDescriptor = exports.buildBondPayload = exports.buildBondRedemption = exports.verifyBondTransition = exports.redeemBond = exports.loadBond = exports.verifyBond = exports.defineBond = exports.verifyStateDescriptorAgainstArtifact = exports.verifyStateAgainstArtifact = exports.buildArtifactStateMetadata = exports.loadStateInput = exports.verifyDefinitionDescriptorAgainstArtifact = exports.verifyDefinitionAgainstArtifact = exports.buildArtifactDefinitionMetadata = exports.loadDefinitionInput = exports.normalizeArtifact = exports.saveArtifact = exports.loadArtifact = exports.getPresetOrThrow = exports.listPresets = exports.RelayerClient = exports.DeployedContract = exports.CompiledContract = exports.SimplicityClient = exports.createSimplicityClient = void 0;
 var SimplicityClient_1 = require("./client/SimplicityClient");
 Object.defineProperty(exports, "createSimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.createSimplicityClient; } });
 Object.defineProperty(exports, "SimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.SimplicityClient; } });
@@ -38,3 +38,43 @@ Object.defineProperty(exports, "loadDefinitionInput", { enumerable: true, get: f
 Object.defineProperty(exports, "buildArtifactDefinitionMetadata", { enumerable: true, get: function () { return definition_1.buildArtifactDefinitionMetadata; } });
 Object.defineProperty(exports, "verifyDefinitionAgainstArtifact", { enumerable: true, get: function () { return definition_1.verifyDefinitionAgainstArtifact; } });
 Object.defineProperty(exports, "verifyDefinitionDescriptorAgainstArtifact", { enumerable: true, get: function () { return definition_1.verifyDefinitionDescriptorAgainstArtifact; } });
+var state_1 = require("./core/state");
+Object.defineProperty(exports, "loadStateInput", { enumerable: true, get: function () { return state_1.loadStateInput; } });
+Object.defineProperty(exports, "buildArtifactStateMetadata", { enumerable: true, get: function () { return state_1.buildArtifactStateMetadata; } });
+Object.defineProperty(exports, "verifyStateAgainstArtifact", { enumerable: true, get: function () { return state_1.verifyStateAgainstArtifact; } });
+Object.defineProperty(exports, "verifyStateDescriptorAgainstArtifact", { enumerable: true, get: function () { return state_1.verifyStateDescriptorAgainstArtifact; } });
+var bond_1 = require("./domain/bond");
+Object.defineProperty(exports, "defineBond", { enumerable: true, get: function () { return bond_1.defineBond; } });
+Object.defineProperty(exports, "verifyBond", { enumerable: true, get: function () { return bond_1.verifyBond; } });
+Object.defineProperty(exports, "loadBond", { enumerable: true, get: function () { return bond_1.loadBond; } });
+Object.defineProperty(exports, "redeemBond", { enumerable: true, get: function () { return bond_1.redeemBond; } });
+Object.defineProperty(exports, "verifyBondTransition", { enumerable: true, get: function () { return bond_1.verifyBondTransition; } });
+Object.defineProperty(exports, "buildBondRedemption", { enumerable: true, get: function () { return bond_1.buildBondRedemption; } });
+Object.defineProperty(exports, "buildBondPayload", { enumerable: true, get: function () { return bond_1.buildBondPayload; } });
+Object.defineProperty(exports, "buildBondSettlementDescriptor", { enumerable: true, get: function () { return bond_1.buildBondSettlementDescriptor; } });
+Object.defineProperty(exports, "buildBondSettlementPayload", { enumerable: true, get: function () { return bond_1.buildBondSettlementPayload; } });
+Object.defineProperty(exports, "buildBondTransitionPayload", { enumerable: true, get: function () { return bond_1.buildBondTransitionPayload; } });
+Object.defineProperty(exports, "buildBondRolloverPlan", { enumerable: true, get: function () { return bond_1.buildBondRolloverPlan; } });
+Object.defineProperty(exports, "buildBondMachineRolloverPlan", { enumerable: true, get: function () { return bond_1.buildBondMachineRolloverPlan; } });
+Object.defineProperty(exports, "buildBondMachineSettlementPlan", { enumerable: true, get: function () { return bond_1.buildBondMachineSettlementPlan; } });
+Object.defineProperty(exports, "compileBondTransition", { enumerable: true, get: function () { return bond_1.compileBondTransition; } });
+Object.defineProperty(exports, "compileBondRedemptionMachine", { enumerable: true, get: function () { return bond_1.compileBondRedemptionMachine; } });
+Object.defineProperty(exports, "inspectBondMachineRollover", { enumerable: true, get: function () { return bond_1.inspectBondMachineRollover; } });
+Object.defineProperty(exports, "inspectBondMachineSettlement", { enumerable: true, get: function () { return bond_1.inspectBondMachineSettlement; } });
+Object.defineProperty(exports, "inspectBondStateRollover", { enumerable: true, get: function () { return bond_1.inspectBondStateRollover; } });
+Object.defineProperty(exports, "executeBondStateRollover", { enumerable: true, get: function () { return bond_1.executeBondStateRollover; } });
+Object.defineProperty(exports, "executeBondMachineRollover", { enumerable: true, get: function () { return bond_1.executeBondMachineRollover; } });
+Object.defineProperty(exports, "executeBondMachineSettlement", { enumerable: true, get: function () { return bond_1.executeBondMachineSettlement; } });
+Object.defineProperty(exports, "verifyBondRedemptionMachineArtifact", { enumerable: true, get: function () { return bond_1.verifyBondRedemptionMachineArtifact; } });
+Object.defineProperty(exports, "verifyBondSettlementDescriptor", { enumerable: true, get: function () { return bond_1.verifyBondSettlementDescriptor; } });
+var bondValidation_1 = require("./domain/bondValidation");
+Object.defineProperty(exports, "validateBondDefinition", { enumerable: true, get: function () { return bondValidation_1.validateBondDefinition; } });
+Object.defineProperty(exports, "validateBondIssuanceState", { enumerable: true, get: function () { return bondValidation_1.validateBondIssuanceState; } });
+Object.defineProperty(exports, "validateBondCrossChecks", { enumerable: true, get: function () { return bondValidation_1.validateBondCrossChecks; } });
+Object.defineProperty(exports, "validateBondStateTransition", { enumerable: true, get: function () { return bondValidation_1.validateBondStateTransition; } });
+Object.defineProperty(exports, "buildRedeemedBondIssuanceState", { enumerable: true, get: function () { return bondValidation_1.buildRedeemedBondIssuanceState; } });
+Object.defineProperty(exports, "summarizeBondIssuanceState", { enumerable: true, get: function () { return bondValidation_1.summarizeBondIssuanceState; } });
+var bondSettlementValidation_1 = require("./domain/bondSettlementValidation");
+Object.defineProperty(exports, "summarizeBondSettlementDescriptor", { enumerable: true, get: function () { return bondSettlementValidation_1.summarizeBondSettlementDescriptor; } });
+Object.defineProperty(exports, "validateBondSettlementDescriptor", { enumerable: true, get: function () { return bondSettlementValidation_1.validateBondSettlementDescriptor; } });
+Object.defineProperty(exports, "validateBondSettlementMatchesExpected", { enumerable: true, get: function () { return bondSettlementValidation_1.validateBondSettlementMatchesExpected; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazbase/simplicity",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "An SDK for Simplicity on Liquid",
   "author": "IndieSquare Inc <info@hazbase.com>",
   "keywords": [