lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

receipt.rs (11555B)


      1 use crate::{
      2     Admission, ArtifactRole, BusinessInstallation, ChatValue, Delivery, Error, Issuance,
      3     ListingValue, OperationKind, RecoveryRequirement, SatisfactionClass, TargetObservation, Value,
      4     WaitTermination,
      5 };
      6 
      7 /// Exact protected artifact references, without payload or invocation rights.
      8 #[derive(Clone, uniffi::Record)]
      9 pub struct Artifact {
     10     pub role: ArtifactRole,
     11     pub recipient: Option<String>,
     12     pub expected_event: Option<String>,
     13     pub issuance: Issuance,
     14     pub attempt_id: Option<String>,
     15     pub claim_transaction: Option<String>,
     16     pub intent_digest: Option<String>,
     17     pub capture_transaction: Option<String>,
     18     pub obtained_digest: Option<String>,
     19     pub publication_transaction: Option<String>,
     20     pub observed_at_unix_ms: Option<String>,
     21 }
     22 #[derive(Clone, uniffi::Record)]
     23 pub struct Observation {
     24     pub event_id: String,
     25     pub recipient: Option<String>,
     26     pub target: String,
     27     pub request_id: String,
     28     pub target_fingerprint: String,
     29     pub target_ordinal: u8,
     30     pub outcome: TargetObservation,
     31     pub observed_at_unix_ms: Option<String>,
     32 }
     33 #[derive(Clone, uniffi::Enum)]
     34 pub enum TargetPolicy {
     35     Any,
     36     All,
     37     Quorum { threshold: u16 },
     38     Required { fingerprints: Vec<String> },
     39 }
     40 #[derive(Clone, uniffi::Record)]
     41 pub struct Target {
     42     pub uri: String,
     43     pub kind: String,
     44     pub fingerprint: String,
     45 }
     46 #[derive(Clone, uniffi::Record)]
     47 pub struct DeliveryAttempt {
     48     pub request_id: String,
     49     pub event_id: String,
     50     pub role: ArtifactRole,
     51     pub recipient: Option<String>,
     52     pub targets: Vec<Target>,
     53     pub selected_fingerprints: Vec<String>,
     54     pub satisfaction_class: SatisfactionClass,
     55     pub policy: TargetPolicy,
     56     pub publication_policy_digest: String,
     57     pub intent_digest: String,
     58     pub original_bytes_digest: String,
     59     pub transaction_id: String,
     60     pub work_transaction_id: String,
     61     pub retained_at: String,
     62     pub deadline_unix_ms: String,
     63     pub target_ordinals: Vec<u8>,
     64 }
     65 
     66 /// Source-projected current facts. This data is never an executable context or
     67 /// a new authority to sign, install, dispatch or infer recipient delivery.
     68 #[derive(Clone, uniffi::Record)]
     69 pub struct Receipt {
     70     pub kind: OperationKind,
     71     pub operation_id: String,
     72     pub captured_context_json: Vec<u8>,
     73     pub command_digest: String,
     74     pub admission: Admission,
     75     pub admission_transaction_id: String,
     76     pub plan_transaction_id: Option<String>,
     77     pub installation_transaction_id: Option<String>,
     78     pub installed_at: Option<String>,
     79     pub prepared_at: String,
     80     pub first_issue_not_after: String,
     81     pub authority_checkpoint_json: Vec<u8>,
     82     pub operation_checkpoint: String,
     83     pub observed_at: String,
     84     pub business_installation: BusinessInstallation,
     85     pub business_result: Option<Value>,
     86     pub issuance: Issuance,
     87     pub delivery: Delivery,
     88     pub wait_termination: WaitTermination,
     89     pub message_id: Option<String>,
     90     pub record_ids: Vec<String>,
     91     pub missing_sources: Vec<String>,
     92     pub conflicting_records: Vec<String>,
     93     pub conflicting_sources: Vec<String>,
     94     pub artifacts: Vec<Artifact>,
     95     pub delivery_attempts: Vec<DeliveryAttempt>,
     96     pub delivery_observations: Vec<Observation>,
     97     pub recovery: Vec<RecoveryRequirement>,
     98     pub error: Option<Error>,
     99 }
    100 impl Receipt {
    101     pub(crate) fn listing(
    102         value: &radroots::OperationReceipt<radroots::listings::Listing>,
    103     ) -> Result<Self, Error> {
    104         project(
    105             value,
    106             value.business_result().map(|v| Value::Listing {
    107                 listing: ListingValue::captured(v),
    108             }),
    109         )
    110     }
    111     pub(crate) fn chat(
    112         value: &radroots::OperationReceipt<radroots::domain::ChatMessage>,
    113     ) -> Result<Self, Error> {
    114         project(
    115             value,
    116             value.business_result().map(|v| Value::Chat {
    117                 message: ChatValue::captured(v),
    118             }),
    119         )
    120     }
    121     pub(crate) fn status(value: &radroots::OperationStatus) -> Result<Self, Error> {
    122         let result = value.business_result().map(|v| match v {
    123             radroots::OperationValue::Listing(v) => Value::Listing {
    124                 listing: ListingValue::captured(v),
    125             },
    126             radroots::OperationValue::Chat(v) => Value::Chat {
    127                 message: ChatValue::captured(v),
    128             },
    129         });
    130         project(value, result)
    131     }
    132 }
    133 fn project<T>(
    134     value: &radroots::OperationReceipt<T>,
    135     business_result: Option<Value>,
    136 ) -> Result<Receipt, Error> {
    137     let operation = value.context().operation_id().to_string();
    138     project_inner(value, business_result).map_err(|v| v.with_operation(operation))
    139 }
    140 fn project_inner<T>(
    141     value: &radroots::OperationReceipt<T>,
    142     business_result: Option<Value>,
    143 ) -> Result<Receipt, Error> {
    144     let context = || Error::UnsupportedState {
    145         axis: "receipt_data".to_owned(),
    146         operation_id: Some(value.context().operation_id().to_string()),
    147         signer_rejection: None,
    148     };
    149     let artifacts = value
    150         .artifacts()
    151         .iter()
    152         .map(|v| {
    153             Ok(Artifact {
    154                 role: v.role().try_into()?,
    155                 recipient: v.recipient().map(|v| v.to_hex()),
    156                 expected_event: v.expected_event().map(|v| v.to_string()),
    157                 issuance: v.issuance().try_into()?,
    158                 attempt_id: v.attempt_id().map(|v| v.to_string()),
    159                 claim_transaction: v.claim_transaction_id().map(|v| v.to_string()),
    160                 intent_digest: v.intent_digest().map(|v| hex(&v)),
    161                 capture_transaction: v.capture_transaction_id().map(|v| v.to_string()),
    162                 obtained_digest: v.obtained_digest().map(|v| hex(&v)),
    163                 publication_transaction: v.publication_transaction_id().map(|v| v.to_string()),
    164                 observed_at_unix_ms: v.observed_at_unix_ms().map(|v| v.to_string()),
    165             })
    166         })
    167         .collect::<Result<Vec<_>, Error>>()?;
    168     let observations = value
    169         .delivery_observations()
    170         .iter()
    171         .map(|v| {
    172             Ok(Observation {
    173                 event_id: v.event_id().to_string(),
    174                 recipient: v.recipient().map(|v| v.to_hex()),
    175                 target: v.target().to_owned(),
    176                 request_id: v.request_id().to_owned(),
    177                 target_fingerprint: v.target_fingerprint().to_owned(),
    178                 target_ordinal: v.target_ordinal(),
    179                 outcome: v.outcome().try_into()?,
    180                 observed_at_unix_ms: v.observed_at_unix_ms().map(|v| v.to_string()),
    181             })
    182         })
    183         .collect::<Result<Vec<_>, Error>>()?;
    184     let attempts = value
    185         .delivery_attempts()
    186         .iter()
    187         .map(|v| {
    188             let intent = v.intent();
    189             let selected = intent.policy().targets();
    190             let policy = if selected.is_any() {
    191                 TargetPolicy::Any
    192             } else if selected.is_all() {
    193                 TargetPolicy::All
    194             } else if let Some(threshold) = selected.quorum_threshold() {
    195                 TargetPolicy::Quorum { threshold }
    196             } else if let Some(required) = selected.required_targets() {
    197                 TargetPolicy::Required {
    198                     fingerprints: required.iter().map(|v| v.as_str().to_owned()).collect(),
    199                 }
    200             } else {
    201                 return Err(context());
    202             };
    203             Ok(DeliveryAttempt {
    204                 request_id: intent.request_id().as_str().to_owned(),
    205                 event_id: intent.event_id().to_string(),
    206                 role: intent.role().try_into()?,
    207                 recipient: v.work().target().recipient().map(|v| v.to_hex()),
    208                 targets: intent
    209                     .targets()
    210                     .targets()
    211                     .iter()
    212                     .map(|v| Target {
    213                         uri: v.uri().as_str().to_owned(),
    214                         kind: v.kind().as_str().to_owned(),
    215                         fingerprint: v.fingerprint().as_str().to_owned(),
    216                     })
    217                     .collect(),
    218                 selected_fingerprints: intent
    219                     .selection()
    220                     .iter()
    221                     .map(|v| v.as_str().to_owned())
    222                     .collect(),
    223                 satisfaction_class: intent.policy().class().into(),
    224                 policy,
    225                 publication_policy_digest: hex(intent.publication_policy_digest()),
    226                 intent_digest: hex(intent.digest()),
    227                 original_bytes_digest: hex(v.envelope_digest()),
    228                 transaction_id: v.transaction_id().to_string(),
    229                 work_transaction_id: v.work().transaction_id().to_string(),
    230                 retained_at: v.retained_at().to_string(),
    231                 deadline_unix_ms: intent.deadline_unix_ms().to_string(),
    232                 target_ordinals: v.target_ordinals().to_vec(),
    233             })
    234         })
    235         .collect::<Result<Vec<_>, Error>>()?;
    236     Ok(Receipt {
    237         kind: value.kind().try_into()?,
    238         operation_id: value.context().operation_id().to_string(),
    239         captured_context_json: serde_json::to_vec(value.context()).map_err(|_| context())?,
    240         command_digest: value.command_digest().to_string(),
    241         admission: value.admission().try_into()?,
    242         admission_transaction_id: value.admission_transaction_id().to_string(),
    243         plan_transaction_id: value.plan_transaction_id().map(|v| v.to_string()),
    244         installation_transaction_id: value.installation_transaction_id().map(|v| v.to_string()),
    245         installed_at: value.installed_at().map(|v| v.to_string()),
    246         prepared_at: value.issuance_window().prepared_at().to_string(),
    247         first_issue_not_after: value.issuance_window().first_issue_not_after().to_string(),
    248         authority_checkpoint_json: serde_json::to_vec(value.authority_checkpoint())
    249             .map_err(|_| context())?,
    250         operation_checkpoint: value.operation_checkpoint().to_string(),
    251         observed_at: value.observed_at().to_string(),
    252         business_installation: value.business_installation().try_into()?,
    253         business_result,
    254         issuance: value.issuance().try_into()?,
    255         delivery: value.delivery().try_into()?,
    256         wait_termination: value.wait_termination().try_into()?,
    257         message_id: value.message_id().map(|v| v.to_string()),
    258         record_ids: value.record_ids().iter().map(ToString::to_string).collect(),
    259         missing_sources: value
    260             .missing_sources()
    261             .iter()
    262             .map(ToString::to_string)
    263             .collect(),
    264         conflicting_records: value
    265             .conflicting_records()
    266             .iter()
    267             .map(ToString::to_string)
    268             .collect(),
    269         conflicting_sources: value
    270             .conflicting_sources()
    271             .iter()
    272             .map(ToString::to_string)
    273             .collect(),
    274         artifacts,
    275         delivery_attempts: attempts,
    276         delivery_observations: observations,
    277         recovery: value
    278             .recovery()
    279             .iter()
    280             .copied()
    281             .map(TryInto::try_into)
    282             .collect::<Result<Vec<_>, Error>>()?,
    283         error: value.error().map(Error::from),
    284     })
    285 }
    286 fn hex(bytes: &[u8]) -> String {
    287     const DIGITS: &[u8; 16] = b"0123456789abcdef";
    288     let mut result = String::with_capacity(bytes.len() * 2);
    289     for byte in bytes {
    290         result.push(DIGITS[(byte >> 4) as usize] as char);
    291         result.push(DIGITS[(byte & 15) as usize] as char);
    292     }
    293     result
    294 }