14565525798

Committed 21 Apr 2025 01:39AM UTC coverage: 67.072% (-17.5%) from 84.616%

Build # 14565525798

Build Type

push

github

Committed by

Chik-Network

Commit Message

update 0.22.0

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

2902 existing lines in 63 files now uncovered.

11097 of 16545 relevant lines covered (67.07%)

799466.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/crates/chik-protocol/src/full_node_protocol.rs

use chik_streamable_macro::streamable;

use crate::EndOfSubSlotBundle;
use crate::FullBlock;
use crate::SpendBundle;
use crate::TimestampedPeerInfo;
use crate::UnfinishedBlock;
use crate::VDFInfo;
use crate::VDFProof;
use crate::WeightProof;
use crate::{Bytes, Bytes32};

#[streamable(message)]
pub struct NewPeak {
    header_hash: Bytes32,
    height: u32,
    weight: u128,
    fork_point_with_previous_peak: u32,
    unfinished_reward_block_hash: Bytes32,
}

#[streamable(message)]
pub struct NewTransaction {
    transaction_id: Bytes32,
    cost: u64,
    fees: u64,
}

#[streamable(message)]
pub struct RequestTransaction {
    transaction_id: Bytes32,
}

#[streamable(message)]
pub struct RespondTransaction {
    transaction: SpendBundle,
}

#[streamable(message)]
pub struct RequestProofOfWeight {
    total_number_of_blocks: u32,
    tip: Bytes32,
}

#[streamable(message)]
pub struct RespondProofOfWeight {
    wp: WeightProof,
    tip: Bytes32,
}

#[streamable(message)]
pub struct RequestBlock {
    height: u32,
    include_transaction_block: bool,
}

#[streamable(message)]
pub struct RejectBlock {
    height: u32,
}

#[streamable(message)]
pub struct RequestBlocks {
    start_height: u32,
    end_height: u32,
    include_transaction_block: bool,
}

#[streamable(message)]
pub struct RespondBlocks {
    start_height: u32,
    end_height: u32,
    blocks: Vec<FullBlock>,
}

#[streamable(message)]
pub struct RejectBlocks {
    start_height: u32,
    end_height: u32,
}

#[streamable(message)]
pub struct RespondBlock {
    block: FullBlock,
}

#[streamable(message)]
pub struct NewUnfinishedBlock {
    unfinished_reward_hash: Bytes32,
}

#[streamable(message)]
pub struct RequestUnfinishedBlock {
    unfinished_reward_hash: Bytes32,
}

#[streamable(message)]
pub struct RespondUnfinishedBlock {
    unfinished_block: UnfinishedBlock,
}

#[streamable(message)]
pub struct NewSignagePointOrEndOfSubSlot {
    prev_challenge_hash: Option<Bytes32>,
    challenge_hash: Bytes32,
    index_from_challenge: u8,
    last_rc_infusion: Bytes32,
}

#[streamable(message)]
pub struct RequestSignagePointOrEndOfSubSlot {
    challenge_hash: Bytes32,
    index_from_challenge: u8,
    last_rc_infusion: Bytes32,
}

#[streamable(message)]
pub struct RespondSignagePoint {
    index_from_challenge: u8,
    challenge_chain_vdf: VDFInfo,
    challenge_chain_proof: VDFProof,
    reward_chain_vdf: VDFInfo,
    reward_chain_proof: VDFProof,
}

#[streamable(message)]
pub struct RespondEndOfSubSlot {
    end_of_slot_bundle: EndOfSubSlotBundle,
}

#[streamable(message)]
pub struct RequestMempoolTransactions {
    filter: Bytes,
}

#[streamable(message)]
pub struct NewCompactVDF {
    height: u32,
    header_hash: Bytes32,
    field_vdf: u8,
    vdf_info: VDFInfo,
}

#[streamable(message)]
pub struct RequestCompactVDF {
    height: u32,
    header_hash: Bytes32,
    field_vdf: u8,
    vdf_info: VDFInfo,
}

#[streamable(message)]
pub struct RespondCompactVDF {
    height: u32,
    header_hash: Bytes32,
    field_vdf: u8,
    vdf_info: VDFInfo,
    vdf_proof: VDFProof,
}

#[streamable(message)]
pub struct RequestPeers {}

#[streamable(message)]
pub struct RespondPeers {
    peer_list: Vec<TimestampedPeerInfo>,
}

#[streamable(message)]
pub struct NewUnfinishedBlock2 {
    unfinished_reward_hash: Bytes32,
    foliage_hash: Option<Bytes32>,
}

#[streamable(message)]
pub struct RequestUnfinishedBlock2 {
    unfinished_reward_hash: Bytes32,
    foliage_hash: Option<Bytes32>,
}

1	use chik_streamable_macro::streamable;
2
3	use crate::EndOfSubSlotBundle;
4	use crate::FullBlock;
5	use crate::SpendBundle;
6	use crate::TimestampedPeerInfo;
7	use crate::UnfinishedBlock;
8	use crate::VDFInfo;
9	use crate::VDFProof;
10	use crate::WeightProof;
11	use crate::{Bytes, Bytes32};
12
UNCOV 13	#[streamable(message)]	×
14	pub struct NewPeak {
15	header_hash: Bytes32,
16	height: u32,
17	weight: u128,
18	fork_point_with_previous_peak: u32,
19	unfinished_reward_block_hash: Bytes32,
20	}
21
UNCOV 22	#[streamable(message)]	×
23	pub struct NewTransaction {
24	transaction_id: Bytes32,
25	cost: u64,
26	fees: u64,
27	}
28
UNCOV 29	#[streamable(message)]	×
30	pub struct RequestTransaction {
31	transaction_id: Bytes32,
32	}
33
UNCOV 34	#[streamable(message)]	×
35	pub struct RespondTransaction {
36	transaction: SpendBundle,
37	}
38
UNCOV 39	#[streamable(message)]	×
40	pub struct RequestProofOfWeight {
41	total_number_of_blocks: u32,
42	tip: Bytes32,
43	}
44
UNCOV 45	#[streamable(message)]	×
46	pub struct RespondProofOfWeight {
47	wp: WeightProof,
48	tip: Bytes32,
49	}
50
UNCOV 51	#[streamable(message)]	×
52	pub struct RequestBlock {
53	height: u32,
54	include_transaction_block: bool,
55	}
56
UNCOV 57	#[streamable(message)]	×
58	pub struct RejectBlock {
59	height: u32,
60	}
61
UNCOV 62	#[streamable(message)]	×
63	pub struct RequestBlocks {
64	start_height: u32,
65	end_height: u32,
66	include_transaction_block: bool,
67	}
68
UNCOV 69	#[streamable(message)]	×
70	pub struct RespondBlocks {
71	start_height: u32,
72	end_height: u32,
73	blocks: Vec<FullBlock>,
74	}
75
UNCOV 76	#[streamable(message)]	×
77	pub struct RejectBlocks {
78	start_height: u32,
79	end_height: u32,
80	}
81
UNCOV 82	#[streamable(message)]	×
83	pub struct RespondBlock {
84	block: FullBlock,
85	}
86
UNCOV 87	#[streamable(message)]	×
88	pub struct NewUnfinishedBlock {
89	unfinished_reward_hash: Bytes32,
90	}
91
UNCOV 92	#[streamable(message)]	×
93	pub struct RequestUnfinishedBlock {
94	unfinished_reward_hash: Bytes32,
95	}
96
UNCOV 97	#[streamable(message)]	×
98	pub struct RespondUnfinishedBlock {
99	unfinished_block: UnfinishedBlock,
100	}
101
UNCOV 102	#[streamable(message)]	×
103	pub struct NewSignagePointOrEndOfSubSlot {
104	prev_challenge_hash: Option<Bytes32>,
105	challenge_hash: Bytes32,
106	index_from_challenge: u8,
107	last_rc_infusion: Bytes32,
108	}
109
UNCOV 110	#[streamable(message)]	×
111	pub struct RequestSignagePointOrEndOfSubSlot {
112	challenge_hash: Bytes32,
113	index_from_challenge: u8,
114	last_rc_infusion: Bytes32,
115	}
116
UNCOV 117	#[streamable(message)]	×
118	pub struct RespondSignagePoint {
119	index_from_challenge: u8,
120	challenge_chain_vdf: VDFInfo,
121	challenge_chain_proof: VDFProof,
122	reward_chain_vdf: VDFInfo,
123	reward_chain_proof: VDFProof,
124	}
125
UNCOV 126	#[streamable(message)]	×
127	pub struct RespondEndOfSubSlot {
128	end_of_slot_bundle: EndOfSubSlotBundle,
129	}
130
UNCOV 131	#[streamable(message)]	×
132	pub struct RequestMempoolTransactions {
133	filter: Bytes,
134	}
135
UNCOV 136	#[streamable(message)]	×
137	pub struct NewCompactVDF {
138	height: u32,
139	header_hash: Bytes32,
140	field_vdf: u8,
141	vdf_info: VDFInfo,
142	}
143
UNCOV 144	#[streamable(message)]	×
145	pub struct RequestCompactVDF {
146	height: u32,
147	header_hash: Bytes32,
148	field_vdf: u8,
149	vdf_info: VDFInfo,
150	}
151
UNCOV 152	#[streamable(message)]	×
153	pub struct RespondCompactVDF {
154	height: u32,
155	header_hash: Bytes32,
156	field_vdf: u8,
157	vdf_info: VDFInfo,
158	vdf_proof: VDFProof,
159	}
160
UNCOV 161	#[streamable(message)]	×
162	pub struct RequestPeers {}
163
UNCOV 164	#[streamable(message)]	×
165	pub struct RespondPeers {
166	peer_list: Vec<TimestampedPeerInfo>,
167	}
168
UNCOV 169	#[streamable(message)]	×
170	pub struct NewUnfinishedBlock2 {
171	unfinished_reward_hash: Bytes32,
172	foliage_hash: Option<Bytes32>,
173	}
174
UNCOV 175	#[streamable(message)]	×
176	pub struct RequestUnfinishedBlock2 {
177	unfinished_reward_hash: Bytes32,
178	foliage_hash: Option<Bytes32>,
179	}

Chik-Network / chik_rs / 14565525798

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous