@hazbase/simplicity 0.1.1 → 0.2.1

package/dist/docs/definitions/receivable-definition.json

@@ -0,0 +1,10 @@
+{
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "currencyAssetId": "bitcoin",
+  "faceValue": 10000,
+  "dueDate": "2027-12-31T00:00:00Z",
+  "controllerXonly": "3333333333333333333333333333333333333333333333333333333333333333",
+  "originatorClaimantXonly": "1111111111111111111111111111111111111111111111111111111111111111"
+}

package/dist/docs/definitions/receivable-funding-claim.json

@@ -0,0 +1,13 @@
+{
+  "claimId": "REC-001-FUNDING-CLAIM",
+  "claimKind": "FUNDING",
+  "receivableId": "REC-001",
+  "currentStateHash": "13147d187ce3200d7044d73d7b86b93140c43f29dd048f919569f5eb7b47c562",
+  "currentStatus": "FUNDED",
+  "payerEntityId": "fund-1",
+  "payeeEntityId": "originator-1",
+  "claimantXonly": "1111111111111111111111111111111111111111111111111111111111111111",
+  "currencyAssetId": "bitcoin",
+  "amountSat": 10000,
+  "eventTimestamp": "2027-01-02T00:00:00Z"
+}

package/dist/docs/definitions/receivable-funding-claim.simf

@@ -0,0 +1,58 @@
+/*
+ * Receivable funding claim contract.
+ *
+ * After a receivable moves into FUNDED state off-chain, the funder/SPV funds
+ * this one-shot claim contract and the committed claimant releases the payout
+ * to the originator-side destination. Runtime output binding is optional.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn require_output_shape(expected_output_hash: u256, expected_output_script_hash: u256, binding_mode: u8) {
+    match jet::eq_8(binding_mode, 1) {
+        true => {
+            let actual_output_hash: u256 = match jet::output_hash(0) {
+                Some(output_hash : u256) => output_hash,
+                None => panic!(),
+            };
+            assert!(jet::eq_32(jet::num_outputs(), 2));
+            assert!(unwrap(jet::output_is_fee(1)));
+            assert!(jet::eq_256(actual_output_hash, expected_output_hash));
+        },
+        false => {
+            match jet::eq_8(binding_mode, 2) {
+                true => {
+                    let actual_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+                    assert!(jet::eq_32(jet::num_outputs(), 2));
+                    assert!(unwrap(jet::output_is_fee(1)));
+                    assert!(jet::eq_256(actual_output_script_hash, expected_output_script_hash));
+                },
+                false => {},
+            }
+        },
+    }
+}
+
+fn main() {
+    require_definition_anchor();
+    require_state_anchor();
+    let expected_output_hash: u256 = witness::EXPECTED_PAYOUT_OUTPUT_HASH;
+    let expected_output_script_hash: u256 = witness::EXPECTED_PAYOUT_OUTPUT_SCRIPT_HASH;
+    let binding_mode: u8 = witness::OUTPUT_BINDING_MODE;
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
+    let claimant: Pubkey = 0x{{CLAIMANT_XONLY}};
+    jet::bip_0340_verify((claimant, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/receivable-repayment-claim-partial.json

@@ -0,0 +1,13 @@
+{
+  "claimId": "REC-001-REPAYMENT-CLAIM-PARTIAL",
+  "claimKind": "REPAYMENT",
+  "receivableId": "REC-001",
+  "currentStateHash": "34e4db6639ad5b3ccb555320af22fb0eca2ab393ff198602ce5ca69d398cec31",
+  "currentStatus": "PARTIALLY_REPAID",
+  "payerEntityId": "debtor-1",
+  "payeeEntityId": "fund-1",
+  "claimantXonly": "2222222222222222222222222222222222222222222222222222222222222222",
+  "currencyAssetId": "bitcoin",
+  "amountSat": 4000,
+  "eventTimestamp": "2027-02-01T00:00:00Z"
+}

package/dist/docs/definitions/receivable-repayment-claim.json

@@ -0,0 +1,13 @@
+{
+  "claimId": "REC-001-REPAYMENT-CLAIM-FINAL",
+  "claimKind": "REPAYMENT",
+  "receivableId": "REC-001",
+  "currentStateHash": "a18fdc99bf37de415bfa242a387cdb41b943d2581bfe177aec51c3e42e9e40bf",
+  "currentStatus": "REPAID",
+  "payerEntityId": "debtor-1",
+  "payeeEntityId": "fund-1",
+  "claimantXonly": "2222222222222222222222222222222222222222222222222222222222222222",
+  "currencyAssetId": "bitcoin",
+  "amountSat": 6000,
+  "eventTimestamp": "2027-03-01T00:00:00Z"
+}

package/dist/docs/definitions/receivable-repayment-claim.simf

@@ -0,0 +1,59 @@
+/*
+ * Receivable repayment claim contract.
+ *
+ * After a receivable moves into PARTIALLY_REPAID or REPAID state off-chain,
+ * the debtor-side payment funds this one-shot claim contract and the committed
+ * claimant releases the payout to the current holder-side destination. Runtime
+ * output binding is optional.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn require_output_shape(expected_output_hash: u256, expected_output_script_hash: u256, binding_mode: u8) {
+    match jet::eq_8(binding_mode, 1) {
+        true => {
+            let actual_output_hash: u256 = match jet::output_hash(0) {
+                Some(output_hash : u256) => output_hash,
+                None => panic!(),
+            };
+            assert!(jet::eq_32(jet::num_outputs(), 2));
+            assert!(unwrap(jet::output_is_fee(1)));
+            assert!(jet::eq_256(actual_output_hash, expected_output_hash));
+        },
+        false => {
+            match jet::eq_8(binding_mode, 2) {
+                true => {
+                    let actual_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+                    assert!(jet::eq_32(jet::num_outputs(), 2));
+                    assert!(unwrap(jet::output_is_fee(1)));
+                    assert!(jet::eq_256(actual_output_script_hash, expected_output_script_hash));
+                },
+                false => {},
+            }
+        },
+    }
+}
+
+fn main() {
+    require_definition_anchor();
+    require_state_anchor();
+    let expected_output_hash: u256 = witness::EXPECTED_PAYOUT_OUTPUT_HASH;
+    let expected_output_script_hash: u256 = witness::EXPECTED_PAYOUT_OUTPUT_SCRIPT_HASH;
+    let binding_mode: u8 = witness::OUTPUT_BINDING_MODE;
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
+    let claimant: Pubkey = 0x{{CLAIMANT_XONLY}};
+    jet::bip_0340_verify((claimant, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/receivable-state-funded.json

@@ -0,0 +1,21 @@
+{
+  "stateId": "REC-001-S1",
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "holderEntityId": "fund-1",
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "3333333333333333333333333333333333333333333333333333333333333333",
+  "holderClaimantXonly": "2222222222222222222222222222222222222222222222222222222222222222",
+  "faceValue": 10000,
+  "outstandingAmount": 10000,
+  "repaidAmount": 0,
+  "status": "FUNDED",
+  "createdAt": "2027-01-02T00:00:00Z",
+  "previousStateHash": "cdd1a8e867611a0bf486c35a7811c80c2459f28ca988c22f789fbacdd4ee5c9e",
+  "lastTransition": {
+    "type": "FUND",
+    "amount": 10000,
+    "at": "2027-01-02T00:00:00Z"
+  }
+}

package/dist/docs/definitions/receivable-state-originated.json

@@ -0,0 +1,20 @@
+{
+  "stateId": "REC-001-S0",
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "holderEntityId": "originator-1",
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "3333333333333333333333333333333333333333333333333333333333333333",
+  "holderClaimantXonly": "1111111111111111111111111111111111111111111111111111111111111111",
+  "faceValue": 10000,
+  "outstandingAmount": 10000,
+  "repaidAmount": 0,
+  "status": "ORIGINATED",
+  "createdAt": "2027-01-01T00:00:00Z",
+  "lastTransition": {
+    "type": "ORIGINATE",
+    "amount": 10000,
+    "at": "2027-01-01T00:00:00Z"
+  }
+}

package/dist/docs/definitions/receivable-state-partially-repaid.json

@@ -0,0 +1,21 @@
+{
+  "stateId": "REC-001-S2",
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "holderEntityId": "fund-1",
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "3333333333333333333333333333333333333333333333333333333333333333",
+  "holderClaimantXonly": "2222222222222222222222222222222222222222222222222222222222222222",
+  "faceValue": 10000,
+  "outstandingAmount": 6000,
+  "repaidAmount": 4000,
+  "status": "PARTIALLY_REPAID",
+  "createdAt": "2027-02-01T00:00:00Z",
+  "previousStateHash": "13147d187ce3200d7044d73d7b86b93140c43f29dd048f919569f5eb7b47c562",
+  "lastTransition": {
+    "type": "REPAY",
+    "amount": 4000,
+    "at": "2027-02-01T00:00:00Z"
+  }
+}

package/dist/docs/definitions/receivable-state-repaid.json

@@ -0,0 +1,21 @@
+{
+  "stateId": "REC-001-S3",
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "holderEntityId": "fund-1",
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "3333333333333333333333333333333333333333333333333333333333333333",
+  "holderClaimantXonly": "2222222222222222222222222222222222222222222222222222222222222222",
+  "faceValue": 10000,
+  "outstandingAmount": 0,
+  "repaidAmount": 10000,
+  "status": "REPAID",
+  "createdAt": "2027-03-01T00:00:00Z",
+  "previousStateHash": "34e4db6639ad5b3ccb555320af22fb0eca2ab393ff198602ce5ca69d398cec31",
+  "lastTransition": {
+    "type": "REPAY",
+    "amount": 6000,
+    "at": "2027-03-01T00:00:00Z"
+  }
+}

package/dist/domain/bond.d.ts

@@ -64,7 +64,15 @@ export declare function buildBondPayload(sdk: SimplicityClient, input: {
     definitionValue?: BondDefinition;
     issuancePath?: string;
     issuanceValue?: BondIssuanceState;
+    issuanceHistoryPaths?: string[];
+    issuanceHistoryValues?: BondIssuanceState[];
 }): Promise<{
+    issuanceHistory?: import("../core/types").StateDocumentDescriptor[] | undefined;
+    issuanceHistoryValues?: BondIssuanceState[] | undefined;
+    issuanceHistorySummaries?: {
+        canonicalJson: string;
+        hash: string;
+    }[] | undefined;
     artifact: SimplicityArtifact;
     payload: {
         bondId: string;
@@ -109,8 +117,76 @@ export declare function buildBondPayload(sdk: SimplicityClient, input: {
             onChainAnchorVerified: boolean;
             effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
         };
+        issuanceLineageTrust: import("../core/types").BondIssuanceLineageTrust | undefined;
     };
 }>;
+export declare function verifyIssuanceHistory(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: BondDefinition;
+    issuanceHistoryPaths?: string[];
+    issuanceHistoryValues?: BondIssuanceState[];
+}): Promise<{
+    issuanceHistory: import("../core/types").StateDocumentDescriptor[];
+    issuanceHistoryValues: BondIssuanceState[];
+    issuanceHistorySummaries: {
+        canonicalJson: string;
+        hash: string;
+    }[];
+    checks: {
+        chainLength: number;
+        latestStatus: import("../core/types").BondIssuanceStatus | undefined;
+        startsAtGenesis: boolean;
+        previousStateHashLinked: boolean;
+        issuanceIdConsistent: boolean;
+        bondIdConsistent: boolean;
+        currencyConsistent: boolean;
+        controllerConsistent: boolean;
+        issuerEntityConsistent: boolean;
+        issuedPrincipalConsistent: boolean;
+        allPreviousStateHashMatch: boolean;
+        allRedemptionArithmeticValid: boolean;
+        allStatusProgressionValid: boolean;
+        allTransitionIdentitiesMatch: boolean;
+        fullHistoryVerified: boolean;
+        transitionChecks: {
+            issuanceIdMatch: boolean;
+            bondIdMatch: boolean;
+            currencyMatch: boolean;
+            controllerMatch: boolean;
+            issuerEntityMatch: boolean;
+            issuedPrincipalMatch: boolean;
+            previousStateHashMatch: boolean;
+            redemptionArithmeticValid: boolean;
+            statusProgressionValid: boolean;
+        }[];
+    };
+    report: {
+        issuanceLineageTrust: import("../core/types").BondIssuanceLineageTrust | undefined;
+        artifactTrust: {
+            definition: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+            state: {
+                artifactMatch: boolean;
+                onChainAnchorPresent: boolean;
+                onChainAnchorVerified: boolean;
+                effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+            };
+        };
+        stateTrust: {
+            artifactMatch: boolean;
+            onChainAnchorPresent: boolean;
+            onChainAnchorVerified: boolean;
+            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
+        };
+    };
+    definition?: import("../core/types").DefinitionDescriptor | undefined;
+    definitionValue?: BondDefinition | undefined;
+    verified: boolean;
+}>;
 export declare function summarizeExpectedOutputDescriptor(descriptor: BondExpectedOutputDescriptor): {
     canonicalJson: string;
     hash: string;
@@ -493,6 +569,8 @@ export declare function buildEvidenceBundle(sdk: SimplicityClient, input: {
     definitionValue?: BondDefinition;
     issuancePath?: string;
     issuanceValue?: BondIssuanceState;
+    issuanceHistoryPaths?: string[];
+    issuanceHistoryValues?: BondIssuanceState[];
     settlementDescriptorValue?: BondSettlementDescriptor;
     closingDescriptorValue?: BondClosingDescriptor;
     transitionValue?: unknown;
@@ -751,6 +829,8 @@ export declare function exportFinalityPayload(sdk: SimplicityClient, input: {
     definitionValue?: BondDefinition;
     issuancePath?: string;
     issuanceValue?: BondIssuanceState;
+    issuanceHistoryPaths?: string[];
+    issuanceHistoryValues?: BondIssuanceState[];
     settlementDescriptorValue?: BondSettlementDescriptor;
     closingDescriptorValue?: BondClosingDescriptor;
 }): Promise<{
@@ -798,22 +878,9 @@ export declare function exportFinalityPayload(sdk: SimplicityClient, input: {
             onChainAnchorVerified: boolean;
             effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
         };
+        issuanceLineageTrust: import("../core/types").BondIssuanceLineageTrust | undefined;
     };
-    trustSummary: {
-        definition: {
-            artifactMatch: boolean;
-            onChainAnchorPresent: boolean;
-            onChainAnchorVerified: boolean;
-            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
-        };
-        issuance: {
-            artifactMatch: boolean;
-            onChainAnchorPresent: boolean;
-            onChainAnchorVerified: boolean;
-            effectiveMode: "none" | import("../core/types").DefinitionAnchorMode;
-        };
-        bindingMode: BondOutputBindingMode;
-    };
+    trustSummary: import("../core/types").VerificationTrustSummary;
     evidenceSummary: {
         definitionHash: string;
         issuanceHash: string;

package/dist/domain/bond.js

@@ -40,6 +40,7 @@ exports.defineBond = defineBond;
 exports.verifyBond = verifyBond;
 exports.loadBond = loadBond;
 exports.buildBondPayload = buildBondPayload;
+exports.verifyIssuanceHistory = verifyIssuanceHistory;
 exports.summarizeExpectedOutputDescriptor = summarizeExpectedOutputDescriptor;
 exports.validateExpectedOutputDescriptor = validateExpectedOutputDescriptor;
 exports.buildExpectedOutputDescriptor = buildExpectedOutputDescriptor;
@@ -107,6 +108,7 @@ 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");
@@ -130,6 +132,94 @@ function resolveBondDocsAsset(filename) {
     }
     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,
@@ -246,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: {
@@ -278,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),
         },
     };
 }
@@ -932,6 +1070,15 @@ async function buildEvidenceBundle(sdk, input) {
     });
     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;
@@ -977,11 +1124,11 @@ async function buildEvidenceBundle(sdk, input) {
             }
             : undefined,
         trust: {
-            artifactTrust: {
-                definition: verification.definition.trust,
-                state: verification.issuance.trust,
-            },
-            stateTrust: verification.issuance.trust,
+            ...buildBaseBondReport({
+                definitionTrust: verification.definition.trust,
+                stateTrust: verification.issuance.trust,
+            }),
+            issuanceLineageTrust: lineageChecks ? buildBondIssuanceLineageTrust(lineageChecks) : undefined,
             settlementTrust: input.settlementDescriptorValue
                 ? {
                     descriptorHashMatch: true,
@@ -989,6 +1136,12 @@ async function buildEvidenceBundle(sdk, input) {
                 }
                 : 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: {
@@ -1059,11 +1212,7 @@ async function exportFinalityPayload(sdk, input) {
         payload: bondPayload.payload,
         bindingMode: input.settlementDescriptorValue?.outputBindingMode ?? "none",
         trust: bondPayload.trust,
-        trustSummary: {
-            definition: bondPayload.trust.definitionTrust,
-            issuance: bondPayload.trust.issuanceTrust,
-            bindingMode: input.settlementDescriptorValue?.outputBindingMode ?? "none",
-        },
+        trustSummary: evidence.trustSummary,
         evidenceSummary: {
             definitionHash: evidence.definition.hash,
             issuanceHash: evidence.issuance.hash,

package/dist/domain/bondValidation.d.ts

@@ -1,4 +1,4 @@
-import { BondDefinition, BondIssuanceState } from "../core/types";
+import { BondDefinition, BondIssuanceState, BondIssuanceStatus } from "../core/types";
 export declare function summarizeBondIssuanceState(state: BondIssuanceState): {
     canonicalJson: string;
     hash: string;
@@ -33,3 +33,33 @@ export declare function buildClosedBondIssuanceState(input: {
     closingReason: "REDEEMED" | "CANCELLED" | "MATURED_OUT";
     finalSettlementDescriptorHash: string;
 }): BondIssuanceState;
+export declare function verifyBondIssuanceHistory(input: {
+    history: BondIssuanceState[];
+}): {
+    chainLength: number;
+    latestStatus: BondIssuanceStatus | undefined;
+    startsAtGenesis: boolean;
+    previousStateHashLinked: boolean;
+    issuanceIdConsistent: boolean;
+    bondIdConsistent: boolean;
+    currencyConsistent: boolean;
+    controllerConsistent: boolean;
+    issuerEntityConsistent: boolean;
+    issuedPrincipalConsistent: boolean;
+    allPreviousStateHashMatch: boolean;
+    allRedemptionArithmeticValid: boolean;
+    allStatusProgressionValid: boolean;
+    allTransitionIdentitiesMatch: boolean;
+    fullHistoryVerified: boolean;
+    transitionChecks: {
+        issuanceIdMatch: boolean;
+        bondIdMatch: boolean;
+        currencyMatch: boolean;
+        controllerMatch: boolean;
+        issuerEntityMatch: boolean;
+        issuedPrincipalMatch: boolean;
+        previousStateHashMatch: boolean;
+        redemptionArithmeticValid: boolean;
+        statusProgressionValid: boolean;
+    }[];
+};