13811622200

Committed 12 Mar 2025 12:40PM UTC coverage: 84.013% (-0.2%) from 84.19%

Build # 13811622200

Build Type

push

github

Committed by

jan-ferdinand

Commit Message

chore: Make clippy more pedantic

changelog: ignore

Run Details

455 of 580 new or added lines in 91 files covered. (78.45%)

116 existing lines in 17 files now uncovered.

50424 of 60019 relevant lines covered (84.01%)

175779.42 hits per line

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

92.11

/src/models/blockchain/block/block_kernel.rs

use get_size2::GetSize;
use serde::Deserialize;
use serde::Serialize;
use strum::EnumCount;
use tasm_lib::twenty_first::math::b_field_element::BFieldElement;
use tasm_lib::twenty_first::math::bfield_codec::BFieldCodec;

use super::block_appendix::BlockAppendix;
use super::block_body::BlockBody;
use super::block_header::BlockHeader;
use crate::models::proof_abstractions::mast_hash::HasDiscriminant;
use crate::models::proof_abstractions::mast_hash::MastHash;

/// The kernel of a block contains all data that is not proof data
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, BFieldCodec, GetSize)]
pub struct BlockKernel {
    pub header: BlockHeader,
    pub body: BlockBody,

    pub(crate) appendix: BlockAppendix,
}

impl BlockKernel {
    pub(crate) fn new(header: BlockHeader, body: BlockBody, appendix: BlockAppendix) -> Self {
        Self {
            header,
            body,
            appendix,
        }
    }
}

#[derive(Debug, Copy, Clone, EnumCount)]
pub enum BlockKernelField {
    Header,
    Body,
    Appendix,
}

impl HasDiscriminant for BlockKernelField {
    fn discriminant(&self) -> usize {
        *self as usize
    }
}

impl MastHash for BlockKernel {
    type FieldEnum = BlockKernelField;

    fn mast_sequences(&self) -> Vec<Vec<BFieldElement>> {
        let sequences = vec![
            self.header.mast_hash().encode(),
            self.body.mast_hash().encode(),
            self.appendix.encode(),
        ];
        sequences
    }
}

#[cfg(test)]
mod tests {
    use tasm_lib::prelude::Digest;
    use tasm_lib::prelude::Tip5;
    use tasm_lib::twenty_first::prelude::MerkleTree;

    use super::*;
    use crate::models::blockchain::block::validity::block_primitive_witness::test::deterministic_block_primitive_witness;
    use crate::models::blockchain::block::Block;
    use crate::models::proof_abstractions::timestamp::Timestamp;

    #[test]
    fn kernel_hash_calculation() {
        let block_primitive_witness = deterministic_block_primitive_witness();
        let invalid_block = Block::block_template_invalid_proof_from_witness(
            block_primitive_witness,
            Timestamp::now(),
            None,
        );
        let calculated = invalid_block.hash();
        let merkle_tree_leafs = [
            Tip5::hash_varlen(&invalid_block.header().mast_hash().encode()),
            Tip5::hash_varlen(&invalid_block.body().mast_hash().encode()),
            Tip5::hash_varlen(&invalid_block.appendix().encode()),
            Digest::default(),
        ];

        let mt = MerkleTree::par_new(&merkle_tree_leafs).unwrap();
        let expected_root = mt.root();
        assert_eq!(expected_root, calculated);
    }
}

1	use get_size2::GetSize;
2	use serde::Deserialize;
3	use serde::Serialize;
4	use strum::EnumCount;
5	use tasm_lib::twenty_first::math::b_field_element::BFieldElement;
6	use tasm_lib::twenty_first::math::bfield_codec::BFieldCodec;
7
8	use super::block_appendix::BlockAppendix;
9	use super::block_body::BlockBody;
10	use super::block_header::BlockHeader;
11	use crate::models::proof_abstractions::mast_hash::HasDiscriminant;
12	use crate::models::proof_abstractions::mast_hash::MastHash;
13
14	/// The kernel of a block contains all data that is not proof data
15	#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, BFieldCodec, GetSize)]	64✔
16	pub struct BlockKernel {
17	pub header: BlockHeader,
18	pub body: BlockBody,
19
20	pub(crate) appendix: BlockAppendix,
21	}
22
23	impl BlockKernel {
24	pub(crate) fn new(header: BlockHeader, body: BlockBody, appendix: BlockAppendix) -> Self {	2,235✔
25	Self {	2,235✔
26	header,	2,235✔
27	body,	2,235✔
28	appendix,	2,235✔
29	}	2,235✔
30	}	2,235✔
31	}
32
33	#[derive(Debug, Copy, Clone, EnumCount)]
34	pub enum BlockKernelField {
35	Header,
36	Body,
37	Appendix,
38	}
39
40	impl HasDiscriminant for BlockKernelField {
41	fn discriminant(&self) -> usize {	×
NEW 42	*self as usize	×
43	}	×
44	}
45
46	impl MastHash for BlockKernel {
47	type FieldEnum = BlockKernelField;
48
49	fn mast_sequences(&self) -> Vec<Vec<BFieldElement>> {	441,838✔
50	let sequences = vec![	441,838✔
51	self.header.mast_hash().encode(),	441,838✔
52	self.body.mast_hash().encode(),	441,838✔
53	self.appendix.encode(),	441,838✔
54	];	441,838✔
55	sequences	441,838✔
56	}	441,838✔
57	}
58
59	#[cfg(test)]
60	mod tests {
61	use tasm_lib::prelude::Digest;
62	use tasm_lib::prelude::Tip5;
63	use tasm_lib::twenty_first::prelude::MerkleTree;
64
65	use super::*;
66	use crate::models::blockchain::block::validity::block_primitive_witness::test::deterministic_block_primitive_witness;
67	use crate::models::blockchain::block::Block;
68	use crate::models::proof_abstractions::timestamp::Timestamp;
69
70	#[test]
71	fn kernel_hash_calculation() {	1✔
72	let block_primitive_witness = deterministic_block_primitive_witness();	1✔
73	let invalid_block = Block::block_template_invalid_proof_from_witness(	1✔
74	block_primitive_witness,	1✔
75	Timestamp::now(),	1✔
76	None,	1✔
77	);	1✔
78	let calculated = invalid_block.hash();	1✔
79	let merkle_tree_leafs = [	1✔
80	Tip5::hash_varlen(&invalid_block.header().mast_hash().encode()),	1✔
81	Tip5::hash_varlen(&invalid_block.body().mast_hash().encode()),	1✔
82	Tip5::hash_varlen(&invalid_block.appendix().encode()),	1✔
83	Digest::default(),	1✔
84	];	1✔
85		1✔
86	let mt = MerkleTree::par_new(&merkle_tree_leafs).unwrap();	1✔
87	let expected_root = mt.root();	1✔
88	assert_eq!(expected_root, calculated);	1✔
89	}	1✔
90	}

Neptune-Crypto / neptune-core / 13811622200

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