ckb-sync 1.3.0

The ckb sync/relayer protocols implementation
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

use crate::Status;
use crate::relayer::block_proposal_process::BlockProposalProcess;
use crate::relayer::tests::helper::{build_chain, new_transaction};
use ckb_types::packed::{self, ProposalShortId};
use ckb_types::prelude::*;

#[test]
fn test_no_unknown() {
    let (_chain, relayer, always_success_out_point) = build_chain(5);
    let transaction = new_transaction(&relayer, 1, &always_success_out_point);

    let transactions = vec![transaction.clone()];

    // known tx
    {
        relayer.shared.state().mark_as_known_tx(transaction.hash());
    }
    let content = packed::BlockProposal::new_builder()
        .transactions(
            transactions
                .into_iter()
                .map(|tx| tx.data())
                .collect::<Vec<_>>(),
        )
        .build();

    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    let process = BlockProposalProcess::new(content.as_reader(), &relayer);
    assert_eq!(rt.block_on(process.execute()), Status::ignored());
}

#[test]
fn test_no_asked() {
    let (_chain, relayer, always_success_out_point) = build_chain(5);
    let transaction = new_transaction(&relayer, 1, &always_success_out_point);

    let transactions = vec![transaction.clone()];

    let content = packed::BlockProposal::new_builder()
        .transactions(
            transactions
                .into_iter()
                .map(|tx| tx.data())
                .collect::<Vec<_>>(),
        )
        .build();

    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    let process = BlockProposalProcess::new(content.as_reader(), &relayer);
    assert_eq!(rt.block_on(process.execute()), Status::ignored());

    let known = relayer.shared.state().already_known_tx(&transaction.hash());
    assert!(!known);
}

#[test]
fn test_ok() {
    let (_chain, relayer, always_success_out_point) = build_chain(5);
    let transaction = new_transaction(&relayer, 1, &always_success_out_point);
    let transactions = vec![transaction.clone()];
    let proposals: Vec<ProposalShortId> = transactions
        .iter()
        .map(|tx| tx.proposal_short_id())
        .collect();

    // Before asked proposals
    {
        relayer
            .shared
            .state()
            .insert_inflight_proposals(proposals, 1);
    }

    let content = packed::BlockProposal::new_builder()
        .transactions(
            transactions
                .into_iter()
                .map(|tx| tx.data())
                .collect::<Vec<_>>(),
        )
        .build();

    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    let process = BlockProposalProcess::new(content.as_reader(), &relayer);
    assert_eq!(rt.block_on(process.execute()), Status::ok());

    let known = relayer.shared.state().already_known_tx(&transaction.hash());
    assert!(known);
}

#[test]
fn test_clear_expired_inflight_proposals() {
    // mark the inflight proposals as block number 2, the default farthest proposal window is 10, it will be expired and ignored
    let (_chain, relayer, always_success_out_point) = build_chain(13);
    let transaction = new_transaction(&relayer, 1, &always_success_out_point);
    let transactions = vec![transaction];
    let proposals: Vec<ProposalShortId> = transactions
        .iter()
        .map(|tx| tx.proposal_short_id())
        .collect();

    {
        relayer
            .shared
            .state()
            .insert_inflight_proposals(proposals, 2);
    }

    let content = packed::BlockProposal::new_builder()
        .transactions(
            transactions
                .into_iter()
                .map(|tx| tx.data())
                .collect::<Vec<_>>(),
        )
        .build();

    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    let process = BlockProposalProcess::new(content.as_reader(), &relayer);
    assert_eq!(rt.block_on(process.execute()), Status::ignored());
}