18097567115

Committed 29 Sep 2025 12:50PM UTC coverage: 58.554% (-2.3%) from 60.88%

Build # 18097567115

Build Type

push

github

Committed by

web-flow

Commit Message

chore(ci): switch rust toolchain to stable (#7524)

Description
switch rust toolchain to stable

Motivation and Context
use stable rust toolchain


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Chores**
* Standardized Rust toolchain on stable across CI workflows for more
predictable builds.
* Streamlined setup by removing unnecessary components and aligning
toolchain configuration with environment variables.
  * Enabled an environment flag to improve rustup behavior during CI.
* Improved coverage workflow consistency with dynamic toolchain
selection.

* **Tests**
* Removed nightly-only requirements, simplifying test commands and
improving compatibility.
* Expanded CI triggers to include ci-* branches for better pre-merge
validation.
* Maintained existing job logic while improving reliability and
maintainability.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Run Details

66336 of 113291 relevant lines covered (58.55%)

551641.45 hits per line

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

73.53

/base_layer/common_types/src/types/fixed_hash.rs

//  Copyright 2022. The Tari Project
//
//  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
//  following conditions are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
//  disclaimer.
//
//  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
//  following disclaimer in the documentation and/or other materials provided with the distribution.
//
//  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
//  products derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
//  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
//  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use std::{
    convert::TryFrom,
    fmt::{Display, Formatter},
    ops::{Deref, DerefMut},
};

use borsh::{BorshDeserialize, BorshSerialize};
use digest::{consts::U32, generic_array};
use serde::{Deserialize, Serialize};
use tari_utilities::hex::{Hex, HexError};
use utoipa::ToSchema;

const ZERO_HASH: [u8; FixedHash::byte_size()] = [0u8; FixedHash::byte_size()];

#[derive(thiserror::Error, Debug)]
#[error("Invalid size")]
pub struct FixedHashSizeError;

#[derive(
    Clone,
    Copy,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Debug,
    Default,
    Hash,
    Deserialize,
    Serialize,
    BorshSerialize,
    BorshDeserialize,
    ToSchema,
)]
#[serde(transparent)]
pub struct FixedHash([u8; FixedHash::byte_size()]);

impl FixedHash {
    pub const fn new(hash: [u8; FixedHash::byte_size()]) -> Self {
        Self(hash)
    }

    pub const fn byte_size() -> usize {
        32
    }

    pub const fn zero() -> Self {
        Self(ZERO_HASH)
    }

    pub const fn into_array(self) -> [u8; 32] {
        self.0
    }

    pub fn as_slice(&self) -> &[u8] {
        &self.0
    }
}

impl From<[u8; FixedHash::byte_size()]> for FixedHash {
    fn from(hash: [u8; FixedHash::byte_size()]) -> Self {
        Self(hash)
    }
}

impl TryFrom<Vec<u8>> for FixedHash {
    type Error = FixedHashSizeError;

    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
        TryFrom::try_from(value.as_slice())
    }
}

impl TryFrom<&[u8]> for FixedHash {
    type Error = FixedHashSizeError;

    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
        if bytes.len() != FixedHash::byte_size() {
            return Err(FixedHashSizeError);
        }

        let mut buf = [0u8; FixedHash::byte_size()];
        buf.copy_from_slice(bytes);
        Ok(Self(buf))
    }
}

impl From<generic_array::GenericArray<u8, U32>> for FixedHash {
    fn from(hash: generic_array::GenericArray<u8, U32>) -> Self {
        Self(hash.into())
    }
}

impl PartialEq<[u8]> for FixedHash {
    fn eq(&self, other: &[u8]) -> bool {
        self.0[..].eq(other)
    }
}

impl PartialEq<FixedHash> for [u8] {
    fn eq(&self, other: &FixedHash) -> bool {
        self[..].eq(&other.0)
    }
}

impl PartialEq<Vec<u8>> for FixedHash {
    fn eq(&self, other: &Vec<u8>) -> bool {
        self == other.as_slice()
    }
}
impl PartialEq<FixedHash> for Vec<u8> {
    fn eq(&self, other: &FixedHash) -> bool {
        self == other.as_slice()
    }
}

impl AsRef<[u8]> for FixedHash {
    fn as_ref(&self) -> &[u8] {
        self.as_slice()
    }
}

impl Hex for FixedHash {
    fn from_hex(hex: &str) -> Result<Self, HexError>
    where Self: Sized {
        let hash = <[u8; FixedHash::byte_size()] as Hex>::from_hex(hex)?;
        Ok(Self(hash))
    }

    fn to_hex(&self) -> String {
        self.0.to_hex()
    }
}

impl Deref for FixedHash {
    type Target = [u8; FixedHash::byte_size()];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for FixedHash {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl Display for FixedHash {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        for b in self.0 {
            write!(f, "{b:02x}")?;
        }
        Ok(())
    }
}

1	// Copyright 2022. The Tari Project
2	//
3	// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
4	// following conditions are met:
5	//
6	// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
7	// disclaimer.
8	//
9	// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
10	// following disclaimer in the documentation and/or other materials provided with the distribution.
11	//
12	// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
13	// products derived from this software without specific prior written permission.
14	//
15	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
16	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
18	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
20	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
21	// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
23	use std::{
24	convert::TryFrom,
25	fmt::{Display, Formatter},
26	ops::{Deref, DerefMut},
27	};
28
29	use borsh::{BorshDeserialize, BorshSerialize};
30	use digest::{consts::U32, generic_array};
31	use serde::{Deserialize, Serialize};
32	use tari_utilities::hex::{Hex, HexError};
33	use utoipa::ToSchema;
34
35	const ZERO_HASH: [u8; FixedHash::byte_size()] = [0u8; FixedHash::byte_size()];
36
37	#[derive(thiserror::Error, Debug)]
38	#[error("Invalid size")]
39	pub struct FixedHashSizeError;
40
41	#[derive(
42	Clone,
43	Copy,
44	PartialEq,
45	Eq,
46	PartialOrd,
47	Ord,
48	Debug,
49	Default,
50	Hash,
51	Deserialize,
52	Serialize,
53	BorshSerialize,	×
54	BorshDeserialize,	×
55	ToSchema,
56	)]
57	#[serde(transparent)]
58	pub struct FixedHash([u8; FixedHash::byte_size()]);
59
60	impl FixedHash {
61	pub const fn new(hash: [u8; FixedHash::byte_size()]) -> Self {	×
62	Self(hash)	×
63	}	×
64
65	pub const fn byte_size() -> usize {	1,109✔
66	32	1,109✔
67	}	1,109✔
68
69	pub const fn zero() -> Self {	11,128✔
70	Self(ZERO_HASH)	11,128✔
71	}	11,128✔
72
73	pub const fn into_array(self) -> [u8; 32] {	4✔
74	self.0	4✔
75	}	4✔
76
77	pub fn as_slice(&self) -> &[u8] {	26,311✔
78	&self.0	26,311✔
79	}	26,311✔
80	}
81
82	impl From<[u8; FixedHash::byte_size()]> for FixedHash {
83	fn from(hash: [u8; FixedHash::byte_size()]) -> Self {	12,895✔
84	Self(hash)	12,895✔
85	}	12,895✔
86	}
87
88	impl TryFrom<Vec<u8>> for FixedHash {
89	type Error = FixedHashSizeError;
90
91	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {	346✔
92	TryFrom::try_from(value.as_slice())	346✔
93	}	346✔
94	}
95
96	impl TryFrom<&[u8]> for FixedHash {
97	type Error = FixedHashSizeError;
98
99	fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {	464✔
100	if bytes.len() != FixedHash::byte_size() {	464✔
101	return Err(FixedHashSizeError);	×
102	}	464✔
103
104	let mut buf = [0u8; FixedHash::byte_size()];	464✔
105	buf.copy_from_slice(bytes);	464✔
106	Ok(Self(buf))	464✔
107	}	464✔
108	}
109
110	impl From<generic_array::GenericArray<u8, U32>> for FixedHash {
111	fn from(hash: generic_array::GenericArray<u8, U32>) -> Self {	41,761✔
112	Self(hash.into())	41,761✔
113	}	41,761✔
114	}
115
116	impl PartialEq<[u8]> for FixedHash {
117	fn eq(&self, other: &[u8]) -> bool {	×
118	self.0[..].eq(other)	×
119	}	×
120	}
121
122	impl PartialEq<FixedHash> for [u8] {
123	fn eq(&self, other: &FixedHash) -> bool {	×
124	self[..].eq(&other.0)	×
125	}	×
126	}
127
128	impl PartialEq<Vec<u8>> for FixedHash {
129	fn eq(&self, other: &Vec<u8>) -> bool {	×
130	self == other.as_slice()	×
131	}	×
132	}
133	impl PartialEq<FixedHash> for Vec<u8> {
134	fn eq(&self, other: &FixedHash) -> bool {	×
135	self == other.as_slice()	×
136	}	×
137	}
138
139	impl AsRef<[u8]> for FixedHash {
140	fn as_ref(&self) -> &[u8] {	205✔
141	self.as_slice()	205✔
142	}	205✔
143	}
144
145	impl Hex for FixedHash {
146	fn from_hex(hex: &str) -> Result<Self, HexError>	585✔
147	where Self: Sized {	585✔
148	let hash = <[u8; FixedHash::byte_size()] as Hex>::from_hex(hex)?;	585✔
149	Ok(Self(hash))	585✔
150	}	585✔
151
152	fn to_hex(&self) -> String {	123✔
153	self.0.to_hex()	123✔
154	}	123✔
155	}
156
157	impl Deref for FixedHash {
158	type Target = [u8; FixedHash::byte_size()];
159
160	fn deref(&self) -> &Self::Target {	14,753✔
161	&self.0	14,753✔
162	}	14,753✔
163	}
164
165	impl DerefMut for FixedHash {
166	fn deref_mut(&mut self) -> &mut Self::Target {	1✔
167	&mut self.0	1✔
168	}	1✔
169	}
170
171	impl Display for FixedHash {
172	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {	53✔
173	for b in self.0 {	1,749✔
174	write!(f, "{b:02x}")?;	1,696✔
175	}
176	Ok(())	53✔
177	}	53✔
178	}

tari-project / tari / 18097567115

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