lib

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

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 }