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 }