lib

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

order_terms.rs (9185B)


      1 #![cfg(feature = "commands")]
      2 use radroots_protocol::command::{
      3     COMMAND_MAX_BYTES, CapturedCommand, CapturedInventoryCommand, CapturedOrderAcceptance,
      4     CapturedStockCommitment, CapturedTermsInstallation, CommandError,
      5 };
      6 use serde_json::{Value, json};
      7 
      8 fn vectors() -> Value {
      9     serde_json::from_str(include_str!("fixtures/terms_installation.v1.json")).unwrap()
     10 }
     11 fn parse(value: &Value) -> Result<CapturedTermsInstallation, CommandError> {
     12     CapturedTermsInstallation::parse(&serde_json::to_vec(value).unwrap())
     13 }
     14 
     15 #[test]
     16 fn automatic_and_explicit_capture_match_independent_ecmascript_bytes_and_digests() {
     17     for case in vectors()["cases"].as_array().unwrap() {
     18         let captured = parse(&case["wire"]).unwrap();
     19         assert_eq!(
     20             captured.protected_wire(),
     21             case["protected_canonical_utf8"]
     22                 .as_str()
     23                 .unwrap()
     24                 .as_bytes()
     25         );
     26         assert_eq!(
     27             captured.digest().to_string(),
     28             case["command_digest"].as_str().unwrap()
     29         );
     30         assert_eq!(
     31             captured.approval_intent_digest().to_string(),
     32             case["approval_intent_digest"].as_str().unwrap()
     33         );
     34         assert_eq!(
     35             CapturedTermsInstallation::parse(captured.protected_wire())
     36                 .unwrap()
     37                 .digest(),
     38             captured.digest()
     39         );
     40         assert_eq!(captured.input().proposal().to_string(), "31".repeat(32));
     41         assert_eq!(
     42             captured.input().authorization().to_string(),
     43             "32".repeat(32)
     44         );
     45         assert_eq!(
     46             captured.input().terms_digest().to_string(),
     47             case["wire"]["input"]["terms_digest"].as_str().unwrap()
     48         );
     49         assert_eq!(
     50             format!("{captured:?}"),
     51             "CapturedTermsInstallation(<redacted>)"
     52         );
     53         assert_eq!(
     54             format!("{:?}", captured.input()),
     55             "InstallTermsInput(<redacted>)"
     56         );
     57         assert!(CapturedCommand::parse(captured.protected_wire()).is_err());
     58         assert!(CapturedInventoryCommand::parse(captured.protected_wire()).is_err());
     59         assert!(CapturedOrderAcceptance::parse(captured.protected_wire()).is_err());
     60     }
     61     let values = vectors();
     62     assert!(
     63         parse(&values["cases"][0]["wire"])
     64             .unwrap()
     65             .input()
     66             .allocation()
     67             .is_automatic()
     68     );
     69     assert_eq!(
     70         parse(&values["cases"][1]["wire"])
     71             .unwrap()
     72             .input()
     73             .allocation()
     74             .explicit_allocations()
     75             .unwrap()
     76             .len(),
     77         2
     78     );
     79 }
     80 
     81 #[test]
     82 fn proposal_authorization_digest_base_and_allocation_each_bind_the_displayed_intent() {
     83     let data = vectors();
     84     let original = &data["cases"][0]["wire"];
     85     let expected = parse(original).unwrap();
     86     for (path, value) in [
     87         ("/input/proposal", json!("61".repeat(32))),
     88         ("/input/authorization", json!("62".repeat(32))),
     89         ("/input/terms_digest", json!("63".repeat(32))),
     90         ("/context/expected/agreement", json!("64".repeat(32))),
     91         ("/context/expected/seller_sequence", json!("2")),
     92         (
     93             "/input/allocation",
     94             data["cases"][1]["wire"]["input"]["allocation"].clone(),
     95         ),
     96     ] {
     97         let mut changed = original.clone();
     98         *changed.pointer_mut(path).unwrap() = value;
     99         let changed = parse(&changed).unwrap();
    100         assert_ne!(changed.digest(), expected.digest());
    101         assert_ne!(
    102             changed.approval_intent_digest(),
    103             expected.approval_intent_digest()
    104         );
    105     }
    106     let mut correlated = original.clone();
    107     correlated["context"]["correlation_id"] = json!("different observer");
    108     let correlated = parse(&correlated).unwrap();
    109     assert_eq!(correlated.digest(), expected.digest());
    110     assert_eq!(
    111         correlated.approval_intent_digest(),
    112         expected.approval_intent_digest()
    113     );
    114     assert_ne!(correlated.protected_wire(), expected.protected_wire());
    115     let mut approved = original.clone();
    116     approved["context"]["approval"] = json!({"intent_digest":expected.approval_intent_digest(),"scope":"orders.install_terms","expires_at":"190"});
    117     let approved = parse(&approved).unwrap();
    118     assert_ne!(approved.digest(), expected.digest());
    119     assert_eq!(
    120         approved.approval_intent_digest(),
    121         expected.approval_intent_digest()
    122     );
    123 }
    124 
    125 #[test]
    126 fn closed_shapes_and_seller_order_descriptors_cannot_turn_capture_into_a_fallback_command() {
    127     let data = vectors();
    128     let original = &data["cases"][0]["wire"];
    129     for (path, value) in [
    130         ("/type", json!("orders.accept")),
    131         ("/context/actor/role", json!("buyer")),
    132         ("/context/expected", Value::Null),
    133         ("/input/proposal", json!("2A".repeat(32))),
    134         ("/input/authorization", json!("2A".repeat(32))),
    135         ("/input/terms_digest", json!("2A".repeat(32))),
    136         (
    137             "/input/allocation",
    138             json!({"type":"automatic","allocations":[]}),
    139         ),
    140         (
    141             "/input/allocation",
    142             json!({"type":"explicit","allocations":[]}),
    143         ),
    144         ("/input/allocation", json!({"type":"unknown"})),
    145     ] {
    146         let mut changed = original.clone();
    147         *changed.pointer_mut(path).unwrap() = value;
    148         assert!(parse(&changed).is_err(), "{path}");
    149     }
    150     for field in ["proposal", "authorization", "terms_digest", "allocation"] {
    151         let mut changed = original.clone();
    152         changed["input"].as_object_mut().unwrap().remove(field);
    153         assert!(parse(&changed).is_err(), "{field}");
    154     }
    155     let mut extra = original.clone();
    156     extra["input"]["stock_free"] = json!(true);
    157     assert!(parse(&extra).is_err());
    158     let mut extra = original.clone();
    159     extra["unrecognized"] = json!(true);
    160     assert!(parse(&extra).is_err());
    161 }
    162 
    163 #[test]
    164 fn duplicate_members_and_allocation_or_frame_overflow_refuse_before_any_execution() {
    165     let data = vectors();
    166     let original = &data["cases"][0]["wire"];
    167     let raw = serde_json::to_string(original).unwrap();
    168     let member = format!("\"proposal\":\"{}\"", "31".repeat(32));
    169     let duplicate = raw.replacen(&member, &format!("{member},{member}"), 1);
    170     assert!(CapturedTermsInstallation::parse(duplicate.as_bytes()).is_err());
    171     let mut excess = data["cases"][1]["wire"].clone();
    172     let allocation = excess["input"]["allocation"]["allocations"][0].clone();
    173     excess["input"]["allocation"]["allocations"] = json!(vec![allocation; 65]);
    174     assert!(parse(&excess).is_err());
    175     let mut oversized = raw.into_bytes();
    176     oversized.resize(COMMAND_MAX_BYTES + 1, b' ');
    177     assert!(matches!(
    178         CapturedTermsInstallation::parse(&oversized),
    179         Err(CommandError::LimitExceeded)
    180     ));
    181 }
    182 
    183 #[test]
    184 fn shared_commitment_dispatch_preserves_exact_bytes_and_rejects_ambiguous_roots() {
    185     let data = vectors();
    186     let acceptance: Value =
    187         serde_json::from_str(include_str!("fixtures/order_acceptance.v1.json")).unwrap();
    188     for (cases, name) in [
    189         (&data["cases"], "orders.install_terms"),
    190         (&acceptance["cases"], "orders.accept"),
    191     ] {
    192         for case in cases.as_array().unwrap() {
    193             let raw = serde_json::to_vec(&case["wire"]).unwrap();
    194             let captured = CapturedStockCommitment::parse(&raw).unwrap();
    195             assert_eq!(captured.command_name(), name);
    196             assert_eq!(
    197                 captured.proposal().is_some(),
    198                 name == "orders.install_terms"
    199             );
    200             assert_eq!(
    201                 CapturedStockCommitment::parse(captured.protected_wire())
    202                     .unwrap()
    203                     .digest(),
    204                 captured.digest()
    205             );
    206             match &captured {
    207                 CapturedStockCommitment::Acceptance(value) => {
    208                     assert_eq!(value.protected_wire(), captured.protected_wire());
    209                     assert_eq!(value.input().request(), captured.authorization());
    210                     assert_eq!(
    211                         value.approval_intent_digest(),
    212                         captured.approval_intent_digest()
    213                     );
    214                 }
    215                 CapturedStockCommitment::TermsInstallation(value) => {
    216                     assert_eq!(value.protected_wire(), captured.protected_wire());
    217                     assert_eq!(value.input().authorization(), captured.authorization());
    218                     assert_eq!(
    219                         value.approval_intent_digest(),
    220                         captured.approval_intent_digest()
    221                     );
    222                 }
    223             }
    224         }
    225     }
    226     let raw = serde_json::to_string(&data["cases"][0]["wire"]).unwrap();
    227     let duplicate = raw.replacen(
    228         "\"type\":\"orders.install_terms\"",
    229         "\"type\":\"orders.install_terms\",\"type\":\"orders.accept\"",
    230         1,
    231     );
    232     assert!(CapturedStockCommitment::parse(duplicate.as_bytes()).is_err());
    233     let mut unknown = data["cases"][0]["wire"].clone();
    234     unknown["type"] = json!("orders.handover");
    235     assert!(CapturedStockCommitment::parse(&serde_json::to_vec(&unknown).unwrap()).is_err());
    236 }