Enum Wallet 

pub enum Wallet<P> {
    Safe(Safe<P>),
    Eoa(Eoa<P>),
}

A wallet that can be either a Safe smart account or an EOA

Note: Debug is not derived because Safe<P> and Eoa<P> don’t implement Debug.

Variants

Safe(Safe<P>)

Safe smart account variant

Eoa(Eoa<P>)

Externally Owned Account variant

Implementations

impl<P> Wallet<P>

where P: Provider<AnyNetwork> + Clone + 'static,

pub async fn connect(provider: P, signer: PrivateKeySigner) -> Result<Self>

Connects to a wallet, auto-detecting whether a Safe exists

Uses default configuration (salt_nonce = 0, single owner, threshold = 1). If a Safe is deployed at the computed CREATE2 address, returns Wallet::Safe. Otherwise, returns Wallet::Eoa.

Arguments

• provider - The provider for RPC calls
• signer - The private key signer

Returns

Wallet::Safe if Safe exists at computed address, Wallet::Eoa otherwise

pub async fn connect_with_config( provider: P, signer: PrivateKeySigner, config: WalletConfig, ) -> Result<Self>

Connects to a wallet with custom configuration

If a Safe is deployed at the computed CREATE2 address for the given config, returns Wallet::Safe. Otherwise, returns Wallet::Eoa.

Arguments

• provider - The provider for RPC calls
• signer - The private key signer
• config - Configuration for Safe address computation

pub async fn connect_and_deploy( provider: P, signer: PrivateKeySigner, ) -> Result<Self>

Connects and deploys a Safe if one doesn’t exist

Uses default configuration. If Safe already exists, connects to it. If not, deploys a new Safe and returns Wallet::Safe.

Arguments

• provider - The provider for RPC calls (must support sending transactions)
• signer - The private key signer

pub async fn connect_and_deploy_with_config( provider: P, signer: PrivateKeySigner, config: WalletConfig, ) -> Result<Self>

Connects and deploys a Safe with custom configuration

If Safe already exists at the computed address, connects to it. If not, deploys a new Safe with the specified configuration.

Arguments

• provider - The provider for RPC calls (must support sending transactions)
• signer - The private key signer
• config - Configuration for Safe address computation and deployment

pub fn address(&self) -> Address

Returns the wallet’s address

For Wallet::Safe, returns the Safe contract address. For Wallet::Eoa, returns the EOA signer address.

pub fn is_safe(&self) -> bool

Returns true if this is a Safe wallet

pub fn is_eoa(&self) -> bool

Returns true if this is an EOA wallet

pub fn signer_address(&self) -> Address

Returns the underlying EOA signer address

For both variants, this returns the address of the private key signer.

pub fn provider(&self) -> &P

Returns a reference to the provider

pub fn batch(&self) -> BatchBuilder<'_, P>

Creates a unified batch builder for executing transactions

This provides the same API for both Safe and EOA wallets, abstracting away the differences between atomic multicall (Safe) and sequential transactions (EOA).

Example

wallet.batch()
    .add_typed(token, IERC20::transferCall { to: recipient, amount })
    .simulate().await?
    .execute().await?;

pub async fn execute_single( &self, to: Address, value: U256, data: Bytes, operation: Operation, ) -> Result<ExecutionResult>

Executes a single transaction

This is a convenience method for executing a single call without the batch builder. For multiple calls, use batch() instead.

Errors

Returns Error::UnsupportedEoaOperation if operation is DelegateCall and the wallet is an EOA.

pub async fn computed_safe_address( provider: &P, signer: &PrivateKeySigner, config: &WalletConfig, ) -> Result<Address>

Computes the Safe address that would be used for the given signer and config

This is useful for checking what Safe address would be computed without actually connecting or deploying.

impl<P> Wallet<P>

where P: Provider<AnyNetwork> + Clone + 'static,

Specialized implementation for the common HTTP provider case

pub async fn connect_and_deploy_with_rpc( provider: P, signer: PrivateKeySigner, rpc_url: Url, ) -> Result<Self>

Connects and deploys a Safe using the specified RPC URL

This variant is useful when the provider doesn’t expose its RPC URL directly.

Arguments

• provider - The provider for RPC calls
• signer - The private key signer
• rpc_url - The RPC URL for sending deployment transaction

pub async fn connect_and_deploy_with_rpc_and_config( provider: P, signer: PrivateKeySigner, rpc_url: Url, config: WalletConfig, ) -> Result<Self>

Connects and deploys a Safe with custom configuration and RPC URL