lib

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

commerce_envelopes.rs (11334B)


      1 use radroots_identity::PublicKey;
      2 use radroots_nostr::{
      3     commerce::{self, RecordOpening, RejectedReason, UnsupportedReason},
      4     key::SecretKey,
      5     private_ingress::OpeningError,
      6     signing::LocalSigner,
      7 };
      8 use radroots_protocol::{commerce::EncodedCommerceRumor, private_rumor::DecodedRumor};
      9 use radroots_signing::{
     10     SignReceipt, SignRequest, Signer, SignerStatus,
     11     provider::{
     12         ParticipantProvider, PrivateCiphertext, PrivateCryptoCapability, PrivateText, ProviderCall,
     13         ProviderError, ProviderState,
     14     },
     15     request::CancellationSignal,
     16     signer::BoxFuture,
     17 };
     18 use serde::Deserialize;
     19 use std::{
     20     num::NonZeroU64,
     21     sync::atomic::{AtomicUsize, Ordering},
     22 };
     23 
     24 #[derive(Deserialize)]
     25 struct Corpus {
     26     positives: Vec<Vector>,
     27     negatives: Vec<Vector>,
     28 }
     29 #[derive(Deserialize)]
     30 struct Vector {
     31     name: String,
     32     recipient_scalar: u64,
     33     recipient: String,
     34     rumor_id: String,
     35     raw_rumor: String,
     36     raw_seal: String,
     37     raw_wrap: String,
     38     record_id: Option<String>,
     39     expected: Expected,
     40 }
     41 #[derive(Deserialize)]
     42 struct Expected {
     43     outcome: String,
     44     reason: Option<String>,
     45 }
     46 fn corpus() -> Corpus {
     47     serde_json::from_str(include_str!("fixtures/commerce_envelopes.v1.json")).unwrap()
     48 }
     49 fn signer(scalar: u64) -> LocalSigner {
     50     LocalSigner::with_clock(SecretKey::parse(&format!("{scalar:064x}")).unwrap(), || {
     51         Ok(1000)
     52     })
     53     .unwrap()
     54 }
     55 fn call(key: PublicKey) -> ProviderCall {
     56     ProviderCall::new(
     57         key,
     58         NonZeroU64::new(2000).unwrap(),
     59         CancellationSignal::new(),
     60     )
     61 }
     62 
     63 fn reason(value: RejectedReason) -> &'static str {
     64     match value {
     65         RejectedReason::InvalidProfile => "invalid_profile",
     66         RejectedReason::LimitExceeded => "limit_exceeded",
     67         RejectedReason::RecordIdentityMismatch => "record_identity_mismatch",
     68         RejectedReason::CarrierMismatch => "carrier_mismatch",
     69         RejectedReason::RecipientMismatch => "recipient_mismatch",
     70     }
     71 }
     72 
     73 #[tokio::test]
     74 async fn independent_nested_vectors_open_all_families_peer_self_and_exact_budgets() {
     75     let rows = corpus().positives;
     76     assert_eq!(rows.len(), 80);
     77     for row in &rows {
     78         let provider = signer(row.recipient_scalar);
     79         assert_eq!(provider.public_key().to_hex(), row.recipient);
     80         let result = commerce::open(&provider, call(provider.public_key()), &row.raw_wrap)
     81             .await
     82             .unwrap_or_else(|e| panic!("{}: {e}", row.name));
     83         let RecordOpening::Known(value) = result else {
     84             panic!("{}: {result:?}", row.name)
     85         };
     86         assert_eq!(
     87             value.record().record_id().to_string(),
     88             *row.record_id.as_ref().unwrap(),
     89             "{}",
     90             row.name
     91         );
     92         let carrier = value.carrier();
     93         let outer: serde_json::Value = serde_json::from_str(&row.raw_wrap).unwrap();
     94         let seal: serde_json::Value = serde_json::from_str(&row.raw_seal).unwrap();
     95         assert_eq!(
     96             carrier.envelope_id().to_string(),
     97             outer["id"].as_str().unwrap()
     98         );
     99         assert_eq!(carrier.seal_id().to_string(), seal["id"].as_str().unwrap());
    100         assert_eq!(carrier.rumor().event_id().to_string(), row.rumor_id);
    101         assert_eq!(carrier.protected_outer(), row.raw_wrap);
    102         assert_eq!(carrier.protected_seal(), row.raw_seal);
    103         assert_eq!(carrier.protected_rumor(), row.raw_rumor);
    104         assert_eq!(carrier.recipient(), provider.public_key());
    105         assert!(!carrier.rumor().has_tags());
    106         let encoded = EncodedCommerceRumor::capture(value.record().content()).unwrap();
    107         assert_eq!(encoded.record_id(), value.record().record_id());
    108         assert_eq!(encoded.event_id(), carrier.rumor().event_id());
    109         let decoded = DecodedRumor::decode(encoded.protected_wire().as_bytes()).unwrap();
    110         assert_eq!(
    111             decoded.protected_content(),
    112             carrier.rumor().protected_content()
    113         );
    114         assert_eq!(decoded.author(), carrier.rumor().author());
    115         assert_eq!(decoded.created_at(), carrier.rumor().created_at());
    116         assert!(!format!("{value:?}").contains("private"));
    117     }
    118     for pair in rows[..78].as_chunks::<2>().0 {
    119         assert_eq!(pair[0].rumor_id, pair[1].rumor_id);
    120         assert_eq!(pair[0].record_id, pair[1].record_id);
    121         assert_ne!(pair[0].raw_seal, pair[1].raw_seal);
    122         assert_ne!(pair[0].raw_wrap, pair[1].raw_wrap);
    123         assert_ne!(pair[0].recipient, pair[1].recipient);
    124     }
    125     assert_eq!(rows[78].raw_rumor.len(), 24_576);
    126     assert_eq!(rows[79].raw_wrap.len(), 65_536);
    127 }
    128 
    129 #[tokio::test]
    130 async fn independent_nested_failures_and_unsupported_evidence_have_exact_dispositions() {
    131     let rows = corpus().negatives;
    132     assert_eq!(rows.len(), 36);
    133     for row in rows {
    134         let provider = signer(row.recipient_scalar);
    135         let result = commerce::open(&provider, call(provider.public_key()), &row.raw_wrap).await;
    136         let (outcome, actual_reason) = match result {
    137             Err(error) => ("error", error.to_string()),
    138             Ok(RecordOpening::Unsupported(value)) => {
    139                 assert_eq!(value.carrier().protected_rumor(), row.raw_rumor);
    140                 assert_eq!(value.carrier().protected_seal(), row.raw_seal);
    141                 assert_eq!(value.carrier().protected_outer(), row.raw_wrap);
    142                 (
    143                     "unsupported",
    144                     match value.reason() {
    145                         UnsupportedReason::CarrierKind => "carrier_kind",
    146                         UnsupportedReason::Profile => "profile",
    147                     }
    148                     .into(),
    149                 )
    150             }
    151             Ok(RecordOpening::Rejected(value)) => {
    152                 assert_eq!(value.carrier().protected_rumor(), row.raw_rumor);
    153                 ("rejected", reason(value.reason()).into())
    154             }
    155             Ok(value) => panic!("{} unexpectedly admitted: {value:?}", row.name),
    156         };
    157         assert_eq!(
    158             (outcome, actual_reason.as_str()),
    159             (
    160                 row.expected.outcome.as_str(),
    161                 row.expected.reason.as_deref().unwrap()
    162             ),
    163             "{}",
    164             row.name
    165         );
    166     }
    167 }
    168 
    169 struct ObservedProvider {
    170     inner: LocalSigner,
    171     observations: AtomicUsize,
    172     decryptions: AtomicUsize,
    173     change_at: usize,
    174     available: bool,
    175 }
    176 impl ObservedProvider {
    177     fn new() -> Self {
    178         Self {
    179             inner: signer(2),
    180             observations: AtomicUsize::new(0),
    181             decryptions: AtomicUsize::new(0),
    182             change_at: usize::MAX,
    183             available: true,
    184         }
    185     }
    186 }
    187 impl Signer for ObservedProvider {
    188     fn status(&self) -> BoxFuture<'_, Result<SignerStatus, radroots_signing::Error>> {
    189         self.inner.status()
    190     }
    191     fn sign(&self, _: SignRequest) -> BoxFuture<'_, Result<SignReceipt, radroots_signing::Error>> {
    192         panic!("opening must never sign")
    193     }
    194 }
    195 impl ParticipantProvider for ObservedProvider {
    196     fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> {
    197         Box::pin(async {
    198             let observed = self.observations.fetch_add(1, Ordering::SeqCst);
    199             let identity = if observed >= self.change_at {
    200                 signer(3).public_key()
    201             } else {
    202                 self.inner.public_key()
    203             };
    204             let support = if self.available {
    205                 PrivateCryptoCapability::Nip44V2
    206             } else {
    207                 PrivateCryptoCapability::Unavailable
    208             };
    209             Ok(ProviderState::new(
    210                 identity,
    211                 PrivateCryptoCapability::Unavailable,
    212                 support,
    213                 radroots_signing::recovery::ReplayCapability::NonReplayable,
    214             ))
    215         })
    216     }
    217     fn encrypt_private(
    218         &self,
    219         _: ProviderCall,
    220         _: PublicKey,
    221         _: PrivateText,
    222     ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> {
    223         panic!("opening must never encrypt")
    224     }
    225     fn decrypt_private(
    226         &self,
    227         call: ProviderCall,
    228         sender: PublicKey,
    229         value: PrivateCiphertext,
    230     ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> {
    231         self.decryptions.fetch_add(1, Ordering::SeqCst);
    232         self.inner.decrypt_private(call, sender, value)
    233     }
    234 }
    235 
    236 #[tokio::test]
    237 async fn original_outer_and_recipient_are_admitted_before_any_provider_callback() {
    238     let rows = corpus().negatives;
    239     for name in [
    240         "outer_id",
    241         "outer_signature",
    242         "outer_recipient",
    243         "outer_duplicate_recipient",
    244         "outer_kind",
    245         "outer_unknown_field",
    246         "outer_encryption_version",
    247         "outer_limit_plus_one",
    248     ] {
    249         let row = rows.iter().find(|r| r.name == name).unwrap();
    250         let provider = ObservedProvider::new();
    251         assert!(
    252             commerce::open(&provider, call(provider.inner.public_key()), &row.raw_wrap)
    253                 .await
    254                 .is_err(),
    255             "{name}"
    256         );
    257         assert_eq!(provider.observations.load(Ordering::SeqCst), 0, "{name}");
    258         assert_eq!(provider.decryptions.load(Ordering::SeqCst), 0, "{name}");
    259     }
    260     for name in ["seal_id", "seal_signature", "seal_kind", "seal_tags"] {
    261         let row = rows.iter().find(|r| r.name == name).unwrap();
    262         let provider = ObservedProvider::new();
    263         assert!(
    264             commerce::open(&provider, call(provider.inner.public_key()), &row.raw_wrap)
    265                 .await
    266                 .is_err()
    267         );
    268         assert_eq!(provider.decryptions.load(Ordering::SeqCst), 1, "{name}");
    269     }
    270 }
    271 
    272 #[tokio::test]
    273 async fn identity_support_deadline_and_cancellation_remain_provider_bound() {
    274     let row = corpus().positives.remove(0);
    275     for (change_at, expected_decryptions) in [(0, 0), (1, 1), (2, 2)] {
    276         let mut provider = ObservedProvider::new();
    277         provider.change_at = change_at;
    278         assert_eq!(
    279             commerce::open(&provider, call(provider.inner.public_key()), &row.raw_wrap)
    280                 .await
    281                 .unwrap_err(),
    282             OpeningError::Provider(ProviderError::IdentityChanged)
    283         );
    284         assert_eq!(
    285             provider.decryptions.load(Ordering::SeqCst),
    286             expected_decryptions
    287         );
    288     }
    289     let mut provider = ObservedProvider::new();
    290     provider.available = false;
    291     assert_eq!(
    292         commerce::open(&provider, call(provider.inner.public_key()), &row.raw_wrap)
    293             .await
    294             .unwrap_err(),
    295         OpeningError::Provider(ProviderError::CapabilityUnavailable)
    296     );
    297     assert_eq!(provider.decryptions.load(Ordering::SeqCst), 0);
    298     let provider = signer(2);
    299     let cancelled = CancellationSignal::new();
    300     cancelled.cancel();
    301     for (deadline, signal, expected) in [
    302         (2000, cancelled, ProviderError::Cancelled),
    303         (
    304             1000,
    305             CancellationSignal::new(),
    306             ProviderError::DeadlineExceeded,
    307         ),
    308     ] {
    309         let call = ProviderCall::new(
    310             provider.public_key(),
    311             NonZeroU64::new(deadline).unwrap(),
    312             signal,
    313         );
    314         assert_eq!(
    315             commerce::open(&provider, call, &row.raw_wrap)
    316                 .await
    317                 .unwrap_err(),
    318             OpeningError::Provider(expected)
    319         );
    320     }
    321 }