lib

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

commerce.rs (3685B)


      1 //! Complete authenticated record admission. This supplies provenance, not a
      2 //! business transition, current authority, agreement, inventory or physical fact.
      3 use crate::private_ingress::{self, AuthenticatedCarrier, OpeningError};
      4 use alloc::boxed::Box;
      5 use radroots_protocol::commerce::{self, DecodedRecord, RecordWireError};
      6 use radroots_protocol::profile;
      7 use radroots_signing::provider::{ParticipantProvider, ProviderCall};
      8 
      9 /// Only a fully admitted known profile can construct this record.
     10 #[derive(Debug)]
     11 pub struct AuthenticatedRecord {
     12     carrier: AuthenticatedCarrier,
     13     record: Box<DecodedRecord>,
     14 }
     15 impl AuthenticatedRecord {
     16     pub const fn carrier(&self) -> &AuthenticatedCarrier {
     17         &self.carrier
     18     }
     19     pub fn record(&self) -> &DecodedRecord {
     20         &self.record
     21     }
     22 }
     23 
     24 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
     25 pub enum UnsupportedReason {
     26     CarrierKind,
     27     Profile,
     28 }
     29 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
     30 pub enum RejectedReason {
     31     InvalidProfile,
     32     LimitExceeded,
     33     RecordIdentityMismatch,
     34     CarrierMismatch,
     35     RecipientMismatch,
     36 }
     37 
     38 /// Authenticated but non-actionable evidence, retained for protected storage.
     39 #[derive(Debug)]
     40 pub struct NonActionable<R> {
     41     carrier: AuthenticatedCarrier,
     42     reason: R,
     43 }
     44 impl<R: Copy> NonActionable<R> {
     45     pub const fn carrier(&self) -> &AuthenticatedCarrier {
     46         &self.carrier
     47     }
     48     pub const fn reason(&self) -> R {
     49         self.reason
     50     }
     51 }
     52 #[derive(Debug)]
     53 pub enum RecordOpening {
     54     Known(AuthenticatedRecord),
     55     Unsupported(NonActionable<UnsupportedReason>),
     56     Rejected(NonActionable<RejectedReason>),
     57 }
     58 
     59 /// Interprets only already authenticated evidence. Future profiles retain
     60 /// original protected bytes and cannot become a known record through fallback.
     61 pub fn admit(carrier: AuthenticatedCarrier) -> RecordOpening {
     62     let unsupported =
     63         |carrier, reason| RecordOpening::Unsupported(NonActionable { carrier, reason });
     64     let rejected = |carrier, reason| RecordOpening::Rejected(NonActionable { carrier, reason });
     65     let rumor = carrier.rumor();
     66     if rumor.kind() != profile::COMMERCE_KIND {
     67         return unsupported(carrier, UnsupportedReason::CarrierKind);
     68     }
     69     let record = match commerce::decode(rumor.protected_content().as_bytes()) {
     70         Ok(value) => value,
     71         Err(RecordWireError::UnsupportedProfile) => {
     72             return unsupported(carrier, UnsupportedReason::Profile);
     73         }
     74         Err(error) => {
     75             let reason = match error {
     76                 RecordWireError::LimitExceeded => RejectedReason::LimitExceeded,
     77                 RecordWireError::IdentityMismatch => RejectedReason::RecordIdentityMismatch,
     78                 RecordWireError::CarrierMismatch => RejectedReason::CarrierMismatch,
     79                 _ => RejectedReason::InvalidProfile,
     80             };
     81             return rejected(carrier, reason);
     82         }
     83     };
     84     if rumor.has_tags()
     85         || record
     86             .check_rumor_fields(rumor.author(), rumor.created_at(), rumor.kind())
     87             .is_err()
     88     {
     89         return rejected(carrier, RejectedReason::CarrierMismatch);
     90     }
     91     let header = record.content().header();
     92     if carrier.recipient() != header.buyer() && carrier.recipient() != header.seller() {
     93         return rejected(carrier, RejectedReason::RecipientMismatch);
     94     }
     95     RecordOpening::Known(AuthenticatedRecord {
     96         carrier,
     97         record: Box::new(record),
     98     })
     99 }
    100 
    101 pub async fn open(
    102     provider: &dyn ParticipantProvider,
    103     call: ProviderCall,
    104     raw_outer: &str,
    105 ) -> Result<RecordOpening, OpeningError> {
    106     Ok(admit(
    107         private_ingress::open(provider, call, raw_outer).await?,
    108     ))
    109 }