lib

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

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 }