cli_commands/
key_params.rs

1use sidechain_domain::*;
2use std::convert::Infallible;
3use std::fmt::Display;
4use std::io;
5use std::io::ErrorKind;
6use std::str::FromStr;
7
8#[derive(Clone, Debug)]
9pub struct SidechainSigningKeyParam(pub secp256k1::SecretKey);
10
11impl SidechainSigningKeyParam {
12	pub fn to_pub_key(&self) -> secp256k1::PublicKey {
13		secp256k1::PublicKey::from_secret_key_global(&self.0)
14	}
15}
16
17impl FromStr for SidechainSigningKeyParam {
18	type Err = secp256k1::Error;
19
20	fn from_str(s: &str) -> Result<Self, Self::Err> {
21		let trimmed = s.trim_start_matches("0x");
22		let pair = secp256k1::SecretKey::from_str(trimmed)?;
23		Ok(SidechainSigningKeyParam(pair))
24	}
25}
26
27#[derive(Clone, Debug)]
28pub struct SidechainPublicKeyParam(pub SidechainPublicKey);
29
30impl Display for SidechainPublicKeyParam {
31	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
32		write!(f, "0x{}", hex::encode(&self.0.0))
33	}
34}
35
36impl FromStr for SidechainPublicKeyParam {
37	type Err = secp256k1::Error;
38
39	fn from_str(s: &str) -> Result<Self, Self::Err> {
40		let trimmed = s.trim_start_matches("0x");
41		let pk = secp256k1::PublicKey::from_str(trimmed)?;
42		Ok(SidechainPublicKeyParam(SidechainPublicKey(pk.serialize().to_vec())))
43	}
44}
45
46#[derive(Clone, Debug)]
47pub struct PlainPublicKeyParam(pub String);
48
49impl Display for PlainPublicKeyParam {
50	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
51		write!(f, "{}", self.0)
52	}
53}
54
55impl FromStr for PlainPublicKeyParam {
56	type Err = Infallible;
57
58	fn from_str(s: &str) -> Result<Self, Self::Err> {
59		Ok(PlainPublicKeyParam(s.to_string()))
60	}
61}
62
63#[derive(Debug, thiserror::Error)]
64pub enum Ed25519SigningKeyError {
65	#[error("{0}")]
66	HexError(#[from] hex::FromHexError),
67	#[error("{0}")]
68	Ed25519Error(#[from] ed25519_zebra::Error),
69}
70
71impl From<Ed25519SigningKeyError> for io::Error {
72	fn from(value: Ed25519SigningKeyError) -> Self {
73		io::Error::new(ErrorKind::InvalidInput, value)
74	}
75}
76
77pub(crate) fn parse_zebra_signing_key(
78	s: &str,
79) -> Result<ed25519_zebra::SigningKey, Ed25519SigningKeyError> {
80	let trimmed = s.trim_start_matches("0x");
81	Ok(ed25519_zebra::SigningKey::try_from(hex::decode(trimmed)?.as_slice())?)
82}
83
84#[derive(Clone, Debug)]
85pub struct StakePoolSigningKeyParam(pub ed25519_zebra::SigningKey);
86
87impl FromStr for StakePoolSigningKeyParam {
88	type Err = Ed25519SigningKeyError;
89
90	fn from_str(s: &str) -> Result<Self, Self::Err> {
91		Ok(Self(parse_zebra_signing_key(s)?))
92	}
93}
94
95impl From<[u8; 32]> for StakePoolSigningKeyParam {
96	fn from(key: [u8; 32]) -> Self {
97		Self(ed25519_zebra::SigningKey::from(key))
98	}
99}
100
101impl StakePoolSigningKeyParam {
102	pub fn vkey(&self) -> StakePoolPublicKey {
103		StakePoolPublicKey(ed25519_zebra::VerificationKey::from(&self.0).into())
104	}
105}
106
107#[derive(Clone, Debug)]
108pub struct StakeSigningKeyParam(pub ed25519_zebra::SigningKey);
109
110impl FromStr for StakeSigningKeyParam {
111	type Err = Ed25519SigningKeyError;
112
113	fn from_str(s: &str) -> Result<Self, Self::Err> {
114		Ok(Self(parse_zebra_signing_key(s)?))
115	}
116}
117
118impl StakeSigningKeyParam {
119	pub fn vkey(&self) -> StakePublicKey {
120		StakePublicKey(ed25519_zebra::VerificationKey::from(&self.0).into())
121	}
122}
123
124#[derive(Clone, Debug)]
125pub struct CrossChainSigningKeyParam(pub k256::SecretKey);
126
127impl FromStr for CrossChainSigningKeyParam {
128	type Err = anyhow::Error;
129
130	fn from_str(s: &str) -> Result<Self, Self::Err> {
131		Ok(Self(k256::SecretKey::from_slice(&hex::decode(s)?)?))
132	}
133}
134
135impl CrossChainSigningKeyParam {
136	pub fn vkey(&self) -> CrossChainPublicKey {
137		CrossChainPublicKey(self.0.public_key().to_sec1_bytes().to_vec())
138	}
139}
cli_commands/key_params.rs

cli_commands/
key_params.rs
