reth_rpc/eth/helpers/
signer.rs

1//! An abstraction over ethereum signers.
2
3use std::collections::HashMap;
4
5use crate::EthApi;
6use alloy_dyn_abi::TypedData;
7use alloy_eips::eip2718::Decodable2718;
8use alloy_network::{eip2718::Encodable2718, EthereumWallet, TransactionBuilder};
9use alloy_primitives::{eip191_hash_message, Address, PrimitiveSignature as Signature, B256};
10use alloy_rpc_types_eth::TransactionRequest;
11use alloy_signer::SignerSync;
12use alloy_signer_local::PrivateKeySigner;
13use reth_provider::BlockReader;
14use reth_rpc_eth_api::helpers::{signer::Result, AddDevSigners, EthSigner};
15use reth_rpc_eth_types::SignError;
16
17impl<Provider, Pool, Network, EvmConfig> AddDevSigners
18    for EthApi<Provider, Pool, Network, EvmConfig>
19where
20    Provider: BlockReader,
21{
22    fn with_dev_accounts(&self) {
23        *self.inner.signers().write() = DevSigner::random_signers(20)
24    }
25}
26
27/// Holds developer keys
28#[derive(Debug, Clone)]
29pub struct DevSigner {
30    addresses: Vec<Address>,
31    accounts: HashMap<Address, PrivateKeySigner>,
32}
33
34#[allow(dead_code)]
35impl DevSigner {
36    /// Generates a random dev signer which satisfies [`EthSigner`] trait
37    pub fn random<T: Decodable2718>() -> Box<dyn EthSigner<T>> {
38        let mut signers = Self::random_signers(1);
39        signers.pop().expect("expect to generate at least one signer")
40    }
41
42    /// Generates provided number of random dev signers
43    /// which satisfy [`EthSigner`] trait
44    pub fn random_signers<T: Decodable2718>(num: u32) -> Vec<Box<dyn EthSigner<T> + 'static>> {
45        let mut signers = Vec::with_capacity(num as usize);
46        for _ in 0..num {
47            let sk = PrivateKeySigner::random_with(&mut rand::thread_rng());
48
49            let address = sk.address();
50            let addresses = vec![address];
51
52            let accounts = HashMap::from([(address, sk)]);
53            signers.push(Box::new(Self { addresses, accounts }) as Box<dyn EthSigner<T>>);
54        }
55        signers
56    }
57
58    fn get_key(&self, account: Address) -> Result<&PrivateKeySigner> {
59        self.accounts.get(&account).ok_or(SignError::NoAccount)
60    }
61
62    fn sign_hash(&self, hash: B256, account: Address) -> Result<Signature> {
63        let signature = self.get_key(account)?.sign_hash_sync(&hash);
64        signature.map_err(|_| SignError::CouldNotSign)
65    }
66}
67
68#[async_trait::async_trait]
69impl<T: Decodable2718> EthSigner<T> for DevSigner {
70    fn accounts(&self) -> Vec<Address> {
71        self.addresses.clone()
72    }
73
74    fn is_signer_for(&self, addr: &Address) -> bool {
75        self.accounts.contains_key(addr)
76    }
77
78    async fn sign(&self, address: Address, message: &[u8]) -> Result<Signature> {
79        // Hash message according to EIP 191:
80        // https://ethereum.org/es/developers/docs/apis/json-rpc/#eth_sign
81        let hash = eip191_hash_message(message);
82        self.sign_hash(hash, address)
83    }
84
85    async fn sign_transaction(&self, request: TransactionRequest, address: &Address) -> Result<T> {
86        // create local signer wallet from signing key
87        let signer = self.accounts.get(address).ok_or(SignError::NoAccount)?.clone();
88        let wallet = EthereumWallet::from(signer);
89
90        // build and sign transaction with signer
91        let txn_envelope =
92            request.build(&wallet).await.map_err(|_| SignError::InvalidTransactionRequest)?;
93
94        // decode transaction into signed transaction type
95        let encoded = txn_envelope.encoded_2718();
96        let txn_signed = T::decode_2718(&mut encoded.as_ref())
97            .map_err(|_| SignError::InvalidTransactionRequest)?;
98
99        Ok(txn_signed)
100    }
101
102    fn sign_typed_data(&self, address: Address, payload: &TypedData) -> Result<Signature> {
103        let encoded = payload.eip712_signing_hash().map_err(|_| SignError::InvalidTypedData)?;
104        self.sign_hash(encoded, address)
105    }
106}
107
108#[cfg(test)]
109mod tests {
110    use alloy_consensus::Transaction;
111    use alloy_primitives::{Bytes, U256};
112    use alloy_rpc_types_eth::TransactionInput;
113    use reth_primitives::TransactionSigned;
114    use revm_primitives::TxKind;
115
116    use super::*;
117
118    fn build_signer() -> DevSigner {
119        let signer: PrivateKeySigner =
120            "4646464646464646464646464646464646464646464646464646464646464646".parse().unwrap();
121        let address = signer.address();
122        let accounts = HashMap::from([(address, signer)]);
123        let addresses = vec![address];
124        DevSigner { addresses, accounts }
125    }
126
127    #[tokio::test]
128    async fn test_sign_type_data() {
129        let eip_712_example = r#"{
130            "types": {
131            "EIP712Domain": [
132                {
133                    "name": "name",
134                    "type": "string"
135                },
136                {
137                    "name": "version",
138                    "type": "string"
139                },
140                {
141                    "name": "chainId",
142                    "type": "uint256"
143                },
144                {
145                    "name": "verifyingContract",
146                    "type": "address"
147                }
148            ],
149            "Person": [
150                {
151                    "name": "name",
152                    "type": "string"
153                },
154                {
155                    "name": "wallet",
156                    "type": "address"
157                }
158            ],
159            "Mail": [
160                {
161                    "name": "from",
162                    "type": "Person"
163                },
164                {
165                    "name": "to",
166                    "type": "Person"
167                },
168                {
169                    "name": "contents",
170                    "type": "string"
171                }
172            ]
173        },
174        "primaryType": "Mail",
175        "domain": {
176            "name": "Ether Mail",
177            "version": "1",
178            "chainId": 1,
179            "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
180        },
181        "message": {
182            "from": {
183                "name": "Cow",
184                "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
185            },
186            "to": {
187                "name": "Bob",
188                "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
189            },
190            "contents": "Hello, Bob!"
191        }
192        }"#;
193        let data: TypedData = serde_json::from_str(eip_712_example).unwrap();
194        let signer = build_signer();
195        let from = *signer.addresses.first().unwrap();
196        let sig =
197            EthSigner::<reth_primitives::TransactionSigned>::sign_typed_data(&signer, from, &data)
198                .unwrap();
199        let expected = Signature::new(
200            U256::from_str_radix(
201                "5318aee9942b84885761bb20e768372b76e7ee454fc4d39b59ce07338d15a06c",
202                16,
203            )
204            .unwrap(),
205            U256::from_str_radix(
206                "5e585a2f4882ec3228a9303244798b47a9102e4be72f48159d890c73e4511d79",
207                16,
208            )
209            .unwrap(),
210            false,
211        );
212        assert_eq!(sig, expected)
213    }
214
215    #[tokio::test]
216    async fn test_signer() {
217        let message = b"Test message";
218        let signer = build_signer();
219        let from = *signer.addresses.first().unwrap();
220        let sig = EthSigner::<reth_primitives::TransactionSigned>::sign(&signer, from, message)
221            .await
222            .unwrap();
223        let expected = Signature::new(
224            U256::from_str_radix(
225                "54313da7432e4058b8d22491b2e7dbb19c7186c35c24155bec0820a8a2bfe0c1",
226                16,
227            )
228            .unwrap(),
229            U256::from_str_radix(
230                "687250f11a3d4435004c04a4cb60e846bc27997271d67f21c6c8170f17a25e10",
231                16,
232            )
233            .unwrap(),
234            true,
235        );
236        assert_eq!(sig, expected)
237    }
238
239    #[tokio::test]
240    async fn test_sign_transaction() {
241        let message = b"Test message";
242        let signer = build_signer();
243        let from = *signer.addresses.first().unwrap();
244        let request = TransactionRequest {
245            chain_id: Some(1u64),
246            from: Some(from),
247            to: Some(TxKind::Create),
248            gas: Some(1000),
249            gas_price: Some(1000u128),
250            value: Some(U256::from(1000)),
251            input: TransactionInput {
252                data: Some(Bytes::from(message.to_vec())),
253                input: Some(Bytes::from(message.to_vec())),
254            },
255            nonce: Some(0u64),
256            ..Default::default()
257        };
258        let txn_signed: std::result::Result<TransactionSigned, SignError> =
259            signer.sign_transaction(request, &from).await;
260        assert!(txn_signed.is_ok());
261
262        assert_eq!(Bytes::from(message.to_vec()), txn_signed.unwrap().input().0);
263    }
264}
reth_rpc/eth/helpers/signer.rs

reth_rpc/eth/helpers/
signer.rs
