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 }