reth_rpc/eth/helpers/
signer.rs

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

reth_rpc/eth/helpers/
signer.rs
