ckb-testkit 0.0.1

ckb testkit
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

//! A set of functions used to construct network messages.
use ckb_types::{
    core::{Cycle, TransactionView},
    packed,
    prelude::*,
};
use p2p::multiaddr::Multiaddr;

pub fn build_identify_message(
    network_identifier: &str,
    client_version: &str,
    listening_addresses: Vec<Multiaddr>,
    observed_address: Multiaddr,
) -> packed::IdentifyMessage {
    let identify_self_defined_payload = packed::Identify::new_builder()
        .name(network_identifier.pack())
        .client_version(client_version.pack())
        .flag({
            // https://github.com/nervosnetwork/ckb/blob/3f89ae6dd2e0fd86b899b0c37dbe11864dc16544/network/src/protocols/identify/mod.rs#L604
            const FLAG_FULL_NODE: u64 = 1;
            FLAG_FULL_NODE.pack()
        })
        .build();
    packed::IdentifyMessage::new_builder()
        .identify({
            packed::Bytes::new_builder()
                .set(
                    identify_self_defined_payload
                        .as_bytes()
                        .to_vec()
                        .into_iter()
                        .map(Into::into)
                        .collect(),
                )
                .build()
        })
        .listen_addrs({
            let to_vec = listening_addresses
                .into_iter()
                .map(|addr| packed::Address::from_slice(&addr.to_vec()).unwrap())
                .collect::<Vec<_>>();
            packed::AddressVec::new_builder().set(to_vec).build()
        })
        .observed_addr({
            let byte_vec = observed_address
                .to_vec()
                .into_iter()
                .map(Into::into)
                .collect();
            let bytes = packed::Bytes::new_builder().set(byte_vec).build();
            packed::Address::new_builder().bytes(bytes).build()
        })
        .build()
}

pub fn build_relay_transaction(
    transaction: &TransactionView,
    cycles: Cycle,
) -> packed::RelayMessage {
    let relay_tx = packed::RelayTransaction::new_builder()
        .transaction(transaction.data())
        .cycles(cycles.pack())
        .build();
    let relay_tx_vec = packed::RelayTransactionVec::new_builder()
        .push(relay_tx)
        .build();
    let relay_txs = packed::RelayTransactions::new_builder()
        .transactions(relay_tx_vec)
        .build();
    packed::RelayMessage::new_builder().set(relay_txs).build()
}

pub fn build_relay_transaction_hashes(hashes: Vec<packed::Byte32>) -> packed::RelayMessage {
    let hashes = packed::Byte32Vec::new_builder().set(hashes).build();
    let relay_txs_hashes = packed::RelayTransactionHashes::new_builder()
        .tx_hashes(hashes)
        .build();
    packed::RelayMessage::new_builder()
        .set(relay_txs_hashes)
        .build()
}

pub fn build_discovery_get_nodes(
    listening_port: Option<u16>,
    max_nodes: u32,
    self_defined_flag: u32,
) -> packed::DiscoveryMessage {
    let discovery_payload = packed::DiscoveryPayload::new_builder()
        .set(
            packed::GetNodes::new_builder()
                .listen_port({
                    match listening_port {
                        None => packed::PortOpt::default(),
                        Some(port) => packed::PortOpt::new_builder()
                            .set(Some({
                                packed::Uint16::from_slice(&port.to_le_bytes()).unwrap()
                            }))
                            .build(),
                    }
                })
                .count(max_nodes.pack())
                .version(self_defined_flag.pack())
                .build(),
        )
        .build();
    packed::DiscoveryMessage::new_builder()
        .payload(discovery_payload)
        .build()
}

pub fn build_discovery_nodes(
    active_push: bool,
    addresses: Vec<Multiaddr>,
) -> packed::DiscoveryMessage {
    let nodes = addresses
        .into_iter()
        .map(|address| {
            let bytes = packed::Bytes::new_builder()
                .set(address.to_vec().into_iter().map(Into::into).collect())
                .build();
            packed::Node::new_builder()
                .addresses(vec![bytes].pack())
                .build()
        })
        .collect::<Vec<_>>();
    let discovery_payload = packed::DiscoveryPayload::new_builder()
        .set(
            packed::Nodes::new_builder()
                .announce(active_push.pack())
                .items(packed::NodeVec::new_builder().set(nodes).build())
                .build(),
        )
        .build();
    packed::DiscoveryMessage::new_builder()
        .payload(discovery_payload)
        .build()
}