Motivation

Working with the Solc AST right now is not super ergonomic and it's making it hard to provide support for library coverage in Foundry, since for that feature we would need to walk out to each call expression node and parse the type name. It's doable currently, but a lot of the nice information in the AST is rolled into other, so it's not super easy or maintanable.

Solution

Replace the AST abstraction with more strict types. Each node gets its own type loosely based on https://github.com/OpenZeppelin/solidity-ast which claims to have a wide Solidity version support. I'll also add a Visitor trait with some walk_* helper functions for easier traversal.

I've opened up this PR because I am currently at an impasse: I've started implementing macros to generate some of the common fields in the different nodes, but we could also use struct composition instead.

The downside of struct composition is that you have to "reach" and I am having some struggle coming up with nice names. For example, the two most common fields are id and src... we could call these "meta", but then what about the expression meta-fields? If we called them "node", then it's a bit awkward since you'd probably have a lot of code doing things like node.node.id.

If we called these fields "meta", and the common expression fields "expression", then you'd instead have a lot of code doing expr.expression.

The downside of macros is that it might be slow to compile, too opaque or too inflexible.

Thoughts @mattsse @gakonst?

(Docs + doc comments and so on coming later, this is very much a WIP)

PR Checklist

• [ ] Added Tests
• [ ] Added Documentation
• [ ] Updated the changelog

Is your feature request related to a problem? Please describe. Rust does not implement the Default for [T; N] where N > 32. So if a solidity function has an input parameter with type uint256[40], abigen! can not work well.

Describe the solution you'd like Introduce a custom trait CustomDefault, which has the same behavior as the Default trait, except the way to initialize an array [T; N]. It simply assumes T: Clone and initializes [T; N] by [T::custom_default(); N]. Then implement Default for solidity structs/inputs by CustomDefault.

Describe alternatives you've considered

Alternative 1: Manually implementing the Default trait in the procedure macro.

Alternative 2: Use a wrapped type for large fixed arrays. Like what you did for Uint8.

This commit provides an initial implementation for a derive macro to encode typed data according to EIP-712, https://eips.ethereum.org/EIPS/eip-712

Additionally, this commit introduces a new signer trait method:

    async fn sign_typed_data<T: Eip712 + Send + Sync>(
        &self,
        payload: &T,
    ) -> Result<Signature, Self::Error>;

And implements the new method for each of the signers (wallet, ledger, aws).

At the moment, derive does not recurse the primary type to find nested Eip712 structs. In the future, a field helper attribute #[eip712] could be used to denote a nested field and handle the proper encoding for the field.

Motivation

#16

Solution

This implementation is based on the proposed solution in #16 .

PR Checklist

• [x] Added Tests
• [x] Added Documentation
• [x] Updated the changelog

Motivation

I was trying to call multiple contracts concurrently by aggregating calls into a vec, so that I can join_all(calls).await them later.

Since ContractCall::call(&self) takes an immutable reference, compiler prevents future from being created because future references ContractCall, which may not live long enough.

I’ve tried Box-ing ContractCall, but it didn’t quite work.

Solution

Add another method that takes ownership: call_owned(self). That completely solved my problem.

PR Checklist

• [ ] Added Tests
• [x] Added Documentation
• [ ] Updated the changelog

Motivation

Currently Foundry and ethers-rs is not capable of compiling Yul sources (https://github.com/gakonst/foundry/issues/759)

Solution

Add yul compilation

Will address #791

• [x] Fix downstream issue of ambiguous contract naming
• [x] Handle collision of artifacts compiled with different version
• [x] Add convenience methods so the cache can be queried for artifact compile info (optim. runs, comp. version)
• [ ] ~~Support foundry config file~~

Currently this changes ProjectCompileOutput::into_artifacts to return dapptools-style contract names. Example:

Greet.json:Greet

becomes:

src/test/Greeter.t.sol:Greet

This fixes this issue w/o any material changes on the foundry side.

Internally this does two main things:

1. Changes how output contract paths are created
2. Preserves relative paths within the artifacts directory

#\2 is to be able to re-map artifact paths to source paths. During compilation, source paths are discarded and since artifacts don't carry metadata, there's no clean way to carry them around. Keeping relative paths in the artifacts dir solves this.

@mattsse let me know if you think #\2 is problematic. The flat structure of the artifacts dir seems unnecessary to me, but I may be missing something.

We could also add compiler versions to paths to avoid the related collision issue.

WIP

Version

├── ethers v0.5.4 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   ├── ethers-contract v0.5.3 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   ├── ethers-contract-abigen v0.5.3 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   ├── ethers-contract-derive v0.5.3 (proc-macro) (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   │   ├── ethers-contract-abigen v0.5.3 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   │   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   │   ├── ethers-derive-eip712 v0.1.0 (proc-macro) (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   │   ├── ethers-providers v0.5.4 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   ├── ethers-middleware v0.5.3 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   ├── ethers-contract v0.5.3 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   │   ├── ethers-providers v0.5.4 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   │   ├── ethers-signers v0.5.3 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│   │   │   ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   ├── ethers-providers v0.5.4 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   ├── ethers-signers v0.5.3 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)
│   └── ethers-solc v0.1.0 (https://github.com/gakonst/ethers-rs.git#ec00325a)
│       ├── ethers-core v0.5.5 (https://github.com/gakonst/ethers-rs.git#ec00325a) (*)

Platform windows 11

Description use the etheris sign a typed data and then copy the data & signature to rust side, it verified failed

the js code

const {Wallet, ethers} = require("ethers");
const crypto = require('crypto');

async function sign_eip712() {
    const mnemonic = "announce room limb pattern dry unit scale effort smooth jazz weasel alcohol"
    const walletMnemonic = Wallet.fromMnemonic(mnemonic)


    const domain = {
        name: 'Relationship dApp',
        version: '1',
        chainId: 1,
        verifyingContract: '0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc',
        //salt: 'aBrqX434MenBV2yBhAf5oD7VrqbSLW3p'
    };

    const types = {
        Receipt : [
            { name: 'address', type: 'string' },
            { name: 'nonce', type: 'string' },
            { name: 'timestamp', type: 'uint256' }
        ]
    };

    const value = {
        address: walletMnemonic.address,
        nonce: crypto.randomBytes(16).toString('base64'),
        timestamp: Math.floor(Date.now() / 1000)
    };

    const rawSignature = await walletMnemonic._signTypedData(domain, types, value);
    const signature = ethers.utils.splitSignature(rawSignature);
    console.log(JSON.stringify({
        address: value.address,
        nonce: value.nonce,
        timestamp: value.timestamp,
        r: signature.r,
        s: signature.s,
        v: signature.v
    }));
}

sign_eip712().then(_ => {})

rust code:

use chrono::{Duration, TimeZone, Utc};
use ethers::types::U256;
use ethers::{
    contract::{Eip712, EthAbiType},
    core::types::transaction::eip712::Eip712,
    types::{Address, Signature},
    utils::hex,
};
use serde::{Deserialize, Deserializer};

fn deserialize_u256_from_i64<'de, D>(deserializer: D) -> Result<U256, D::Error>
where
    D: Deserializer<'de>,
{
    i64::deserialize(deserializer).map(U256::from)
}

#[derive(Clone, Debug, Deserialize, Eip712, EthAbiType)]
#[eip712(
    name = "Relationship dApp",
    version = "1",
    chain_id = 1,
    verifying_contract = "0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc"
)]
pub struct Receipt {
    pub address: Address,
    pub nonce: String,
    #[serde(deserialize_with = "deserialize_u256_from_i64")]
    pub timestamp: U256,
}

impl Receipt {
    pub fn is_expired(&self, expired: Duration) -> bool {
        let datetime = Utc.timestamp(self.timestamp.try_into().unwrap(), 0);
        (Utc::now() - datetime) > expired
    }

    pub fn verify(&self, signature: &Signature) -> anyhow::Result<()> {
        self.encode_eip712()
            .map_err(anyhow::Error::from)
            .and_then(|receipt_hash| {
                signature
                    .verify(receipt_hash, self.address)
                    .map_err(anyhow::Error::from)
            })
            .map_err(Into::into)
    }
}

Motivation

This reverts parts of #1943 because that PR did not pass all checks and will likely cause a lot of issues in foundry just because there are a lot of different version-specific variants which are likely not covered.

My suggesting is:

1. partially revert #1943 breaking changes with this PR
2. fix tests first
3. more tests for all versions
4. reconsider replacing Ast with SourceUnit

Since the AST is not of interest in most cases, we ca also handle it similar to Metadata where we just use the Json and add a separate function to deserialize the SourceUnit this makes it less error prone for foundry use case and you can still get the deserialized object via an additional call if you need that.

wdyt @iFrostizz ?

Solution

PR Checklist

• [ ] Added Tests
• [ ] Added Documentation
• [ ] Updated the changelog
• [ ] Breaking changes

Version ethers-signers = { version = "0.6.2", features = ["ledger"]} ethers-core = "^0.6"

cargo tree | grep ethers ├── ethers-core v0.6.3 ├── ethers-signers v0.6.2 │ ├── ethers-core v0.6.3 (*)

Platform Darwin molindeMacBook-Pro-2.local 21.1.0 Darwin Kernel Version 21.1.0: Wed Oct 13 17:33:01 PDT 2021; root:xnu-8019.41.5~1/RELEASE_ARM64_T6000 arm64

Description Ledger sign_tx can not work anymore. always show LedgerError(BadRetcode(BadKeyHandle))

I tried this code:

pub async fn signs_ledger() -> Result<(),()> {
  let ledger = Ledger::new(HDPath::LedgerLive(0), 1).await;
  match ledger {
    Ok(wallet) => {
      println!("Ledger: {:?}", wallet);

      let data = hex::decode("095ea7b30000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488dffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();

      let tx_req = TransactionRequest::new()
        .to("0x2ed7afa17473e17ac59908f088b4371d28585476".parse::<Address>().unwrap())
        .gas(1000000)
        .gas_price(400e9 as u64)
        .nonce(5)
        .data(data)
        .value(ethers_core::utils::parse_ether(100).unwrap())
        .into();
      
      println!("tx_req {:?}", tx_req);
      
      let tx = wallet.sign_tx(&tx_req).await;
      match tx {
        Ok(tx_ret) => println!("txRet {:?}", tx_ret),
        Err(e) => println!("Err {:?}", e),
      }
    },
    Err(e) => {
      println!("ERROR {:?}", e.to_string());
    }
  }
  
  Ok(())
}

I expected to see this happen:

Ledger: LedgerEthereum { transport: Mutex { is_locked: false, has_waiters: false }, derivation: LedgerLive(0), chain_id: 1, address: 0x0242e3f6ced3817bd4cbc80b66f59bf2970c157c }
tx_req Legacy(TransactionRequest { from: None, to: Some(Address(0x2ed7afa17473e17ac59908f088b4371d28585476)), gas: Some(1000000), gas_price: Some(400000000000), value: Some(100000000000000000000), data: Some(Bytes(b"\t^\xa7\xb3\0\0\0\0\0\0\0\0\0\0\0\0z%\rV0\xb4\xcfS\x979\xdf,]\xac\xb4\xc6Y\xf2H\x8d\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff")), nonce: Some(5) })
Err LedgerError(BadRetcode(BadKeyHandle))

Instead, this happened: LedgerError(BadRetcode(BadKeyHandle))

Version

├── ethers v0.6.2
│   ├── ethers-contract v0.6.2
│   │   ├── ethers-contract-abigen v0.6.3
│   │   │   ├── ethers-core v0.6.3
│   │   ├── ethers-contract-derive v0.6.3 (proc-macro)
│   │   │   ├── ethers-contract-abigen v0.6.3
│   │   │   │   ├── ethers-core v0.6.3
│   │   │   ├── ethers-core v0.6.3 (*)
│   │   ├── ethers-core v0.6.3 (*)
│   │   ├── ethers-providers v0.6.2
│   │   │   ├── ethers-core v0.6.3 (*)
│   ├── ethers-core v0.6.3 (*)
│   ├── ethers-etherscan v0.2.2
│   │   ├── ethers-core v0.6.3 (*)
│   ├── ethers-middleware v0.6.2
│   │   ├── ethers-contract v0.6.2 (*)
│   │   ├── ethers-core v0.6.3 (*)
│   │   ├── ethers-etherscan v0.2.2 (*)
│   │   ├── ethers-providers v0.6.2 (*)
│   │   ├── ethers-signers v0.6.2
│   │   │   ├── ethers-core v0.6.3 (*)
│   ├── ethers-providers v0.6.2 (*)
│   ├── ethers-signers v0.6.2 (*)
│   └── ethers-solc v0.1.2
│       ├── ethers-core v0.6.3 (*)

Platform

Linux dev 5.4.0-96-generic #109-Ubuntu SMP Wed Jan 12 16:49:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

Description

Using the abigen macro results in rust-analyzer errors, which in turn make code completion unusable.

/Cargo.toml

[package]
name = "demo"
version = "0.1.0"
edition = "2021"

[dependencies]
ethers = "=0.6.2"
serde_json = "=1.0.79"

/src/main.rs

use ethers::prelude::abigen;

abigen!(ERC20, "src/ERC20.json");

fn main() {}

/src/ERC20.json

[
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "balanceOf",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  }
]

The code compiles just fine:

$ cargo build
    Finished dev [unoptimized + debuginfo] target(s) in 0.10s

But rust-analyzer is not happy:

Not sure if it's just me though.

Motivation

The examples directory is the first place for developers to onboard quickly on ethers-rs. Anyway the lack of a proper structure makes it difficult to find useful content.

Solution

I catched your desire to provide something similar to this ebook repo and started restructuring the entire folder providing:

1. ToC README in the root dir
2. Refactor examples by topic
3. Provide new examples where missing
4. In another PR create a CI step to export docs in convenient formats

I'll leave this in DRAFT till completion of the first 3 points. @gakonst @mattsse @prestwich let me know if the ToC is missing some core topics.

Thank you guys

PR Checklist

• [ ] Added Tests
• [x] Added Documentation
• [ ] Updated the changelog
• [ ] Breaking changes

Motivation

Docs improvement

Solution

• [x] Provided examples for the MockProvider
• [x] Extended the mdbook

PR Checklist

• [ ] Added Tests
• [x] Added Documentation
• [ ] Updated the changelog
• [ ] Breaking changes

Bumps solang-parser from 0.1.18 to 0.2.1.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

fixes #2004

Need some guidance on creating test(s) and updating docs

PR Checklist

• [ ] Added Tests
• [ ] Added Documentation
• [ ] Updated the changelog
• [ ] Breaking changes

Version ethers-solc v1.0.2

Platform Linux ash11 4.15.0-143-generic #147-Ubuntu SMP Wed Apr 14 16:10:11 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux

Description Using solc installed from solc-select the version cannot be parsed.

When parsing the solc version I get the error: SemverError(Error("unexpected end of input while parsing major version number"))

Running solc --version I get:

solc, the solidity compiler commandline interface
Version: 0.8.12+commit.f00d7308.Linux.g++

After some debugging of this code: https://github.com/gakonst/ethers-rs/blob/master/ethers-solc/src/compile/mod.rs#L684-L697

I found that solc --version output includes two trailing newlines:

[src/compile/mod.rs:687] &output = Output {
  status: ExitStatus(
    unix_wait_status(
      0,
    ),
  ),
  stdout: "solc, the solidity compiler commandline interface\nVersion: 0.8.12+commit.f00d7308.Linux.g++\n\n",
  stderr: "",
}
[src/compile/mod.rs:689] output.stdout.lines().last() = Some(
  Ok(
    "",
  ),
)

The last() call evaluates to an empty string causing the version parsing to fail.

I fixed locally by stripping newlines as follows:

fn version_from_output(output: Output) -> Result<Version> {
    if output.status.success() {
        let version =
            output.
            stdout.
            lines().
            **filter(|l| !l.as_ref().unwrap().is_empty()).**
            last()
            .ok_or_else(|| SolcError::solc("version not found in solc output"))?
            .map_err(|err| SolcError::msg(format!("Failed to read output: {err}")))?;
        // NOTE: semver doesn't like `+` in g++ in build metadata which is invalid semver
        //dbg!(&version);
        Ok(Version::from_str(&version.trim_start_matches("Version: ").replace(".g++", ".gcc"))?)
    } else {
        Err(SolcError::solc(String::from_utf8_lossy(&output.stderr).to_string()))
    }
}

Is your feature request related to a problem? Please describe.

No.

Describe the solution you'd like

Please make https://github.com/gakonst/ethers-rs/blob/master/ethers-providers/src/transports/common.rs accessible to external crates. Current workaround is just copying the whole file: https://github.com/x04/nfty-public/blob/21b21f70d755a6af7d6b23c5b34bb1bcda4cff7f/nfty/src/flashbots/jsonrpc.rs

// NOTE: This module only exists since there is no way to use the data structures
// in the `ethers-providers/src/transports/common.rs` from another crate.

Describe alternatives you've considered

Change mod transports to pub mod transports.

And change the following fields to pub:

pub struct Request<'a, T> {
    pub id: u64,
    pub jsonrpc: &'a str,
    pub method: &'a str,
    #[serde(skip_serializing_if = "is_zst")]
    pub params: T,
}

Happy to contribute if it's ok with the maintainers.

Additional context

N/A

https://github.com/gakonst/ethers-rs/actions/runs/3816587795/jobs/6492313112

due to eth gas station EOL

TODO

• remove test

cc @DaniPopes easy pick off