A Rust library and CLI for interacting with Safe smart accounts. Built for single-owner (1/1) Safes with a focus on simplicity, safety, and developer experience.

Opinionated by design. safe-rs optimizes for an opinionated usecase: single-owner Safes where you want to execute transactions with confidence. Rather than supporting every Safe configuration, it provides a streamlined experience with compile-time guarantees and optional forking simulation.

Minimal surface area. One way to do things, done well. No configuration sprawl, no optional safety features that can be accidentally disabled.

• Fluent builder pattern — Simple API with optional simulation before execution
• Fork simulation — Test transactions against live blockchain state using revm
• Automatic multicall batching — Single calls execute directly; multiple calls batch via MultiSend
• Type-safe contract calls — First-class support for alloy's sol! macro
• Multi-chain support — Pre-configured for Ethereum, Arbitrum, Optimism, Base, Polygon, and more
• Deterministic deployment — Deploy new Safes with predictable addresses via CREATE2
• Gas estimation — Automatic safeTxGas calculation with safety buffer
• Revert decoding — Human-readable error messages from failed simulations
• EOA fallback mode — Same builder API for executing as individual transactions from an EOA

cargo install safe-rs

[dependencies]
safe-rs = "0.1"

Execute an ERC20 transfer through your Safe:

safe send 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 \
    'transfer(address,uint256)' 0xRecipient 1000000 \
    --safe 0xYourSafe \
    --rpc-url $ETH_RPC_URL \
    --private-key $PRIVATE_KEY

Simulate without executing:

safe call 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 \
    'transfer(address,uint256)' 0xRecipient 1000000 \
    --safe 0xYourSafe \
    --rpc-url $ETH_RPC_URL

use safe_rs::{Safe, contracts::IERC20};
use alloy::primitives::{address, U256};

let safe = Safe::connect(provider, signer, safe_address).await?;
safe.verify_single_owner().await?;

let result = safe
    .batch()
    .add_typed(token, IERC20::transferCall {
        to: recipient,
        amount: U256::from(1_000_000),
    })
    .simulate().await?
    .execute().await?;

println!("Transaction: {:?}", result.transaction_hash);

Execute transactions through a Safe. Always simulates first, then prompts for confirmation.

Single call:

safe send <to> <signature> [args...] --safe <address> --rpc-url <url>

Multiple calls:

safe send \
    --call 0xToken:transfer(address,uint256):0xRecipient,1000 \
    --call 0xToken:approve(address,uint256):0xSpender,5000 \
    --safe 0xYourSafe \
    --rpc-url $ETH_RPC_URL

From bundle file:

safe send --bundle transactions.json --safe 0xYourSafe --rpc-url $ETH_RPC_URL

Options:

Simulate a transaction without executing. Useful for testing and gas estimation.

safe call <to> <signature> [args...] --safe <address> --rpc-url <url>

Query Safe state.

safe info --safe 0xYourSafe --rpc-url $ETH_RPC_URL

Output:

Safe: 0xYourSafe
Nonce: 42
Threshold: 1
Owners:
  - 0xOwner1

Deploy a new Safe with deterministic addressing.

safe create \
    --owner 0xAdditionalOwner \
    --threshold 2 \
    --salt-nonce 12345 \
    --rpc-url $ETH_RPC_URL \
    --private-key $PRIVATE_KEY

Options:

All commands that require signing support:

use safe_rs::Safe;

// Auto-detect chain configuration
let safe = Safe::connect(provider, signer, safe_address).await?;

// Verify single-owner requirement
safe.verify_single_owner().await?;

The MulticallBuilder provides a fluent API for constructing transactions:

// Raw call
let builder = safe.batch()
    .add(Call {
        to: address,
        value: U256::ZERO,
        data: calldata.into(),
        operation: Operation::Call,
    });

// Typed call (recommended)
let builder = safe.batch()
    .add_typed(token, IERC20::transferCall { to, amount });

// Multiple calls batch automatically
let builder = safe.batch()
    .add_typed(token1, transfer1)
    .add_typed(token2, transfer2)
    .call_only();  // Use MultiSendCallOnly for safety

Simulation runs the transaction against a fork of the current blockchain state:

let builder = builder.simulate().await?;

// Access simulation result
if let Some(result) = builder.simulation_result() {
    println!("Success: {}", result.success);
    println!("Gas used: {}", result.gas_used);
    println!("Logs: {:?}", result.logs);

    // If simulation failed
    if let Some(reason) = &result.revert_reason {
        println!("Revert reason: {}", reason);
    }
}

After simulation, you can execute:

let result = simulated.execute().await?;
println!("Transaction hash: {:?}", result.transaction_hash);

For read-only operations or testing, you don't need to be an owner:

use alloy::signers::local::PrivateKeySigner;

// Use any signer for simulation
let dummy = PrivateKeySigner::random();
let safe = Safe::new(provider, dummy, safe_address, config);

let builder = safe.batch()
    .add_typed(token, call)
    .simulate().await?;

// Inspect results without executing
if let Some(result) = builder.simulation_result() {
    println!("Would use {} gas", result.gas_used);
}

let nonce = safe.nonce().await?;
let threshold = safe.threshold().await?;
let owners = safe.owners().await?;

The Eoa client provides the same builder API as Safe multicall, but executes each call as a separate transaction. This is useful when you don't have a Safe but want the same batching workflow:

use safe_rs::Eoa;

let eoa = Eoa::connect(provider, signer).await?;

let result = eoa.batch()
    .add_typed(token, IERC20::transferCall { to: alice, amount: U256::from(100) })
    .add_typed(token, IERC20::transferCall { to: bob, amount: U256::from(200) })
    .simulate().await?
    .execute().await?;

println!("Executed {} txs, {} succeeded", result.results.len(), result.success_count);

for tx in &result.results {
    println!("Tx {}: {:?}", tx.index, tx.tx_hash);
}

Key differences from Safe mode:

Partial failure handling:

By default, EOA batch execution stops on the first failure. Use continue_on_failure() to execute all transactions regardless:

let result = eoa.batch()
    .add_typed(token, transfer1)
    .add_typed(token, transfer2)
    .continue_on_failure()  // Don't stop on first failure
    .simulate().await?
    .execute().await?;

if let Some(idx) = result.first_failure {
    println!("First failure at index {}", idx);
}

The --bundle option accepts JSON files compatible with the Safe Transaction Bundler format:

[
  {
    "to": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    "value": "0",
    "data": "0xa9059cbb000000000000000000000000...",
    "operation": 0
  },
  {
    "to": "0x6B175474E89094C44Da98b954EescdAD80089fD12",
    "data": "0x095ea7b3...",
    "operation": 0
  }
]

Fields:

• to — Target address (required)
• value — Wei to send (optional, default: "0")
• data — Calldata hex (optional, default: "0x")
• operation — 0 for Call, 1 for DelegateCall (optional, default: 0)

safe-rs includes pre-configured addresses for Safe v1.4.1 contracts:

All chains use the same contract addresses (deployed via CREATE2):

See the examples/ directory:

• simple_transfer.rs — Single ERC20 transfer
• multicall_erc20.rs — Batch multiple operations
• simulation_only.rs — Simulation without execution

Run examples:

cargo run --example simple_transfer

vs Safe Transaction Service API: safe-rs executes transactions directly on-chain without relying on Safe's infrastructure. No API keys, no rate limits, no external dependencies.

vs ethers/alloy directly: safe-rs handles the complexity of Safe transaction encoding, EIP-712 signing, gas estimation, and multicall batching. You focus on what you want to do, not how Safe works internally.

vs multi-owner Safes: If you need multiple signers, use the Safe web interface or Transaction Service. safe-rs is intentionally limited to 1/1 Safes for simplicity and reliability.

MIT