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 }