19227006544

// Copyright 2020. 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},
    str::FromStr,
};

use borsh::{BorshDeserialize, BorshSerialize};
use serde::{Deserialize, Serialize};

/// Indicates the algorithm used to mine a block
#[repr(u8)]
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Hash, Eq, BorshSerialize, BorshDeserialize)]
#[borsh(use_discriminant = true)]
pub enum PowAlgorithm {
    RandomXM = 0,
    Sha3x = 1,
    RandomXT = 2,
    Cuckaroo = 3,
}

impl PowAlgorithm {
    /// Returns true if the PoW algorithm is merged mined monero RandomX
    pub fn is_merged_mined_randomx(&self) -> bool {
        matches!(self, Self::RandomXM)
    }

    /// Returns true if the PoW algorithm is solo tari RandomX
    pub fn is_tari_randomx(&self) -> bool {
        matches!(self, Self::RandomXT)
    }

    /// Returns true if the PoW algorithm is Sha3
    pub fn is_sha3(&self) -> bool {
        matches!(self, Self::Sha3x)
    }

    /// A convenience functions that returns the PoW algorithm as a u64
    pub fn as_u64(&self) -> u64 {
        *self as u64
    }
}

impl TryFrom<u64> for PowAlgorithm {
    type Error = String;

    fn try_from(v: u64) -> Result<Self, Self::Error> {
        match v {
            0 => Ok(PowAlgorithm::RandomXM),
            1 => Ok(PowAlgorithm::Sha3x),
            2 => Ok(PowAlgorithm::RandomXT),
            3 => Ok(PowAlgorithm::Cuckaroo),
            _ => Err("Invalid PoWAlgorithm".into()),
        }
    }
}

impl FromStr for PowAlgorithm {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s_trimmed = s.replace("\"", "").replace("\'", "").replace(" ", "").to_uppercase();
        match s_trimmed.as_str() {
            "RANDOMXM" | "RANDOM_XM" | "MONERO_RANDOM_X" | "RANDOMX" | "RANDOM_X" | "RANDOMXMONERO" => {
                Ok(Self::RandomXM)
            },
            "SHA" | "SHA3" | "SHA3X" => Ok(Self::Sha3x),
            "RANDOMXT" | "RANDOM_XT" | "TARI_RANDOM_X" | "RANDOMXTARI" => Ok(Self::RandomXT),
            "CUCKAROO" | "CUCKAROO29" | "C29" => Ok(Self::Cuckaroo),
            _ => Err(anyhow::Error::msg(format!("Unknown pow algorithm type: {s}"))),
        }
    }
}

impl Display for PowAlgorithm {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> std::fmt::Result {
        let algo = match self {
            PowAlgorithm::RandomXM => "RandomXMonero",
            PowAlgorithm::Sha3x => "Sha3",
            PowAlgorithm::RandomXT => "RandomXTari",
            PowAlgorithm::Cuckaroo => "Cuckaroo",
        };
        fmt.write_str(algo)
    }
}

#[cfg(test)]
mod tests {
    use serde_json;

    use super::*;

    #[test]
    fn test_pow_algorithm_from_str_variants() {
        // Test valid variants for RandomXM
        let randomxm_variants = vec![
            "RandomXM",
            "RandomX",
            "randomx",
            "random_x",
            "randomxm",
            "RANDOM_XM",
            "monero_random_x",
        ];
        for variant in randomxm_variants {
            let algo = PowAlgorithm::from_str(variant).expect("Failed to parse RandomXM variant");
            assert_eq!(algo, PowAlgorithm::RandomXM);
        }

        // Test valid variants for Sha3x
        let sha3x_variants = vec![
            "Sha3x",
            "\"Sha3x\"",
            "\'Sha3x\'",
            "Sha 3 x",
            "sha",
            "sha3",
            "SHA3",
            "sha3X",
            "Sha3X",
            "SHA3X",
        ];
        for variant in sha3x_variants {
            let algo = PowAlgorithm::from_str(variant).expect("Failed to parse Sha3x variant");
            assert_eq!(algo, PowAlgorithm::Sha3x);
        }

        // Test valid variants for RandomXT
        let randomxt_variants = vec!["RandomXT", "randomxt", "tari_random_x", "RANDOM_XT"];
        for variant in randomxt_variants {
            let algo = PowAlgorithm::from_str(variant).expect("Failed to parse RandomXT variant");
            assert_eq!(algo, PowAlgorithm::RandomXT);
        }
    }

    #[test]
    fn test_pow_algorithm_serialization() {
        for algo in [PowAlgorithm::Sha3x, PowAlgorithm::RandomXM, PowAlgorithm::RandomXT] {
            let serialized = serde_json::to_string(&algo).expect("Failed to serialize PowAlgorithm");
            let deserialized: PowAlgorithm =
                serde_json::from_str(&serialized).expect("Failed to deserialize PowAlgorithm");
            assert_eq!(deserialized, algo);
        }
    }
}

1	// Copyright 2020. 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	use std::{
23	convert::TryFrom,
24	fmt::{Display, Formatter},
25	str::FromStr,
26	};
27
28	use borsh::{BorshDeserialize, BorshSerialize};
29	use serde::{Deserialize, Serialize};
30
31	/// Indicates the algorithm used to mine a block
32	#[repr(u8)]
33	#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Hash, Eq, BorshSerialize, BorshDeserialize)]	×
34	#[borsh(use_discriminant = true)]
35	pub enum PowAlgorithm {
36	RandomXM = 0,
37	Sha3x = 1,
38	RandomXT = 2,
39	Cuckaroo = 3,
40	}
41
42	impl PowAlgorithm {
43	/// Returns true if the PoW algorithm is merged mined monero RandomX
44	pub fn is_merged_mined_randomx(&self) -> bool {	×
45	matches!(self, Self::RandomXM)	×
46	}	×
47
48	/// Returns true if the PoW algorithm is solo tari RandomX
49	pub fn is_tari_randomx(&self) -> bool {	×
50	matches!(self, Self::RandomXT)	×
51	}	×
52
53	/// Returns true if the PoW algorithm is Sha3
54	pub fn is_sha3(&self) -> bool {	×
55	matches!(self, Self::Sha3x)	×
56	}	×
57
58	/// A convenience functions that returns the PoW algorithm as a u64
59	pub fn as_u64(&self) -> u64 {	×
60	*self as u64	×
61	}	×
62	}
63
64	impl TryFrom<u64> for PowAlgorithm {
65	type Error = String;
66
67	fn try_from(v: u64) -> Result<Self, Self::Error> {	×
68	match v {	×
69	0 => Ok(PowAlgorithm::RandomXM),	×
70	1 => Ok(PowAlgorithm::Sha3x),	×
71	2 => Ok(PowAlgorithm::RandomXT),	×
72	3 => Ok(PowAlgorithm::Cuckaroo),	×
73	_ => Err("Invalid PoWAlgorithm".into()),	×
74	}
75	}	×
76	}
77
78	impl FromStr for PowAlgorithm {
79	type Err = anyhow::Error;
80
UNCOV 81	fn from_str(s: &str) -> Result<Self, Self::Err> {	×
UNCOV 82	let s_trimmed = s.replace("\"", "").replace("\'", "").replace(" ", "").to_uppercase();	×
UNCOV 83	match s_trimmed.as_str() {	×
UNCOV 84	"RANDOMXM" \| "RANDOM_XM" \| "MONERO_RANDOM_X" \| "RANDOMX" \| "RANDOM_X" \| "RANDOMXMONERO" => {	×
UNCOV 85	Ok(Self::RandomXM)	×
86	},
UNCOV 87	"SHA" \| "SHA3" \| "SHA3X" => Ok(Self::Sha3x),	×
UNCOV 88	"RANDOMXT" \| "RANDOM_XT" \| "TARI_RANDOM_X" \| "RANDOMXTARI" => Ok(Self::RandomXT),	×
89	"CUCKAROO" \| "CUCKAROO29" \| "C29" => Ok(Self::Cuckaroo),	×
90	_ => Err(anyhow::Error::msg(format!("Unknown pow algorithm type: {s}"))),	×
91	}
UNCOV 92	}	×
93	}
94
95	impl Display for PowAlgorithm {
96	fn fmt(&self, fmt: &mut Formatter<'_>) -> std::fmt::Result {	1✔
97	let algo = match self {	1✔
98	PowAlgorithm::RandomXM => "RandomXMonero",	×
UNCOV 99	PowAlgorithm::Sha3x => "Sha3",	×
100	PowAlgorithm::RandomXT => "RandomXTari",	1✔
101	PowAlgorithm::Cuckaroo => "Cuckaroo",	×
102	};
103	fmt.write_str(algo)	1✔
104	}	1✔
105	}
106
107	#[cfg(test)]
108	mod tests {
109	use serde_json;
110
111	use super::*;
112
113	#[test]
UNCOV 114	fn test_pow_algorithm_from_str_variants() {	×
115	// Test valid variants for RandomXM
UNCOV 116	let randomxm_variants = vec![	×
117	"RandomXM",
UNCOV 118	"RandomX",	×
UNCOV 119	"randomx",	×
UNCOV 120	"random_x",	×
UNCOV 121	"randomxm",	×
UNCOV 122	"RANDOM_XM",	×
UNCOV 123	"monero_random_x",	×
124	];
UNCOV 125	for variant in randomxm_variants {	×
UNCOV 126	let algo = PowAlgorithm::from_str(variant).expect("Failed to parse RandomXM variant");	×
UNCOV 127	assert_eq!(algo, PowAlgorithm::RandomXM);	×
128	}
129
130	// Test valid variants for Sha3x
UNCOV 131	let sha3x_variants = vec![	×
132	"Sha3x",
UNCOV 133	"\"Sha3x\"",	×
UNCOV 134	"\'Sha3x\'",	×
UNCOV 135	"Sha 3 x",	×
UNCOV 136	"sha",	×
UNCOV 137	"sha3",	×
UNCOV 138	"SHA3",	×
UNCOV 139	"sha3X",	×
UNCOV 140	"Sha3X",	×
UNCOV 141	"SHA3X",	×
142	];
UNCOV 143	for variant in sha3x_variants {	×
UNCOV 144	let algo = PowAlgorithm::from_str(variant).expect("Failed to parse Sha3x variant");	×
UNCOV 145	assert_eq!(algo, PowAlgorithm::Sha3x);	×
146	}
147
148	// Test valid variants for RandomXT
UNCOV 149	let randomxt_variants = vec!["RandomXT", "randomxt", "tari_random_x", "RANDOM_XT"];	×
UNCOV 150	for variant in randomxt_variants {	×
UNCOV 151	let algo = PowAlgorithm::from_str(variant).expect("Failed to parse RandomXT variant");	×
UNCOV 152	assert_eq!(algo, PowAlgorithm::RandomXT);	×
153	}
UNCOV 154	}	×
155
156	#[test]
UNCOV 157	fn test_pow_algorithm_serialization() {	×
UNCOV 158	for algo in [PowAlgorithm::Sha3x, PowAlgorithm::RandomXM, PowAlgorithm::RandomXT] {	×
UNCOV 159	let serialized = serde_json::to_string(&algo).expect("Failed to serialize PowAlgorithm");	×
UNCOV 160	let deserialized: PowAlgorithm =	×
UNCOV 161	serde_json::from_str(&serialized).expect("Failed to deserialize PowAlgorithm");	×
UNCOV 162	assert_eq!(deserialized, algo);	×
163	}
UNCOV 164	}	×
165	}

tari-project / tari / 19227006544

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