Skip to content

Ethereum JSON-RPC multi-transport client. Rust implementation of web3 library. ENS address: rust-web3.eth

License

Notifications You must be signed in to change notification settings

sunhuachuang/rust-web3

This branch is 7 commits ahead of, 37 commits behind tomusdrw/rust-web3:master.

Folders and files

NameName
Last commit message
Last commit date
Jan 9, 2021
May 17, 2021
Jul 26, 2021
Jul 25, 2022
May 30, 2019
Feb 15, 2019
Dec 28, 2022
Jan 29, 2019
Jul 29, 2021
Feb 11, 2020
Apr 11, 2019

Repository files navigation

web3

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

Build Status Crates.io

Documentation: crates.io

Usage

First, add this to your Cargo.toml:

[dependencies]
web3 = "0.17.0"

Example

#[tokio::main]
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);
    accounts.push("00a329c0648769a73afac7f9381e08fb43dbea72".parse().unwrap());

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

    Ok(())
}

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)
  • WebSockets: TLS support (#360)
  • WebSockets: Reconnecting & Pings
  • Consider using tokio instead of async-std for ws.rs transport (issue with test).
  • Restore IPC Transport

General

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

Transports

  • HTTP transport
  • IPC transport
  • WebSockets transport

Types

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

APIs

  • Eth: eth_*
  • Eth filters: eth_*
  • Eth pubsub: eth_*
  • net_*
  • web3_*
  • personal_*
  • traces_*

Parity-specific APIs

  • Parity read-only: parity_*

  • Parity accounts: parity_* (partially implemented)

  • Parity set: parity_*

  • signer_*

  • Own APIs (Extendable)

let web3 = Web3::new(transport);
web3.api::<CustomNamespace>().custom_method().wait().unwrap()

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.

About

Ethereum JSON-RPC multi-transport client. Rust implementation of web3 library. ENS address: rust-web3.eth

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages

  • Rust 100.0%