diff --git a/Cargo.lock b/Cargo.lock index fde0c6326e50..dc265e5d0f88 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -90,7 +90,7 @@ dependencies = [ [[package]] name = "alloy-consensus" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-eips", "alloy-network", @@ -98,6 +98,21 @@ dependencies = [ "alloy-rlp", ] +[[package]] +name = "alloy-contract" +version = "0.1.0" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" +dependencies = [ + "alloy-dyn-abi", + "alloy-json-abi", + "alloy-primitives", + "alloy-providers", + "alloy-rpc-types", + "alloy-sol-types", + "alloy-transport", + "thiserror", +] + [[package]] name = "alloy-dyn-abi" version = "0.6.3" @@ -122,7 +137,7 @@ dependencies = [ [[package]] name = "alloy-eips" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-primitives", "alloy-rlp", @@ -133,7 +148,7 @@ dependencies = [ [[package]] name = "alloy-genesis" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-primitives", "alloy-rpc-types", @@ -155,7 +170,7 @@ dependencies = [ [[package]] name = "alloy-json-rpc" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-primitives", "serde", @@ -166,7 +181,7 @@ dependencies = [ [[package]] name = "alloy-network" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-eips", "alloy-json-rpc", @@ -205,7 +220,7 @@ dependencies = [ [[package]] name = "alloy-providers" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-network", "alloy-primitives", @@ -224,7 +239,7 @@ dependencies = [ [[package]] name = "alloy-pubsub" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-json-rpc", "alloy-primitives", @@ -263,7 +278,7 @@ dependencies = [ [[package]] name = "alloy-rpc-client" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-json-rpc", "alloy-transport", @@ -280,7 +295,7 @@ dependencies = [ [[package]] name = "alloy-rpc-trace-types" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-primitives", "alloy-rpc-types", @@ -291,7 +306,7 @@ dependencies = [ [[package]] name = "alloy-rpc-types" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-primitives", "alloy-rlp", @@ -304,7 +319,7 @@ dependencies = [ [[package]] name = "alloy-signer" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-network", "alloy-primitives", @@ -365,7 +380,7 @@ dependencies = [ [[package]] name = "alloy-transport" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-json-rpc", "base64 0.21.7", @@ -382,7 +397,7 @@ dependencies = [ [[package]] name = "alloy-transport-http" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-json-rpc", "alloy-transport", @@ -395,7 +410,7 @@ dependencies = [ [[package]] name = "alloy-transport-ipc" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-json-rpc", "alloy-pubsub", @@ -413,7 +428,7 @@ dependencies = [ [[package]] name = "alloy-transport-ws" version = "0.1.0" -source = "git+https://github.com/alloy-rs/alloy#5062eaf1af2733a7115bc0536c9708a42bfb53ca" +source = "git+https://github.com/alloy-rs/alloy#2eaf79f2883e5221e8eeb29c14a1ed81ab60253e" dependencies = [ "alloy-pubsub", "alloy-transport", @@ -462,9 +477,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" [[package]] name = "anstream" -version = "0.6.11" +version = "0.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e2e1ebcb11de5c03c67de28a7df593d32191b44939c482e97702baaaa6ab6a5" +checksum = "96b09b5178381e0874812a9b157f7fe84982617e48f71f4e3235482775e5b540" dependencies = [ "anstyle", "anstyle-parse", @@ -514,6 +529,7 @@ version = "0.2.0" dependencies = [ "alloy-chains", "alloy-consensus", + "alloy-contract", "alloy-dyn-abi", "alloy-genesis", "alloy-network", @@ -631,9 +647,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.79" +version = "1.0.80" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "080e9890a082662b09c1ad45f567faeeb47f22b5fb23895fbe1e651e718e25ca" +checksum = "5ad32ce52e4161730f7098c077cd2ed6229b5804ccf99e5366be1ab72a98b4e1" [[package]] name = "arbitrary" @@ -797,7 +813,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3" dependencies = [ "concurrent-queue", - "event-listener 5.0.0", + "event-listener 5.1.0", "event-listener-strategy 0.5.0", "futures-core", "pin-project-lite", @@ -1233,7 +1249,7 @@ checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037" dependencies = [ "camino", "cargo-platform", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "thiserror", @@ -1291,7 +1307,7 @@ dependencies = [ "rpassword", "rusoto_core", "rusoto_kms", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "tempfile", @@ -1347,7 +1363,7 @@ dependencies = [ "reqwest", "revm", "rustyline", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "serial_test", @@ -2458,7 +2474,7 @@ dependencies = [ "chrono", "ethers-core", "reqwest", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "thiserror", @@ -2548,7 +2564,7 @@ dependencies = [ "rand 0.8.5", "rusoto_core", "rusoto_kms", - "semver 1.0.21", + "semver 1.0.22", "sha2 0.10.8", "spki", "thiserror", @@ -2577,7 +2593,7 @@ dependencies = [ "rand 0.8.5", "rayon", "regex", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "sha2 0.10.8", @@ -2612,9 +2628,9 @@ dependencies = [ [[package]] name = "event-listener" -version = "5.0.0" +version = "5.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b72557800024fabbaa2449dd4bf24e37b93702d457a4d4f2b0dd1f0f039f20c1" +checksum = "b7ad6fd685ce13acd6d9541a30f6db6567a7a24c9ffd4ba2955d29e3f22c8b27" dependencies = [ "concurrent-queue", "parking", @@ -2637,7 +2653,7 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "feedafcaa9b749175d5ac357452a9d41ea2911da598fde46ce1fe02c37751291" dependencies = [ - "event-listener 5.0.0", + "event-listener 5.1.0", "pin-project-lite", ] @@ -2873,7 +2889,7 @@ dependencies = [ "regex", "reqwest", "revm-inspectors", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "serial_test", @@ -2953,7 +2969,7 @@ dependencies = [ "alloy-primitives", "foundry-compilers", "reqwest", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "thiserror", @@ -3074,7 +3090,7 @@ dependencies = [ "pretty_assertions", "rand 0.8.5", "reqwest", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "tempfile", @@ -3109,7 +3125,7 @@ dependencies = [ "rand 0.8.5", "rayon", "regex", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "sha2 0.10.8", @@ -3145,14 +3161,14 @@ dependencies = [ "regex", "reqwest", "revm-primitives", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "serde_regex", "tempfile", "thiserror", "toml 0.8.10", - "toml_edit 0.21.1", + "toml_edit 0.22.6", "tracing", "walkdir", ] @@ -3250,7 +3266,7 @@ dependencies = [ "foundry-compilers", "foundry-evm-core", "revm", - "semver 1.0.21", + "semver 1.0.22", "tracing", ] @@ -6396,7 +6412,7 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" dependencies = [ - "semver 1.0.21", + "semver 1.0.22", ] [[package]] @@ -6510,9 +6526,9 @@ dependencies = [ [[package]] name = "ryu" -version = "1.0.16" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c" +checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1" [[package]] name = "salsa20" @@ -6683,9 +6699,9 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.21" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0" +checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca" dependencies = [ "serde", ] @@ -7171,7 +7187,7 @@ dependencies = [ "hex", "once_cell", "reqwest", - "semver 1.0.21", + "semver 1.0.22", "serde", "serde_json", "sha2 0.10.8", @@ -7188,7 +7204,7 @@ checksum = "aa64b5e8eecd3a8af7cfc311e29db31a268a62d5953233d3e8243ec77a71c4e3" dependencies = [ "build_const", "hex", - "semver 1.0.21", + "semver 1.0.22", "serde_json", "svm-rs", ] @@ -7201,7 +7217,7 @@ checksum = "5b8d3c94c4d3337336f58493471b98d712c267c66977b0fbe48efd6cbf69ffd0" dependencies = [ "build_const", "hex", - "semver 1.0.21", + "semver 1.0.22", "serde_json", "svm-rs", ] diff --git a/Cargo.toml b/Cargo.toml index 2c650152f186..8b9b774cfde5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -155,6 +155,7 @@ ethers-solc = { version = "2.0", default-features = false } ## alloy alloy-consensus = { git = "https://github.com/alloy-rs/alloy" } +alloy-contract = { git = "https://github.com/alloy-rs/alloy" } alloy-eips = { git = "https://github.com/alloy-rs/alloy" } alloy-genesis = { git = "https://github.com/alloy-rs/alloy" } alloy-json-rpc = { git = "https://github.com/alloy-rs/alloy" } diff --git a/crates/anvil/Cargo.toml b/crates/anvil/Cargo.toml index ff59985f0441..d2baf705311a 100644 --- a/crates/anvil/Cargo.toml +++ b/crates/anvil/Cargo.toml @@ -47,6 +47,7 @@ alloy-providers.workspace = true alloy-transport.workspace = true alloy-chains.workspace = true alloy-genesis.workspace = true +alloy-contract.workspace = true # axum related axum.workspace = true diff --git a/crates/anvil/tests/it/abi.rs b/crates/anvil/tests/it/abi.rs index c9cb0d7b1d81..8e3822e00075 100644 --- a/crates/anvil/tests/it/abi.rs +++ b/crates/anvil/tests/it/abi.rs @@ -1,5 +1,6 @@ //! commonly used abigen generated types +use alloy_sol_types::sol; use ethers::{ contract::{abigen, EthEvent}, types::Address, @@ -39,12 +40,79 @@ abigen!( _exists(uint256)(bool) ]"# ); -abigen!( - BUSD, - r#"[ - balanceOf(address)(uint256) -]"# -); + +sol! { + #[sol(rpc)] + contract Multicall { + struct Call { + address target; + bytes callData; + } + function aggregate(Call[] memory calls) public returns (uint256 blockNumber, bytes[] memory returnData); + function getEthBalance(address addr) public view returns (uint256 balance); + function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash); + function getLastBlockHash() public view returns (bytes32 blockHash); + function getCurrentBlockTimestamp() public view returns (uint256 timestamp); + function getCurrentBlockDifficulty() public view returns (uint256 difficulty); + function getCurrentBlockGasLimit() public view returns (uint256 gaslimit); + function getCurrentBlockCoinbase() public view returns (address coinbase); + } +} + +sol! { + #[sol(rpc)] + contract SolSimpleStorage { + event ValueChanged(address indexed author, address indexed oldAuthor, string oldValue, string newValue); + + constructor(string memory value) public; + + function getValue() view public returns (string memory); + + function setValue(string memory value) public; + + function setValues(string memory value, string memory value2); + + function _hashPuzzle() public view returns (uint256); +} + +} + +sol! { + #[sol(rpc)] + contract SolGreeter { + function greet() external view returns (string memory); + function setGreeting(string memory _greeting) external; + } +} + +sol! { + #[sol(rpc)] + contract ERC721 { + function balanceOf(address account) external view returns (uint256); + function ownerOf(uint256 tokenId) external view returns (address); + function name() external view returns (string memory); + function symbol() external view returns (string memory); + function tokenURI(uint256 tokenId) external view returns (string memory); + function getApproved(uint256 tokenId) external view returns (address); + function setApprovalForAll(address operator, bool _approved) external; + function isApprovedForAll(address owner, address operator) external view returns (bool); + function transferFrom(address from, address to, uint256 tokenId) external; + function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; + function _transfer(address from, address to, uint256 tokenId) external; + function _approve(address to, uint256 tokenId) external; + function _burn(uint256 tokenId) external; + function _safeMint(address to, uint256 tokenId, bytes calldata data) external; + function _mint(address to, uint256 tokenId) external; + function _exists(uint256 tokenId) external view returns (bool); + } +} + +sol! { + #[sol(rpc)] + contract BinanceUSD { + function balanceOf(address account) external view returns (uint256); + } +} // pub(crate) const VENDING_MACHINE_CONTRACT: &str = r#"// SPDX-License-Identifier: GPL-3.0 diff --git a/crates/anvil/tests/it/anvil.rs b/crates/anvil/tests/it/anvil.rs index 3a39f7e74664..c09fc4c46e16 100644 --- a/crates/anvil/tests/it/anvil.rs +++ b/crates/anvil/tests/it/anvil.rs @@ -1,52 +1,45 @@ //! tests for anvil specific logic -use crate::utils::ethers_http_provider; +use alloy_primitives::Address; +use alloy_providers::provider::TempProvider; use anvil::{spawn, NodeConfig}; -use ethers::{prelude::Middleware, types::Address}; -use foundry_common::types::ToAlloy; #[tokio::test(flavor = "multi_thread")] async fn test_can_change_mining_mode() { let (api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); assert!(api.anvil_get_auto_mine().unwrap()); let num = provider.get_block_number().await.unwrap(); - assert_eq!(num.as_u64(), 0); + assert_eq!(num, 0); api.anvil_set_interval_mining(1).unwrap(); assert!(!api.anvil_get_auto_mine().unwrap()); // changing the mining mode will instantly mine a new block tokio::time::sleep(std::time::Duration::from_millis(500)).await; let num = provider.get_block_number().await.unwrap(); - assert_eq!(num.as_u64(), 0); + assert_eq!(num, 0); tokio::time::sleep(std::time::Duration::from_millis(700)).await; let num = provider.get_block_number().await.unwrap(); - assert_eq!(num.as_u64(), 1); + assert_eq!(num, 1); // assert that no block is mined when the interval is set to 0 api.anvil_set_interval_mining(0).unwrap(); assert!(!api.anvil_get_auto_mine().unwrap()); tokio::time::sleep(std::time::Duration::from_millis(1000)).await; let num = provider.get_block_number().await.unwrap(); - assert_eq!(num.as_u64(), 1); + assert_eq!(num, 1); } #[tokio::test(flavor = "multi_thread")] async fn can_get_default_dev_keys() { let (_api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let dev_accounts = handle.dev_accounts().collect::>(); - let accounts = provider - .get_accounts() - .await - .unwrap() - .into_iter() - .map(ToAlloy::to_alloy) - .collect::>(); + let accounts = provider.get_accounts().await.unwrap(); assert_eq!(dev_accounts, accounts); } @@ -54,8 +47,8 @@ async fn can_get_default_dev_keys() { async fn can_set_empty_code() { let (api, _handle) = spawn(NodeConfig::test()).await; let addr = Address::random(); - api.anvil_set_code(addr.to_alloy(), Vec::new().into()).await.unwrap(); - let code = api.get_code(addr.to_alloy(), None).await.unwrap(); + api.anvil_set_code(addr, Vec::new().into()).await.unwrap(); + let code = api.get_code(addr, None).await.unwrap(); assert!(code.as_ref().is_empty()); } @@ -64,15 +57,21 @@ async fn test_can_set_genesis_timestamp() { let genesis_timestamp = 1000u64; let (_api, handle) = spawn(NodeConfig::test().with_genesis_timestamp(genesis_timestamp.into())).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); - assert_eq!(genesis_timestamp, provider.get_block(0).await.unwrap().unwrap().timestamp.as_u64()); + assert_eq!( + genesis_timestamp, + provider.get_block(0.into(), false).await.unwrap().unwrap().header.timestamp.to::() + ); } #[tokio::test(flavor = "multi_thread")] async fn test_can_use_default_genesis_timestamp() { let (_api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); - assert_ne!(0u64, provider.get_block(0).await.unwrap().unwrap().timestamp.as_u64()); + assert_ne!( + 0u64, + provider.get_block(0.into(), false).await.unwrap().unwrap().header.timestamp.to::() + ); } diff --git a/crates/anvil/tests/it/anvil_api.rs b/crates/anvil/tests/it/anvil_api.rs index e487033cc179..2d2080a842b1 100644 --- a/crates/anvil/tests/it/anvil_api.rs +++ b/crates/anvil/tests/it/anvil_api.rs @@ -1,13 +1,19 @@ //! tests for custom anvil endpoints -use crate::{abi::*, fork::fork_config, utils::ethers_http_provider}; +use crate::{ + abi::{BinanceUSD, Greeter, Multicall, SolGreeter}, + fork::fork_config, + utils::ethers_http_provider, +}; +use alloy_primitives::{Address as rAddress, B256, U256 as rU256}; +use alloy_providers::provider::TempProvider; use alloy_rpc_types::BlockNumberOrTag; +use alloy_sol_types::SolCall; use anvil::{eth::api::CLIENT_VERSION, spawn, Hardfork, NodeConfig}; use anvil_core::{ eth::EthRequest, types::{AnvilMetadata, ForkedNetwork, Forking, NodeEnvironment, NodeForkConfig, NodeInfo}, }; use ethers::{ - abi::{ethereum_types::BigEndianHash, AbiDecode}, prelude::{Middleware, SignerMiddleware}, types::{ transaction::eip2718::TypedTransaction, Address, BlockNumber, Eip1559TransactionRequest, @@ -26,10 +32,10 @@ use std::{ #[tokio::test(flavor = "multi_thread")] async fn can_set_gas_price() { let (api, handle) = spawn(NodeConfig::test().with_hardfork(Some(Hardfork::Berlin))).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); - let gas_price: U256 = 1337u64.into(); - api.anvil_set_min_gas_price(gas_price.to_alloy()).await.unwrap(); + let gas_price = rU256::from(1337u64); + api.anvil_set_min_gas_price(gas_price).await.unwrap(); assert_eq!(gas_price, provider.get_gas_price().await.unwrap()); } @@ -37,13 +43,13 @@ async fn can_set_gas_price() { async fn can_set_block_gas_limit() { let (api, _) = spawn(NodeConfig::test().with_hardfork(Some(Hardfork::Berlin))).await; - let block_gas_limit: U256 = 1337u64.into(); - assert!(api.evm_set_block_gas_limit(block_gas_limit.to_alloy()).unwrap()); + let block_gas_limit = rU256::from(1337u64); + assert!(api.evm_set_block_gas_limit(block_gas_limit).unwrap()); // Mine a new block, and check the new block gas limit api.mine_one().await; let latest_block = api.block_by_number(alloy_rpc_types::BlockNumberOrTag::Latest).await.unwrap().unwrap(); - assert_eq!(block_gas_limit.to_alloy(), latest_block.header.gas_limit); + assert_eq!(block_gas_limit, latest_block.header.gas_limit); } // Ref @@ -61,7 +67,7 @@ async fn can_set_storage() { let storage_value = api.storage_at(addr, slot, None).await.unwrap(); assert_eq!(val, storage_value); - assert_eq!(val.to_ethers(), H256::from_uint(&U256::from(12345))); + assert_eq!(val, B256::from(rU256::from(12345))); } #[tokio::test(flavor = "multi_thread")] @@ -151,6 +157,7 @@ async fn can_impersonate_contract() { let greeter_contract = Greeter::deploy(provider, "Hello World!".to_string()).unwrap().send().await.unwrap(); + let greeter = SolGreeter::new(greeter_contract.address().to_alloy(), handle.http_provider()); let impersonate = greeter_contract.address(); let to = Address::random(); @@ -168,7 +175,7 @@ async fn can_impersonate_contract() { let res = provider.send_transaction(tx.clone(), None).await; res.unwrap_err(); - let greeting = greeter_contract.greet().call().await.unwrap(); + let greeting = greeter.greet().call().await.unwrap()._0; assert_eq!("Hello World!", greeting); api.anvil_impersonate_account(impersonate.to_alloy()).await.unwrap(); @@ -183,36 +190,36 @@ async fn can_impersonate_contract() { let res = provider.send_transaction(tx, None).await; res.unwrap_err(); - let greeting = greeter_contract.greet().call().await.unwrap(); + let greeting = greeter.greet().call().await.unwrap()._0; assert_eq!("Hello World!", greeting); } #[tokio::test(flavor = "multi_thread")] async fn can_impersonate_gnosis_safe() { let (api, handle) = spawn(fork_config()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); // - let safe: Address = "0xA063Cb7CFd8E57c30c788A0572CBbf2129ae56B6".parse().unwrap(); + let safe: rAddress = "0xA063Cb7CFd8E57c30c788A0572CBbf2129ae56B6".parse().unwrap(); - let code = provider.get_code(safe, None).await.unwrap(); + let code = provider.get_code_at(safe, None).await.unwrap(); assert!(!code.is_empty()); - api.anvil_impersonate_account(safe.to_alloy()).await.unwrap(); + api.anvil_impersonate_account(safe).await.unwrap(); - let code = provider.get_code(safe, None).await.unwrap(); + let code = provider.get_code_at(safe, None).await.unwrap(); assert!(!code.is_empty()); - let balance = U256::from(1e18 as u64); + let balance = rU256::from(1e18 as u64); // fund the impersonated account - api.anvil_set_balance(safe.to_alloy(), balance.to_alloy()).await.unwrap(); + api.anvil_set_balance(safe, balance).await.unwrap(); let on_chain_balance = provider.get_balance(safe, None).await.unwrap(); assert_eq!(on_chain_balance, balance); - api.anvil_stop_impersonating_account(safe.to_alloy()).await.unwrap(); + api.anvil_stop_impersonating_account(safe).await.unwrap(); - let code = provider.get_code(safe, None).await.unwrap(); + let code = provider.get_code_at(safe, None).await.unwrap(); // code is added back after stop impersonating assert!(!code.is_empty()); } @@ -267,21 +274,21 @@ async fn can_impersonate_multiple_account() { #[tokio::test(flavor = "multi_thread")] async fn can_mine_manually() { let (api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let start_num = provider.get_block_number().await.unwrap(); for (idx, _) in std::iter::repeat(()).take(10).enumerate() { api.evm_mine(None).await.unwrap(); let num = provider.get_block_number().await.unwrap(); - assert_eq!(num, start_num + idx + 1); + assert_eq!(num, start_num + (idx as u64) + 1); } } #[tokio::test(flavor = "multi_thread")] async fn test_set_next_timestamp() { let (api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap(); @@ -292,23 +299,23 @@ async fn test_set_next_timestamp() { api.evm_mine(None).await.unwrap(); - let block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let block = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); - assert_eq!(block.number.unwrap().as_u64(), 1); - assert_eq!(block.timestamp.as_u64(), next_timestamp.as_secs()); + assert_eq!(block.header.number.unwrap().to::(), 1); + assert_eq!(block.header.timestamp.to::(), next_timestamp.as_secs()); api.evm_mine(None).await.unwrap(); - let next = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); - assert_eq!(next.number.unwrap().as_u64(), 2); + let next = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); + assert_eq!(next.header.number.unwrap().to::(), 2); - assert!(next.timestamp > block.timestamp); + assert!(next.header.timestamp > block.header.timestamp); } #[tokio::test(flavor = "multi_thread")] async fn test_evm_set_time() { let (api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap(); @@ -319,20 +326,20 @@ async fn test_evm_set_time() { // mine a block api.evm_mine(None).await.unwrap(); - let block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let block = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); - assert!(block.timestamp.as_u64() >= timestamp.as_secs()); + assert!(block.header.timestamp.to::() >= timestamp.as_secs()); api.evm_mine(None).await.unwrap(); - let next = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let next = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); - assert!(next.timestamp > block.timestamp); + assert!(next.header.timestamp > block.header.timestamp); } #[tokio::test(flavor = "multi_thread")] async fn test_evm_set_time_in_past() { let (api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap(); @@ -343,59 +350,63 @@ async fn test_evm_set_time_in_past() { // mine a block api.evm_mine(None).await.unwrap(); - let block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let block = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); - assert!(block.timestamp.as_u64() >= timestamp.as_secs()); - assert!(block.timestamp.as_u64() < now.as_secs()); + assert!(block.header.timestamp.to::() >= timestamp.as_secs()); + assert!(block.header.timestamp.to::() < now.as_secs()); } #[tokio::test(flavor = "multi_thread")] async fn test_timestamp_interval() { let (api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); api.evm_mine(None).await.unwrap(); let interval = 10; for _ in 0..5 { - let block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let block = + provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); // mock timestamp api.evm_set_block_timestamp_interval(interval).unwrap(); api.evm_mine(None).await.unwrap(); - let new_block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let new_block = + provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); - assert_eq!(new_block.timestamp, block.timestamp + interval); + assert_eq!(new_block.header.timestamp, block.header.timestamp + rU256::from(interval)); } - let block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let block = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); - let next_timestamp = block.timestamp + 50; - api.evm_set_next_block_timestamp(next_timestamp.as_u64()).unwrap(); + let next_timestamp = block.header.timestamp.to::() + 50; + api.evm_set_next_block_timestamp(next_timestamp).unwrap(); api.evm_mine(None).await.unwrap(); - let block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); - assert_eq!(block.timestamp, next_timestamp); + let block = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); + assert_eq!(block.header.timestamp.to::(), next_timestamp); api.evm_mine(None).await.unwrap(); - let block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let block = provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); // interval also works after setting the next timestamp manually - assert_eq!(block.timestamp, next_timestamp + interval); + assert_eq!(block.header.timestamp.to::(), next_timestamp + interval); assert!(api.evm_remove_block_timestamp_interval().unwrap()); api.evm_mine(None).await.unwrap(); - let new_block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let new_block = + provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); // offset is applied correctly after resetting the interval - assert!(new_block.timestamp > block.timestamp); + assert!(new_block.header.timestamp > block.header.timestamp); api.evm_mine(None).await.unwrap(); - let another_block = provider.get_block(BlockNumber::Latest).await.unwrap().unwrap(); + let another_block = + provider.get_block(BlockNumberOrTag::Latest.into(), false).await.unwrap().unwrap(); // check interval is disabled - assert!(another_block.timestamp - new_block.timestamp < U256::from(interval)); + assert!(another_block.header.timestamp - new_block.header.timestamp < rU256::from(interval)); } // @@ -403,7 +414,6 @@ async fn test_timestamp_interval() { async fn test_can_set_storage_bsc_fork() { let (api, handle) = spawn(NodeConfig::test().with_eth_rpc_url(Some("https://bsc-dataseed.binance.org/"))).await; - let provider = Arc::new(ethers_http_provider(&handle.http_endpoint())); let busd_addr: Address = "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56".parse().unwrap(); let idx: U256 = @@ -419,11 +429,14 @@ async fn test_can_set_storage_bsc_fork() { hex::decode("70a082310000000000000000000000000000000000000000000000000000000000000000") .unwrap(); - let busd = BUSD::new(busd_addr, provider); - let call = busd::BalanceOfCall::decode(&input).unwrap(); + let provider = handle.http_provider(); - let balance = busd.balance_of(call.0).call().await.unwrap(); - assert_eq!(balance, U256::from(12345u64)); + let contract = BinanceUSD::new(busd_addr.to_alloy(), provider); + let busd_call_input = BinanceUSD::balanceOfCall::abi_decode(&input, false).unwrap(); + + let balance = contract.balanceOf(busd_call_input.account).call().await.unwrap()._0; + + assert_eq!(balance, rU256::from(12345u64)); } #[tokio::test(flavor = "multi_thread")] @@ -432,15 +445,15 @@ async fn can_get_node_info() { let node_info = api.anvil_node_info().await.unwrap(); - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let block_number = provider.get_block_number().await.unwrap(); - let block = provider.get_block(block_number).await.unwrap().unwrap(); + let block = provider.get_block(block_number.into(), false).await.unwrap().unwrap(); let expected_node_info = NodeInfo { current_block_number: U64([0]).to_alloy(), current_block_timestamp: 1, - current_block_hash: block.hash.unwrap().to_alloy(), + current_block_hash: block.header.hash.unwrap(), hard_fork: SpecId::SHANGHAI, transaction_order: "fees".to_owned(), environment: NodeEnvironment { @@ -465,14 +478,14 @@ async fn can_get_metadata() { let metadata = api.anvil_metadata().await.unwrap(); - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); - let block_number = provider.get_block_number().await.unwrap().as_u64(); - let chain_id = provider.get_chainid().await.unwrap().as_u64(); - let block = provider.get_block(block_number).await.unwrap().unwrap(); + let block_number = provider.get_block_number().await.unwrap(); + let chain_id = provider.get_chain_id().await.unwrap().to::(); + let block = provider.get_block(block_number.into(), false).await.unwrap().unwrap(); let expected_metadata = AnvilMetadata { - latest_block_hash: block.hash.unwrap().to_alloy(), + latest_block_hash: block.header.hash.unwrap(), latest_block_number: block_number, chain_id, client_version: CLIENT_VERSION, @@ -488,16 +501,16 @@ async fn can_get_metadata() { async fn can_get_metadata_on_fork() { let (api, handle) = spawn(NodeConfig::test().with_eth_rpc_url(Some("https://bsc-dataseed.binance.org/"))).await; - let provider = Arc::new(ethers_http_provider(&handle.http_endpoint())); + let provider = handle.http_provider(); let metadata = api.anvil_metadata().await.unwrap(); - let block_number = provider.get_block_number().await.unwrap().as_u64(); - let chain_id = provider.get_chainid().await.unwrap().as_u64(); - let block = provider.get_block(block_number).await.unwrap().unwrap(); + let block_number = provider.get_block_number().await.unwrap(); + let chain_id = provider.get_chain_id().await.unwrap().to::(); + let block = provider.get_block(block_number.into(), false).await.unwrap().unwrap(); let expected_metadata = AnvilMetadata { - latest_block_hash: block.hash.unwrap().to_alloy(), + latest_block_hash: block.header.hash.unwrap(), latest_block_number: block_number, chain_id, client_version: CLIENT_VERSION, @@ -505,7 +518,7 @@ async fn can_get_metadata_on_fork() { forked_network: Some(ForkedNetwork { chain_id, fork_block_number: block_number, - fork_block_hash: block.hash.unwrap().to_alloy(), + fork_block_hash: block.header.hash.unwrap(), }), snapshots: Default::default(), }; @@ -563,15 +576,15 @@ async fn test_get_transaction_receipt() { #[tokio::test(flavor = "multi_thread")] async fn test_set_chain_id() { let (api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); - let chain_id = provider.get_chainid().await.unwrap(); - assert_eq!(chain_id, U256::from(31337)); + let provider = handle.http_provider(); + let chain_id = provider.get_chain_id().await.unwrap(); + assert_eq!(chain_id.to::(), 31337); let chain_id = 1234; api.anvil_set_chain_id(chain_id).await.unwrap(); - let chain_id = provider.get_chainid().await.unwrap(); - assert_eq!(chain_id, U256::from(1234)); + let chain_id = provider.get_chain_id().await.unwrap(); + assert_eq!(chain_id.to::(), 1234); } // @@ -599,7 +612,6 @@ async fn test_fork_revert_next_block_timestamp() { #[tokio::test(flavor = "multi_thread")] async fn test_fork_revert_call_latest_block_timestamp() { let (api, handle) = spawn(fork_config()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); // Mine a new block, and check the new block gas limit api.mine_one().await; @@ -609,25 +621,25 @@ async fn test_fork_revert_call_latest_block_timestamp() { api.mine_one().await; api.evm_revert(snapshot_id).await.unwrap(); - let multicall = MulticallContract::new( - Address::from_str("0xeefba1e63905ef1d7acba5a8513c70307c1ce441").unwrap(), - provider.into(), + let multicall = Multicall::new( + rAddress::from_str("0xeefba1e63905ef1d7acba5a8513c70307c1ce441").unwrap(), + handle.http_provider(), ); assert_eq!( - multicall.get_current_block_timestamp().await.unwrap(), - latest_block.header.timestamp.to_ethers() + multicall.getCurrentBlockTimestamp().call().await.unwrap().timestamp, + latest_block.header.timestamp ); assert_eq!( - multicall.get_current_block_difficulty().await.unwrap(), - latest_block.header.difficulty.to_ethers() + multicall.getCurrentBlockDifficulty().call().await.unwrap().difficulty, + latest_block.header.difficulty ); assert_eq!( - multicall.get_current_block_gas_limit().await.unwrap(), - latest_block.header.gas_limit.to_ethers() + multicall.getCurrentBlockGasLimit().call().await.unwrap().gaslimit, + latest_block.header.gas_limit ); assert_eq!( - multicall.get_current_block_coinbase().await.unwrap(), - latest_block.header.miner.to_ethers() + multicall.getCurrentBlockCoinbase().call().await.unwrap().coinbase, + latest_block.header.miner ); } diff --git a/crates/anvil/tests/it/api.rs b/crates/anvil/tests/it/api.rs index fb3c3742b2e6..721efbf8bd6b 100644 --- a/crates/anvil/tests/it/api.rs +++ b/crates/anvil/tests/it/api.rs @@ -1,9 +1,10 @@ //! general eth api tests use crate::{ - abi::{MulticallContract, SimpleStorage}, + abi::{Multicall, MulticallContract, SimpleStorage}, utils::ethers_http_provider, }; +use alloy_chains::NamedChain; use alloy_primitives::{Address as rAddress, B256, U256 as rU256}; use alloy_providers::provider::TempProvider; use alloy_rpc_types::{ @@ -19,7 +20,7 @@ use ethers::{ abi::{Address, Tokenizable}, prelude::{builders::ContractCall, decode_function_data, Middleware, SignerMiddleware}, signers::Signer, - types::{Block, BlockNumber, Chain, Transaction, TransactionRequest, U256}, + types::{Block, BlockNumber, Transaction, TransactionRequest, U256}, utils::get_contract_address, }; use foundry_common::types::{ToAlloy, ToEthers}; @@ -32,10 +33,10 @@ async fn can_get_block_number() { let block_num = api.block_number().unwrap(); assert_eq!(block_num, U256::zero().to_alloy()); - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let num = provider.get_block_number().await.unwrap(); - assert_eq!(num, block_num.to::().into()); + assert_eq!(num, block_num.to::()); } #[tokio::test(flavor = "multi_thread")] @@ -53,7 +54,7 @@ async fn can_dev_get_balance() { #[tokio::test(flavor = "multi_thread")] async fn can_get_price() { let (_api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let _ = provider.get_gas_price().await.unwrap(); } @@ -61,7 +62,7 @@ async fn can_get_price() { #[tokio::test(flavor = "multi_thread")] async fn can_get_accounts() { let (_api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let _ = provider.get_accounts().await.unwrap(); } @@ -69,31 +70,31 @@ async fn can_get_accounts() { #[tokio::test(flavor = "multi_thread")] async fn can_get_client_version() { let (_api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); - let version = provider.client_version().await.unwrap(); + let version = provider.get_client_version().await.unwrap(); assert_eq!(CLIENT_VERSION, version); } #[tokio::test(flavor = "multi_thread")] async fn can_get_chain_id() { let (_api, handle) = spawn(NodeConfig::test()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); - let chain_id = provider.get_chainid().await.unwrap(); - assert_eq!(chain_id, CHAIN_ID.into()); + let chain_id = provider.get_chain_id().await.unwrap(); + assert_eq!(chain_id.to::(), CHAIN_ID); } #[tokio::test(flavor = "multi_thread")] async fn can_modify_chain_id() { - let (_api, handle) = spawn(NodeConfig::test().with_chain_id(Some(Chain::Goerli))).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let (_api, handle) = spawn(NodeConfig::test().with_chain_id(Some(NamedChain::Goerli))).await; + let provider = &handle.http_provider(); - let chain_id = provider.get_chainid().await.unwrap(); - assert_eq!(chain_id, Chain::Goerli.into()); + let chain_id = provider.get_chain_id().await.unwrap(); + assert_eq!(chain_id.to::(), NamedChain::Goerli as u64); let chain_id = provider.get_net_version().await.unwrap(); - assert_eq!(chain_id, (Chain::Goerli as u64).to_string()); + assert_eq!(chain_id.to::(), (NamedChain::Goerli as u64)); } #[tokio::test(flavor = "multi_thread")] @@ -167,6 +168,7 @@ async fn can_get_pending_block() { async fn can_call_on_pending_block() { let (api, handle) = spawn(NodeConfig::test()).await; let provider = ethers_http_provider(&handle.http_endpoint()); + let alloy_provider = Arc::new(handle.http_provider()); let num = provider.get_block_number().await.unwrap(); assert_eq!(num.as_u64(), 0u64); @@ -203,33 +205,22 @@ async fn can_call_on_pending_block() { } // Ensure that the right header values are set when calling a past block for block_number in 1..(api.block_number().unwrap().to::() + 1) { - let block_number_alloy = alloy_rpc_types::BlockNumberOrTag::Number(block_number as u64); - let block_number_ethers = BlockNumber::Number((block_number as u64).into()); - let block = api.block_by_number(block_number_alloy).await.unwrap().unwrap(); - - let block_timestamp = pending_contract - .get_current_block_timestamp() - .block(block_number_ethers) - .call() - .await - .unwrap(); - assert_eq!(block.header.timestamp, block_timestamp.to_alloy()); - - let block_gas_limit = pending_contract - .get_current_block_gas_limit() - .block(block_number_ethers) - .call() - .await - .unwrap(); - assert_eq!(block.header.gas_limit, block_gas_limit.to_alloy()); - - let block_coinbase = pending_contract - .get_current_block_coinbase() - .block(block_number_ethers) - .call() - .await - .unwrap(); - assert_eq!(block.header.miner, block_coinbase.to_alloy()); + let block_number = alloy_rpc_types::BlockNumberOrTag::Number(block_number as u64); + let block = api.block_by_number(block_number).await.unwrap().unwrap(); + let multicall = + Multicall::new(pending_contract.address().to_alloy(), alloy_provider.clone()); + + let block_timestamp = + multicall.getCurrentBlockTimestamp().block(block_number.into()).call().await.unwrap(); + assert_eq!(block.header.timestamp, block_timestamp.timestamp); + + let block_gas_limit = + multicall.getCurrentBlockGasLimit().block(block_number.into()).call().await.unwrap(); + assert_eq!(block.header.gas_limit, block_gas_limit.gaslimit); + + let block_coinbase = + multicall.getCurrentBlockCoinbase().block(block_number.into()).call().await.unwrap(); + assert_eq!(block.header.miner, block_coinbase.coinbase); } } diff --git a/crates/anvil/tests/it/fork.rs b/crates/anvil/tests/it/fork.rs index 0bd6f7dcb78e..e7133e8f374f 100644 --- a/crates/anvil/tests/it/fork.rs +++ b/crates/anvil/tests/it/fork.rs @@ -1,10 +1,10 @@ //! various fork related test use crate::{ - abi::*, + abi::{Erc721, Greeter, SolGreeter, ERC721}, utils::{self, ethers_http_provider}, }; -use alloy_primitives::U256 as rU256; +use alloy_primitives::{Address as rAddress, U256 as rU256}; use alloy_providers::provider::TempProvider; use alloy_rpc_types::{request::TransactionRequest as CallRequest, BlockNumberOrTag}; use alloy_signer::Signer as AlloySigner; @@ -81,12 +81,12 @@ async fn test_spawn_fork() { #[tokio::test(flavor = "multi_thread")] async fn test_fork_eth_get_balance() { let (api, handle) = spawn(fork_config()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); for _ in 0..10 { - let addr = Address::random(); - let balance = api.balance(addr.to_alloy(), None).await.unwrap(); + let addr = rAddress::random(); + let balance = api.balance(addr, None).await.unwrap(); let provider_balance = provider.get_balance(addr, None).await.unwrap(); - assert_eq!(balance, provider_balance.to_alloy()) + assert_eq!(balance, provider_balance) } } @@ -94,22 +94,22 @@ async fn test_fork_eth_get_balance() { #[tokio::test(flavor = "multi_thread")] async fn test_fork_eth_get_balance_after_mine() { let (api, handle) = spawn(fork_config()).await; - let provider = ethers_http_provider(&handle.http_endpoint()); + let provider = handle.http_provider(); let info = api.anvil_node_info().await.unwrap(); let number = info.fork_config.fork_block_number.unwrap(); assert_eq!(number, BLOCK_NUMBER); - let address = Address::random(); + let address = rAddress::random(); let _balance = provider - .get_balance(address, Some(BlockNumber::Number(number.into()).into())) + .get_balance(address, Some(BlockNumberOrTag::Number(number.into()).into())) .await .unwrap(); api.evm_mine(None).await.unwrap(); let _balance = provider - .get_balance(address, Some(BlockNumber::Number(number.into()).into())) + .get_balance(address, Some(BlockNumberOrTag::Number(number.into()).into())) .await .unwrap(); } @@ -451,13 +451,17 @@ async fn can_deploy_greeter_on_fork() { .await .unwrap(); - let greeting = greeter_contract.greet().call().await.unwrap(); + let greeter = SolGreeter::new(greeter_contract.address().to_alloy(), handle.http_provider()); + + let greeting = greeter.greet().call().await.unwrap()._0; assert_eq!("Hello World!", greeting); let greeter_contract = Greeter::deploy(client, "Hello World!".to_string()).unwrap().send().await.unwrap(); - let greeting = greeter_contract.greet().call().await.unwrap(); + let greeter = SolGreeter::new(greeter_contract.address().to_alloy(), handle.http_provider()); + + let greeting = greeter.greet().call().await.unwrap()._0; assert_eq!("Hello World!", greeting); } @@ -623,15 +627,14 @@ async fn test_fork_nft_set_approve_all() { let token_id: U256 = 154u64.into(); let nouns = Erc721::new(nouns_addr, Arc::clone(&provider)); + let solnouns = ERC721::new(nouns_addr.to_alloy(), handle.http_provider()); - let real_owner = nouns.owner_of(token_id).call().await.unwrap(); - assert_eq!(real_owner, owner); + let real_owner = solnouns.ownerOf(token_id.to_alloy()).call().await.unwrap()._0; + assert_eq!(real_owner, owner.to_alloy()); let approval = nouns.set_approval_for_all(nouns_addr, true); let tx = approval.send().await.unwrap().await.unwrap().unwrap(); assert_eq!(tx.status, Some(1u64.into())); - let real_owner = real_owner.to_alloy(); - // transfer: impersonate real owner and transfer nft api.anvil_impersonate_account(real_owner).await.unwrap(); @@ -644,8 +647,8 @@ async fn test_fork_nft_set_approve_all() { let tx = provider.send_transaction(tx, None).await.unwrap().await.unwrap().unwrap(); assert_eq!(tx.status, Some(1u64.into())); - let real_owner = nouns.owner_of(token_id).call().await.unwrap(); - assert_eq!(real_owner, wallet.address()); + let real_owner = solnouns.ownerOf(token_id.to_alloy()).call().await.unwrap()._0; + assert_eq!(real_owner, wallet.address().to_alloy()); } // @@ -1034,18 +1037,20 @@ async fn can_override_fork_chain_id() { .await .unwrap(); - let greeting = greeter_contract.greet().call().await.unwrap(); + let greeter = SolGreeter::new(greeter_contract.address().to_alloy(), handle.http_provider()); + let greeting = greeter.greet().call().await.unwrap()._0; assert_eq!("Hello World!", greeting); let greeter_contract = Greeter::deploy(client, "Hello World!".to_string()).unwrap().send().await.unwrap(); - let greeting = greeter_contract.greet().call().await.unwrap(); + let greeter = SolGreeter::new(greeter_contract.address().to_alloy(), handle.http_provider()); + let greeting = greeter.greet().call().await.unwrap()._0; assert_eq!("Hello World!", greeting); - let provider = ethers_http_provider(&handle.http_endpoint()); - let chain_id = provider.get_chainid().await.unwrap(); - assert_eq!(chain_id.as_u64(), chain_id_override); + let provider = handle.http_provider(); + let chain_id = provider.get_chain_id().await.unwrap(); + assert_eq!(chain_id.to::(), chain_id_override); } // diff --git a/crates/anvil/tests/it/ipc.rs b/crates/anvil/tests/it/ipc.rs index 6e3204d9d6b3..9d58c350d494 100644 --- a/crates/anvil/tests/it/ipc.rs +++ b/crates/anvil/tests/it/ipc.rs @@ -1,6 +1,7 @@ //! IPC tests use alloy_primitives::U256; +use alloy_providers::provider::TempProvider; use anvil::{spawn, NodeConfig}; use ethers::{core::rand, prelude::Middleware}; use futures::StreamExt; @@ -27,10 +28,10 @@ async fn can_get_block_number_ipc() { let block_num = api.block_number().unwrap(); assert_eq!(block_num, U256::ZERO); - let provider = ethers_ipc_provider(handle.ipc_path()).unwrap(); + let provider = handle.ipc_provider().unwrap(); let num = provider.get_block_number().await.unwrap(); - assert_eq!(num.as_u64(), block_num.to::()); + assert_eq!(num, block_num.to::()); } #[tokio::test(flavor = "multi_thread")] diff --git a/crates/config/Cargo.toml b/crates/config/Cargo.toml index b3f4c514a766..3b1169b82438 100644 --- a/crates/config/Cargo.toml +++ b/crates/config/Cargo.toml @@ -34,7 +34,7 @@ serde_regex = "1" serde.workspace = true thiserror = "1" toml = { version = "0.8", features = ["preserve_order"] } -toml_edit = "0.21" +toml_edit = "0.22.4" tracing.workspace = true walkdir = "2"