1pub use quai_abi::TypedData;
3use quai_consensus::{
4 QiTransaction, QuaiTransaction, SignedQiTransaction, SignedQuaiTransaction, U256,
5};
6use quai_crypto::{
7 PublicKey, RecoverableSignature, SchnorrPublicKey, SchnorrSignature, SecretKey, hash_message,
8 keccak256,
9};
10use quai_primitives::{Address, QiAddress};
11use std::fmt;
12use thiserror::Error;
13
14#[derive(Clone, Copy, Debug, Eq, PartialEq)]
16pub enum DomainPolicy {
17 RequireChainId,
19 AllowUnbound,
22}
23
24impl DomainPolicy {
25 pub fn validate(self, data: &TypedData, chain_id: U256) -> Result<(), SignerError> {
27 if chain_id == U256::ZERO {
28 return Err(SignerError::ChainMismatch);
29 }
30 match data.domain().get("chainId").filter(|v| !v.is_null()) {
31 None if self == DomainPolicy::RequireChainId => {
32 return Err(SignerError::ChainMismatch);
33 }
34 None => (),
35 Some(value) => {
36 let chain = match value {
37 serde_json::Value::Number(n) => n
38 .as_u64()
39 .map(U256::from)
40 .ok_or(SignerError::ChainMismatch)?,
41 serde_json::Value::String(text) => {
42 let (digits, radix) = text
43 .strip_prefix("0x")
44 .or_else(|| text.strip_prefix("0X"))
45 .map_or((text.as_str(), 10), |digits| (digits, 16));
46 U256::from_str_radix(digits, radix)
47 .map_err(|_| SignerError::ChainMismatch)?
48 }
49 _ => return Err(SignerError::ChainMismatch),
50 };
51 if chain != chain_id {
52 return Err(SignerError::ChainMismatch);
53 }
54 }
55 }
56 Ok(())
57 }
58}
59
60#[derive(Debug, Error)]
62#[non_exhaustive]
63pub enum SignerError {
64 #[error("signer chain ID mismatch or invalid chain ID")]
66 ChainMismatch,
67 #[error("signer address does not select a supported zone")]
69 InvalidAddress,
70 #[error("watch-only signer cannot sign")]
72 WatchOnly,
73 #[error("transaction signing failed validation")]
75 InvalidTransaction,
76 #[error("message signing failed")]
78 MessageSigning,
79 #[error("refusing to sign a Qi transaction as a message")]
81 QiTransactionMessage,
82 #[error("Qi message signing is unsupported by this signer")]
84 QiMessageUnsupported,
85 #[error("typed-data signing is unsupported by this signer")]
87 TypedDataUnsupported,
88}
89
90pub trait Signer {
92 fn address(&self) -> Address;
94 fn chain_id(&self) -> U256;
96 fn sign_quai(
98 &self,
99 transaction: &QuaiTransaction,
100 ) -> Result<SignedQuaiTransaction, SignerError>;
101 fn sign_qi_single(
103 &self,
104 transaction: &QiTransaction,
105 ) -> Result<SignedQiTransaction, SignerError>;
106 fn sign_message(&self, message: &[u8]) -> Result<RecoverableSignature, SignerError>;
108 fn sign_qi_message(&self, _message: &[u8]) -> Result<SchnorrSignature, SignerError> {
111 Err(SignerError::QiMessageUnsupported)
112 }
113 fn sign_typed_data(
115 &self,
116 _data: &TypedData,
117 _policy: DomainPolicy,
118 ) -> Result<RecoverableSignature, SignerError> {
119 Err(SignerError::TypedDataUnsupported)
120 }
121}
122
123pub struct LocalSigner {
125 key: SecretKey,
126 address: Address,
127 chain_id: U256,
128}
129impl LocalSigner {
130 pub fn public_key(&self) -> PublicKey {
132 self.key.public_key()
133 }
134 pub fn new(key: SecretKey, chain_id: U256) -> Result<Self, SignerError> {
136 if chain_id == U256::ZERO {
137 return Err(SignerError::ChainMismatch);
138 }
139 let address = key.public_key().address();
140 address.zone().map_err(|_| SignerError::InvalidAddress)?;
141 Ok(Self {
142 key,
143 address,
144 chain_id,
145 })
146 }
147}
148impl fmt::Debug for LocalSigner {
149 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
150 f.debug_struct("LocalSigner")
151 .field("address", &self.address)
152 .field("chain_id", &self.chain_id)
153 .finish_non_exhaustive()
154 }
155}
156impl Signer for LocalSigner {
157 fn address(&self) -> Address {
158 self.address
159 }
160 fn chain_id(&self) -> U256 {
161 self.chain_id
162 }
163 fn sign_quai(&self, tx: &QuaiTransaction) -> Result<SignedQuaiTransaction, SignerError> {
164 if tx.chain_id != self.chain_id {
165 return Err(SignerError::ChainMismatch);
166 }
167 tx.sign(&self.key)
168 .map_err(|_| SignerError::InvalidTransaction)
169 }
170 fn sign_qi_single(&self, tx: &QiTransaction) -> Result<SignedQiTransaction, SignerError> {
171 if tx.chain_id != self.chain_id {
172 return Err(SignerError::ChainMismatch);
173 }
174 tx.sign_single(&self.key)
175 .map_err(|_| SignerError::InvalidTransaction)
176 }
177 fn sign_message(&self, message: &[u8]) -> Result<RecoverableSignature, SignerError> {
178 self.key
179 .sign_prehash(&hash_message(message))
180 .map_err(|_| SignerError::MessageSigning)
181 }
182 fn sign_qi_message(&self, message: &[u8]) -> Result<SchnorrSignature, SignerError> {
183 sign_qi_message(&self.key, message)
184 }
185 fn sign_typed_data(
186 &self,
187 data: &TypedData,
188 policy: DomainPolicy,
189 ) -> Result<RecoverableSignature, SignerError> {
190 policy.validate(data, self.chain_id)?;
191 self.key
192 .sign_prehash(data.signing_hash().bytes())
193 .map_err(|_| SignerError::MessageSigning)
194 }
195}
196
197#[derive(Clone, Copy, Debug)]
199pub struct WatchOnlySigner {
200 address: Address,
201 chain_id: U256,
202}
203impl WatchOnlySigner {
204 pub fn new(address: Address, chain_id: U256) -> Result<Self, SignerError> {
206 if chain_id == U256::ZERO {
207 return Err(SignerError::ChainMismatch);
208 }
209 address.zone().map_err(|_| SignerError::InvalidAddress)?;
210 Ok(Self { address, chain_id })
211 }
212}
213impl Signer for WatchOnlySigner {
214 fn address(&self) -> Address {
215 self.address
216 }
217 fn chain_id(&self) -> U256 {
218 self.chain_id
219 }
220 fn sign_quai(&self, _: &QuaiTransaction) -> Result<SignedQuaiTransaction, SignerError> {
221 Err(SignerError::WatchOnly)
222 }
223 fn sign_qi_single(&self, _: &QiTransaction) -> Result<SignedQiTransaction, SignerError> {
224 Err(SignerError::WatchOnly)
225 }
226 fn sign_message(&self, _: &[u8]) -> Result<RecoverableSignature, SignerError> {
227 Err(SignerError::WatchOnly)
228 }
229 fn sign_qi_message(&self, _: &[u8]) -> Result<SchnorrSignature, SignerError> {
230 Err(SignerError::WatchOnly)
231 }
232 fn sign_typed_data(
233 &self,
234 _: &TypedData,
235 _: DomainPolicy,
236 ) -> Result<RecoverableSignature, SignerError> {
237 Err(SignerError::WatchOnly)
238 }
239}
240
241pub fn sign_qi_message(key: &SecretKey, message: &[u8]) -> Result<SchnorrSignature, SignerError> {
255 QiAddress::try_from(key.public_key().address()).map_err(|_| SignerError::InvalidAddress)?;
256 if quai_consensus::has_transaction_inputs(message) {
257 return Err(SignerError::QiTransactionMessage);
258 }
259 key.sign_schnorr(&keccak256(message))
260 .map_err(|_| SignerError::MessageSigning)
261}
262
263pub fn verify_qi_message(
266 address: QiAddress,
267 public_key: &PublicKey,
268 message: &[u8],
269 signature: &SchnorrSignature,
270) -> Result<(), SignerError> {
271 if public_key.address() != address.address() {
272 return Err(SignerError::InvalidAddress);
273 }
274 let compressed = public_key.to_compressed();
275 let mut x = [0; 32];
276 x.copy_from_slice(&compressed[1..]);
277 SchnorrPublicKey::from_bytes(&x)
278 .and_then(|key| key.verify(&keccak256(message), signature))
279 .map_err(|_| SignerError::MessageSigning)
280}