lib

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

commerce_run.rs (24020B)


      1 //! One shared T1/S/T2/D algorithm; target hosts implement transactions only.
      2 use super::*;
      3 use crate::{
      4     Error, OperationContext,
      5     session::{
      6         Shared, SignerSession,
      7         command::{CommandRuntime, RunMode, SigningResources},
      8     },
      9 };
     10 use alloc::vec::Vec;
     11 use core::num::NonZeroU64;
     12 use radroots_domain::UnixSeconds;
     13 use radroots_protocol::{
     14     commerce::{CommerceSeal, EncodedCommerceRumor},
     15     intent::SigningReplay,
     16 };
     17 use radroots_signing::{
     18     issuance::{ExactRecoveryCapability, ExactRecoveryKind, SignedArtifact, SigningIntent},
     19     provider::PrivateText,
     20     recovery::ReplayCapability,
     21 };
     22 use radroots_storage::inventory::{InventoryStore, StockEvidenceOutcome};
     23 #[path = "commerce_delivery.rs"]
     24 mod delivery;
     25 #[path = "commerce_rewrap.rs"]
     26 mod rewrap;
     27 pub(in crate::session) use rewrap::status as rewrap_status;
     28 
     29 fn same(attempt: CommitAttempt, selection: &AcceptanceSelection) -> bool {
     30     attempt.workspace_id() == selection.binding.input().workspace_id()
     31         && attempt.operation_id() == selection.operation
     32         && attempt.command_digest() == selection.digest
     33 }
     34 pub(crate) fn observe(
     35     selection: &AcceptanceSelection,
     36     snapshot: &dyn AcceptanceSnapshot,
     37 ) -> Result<AcceptanceStatus, OperationError> {
     38     let original = snapshot.preparation();
     39     let recipients = snapshot.recipients();
     40     if !same(original.attempt(), selection)
     41         || original.attempt().transaction_id().is_none()
     42         || recipients
     43             .iter()
     44             .map(|v| v.recipient)
     45             .ne(original.rumor().recipients().iter().copied())
     46     {
     47         return Err(OperationError::RecoveryRequired);
     48     }
     49     if let Some(plan) = snapshot.plan() {
     50         CommerceSigningPlan::parse(
     51             selection.operation,
     52             selection.digest,
     53             original.rumor(),
     54             plan.protected_wire(),
     55         )
     56         .map_err(|_| OperationError::RecoveryRequired)?;
     57     } else if recipients
     58         .iter()
     59         .any(|v| v.claim.is_some() || v.evidence.is_some() || v.original_unissued.is_some())
     60     {
     61         return Err(OperationError::RecoveryRequired);
     62     }
     63     for recipient in &recipients {
     64         if let Some(claim) = recipient.claim {
     65             let plan = snapshot.plan().ok_or(OperationError::RecoveryRequired)?;
     66             let seal = plan
     67                 .seals()
     68                 .iter()
     69                 .find(|v| v.recipient() == recipient.recipient)
     70                 .ok_or(OperationError::RecoveryRequired)?;
     71             if claim.binding
     72                 != SigningIntent::from_commerce_seal(seal, call(original)?)
     73                     .map_err(|_| OperationError::RecoveryRequired)?
     74                     .binding()
     75             {
     76                 return Err(OperationError::RecoveryRequired);
     77             }
     78         }
     79         if let Some(evidence) = recipient.evidence
     80             && (!same(evidence.attempt(), selection)
     81                 || evidence.attempt().transaction_id().is_none()
     82                 || evidence.recipient() != recipient.recipient
     83                 || recipient
     84                     .claim
     85                     .is_none_or(|v| v.id != evidence.signing_attempt_id()))
     86         {
     87             return Err(OperationError::RecoveryRequired);
     88         }
     89     }
     90     for recipient in &recipients {
     91         if let Some(value) = recipient.original_unissued
     92             && (!same(value.attempt, selection)
     93                 || value.attempt.transaction_id().is_none()
     94                 || value.recipient != recipient.recipient
     95                 || recipient.claim.is_none_or(|v| v.id != value.claim)
     96                 || value.checkpoint.authority() != selection.minimum.authority())
     97         {
     98             return Err(OperationError::RecoveryRequired);
     99         }
    100     }
    101     let installation = snapshot.installation();
    102     if snapshot.aborted()
    103         && recipients
    104             .iter()
    105             .any(|v| v.evidence.is_some() || (v.claim.is_some() && v.original_unissued.is_none()))
    106     {
    107         return Err(OperationError::RecoveryRequired);
    108     }
    109     if let Some(installed) = installation {
    110         let peer = recipients
    111             .iter()
    112             .find(|v| v.recipient != original.rumor().author())
    113             .ok_or(OperationError::RecoveryRequired)?;
    114         if !same(installed.attempt, selection)
    115             || installed.attempt.transaction_id().is_none()
    116             || installed.order != original.order_id()
    117             || installed.record != original.rumor().record_id()
    118             || peer.evidence.is_none()
    119             || snapshot.aborted()
    120         {
    121             return Err(OperationError::RecoveryRequired);
    122         }
    123     }
    124     Ok(AcceptanceStatus {
    125         delivery: match snapshot.delivery() {
    126             Some(values) => {
    127                 for (value, recipient) in values.iter().zip(&recipients) {
    128                     if value.checkpoint() != snapshot.checkpoint()
    129                         || value.source().is_some_and(|source| {
    130                             !same(source.attempt(), selection)
    131                                 || source.recipient() != recipient.recipient
    132                                 || recipient.evidence != Some(source.evidence())
    133                                 || installation.is_none_or(|installed| {
    134                                     Some(source.installation_transaction_id())
    135                                         != installed.attempt.transaction_id()
    136                                 })
    137                         })
    138                     {
    139                         return Err(OperationError::RecoveryRequired);
    140                     }
    141                 }
    142                 Some(alloc::boxed::Box::new(values.clone()))
    143             }
    144             None => None,
    145         },
    146         attempt: original.attempt(),
    147         record: original.rumor().record_id(),
    148         checkpoint: snapshot.checkpoint(),
    149         recipients,
    150         plan_bound: snapshot.plan().is_some(),
    151         installation,
    152         aborted: snapshot.aborted(),
    153     })
    154 }
    155 fn call(original: &StockAcceptanceReceipt) -> Result<ProviderCall, OperationError> {
    156     let deadline = original
    157         .first_issue_deadline()
    158         .get()
    159         .checked_mul(1000)
    160         .and_then(NonZeroU64::new)
    161         .ok_or(OperationError::RecoveryRequired)?;
    162     Ok(ProviderCall::new(
    163         original.rumor().author(),
    164         deadline,
    165         CancellationSignal::new(),
    166     ))
    167 }
    168 fn copy(proof: &AttachmentProof) -> Result<AttachmentProof, OperationError> {
    169     proof
    170         .with_secret(|bytes| AttachmentProof::from_protected_input(bytes))
    171         .map_err(Into::into)
    172 }
    173 impl CommandRuntime {
    174     pub(in crate::session) async fn run_acceptance(
    175         &self,
    176         store: Shared<dyn AcceptanceStore>,
    177         inventory: Shared<dyn InventoryStore>,
    178         mut selection: AcceptanceSelection,
    179         proof: &AttachmentProof,
    180         resources: SigningResources,
    181         mode: RunMode,
    182     ) -> crate::ExecutionResult<AcceptanceStatus> {
    183         let retained = OperationContext::retained(selection.operation);
    184         let fail = |e| crate::ExecutionFailure::from(Error::operation(e, retained));
    185         let mut snapshot = store
    186             .snapshot(selection.clone(), proof)
    187             .await
    188             .map_err(fail)?;
    189         let mut status = observe(&selection, snapshot.as_ref()).map_err(fail)?;
    190         if !snapshot.aborted()
    191             && snapshot.installation().is_none()
    192             && snapshot.recipients().iter().any(|v| {
    193                 v.recipient != snapshot.preparation().rumor().author() && v.evidence.is_some()
    194             })
    195         {
    196             selection.minimum = snapshot.checkpoint();
    197             match store
    198                 .install(selection.clone(), proof)
    199                 .await
    200                 .map_err(fail)?
    201             {
    202                 AcceptanceInstallationOutcome::Installed(value)
    203                     if same(value.attempt, &selection)
    204                         && value.attempt.transaction_id().is_some() => {}
    205                 _ => return Err(fail(OperationError::RecoveryRequired)),
    206             }
    207             snapshot = store
    208                 .snapshot(selection.clone(), proof)
    209                 .await
    210                 .map_err(fail)?;
    211             status = observe(&selection, snapshot.as_ref()).map_err(fail)?;
    212         }
    213         if snapshot.aborted() || !self.io.enabled() {
    214             return Ok(status);
    215         }
    216         self.drain().await?;
    217         resources.stock_captures.ensure_ready().map_err(fail)?;
    218         if snapshot.plan().is_none() {
    219             let Some(signer) = resources.signer.as_ref() else {
    220                 return Ok(status);
    221             };
    222             let plan = self
    223                 .acceptance_plan(snapshot.preparation(), signer)
    224                 .await
    225                 .map_err(fail)?;
    226             selection.minimum = snapshot.checkpoint();
    227             match store
    228                 .bind(selection.clone(), plan, proof)
    229                 .await
    230                 .map_err(fail)?
    231             {
    232                 AcceptancePlanOutcome::Bound(anchor)
    233                     if same(anchor, &selection) && anchor.transaction_id().is_some() => {}
    234                 _ => return Err(fail(OperationError::RecoveryRequired)),
    235             }
    236         }
    237         let author = snapshot.preparation().rumor().author();
    238         let peer = *snapshot
    239             .preparation()
    240             .rumor()
    241             .recipients()
    242             .iter()
    243             .find(|v| **v != author)
    244             .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    245         drop(snapshot);
    246         // A peer commitment is installed before self-history work can fail.
    247         for recipient in [peer, author] {
    248             let current = store
    249                 .snapshot(selection.clone(), proof)
    250                 .await
    251                 .map_err(fail)?;
    252             observe(&selection, current.as_ref()).map_err(fail)?;
    253             if current.aborted() {
    254                 return observe(&selection, current.as_ref()).map_err(fail);
    255             }
    256             selection.minimum = current.checkpoint();
    257             let facts = current
    258                 .recipients()
    259                 .into_iter()
    260                 .find(|v| v.recipient == recipient)
    261                 .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    262             if facts.evidence.is_none() {
    263                 let Some(signer) = resources.signer.as_ref() else {
    264                     continue;
    265                 };
    266                 resources.stock_captures.ensure_ready().map_err(fail)?;
    267                 let plan = current
    268                     .plan()
    269                     .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    270                 if facts.claim.is_some()
    271                     && (!matches!(&mode, RunMode::Resume)
    272                         || plan.replay() != SigningReplay::LocalReplaySafe)
    273                 {
    274                     continue;
    275                 }
    276                 if facts.claim.is_none()
    277                     && self.io.now().map_err(fail)? >= current.preparation().first_issue_deadline()
    278                 {
    279                     continue;
    280                 }
    281                 // Recheck every originally selected target and the actual scoped
    282                 // provider before acquiring any fresh first-dispatch claim.
    283                 for route in plan.routes() {
    284                     self.io.targets(route).map_err(fail)?;
    285                 }
    286                 let original = current.preparation();
    287                 let plan_copy = CommerceSigningPlan::parse(
    288                     selection.operation,
    289                     selection.digest,
    290                     original.rumor(),
    291                     plan.protected_wire(),
    292                 )
    293                 .map_err(|_| fail(OperationError::RecoveryRequired))?;
    294                 signer
    295                     .verify_commerce_plan(
    296                         call(original).map_err(fail)?,
    297                         original.rumor(),
    298                         plan_copy,
    299                     )
    300                     .await
    301                     .map_err(|_| fail(OperationError::Unauthorized))?;
    302                 let capture_proof = copy(proof).map_err(fail)?;
    303                 let capture_selection = selection.clone();
    304                 let obtained: Option<(SignedArtifact, AcceptanceClaim)> = if let Some(claim) =
    305                     facts.claim
    306                 {
    307                     if !matches!(&mode, RunMode::Resume)
    308                         || plan.replay() != SigningReplay::LocalReplaySafe
    309                     {
    310                         None
    311                     } else {
    312                         let (request, report) = store
    313                             .exact_replay(
    314                                 selection.clone(),
    315                                 recipient,
    316                                 call(original).map_err(fail)?,
    317                                 proof,
    318                             )
    319                             .await
    320                             .map_err(fail)?;
    321                         if report != claim || request.original().binding() != claim.binding {
    322                             return Err(fail(OperationError::RecoveryRequired));
    323                         }
    324                         self.ensure_ready()?;
    325                         match signer.recover_exact(request).await.into_parts().1 {
    326                             ExactRecoveryKind::Obtained(artifact) => Some((artifact, report)),
    327                             ExactRecoveryKind::Rejected(rejected) => {
    328                                 return Err(crate::ExecutionFailure::rejected(
    329                                     selection.operation,
    330                                     rejected,
    331                                 ));
    332                             }
    333                             _ => None,
    334                         }
    335                     }
    336                 } else {
    337                     if self.io.now().map_err(fail)? >= original.first_issue_deadline() {
    338                         continue;
    339                     }
    340                     match store
    341                         .claim(selection.clone(), recipient, proof)
    342                         .await
    343                         .map_err(fail)?
    344                     {
    345                         AcceptanceClaimOutcome::Fresh(permit) => {
    346                             let report = permit.claim();
    347                             let seal = plan
    348                                 .seals()
    349                                 .iter()
    350                                 .find(|v| v.recipient() == recipient)
    351                                 .ok_or_else(|| fail(OperationError::RecoveryRequired))?;
    352                             let expected = SigningIntent::from_commerce_seal(
    353                                 seal,
    354                                 call(original).map_err(fail)?,
    355                             )
    356                             .map_err(|_| fail(OperationError::RecoveryRequired))?
    357                             .binding();
    358                             if report.binding != expected {
    359                                 return Err(fail(OperationError::RecoveryRequired));
    360                             }
    361                             self.ensure_ready()?;
    362                             resources.stock_captures.ensure_ready().map_err(fail)?;
    363                             match permit
    364                                 .dispatch(signer, CancellationSignal::new())
    365                                 .await
    366                                 .map_err(fail)?
    367                             {
    368                                 AcceptanceDispatchOutcome::Obtained(actual, artifact) => {
    369                                     if actual != report {
    370                                         resources.stock_captures.retain_obtained(
    371                                             crate::session::stock_evidence::ObtainedContext {
    372                                                 selection: capture_selection,
    373                                                 claim: report,
    374                                                 recipient,
    375                                                 store: inventory.clone(),
    376                                                 proof: capture_proof,
    377                                                 lease: resources.lease.clone(),
    378                                             },
    379                                             artifact,
    380                                         );
    381                                         return Err(fail(OperationError::RecoveryRequired));
    382                                     }
    383                                     Some((artifact, report))
    384                                 }
    385                                 AcceptanceDispatchOutcome::Unissued(observation) => {
    386                                     let pending = resources.stock_captures.retain_unissued(
    387                                         capture_selection.clone(),
    388                                         report,
    389                                         recipient,
    390                                         observation,
    391                                         resources.lease.clone(),
    392                                     );
    393                                     if !matches!(
    394                                         resources.stock_captures.capture_unissued(&pending).await?,
    395                                         AcceptanceUnissuedOutcome::Committed(_)
    396                                     ) {
    397                                         return Err(fail(OperationError::RecoveryRequired));
    398                                     }
    399                                     None
    400                                 }
    401                                 AcceptanceDispatchOutcome::Rejected(actual, rejected)
    402                                     if actual == report =>
    403                                 {
    404                                     return Err(crate::ExecutionFailure::rejected(
    405                                         selection.operation,
    406                                         rejected,
    407                                     ));
    408                                 }
    409                                 AcceptanceDispatchOutcome::Unknown(actual, _)
    410                                     if actual == report =>
    411                                 {
    412                                     None
    413                                 }
    414                                 _ => return Err(fail(OperationError::RecoveryRequired)),
    415                             }
    416                         }
    417                         AcceptanceClaimOutcome::Existing(_) => None,
    418                         AcceptanceClaimOutcome::Unknown(_) => {
    419                             return Err(fail(OperationError::RecoveryRequired));
    420                         }
    421                     }
    422                 };
    423                 if let Some((artifact, claim)) = obtained {
    424                     let pending = resources.stock_captures.retain_obtained(
    425                         crate::session::stock_evidence::ObtainedContext {
    426                             selection: capture_selection,
    427                             claim,
    428                             recipient,
    429                             store: inventory.clone(),
    430                             proof: capture_proof,
    431                             lease: resources.lease.clone(),
    432                         },
    433                         artifact,
    434                     );
    435                     if !matches!(
    436                         resources
    437                             .stock_captures
    438                             .capture_obtained(&pending)
    439                             .await
    440                             .map_err(|e| e.with_context(retained))?,
    441                         StockEvidenceOutcome::Committed(_)
    442                     ) {
    443                         return Err(fail(OperationError::RecoveryRequired));
    444                     }
    445                 }
    446             }
    447             if recipient == peer {
    448                 let captured = store
    449                     .snapshot(selection.clone(), proof)
    450                     .await
    451                     .map_err(fail)?;
    452                 observe(&selection, captured.as_ref()).map_err(fail)?;
    453                 let peer_ready = captured
    454                     .recipients()
    455                     .iter()
    456                     .any(|v| v.recipient == peer && v.evidence.is_some());
    457                 if peer_ready && captured.installation().is_none() {
    458                     selection.minimum = captured.checkpoint();
    459                     match store
    460                         .install(selection.clone(), proof)
    461                         .await
    462                         .map_err(fail)?
    463                     {
    464                         AcceptanceInstallationOutcome::Installed(value)
    465                             if same(value.attempt, &selection)
    466                                 && value.attempt.transaction_id().is_some() => {}
    467                         _ => return Err(fail(OperationError::RecoveryRequired)),
    468                     }
    469                 }
    470             }
    471             self.deliver_acceptance(
    472                 &store, &inventory, &selection, proof, &resources, recipient, &mode,
    473             )
    474             .await?;
    475         }
    476         let final_view = store
    477             .snapshot(selection.clone(), proof)
    478             .await
    479             .map_err(fail)?;
    480         observe(&selection, final_view.as_ref()).map_err(fail)
    481     }
    482     async fn acceptance_plan(
    483         &self,
    484         original: &StockAcceptanceReceipt,
    485         signer: &SignerSession,
    486     ) -> Result<VerifiedCommerceSigningPlan, OperationError> {
    487         let rumor: &EncodedCommerceRumor = original.rumor();
    488         let now: UnixSeconds = self.io.now()?;
    489         if now < original.prepared_at() || now >= original.first_issue_deadline() {
    490             return Err(OperationError::DeadlineExceeded);
    491         }
    492         let state = signer
    493             .observe()
    494             .await
    495             .map_err(|_| OperationError::Unauthorized)?;
    496         if state.identity() != rumor.author() {
    497             return Err(OperationError::Unauthorized);
    498         }
    499         let replay = match state.exact_issuance() {
    500             Some(_) if state.exact_recovery() == ExactRecoveryCapability::LocalExactReplay => {
    501                 SigningReplay::LocalReplaySafe
    502             }
    503             Some(ReplayCapability::NonReplayable) => SigningReplay::NonReplayable,
    504             Some(ReplayCapability::ExactReplayByRequestId) => SigningReplay::ExactReplayByRequestId,
    505             _ => return Err(OperationError::UnsupportedOperation),
    506         };
    507         let mut routes = Vec::with_capacity(2);
    508         for recipient in rumor.recipients() {
    509             let route = self
    510                 .io
    511                 .route(*recipient, call(original)?.deadline_unix_ms())
    512                 .await?;
    513             self.io.targets(&route)?;
    514             routes.push(route);
    515         }
    516         let mut seals = Vec::with_capacity(2);
    517         for recipient in rumor.recipients() {
    518             let plaintext = PrivateText::new(rumor.protected_wire())
    519                 .map_err(|_| OperationError::InvalidCommand)?;
    520             let ciphertext = signer
    521                 .encrypt_private(call(original)?, *recipient, plaintext)
    522                 .await
    523                 .map_err(|_| OperationError::Unauthorized)?;
    524             seals.push(
    525                 CommerceSeal::new(
    526                     original.attempt().operation_id(),
    527                     original.attempt().command_digest(),
    528                     rumor,
    529                     *recipient,
    530                     self.io.seal_time(now)?,
    531                     ciphertext.as_str(),
    532                 )
    533                 .map_err(|_| OperationError::InvalidEvidence)?,
    534             );
    535         }
    536         let plan = CommerceSigningPlan::new(
    537             original.attempt().operation_id(),
    538             original.attempt().command_digest(),
    539             rumor,
    540             seals
    541                 .try_into()
    542                 .map_err(|_| OperationError::RecoveryRequired)?,
    543             routes
    544                 .try_into()
    545                 .map_err(|_| OperationError::RecoveryRequired)?,
    546             replay,
    547         )
    548         .map_err(|_| OperationError::InvalidEvidence)?;
    549         signer
    550             .verify_commerce_plan(call(original)?, rumor, plan)
    551             .await
    552             .map_err(|_| OperationError::InvalidEvidence)
    553     }
    554 }