lib

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

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 }