lib

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

pool_creation.rs (6283B)


      1 #![cfg(feature = "commands")]
      2 use radroots_domain::{
      3     ActorRef, ActorRole, AuthorityRef, CommandContextData, CorrelationId, Decimal, ExecutorId,
      4     Generation, GrantId, OperationId, PoolId, PublicKey, Quantity, RouteDigest, UnixSeconds,
      5     WorkspaceId, listing::MeasurementUnit, stock::PoolUnit,
      6 };
      7 use radroots_protocol::command::{CapturedPoolCreation, CreatePoolInput};
      8 use serde_json::json;
      9 fn context(correlation: Option<&str>) -> CommandContextData {
     10     let key =
     11         PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798")
     12             .unwrap();
     13     CommandContextData::new(
     14         OperationId::from_bytes([7; 32]),
     15         ActorRef::new(
     16             key,
     17             ActorRole::Seller,
     18             None,
     19             Some(GrantId::from_bytes([3; 32])),
     20         ),
     21         WorkspaceId::from_bytes([1; 32]),
     22         AuthorityRef::new(ExecutorId::from_bytes([2; 32]), Generation::new(1).unwrap()),
     23         RouteDigest::from_bytes([6; 32]),
     24         None,
     25         None,
     26         UnixSeconds::new(200).unwrap(),
     27         correlation.map(|s| CorrelationId::new(s).unwrap()),
     28     )
     29     .unwrap()
     30 }
     31 fn capture(scale: u8, correlation: Option<&str>) -> CapturedPoolCreation {
     32     let unit = PoolUnit::new(MeasurementUnit::Kilogram, scale).unwrap();
     33     let quantity = Quantity::new(
     34         "0.25".parse::<Decimal>().unwrap(),
     35         MeasurementUnit::Kilogram,
     36     )
     37     .unwrap();
     38     CapturedPoolCreation::new(
     39         context(correlation),
     40         CreatePoolInput::new(PoolId::from_bytes([8; 32]), "Carrots", unit, quantity).unwrap(),
     41     )
     42     .unwrap()
     43 }
     44 #[test]
     45 fn exact_pool_capture_binds_precision_and_excludes_only_diagnostic_correlation() {
     46     let original = capture(3, None);
     47     let parsed = CapturedPoolCreation::parse(original.protected_wire()).unwrap();
     48     assert_eq!(parsed.digest(), original.digest());
     49     assert_eq!(parsed.protected_wire(), original.protected_wire());
     50     assert_eq!(parsed.input().initial_ticks().get(), 250);
     51     let correlated = capture(3, Some("display-only"));
     52     assert_eq!(original.digest(), correlated.digest());
     53     assert_ne!(original.protected_wire(), correlated.protected_wire());
     54     let finer = capture(4, None);
     55     assert_ne!(original.digest(), finer.digest());
     56     assert_eq!(finer.input().initial_ticks().get(), 2500);
     57     let value: serde_json::Value = serde_json::from_slice(original.protected_wire()).unwrap();
     58     assert_eq!(value["input"]["tick_scale"], json!("3"));
     59     assert_eq!(value["input"]["initial_quantity"], json!("0.25"));
     60 }
     61 #[test]
     62 fn malformed_or_implicit_pool_precision_and_unknown_shapes_are_refused() {
     63     let original = capture(3, None);
     64     let base: serde_json::Value = serde_json::from_slice(original.protected_wire()).unwrap();
     65     for (path, bad) in [
     66         ("/input/tick_scale", json!(3)),
     67         ("/input/tick_scale", json!("03")),
     68         ("/input/tick_scale", json!("7")),
     69         ("/input/tick_scale", json!("1")),
     70         ("/input/unit", json!("each")),
     71         ("/input/unit", json!({"kg":null})),
     72         ("/input/initial_quantity", json!(0.25)),
     73         ("/input/initial_quantity", json!("0.250")),
     74         ("/input/id", json!("F".repeat(64))),
     75     ] {
     76         let mut v = base.clone();
     77         *v.pointer_mut(path).unwrap() = bad;
     78         assert!(
     79             CapturedPoolCreation::parse(&serde_json::to_vec(&v).unwrap()).is_err(),
     80             "{path}"
     81         );
     82     }
     83     for field in ["tick_scale", "unit", "label", "initial_quantity", "id"] {
     84         let mut v = base.clone();
     85         v["input"].as_object_mut().unwrap().remove(field);
     86         assert!(
     87             CapturedPoolCreation::parse(&serde_json::to_vec(&v).unwrap()).is_err(),
     88             "{field}"
     89         );
     90     }
     91     for path in ["", "/input"] {
     92         let mut v = base.clone();
     93         v.pointer_mut(path)
     94             .unwrap()
     95             .as_object_mut()
     96             .unwrap()
     97             .insert("ignored".into(), json!(true));
     98         assert!(CapturedPoolCreation::parse(&serde_json::to_vec(&v).unwrap()).is_err());
     99     }
    100     assert!(
    101         CapturedPoolCreation::parse(
    102             &serde_json::to_vec(&json!([base["type"], base["context"], base["input"]])).unwrap()
    103         )
    104         .is_err()
    105     );
    106 }
    107 #[test]
    108 fn typed_creation_never_converts_units_rounds_quantities_or_copies_oversized_labels() {
    109     let unit = PoolUnit::new(MeasurementUnit::Kilogram, 3).unwrap();
    110     let other = Quantity::new(Decimal::ONE, MeasurementUnit::Gram).unwrap();
    111     assert!(CreatePoolInput::new(PoolId::from_bytes([1; 32]), "x", unit, other).is_err());
    112     let quantity = Quantity::new(Decimal::ONE, MeasurementUnit::Kilogram).unwrap();
    113     assert!(
    114         CreatePoolInput::new(
    115             PoolId::from_bytes([1; 32]),
    116             &"a".repeat(161),
    117             unit,
    118             quantity
    119         )
    120         .is_err()
    121     );
    122     assert!(
    123         CreatePoolInput::new(PoolId::from_bytes([1; 32]), "hidden\nlabel", unit, quantity).is_err()
    124     );
    125 }
    126 
    127 #[test]
    128 fn complete_pool_command_matches_independent_canonical_hash_vector() {
    129     let fixture: serde_json::Value =
    130         serde_json::from_str(include_str!("fixtures/pool_creation.v1.json")).unwrap();
    131     let captured =
    132         CapturedPoolCreation::parse(&serde_json::to_vec(&fixture["wire"]).unwrap()).unwrap();
    133     assert_eq!(
    134         captured.digest().to_string(),
    135         fixture["command_digest"].as_str().unwrap()
    136     );
    137     assert_eq!(
    138         captured.approval_intent_digest().to_string(),
    139         fixture["approval_intent_digest"].as_str().unwrap()
    140     );
    141     for (path, value) in [
    142         ("/context/authority/generation", json!("2")),
    143         ("/context/actor/grant_id", json!("09".repeat(32))),
    144         ("/context/not_after", json!("201")),
    145         ("/context/route_digest", json!("09".repeat(32))),
    146         ("/context/workspace_id", json!("09".repeat(32))),
    147         ("/input/unit", json!("g")),
    148         ("/input/label", json!("カブ 🥕")),
    149         ("/input/initial_quantity", json!("0.5")),
    150         ("/input/tick_scale", json!("4")),
    151     ] {
    152         let mut changed = fixture["wire"].clone();
    153         *changed.pointer_mut(path).unwrap() = value;
    154         let changed = CapturedPoolCreation::parse(&serde_json::to_vec(&changed).unwrap()).unwrap();
    155         assert_ne!(changed.digest(), captured.digest(), "{path}");
    156     }
    157 }