Add EIP-1193 support

.travis.yml

@@ -33,6 +33,7 @@ before_script:
   - if [[ "${TRAVIS_RUST_VERSION}" == stable ]]; then
       rustup component add rustfmt && cargo install cargo-deny;
     fi
+  - rustup target add wasm32-unknown-unknown
 
 script:
   - if [[ "${TRAVIS_RUST_VERSION}" == "stable" ]]; then
@@ -42,6 +43,7 @@ script:
   - cargo build
   - cargo test
   - cargo check --no-default-features
+  - cargo check --target wasm32-unknown-unknown --no-default-features --features eip-1193
   - cargo check --no-default-features --features http
   - cargo check --no-default-features --features http-tls
   - cargo check --no-default-features --features ws-tokio

Cargo.toml

@@ -23,7 +23,7 @@ log = "0.4.6"
 parking_lot = "0.11.0"
 rlp = "0.4"
 rustc-hex = "2.1.0"
-secp256k1 = { version = "0.19", features = ["recovery"] }
+secp256k1 = { version = "0.19", features = ["recovery"], optional = true }
 serde = { version = "1.0.90", features = ["derive"] }
 serde_json = "1.0.39"
 tiny-keccak = { version = "2.0.1", features = ["keccak"] }
@@ -44,16 +44,24 @@ soketto = { version = "0.4.1", optional = true }
 ## Shared (WS, HTTP)
 native-tls = { version = "0.2", optional = true }
 url = { version = "2.1", optional = true }
+## EIP-1193
+js-sys = { version = "0.3.45", optional = true }
+### This is a transitive dependency, only here so we can turn on its wasm_bindgen feature
+rand = { version = "0.7.3", optional = true }
+wasm-bindgen = { version = "0.2.68", optional = true, features = ["serde-serialize"] }
+wasm-bindgen-futures = { version = "0.4.18", optional = true }
 
 [dev-dependencies]
 # For examples
 env_logger = "0.8"
 tokio = { version = "0.2", features = ["full"] }
 
 [features]
-default = ["http-tls", "ws-tls-tokio"]
+default = ["http-tls", "signing", "ws-tls-tokio"]
+eip-1193 = ["js-sys", "wasm-bindgen", "wasm-bindgen-futures", "futures-timer/wasm-bindgen", "rand/wasm-bindgen"]
 http = ["hyper", "hyper-proxy", "url", "base64", "typed-headers"]
 http-tls = ["hyper-tls", "native-tls", "http"]
+signing = ["secp256k1"]
 ws-tokio = ["soketto", "url", "tokio", "tokio-util"]
 ws-async-std = ["soketto", "url", "async-std"]
 ws-tls-tokio = ["async-native-tls", "native-tls", "async-native-tls/runtime-tokio", "ws-tokio"]

src/api/accounts.rs

@@ -1,13 +1,22 @@
 //! Partial implementation of the `Accounts` namespace.
 
-use crate::api::{Namespace, Web3};
+use crate::api::Namespace;
+#[cfg(feature = "signing")]
+use crate::api::Web3;
+#[cfg(feature = "signing")]
 use crate::error;
-use crate::signing::{self, Signature};
+use crate::signing;
+#[cfg(feature = "signing")]
+use crate::signing::Signature;
+use crate::types::H256;
+#[cfg(feature = "signing")]
 use crate::types::{
-    Address, Bytes, Recovery, RecoveryMessage, SignedData, SignedTransaction, TransactionParameters, H256, U256,
+    Address, Bytes, Recovery, RecoveryMessage, SignedData, SignedTransaction, TransactionParameters, U256,
 };
 use crate::Transport;
+#[cfg(feature = "signing")]
 use rlp::RlpStream;
+#[cfg(feature = "signing")]
 use std::convert::TryInto;
 
 /// `Accounts` namespace
@@ -31,6 +40,7 @@ impl<T: Transport> Namespace<T> for Accounts<T> {
 
 impl<T: Transport> Accounts<T> {
     /// Gets the parent `web3` namespace
+    #[cfg(feature = "signing")]
     fn web3(&self) -> Web3<T> {
         Web3::new(self.transport.clone())
     }
@@ -41,6 +51,7 @@ impl<T: Transport> Accounts<T> {
     /// parameters required for signing `nonce`, `gas_price` and `chain_id`. Note
     /// that if all transaction parameters were provided, this future will resolve
     /// immediately.
+    #[cfg(feature = "signing")]
     pub async fn sign_transaction<K: signing::Key>(
         &self,
         tx: TransactionParameters,
@@ -100,6 +111,7 @@ impl<T: Transport> Accounts<T> {
     /// notation, that is the recovery value `v` is either `27` or `28` (as
     /// opposed to the standard notation where `v` is either `0` or `1`). This
     /// is important to consider when using this signature with other crates.
+    #[cfg(feature = "signing")]
     pub fn sign<S>(&self, message: S, key: impl signing::Key) -> SignedData
     where
         S: AsRef<[u8]>,
@@ -140,6 +152,7 @@ impl<T: Transport> Accounts<T> {
     ///
     /// Recovery signature data uses 'Electrum' notation, this means the `v`
     /// value is expected to be either `27` or `28`.
+    #[cfg(feature = "signing")]
     pub fn recover<R>(&self, recovery: R) -> error::Result<Address>
     where
         R: Into<Recovery>,
@@ -158,6 +171,7 @@ impl<T: Transport> Accounts<T> {
 }
 
 /// A transaction used for RLP encoding, hashing and signing.
+#[cfg(feature = "signing")]
 struct Transaction {
     to: Option<Address>,
     nonce: U256,
@@ -167,6 +181,7 @@ struct Transaction {
     data: Vec<u8>,
 }
 
+#[cfg(feature = "signing")]
 impl Transaction {
     /// RLP encode an unsigned transaction for the specified chain ID.
     fn rlp_append_unsigned(&self, rlp: &mut RlpStream, chain_id: u64) {
@@ -205,6 +220,7 @@ impl Transaction {
     }
 
     /// Sign and return a raw signed transaction.
+    #[cfg(feature = "signing")]
     fn sign(self, sign: impl signing::Key, chain_id: u64) -> SignedTransaction {
         let mut rlp = RlpStream::new();
         self.rlp_append_unsigned(&mut rlp, chain_id);

src/api/eth.rs

@@ -171,6 +171,13 @@ impl<T: Transport> Eth<T> {
         CallFuture::new(self.transport.execute("eth_chainId", vec![]))
     }
 
+    /// Get available user accounts. This method is only available in the browser. With MetaMask,
+    /// this will cause the popup that prompts the user to allow or deny access to their accounts
+    /// to your app.
+    pub fn request_accounts(&self) -> CallFuture<Vec<Address>, T::Out> {
+        CallFuture::new(self.transport.execute("eth_requestAccounts", vec![]))
+    }
+
     /// Get storage entry
     pub fn storage(&self, address: Address, idx: U256, block: Option<BlockNumber>) -> CallFuture<H256, T::Out> {
         let address = helpers::serialize(&address);

src/contract/mod.rs

@@ -1,12 +1,17 @@
 //! Ethereum Contract Interface
 
-use crate::api::{Accounts, Eth, Namespace};
+#[cfg(feature = "signing")]
+use crate::api::Accounts;
+use crate::api::{Eth, Namespace};
 use crate::confirm;
 use crate::contract::tokens::{Detokenize, Tokenize};
+#[cfg(feature = "signing")]
 use crate::signing;
+#[cfg(feature = "signing")]
+use crate::types::TransactionParameters;
 use crate::types::{
-    Address, BlockId, Bytes, CallRequest, FilterBuilder, TransactionCondition, TransactionParameters,
-    TransactionReceipt, TransactionRequest, H256, U256,
+    Address, BlockId, Bytes, CallRequest, FilterBuilder, TransactionCondition, TransactionReceipt, TransactionRequest,
+    H256, U256,
 };
 use crate::Transport;
 use std::{collections::HashMap, hash::Hash, time};
@@ -142,6 +147,7 @@ impl<T: Transport> Contract<T> {
     }
 
     /// Execute a signed contract function and wait for confirmations
+    #[cfg(feature = "signing")]
     pub async fn signed_call_with_confirmations(
         &self,
         func: &str,

src/signing.rs

@@ -1,10 +1,16 @@
 //! Signing capabilities and utilities.
 
-use crate::types::{Address, H256};
+#[cfg(feature = "signing")]
+use crate::types::Address;
+use crate::types::H256;
+#[cfg(feature = "signing")]
 use secp256k1::recovery::{RecoverableSignature, RecoveryId};
+#[cfg(feature = "signing")]
 use secp256k1::{Message, PublicKey, Secp256k1};
+#[cfg(feature = "signing")]
 use std::ops::Deref;
 
+#[cfg(feature = "signing")]
 pub(crate) use secp256k1::SecretKey;
 
 /// Error during signing.
@@ -41,6 +47,7 @@ impl std::error::Error for RecoveryError {}
 ///
 /// If it's enough to pass a reference to `SecretKey` (lifetimes) than you can use `SecretKeyRef`
 /// wrapper.
+#[cfg(feature = "signing")]
 pub trait Key {
     /// Sign given message and include chain-id replay protection.
     ///
@@ -57,23 +64,27 @@ pub trait Key {
 ///
 /// A wrapper around `secp256k1::SecretKey` reference, which enables it to be used in methods expecting
 /// `Key` capabilities.
+#[cfg(feature = "signing")]
 pub struct SecretKeyRef<'a> {
     key: &'a SecretKey,
 }
 
+#[cfg(feature = "signing")]
 impl<'a> SecretKeyRef<'a> {
     /// A simple wrapper around a reference to `SecretKey` which allows it to be usable for signing.
     pub fn new(key: &'a SecretKey) -> Self {
         Self { key }
     }
 }
 
+#[cfg(feature = "signing")]
 impl<'a> From<&'a SecretKey> for SecretKeyRef<'a> {
     fn from(key: &'a SecretKey) -> Self {
         Self::new(key)
     }
 }
 
+#[cfg(feature = "signing")]
 impl<'a> Deref for SecretKeyRef<'a> {
     type Target = SecretKey;
 
@@ -82,6 +93,7 @@ impl<'a> Deref for SecretKeyRef<'a> {
     }
 }
 
+#[cfg(feature = "signing")]
 impl<T: Deref<Target = SecretKey>> Key for T {
     fn sign(&self, message: &[u8], chain_id: Option<u64>) -> Result<Signature, SigningError> {
         let message = Message::from_slice(&message).map_err(|_| SigningError::InvalidMessage)?;
@@ -121,6 +133,7 @@ pub struct Signature {
 /// Recover a sender, given message and the signature.
 ///
 /// Signature and `recovery_id` can be obtained from `types::Recovery` type.
+#[cfg(feature = "signing")]
 pub fn recover(message: &[u8], signature: &[u8], recovery_id: i32) -> Result<Address, RecoveryError> {
     let message = Message::from_slice(message).map_err(|_| RecoveryError::InvalidMessage)?;
     let recovery_id = RecoveryId::from_i32(recovery_id).map_err(|_| RecoveryError::InvalidSignature)?;
@@ -140,6 +153,7 @@ pub fn recover(message: &[u8], signature: &[u8], recovery_id: i32) -> Result<Add
 /// crate is 65 bytes long, that is because it is prefixed by `0x04` to
 /// indicate an uncompressed public key; this first byte is ignored when
 /// computing the hash.
+#[cfg(feature = "signing")]
 pub(crate) fn public_key_address(public_key: &PublicKey) -> Address {
     let public_key = public_key.serialize_uncompressed();
 
@@ -150,6 +164,7 @@ pub(crate) fn public_key_address(public_key: &PublicKey) -> Address {
 }
 
 /// Gets the public address of a private key.
+#[cfg(feature = "signing")]
 pub(crate) fn secret_key_address(key: &SecretKey) -> Address {
     let secp = Secp256k1::signing_only();
     let public_key = PublicKey::from_secret_key(&secp, key);