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 }