Receipt Lineage & Buyer Packets

//! Complete hash-binding example adapted from the public runtime verifier fixtures.
//! Opaque digests and declared evidence grades are illustrative, not cryptographic evidence.
#![allow(unused_imports)]
use chio_core_types::crypto::Keypair;
use chio_core_types::receipt::{
    body::ChioReceipt, body::ChioReceiptBody, decision::Decision, decision::ToolCallAction,
    kinds::BoundaryClass, kinds::ReceiptKind, kinds::RedactionMode, kinds::ToolOrigin,
    kinds::TrustLevel, metadata::ActorRef,
};
use chio_federation::{
    bilateral_dsse::sign_chio_bilateral_dsse_envelope,
    bilateral_dsse::BilateralPredicateExtensions, bilateral_dsse::CapabilityLeaseRef,
    bilateral_dsse::DsseEnvelope, bilateral_dsse::GovernanceReceiptRef, bilateral_dsse::HashRecord,
    bilateral_dsse::PolicyEvaluationSummary, bilateral_dsse::PolicyVerdict,
    bilateral_dsse::TreatyBindingRef, bilateral_dsse::PAYLOAD_TYPE_IN_TOTO,
};
use chio_runtime_core::{
    bilateral_dsse_consistency_model as dsse_consistency_model, tool_args_sha256,
    verify_buyer_attestation_packet, verify_buyer_attestation_review_package_with_trust,
    verify_receipt_lineage_bundle, BilateralInvocation, BuyerAttestationPacket,
    BuyerAttestationReviewArtifactRef, BuyerAttestationReviewPackage, BuyerAttestationReviewReport,
    BuyerAttestationReviewSource, BuyerAttestationReviewTrustContext, ChioRuntimeError,
    CrossBoundaryAdmissionReport, CrossBoundaryEvidenceRef, CrossKernelContinuation,
    ReceiptLineageBundle, ReceiptLineageStatement, RuntimeEvidenceManifest,
    RuntimeEvidenceManifestEntry, RuntimeProofRegenerationInput, RuntimeProofRegenerationReport,
    RuntimeProofSourceRecord, RuntimeStepEvidence, RuntimeWorkflowRunReport,
    CHIO_BILATERAL_INVOCATION_SCHEMA, CHIO_BUYER_ATTESTATION_PACKET_SCHEMA,
    CHIO_BUYER_ATTESTATION_REVIEW_PACKAGE_SCHEMA, CHIO_CROSS_BOUNDARY_ADMISSION_REPORT_SCHEMA,
    CHIO_CROSS_KERNEL_CONTINUATION_SCHEMA, CHIO_FEDERATION_RECEIPT_LINEAGE_BUNDLE_SCHEMA,
    CHIO_FEDERATION_RECEIPT_LINEAGE_STATEMENT_SCHEMA, CHIO_RECEIPT_LINEAGE_BUNDLE_SCHEMA,
    CHIO_RECEIPT_LINEAGE_STATEMENT_SCHEMA, CHIO_RUNTIME_EVIDENCE_MANIFEST_SCHEMA,
    CHIO_RUNTIME_PROOF_REGENERATION_INPUT_SCHEMA, CHIO_RUNTIME_PROOF_REGENERATION_REPORT_SCHEMA,
    CHIO_RUNTIME_STEP_EVIDENCE_SCHEMA, CHIO_RUNTIME_WORKFLOW_RUN_REPORT_SCHEMA,
};
use std::io;

type BuyerFixture = (
    BuyerAttestationPacket,
    ReceiptLineageStatement,
    CrossKernelContinuation,
    CrossBoundaryAdmissionReport,
    BilateralInvocation,
);

fn strict_dsse_fixture_receipt(
    capability_id: &str,
    signer_b: &Keypair,
    receipt_action: Option<ToolCallAction>,
) -> Result<ChioReceipt, Box<dyn std::error::Error>> {
    strict_dsse_fixture_receipt_with_id("rcpt-treaty-dsse", capability_id, signer_b, receipt_action)
}

fn strict_dsse_fixture_receipt_with_id(
    receipt_id: &str,
    capability_id: &str,
    signer: &Keypair,
    receipt_action: Option<ToolCallAction>,
) -> Result<ChioReceipt, Box<dyn std::error::Error>> {
    ChioReceipt::sign(
        ChioReceiptBody {
            id: receipt_id.to_string(),
            timestamp: 1_800_000_010,
            capability_id: capability_id.to_string(),
            tool_server: "vendor-ledger".to_string(),
            tool_name: "close_account".to_string(),
            action: receipt_action.unwrap_or(ToolCallAction::from_parameters(serde_json::json!({
                "record": "vendor-ledger-7",
                "value": "closed"
            }))?),
            decision: Some(Decision::Allow),
            receipt_kind: ReceiptKind::MediatedDecision,
            boundary_class: BoundaryClass::Prevent,
            observation_outcome: None,
            tool_origin: ToolOrigin::CallerExecuted,
            redaction_mode: RedactionMode::None,
            actor_chain: vec![ActorRef {
                actor_id: "agent:chio-runtime/buyer-review".to_string(),
                actor_kind: Some("agent".to_string()),
            }],
            content_hash: "c".repeat(64),
            policy_hash: "policy-live".to_string(),
            evidence: Vec::new(),
            metadata: None,
            trust_level: TrustLevel::default(),
            tenant_id: None,
            kernel_key: signer.public_key(),
            bbs_projection_version: None,
        },
        signer,
    )
    .map_err(Into::into)
}

fn buyer_fixture() -> Result<BuyerFixture, Box<dyn std::error::Error>> {
    let default_buyer_key = Keypair::from_seed(&[1; 32]);
    let default_vendor_key = Keypair::from_seed(&[2; 32]);
    let default_parent_receipt = strict_dsse_fixture_receipt_with_id(
        "rcpt-parent-local",
        "cap-live-1",
        &default_buyer_key,
        None,
    )?;
    let default_parent_receipt_sha256 = chio_core_types::crypto::sha256_hex(
        &chio_core_types::crypto::canonical_json_bytes(&default_parent_receipt)?,
    );
    let default_child_receipt =
        strict_dsse_fixture_receipt("cap-live-1", &default_vendor_key, None)?;
    let default_child_receipt_sha256 = chio_core_types::crypto::sha256_hex(
        &chio_core_types::crypto::canonical_json_bytes(&default_child_receipt)?,
    );
    let continuation = CrossKernelContinuation {
        schema: CHIO_CROSS_KERNEL_CONTINUATION_SCHEMA.to_string(),
        continuation_id: "continue-1".to_string(),
        source_kernel_id: "kernel.buyer".to_string(),
        target_kernel_id: "kernel.vendor-b".to_string(),
        parent_receipt_sha256: default_parent_receipt_sha256.clone(),
        parent_session_anchor_sha256: "2".repeat(64),
        capability_id: "cap-live-1".to_string(),
        action_class_id: "workflow.destructive.vendor_call".to_string(),
        audience_tool: "vendor-ledger.close_account".to_string(),
        nonce: "nonce-1".to_string(),
        issued_at_unix_ms: 1_800_000_000_000,
        expires_at_unix_ms: 1_800_003_600_000,
    };
    let continuation_sha256 = chio_core_types::crypto::sha256_hex(
        &chio_core_types::crypto::canonical_json_bytes(&continuation)?,
    );
    let mut lineage = ReceiptLineageStatement {
        schema: CHIO_RECEIPT_LINEAGE_STATEMENT_SCHEMA.to_string(),
        statement_id: "lineage-1".to_string(),
        parent_receipt_sha256: default_parent_receipt_sha256,
        child_receipt_sha256: default_child_receipt_sha256,
        continuation_sha256,
        bilateral_invocation_sha256: String::new(),
        evidence_class: "verified".to_string(),
        source_kernel_id: "kernel.buyer".to_string(),
        target_kernel_id: "kernel.vendor-b".to_string(),
    };
    let mut admission = CrossBoundaryAdmissionReport {
        schema: CHIO_CROSS_BOUNDARY_ADMISSION_REPORT_SCHEMA.to_string(),
        treaty_id: "treaty-buyer-vendor".to_string(),
        action_class_id: "workflow.destructive.vendor_call".to_string(),
        accepted: true,
        failure_code: None,
        mode: "receipt_backed".to_string(),
        consistency_model: "totally_ordered".to_string(),
        co_sign: "bilateral_required".to_string(),
        co_sign_quorum: None,
        required_evidence: vec![
            "governance_receipt".to_string(),
            "bilateral_invocation".to_string(),
            "receipt_lineage".to_string(),
        ],
        present_evidence: vec![
            "governance_receipt".to_string(),
            "bilateral_invocation".to_string(),
            "receipt_lineage".to_string(),
        ],
        verified_evidence: vec![
            CrossBoundaryEvidenceRef {
                evidence_class: "governance_receipt".to_string(),
                artifact_sha256: "d".repeat(64),
                verified: true,
            },
            CrossBoundaryEvidenceRef {
                evidence_class: "bilateral_invocation".to_string(),
                artifact_sha256: "4".repeat(64),
                verified: true,
            },
            CrossBoundaryEvidenceRef {
                evidence_class: "bilateral_dsse".to_string(),
                artifact_sha256: "4".repeat(64),
                verified: true,
            },
            CrossBoundaryEvidenceRef {
                evidence_class: "receipt_lineage".to_string(),
                artifact_sha256: String::new(),
                verified: true,
            },
        ],
        treaty_scope_sha256: "5".repeat(64),
        ladder_intersection_sha256: "6".repeat(64),
        expected_ladder_intersection_sha256: Some("6".repeat(64)),
        checks: vec!["chio_treaty.required_evidence_present".to_string()],
    };
    let mut bilateral = BilateralInvocation {
        schema: CHIO_BILATERAL_INVOCATION_SCHEMA.to_string(),
        invocation_id: "invoke-1".to_string(),
        treaty_id: "treaty-buyer-vendor".to_string(),
        ladder_intersection_sha256: admission.ladder_intersection_sha256.clone(),
        continuation_sha256: lineage.continuation_sha256.clone(),
        lineage_statement_sha256: String::new(),
        action_class_id: "workflow.destructive.vendor_call".to_string(),
        consistency_model: "totally_ordered".to_string(),
        capability_id: "cap-live-1".to_string(),
        request_sha256: tool_args_sha256(&serde_json::json!({
            "record": "vendor-ledger-7",
            "value": "closed"
        }))?,
        outcome_sha256: "c".repeat(64),
        local_receipt_sha256: lineage.parent_receipt_sha256.clone(),
        remote_receipt_sha256: lineage.child_receipt_sha256.clone(),
        signer_kernel_ids: vec!["kernel.buyer".to_string(), "kernel.vendor-b".to_string()],
    };
    let bilateral_invocation_sha256 =
        chio_runtime_core::bilateral_invocation_binding_sha256(&bilateral)?;
    lineage.bilateral_invocation_sha256 = bilateral_invocation_sha256.clone();
    let lineage_hash = chio_core_types::crypto::sha256_hex(
        &chio_core_types::crypto::canonical_json_bytes(&lineage)?,
    );
    bilateral.lineage_statement_sha256 = lineage_hash.clone();
    for evidence in &mut admission.verified_evidence {
        if evidence.evidence_class == "receipt_lineage" {
            evidence.artifact_sha256 = lineage_hash.clone();
        } else if evidence.evidence_class == "bilateral_invocation" {
            evidence.artifact_sha256 = bilateral_invocation_sha256.clone();
        }
    }
    let admission_hash = chio_core_types::crypto::sha256_hex(
        &chio_core_types::crypto::canonical_json_bytes(&admission)?,
    );
    let packet = BuyerAttestationPacket {
        schema: CHIO_BUYER_ATTESTATION_PACKET_SCHEMA.to_string(),
        packet_id: "buyer-packet-1".to_string(),
        buyer_id: "kernel.buyer".to_string(),
        capability_id: bilateral.capability_id.clone(),
        treaty_scope_sha256: admission.treaty_scope_sha256.clone(),
        ladder_intersection_sha256: admission.ladder_intersection_sha256.clone(),
        cross_boundary_admission_report_sha256: admission_hash,
        continuation_sha256: lineage.continuation_sha256.clone(),
        receipt_lineage_statement_sha256: lineage_hash,
        bilateral_invocation_sha256,
        bilateral_dsse_sha256: "4".repeat(64),
        workflow_receipt_sha256: "8".repeat(64),
        proof_package_sha256: "9".repeat(64),
        verifier_report_sha256: "a".repeat(64),
        budget_refs: vec!["budget.reserve:local-demo".to_string()],
        settlement_claimed: false,
    };
    Ok((packet, lineage, continuation, admission, bilateral))
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let (packet, lineage, continuation, admission, bilateral) = buyer_fixture()?;
    std::fs::create_dir("packet-inputs")?;
    for (name, value) in [
        ("packet", serde_json::to_value(&packet)?),
        ("lineage", serde_json::to_value(&lineage)?),
        ("continuation", serde_json::to_value(&continuation)?),
        ("admission", serde_json::to_value(&admission)?),
        ("bilateral", serde_json::to_value(&bilateral)?),
    ] {
        std::fs::write(
            format!("packet-inputs/{name}.json"),
            serde_json::to_vec_pretty(&value)?,
        )?;
    }
    let report =
        verify_buyer_attestation_packet(&packet, &lineage, &continuation, &admission, &bilateral)?;
    assert!(!report.accepted);
    assert_eq!(report.verification_state, "unresolved");
    assert_eq!(
        report.failure_code.as_deref(),
        Some("chio_buyer_packet_dsse_unresolved")
    );
    println!("consistent hash-only packet: unresolved; DSSE bytes and trust are still required");
    let mut changed = packet;
    changed.bilateral_invocation_sha256 = "b".repeat(64);
    let denied =
        verify_buyer_attestation_packet(&changed, &lineage, &continuation, &admission, &bilateral)?;
    assert_eq!(
        denied.failure_code.as_deref(),
        Some("chio_buyer_packet_hash_mismatch")
    );
    println!("altered artifact binding: rejected");
    println!("wrote all five input files; no execution or settlement is claimed");
    Ok(())
}