lib

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

terms.rs (11182B)


      1 #![cfg(feature = "terms")]
      2 
      3 use radroots_domain::{
      4     AgreedFixedPrice, AgreementLine, AgreementLineId, AgreementPrice, ContentMeasure, DiscountBps,
      5     EnvelopeEventId, FixedPrice, FulfillmentGroup, FulfillmentGroupId, FuturePromise,
      6     ListingOptionId, Money, PositiveDecimal, PriceTier, PrivateFulfillment, PublicKey, Quantity,
      7     SupplyCommitment, Terms, TimeZoneId, UnixSeconds, VariableWeight, Window, listing::*,
      8 };
      9 use radroots_protocol::terms::{EncodedTerms, TERMS_MAX_BYTES, TermsWireError};
     10 use serde::Deserialize;
     11 
     12 #[derive(Deserialize)]
     13 struct Fixture {
     14     vectors: Vec<Vector>,
     15     invalid: Vec<Invalid>,
     16 }
     17 #[derive(Deserialize)]
     18 struct Vector {
     19     name: String,
     20     config: Config,
     21     wire: String,
     22     utf8_bytes: usize,
     23     terms_digest: String,
     24     raw_sha256: String,
     25     record_domain_digest: String,
     26 }
     27 #[derive(Deserialize)]
     28 struct Invalid {
     29     config: Config,
     30     utf8_bytes: usize,
     31 }
     32 #[derive(Deserialize)]
     33 struct Config {
     34     price: String,
     35     currency: String,
     36     exponent: u8,
     37     contents: String,
     38     public_window: bool,
     39     mode: String,
     40     address: String,
     41     instructions: String,
     42     contact: Option<String>,
     43     lot: Option<String>,
     44     future: bool,
     45     instructions_by_group: Option<Vec<String>>,
     46 }
     47 fn fixtures() -> Fixture {
     48     serde_json::from_str(include_str!("fixtures/terms_wire.v1.json")).unwrap()
     49 }
     50 fn seller() -> PublicKey {
     51     PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798").unwrap()
     52 }
     53 fn buyer() -> PublicKey {
     54     PublicKey::from_hex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5").unwrap()
     55 }
     56 fn window(start: u64, end: u64) -> Window {
     57     Window::new(
     58         UnixSeconds::new(start).unwrap(),
     59         UnixSeconds::new(end).unwrap(),
     60         TimeZoneId::from_name("Etc/UTC").unwrap(),
     61     )
     62     .unwrap()
     63 }
     64 fn build(config: &Config) -> Terms {
     65     let money = |minor| Money::from_parts(&config.currency, minor, config.exponent).unwrap();
     66     let quantity = Quantity::new("500".parse().unwrap(), MeasurementUnit::Gram).unwrap();
     67     let contents = match config.contents.as_str() {
     68         "fixed" => ContentMeasure::Fixed { quantity },
     69         "estimated" => ContentMeasure::Estimated { quantity },
     70         "unspecified" => ContentMeasure::Unspecified,
     71         _ => panic!("unknown fixture contents"),
     72     };
     73     let quoted = config.price == "negotiated";
     74     let variable = config.price == "variable";
     75     let price = if quoted {
     76         Price::QuoteRequired
     77     } else if variable {
     78         Price::VariableWeight(
     79             VariableWeight::new(
     80                 MeasurementUnit::Gram,
     81                 "250".parse().unwrap(),
     82                 "500".parse().unwrap(),
     83                 money("17"),
     84                 "100".parse().unwrap(),
     85                 money("85"),
     86             )
     87             .unwrap(),
     88         )
     89     } else {
     90         Price::Fixed(
     91             FixedPrice::new(
     92                 money("200"),
     93                 "1".parse().unwrap(),
     94                 DiscountBps::new(250).unwrap(),
     95                 vec![PriceTier::new("2".parse().unwrap(), money("150"))],
     96             )
     97             .unwrap(),
     98         )
     99     };
    100     let option = ListingOption::new(
    101         ListingOptionId::from_bytes([2; 32]),
    102         "Bag",
    103         SaleUnit::package("bag", contents).unwrap(),
    104         "1".parse().unwrap(),
    105         "1".parse().unwrap(),
    106         price,
    107         if quoted {
    108             Supply::Unknown
    109         } else {
    110             Supply::Estimated {
    111                 amount: "0".parse().unwrap(),
    112                 window: config.public_window.then(|| window(100, 200)),
    113             }
    114         },
    115         LeadSeconds::new(0).unwrap(),
    116     )
    117     .unwrap();
    118     let amount: PositiveDecimal = if quoted || variable { "2" } else { "3" }.parse().unwrap();
    119     let agreed = if quoted {
    120         AgreementPrice::Fixed(AgreedFixedPrice::new(
    121             money("325"),
    122             "2".parse().unwrap(),
    123             DiscountBps::NONE,
    124             None,
    125         ))
    126     } else if variable {
    127         AgreementPrice::VariableWeight(
    128             VariableWeight::new(
    129                 MeasurementUnit::Gram,
    130                 "500".parse().unwrap(),
    131                 "1000".parse().unwrap(),
    132                 money("17"),
    133                 "100".parse().unwrap(),
    134                 money("170"),
    135             )
    136             .unwrap(),
    137         )
    138     } else {
    139         AgreementPrice::Fixed(AgreedFixedPrice::from_line(
    140             option.fixed_line(amount).unwrap(),
    141         ))
    142     };
    143     let total = if quoted {
    144         "325"
    145     } else if variable {
    146         "170"
    147     } else {
    148         "439"
    149     };
    150     let fee = if quoted { "0" } else { "25" };
    151     let line = AgreementLine::new(
    152         AgreementLineId::from_bytes([5; 32]),
    153         ListingRevision::new(
    154             ListingCoordinate::new(seller(), ListingId::from_bytes([1; 16])),
    155             EnvelopeEventId::from_bytes([3; 32]),
    156         ),
    157         option.id(),
    158         Product::new(
    159             "Carrots 🥕",
    160             "Public crop",
    161             Some(seller()),
    162             Some("Example area"),
    163         )
    164         .unwrap(),
    165         option,
    166         amount,
    167         FulfillmentGroupId::from_bytes([4; 32]),
    168         config.lot.as_deref(),
    169         agreed,
    170         money(total),
    171     )
    172     .unwrap();
    173     let instructions = config
    174         .instructions_by_group
    175         .as_deref()
    176         .unwrap_or_else(|| std::slice::from_ref(&config.instructions));
    177     let groups = instructions
    178         .iter()
    179         .enumerate()
    180         .map(|(index, instruction)| {
    181             FulfillmentGroup::new(
    182                 FulfillmentGroupId::from_bytes([u8::try_from(4 + index).unwrap(); 32]),
    183                 PrivateFulfillment::new(
    184                     match config.mode.as_str() {
    185                         "pickup" => FulfillmentMode::Pickup,
    186                         "delivery" => FulfillmentMode::Delivery,
    187                         _ => panic!("unknown fixture mode"),
    188                     },
    189                     window(300, 400),
    190                     &config.address,
    191                     instruction,
    192                     config.contact.as_deref(),
    193                 )
    194                 .unwrap(),
    195             )
    196         })
    197         .collect();
    198     Terms::new(
    199         buyer(),
    200         seller(),
    201         vec![line],
    202         groups,
    203         money(fee),
    204         money(total).checked_add(money(fee)).unwrap(),
    205         if config.future {
    206             SupplyCommitment::FuturePromise(
    207                 FuturePromise::new(window(100, 200), "Weather change 🌧").unwrap(),
    208             )
    209         } else {
    210             SupplyCommitment::StockBacked
    211         },
    212     )
    213     .unwrap()
    214 }
    215 
    216 #[test]
    217 fn independent_ecmascript_terms_bytes_and_all_hash_domains_match() {
    218     let fixture = fixtures();
    219     assert_eq!(fixture.vectors.len(), 9);
    220     for vector in fixture.vectors {
    221         let terms = build(&vector.config);
    222         let encoded = EncodedTerms::capture(&terms).unwrap();
    223         assert_eq!(
    224             encoded.protected_wire(),
    225             vector.wire.as_bytes(),
    226             "{}",
    227             vector.name
    228         );
    229         assert_eq!(
    230             encoded.protected_wire().len(),
    231             vector.utf8_bytes,
    232             "{}",
    233             vector.name
    234         );
    235         assert_eq!(
    236             encoded.digest().to_string(),
    237             vector.terms_digest,
    238             "{}",
    239             vector.name
    240         );
    241         assert_ne!(encoded.digest().to_string(), vector.raw_sha256);
    242         assert_ne!(encoded.digest().to_string(), vector.record_domain_digest);
    243         assert_eq!(
    244             encoded.retained_bytes(),
    245             std::mem::size_of::<EncodedTerms>() + vector.utf8_bytes
    246         );
    247         assert_eq!(format!("{encoded:?}"), "EncodedTerms(<redacted>)");
    248         let mut value: serde_json::Value =
    249             serde_json::from_slice(encoded.protected_wire()).unwrap();
    250         assert_eq!(value.as_object().unwrap().len(), 9);
    251         assert!(value.as_object_mut().unwrap().remove("record_id").is_none());
    252     }
    253 }
    254 
    255 #[test]
    256 fn unicode_spelling_and_explicit_optional_values_remain_distinct() {
    257     let fixture = fixtures();
    258     let get = |name| {
    259         fixture
    260             .vectors
    261             .iter()
    262             .find(|value| value.name == name)
    263             .unwrap()
    264     };
    265     for (left, right) in [
    266         ("unicode_composed", "unicode_decomposed"),
    267         ("contact_null", "contact_empty"),
    268     ] {
    269         let first = EncodedTerms::capture(&build(&get(left).config)).unwrap();
    270         let second = EncodedTerms::capture(&build(&get(right).config)).unwrap();
    271         assert_ne!(first.protected_wire(), second.protected_wire());
    272         assert_ne!(first.digest(), second.digest());
    273     }
    274 }
    275 
    276 #[test]
    277 fn complete_escaped_content_accepts_exact_limit_and_refuses_one_more_byte() {
    278     let fixture = fixtures();
    279     let exact = fixture
    280         .vectors
    281         .iter()
    282         .find(|value| value.name == "exact_content_limit")
    283         .unwrap();
    284     assert_eq!(
    285         EncodedTerms::capture(&build(&exact.config))
    286             .unwrap()
    287             .protected_wire()
    288             .len(),
    289         TERMS_MAX_BYTES
    290     );
    291     assert_eq!(fixture.invalid.len(), 1);
    292     for invalid in fixture.invalid {
    293         assert_eq!(invalid.utf8_bytes, TERMS_MAX_BYTES + 1);
    294         let terms = build(&invalid.config);
    295         assert!(matches!(
    296             EncodedTerms::capture(&terms),
    297             Err(TermsWireError::LimitExceeded)
    298         ));
    299     }
    300 }
    301 
    302 #[test]
    303 fn complete_line_and_fulfillment_array_order_is_part_of_the_terms_identity() {
    304     let mut config = fixtures().vectors.remove(0).config;
    305     config.instructions_by_group = Some(vec!["First group".into(), "Second group".into()]);
    306     let original = build(&config);
    307     let line = &original.lines()[0];
    308     let second = AgreementLine::new(
    309         AgreementLineId::from_bytes([6; 32]),
    310         line.source(),
    311         line.option_id(),
    312         line.product().clone(),
    313         line.option().clone(),
    314         line.amount(),
    315         FulfillmentGroupId::from_bytes([5; 32]),
    316         line.source_lot_label(),
    317         line.price(),
    318         line.maximum_line_total(),
    319     )
    320     .unwrap();
    321     let total = original
    322         .maximum_total()
    323         .checked_add(second.maximum_line_total())
    324         .unwrap();
    325     let lines = vec![line.clone(), second];
    326     let groups = original.fulfillment().to_vec();
    327     let create = |lines, groups| {
    328         Terms::new(
    329             original.buyer(),
    330             original.seller(),
    331             lines,
    332             groups,
    333             original.fulfillment_charge(),
    334             total,
    335             original.supply().clone(),
    336         )
    337         .unwrap()
    338     };
    339     let normal = EncodedTerms::capture(&create(lines.clone(), groups.clone())).unwrap();
    340     let reversed_lines = EncodedTerms::capture(&create(
    341         lines.iter().rev().cloned().collect(),
    342         groups.clone(),
    343     ))
    344     .unwrap();
    345     let reversed_groups =
    346         EncodedTerms::capture(&create(lines, groups.into_iter().rev().collect())).unwrap();
    347     assert_ne!(normal.protected_wire(), reversed_lines.protected_wire());
    348     assert_ne!(normal.digest(), reversed_lines.digest());
    349     assert_ne!(normal.protected_wire(), reversed_groups.protected_wire());
    350     assert_ne!(normal.digest(), reversed_groups.digest());
    351 }