Struct WalletBuilder 

pub struct WalletBuilder<P> { /* private fields */ }

Builder for creating wallets with a fluent API.

This builder holds the provider and signer, allowing you to:

• Connect to an existing Safe at a known address
• Connect to a Safe at a computed CREATE2 address
• Connect as an EOA (no Safe)
• Deploy a new Safe and then connect to it

Example

// Connect to existing Safe
let wallet = WalletBuilder::new(provider, signer)
    .connect(address)
    .await?;

// Deploy then connect (builder not consumed by deploy)
let builder = WalletBuilder::new(provider, signer);
let address = builder.deploy(rpc_url, config.clone()).await?;
let wallet = builder.connect(address).await?;

Implementations

impl<P> WalletBuilder<P>

pub fn new(provider: P, signer: PrivateKeySigner) -> Self

Creates a new WalletBuilder with the given provider and signer.

pub fn signer(&self) -> &PrivateKeySigner

Returns a reference to the signer.

pub fn signer_address(&self) -> Address

Returns the signer’s address.

pub fn provider(&self) -> &P

Returns a reference to the provider.

impl<P> WalletBuilder<P>

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

pub async fn connect(self, address: Address) -> Result<Wallet<Safe<P>>>

Connects to an existing Safe at the given address.

Arguments

• address - The Safe contract address

Example

let wallet = WalletBuilder::new(provider, signer)
    .connect(safe_address)
    .await?;

pub async fn connect_with_config( self, config: WalletConfig, ) -> Result<Wallet<Safe<P>>>

Connects to a Safe at the computed CREATE2 address for the given config.

This computes the deterministic Safe address based on the signer and config, then connects to it. Returns an error if no Safe is deployed at that address.

Arguments

• config - Configuration for Safe address computation

Example

let config = WalletConfig::new().with_salt_nonce(U256::from(42));
let wallet = WalletBuilder::new(provider, signer)
    .connect_with_config(config)
    .await?;

pub async fn connect_eoa(self, rpc_url: Url) -> Result<Wallet<Eoa<P>>>

Connects as an EOA (no Safe).

Arguments

• rpc_url - The RPC URL for sending signed transactions

Example

let wallet = WalletBuilder::new(provider, signer)
    .connect_eoa(rpc_url)
    .await?;

pub async fn compute_address(&self, config: &WalletConfig) -> Result<Address>

Computes the Safe address that would be used for the given config.

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

Arguments

• config - Configuration for Safe address computation

Example

let builder = WalletBuilder::new(provider, signer);
let config = WalletConfig::new().with_salt_nonce(U256::from(42));
let address = builder.compute_address(&config).await?;

pub async fn deploy( &self, rpc_url: Url, config: WalletConfig, ) -> Result<Address>

Deploys a Safe with the given configuration. Idempotent.

If a Safe already exists at the computed address, returns that address without deploying. Otherwise, deploys a new Safe.

Uses &self so the builder can be reused for connect() afterward.

Arguments

• rpc_url - The RPC URL for sending the deployment transaction
• config - Configuration for Safe deployment

Example

let builder = WalletBuilder::new(provider, signer);
let config = WalletConfig::new().with_salt_nonce(U256::from(42));
let address = builder.deploy(rpc_url, config.clone()).await?;
let wallet = builder.connect(address).await?;