native_commerce.rs (12126B)
1 //! Mechanical views of the same selected native stock owner for Core workflows. 2 use radroots_domain::PublicKey; 3 use radroots_execution::session::{ 4 HostFuture, 5 commerce::{ 6 AcceptanceClaim, AcceptanceClaimOutcome, AcceptanceDispatch, AcceptanceDispatchOutcome, 7 AcceptanceInstallationOutcome, AcceptancePlanOutcome, AcceptanceRecipient, 8 AcceptanceSelection, AcceptanceSnapshot, AcceptanceStore, AcceptanceUnissued, 9 AcceptanceUnissuedOutcome, AcceptanceUnissuedReceipt, InstalledAcceptance, 10 }, 11 }; 12 use radroots_signing::{ 13 host::Shared, 14 issuance::{ExactIssuer, ExactRecoveryRequest}, 15 provider::ProviderCall, 16 request::CancellationSignal, 17 }; 18 use radroots_storage::{ 19 command::OperationError, 20 inventory::{InventoryCheckpointRef, StockAcceptanceReceipt}, 21 workspace::AttachmentProof, 22 }; 23 use radroots_storage_sqlite::workspace::{ 24 NativeWorkspace, StockClaimOutcome, StockClaimRequest, StockDispatchOutcome, 25 StockDispatchPermit, StockInstallationOutcome, StockInstallationReceipt, 26 StockInstallationRequest, StockOperationSnapshot, StockSigningAttempt, StockSigningPlanOutcome, 27 StockSigningPlanRequest, StockSnapshotRequest, StockUnissuedInvocation, StockUnissuedOutcome, 28 StockUnissuedReceipt, 29 }; 30 31 pub(crate) struct NativeCommerce(pub(crate) Shared<NativeWorkspace>); 32 struct Snapshot(StockOperationSnapshot); 33 struct Dispatch { 34 permit: StockDispatchPermit, 35 store: Shared<NativeWorkspace>, 36 binding: radroots_storage::workspace::WorkspaceBinding, 37 proof: AttachmentProof, 38 } 39 struct Unissued { 40 observation: StockUnissuedInvocation, 41 store: Shared<NativeWorkspace>, 42 binding: radroots_storage::workspace::WorkspaceBinding, 43 proof: AttachmentProof, 44 } 45 fn refusal(value: &StockUnissuedReceipt) -> AcceptanceUnissuedReceipt { 46 AcceptanceUnissuedReceipt { 47 attempt: value.attempt(), 48 claim: value.signing_attempt_id(), 49 recipient: value.recipient(), 50 reason: value.reason(), 51 checkpoint: value.checkpoint(), 52 } 53 } 54 fn refusal_outcome(value: StockUnissuedOutcome) -> AcceptanceUnissuedOutcome { 55 match value { 56 StockUnissuedOutcome::Committed(value) => { 57 AcceptanceUnissuedOutcome::Committed(Box::new(refusal(&value))) 58 } 59 StockUnissuedOutcome::Unknown(value) => AcceptanceUnissuedOutcome::Unknown(value), 60 } 61 } 62 impl AcceptanceUnissued for Unissued { 63 fn claim(&self) -> AcceptanceClaim { 64 claim(self.observation.attempt()) 65 } 66 fn reason(&self) -> radroots_signing::provider::ProviderError { 67 self.observation.reason() 68 } 69 fn capture(&self) -> HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> { 70 Box::pin(async move { 71 self.store 72 .capture_stock_original_unissued( 73 self.binding.clone(), 74 &self.observation, 75 &self.proof, 76 ) 77 .await 78 .map(refusal_outcome) 79 }) 80 } 81 fn reconcile(&self) -> HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> { 82 Box::pin(async move { 83 self.store 84 .reconcile_stock_original_unissued( 85 self.binding.clone(), 86 &self.observation, 87 &self.proof, 88 ) 89 .await 90 .map(refusal_outcome) 91 }) 92 } 93 } 94 fn claim(value: &StockSigningAttempt) -> AcceptanceClaim { 95 AcceptanceClaim { 96 id: value.attempt_id(), 97 binding: value.binding(), 98 } 99 } 100 fn installation(value: &StockInstallationReceipt) -> InstalledAcceptance { 101 InstalledAcceptance { 102 attempt: value.attempt(), 103 order: value.order_id(), 104 record: value.record_id(), 105 checkpoint: value.checkpoint(), 106 } 107 } 108 impl AcceptanceSnapshot for Snapshot { 109 fn preparation(&self) -> &StockAcceptanceReceipt { 110 self.0.preparation() 111 } 112 fn plan(&self) -> Option<&radroots_protocol::commerce::CommerceSigningPlan> { 113 self.0.signing_plan().map(|v| v.plan()) 114 } 115 fn checkpoint(&self) -> InventoryCheckpointRef { 116 self.0.checkpoint() 117 } 118 fn recipients(&self) -> [AcceptanceRecipient; 2] { 119 self.0.recipients().each_ref().map(|v| AcceptanceRecipient { 120 recipient: v.recipient(), 121 claim: v.claim().map(|c| AcceptanceClaim { 122 id: c.attempt_id(), 123 binding: c.binding(), 124 }), 125 evidence: v.first_evidence(), 126 original_unissued: v.original_unissued().as_ref().map(refusal), 127 }) 128 } 129 fn installation(&self) -> Option<InstalledAcceptance> { 130 self.0.installation().map(installation) 131 } 132 fn aborted(&self) -> bool { 133 self.0.aborted().is_some() 134 } 135 fn delivery(&self) -> Option<&[radroots_storage::inventory::StockDeliverySummary; 2]> { 136 self.0.delivery() 137 } 138 } 139 impl AcceptanceDispatch for Dispatch { 140 fn claim(&self) -> AcceptanceClaim { 141 claim(self.permit.report()) 142 } 143 fn dispatch<'a>( 144 self: Box<Self>, 145 issuer: &'a dyn ExactIssuer, 146 cancel: CancellationSignal, 147 ) -> HostFuture<'a, Result<AcceptanceDispatchOutcome, OperationError>> { 148 Box::pin(async move { 149 let Self { 150 permit, 151 store, 152 binding, 153 proof, 154 } = *self; 155 Ok(match permit.dispatch(issuer, cancel).await? { 156 StockDispatchOutcome::Obtained { attempt, artifact } => { 157 AcceptanceDispatchOutcome::Obtained(claim(&attempt), artifact) 158 } 159 StockDispatchOutcome::Unissued(observation) => { 160 AcceptanceDispatchOutcome::Unissued(Box::new(Unissued { 161 observation, 162 store, 163 binding, 164 proof, 165 })) 166 } 167 StockDispatchOutcome::Unknown { attempt, reason } => { 168 AcceptanceDispatchOutcome::Unknown(claim(&attempt), reason) 169 } 170 StockDispatchOutcome::Rejected { attempt, rejection } => { 171 AcceptanceDispatchOutcome::Rejected(claim(&attempt), rejection) 172 } 173 }) 174 }) 175 } 176 } 177 fn select(value: AcceptanceSelection, recipient: PublicKey) -> StockClaimRequest { 178 StockClaimRequest::new( 179 value.binding, 180 value.minimum, 181 value.operation, 182 value.digest, 183 recipient, 184 ) 185 } 186 impl AcceptanceStore for NativeCommerce { 187 fn signing_evidence<'a>( 188 &'a self, 189 selection: AcceptanceSelection, 190 receipt: radroots_storage::inventory::StockEvidenceReceipt, 191 proof: &'a AttachmentProof, 192 ) -> HostFuture< 193 'a, 194 Result<Option<radroots_storage::inventory::StockEvidenceSource>, OperationError>, 195 > { 196 Box::pin(async move { 197 let source = self 198 .0 199 .stock_signing_evidence( 200 select(selection, receipt.recipient()), 201 *receipt.digest(), 202 proof, 203 ) 204 .await?; 205 source 206 .map(|source| { 207 if source.receipt() != receipt { 208 return Err(OperationError::RecoveryRequired); 209 } 210 source.with_json(|raw| { 211 radroots_storage::inventory::StockEvidenceSource::from_retained_wire( 212 receipt, raw, 213 ) 214 }) 215 }) 216 .transpose() 217 }) 218 } 219 fn snapshot<'a>( 220 &'a self, 221 value: AcceptanceSelection, 222 proof: &'a AttachmentProof, 223 ) -> HostFuture<'a, Result<Box<dyn AcceptanceSnapshot>, OperationError>> { 224 Box::pin(async move { 225 let value = self 226 .0 227 .stock_operation_snapshot( 228 StockSnapshotRequest::new( 229 value.binding, 230 value.minimum, 231 value.operation, 232 value.digest, 233 ), 234 proof, 235 ) 236 .await?; 237 Ok(Box::new(Snapshot(value)) as Box<dyn AcceptanceSnapshot>) 238 }) 239 } 240 fn bind<'a>( 241 &'a self, 242 value: AcceptanceSelection, 243 plan: radroots_signing::commerce::VerifiedCommerceSigningPlan, 244 proof: &'a AttachmentProof, 245 ) -> HostFuture<'a, Result<AcceptancePlanOutcome, OperationError>> { 246 Box::pin(async move { 247 match self 248 .0 249 .bind_stock_signing_intents( 250 StockSigningPlanRequest::new(value.binding, value.minimum, plan)?, 251 proof, 252 ) 253 .await? 254 { 255 StockSigningPlanOutcome::Bound(value) => { 256 Ok(AcceptancePlanOutcome::Bound(value.attempt())) 257 } 258 StockSigningPlanOutcome::Unknown(value) => { 259 Ok(AcceptancePlanOutcome::Unknown(value)) 260 } 261 } 262 }) 263 } 264 fn claim<'a>( 265 &'a self, 266 value: AcceptanceSelection, 267 recipient: PublicKey, 268 proof: &'a AttachmentProof, 269 ) -> HostFuture<'a, Result<AcceptanceClaimOutcome, OperationError>> { 270 Box::pin(async move { 271 // Retain capture material before admission and before the issuer runs. 272 let binding = value.binding.clone(); 273 let retained_proof = 274 proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?; 275 match self 276 .0 277 .claim_stock_signing_attempt(select(value, recipient), proof) 278 .await? 279 { 280 StockClaimOutcome::Fresh(value) => { 281 Ok(AcceptanceClaimOutcome::Fresh(Box::new(Dispatch { 282 permit: value, 283 store: self.0.clone(), 284 binding, 285 proof: retained_proof, 286 }))) 287 } 288 StockClaimOutcome::Existing(value) => { 289 Ok(AcceptanceClaimOutcome::Existing(claim(&value))) 290 } 291 StockClaimOutcome::Unknown(value) => Ok(AcceptanceClaimOutcome::Unknown(value)), 292 } 293 }) 294 } 295 fn exact_replay<'a>( 296 &'a self, 297 value: AcceptanceSelection, 298 recipient: PublicKey, 299 call: ProviderCall, 300 proof: &'a AttachmentProof, 301 ) -> HostFuture<'a, Result<(ExactRecoveryRequest, AcceptanceClaim), OperationError>> { 302 Box::pin(async move { 303 let permit = self 304 .0 305 .authorize_stock_exact_replay(select(value, recipient), proof) 306 .await?; 307 let (request, report) = permit.into_recovery_request(call)?; 308 Ok((request, claim(&report))) 309 }) 310 } 311 fn install<'a>( 312 &'a self, 313 value: AcceptanceSelection, 314 proof: &'a AttachmentProof, 315 ) -> HostFuture<'a, Result<AcceptanceInstallationOutcome, OperationError>> { 316 Box::pin(async move { 317 match self 318 .0 319 .install_stock_agreement( 320 StockInstallationRequest::new( 321 value.binding, 322 value.minimum, 323 value.operation, 324 value.digest, 325 ), 326 proof, 327 ) 328 .await? 329 { 330 StockInstallationOutcome::Installed(value) => Ok( 331 AcceptanceInstallationOutcome::Installed(Box::new(installation(&value))), 332 ), 333 StockInstallationOutcome::Unknown(value) => { 334 Ok(AcceptanceInstallationOutcome::Unknown(value)) 335 } 336 } 337 }) 338 } 339 }