Awesome Open Source
Awesome Open Source


Ethereum JSON-RPC multi-transport client. Rust implementation of Web3.js library.

Build Status



First, add this to your Cargo.toml:

web3 = "0.17.0"


async fn main() -> web3::Result<()> {
    let transport = web3::transports::Http::new("http://localhost:8545")?;
    let web3 = web3::Web3::new(transport);

    println!("Calling accounts.");
    let mut accounts = web3.eth().accounts().await?;
    println!("Accounts: {:?}", accounts);

    println!("Calling balance.");
    for account in accounts {
        let balance = web3.eth().balance(account, None).await?;
        println!("Balance of {:?}: {}", account, balance);


If you want to deploy smart contracts you have written you can do something like this (make sure you have the solidity compiler installed):

solc -o build --bin --abi contracts/*.sol

The solidity compiler is generating the binary and abi code for the smart contracts in a directory called contracts and is being output to a directory called build.

For more see examples folder.

Futures migration

  • [ ] Get rid of parking_lot (replace with async-aware locks if really needed).
  • [ ] Consider getting rid of Unpin requirements. (#361)
  • [x] WebSockets: TLS support (#360)
  • [ ] WebSockets: Reconnecting & Pings
  • [x] Consider using tokio instead of async-std for transport (issue with test).
  • [x] Restore IPC Transport


  • [ ] More flexible API (accept Into<X>)
  • [x] Contract calls (ABI encoding; debris/ethabi)
  • [X] Batch Requests


  • [x] HTTP transport
  • [x] IPC transport
  • [x] WebSockets transport


  • [x] Types for U256,H256,Address(H160)
  • [x] Index type (numeric, encoded to hex)
  • [x] Transaction type (Transaction from Parity)
  • [x] Transaction receipt type (TransactionReceipt from Parity)
  • [x] Block type (RichBlock from Parity)
  • [x] Work type (Work from Parity)
  • [X] Syncing type (SyncStats from Parity)


  • [x] Eth: eth_*
  • [x] Eth filters: eth_*
  • [x] Eth pubsub: eth_*
  • [x] net_*
  • [x] web3_*
  • [x] personal_*
  • [ ] traces_*

Parity-specific APIs

  • [ ] Parity read-only: parity_*

  • [ ] Parity accounts: parity_* (partially implemented)

  • [x] Parity set: parity_*

  • [ ] signer_*

  • [x] Own APIs (Extendable)

let web3 = Web3::new(transport);

Installation on Windows

Currently, Windows does not support IPC, which is enabled in the library by default. To compile, you need to disable the IPC feature:

web3 = { version = "0.17.0", default-features = false, features = ["http"] }

Avoiding OpenSSL dependency

On Linux, native-tls is implemented using OpenSSL. To avoid that dependency for HTTPS use the corresponding feature.

web3 = { version = "0.17.0", default-features = false, features = ["http-rustls-tls"] }

Cargo Features

The library supports following features:

  • http - Enables HTTP transport (requires tokio runtime, because of hyper).
  • http-tls - Enables TLS support via reqwest/default-tls for HTTP transport (implies http; default).
  • http-native-tls - Enables TLS support via reqwest/native-tls for HTTP transport (implies http).
  • http-rustls-tls - Enables TLS support via reqwest/rustls-tls for HTTP transport (implies http).
  • ws-tokio - Enables WS transport using tokio runtime.
  • ws-tls-tokio - Enables TLS support for WS transport (implies ws-tokio; default).
  • ws-async-std - Enables WS transport using async-std runtime.
  • ws-tls-async-std - Enables TLS support for WS transport (implies ws-async-std).
  • ipc-tokio - Enables IPC transport using tokio runtime (default).
  • signing - Enable account namespace and local-signing support (default).
  • eip-1193 - Enable EIP-1193 support.
  • wasm - Compile for WASM (make sure to disable default features).
  • arbitrary_precision - Enable arbitrary_precision in serde_json.
Related Awesome Lists
Top Programming Languages
Top Projects

Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
Rust (59,844
Transport (5,372
Tls (4,953
Web3 (2,226
Ipc (1,542