stock_unissued.rs (4239B)
1 //! Retain original invocation material before any fallible capture or await. 2 use super::*; 3 use crate::session::commerce::{ 4 AcceptanceClaim, AcceptanceSelection, AcceptanceUnissued, AcceptanceUnissuedOutcome, 5 AcceptanceUnissuedReceipt, 6 }; 7 use alloc::boxed::Box; 8 use radroots_domain::PublicKey; 9 10 pub(in crate::session) struct RetainedUnissued { 11 selection: AcceptanceSelection, 12 claim: AcceptanceClaim, 13 recipient: PublicKey, 14 observation: Box<dyn AcceptanceUnissued>, 15 receipt: Mutex<Option<AcceptanceUnissuedReceipt>>, 16 _lease: Shared<dyn HostBound>, 17 } 18 impl RetainedUnissued { 19 pub(super) fn operation(&self) -> radroots_domain::OperationId { 20 self.selection.operation 21 } 22 } 23 impl Owner { 24 pub(in crate::session) fn retain_unissued( 25 &self, 26 selection: AcceptanceSelection, 27 claim: AcceptanceClaim, 28 recipient: PublicKey, 29 observation: Box<dyn AcceptanceUnissued>, 30 lease: Shared<dyn HostBound>, 31 ) -> Shared<RetainedUnissued> { 32 let entry = Shared::new(RetainedUnissued { 33 selection, 34 claim, 35 recipient, 36 observation, 37 receipt: Mutex::new(None), 38 _lease: lease, 39 }); 40 self.unissued 41 .lock() 42 .unwrap_or_else(std::sync::PoisonError::into_inner) 43 .push(entry.clone()); 44 entry 45 } 46 pub(in crate::session) async fn capture_unissued( 47 &self, 48 entry: &Shared<RetainedUnissued>, 49 ) -> crate::Result<AcceptanceUnissuedOutcome> { 50 let _serial = self.serial.lock().await; 51 self.append_unissued(entry, false).await 52 } 53 pub(super) async fn append_unissued( 54 &self, 55 entry: &Shared<RetainedUnissued>, 56 reconciling: bool, 57 ) -> crate::Result<AcceptanceUnissuedOutcome> { 58 let error = |reason| { 59 Error::capture_pending( 60 reason, 61 OperationContext::retained(entry.selection.operation), 62 ) 63 }; 64 let committed = *entry 65 .receipt 66 .lock() 67 .unwrap_or_else(std::sync::PoisonError::into_inner); 68 if let Some(receipt) = committed { 69 return Ok(AcceptanceUnissuedOutcome::Committed(Box::new(receipt))); 70 } 71 // A malformed report must never cause material to leave this owner. 72 if entry.observation.claim() != entry.claim { 73 return Err(error(OperationError::RecoveryRequired)); 74 } 75 let outcome = if reconciling { 76 entry.observation.reconcile().await 77 } else { 78 entry.observation.capture().await 79 } 80 .map_err(error)?; 81 let attempt = match &outcome { 82 AcceptanceUnissuedOutcome::Committed(value) => value.attempt, 83 AcceptanceUnissuedOutcome::Unknown(value) => *value, 84 }; 85 if attempt.workspace_id() != entry.selection.binding.input().workspace_id() 86 || attempt.operation_id() != entry.selection.operation 87 || attempt.command_digest() != entry.selection.digest 88 { 89 return Err(error(OperationError::RecoveryRequired)); 90 } 91 if let AcceptanceUnissuedOutcome::Committed(value) = &outcome { 92 if attempt.transaction_id().is_none() 93 || value.claim != entry.claim.id 94 || value.recipient != entry.recipient 95 || value.reason != entry.observation.reason() 96 || value.checkpoint.authority() != entry.selection.minimum.authority() 97 { 98 return Err(error(OperationError::RecoveryRequired)); 99 } 100 *entry 101 .receipt 102 .lock() 103 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(**value); 104 let removed = { 105 let mut pending = self 106 .unissued 107 .lock() 108 .unwrap_or_else(std::sync::PoisonError::into_inner); 109 pending 110 .iter() 111 .position(|v| Shared::ptr_eq(v, entry)) 112 .map(|i| pending.remove(i)) 113 }; 114 drop(removed); 115 } 116 Ok(outcome) 117 } 118 }