bee-block 1.0.1

Implementation of the IOTA protocol block layouts
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

// Copyright 2020-2021 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use bee_block::{
    parent::Parents,
    payload::milestone::{MilestoneEssence, MilestoneIndex, MilestoneOptions, MilestonePayload},
    protocol::protocol_parameters,
    rand::{
        block::rand_block_ids,
        milestone::{rand_merkle_root, rand_milestone_id, rand_milestone_index},
        number::rand_number,
        parents::rand_parents,
    },
    signature::{Ed25519Signature, Signature},
    Error,
};
use packable::{bounded::TryIntoBoundedU8Error, PackableExt};

#[test]
fn kind() {
    assert_eq!(MilestonePayload::KIND, 7);
}

#[test]
fn new_valid() {
    assert!(
        MilestonePayload::new(
            MilestoneEssence::new(
                MilestoneIndex(0),
                0,
                protocol_parameters().protocol_version(),
                rand_milestone_id(),
                rand_parents(),
                rand_merkle_root(),
                rand_merkle_root(),
                vec![],
                MilestoneOptions::new(vec![]).unwrap(),
            )
            .unwrap(),
            vec![Signature::from(Ed25519Signature::new([0; 32], [0; 64]))]
        )
        .is_ok()
    );
}

#[test]
fn new_invalid_no_signature() {
    assert!(matches!(
        MilestonePayload::new(
            MilestoneEssence::new(
                MilestoneIndex(0),
                0,
                protocol_parameters().protocol_version(),
                rand_milestone_id(),
                rand_parents(),
                rand_merkle_root(),
                rand_merkle_root(),
                vec![],
                MilestoneOptions::new(vec![]).unwrap(),
            )
            .unwrap(),
            vec![]
        ),
        Err(Error::MilestoneInvalidSignatureCount(TryIntoBoundedU8Error::Invalid(0)))
    ));
}

#[test]
fn new_invalid_too_many_signatures() {
    assert!(matches!(
        MilestonePayload::new(
            MilestoneEssence::new(
                MilestoneIndex(0),
                0,
                protocol_parameters().protocol_version(),
                rand_milestone_id(),
                rand_parents(),
                rand_merkle_root(),
                rand_merkle_root(),
                vec![],
                MilestoneOptions::new(vec![]).unwrap(),
            )
            .unwrap(),
            vec![Signature::from(Ed25519Signature::new([0; 32], [0; 64])); 300]
        ),
        Err(Error::MilestoneInvalidSignatureCount(TryIntoBoundedU8Error::Truncated(
            300
        )))
    ));
}

#[test]
fn packed_len() {
    let ms = MilestonePayload::new(
        MilestoneEssence::new(
            MilestoneIndex(0),
            0,
            protocol_parameters().protocol_version(),
            rand_milestone_id(),
            Parents::new(rand_block_ids(4)).unwrap(),
            rand_merkle_root(),
            rand_merkle_root(),
            vec![0x2a, 0x2a, 0x2a, 0x2a, 0x2a],
            MilestoneOptions::new(vec![]).unwrap(),
        )
        .unwrap(),
        vec![
            Signature::from(Ed25519Signature::new([0; 32], [0; 64])),
            Signature::from(Ed25519Signature::new([1; 32], [1; 64])),
        ],
    )
    .unwrap();

    assert_eq!(ms.packed_len(), 437);
    assert_eq!(ms.pack_to_vec().len(), 437);
}

#[test]
fn pack_unpack_valid() {
    let protocol_parameters = protocol_parameters();
    let payload = MilestonePayload::new(
        MilestoneEssence::new(
            MilestoneIndex(0),
            0,
            protocol_parameters.protocol_version(),
            rand_milestone_id(),
            rand_parents(),
            rand_merkle_root(),
            rand_merkle_root(),
            vec![],
            MilestoneOptions::new(vec![]).unwrap(),
        )
        .unwrap(),
        vec![Signature::from(Ed25519Signature::new([0; 32], [0; 64]))],
    )
    .unwrap();

    let packed = payload.pack_to_vec();

    assert_eq!(payload.packed_len(), packed.len());
    assert_eq!(
        payload,
        PackableExt::unpack_verified(&mut packed.as_slice(), &protocol_parameters).unwrap()
    )
}

#[test]
fn getters() {
    let essence = MilestoneEssence::new(
        rand_milestone_index(),
        rand_number::<u32>(),
        protocol_parameters().protocol_version(),
        rand_milestone_id(),
        rand_parents(),
        rand_merkle_root(),
        rand_merkle_root(),
        vec![],
        MilestoneOptions::new(vec![]).unwrap(),
    )
    .unwrap();
    let signatures = vec![Signature::from(Ed25519Signature::new([0; 32], [0; 64]))];
    let milestone = MilestonePayload::new(essence.clone(), signatures.clone()).unwrap();

    assert_eq!(essence, *milestone.essence());

    assert_eq!(signatures.len(), milestone.signatures().len());
    for (s1, s2) in signatures.iter().zip(milestone.signatures()) {
        assert_eq!(s1, s2);
    }
}