commerce.rs (14926B)
1 #![cfg(feature = "commerce")] 2 use radroots_domain::{CommerceContent, CommercePayload, TermsQuote}; 3 use radroots_protocol::{ 4 commerce::{EncodedRecord, RECORD_MAX_BYTES, RecordWireError, decode}, 5 profile::COMMERCE_KIND, 6 }; 7 use serde_json::{Value, json}; 8 use std::collections::BTreeSet; 9 10 fn fixture() -> Value { 11 serde_json::from_str(include_str!("fixtures/commerce_wire.v1.json")).unwrap() 12 } 13 fn body(row: &Value) -> Value { 14 serde_json::from_str(row["wire"].as_str().unwrap()).unwrap() 15 } 16 fn bytes(value: &Value) -> Vec<u8> { 17 serde_json::to_vec(value).unwrap() 18 } 19 fn objects(value: &Value, path: &str, result: &mut Vec<String>) { 20 match value { 21 Value::Object(fields) => { 22 result.push(path.into()); 23 for (key, value) in fields { 24 objects(value, &format!("{path}/{key}"), result); 25 } 26 } 27 Value::Array(values) => { 28 for (index, value) in values.iter().enumerate() { 29 objects(value, &format!("{path}/{index}"), result); 30 } 31 } 32 _ => {} 33 } 34 } 35 36 #[test] 37 fn independent_complete_record_bytes_and_both_identity_domains_match_every_family() { 38 let fixture = fixture(); 39 let rows = fixture["vectors"].as_array().unwrap(); 40 assert_eq!(rows.len(), 39); 41 let mut types = BTreeSet::new(); 42 let mut identities = BTreeSet::new(); 43 for row in rows { 44 types.insert(row["type"].as_str().unwrap()); 45 let wire = row["wire"].as_str().unwrap(); 46 let record = decode(wire.as_bytes()).unwrap(); 47 assert_eq!( 48 record.record_id().to_string(), 49 row["record_id"].as_str().unwrap() 50 ); 51 assert!(identities.insert(record.record_id().to_string())); 52 let output = EncodedRecord::capture(record.content()).unwrap(); 53 assert_eq!(output.protected_wire(), wire.as_bytes(), "{}", row["name"]); 54 assert_eq!(output.record_id(), record.record_id()); 55 assert_eq!( 56 output.retained_bytes(), 57 std::mem::size_of::<EncodedRecord>() + wire.len() 58 ); 59 assert_ne!( 60 output.record_id().to_string(), 61 row["raw_preimage_sha256"].as_str().unwrap() 62 ); 63 assert_ne!( 64 output.record_id().to_string(), 65 row["terms_domain_digest"].as_str().unwrap() 66 ); 67 assert_eq!(format!("{output:?}"), "EncodedRecord(<redacted>)"); 68 assert_eq!(format!("{record:?}"), "DecodedRecord(<redacted>)"); 69 let mut value: Value = serde_json::from_slice(output.protected_wire()).unwrap(); 70 value.as_object_mut().unwrap().remove("record_id"); 71 assert_eq!( 72 serde_json::to_string(&value).unwrap(), 73 row["canonical_without_id"].as_str().unwrap() 74 ); 75 } 76 assert_eq!(types.len(), 19); 77 } 78 79 #[test] 80 fn all_known_objects_require_closed_duplicate_safe_complete_fields() { 81 for row in fixture()["vectors"].as_array().unwrap().iter().take(19) { 82 let original = body(row); 83 let mut paths = Vec::new(); 84 objects(&original, "", &mut paths); 85 for path in paths { 86 let fields = original.pointer(&path).unwrap().as_object().unwrap(); 87 let mut array = original.clone(); 88 *array.pointer_mut(&path).unwrap() = Value::Array(fields.values().cloned().collect()); 89 assert!( 90 matches!(decode(&bytes(&array)), Err(RecordWireError::InvalidInput)), 91 "array {}:{path}", 92 row["name"] 93 ); 94 let mut extra = original.clone(); 95 extra 96 .pointer_mut(&path) 97 .unwrap() 98 .as_object_mut() 99 .unwrap() 100 .insert("unexpected".into(), Value::Null); 101 let outcome = decode(&bytes(&extra)); 102 assert!( 103 matches!(outcome, Err(RecordWireError::InvalidInput)), 104 "unknown {}:{path}: {outcome:?}", 105 row["name"] 106 ); 107 for key in fields.keys() { 108 let mut missing = original.clone(); 109 missing 110 .pointer_mut(&path) 111 .unwrap() 112 .as_object_mut() 113 .unwrap() 114 .remove(key); 115 assert!( 116 matches!(decode(&bytes(&missing)), Err(RecordWireError::InvalidInput)), 117 "missing {}:{path}/{key}", 118 row["name"] 119 ); 120 let object = serde_json::to_string(original.pointer(&path).unwrap()).unwrap(); 121 let duplicate = format!( 122 "{{{}:{},{}", 123 serde_json::to_string(key).unwrap(), 124 serde_json::to_string(&fields[key]).unwrap(), 125 &object[1..] 126 ); 127 let mut template = original.clone(); 128 *template.pointer_mut(&path).unwrap() = json!("__RECORD_NEGATIVE_TARGET__"); 129 let wire = serde_json::to_string(&template) 130 .unwrap() 131 .replace("\"__RECORD_NEGATIVE_TARGET__\"", &duplicate); 132 assert!( 133 matches!(decode(wire.as_bytes()), Err(RecordWireError::InvalidInput)), 134 "duplicate {}:{path}/{key}", 135 row["name"] 136 ); 137 } 138 } 139 } 140 } 141 142 #[test] 143 fn causal_party_role_and_exact_scalar_checks_precede_record_identity_acceptance() { 144 for row in fixture()["vectors"] 145 .as_array() 146 .unwrap() 147 .iter() 148 .filter(|r| r["name"] != "exact_private_record_limit") 149 { 150 let original = body(row); 151 for parent in row["required_parents"].as_array().unwrap() { 152 let mut missing = original.clone(); 153 missing["parents"] 154 .as_array_mut() 155 .unwrap() 156 .retain(|p| p != parent); 157 assert!( 158 matches!(decode(&bytes(&missing)), Err(RecordWireError::InvalidInput)), 159 "parent {}:{parent}", 160 row["name"] 161 ); 162 } 163 for path in ["/author", "/buyer", "/seller"] { 164 let mut uppercase = original.clone(); 165 *uppercase.pointer_mut(path).unwrap() = json!( 166 original 167 .pointer(path) 168 .unwrap() 169 .as_str() 170 .unwrap() 171 .to_ascii_uppercase() 172 ); 173 assert!( 174 matches!( 175 decode(&bytes(&uppercase)), 176 Err(RecordWireError::InvalidInput) 177 ), 178 "key {path}" 179 ); 180 } 181 for (field, value) in [ 182 ("buyer", original["seller"].clone()), 183 ("author_sequence", json!("0")), 184 ("created_at", json!(450)), 185 ("author_sequence", json!("01")), 186 ] { 187 let mut invalid = original.clone(); 188 invalid[field] = value; 189 assert!( 190 matches!(decode(&bytes(&invalid)), Err(RecordWireError::InvalidInput)), 191 "{field}" 192 ); 193 } 194 if row["type"] != "quote" { 195 let mut no_order = original.clone(); 196 no_order["order_id"] = Value::Null; 197 assert!(matches!( 198 decode(&bytes(&no_order)), 199 Err(RecordWireError::InvalidInput) 200 )); 201 } 202 if [ 203 "quote", 204 "request", 205 "decline", 206 "agreement_committed", 207 "withdrawal_requested", 208 "withdrawal_acknowledged", 209 "residual_released", 210 "ready", 211 "handover", 212 "receipt", 213 "resolution_committed", 214 ] 215 .contains(&row["type"].as_str().unwrap()) 216 { 217 let mut wrong = original.clone(); 218 wrong["author"] = if original["author"] == original["buyer"] { 219 original["seller"].clone() 220 } else { 221 original["buyer"].clone() 222 }; 223 assert!( 224 matches!(decode(&bytes(&wrong)), Err(RecordWireError::InvalidInput)), 225 "role {}", 226 row["name"] 227 ); 228 } 229 } 230 } 231 232 #[test] 233 fn exact_complete_record_limit_includes_header_id_and_payload_before_private_output() { 234 assert_eq!(RECORD_MAX_BYTES, radroots_protocol::terms::TERMS_MAX_BYTES); 235 let f = fixture(); 236 let exact = f["vectors"] 237 .as_array() 238 .unwrap() 239 .iter() 240 .find(|r| r["name"] == "exact_private_record_limit") 241 .unwrap(); 242 let record = decode(exact["wire"].as_str().unwrap().as_bytes()).unwrap(); 243 assert_eq!( 244 EncodedRecord::capture(record.content()) 245 .unwrap() 246 .protected_wire() 247 .len(), 248 RECORD_MAX_BYTES 249 ); 250 for row in f["invalid"].as_array().unwrap() { 251 assert_eq!(row["utf8_bytes"], RECORD_MAX_BYTES + 1); 252 assert!(matches!( 253 decode(row["wire"].as_str().unwrap().as_bytes()), 254 Err(RecordWireError::LimitExceeded) 255 )); 256 } 257 let terms_fixture: Value = 258 serde_json::from_str(include_str!("fixtures/terms_wire.v1.json")).unwrap(); 259 let standalone = terms_fixture["vectors"] 260 .as_array() 261 .unwrap() 262 .iter() 263 .find(|r| r["name"] == "exact_content_limit") 264 .unwrap(); 265 let terms = 266 radroots_protocol::terms::decode(standalone["wire"].as_str().unwrap().as_bytes()).unwrap(); 267 let content = CommerceContent::new( 268 record.content().header().clone(), 269 CommercePayload::Quote(TermsQuote::new( 270 terms, 271 "600".parse().unwrap(), 272 Some(radroots_domain::SourceId::from_bytes([6; 32])), 273 )), 274 ) 275 .unwrap(); 276 assert!(matches!( 277 EncodedRecord::capture(&content), 278 Err(RecordWireError::LimitExceeded) 279 )); 280 let too_deep = format!("{}0{}", "[".repeat(17), "]".repeat(17)); 281 assert!(matches!( 282 decode(too_deep.as_bytes()), 283 Err(RecordWireError::LimitExceeded) 284 )); 285 } 286 287 #[test] 288 fn identity_and_final_rumor_fields_are_distinct_checks_without_authentication() { 289 let row = &fixture()["vectors"][2]; 290 let value = body(row); 291 let record = decode(&bytes(&value)).unwrap(); 292 let output = EncodedRecord::capture(record.content()).unwrap(); 293 let header = record.content().header(); 294 assert!( 295 record 296 .check_rumor_fields(header.author(), header.created_at().get(), COMMERCE_KIND) 297 .is_ok() 298 ); 299 assert!( 300 output 301 .check_rumor_fields(header.author(), header.created_at().get(), COMMERCE_KIND) 302 .is_ok() 303 ); 304 for (author, time, kind) in [ 305 (header.buyer(), header.created_at().get(), COMMERCE_KIND), 306 ( 307 header.author(), 308 header.created_at().get() + 1, 309 COMMERCE_KIND, 310 ), 311 (header.author(), header.created_at().get(), 14), 312 ] { 313 assert_eq!( 314 record.check_rumor_fields(author, time, kind), 315 Err(RecordWireError::CarrierMismatch) 316 ); 317 assert_eq!( 318 output.check_rumor_fields(author, time, kind), 319 Err(RecordWireError::CarrierMismatch) 320 ); 321 } 322 let mut changed = value.clone(); 323 changed["payload"]["reason"] = json!("Changed private text"); 324 assert!(matches!( 325 decode(&bytes(&changed)), 326 Err(RecordWireError::IdentityMismatch) 327 )); 328 changed = value.clone(); 329 changed["record_id"] = json!("00".repeat(32)); 330 assert!(matches!( 331 decode(&bytes(&changed)), 332 Err(RecordWireError::IdentityMismatch) 333 )); 334 for (field, new) in [ 335 ("profile", json!("other.profile")), 336 ("version", json!(2)), 337 ("type", json!("future_record")), 338 ] { 339 let unknown = json!({"profile":value["profile"],"version":value["version"],"type":value["type"],"future_only":{"private":"uninterpreted"}}); 340 let mut unknown = unknown; 341 unknown[field] = new; 342 assert!( 343 matches!( 344 decode(&bytes(&unknown)), 345 Err(RecordWireError::UnsupportedProfile) 346 ), 347 "{field}" 348 ); 349 } 350 for raw in [b"{".as_slice(), b"[]", b"null", b"\xff"] { 351 assert!(decode(raw).is_err()); 352 } 353 } 354 355 #[test] 356 fn nested_future_vocabularies_and_collection_limits_never_become_partial_records() { 357 let f = fixture(); 358 let quote = f["vectors"] 359 .as_array() 360 .unwrap() 361 .iter() 362 .find(|r| r["name"] == "quote") 363 .unwrap(); 364 let mut invalid_source = body(quote); 365 invalid_source["payload"]["terms"]["lines"][0]["source"]["coordinate"]["kind"] = json!(30403); 366 assert!(matches!( 367 decode(&bytes(&invalid_source)), 368 Err(RecordWireError::InvalidInput) 369 )); 370 for (kind, path) in [ 371 ("quote", "/payload/terms/cancellation"), 372 ("quote", "/payload/terms/rounding"), 373 ("quote", "/payload/terms/supply/type"), 374 ("request", "/payload/terms/lines/0/price/measurement_unit"), 375 ("terms_proposed", "/payload/terms/lines/0/option/price/type"), 376 ("handover", "/payload/measurements/0/quantity/unit"), 377 ("issue", "/payload/code"), 378 ] { 379 let row = f["vectors"] 380 .as_array() 381 .unwrap() 382 .iter() 383 .find(|r| r["name"] == kind) 384 .unwrap(); 385 let mut value = body(row); 386 *value.pointer_mut(path).unwrap() = json!("future_variant"); 387 assert!( 388 matches!( 389 decode(&bytes(&value)), 390 Err(RecordWireError::UnsupportedProfile) 391 ), 392 "{kind}:{path}" 393 ); 394 } 395 let row = f["vectors"] 396 .as_array() 397 .unwrap() 398 .iter() 399 .find(|r| r["name"] == "handover") 400 .unwrap(); 401 for path in ["/parents", "/payload/lines", "/payload/measurements"] { 402 let mut value = body(row); 403 *value.pointer_mut(path).unwrap() = 404 Value::Array(vec![Value::Null; if path == "/parents" { 9 } else { 33 }]); 405 assert!( 406 matches!(decode(&bytes(&value)), Err(RecordWireError::InvalidInput)), 407 "{path}" 408 ); 409 } 410 let row = f["vectors"] 411 .as_array() 412 .unwrap() 413 .iter() 414 .find(|r| r["name"] == "resolution_proposed") 415 .unwrap(); 416 for path in [ 417 "/payload/resolution/issues", 418 "/payload/resolution/accepted_receipts", 419 "/payload/resolution/release_residual", 420 ] { 421 let mut value = body(row); 422 *value.pointer_mut(path).unwrap() = Value::Array(vec![Value::Null; 33]); 423 assert!( 424 matches!(decode(&bytes(&value)), Err(RecordWireError::InvalidInput)), 425 "{path}" 426 ); 427 } 428 }