Struct CalculationReceipt 

pub struct CalculationReceipt {
    pub receipt_id: Uuid,
    pub input_hash: String,
    pub output_hash: String,
    pub ruleset_id: String,
    pub ruleset_version: String,
    pub bundle_version: Option<String>,
    pub factor_dataset_id: String,
    pub factor_dataset_version: String,
    pub factor_set_hash: Option<String>,
    pub assessed_as_of: NaiveDate,
    pub computed_at: DateTime<Utc>,
    pub jws: Option<String>,
}

Proof-of-calculation envelope emitted by every calculator function.

Carries enough information to reproduce or audit the result: both inputs and numeric outputs are JCS-hashed (RFC 8785) so an auditor can verify the same inputs produce the same outputs, and the exact ruleset + factor dataset versions are recorded. The receipt may be signed by the vault via seal_with_jws after calling canonical_bytes_for_signing.

Intended to be stored alongside the computed value in the proof-bound store.

Fields

receipt_id: Uuid

Unique receipt identifier (UUIDv7, time-sortable).

input_hash: String

SHA-256 of the JCS (RFC 8785) canonical JSON of the calculator inputs.

output_hash: String

SHA-256 of the JCS (RFC 8785) canonical JSON of the numeric output values. Empty string until populated via with_output_hash.

ruleset_id: String

Machine-readable identifier of the ruleset used.

ruleset_version: String

Version of the ruleset (semver-shaped string).

bundle_version: Option<String>

Version of the signed Compliance-Current bundle that delivered this ruleset. None when the ruleset came from the built-in baseline (no signed bundle involved).

factor_dataset_id: String

Identifier of the factor dataset (empty if no factor provider was used).

factor_dataset_version: String

Version of the factor dataset (empty if no factor provider was used).

factor_set_hash: Option<String>

SHA-256 of the full factor table at calculation time. None when the calculation did not use a FactorProvider.

assessed_as_of: NaiveDate

The date whose law this calculation was performed against — the product’s regulated triggering event, not the day it was computed.

Without this an auditor can see which ruleset was cited but not whether it was the right one to cite, because ruleset selection is a function of this date. It is the difference between a receipt that can be re-verified and one that can only be re-read.

computed_at: DateTime<Utc>

UTC timestamp when the calculation ran.

jws: Option<String>

JWS signature produced by the vault/engine after calculation. None until the caller calls seal_with_jws.

Implementations

impl CalculationReceipt

pub fn new( input_hash: impl Into<String>, ruleset_id: impl Into<String>, ruleset_version: impl Into<String>, clock: AssessmentClock, ) -> Self

Both timestamps come from clock — the receipt never reads the wall clock itself, so replaying a stored calculation reproduces its dates exactly rather than stamping today’s.

pub fn for_ruleset<T: Serialize>( inputs: &T, ruleset: &dyn Ruleset, clock: AssessmentClock, output_hash: impl Into<String>, ) -> Result<Self, CalcError>

Build the receipt for a calculate() call: hashes inputs, cites ruleset’s id/version, and attaches output_hash. The one-liner every calculator’s calculate() should use instead of hand-assembling CalculationReceipt::new(...).with_output_hash(...) — see co2e::calculator::calculate / repairability::calculator::calculate.

pub fn with_output_hash(self, hash: impl Into<String>) -> Self

Bind the numeric output values to this receipt.

pub fn with_bundle_version(self, bundle_version: impl Into<String>) -> Self

Stamp the signed Compliance-Current bundle version that delivered this ruleset. Leave unset (None) for the built-in baseline rulesets.

pub fn with_factor_provider(self, provider: &dyn FactorProvider) -> Self

Attach factor-provider provenance to this receipt.

pub fn seal_with_jws(self, jws: String) -> Self

Attach a JWS signature produced by the external signing infrastructure. Call after canonical_bytes_for_signing to avoid signing the jws field itself.

pub fn canonical_bytes_for_signing(&self) -> Result<Vec<u8>, CalcError>

JCS-canonical bytes of this receipt without the jws field.

Pass these bytes to the vault’s signing infrastructure, then call seal_with_jws with the resulting JWS to produce the final sealed receipt.

Trait Implementations

impl Clone for CalculationReceipt

fn clone(&self) -> CalculationReceipt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CalculationReceipt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CalculationReceipt

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CalculationReceipt

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.