dmsg_protocol 0.1.1

Deterministic encoding, COSE document verification, and approval helpers for dMsg
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use super::*;

#[test]
fn handles_normalize_only_ascii_and_enforce_limits() {
    for (input, expected) in [("A", "a"), ("ALIce_01", "alice_01"), ("9_", "9_")] {
        assert_eq!(normalize_handle(input).unwrap(), expected);
        assert_eq!(normalize_handle(expected).unwrap(), expected);
    }
    assert!(normalize_handle(&"A".repeat(20)).is_ok());
    for input in [
        "",
        "_alice",
        "alice-bob",
        "a b",
        "a/b",
        "a.b",
        "å",
        "中",
        "a\0",
    ] {
        assert!(normalize_handle(input).is_err(), "{input:?}");
    }
    assert!(normalize_handle(&"a".repeat(21)).is_err());
}

#[test]
fn valid_handle_price_boundaries_use_smallest_token_units() {
    for (len, tokens) in [
        (1, 1_000_000),
        (2, 200_000),
        (3, 50_000),
        (4, 50_000),
        (5, 20_000),
        (6, 20_000),
        (7, 5_000),
        (20, 5_000),
    ] {
        assert_eq!(price(&"a".repeat(len)), tokens * 100_000_000);
    }
    assert_eq!(price(&"a".repeat(20)), MIN_HANDLE_PRICE);
}

#[test]
fn charge_digest_binds_ledger_payer_amount_and_fee() {
    let ledger = Principal::from_slice(&[1]);
    let payer = Account {
        owner: Principal::from_slice(&[2]),
        subaccount: None,
    };
    let expected = charge_terms_digest(ledger, &payer, 1, 2);
    assert_ne!(
        charge_terms_digest(Principal::from_slice(&[3]), &payer, 1, 2),
        expected
    );
    assert_ne!(
        charge_terms_digest(
            ledger,
            &Account {
                owner: ledger,
                ..payer
            },
            1,
            2
        ),
        expected
    );
    assert_ne!(
        charge_terms_digest(
            ledger,
            &Account {
                subaccount: Some([1; 32]),
                ..payer
            },
            1,
            2
        ),
        expected
    );
    assert_ne!(
        charge_terms_digest(ledger, &payer, 1 + (1u128 << 100), 2),
        expected
    );
    assert_ne!(charge_terms_digest(ledger, &payer, 1, 3), expected);
}