ckb-light-client-protocol-server 0.111.0-rc8

Server-side implementation for CKB light client protocol.
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

use std::collections::HashSet;

use ckb_network::{CKBProtocolHandler, PeerIndex, SupportProtocols};
use ckb_types::{h256, packed, prelude::*};

use crate::tests::{
    prelude::*,
    utils::{MockChain, MockNetworkContext},
};

#[tokio::test(flavor = "multi_thread")]
async fn get_transactions_proof_with_missing_txs() {
    let chain = MockChain::new();
    let nc = MockNetworkContext::new(SupportProtocols::LightClient);

    chain.mine_to(20);

    let shared = chain.shared();

    let tx1 = chain.get_cellbase_as_input(12);
    let block_contains_tx1 = {
        chain.mine_block(|block| {
            let ids = vec![tx1.proposal_short_id()];
            block.as_advanced_builder().proposals(ids).build()
        });
        chain.mine_blocks(1);
        let num =
            chain.mine_block(|block| block.as_advanced_builder().transaction(tx1.clone()).build());
        chain.mine_blocks(1);
        shared.snapshot().get_block_by_number(num).unwrap()
    };

    let base_header = shared.snapshot().tip_header().to_owned();
    let end_block_number = 40;

    let tx2 = chain.get_cellbase_as_input(13);

    // Spend tx2
    chain.mine_block(|block| {
        let ids = vec![tx2.proposal_short_id()];
        block.as_advanced_builder().proposals(ids).build()
    });
    chain.mine_blocks(1);
    chain.mine_block(|block| block.as_advanced_builder().transaction(tx2.clone()).build());
    chain.mine_to(end_block_number);

    // Rollback
    let mut detached_proposal_ids = HashSet::default();
    detached_proposal_ids.insert(tx2.proposal_short_id());
    chain.rollback_to(base_header.number(), detached_proposal_ids);

    let block_start_number = chain.mine_block(|block| {
        let cellbase = block.transactions().get(0).unwrap();
        block
            .as_advanced_builder()
            .set_transactions(vec![cellbase.into_view()])
            .build()
    });
    assert_eq!(block_start_number, base_header.number() + 1);
    for _ in (base_header.number() + 2)..=end_block_number {
        let _ = chain.mine_block(|block| {
            let cellbase = block.transactions().get(0).unwrap();
            block
                .as_advanced_builder()
                .set_transactions(vec![cellbase.into_view()])
                .build()
        });
    }
    chain.mine_to(end_block_number);

    let tx3_hash = h256!("0x1");

    let expected_missing_tx_hashes = vec![tx2.hash(), tx3_hash.pack()];

    let snapshot = chain.shared().snapshot();

    for num in (base_header.number() + 1)..=end_block_number {
        let new_block = snapshot.get_block_by_number(num).unwrap();
        assert_eq!(new_block.transactions().len(), 1);
    }

    let mut protocol = chain.create_light_client_protocol();

    let data = {
        let content = packed::GetTransactionsProof::new_builder()
            .last_hash(snapshot.tip_header().hash())
            .tx_hashes(vec![tx1.hash(), tx2.hash(), tx3_hash.pack()].pack())
            .build();
        packed::LightClientMessage::new_builder()
            .set(content)
            .build()
    }
    .as_bytes();

    assert!(nc.sent_messages().borrow().is_empty());

    let peer_index = PeerIndex::new(1);
    protocol.received(nc.context(), peer_index, data).await;

    assert!(nc.not_banned(peer_index));

    assert_eq!(nc.sent_messages().borrow().len(), 1);

    let data = &nc.sent_messages().borrow()[0].2;
    let message = packed::LightClientMessageReader::new_unchecked(data);
    let content = if let packed::LightClientMessageUnionReader::SendTransactionsProof(content) =
        message.to_enum()
    {
        content
    } else {
        panic!("unexpected message");
    }
    .to_entity();
    assert_eq!(content.filtered_blocks().len(), 1);
    assert_eq!(content.missing_tx_hashes().len(), 2);
    assert_eq!(
        content
            .filtered_blocks()
            .get(0)
            .unwrap()
            .header()
            .calc_header_hash(),
        block_contains_tx1.hash()
    );
    let missing_tx_hashes = content
        .missing_tx_hashes()
        .into_iter()
        .collect::<HashSet<_>>();
    for hash in &expected_missing_tx_hashes {
        assert!(missing_tx_hashes.contains(hash));
    }
}