Feat: allow multiple signing credentials in NetworkSigner

crates/network/src/any/builder.rs

@@ -130,6 +130,6 @@ impl TransactionBuilder<AnyNetwork> for WithOtherFields<TransactionRequest> {
         self,
         signer: &S,
     ) -> BuilderResult<alloy_consensus::TxEnvelope> {
-        Ok(signer.sign_transaction(self.build_unsigned()?).await?)
+        Ok(signer.sign_request(self).await?)
     }
 }

crates/network/src/ethereum/builder.rs

@@ -148,7 +148,7 @@ impl TransactionBuilder<Ethereum> for TransactionRequest {
         self,
         signer: &S,
     ) -> BuilderResult<<Ethereum as Network>::TxEnvelope> {
-        Ok(signer.sign_transaction(self.build_unsigned()?).await?)
+        Ok(signer.sign_request(self).await?)
     }
 }
 

crates/network/src/ethereum/signer.rs

@@ -1,16 +1,23 @@
 use crate::{Network, NetworkSigner, TxSigner};
 use alloy_consensus::{SignableTransaction, TxEnvelope, TypedTransaction};
+use alloy_primitives::Address;
 use alloy_signer::Signature;
 use async_trait::async_trait;
-use std::sync::Arc;
+use std::{collections::BTreeMap, sync::Arc};
 
 /// A signer capable of signing any transaction for the Ethereum network.
 #[derive(Clone)]
-pub struct EthereumSigner(Arc<dyn TxSigner<Signature> + Send + Sync>);
+pub struct EthereumSigner {
+    default: Address,
+    secp_signers: BTreeMap<Address, Arc<dyn TxSigner<Signature> + Send + Sync>>,
+}
 
 impl std::fmt::Debug for EthereumSigner {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("EthereumSigner").finish()
+        f.debug_struct("EthereumSigner")
+            .field("default_signer", &self.default)
+            .field("credentials", &self.secp_signers.len())
+            .finish()
     }
 }
 
@@ -24,19 +31,66 @@ where
 }
 
 impl EthereumSigner {
-    /// Create a new Ethereum signer.
+    /// Create a new signer with the given signer as the default signer.
     pub fn new<S>(signer: S) -> Self
     where
         S: TxSigner<Signature> + Send + Sync + 'static,
     {
-        Self(Arc::new(signer))
+        let mut this = Self { default: Default::default(), secp_signers: BTreeMap::new() };
+        this.register_default_signer(signer);
+        this
+    }
+
+    /// Register a new signer on this object. This signer will be used to sign
+    /// [`TransactionRequest`] and [`TypedTransaction`] object that specify the
+    /// signer's address in the `from` field.
+    ///
+    /// [`TransactionRequest`]: alloy_rpc_types::TransactionRequest
+    pub fn register_signer<S>(&mut self, signer: S)
+    where
+        S: TxSigner<Signature> + Send + Sync + 'static,
+    {
+        self.secp_signers.insert(signer.address(), Arc::new(signer));
+    }
+
+    /// Register a new signer on this object, and set it as the default signer.
+    /// This signer will be used to sign [`TransactionRequest`] and
+    /// [`TypedTransaction`] objects that do not specify a signer address in the
+    /// `from` field.
+    ///
+    /// [`TransactionRequest`]: alloy_rpc_types::TransactionRequest
+    pub fn register_default_signer<S>(&mut self, signer: S)
+    where
+        S: TxSigner<Signature> + Send + Sync + 'static,
+    {
+        self.default = signer.address();
+        self.register_signer(signer);
+    }
+
+    /// Get the default signer.
+    pub fn default_signer(&self) -> Arc<dyn TxSigner<Signature> + Send + Sync + 'static> {
+        self.secp_signers.get(&self.default).cloned().expect("invalid signer")
+    }
+
+    /// Get the signer for the given address.
+    pub fn signer_by_address(
+        &self,
+        address: Address,
+    ) -> Option<Arc<dyn TxSigner<Signature> + Send + Sync + 'static>> {
+        self.secp_signers.get(&address).cloned()
     }
 
     async fn sign_transaction_inner(
         &self,
+        sender: Address,
         tx: &mut dyn SignableTransaction<Signature>,
     ) -> alloy_signer::Result<Signature> {
-        self.0.sign_transaction(tx).await
+        self.signer_by_address(sender)
+            .ok_or_else(|| {
+                alloy_signer::Error::other(format!("Missing signing credential for {}", sender))
+            })?
+            .sign_transaction(tx)
+            .await
     }
 }
 
@@ -46,22 +100,38 @@ impl<N> NetworkSigner<N> for EthereumSigner
 where
     N: Network<UnsignedTx = TypedTransaction, TxEnvelope = TxEnvelope>,
 {
-    async fn sign_transaction(&self, tx: TypedTransaction) -> alloy_signer::Result<TxEnvelope> {
+    fn default_signer(&self) -> Address {
+        self.default
+    }
+
+    fn is_signer_for(&self, address: &Address) -> bool {
+        self.secp_signers.contains_key(address)
+    }
+
+    fn signers(&self) -> impl Iterator<Item = Address> {
+        self.secp_signers.keys().copied()
+    }
+
+    async fn sign_transaction_from(
+        &self,
+        sender: Address,
+        tx: TypedTransaction,
+    ) -> alloy_signer::Result<TxEnvelope> {
         match tx {
             TypedTransaction::Legacy(mut t) => {
-                let sig = self.sign_transaction_inner(&mut t).await?;
+                let sig = self.sign_transaction_inner(sender, &mut t).await?;
                 Ok(t.into_signed(sig).into())
             }
             TypedTransaction::Eip2930(mut t) => {
-                let sig = self.sign_transaction_inner(&mut t).await?;
+                let sig = self.sign_transaction_inner(sender, &mut t).await?;
                 Ok(t.into_signed(sig).into())
             }
             TypedTransaction::Eip1559(mut t) => {
-                let sig = self.sign_transaction_inner(&mut t).await?;
+                let sig = self.sign_transaction_inner(sender, &mut t).await?;
                 Ok(t.into_signed(sig).into())
             }
             TypedTransaction::Eip4844(mut t) => {
-                let sig = self.sign_transaction_inner(&mut t).await?;
+                let sig = self.sign_transaction_inner(sender, &mut t).await?;
                 Ok(t.into_signed(sig).into())
             }
         }

crates/network/src/transaction/signer.rs

@@ -1,25 +1,58 @@
 use crate::{Network, TransactionBuilder};
 use alloy_consensus::SignableTransaction;
+use alloy_primitives::Address;
 use async_trait::async_trait;
+use futures_utils_wasm::impl_future;
 
 /// A signer capable of signing any transaction for the given network.
 ///
-/// Network crate authors should implement this trait on a type capable of signing any transaction
-/// (regardless of signature type) on a given network. Signer crate authors should instead implement
-/// [`TxSigner`] to signify signing capability for specific signature types.
+/// Network crate authors should implement this trait on a type capable of
+/// signing any transaction (regardless of signature type) on a given network.
+/// Signer crate authors should instead implement [`TxSigner`] to signify
+/// signing capability for specific signature types.
+///
+/// Network signers are expected to contain one or more signing credentials,
+/// keyed by signing address. The default signer address should be used when
+/// no specific signer address is specified.
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait NetworkSigner<N: Network>: std::fmt::Debug + Send + Sync {
+    /// Get the default signer address. This address should be used
+    /// in [`NetworkSigner::sign_transaction_from`] when no specific signer is
+    /// specified.
+    fn default_signer(&self) -> Address;
+
+    /// Return true if the signer contains a credential for the given address.
+    fn is_signer_for(&self, address: &Address) -> bool;
+
+    /// Return an iterator of all signer addresses.
+    fn signers(&self) -> impl Iterator<Item = Address>;
+
+    /// Asynchronously sign an unsigned transaction, with a specified
+    /// credential.
+    async fn sign_transaction_from(
+        &self,
+        sender: Address,
+        tx: N::UnsignedTx,
+    ) -> alloy_signer::Result<N::TxEnvelope>;
+
     /// Asynchronously sign an unsigned transaction.
-    async fn sign_transaction(&self, tx: N::UnsignedTx) -> alloy_signer::Result<N::TxEnvelope>;
+    fn sign_transaction(
+        &self,
+        tx: N::UnsignedTx,
+    ) -> impl_future!(<Output = alloy_signer::Result<N::TxEnvelope>>) {
+        self.sign_transaction_from(self.default_signer(), tx)
+    }
 
-    /// Asynchronously sign a transaction request.
+    /// Asynchronously sign a transaction request, using the sender specified
+    /// in the `from` field.
     async fn sign_request(
         &self,
         request: N::TransactionRequest,
     ) -> alloy_signer::Result<N::TxEnvelope> {
+        let sender = request.from().unwrap_or_else(|| self.default_signer());
         let tx = request.build_unsigned().map_err(alloy_signer::Error::other)?;
-        self.sign_transaction(tx).await
+        self.sign_transaction_from(sender, tx).await
     }
 }
 
@@ -40,6 +73,9 @@ pub trait NetworkSigner<N: Network>: std::fmt::Debug + Send + Sync {
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait TxSigner<Signature> {
+    /// Get the address of the signer.
+    fn address(&self) -> Address;
+
     /// Asynchronously sign an unsigned transaction.
     async fn sign_transaction(
         &self,
@@ -63,6 +99,9 @@ pub trait TxSigner<Signature> {
 /// [EIP-155]: https://eips.ethereum.org/EIPS/eip-155
 /// [`ChainId`]: alloy_primitives::ChainId
 pub trait TxSignerSync<Signature> {
+    /// Get the address of the signer.
+    fn address(&self) -> Address;
+
     /// Synchronously sign an unsigned transaction.
     fn sign_transaction_sync(
         &self,

crates/signer-aws/src/signer.rs

@@ -96,6 +96,10 @@ pub enum AwsSignerError {
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl alloy_network::TxSigner<Signature> for AwsSigner {
+    fn address(&self) -> Address {
+        self.address
+    }
+
     #[inline]
     async fn sign_transaction(
         &self,

crates/signer-gcp/src/signer.rs

@@ -148,6 +148,10 @@ pub enum GcpSignerError {
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl alloy_network::TxSigner<Signature> for GcpSigner {
+    fn address(&self) -> Address {
+        self.address
+    }
+
     #[inline]
     async fn sign_transaction(
         &self,

crates/signer-ledger/src/signer.rs

@@ -31,6 +31,10 @@ pub struct LedgerSigner {
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl alloy_network::TxSigner<Signature> for LedgerSigner {
+    fn address(&self) -> Address {
+        self.address
+    }
+
     #[inline]
     async fn sign_transaction(
         &self,

crates/signer-trezor/src/signer.rs

@@ -67,6 +67,10 @@ impl Signer for TrezorSigner {
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl alloy_network::TxSigner<Signature> for TrezorSigner {
+    fn address(&self) -> Address {
+        self.address
+    }
+
     #[inline]
     async fn sign_transaction(
         &self,

crates/signer-wallet/src/lib.rs

@@ -179,6 +179,10 @@ impl<D> TxSigner<Signature> for Wallet<D>
 where
     D: PrehashSigner<(ecdsa::Signature, RecoveryId)> + Send + Sync,
 {
+    fn address(&self) -> Address {
+        self.address
+    }
+
     async fn sign_transaction(
         &self,
         tx: &mut dyn SignableTransaction<Signature>,
@@ -191,6 +195,10 @@ impl<D> TxSignerSync<Signature> for Wallet<D>
 where
     D: PrehashSigner<(ecdsa::Signature, RecoveryId)>,
 {
+    fn address(&self) -> Address {
+        self.address
+    }
+
     fn sign_transaction_sync(
         &self,
         tx: &mut dyn SignableTransaction<Signature>,