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::{eip191_hash_message, 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        // Hash message according to EIP 191:
86        // https://ethereum.org/es/developers/docs/apis/json-rpc/#eth_sign
87        let hash = eip191_hash_message(message);
88        self.sign_hash(hash, address)
89    }
90
91    async fn sign_transaction(&self, request: TxReq, address: &Address) -> Result<T> {
92        // create local signer wallet from signing key
93        let signer = self.accounts.get(address).ok_or(SignError::NoAccount)?.clone();
94
95        // build and sign transaction with signer
96        let tx = request
97            .try_build_and_sign(&signer)
98            .await
99            .map_err(|_| SignError::InvalidTransactionRequest)?;
100
101        Ok(tx)
102    }
103
104    fn sign_typed_data(&self, address: Address, payload: &TypedData) -> Result<Signature> {
105        let encoded = payload.eip712_signing_hash().map_err(|_| SignError::InvalidTypedData)?;
106        self.sign_hash(encoded, address)
107    }
108}
109
110#[cfg(test)]
111mod tests {
112    use super::*;
113    use alloy_consensus::Transaction;
114    use alloy_primitives::{Bytes, TxKind, U256};
115    use alloy_rpc_types_eth::{TransactionInput, TransactionRequest};
116    use reth_ethereum_primitives::TransactionSigned;
117
118    fn build_signer() -> DevSigner {
119        let signer: PrivateKeySigner =
120            "4646464646464646464646464646464646464646464646464646464646464646".parse().unwrap();
121        let address = signer.address();
122        let accounts = AddressMap::from_iter([(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 = EthSigner::<reth_ethereum_primitives::TransactionSigned>::sign_typed_data(
197            &signer, from, &data,
198        )
199        .unwrap();
200        let expected = Signature::new(
201            U256::from_str_radix(
202                "5318aee9942b84885761bb20e768372b76e7ee454fc4d39b59ce07338d15a06c",
203                16,
204            )
205            .unwrap(),
206            U256::from_str_radix(
207                "5e585a2f4882ec3228a9303244798b47a9102e4be72f48159d890c73e4511d79",
208                16,
209            )
210            .unwrap(),
211            false,
212        );
213        assert_eq!(sig, expected)
214    }
215
216    #[tokio::test]
217    async fn test_signer() {
218        let message = b"Test message";
219        let signer = build_signer();
220        let from = *signer.addresses.first().unwrap();
221        let sig =
222            EthSigner::<reth_ethereum_primitives::TransactionSigned>::sign(&signer, from, message)
223                .await
224                .unwrap();
225        let expected = Signature::new(
226            U256::from_str_radix(
227                "54313da7432e4058b8d22491b2e7dbb19c7186c35c24155bec0820a8a2bfe0c1",
228                16,
229            )
230            .unwrap(),
231            U256::from_str_radix(
232                "687250f11a3d4435004c04a4cb60e846bc27997271d67f21c6c8170f17a25e10",
233                16,
234            )
235            .unwrap(),
236            true,
237        );
238        assert_eq!(sig, expected)
239    }
240
241    #[tokio::test]
242    async fn test_sign_transaction() {
243        let message = b"Test message";
244        let signer = build_signer();
245        let from = *signer.addresses.first().unwrap();
246        let request = TransactionRequest {
247            chain_id: Some(1u64),
248            from: Some(from),
249            to: Some(TxKind::Create),
250            gas: Some(1000),
251            gas_price: Some(1000u128),
252            value: Some(U256::from(1000)),
253            input: TransactionInput {
254                data: Some(Bytes::from(message.to_vec())),
255                input: Some(Bytes::from(message.to_vec())),
256            },
257            nonce: Some(0u64),
258            ..Default::default()
259        };
260        let txn_signed: std::result::Result<TransactionSigned, SignError> =
261            signer.sign_transaction(request, &from).await;
262        assert!(txn_signed.is_ok());
263
264        assert_eq!(Bytes::from(message.to_vec()), txn_signed.unwrap().input().0);
265    }
266}
reth_rpc/eth/helpers/signer.rs

reth_rpc/eth/helpers/
signer.rs
