terms_authorization.rs (14075B)
1 //! Independent complete replacement claims; no source authentication or store. 2 use super::*; 3 4 fn time(value: u64) -> UnixSeconds { 5 UnixSeconds::new(value).unwrap() 6 } 7 fn digest(value: u8) -> TermsDigest { 8 TermsDigest::from_bytes([value; 32]) 9 } 10 fn complete(different: bool) -> Terms { 11 terms( 12 vec![line(if different { 8 } else { 7 }, 9)], 13 vec![group(9)], 14 money("50"), 15 money("700"), 16 ) 17 .unwrap() 18 } 19 fn content( 20 author: PublicKey, 21 sequence: u64, 22 previous: Option<u64>, 23 extra: &[u64], 24 payload: CommercePayload, 25 ) -> CommerceContent { 26 let mut parents = vec![SourceId::from_bytes([3; 32])]; 27 parents.extend(previous.map(src)); 28 parents.extend(extra.iter().copied().map(src)); 29 parents.sort(); 30 parents.dedup(); 31 CommerceContent::new( 32 CommerceHeader::new( 33 thread(), 34 Some(order()), 35 author, 36 buyer(), 37 seller(), 38 time(100), 39 Sequence::new(sequence).unwrap(), 40 previous.map(id), 41 parents, 42 ) 43 .unwrap(), 44 payload, 45 ) 46 .unwrap() 47 } 48 fn proposal(base: Option<u64>, different: bool, expires: u64) -> CommercePayload { 49 CommercePayload::TermsProposed( 50 TermsProposal::new( 51 base.map(id), 52 complete(different), 53 time(expires), 54 "Private replacement", 55 ) 56 .unwrap(), 57 ) 58 } 59 fn authorization(proposal: u64, declared: u8, expires: u64) -> CommercePayload { 60 CommercePayload::TermsAuthorized(TermsAuthorization::new( 61 id(proposal), 62 digest(declared), 63 time(expires), 64 )) 65 } 66 fn fixture(buyer_proposes: bool) -> Vec<(u64, CommerceContent)> { 67 let base = content( 68 seller(), 69 1, 70 None, 71 &[9000], 72 CommercePayload::AgreementCommitted( 73 AgreementCommitment::new( 74 None, 75 id(9000), 76 digest(40), 77 AuthorityRef::new( 78 ExecutorId::from_bytes([20; 32]), 79 Generation::new(1).unwrap(), 80 ), 81 Sequence::new(1).unwrap(), 82 ) 83 .unwrap(), 84 ), 85 ); 86 let (proposed, authorized) = if buyer_proposes { 87 ( 88 content(buyer(), 1, None, &[1], proposal(Some(1), false, 200)), 89 content(seller(), 2, Some(1), &[2], authorization(2, 42, 190)), 90 ) 91 } else { 92 ( 93 content(seller(), 2, Some(1), &[], proposal(Some(1), false, 200)), 94 content(buyer(), 1, None, &[2], authorization(2, 42, 190)), 95 ) 96 }; 97 vec![(1, base), (2, proposed), (3, authorized)] 98 } 99 fn selection() -> ReplacementTermsSelection { 100 ReplacementTermsSelection::new(id(1), id(2), id(3), digest(42)) 101 } 102 fn claim_at( 103 values: &[(u64, CommerceContent)], 104 at: u64, 105 ) -> Result<ReplacementTermsClaim<'_>, ReplacementTermsError> { 106 prepare_replacement_terms( 107 scope(), 108 selection(), 109 &values 110 .iter() 111 .map(|(id_value, value)| CausalRecord::new(id(*id_value), value)) 112 .collect::<Vec<_>>(), 113 &[src(9000), SourceId::from_bytes([3; 32])], 114 &[], 115 time(at), 116 ) 117 } 118 119 #[test] 120 fn either_counterparty_can_propose_and_all_arrival_orders_preserve_exact_selected_claims() { 121 for buyer_proposes in [false, true] { 122 let values = fixture(buyer_proposes); 123 for order in [ 124 [0, 1, 2], 125 [0, 2, 1], 126 [1, 0, 2], 127 [1, 2, 0], 128 [2, 0, 1], 129 [2, 1, 0], 130 ] { 131 let shuffled = order.map(|index| values[index].clone()); 132 let selected = claim_at(&shuffled, 150).unwrap(); 133 assert_eq!(selected.selection(), selection()); 134 assert_eq!(selected.base_commitment().seller_sequence().get(), 1); 135 assert_eq!(selected.terms(), &complete(false)); 136 assert_eq!(selected.expires_at(), time(190)); 137 assert_eq!( 138 format!("{selected:?}"), 139 "ReplacementTermsClaim(<private data>)" 140 ); 141 } 142 let duplicated = [values.as_slice(), values.as_slice()].concat(); 143 assert!(claim_at(&duplicated, 150).is_ok()); 144 } 145 assert_eq!( 146 format!("{:?}", selection()), 147 "ReplacementTermsSelection(<private identities>)" 148 ); 149 } 150 151 #[test] 152 fn same_author_cannot_self_authorize_replacement_even_with_a_contiguous_author_chain() { 153 for buyer_proposes in [false, true] { 154 let mut values = fixture(buyer_proposes); 155 values[2].1 = if buyer_proposes { 156 content(buyer(), 2, Some(2), &[], authorization(2, 42, 190)) 157 } else { 158 content(seller(), 3, Some(2), &[], authorization(2, 42, 190)) 159 }; 160 assert_eq!( 161 claim_at(&values, 150).unwrap_err(), 162 ReplacementTermsError::WrongAuthorization 163 ); 164 } 165 } 166 167 #[test] 168 fn exact_base_proposal_authorization_and_declared_digest_are_separate_required_bindings() { 169 let mut values = fixture(false); 170 values[0].1 = content( 171 seller(), 172 1, 173 None, 174 &[9000], 175 CommercePayload::Decline(RecordReason::new(id(9000), "declined").unwrap()), 176 ); 177 assert_eq!( 178 claim_at(&values, 150).unwrap_err(), 179 ReplacementTermsError::WrongBase 180 ); 181 let mut values = fixture(false); 182 values[1].1 = content(seller(), 2, Some(1), &[], proposal(None, false, 200)); 183 assert_eq!( 184 claim_at(&values, 150).unwrap_err(), 185 ReplacementTermsError::WrongProposal 186 ); 187 let mut values = fixture(false); 188 values[2].1 = content(buyer(), 1, None, &[1], authorization(1, 42, 190)); 189 assert_eq!( 190 claim_at(&values, 150).unwrap_err(), 191 ReplacementTermsError::WrongAuthorization 192 ); 193 let mut values = fixture(false); 194 values[2].1 = content(buyer(), 1, None, &[2], authorization(2, 43, 190)); 195 assert_eq!( 196 claim_at(&values, 150).unwrap_err(), 197 ReplacementTermsError::TermsDigestMismatch 198 ); 199 } 200 201 #[test] 202 fn exact_deadlines_and_future_claims_refuse_fresh_admission_without_erasing_history() { 203 let values = fixture(false); 204 assert!(claim_at(&values, 189).is_ok()); 205 assert_eq!( 206 claim_at(&values, 190).unwrap_err(), 207 ReplacementTermsError::Expired 208 ); 209 assert_eq!( 210 claim_at(&values, 99).unwrap_err(), 211 ReplacementTermsError::ClockAhead 212 ); 213 let mut values = values; 214 values[1].1 = content(seller(), 2, Some(1), &[], proposal(Some(1), false, 140)); 215 assert_eq!( 216 claim_at(&values, 150).unwrap_err(), 217 ReplacementTermsError::Expired 218 ); 219 assert_eq!(values.len(), 3); 220 } 221 222 #[test] 223 fn observed_withdrawal_and_counterparty_rejection_block_only_their_actual_selected_claims() { 224 let mut values = fixture(false); 225 values.push(( 226 4, 227 content( 228 buyer(), 229 2, 230 Some(3), 231 &[], 232 CommercePayload::WithdrawalRequested(RecordReason::new(id(3), "withdraw").unwrap()), 233 ), 234 )); 235 assert_eq!( 236 claim_at(&values, 150).unwrap_err(), 237 ReplacementTermsError::Withdrawn 238 ); 239 values.pop(); 240 values.push(( 241 4, 242 content( 243 buyer(), 244 2, 245 Some(3), 246 &[2], 247 CommercePayload::TermsRejected(RecordReason::new(id(2), "reject").unwrap()), 248 ), 249 )); 250 assert_eq!( 251 claim_at(&values, 150).unwrap_err(), 252 ReplacementTermsError::Rejected 253 ); 254 let mut values = fixture(false); 255 values.push(( 256 4, 257 content( 258 seller(), 259 3, 260 Some(2), 261 &[], 262 CommercePayload::TermsRejected( 263 RecordReason::new(id(2), "proposer is not counterparty").unwrap(), 264 ), 265 ), 266 )); 267 assert!(claim_at(&values, 150).is_ok()); 268 let mut values = fixture(true); 269 values.push(( 270 4, 271 content( 272 buyer(), 273 2, 274 Some(2), 275 &[3], 276 CommercePayload::WithdrawalRequested( 277 RecordReason::new(id(3), "not the author of this authorization").unwrap(), 278 ), 279 ), 280 )); 281 assert!(claim_at(&values, 150).is_ok()); 282 } 283 284 fn competing(different: bool) -> Vec<(u64, CommerceContent)> { 285 let mut values = fixture(false); 286 values.push(( 287 4, 288 content( 289 seller(), 290 3, 291 Some(2), 292 &[1], 293 proposal(Some(1), different, 200), 294 ), 295 )); 296 values.push(( 297 5, 298 content( 299 buyer(), 300 2, 301 Some(3), 302 &[4], 303 authorization(4, if different { 43 } else { 42 }, 190), 304 ), 305 )); 306 values 307 } 308 #[test] 309 fn incompatible_live_authorizations_never_choose_by_arrival_time_but_compatible_claims_remain_usable() 310 { 311 let mut values = competing(true); 312 assert_eq!( 313 claim_at(&values, 150).unwrap_err(), 314 ReplacementTermsError::ConflictingAuthorizations 315 ); 316 values.reverse(); 317 assert_eq!( 318 claim_at(&values, 150).unwrap_err(), 319 ReplacementTermsError::ConflictingAuthorizations 320 ); 321 values.reverse(); 322 values.push(( 323 6, 324 content( 325 buyer(), 326 3, 327 Some(5), 328 &[], 329 CommercePayload::WithdrawalRequested( 330 RecordReason::new(id(5), "withdraw competing authorization").unwrap(), 331 ), 332 ), 333 )); 334 assert!(claim_at(&values, 150).is_ok()); 335 assert!(claim_at(&competing(false), 150).is_ok()); 336 } 337 338 #[test] 339 fn incompatible_counterproposals_authorized_by_different_parties_still_require_reconciliation() { 340 let mut values = fixture(false); 341 values.push(( 342 4, 343 content(buyer(), 2, Some(3), &[1], proposal(Some(1), true, 200)), 344 )); 345 values.push(( 346 5, 347 content(seller(), 3, Some(2), &[4], authorization(4, 43, 190)), 348 )); 349 assert_eq!( 350 claim_at(&values, 150).unwrap_err(), 351 ReplacementTermsError::ConflictingAuthorizations 352 ); 353 } 354 355 #[test] 356 fn selected_originals_cannot_be_filled_by_generic_sources_and_unknown_or_forked_history_never_falls_back() 357 { 358 let values = fixture(false); 359 let no_authorization = &values[..2]; 360 let records = no_authorization 361 .iter() 362 .map(|(i, v)| CausalRecord::new(id(*i), v)) 363 .collect::<Vec<_>>(); 364 assert_eq!( 365 prepare_replacement_terms( 366 scope(), 367 selection(), 368 &records, 369 &[src(9000), SourceId::from_bytes([3; 32]), src(3)], 370 &[], 371 time(150) 372 ) 373 .unwrap_err(), 374 ReplacementTermsError::MissingHistory 375 ); 376 let records = values 377 .iter() 378 .map(|(i, v)| CausalRecord::new(id(*i), v)) 379 .collect::<Vec<_>>(); 380 assert_eq!( 381 prepare_replacement_terms( 382 scope(), 383 selection(), 384 &records, 385 &[src(9000), SourceId::from_bytes([3; 32])], 386 &[src(8000)], 387 time(150) 388 ) 389 .unwrap_err(), 390 ReplacementTermsError::Uninterpreted 391 ); 392 let mut fork = values.clone(); 393 fork.push(( 394 4, 395 content(seller(), 2, Some(1), &[], proposal(Some(1), true, 200)), 396 )); 397 assert_eq!( 398 claim_at(&fork, 150).unwrap_err(), 399 ReplacementTermsError::Conflicted 400 ); 401 let mut missing = values.clone(); 402 missing.remove(0); 403 assert_eq!( 404 claim_at(&missing, 150).unwrap_err(), 405 ReplacementTermsError::MissingHistory 406 ); 407 } 408 409 #[test] 410 fn record_quota_counts_duplicates_and_never_returns_a_claim_from_an_oversized_scope() { 411 let values = fixture(false); 412 let mut records = values 413 .iter() 414 .map(|(i, value)| CausalRecord::new(id(*i), value)) 415 .collect::<Vec<_>>(); 416 records.resize(MAX_CAUSAL_RECORDS + 1, records[2]); 417 assert_eq!( 418 prepare_replacement_terms( 419 scope(), 420 selection(), 421 &records, 422 &[src(9000), SourceId::from_bytes([3; 32])], 423 &[], 424 time(150), 425 ) 426 .unwrap_err(), 427 ReplacementTermsError::InvalidGraph 428 ); 429 } 430 431 #[test] 432 fn complete_scope_and_declared_digest_checks_do_not_authenticate_sources_or_mint_current_authority() 433 { 434 let values = fixture(false); 435 let records = values 436 .iter() 437 .map(|(i, v)| CausalRecord::new(id(*i), v)) 438 .collect::<Vec<_>>(); 439 let foreign = 440 CausalScope::new(ThreadId::from_bytes([99; 32]), order(), buyer(), seller()).unwrap(); 441 assert_eq!( 442 prepare_replacement_terms(foreign, selection(), &records, &[], &[], time(150)).unwrap_err(), 443 ReplacementTermsError::InvalidGraph 444 ); 445 // These are deliberately caller-declared IDs/digests, not a signed carrier 446 // or a canonical hash proof. Native admission must independently prove both. 447 let selected = claim_at(&values, 150).unwrap(); 448 assert_eq!(selected.selection().terms_digest(), digest(42)); 449 assert_eq!(selected.base_commitment().authority().generation().get(), 1); 450 assert_eq!(selection().base_agreement(), id(1)); 451 assert_eq!(selection().proposal(), id(2)); 452 assert_eq!(selection().authorization(), id(3)); 453 for error in [ 454 ReplacementTermsError::InvalidGraph, 455 ReplacementTermsError::MissingHistory, 456 ReplacementTermsError::Conflicted, 457 ReplacementTermsError::Uninterpreted, 458 ReplacementTermsError::WrongBase, 459 ReplacementTermsError::WrongProposal, 460 ReplacementTermsError::WrongAuthorization, 461 ReplacementTermsError::TermsDigestMismatch, 462 ReplacementTermsError::Expired, 463 ReplacementTermsError::ClockAhead, 464 ReplacementTermsError::Withdrawn, 465 ReplacementTermsError::Rejected, 466 ReplacementTermsError::ConflictingAuthorizations, 467 ] { 468 assert!(error.to_string().len() < 80); 469 assert!(core::error::Error::source(&error).is_none()); 470 } 471 }