@hazbase/simplicity 0.1.1 → 0.2.0

package/dist/client/SimplicityClient.d.ts

@@ -1,13 +1,14 @@
 import { evaluateOutputBindingSupport } from "../core/outputBinding";
 import { ElementsRpcClient } from "../core/rpc";
-import { BondEvidenceBundle, OutputBindingSupportEvaluation, OutputBindingSupportMatrix, PolicyEvidenceBundle, PolicyTemplateManifestValidationResult, DefinitionInput, DefinitionVerificationResult, CompileFromFileInput, CompileFromPresetInput, DefinitionDescriptor, StateDocumentDescriptor, StateDocumentInput, StateVerificationResult, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { BondEvidenceBundle, OutputBindingSupportEvaluation, OutputBindingSupportMatrix, PolicyEvidenceBundle, ReceivableEvidenceBundle, PolicyTemplateManifestValidationResult, DefinitionInput, DefinitionVerificationResult, CompileFromFileInput, CompileFromPresetInput, DefinitionDescriptor, StateDocumentDescriptor, StateDocumentInput, StateVerificationResult, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
 import { RelayerClient } from "../gasless/RelayerClient";
 import { GaslessTransferInput, GaslessTransferResult, RelayerClientConfig } from "../gasless/types";
 import { CompiledContract } from "./ContractFactory";
 import { DeployedContract } from "./DeployedContract";
-import { prepareRedemption, prepareClosing, exportFinalityPayload, buildSettlement, verifySettlement, define, executeClosing, executeRedemption, exportEvidence, inspectClosing, inspectRedemption, issue, load, verify, verifyClosing, verifyRedemption } from "../domain/bond";
-import { define as defineFund, verify as verifyFund, load as loadFund, prepareCapitalCall, inspectCapitalCallClaim, executeCapitalCallClaim, inspectCapitalCallRollover, executeCapitalCallRollover, inspectCapitalCallRefund, executeCapitalCallRefund, verifyCapitalCall, signPositionReceipt, verifyPositionReceipt, prepareDistribution, reconcilePosition, inspectDistributionClaim, executeDistributionClaim, verifyDistribution, prepareClosing as prepareFundClosing, verifyClosing as verifyFundClosing, exportEvidence as exportFundEvidence, exportFinalityPayload as exportFundFinalityPayload } from "../domain/fund";
+import { prepareRedemption, prepareClosing, exportFinalityPayload, buildSettlement, verifySettlement, define, executeClosing, executeRedemption, exportEvidence, inspectClosing, inspectRedemption, issue, load, verify, verifyIssuanceHistory, verifyClosing, verifyRedemption } from "../domain/bond";
+import { define as defineFund, verify as verifyFund, load as loadFund, prepareCapitalCall, inspectCapitalCallClaim, executeCapitalCallClaim, inspectCapitalCallRollover, executeCapitalCallRollover, inspectCapitalCallRefund, executeCapitalCallRefund, verifyCapitalCall, signPositionReceipt, verifyPositionReceipt, verifyPositionReceiptChain, prepareDistribution, reconcilePosition, inspectDistributionClaim, executeDistributionClaim, verifyDistribution, prepareClosing as prepareFundClosing, verifyClosing as verifyFundClosing, exportEvidence as exportFundEvidence, exportFinalityPayload as exportFundFinalityPayload } from "../domain/fund";
 import { buildPolicyOutputDescriptor, describePolicyTemplate, listPolicyTemplates, loadPolicyTemplateManifest, executeTransfer as executePolicyTransfer, exportEvidence as exportPolicyEvidence, inspectTransfer as inspectPolicyTransfer, issue as issuePolicy, prepareTransfer as preparePolicyTransfer, validatePolicyTemplateManifest, validatePolicyTemplateParams, verifyState as verifyPolicyState, verifyTransfer as verifyPolicyTransfer } from "../domain/policies";
+import { define as defineReceivable, exportEvidence as exportReceivableEvidence, exportFinalityPayload as exportReceivableFinalityPayload, executeFundingClaim as executeReceivableFundingClaim, executeRepaymentClaim as executeReceivableRepaymentClaim, inspectFundingClaim as inspectReceivableFundingClaim, inspectRepaymentClaim as inspectReceivableRepaymentClaim, load as loadReceivable, prepareClosing as prepareReceivableClosing, prepareFundingClaim as prepareReceivableFundingClaim, prepareFunding as prepareReceivableFunding, prepareRepaymentClaim as prepareReceivableRepaymentClaim, prepareRepayment as prepareReceivableRepayment, prepareWriteOff as prepareReceivableWriteOff, verify as verifyReceivable, verifyClosing as verifyReceivableClosing, verifyFundingClaim as verifyReceivableFundingClaim, verifyFunding as verifyReceivableFunding, verifyRepaymentClaim as verifyReceivableRepaymentClaim, verifyRepayment as verifyReceivableRepayment, verifyStateHistory as verifyReceivableStateHistory, verifyWriteOff as verifyReceivableWriteOff } from "../domain/receivable";
 export declare class SimplicityClient {
     readonly config: SimplicityClientConfig;
     readonly rpc: ElementsRpcClient;
@@ -36,6 +37,7 @@ export declare class SimplicityClient {
     readonly bonds: {
         define: (input: Parameters<typeof define>[1]) => ReturnType<typeof define>;
         verify: (input: Parameters<typeof verify>[1]) => ReturnType<typeof verify>;
+        verifyIssuanceHistory: (input: Parameters<typeof verifyIssuanceHistory>[1]) => ReturnType<typeof verifyIssuanceHistory>;
         load: (input: Parameters<typeof load>[1]) => ReturnType<typeof load>;
         issue: (input: Parameters<typeof issue>[1]) => ReturnType<typeof issue>;
         prepareRedemption: (input: Parameters<typeof prepareRedemption>[1]) => ReturnType<typeof prepareRedemption>;
@@ -65,6 +67,7 @@ export declare class SimplicityClient {
         verifyCapitalCall: (input: Parameters<typeof verifyCapitalCall>[1]) => ReturnType<typeof verifyCapitalCall>;
         signPositionReceipt: (input: Parameters<typeof signPositionReceipt>[1]) => ReturnType<typeof signPositionReceipt>;
         verifyPositionReceipt: (input: Parameters<typeof verifyPositionReceipt>[1]) => ReturnType<typeof verifyPositionReceipt>;
+        verifyPositionReceiptChain: (input: Parameters<typeof verifyPositionReceiptChain>[1]) => ReturnType<typeof verifyPositionReceiptChain>;
         prepareDistribution: (input: Parameters<typeof prepareDistribution>[1]) => ReturnType<typeof prepareDistribution>;
         reconcilePosition: (input: Parameters<typeof reconcilePosition>[1]) => ReturnType<typeof reconcilePosition>;
         inspectDistributionClaim: (input: Parameters<typeof inspectDistributionClaim>[1]) => ReturnType<typeof inspectDistributionClaim>;
@@ -75,6 +78,30 @@ export declare class SimplicityClient {
         exportEvidence: (input: Parameters<typeof exportFundEvidence>[1]) => ReturnType<typeof exportFundEvidence>;
         exportFinalityPayload: (input: Parameters<typeof exportFundFinalityPayload>[1]) => ReturnType<typeof exportFundFinalityPayload>;
     };
+    readonly receivables: {
+        define: (input: Parameters<typeof defineReceivable>[1]) => ReturnType<typeof defineReceivable>;
+        verify: (input: Parameters<typeof verifyReceivable>[1]) => ReturnType<typeof verifyReceivable>;
+        load: (input: Parameters<typeof loadReceivable>[1]) => ReturnType<typeof loadReceivable>;
+        prepareFunding: (input: Parameters<typeof prepareReceivableFunding>[1]) => ReturnType<typeof prepareReceivableFunding>;
+        verifyFunding: (input: Parameters<typeof verifyReceivableFunding>[1]) => ReturnType<typeof verifyReceivableFunding>;
+        prepareFundingClaim: (input: Parameters<typeof prepareReceivableFundingClaim>[1]) => ReturnType<typeof prepareReceivableFundingClaim>;
+        inspectFundingClaim: (input: Parameters<typeof inspectReceivableFundingClaim>[1]) => ReturnType<typeof inspectReceivableFundingClaim>;
+        executeFundingClaim: (input: Parameters<typeof executeReceivableFundingClaim>[1]) => ReturnType<typeof executeReceivableFundingClaim>;
+        verifyFundingClaim: (input: Parameters<typeof verifyReceivableFundingClaim>[1]) => ReturnType<typeof verifyReceivableFundingClaim>;
+        prepareRepayment: (input: Parameters<typeof prepareReceivableRepayment>[1]) => ReturnType<typeof prepareReceivableRepayment>;
+        verifyRepayment: (input: Parameters<typeof verifyReceivableRepayment>[1]) => ReturnType<typeof verifyReceivableRepayment>;
+        prepareRepaymentClaim: (input: Parameters<typeof prepareReceivableRepaymentClaim>[1]) => ReturnType<typeof prepareReceivableRepaymentClaim>;
+        inspectRepaymentClaim: (input: Parameters<typeof inspectReceivableRepaymentClaim>[1]) => ReturnType<typeof inspectReceivableRepaymentClaim>;
+        executeRepaymentClaim: (input: Parameters<typeof executeReceivableRepaymentClaim>[1]) => ReturnType<typeof executeReceivableRepaymentClaim>;
+        verifyRepaymentClaim: (input: Parameters<typeof verifyReceivableRepaymentClaim>[1]) => ReturnType<typeof verifyReceivableRepaymentClaim>;
+        prepareWriteOff: (input: Parameters<typeof prepareReceivableWriteOff>[1]) => ReturnType<typeof prepareReceivableWriteOff>;
+        verifyWriteOff: (input: Parameters<typeof verifyReceivableWriteOff>[1]) => ReturnType<typeof verifyReceivableWriteOff>;
+        prepareClosing: (input: Parameters<typeof prepareReceivableClosing>[1]) => ReturnType<typeof prepareReceivableClosing>;
+        verifyClosing: (input: Parameters<typeof verifyReceivableClosing>[1]) => ReturnType<typeof verifyReceivableClosing>;
+        verifyStateHistory: (input: Parameters<typeof verifyReceivableStateHistory>[1]) => ReturnType<typeof verifyReceivableStateHistory>;
+        exportEvidence: (input: Parameters<typeof exportReceivableEvidence>[1]) => Promise<ReceivableEvidenceBundle>;
+        exportFinalityPayload: (input: Parameters<typeof exportReceivableFinalityPayload>[1]) => ReturnType<typeof exportReceivableFinalityPayload>;
+    };
     constructor(config: SimplicityClientConfig);
     compileFromFile(input: CompileFromFileInput): Promise<CompiledContract>;
     compileFromPreset(input: CompileFromPresetInput): Promise<CompiledContract>;

package/dist/client/SimplicityClient.js

@@ -15,6 +15,7 @@ const DeployedContract_1 = require("./DeployedContract");
 const bond_1 = require("../domain/bond");
 const fund_1 = require("../domain/fund");
 const policies_1 = require("../domain/policies");
+const receivable_1 = require("../domain/receivable");
 class SimplicityClient {
     config;
     rpc;
@@ -23,6 +24,7 @@ class SimplicityClient {
     policies;
     bonds;
     funds;
+    receivables;
     constructor(config) {
         this.config = config;
         this.rpc = new rpc_1.ElementsRpcClient(config.rpc);
@@ -51,6 +53,7 @@ class SimplicityClient {
         this.bonds = {
             define: async (input) => (0, bond_1.define)(this, input),
             verify: async (input) => (0, bond_1.verify)(this, input),
+            verifyIssuanceHistory: async (input) => (0, bond_1.verifyIssuanceHistory)(this, input),
             load: async (input) => (0, bond_1.load)(this, input),
             issue: async (input) => (0, bond_1.issue)(this, input),
             prepareRedemption: async (input) => (0, bond_1.prepareRedemption)(this, input),
@@ -80,6 +83,7 @@ class SimplicityClient {
             verifyCapitalCall: async (input) => (0, fund_1.verifyCapitalCall)(this, input),
             signPositionReceipt: async (input) => (0, fund_1.signPositionReceipt)(this, input),
             verifyPositionReceipt: async (input) => (0, fund_1.verifyPositionReceipt)(this, input),
+            verifyPositionReceiptChain: async (input) => (0, fund_1.verifyPositionReceiptChain)(this, input),
             prepareDistribution: async (input) => (0, fund_1.prepareDistribution)(this, input),
             reconcilePosition: async (input) => (0, fund_1.reconcilePosition)(this, input),
             inspectDistributionClaim: async (input) => (0, fund_1.inspectDistributionClaim)(this, input),
@@ -90,6 +94,30 @@ class SimplicityClient {
             exportEvidence: async (input) => (0, fund_1.exportEvidence)(this, input),
             exportFinalityPayload: async (input) => (0, fund_1.exportFinalityPayload)(this, input),
         };
+        this.receivables = {
+            define: async (input) => (0, receivable_1.define)(this, input),
+            verify: async (input) => (0, receivable_1.verify)(this, input),
+            load: async (input) => (0, receivable_1.load)(this, input),
+            prepareFunding: async (input) => (0, receivable_1.prepareFunding)(this, input),
+            verifyFunding: async (input) => (0, receivable_1.verifyFunding)(this, input),
+            prepareFundingClaim: async (input) => (0, receivable_1.prepareFundingClaim)(this, input),
+            inspectFundingClaim: async (input) => (0, receivable_1.inspectFundingClaim)(this, input),
+            executeFundingClaim: async (input) => (0, receivable_1.executeFundingClaim)(this, input),
+            verifyFundingClaim: async (input) => (0, receivable_1.verifyFundingClaim)(this, input),
+            prepareRepayment: async (input) => (0, receivable_1.prepareRepayment)(this, input),
+            verifyRepayment: async (input) => (0, receivable_1.verifyRepayment)(this, input),
+            prepareRepaymentClaim: async (input) => (0, receivable_1.prepareRepaymentClaim)(this, input),
+            inspectRepaymentClaim: async (input) => (0, receivable_1.inspectRepaymentClaim)(this, input),
+            executeRepaymentClaim: async (input) => (0, receivable_1.executeRepaymentClaim)(this, input),
+            verifyRepaymentClaim: async (input) => (0, receivable_1.verifyRepaymentClaim)(this, input),
+            prepareWriteOff: async (input) => (0, receivable_1.prepareWriteOff)(this, input),
+            verifyWriteOff: async (input) => (0, receivable_1.verifyWriteOff)(this, input),
+            prepareClosing: async (input) => (0, receivable_1.prepareClosing)(this, input),
+            verifyClosing: async (input) => (0, receivable_1.verifyClosing)(this, input),
+            verifyStateHistory: async (input) => (0, receivable_1.verifyStateHistory)(this, input),
+            exportEvidence: async (input) => (0, receivable_1.exportEvidence)(this, input),
+            exportFinalityPayload: async (input) => (0, receivable_1.exportFinalityPayload)(this, input),
+        };
     }
     async compileFromFile(input) {
         const artifact = await (0, compiler_1.compileFromFile)(this.config, input);

package/dist/core/lineage.d.ts

@@ -0,0 +1,18 @@
+export declare function verifyHashLinkedLineage<T, K extends string>(input: {
+    entries: T[];
+    summarize: (entry: T) => {
+        hash: string;
+    };
+    getPreviousHash: (entry: T) => string | null | undefined;
+    isGenesis: (entry: T) => boolean;
+    consistencyChecks?: Record<K, (entry: T, first: T) => boolean>;
+}): {
+    chainLength: number;
+    startsAtGenesis: boolean;
+    previousHashLinked: boolean;
+    consistency: Record<K, boolean>;
+    fullLineageVerified: boolean;
+    summaries: {
+        hash: string;
+    }[];
+};

package/dist/core/lineage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyHashLinkedLineage = verifyHashLinkedLineage;
+function verifyHashLinkedLineage(input) {
+    const entries = [...input.entries];
+    if (entries.length === 0) {
+        throw new Error("hash-linked lineage requires at least one entry");
+    }
+    const first = entries[0];
+    const summaries = entries.map((entry) => input.summarize(entry));
+    const startsAtGenesis = input.isGenesis(first);
+    const previousHashLinked = entries.every((entry, index) => (index === 0
+        ? true
+        : input.getPreviousHash(entry) === summaries[index - 1].hash));
+    const consistency = Object.fromEntries(Object.entries(input.consistencyChecks ?? {}).map(([label, check]) => [
+        label,
+        entries.every((entry) => check(entry, first)),
+    ]));
+    const fullLineageVerified = startsAtGenesis
+        && previousHashLinked
+        && Object.values(consistency).every(Boolean);
+    return {
+        chainLength: entries.length,
+        startsAtGenesis,
+        previousHashLinked,
+        consistency,
+        fullLineageVerified,
+        summaries,
+    };
+}

package/dist/core/reporting.d.ts

@@ -0,0 +1,22 @@
+import type { BondOutputBindingMode, DefinitionVerificationResult, DomainLineageTrust, LineageTrustBase, StateVerificationResult, VerificationTrustSummary } from "./types";
+export declare function buildLineageTrustBase<LineageKind extends string>(input: LineageTrustBase<LineageKind>): LineageTrustBase<LineageKind>;
+export declare function buildVerificationTrustSections<TDefinitionTrust, TStateTrust>(input: {
+    definitionTrust?: TDefinitionTrust;
+    stateTrust?: TStateTrust;
+    requireArtifactTrust?: boolean;
+    emptyDefinitionTrust: TDefinitionTrust;
+    emptyStateTrust: TStateTrust;
+}): {
+    artifactTrust: {
+        definition: TDefinitionTrust;
+        state: TStateTrust;
+    };
+    stateTrust: TStateTrust;
+};
+export declare function buildDomainLineageTrustSummary(lineageTrust?: DomainLineageTrust): VerificationTrustSummary["lineage"] | undefined;
+export declare function buildVerificationTrustSummary(input: {
+    definitionTrust?: DefinitionVerificationResult["trust"];
+    stateTrust?: StateVerificationResult["trust"];
+    bindingMode: BondOutputBindingMode;
+    lineageTrust?: DomainLineageTrust;
+}): VerificationTrustSummary;

package/dist/core/reporting.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLineageTrustBase = buildLineageTrustBase;
+exports.buildVerificationTrustSections = buildVerificationTrustSections;
+exports.buildDomainLineageTrustSummary = buildDomainLineageTrustSummary;
+exports.buildVerificationTrustSummary = buildVerificationTrustSummary;
+function buildLineageTrustBase(input) {
+    return { ...input };
+}
+function buildVerificationTrustSections(input) {
+    void input.requireArtifactTrust;
+    const definitionTrust = input.definitionTrust ?? input.emptyDefinitionTrust;
+    const stateTrust = input.stateTrust ?? input.emptyStateTrust;
+    return {
+        artifactTrust: {
+            definition: definitionTrust,
+            state: stateTrust,
+        },
+        stateTrust,
+    };
+}
+function buildDomainLineageTrustSummary(lineageTrust) {
+    if (!lineageTrust)
+        return undefined;
+    return {
+        lineageKind: lineageTrust.lineageKind,
+        latestOrdinal: lineageTrust.latestOrdinal,
+        allHashLinksVerified: lineageTrust.allHashLinksVerified,
+        identityConsistent: lineageTrust.identityConsistent,
+        fullLineageVerified: lineageTrust.fullLineageVerified,
+    };
+}
+function buildVerificationTrustSummary(input) {
+    return {
+        ...(input.definitionTrust ? { definition: input.definitionTrust } : {}),
+        ...(input.stateTrust ? { state: input.stateTrust } : {}),
+        bindingMode: input.bindingMode,
+        ...(input.lineageTrust ? { lineage: buildDomainLineageTrustSummary(input.lineageTrust) } : {}),
+    };
+}

package/dist/core/schnorr.d.ts

@@ -1,5 +1,5 @@
 export declare function hexToBytes(hex: string, byteLength?: number | null): Uint8Array;
 export declare function bytesToHex(bytes: Uint8Array): string;
-export declare function schnorrPublicKeyFromPrivkeyHex(privkeyHex: string): string;
-export declare function schnorrSignHex(messageHashHex: string, privkeyHex: string): string;
-export declare function schnorrVerifyHex(signatureHex: string, messageHashHex: string, publicKeyHex: string): boolean;
+export declare function schnorrPublicKeyFromPrivkeyHex(privkeyHex: string): Promise<string>;
+export declare function schnorrSignHex(messageHashHex: string, privkeyHex: string): Promise<string>;
+export declare function schnorrVerifyHex(signatureHex: string, messageHashHex: string, publicKeyHex: string): Promise<boolean>;

package/dist/core/schnorr.js

@@ -5,8 +5,17 @@ exports.bytesToHex = bytesToHex;
 exports.schnorrPublicKeyFromPrivkeyHex = schnorrPublicKeyFromPrivkeyHex;
 exports.schnorrSignHex = schnorrSignHex;
 exports.schnorrVerifyHex = schnorrVerifyHex;
-const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
 const errors_1 = require("./errors");
+// Keep native dynamic import intact under CommonJS output so Node can load the ESM-only noble package.
+const nativeImport = new Function("specifier", "return import(specifier);");
+let schnorrPromise;
+async function loadSchnorr() {
+    schnorrPromise ??= nativeImport("@noble/curves/secp256k1.js").then((module) => {
+        const typed = module;
+        return typed.schnorr;
+    });
+    return schnorrPromise;
+}
 function assertHex(value, byteLength, code, message) {
     if (!/^[0-9a-f]+$/i.test(value) || value.length % 2 !== 0) {
         throw new errors_1.ValidationError(message, { code });
@@ -23,12 +32,15 @@ function hexToBytes(hex, byteLength = null) {
 function bytesToHex(bytes) {
     return Buffer.from(bytes).toString("hex");
 }
-function schnorrPublicKeyFromPrivkeyHex(privkeyHex) {
-    return bytesToHex(secp256k1_js_1.schnorr.getPublicKey(hexToBytes(privkeyHex, 32)));
+async function schnorrPublicKeyFromPrivkeyHex(privkeyHex) {
+    const schnorr = await loadSchnorr();
+    return bytesToHex(schnorr.getPublicKey(hexToBytes(privkeyHex, 32)));
 }
-function schnorrSignHex(messageHashHex, privkeyHex) {
-    return bytesToHex(secp256k1_js_1.schnorr.sign(hexToBytes(messageHashHex, 32), hexToBytes(privkeyHex, 32)));
+async function schnorrSignHex(messageHashHex, privkeyHex) {
+    const schnorr = await loadSchnorr();
+    return bytesToHex(schnorr.sign(hexToBytes(messageHashHex, 32), hexToBytes(privkeyHex, 32)));
 }
-function schnorrVerifyHex(signatureHex, messageHashHex, publicKeyHex) {
-    return secp256k1_js_1.schnorr.verify(hexToBytes(signatureHex, 64), hexToBytes(messageHashHex, 32), hexToBytes(publicKeyHex, 32));
+async function schnorrVerifyHex(signatureHex, messageHashHex, publicKeyHex) {
+    const schnorr = await loadSchnorr();
+    return schnorr.verify(hexToBytes(signatureHex, 64), hexToBytes(messageHashHex, 32), hexToBytes(publicKeyHex, 32));
 }

package/dist/core/types.d.ts

@@ -449,12 +449,37 @@ export interface BondClosingDescriptor {
     stateHash: string;
     finalSettlementDescriptorHash: string;
 }
+export interface LineageTrustBase<LineageKind extends string> {
+    lineageKind: LineageKind;
+    chainLength: number;
+    latestOrdinal: number;
+    allHashLinksVerified: boolean;
+    identityConsistent: boolean;
+    fullLineageVerified: boolean;
+}
+export interface BondIssuanceLineageTrust extends LineageTrustBase<"state-history"> {
+    latestStatus?: BondIssuanceStatus;
+    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;
+}
 export interface BondVerificationReport {
     artifactTrust: {
         definition: DefinitionVerificationResult["trust"];
         state: StateVerificationResult["trust"];
     };
     stateTrust: StateVerificationResult["trust"];
+    issuanceLineageTrust?: BondIssuanceLineageTrust;
     settlementTrust?: {
         descriptorHashMatch: boolean;
         outputBindingMode: BondOutputBindingMode;
@@ -510,6 +535,7 @@ export interface BondEvidenceBundle {
         hash: string;
     };
     trust: BondVerificationReport;
+    trustSummary: VerificationTrustSummary;
     renderedSourceHash?: string;
     sourceVerificationMode: "source-reloaded" | "artifact-only";
     compiled: {
@@ -518,6 +544,189 @@ export interface BondEvidenceBundle {
         contractAddress: string;
     };
 }
+export type ReceivableStatus = "ORIGINATED" | "FUNDED" | "PARTIALLY_REPAID" | "REPAID" | "DEFAULTED";
+export type ReceivableTransitionType = "ORIGINATE" | "FUND" | "REPAY" | "WRITE_OFF";
+export type ReceivableClosingReason = "REPAID" | "DEFAULTED" | "CANCELLED";
+export type ReceivableClaimKind = "FUNDING" | "REPAYMENT";
+export type ReceivableVerificationReportSchemaVersion = "receivable-verification-report/v1";
+export type ReceivableEvidenceBundleSchemaVersion = "receivable-evidence-bundle/v1";
+export type ReceivableFinalityPayloadSchemaVersion = "receivable-finality-payload/v1";
+export interface ReceivableDefinition {
+    receivableId: string;
+    originatorEntityId: string;
+    debtorEntityId: string;
+    currencyAssetId: string;
+    faceValue: number;
+    dueDate: string;
+    controllerXonly: string;
+}
+export interface ReceivableStateTransition {
+    type: ReceivableTransitionType;
+    amount: number;
+    at: string;
+}
+export interface ReceivableState {
+    stateId: string;
+    receivableId: string;
+    originatorEntityId: string;
+    debtorEntityId: string;
+    holderEntityId: string;
+    currencyAssetId: string;
+    controllerXonly: string;
+    faceValue: number;
+    outstandingAmount: number;
+    repaidAmount: number;
+    status: ReceivableStatus;
+    createdAt: string;
+    previousStateHash?: string | null;
+    lastTransition?: ReceivableStateTransition;
+}
+export interface ReceivableClosingDescriptor {
+    closingId: string;
+    receivableId: string;
+    latestStateHash: string;
+    latestStatus: ReceivableStatus;
+    holderEntityId: string;
+    closedAt: string;
+    closingReason: ReceivableClosingReason;
+}
+export interface ReceivableClaimDescriptorBase<ClaimKind extends ReceivableClaimKind> {
+    claimId: string;
+    claimKind: ClaimKind;
+    receivableId: string;
+    currentStateHash: string;
+    currentStatus: ReceivableStatus;
+    payerEntityId: string;
+    payeeEntityId: string;
+    claimantXonly: string;
+    currencyAssetId: string;
+    amountSat: number;
+    eventTimestamp: string;
+}
+export interface ReceivableFundingClaimDescriptor extends ReceivableClaimDescriptorBase<"FUNDING"> {
+}
+export interface ReceivableRepaymentClaimDescriptor extends ReceivableClaimDescriptorBase<"REPAYMENT"> {
+}
+export interface ReceivableTransitionTrust {
+    transitionType: ReceivableTransitionType;
+    previousStateHashMatch: boolean;
+    participantConsistencyValid: boolean;
+    statusProgressionValid: boolean;
+    arithmeticDeltaValid: boolean;
+    createdAtMonotonic: boolean;
+    transitionAmountValid: boolean;
+    fullTransitionVerified: boolean;
+}
+export interface ReceivableClosingTrust {
+    terminalStatusEligible: boolean;
+    latestStateHashMatch: boolean;
+    closingReasonMatchesStatus: boolean;
+    historyTipMatches: boolean;
+    lineageProvided: boolean;
+    fullClosingVerified: boolean;
+}
+export interface ReceivableClaimTrust {
+    claimKind: ReceivableClaimKind;
+    generated: boolean;
+    stateStatusEligible: boolean;
+    receivableIdMatch: boolean;
+    currentStateHashMatch: boolean;
+    currentStatusMatch: boolean;
+    payerEntityMatch: boolean;
+    payeeEntityMatch: boolean;
+    claimantXonlyMatch: boolean;
+    claimantXonlyCommitted: boolean;
+    currencyAssetMatch: boolean;
+    amountMatch: boolean;
+    eventTimestampMatch: boolean;
+    bindingMode: BondOutputBindingMode;
+    requestedMode?: BondOutputBindingMode;
+    supportedForm: OutputBindingSupportedForm;
+    reasonCode: OutputBindingReasonCode;
+    nextReceiverRuntimeCommitted: boolean;
+    nextOutputHashRuntimeBound: boolean;
+    nextOutputScriptRuntimeBound: boolean;
+    amountRuntimeBound: boolean;
+    autoDerived?: boolean;
+    fallbackReason?: string;
+    bindingInputs?: OutputBindingInputs;
+    fullClaimVerified: boolean;
+}
+export interface ReceivableVerificationReport {
+    schemaVersion: ReceivableVerificationReportSchemaVersion;
+    receivableTrust: {
+        receivableIdMatch: boolean;
+        originatorMatch: boolean;
+        debtorMatch: boolean;
+        currencyMatch: boolean;
+        controllerMatch: boolean;
+        faceValueMatch: boolean;
+        arithmeticValid: boolean;
+        statusValid: boolean;
+    };
+    transitionTrust?: ReceivableTransitionTrust;
+    closingTrust?: ReceivableClosingTrust;
+    fundingClaimTrust?: ReceivableClaimTrust;
+    repaymentClaimTrust?: ReceivableClaimTrust;
+    stateLineageTrust?: ReceivableStateLineageTrust;
+}
+export interface ReceivableStateLineageTrust extends LineageTrustBase<"state-history"> {
+    latestStatus: ReceivableStatus;
+    startsAtGenesis: boolean;
+    receivableIdConsistent: boolean;
+    originatorConsistent: boolean;
+    debtorConsistent: boolean;
+    currencyConsistent: boolean;
+    controllerConsistent: boolean;
+    faceValueConsistent: boolean;
+    allPreviousStateHashMatch: boolean;
+    allArithmeticValid: boolean;
+    allStatusProgressionValid: boolean;
+    fullHistoryVerified: boolean;
+}
+export interface ReceivableEvidenceBundle {
+    schemaVersion: ReceivableEvidenceBundleSchemaVersion;
+    definition: {
+        canonicalJson: string;
+        hash: string;
+    };
+    state: {
+        canonicalJson: string;
+        hash: string;
+    };
+    stateHistory?: Array<{
+        canonicalJson: string;
+        hash: string;
+    }>;
+    fundingClaim?: {
+        canonicalJson: string;
+        hash: string;
+    };
+    repaymentClaim?: {
+        canonicalJson: string;
+        hash: string;
+    };
+    closing?: {
+        canonicalJson: string;
+        hash: string;
+    };
+    trust: ReceivableVerificationReport;
+    trustSummary: VerificationTrustSummary;
+}
+export interface ReceivableFinalityPayload {
+    schemaVersion: ReceivableFinalityPayloadSchemaVersion;
+    receivableId: string;
+    holderEntityId: string;
+    definitionHash: string;
+    latestStateHash: string;
+    stateHistoryHashes?: string[] | null;
+    fundingClaimHash?: string | null;
+    repaymentClaimHash?: string | null;
+    closingHash?: string | null;
+    closingReason?: ReceivableClosingReason | null;
+    trust: ReceivableVerificationReport;
+    trustSummary: VerificationTrustSummary;
+}
 export type CapitalCallStatus = "OPEN" | "CLAIMED" | "REFUND_ONLY" | "REFUNDED";
 export type CapitalCallStage = "open" | "claimed" | "refund-only" | "refunded";
 export type CapitalCallCutoffMode = "rollover-window";
@@ -666,13 +875,52 @@ export interface FundVerificationReport {
         sequence?: number;
         sequenceMonotonic?: boolean;
         attestingSignerMatch?: boolean;
+        previousEnvelopeProvided?: boolean;
+        previousReceiptHashMatch?: boolean;
+        previousSequenceMatch?: boolean;
+        continuityVerified?: boolean;
     };
+    receiptChainTrust?: FundReceiptChainTrust;
     closingTrust?: {
         positionReceiptHashMatch: boolean;
         finalDistributionHashesPresent: boolean;
         positionStatusEligible: boolean;
     };
 }
+export interface FundReceiptChainTrust extends LineageTrustBase<"receipt-chain"> {
+    latestSequence?: number;
+    startsAtGenesis: boolean;
+    latestSequenceCovered: boolean;
+    sequenceContiguous: boolean;
+    fundConsistent: boolean;
+    positionConsistent: boolean;
+    lpConsistent: boolean;
+    callConsistent: boolean;
+    currencyConsistent: boolean;
+    lpXonlyConsistent: boolean;
+    attestingSignerConsistent: boolean;
+    allPositionReceiptHashMatch: boolean;
+    allSequenceMatch: boolean;
+    allSequenceMonotonic: boolean;
+    allAttestingSignerMatch: boolean;
+    allAttestationVerified: boolean;
+    allContinuityVerified: boolean;
+    fullChainVerified: boolean;
+}
+export type DomainLineageTrust = BondIssuanceLineageTrust | FundReceiptChainTrust | ReceivableStateLineageTrust;
+export interface DomainLineageTrustSummary {
+    lineageKind: DomainLineageTrust["lineageKind"];
+    latestOrdinal: number;
+    allHashLinksVerified: boolean;
+    identityConsistent: boolean;
+    fullLineageVerified: boolean;
+}
+export interface VerificationTrustSummary {
+    definition?: DefinitionVerificationResult["trust"];
+    state?: StateVerificationResult["trust"];
+    bindingMode: BondOutputBindingMode;
+    lineage?: DomainLineageTrustSummary;
+}
 export interface FundEvidenceBundle {
     schemaVersion: FundEvidenceBundleSchemaVersion;
     artifact?: SimplicityArtifact;
@@ -705,6 +953,7 @@ export interface FundEvidenceBundle {
         hash: string;
     };
     trust: FundVerificationReport;
+    trustSummary: VerificationTrustSummary;
     renderedSourceHash?: string;
     sourceVerificationMode: "source-reloaded" | "artifact-only";
     compiled?: {
@@ -728,11 +977,7 @@ export interface FundFinalityPayload {
     closingHash?: string | null;
     bindingMode: BondOutputBindingMode;
     trust: FundVerificationReport;
-    trustSummary: {
-        definition?: DefinitionVerificationResult["trust"];
-        state?: StateVerificationResult["trust"];
-        bindingMode: BondOutputBindingMode;
-    };
+    trustSummary: VerificationTrustSummary;
 }
 export interface PolicyReceiver {
     mode: "plain" | "policy";
@@ -855,6 +1100,7 @@ export interface PolicyEvidenceBundle {
         hash: string;
     };
     report: PolicyVerificationReport;
+    trustSummary: VerificationTrustSummary;
     renderedSourceHash?: string;
     sourceVerificationMode: "source-reloaded" | "artifact-only";
     compiled: {

package/dist/docs/definitions/fund-capital-call-refund-only.simf

@@ -20,7 +20,38 @@ fn require_state_anchor() {
     assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
 }
 
-fn refund_path(lp_signature: Signature) {
+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 refund_path(
+    expected_output_hash: u256,
+    expected_output_script_hash: u256,
+    binding_mode: u8,
+    lp_signature: Signature
+) {
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
     let lp: Pubkey = 0x{{LP_XONLY}};
     jet::bip_0340_verify((lp, jet::sig_all_hash()), lp_signature)
 }
@@ -28,6 +59,9 @@ fn refund_path(lp_signature: Signature) {
 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;
     let signer_signature: Signature = witness::SIGNER_SIGNATURE;
-    refund_path(signer_signature)
+    refund_path(expected_output_hash, expected_output_script_hash, binding_mode, signer_signature)
 }