2019-01-07 11:33:07 +01:00
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity Ethereum.
2016-05-26 16:59:59 +02:00
2019-01-07 11:33:07 +01:00
// Parity Ethereum is free software: you can redistribute it and/or modify
2016-05-26 16:59:59 +02:00
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
2019-01-07 11:33:07 +01:00
// Parity Ethereum is distributed in the hope that it will be useful,
2016-05-26 16:59:59 +02:00
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
2019-01-07 11:33:07 +01:00
// along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
2016-05-26 16:59:59 +02:00
use std ::{
collections ::HashMap ,
str ::FromStr ,
2016-07-13 19:59:59 +02:00
sync ::Arc ,
2018-03-14 12:29:52 +01:00
time ::{ Duration , Instant , SystemTime , UNIX_EPOCH } ,
} ;
2016-11-18 11:03:29 +01:00
2019-02-07 14:34:24 +01:00
use accounts ::AccountProvider ;
2019-11-11 21:57:38 +01:00
use ethcore ::{
client ::{ BlockChainClient , EachBlockWith , Executed , TestBlockChainClient } ,
2019-02-07 14:34:24 +01:00
miner ::{ self , MinerService } ,
} ;
2019-11-11 21:57:38 +01:00
use ethereum_types ::{ Address , Bloom , H160 , H256 , U256 } ;
2018-01-11 17:49:10 +01:00
use miner ::external ::ExternalMiner ;
2019-01-04 14:05:46 +01:00
use parity_runtime ::Runtime ;
use parking_lot ::Mutex ;
2018-01-11 17:49:10 +01:00
use rlp ;
use rustc_hex ::{ FromHex , ToHex } ;
2019-01-04 14:05:46 +01:00
use sync ::SyncState ;
2019-11-11 21:57:38 +01:00
use types ::{
ids ::{ BlockId , TransactionId } ,
log_entry ::{ LocalizedLogEntry , LogEntry } ,
receipt ::{ LocalizedReceipt , RichReceipt , TransactionOutcome } ,
transaction ::{ Action , Transaction } ,
} ;
2016-11-18 11:03:29 +01:00
2017-01-11 20:02:27 +01:00
use jsonrpc_core ::IoHandler ;
2019-02-07 14:34:24 +01:00
use v1 ::{
metadata ::Metadata ,
2016-10-31 17:32:53 +01:00
tests ::helpers ::{ Config , TestMinerService , TestSnapshotService , TestSyncProvider } ,
2017-01-11 20:02:27 +01:00
Eth , EthClient , EthClientOptions , EthFilter , EthFilterClient ,
} ;
2016-05-26 16:59:59 +02:00
fn blockchain_client ( ) -> Arc < TestBlockChainClient > {
let client = TestBlockChainClient ::new ( ) ;
Arc ::new ( client )
}
2016-06-20 00:10:34 +02:00
fn accounts_provider ( ) -> Arc < AccountProvider > {
Arc ::new ( AccountProvider ::transient_provider ( ) )
2016-05-26 16:59:59 +02:00
}
fn sync_provider ( ) -> Arc < TestSyncProvider > {
Arc ::new ( TestSyncProvider ::new ( Config {
2016-11-03 22:22:25 +01:00
network_id : 3 ,
2016-05-26 16:59:59 +02:00
num_peers : 120 ,
} ) )
}
fn miner_service ( ) -> Arc < TestMinerService > {
Arc ::new ( TestMinerService ::default ( ) )
}
2016-10-31 17:32:53 +01:00
fn snapshot_service ( ) -> Arc < TestSnapshotService > {
Arc ::new ( TestSnapshotService ::new ( ) )
}
2016-05-26 16:59:59 +02:00
struct EthTester {
2018-10-22 09:40:50 +02:00
pub runtime : Runtime ,
2016-05-26 16:59:59 +02:00
pub client : Arc < TestBlockChainClient > ,
pub sync : Arc < TestSyncProvider > ,
2016-06-20 00:10:34 +02:00
pub accounts_provider : Arc < AccountProvider > ,
2016-07-14 12:16:53 +02:00
pub miner : Arc < TestMinerService > ,
2016-10-31 17:32:53 +01:00
pub snapshot : Arc < TestSnapshotService > ,
2016-08-02 18:53:32 +02:00
hashrates : Arc < Mutex < HashMap < H256 , ( Instant , U256 ) > > > ,
2017-01-11 20:02:27 +01:00
pub io : IoHandler < Metadata > ,
2016-05-26 16:59:59 +02:00
}
impl Default for EthTester {
fn default ( ) -> Self {
2016-08-03 15:31:00 +02:00
Self ::new_with_options ( Default ::default ( ) )
}
}
impl EthTester {
pub fn new_with_options ( options : EthClientOptions ) -> Self {
2018-10-22 09:40:50 +02:00
let runtime = Runtime ::with_thread_count ( 1 ) ;
2016-05-26 16:59:59 +02:00
let client = blockchain_client ( ) ;
let sync = sync_provider ( ) ;
let ap = accounts_provider ( ) ;
2019-02-07 14:34:24 +01:00
let ap2 = ap . clone ( ) ;
let opt_ap = Arc ::new ( move | | ap2 . accounts ( ) . unwrap_or_default ( ) ) as _ ;
2016-05-26 16:59:59 +02:00
let miner = miner_service ( ) ;
2016-10-31 17:32:53 +01:00
let snapshot = snapshot_service ( ) ;
2016-08-02 18:53:32 +02:00
let hashrates = Arc ::new ( Mutex ::new ( HashMap ::new ( ) ) ) ;
2016-05-26 16:59:59 +02:00
let external_miner = Arc ::new ( ExternalMiner ::new ( hashrates . clone ( ) ) ) ;
2017-03-29 17:07:58 +02:00
let eth = EthClient ::new (
& client ,
& snapshot ,
& sync ,
& opt_ap ,
& miner ,
& external_miner ,
options ,
2020-08-05 06:08:03 +02:00
)
2017-03-29 17:07:58 +02:00
. to_delegate ( ) ;
2018-11-16 12:39:29 +01:00
let filter = EthFilterClient ::new ( client . clone ( ) , miner . clone ( ) , 60 ) . to_delegate ( ) ;
2020-08-05 06:08:03 +02:00
2017-01-11 20:02:27 +01:00
let mut io : IoHandler < Metadata > = IoHandler ::default ( ) ;
io . extend_with ( eth ) ;
io . extend_with ( filter ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
EthTester {
2018-10-22 09:40:50 +02:00
runtime ,
2019-11-11 21:57:38 +01:00
client ,
sync ,
2016-05-26 16:59:59 +02:00
accounts_provider : ap ,
2019-11-11 21:57:38 +01:00
miner ,
snapshot ,
io ,
hashrates ,
2016-05-26 16:59:59 +02:00
}
2020-08-05 06:08:03 +02:00
}
2016-10-19 18:35:39 +02:00
pub fn add_blocks ( & self , count : usize , with : EachBlockWith ) {
self . client . add_blocks ( count , with ) ;
self . sync . increase_imported_block_number ( count as u64 ) ;
}
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_protocol_version ( ) {
let request = r # "{"jsonrpc": "2.0", "method": "eth_protocolVersion", "params": [], "id": 1}"# ;
let response = r # "{"jsonrpc":"2.0","result":"63","id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_syncing ( ) {
2016-10-31 17:32:53 +01:00
use ethcore ::snapshot ::RestorationStatus ;
2020-08-05 06:08:03 +02:00
2016-05-30 12:33:49 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_syncing", "params": [], "id": 1}"# ;
2020-08-05 06:08:03 +02:00
2016-05-30 12:33:49 +02:00
let tester = EthTester ::default ( ) ;
2020-08-05 06:08:03 +02:00
2016-05-30 12:33:49 +02:00
let false_res = r # "{"jsonrpc":"2.0","result":false,"id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( false_res . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2016-05-30 12:33:49 +02:00
{
2016-07-13 19:59:59 +02:00
let mut status = tester . sync . status . write ( ) ;
2016-05-30 12:33:49 +02:00
status . state = SyncState ::Blocks ;
status . highest_block_number = Some ( 2500 ) ;
}
2020-08-05 06:08:03 +02:00
2016-10-19 18:35:39 +02:00
// "sync" to 1000 blocks.
// causes TestBlockChainClient to return 1000 for its best block number.
tester . add_blocks ( 1000 , EachBlockWith ::Nothing ) ;
2020-08-05 06:08:03 +02:00
2016-12-19 15:27:17 +01:00
let true_res = r # "{"jsonrpc":"2.0","result":{"currentBlock":"0x3e8","highestBlock":"0x9c4","startingBlock":"0x0","warpChunksAmount":null,"warpChunksProcessed":null},"id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( true_res . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2016-10-31 17:32:53 +01:00
* tester . client . ancient_block . write ( ) = None ;
* tester . client . first_block . write ( ) = None ;
2020-08-05 06:08:03 +02:00
2016-12-19 15:27:17 +01:00
let snap_res = r # "{"jsonrpc":"2.0","result":{"currentBlock":"0x3e8","highestBlock":"0x9c4","startingBlock":"0x0","warpChunksAmount":"0x32","warpChunksProcessed":"0x18"},"id":1}"# ;
2016-10-31 17:32:53 +01:00
tester . snapshot . set_status ( RestorationStatus ::Ongoing {
state_chunks : 40 ,
block_chunks : 10 ,
state_chunks_done : 18 ,
block_chunks_done : 6 ,
} ) ;
2020-08-05 06:08:03 +02:00
2016-10-31 17:32:53 +01:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( snap_res . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2016-10-31 17:32:53 +01:00
tester . snapshot . set_status ( RestorationStatus ::Inactive ) ;
2020-08-05 06:08:03 +02:00
2016-10-19 18:35:39 +02:00
// finish "syncing"
tester . add_blocks ( 1500 , EachBlockWith ::Nothing ) ;
2020-08-05 06:08:03 +02:00
2016-05-31 10:31:36 +02:00
{
2016-10-19 18:35:39 +02:00
let mut status = tester . sync . status . write ( ) ;
status . state = SyncState ::Idle ;
2016-05-31 10:31:36 +02:00
}
2020-08-05 06:08:03 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( false_res . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2018-10-20 21:13:23 +02:00
#[ test ]
fn rpc_eth_chain_id ( ) {
let tester = EthTester ::default ( ) ;
let request = r # "{"jsonrpc": "2.0", "method": "eth_chainId", "params": [], "id": 1}"# ;
let response = r # "{"jsonrpc":"2.0","result":null,"id":1}"# ;
2020-08-05 06:08:03 +02:00
2018-10-20 21:13:23 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
}
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_hashrate ( ) {
let tester = EthTester ::default ( ) ;
2016-08-02 18:53:32 +02:00
tester . hashrates . lock ( ) . insert (
H256 ::from ( 0 ) ,
( Instant ::now ( ) + Duration ::from_secs ( 2 ) , U256 ::from ( 0xfffa ) ) ,
) ;
tester . hashrates . lock ( ) . insert (
H256 ::from ( 0 ) ,
( Instant ::now ( ) + Duration ::from_secs ( 2 ) , U256 ::from ( 0xfffb ) ) ,
) ;
tester . hashrates . lock ( ) . insert (
H256 ::from ( 1 ) ,
( Instant ::now ( ) + Duration ::from_secs ( 2 ) , U256 ::from ( 0x1 ) ) ,
2020-08-05 06:08:03 +02:00
) ;
2016-05-26 16:59:59 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_hashrate", "params": [], "id": 1}"# ;
let response = r # "{"jsonrpc":"2.0","result":"0xfffc","id":1}"# ;
2020-08-05 06:08:03 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2016-09-14 12:02:30 +02:00
#[ test ]
fn rpc_eth_logs ( ) {
let tester = EthTester ::default ( ) ;
2016-09-21 12:51:10 +02:00
tester . client . set_logs ( vec! [
LocalizedLogEntry {
block_number : 1 ,
block_hash : H256 ::default ( ) ,
entry : LogEntry {
address : Address ::default ( ) ,
topics : vec ! [ ] ,
data : vec ! [ 1 , 2 , 3 ] ,
} ,
transaction_index : 0 ,
2016-12-29 19:48:28 +01:00
transaction_log_index : 0 ,
2016-09-21 12:51:10 +02:00
transaction_hash : H256 ::default ( ) ,
log_index : 0 ,
} ,
LocalizedLogEntry {
block_number : 1 ,
block_hash : H256 ::default ( ) ,
entry : LogEntry {
address : Address ::default ( ) ,
topics : vec ! [ ] ,
data : vec ! [ 1 , 2 , 3 ] ,
} ,
transaction_index : 0 ,
2016-12-29 19:48:28 +01:00
transaction_log_index : 1 ,
2016-09-21 12:51:10 +02:00
transaction_hash : H256 ::default ( ) ,
2016-12-29 19:48:28 +01:00
log_index : 1 ,
2016-09-21 12:51:10 +02:00
} ,
] ) ;
2020-08-05 06:08:03 +02:00
2016-09-21 12:51:10 +02:00
let request1 = r # "{"jsonrpc": "2.0", "method": "eth_getLogs", "params": [{}], "id": 1}"# ;
let request2 =
r # "{"jsonrpc": "2.0", "method": "eth_getLogs", "params": [{"limit":1}], "id": 1}"# ;
let request3 =
r # "{"jsonrpc": "2.0", "method": "eth_getLogs", "params": [{"limit":0}], "id": 1}"# ;
2020-08-05 06:08:03 +02:00
2018-06-13 13:39:27 +02:00
let response1 = r # "{"jsonrpc":"2.0","result":[{"address":"0x0000000000000000000000000000000000000000","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","blockNumber":"0x1","data":"0x010203","logIndex":"0x0","removed":false,"topics":[],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","transactionLogIndex":"0x0","type":"mined"},{"address":"0x0000000000000000000000000000000000000000","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","blockNumber":"0x1","data":"0x010203","logIndex":"0x1","removed":false,"topics":[],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","transactionLogIndex":"0x1","type":"mined"}],"id":1}"# ;
let response2 = r # "{"jsonrpc":"2.0","result":[{"address":"0x0000000000000000000000000000000000000000","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","blockNumber":"0x1","data":"0x010203","logIndex":"0x1","removed":false,"topics":[],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","transactionLogIndex":"0x1","type":"mined"}],"id":1}"# ;
2016-09-21 12:51:10 +02:00
let response3 = r # "{"jsonrpc":"2.0","result":[],"id":1}"# ;
2020-08-05 06:08:03 +02:00
2016-09-21 12:51:10 +02:00
assert_eq! (
tester . io . handle_request_sync ( request1 ) ,
Some ( response1 . to_owned ( ) )
) ;
assert_eq! (
tester . io . handle_request_sync ( request2 ) ,
Some ( response2 . to_owned ( ) )
) ;
assert_eq! (
tester . io . handle_request_sync ( request3 ) ,
Some ( response3 . to_owned ( ) )
) ;
2016-09-14 12:02:30 +02:00
}
2018-08-13 09:47:10 +02:00
#[ test ]
fn rpc_eth_logs_error ( ) {
let tester = EthTester ::default ( ) ;
tester
. client
. set_error_on_logs ( Some ( BlockId ::Hash ( H256 ::from ( [ 5 u8 ] . as_ref ( ) ) ) ) ) ;
let request = r # "{"jsonrpc": "2.0", "method": "eth_getLogs", "params": [{"limit":1,"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}], "id": 1}"# ;
let response = r # "{"jsonrpc":"2.0","error":{"code":-32000,"message":"One of the blocks specified in filter (fromBlock, toBlock or blockHash) cannot be found","data":"0x0500000000000000000000000000000000000000000000000000000000000000"},"id":1}"# ;
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
}
2016-09-14 12:02:30 +02:00
#[ test ]
2016-09-21 12:51:10 +02:00
fn rpc_logs_filter ( ) {
2016-09-14 12:02:30 +02:00
let tester = EthTester ::default ( ) ;
2016-09-21 12:51:10 +02:00
// Set some logs
tester . client . set_logs ( vec! [
LocalizedLogEntry {
block_number : 1 ,
block_hash : H256 ::default ( ) ,
entry : LogEntry {
address : Address ::default ( ) ,
topics : vec ! [ ] ,
data : vec ! [ 1 , 2 , 3 ] ,
} ,
transaction_index : 0 ,
2016-12-29 19:48:28 +01:00
transaction_log_index : 0 ,
2016-09-21 12:51:10 +02:00
transaction_hash : H256 ::default ( ) ,
log_index : 0 ,
} ,
LocalizedLogEntry {
block_number : 1 ,
block_hash : H256 ::default ( ) ,
entry : LogEntry {
address : Address ::default ( ) ,
topics : vec ! [ ] ,
data : vec ! [ 1 , 2 , 3 ] ,
} ,
transaction_index : 0 ,
2016-12-29 19:48:28 +01:00
transaction_log_index : 1 ,
2016-09-21 12:51:10 +02:00
transaction_hash : H256 ::default ( ) ,
2016-12-29 19:48:28 +01:00
log_index : 1 ,
2016-09-21 12:51:10 +02:00
} ,
] ) ;
2020-08-05 06:08:03 +02:00
2016-09-21 12:51:10 +02:00
// Register filters first
let request_default =
r # "{"jsonrpc": "2.0", "method": "eth_newFilter", "params": [{}], "id": 1}"# ;
let request_limit =
r # "{"jsonrpc": "2.0", "method": "eth_newFilter", "params": [{"limit":1}], "id": 1}"# ;
let response1 = r # "{"jsonrpc":"2.0","result":"0x0","id":1}"# ;
let response2 = r # "{"jsonrpc":"2.0","result":"0x1","id":1}"# ;
2020-08-05 06:08:03 +02:00
2016-09-21 12:51:10 +02:00
assert_eq! (
tester . io . handle_request_sync ( request_default ) ,
Some ( response1 . to_owned ( ) )
) ;
assert_eq! (
tester . io . handle_request_sync ( request_limit ) ,
Some ( response2 . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2016-09-21 12:51:10 +02:00
let request_changes1 =
r # "{"jsonrpc": "2.0", "method": "eth_getFilterChanges", "params": ["0x0"], "id": 1}"# ;
let request_changes2 =
r # "{"jsonrpc": "2.0", "method": "eth_getFilterChanges", "params": ["0x1"], "id": 1}"# ;
2018-06-13 13:39:27 +02:00
let response1 = r # "{"jsonrpc":"2.0","result":[{"address":"0x0000000000000000000000000000000000000000","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","blockNumber":"0x1","data":"0x010203","logIndex":"0x0","removed":false,"topics":[],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","transactionLogIndex":"0x0","type":"mined"},{"address":"0x0000000000000000000000000000000000000000","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","blockNumber":"0x1","data":"0x010203","logIndex":"0x1","removed":false,"topics":[],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","transactionLogIndex":"0x1","type":"mined"}],"id":1}"# ;
let response2 = r # "{"jsonrpc":"2.0","result":[{"address":"0x0000000000000000000000000000000000000000","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","blockNumber":"0x1","data":"0x010203","logIndex":"0x1","removed":false,"topics":[],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","transactionLogIndex":"0x1","type":"mined"}],"id":1}"# ;
2020-08-05 06:08:03 +02:00
2016-09-21 12:51:10 +02:00
assert_eq! (
tester . io . handle_request_sync ( request_changes1 ) ,
Some ( response1 . to_owned ( ) )
) ;
assert_eq! (
tester . io . handle_request_sync ( request_changes2 ) ,
Some ( response2 . to_owned ( ) )
) ;
2016-09-14 12:02:30 +02:00
}
2018-02-23 10:41:29 +01:00
#[ test ]
fn rpc_blocks_filter ( ) {
let tester = EthTester ::default ( ) ;
let request_filter = r # "{"jsonrpc": "2.0", "method": "eth_newBlockFilter", "id": 1}"# ;
let response = r # "{"jsonrpc":"2.0","result":"0x0","id":1}"# ;
2020-08-05 06:08:03 +02:00
2018-02-23 10:41:29 +01:00
assert_eq! (
tester . io . handle_request_sync ( request_filter ) ,
Some ( response . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2018-02-23 10:41:29 +01:00
let request_changes =
r # "{"jsonrpc": "2.0", "method": "eth_getFilterChanges", "params": ["0x0"], "id": 1}"# ;
let response = r # "{"jsonrpc":"2.0","result":[],"id":1}"# ;
2020-08-05 06:08:03 +02:00
2018-02-23 10:41:29 +01:00
assert_eq! (
tester . io . handle_request_sync ( request_changes ) ,
Some ( response . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2018-02-23 10:41:29 +01:00
tester . client . add_blocks ( 2 , EachBlockWith ::Nothing ) ;
2020-08-05 06:08:03 +02:00
2018-11-21 16:50:41 +01:00
let hash1 = tester . client . block_hash ( BlockId ::Number ( 1 ) ) . unwrap ( ) ;
let hash2 = tester . client . block_hash ( BlockId ::Number ( 2 ) ) . unwrap ( ) ;
2018-02-23 10:41:29 +01:00
let response = format! (
r # "{{"jsonrpc":"2.0","result":["0x{:x}","0x{:x}"],"id":1}}"# ,
2018-11-21 16:50:41 +01:00
hash1 , hash2
) ;
2020-08-05 06:08:03 +02:00
2018-11-21 16:50:41 +01:00
assert_eq! (
tester . io . handle_request_sync ( request_changes ) ,
Some ( response . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2018-11-21 16:50:41 +01:00
// in the case of a re-org we get same block number if hash is different - BlockId::Number(2)
tester . client . blocks . write ( ) . remove ( & hash2 ) . unwrap ( ) ;
tester . client . numbers . write ( ) . remove ( & 2 ) . unwrap ( ) ;
* tester . client . last_hash . write ( ) = hash1 ;
tester . client . add_blocks ( 2 , EachBlockWith ::Uncle ) ;
2020-08-05 06:08:03 +02:00
2018-11-21 16:50:41 +01:00
let request_changes =
r # "{"jsonrpc": "2.0", "method": "eth_getFilterChanges", "params": ["0x0"], "id": 2}"# ;
let response = format! (
r # "{{"jsonrpc":"2.0","result":["0x{:x}","0x{:x}"],"id":2}}"# ,
tester . client . block_hash ( BlockId ::Number ( 2 ) ) . unwrap ( ) ,
tester . client . block_hash ( BlockId ::Number ( 3 ) ) . unwrap ( )
) ;
2020-08-05 06:08:03 +02:00
2018-02-23 10:41:29 +01:00
assert_eq! (
tester . io . handle_request_sync ( request_changes ) ,
Some ( response . to_owned ( ) )
) ;
}
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_submit_hashrate ( ) {
let tester = EthTester ::default ( ) ;
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_submitHashrate " ,
" params " : [
" 0x0000000000000000000000000000000000000000000000000000000000500000 " ,
" 0x59daa26581d0acd1fce254fb7e85952f4c09d0915afd33d3886cd914bc7d283c " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":true,"id":1}"# ;
2020-08-05 06:08:03 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-08-02 18:53:32 +02:00
assert_eq! (
tester
. hashrates
. lock ( )
. get ( & H256 ::from (
" 0x59daa26581d0acd1fce254fb7e85952f4c09d0915afd33d3886cd914bc7d283c "
) )
. cloned ( )
. unwrap ( )
. 1 ,
U256 ::from ( 0x500_000 )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_author ( ) {
2018-04-02 13:12:52 +02:00
let make_res = | addr | {
r # "{"jsonrpc":"2.0","result":""# . to_owned ( ) + & format! ( " 0x {:x} " , addr ) + r # "","id":1}"#
} ;
2016-05-29 17:18:37 +02:00
let tester = EthTester ::default ( ) ;
2018-09-05 19:21:08 +02:00
let request = r #" {
2016-05-29 17:18:37 +02:00
" jsonrpc " : " 2.0 " ,
" method " : " eth_coinbase " ,
" params " : [ ] ,
" id " : 1
} " #;
2018-09-05 19:21:08 +02:00
let response = r # "{"jsonrpc":"2.0","error":{"code":-32023,"message":"No accounts were found","data":"\"\""},"id":1}"# ;
// No accounts - returns an error indicating that no accounts were found
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_string ( ) )
) ;
2016-05-29 17:18:37 +02:00
2017-01-30 11:10:58 +01:00
// Account set - return first account
2018-06-22 15:09:15 +02:00
let addr = tester . accounts_provider . new_account ( & " 123 " . into ( ) ) . unwrap ( ) ;
2018-09-05 19:21:08 +02:00
assert_eq! ( tester . io . handle_request_sync ( request ) , Some ( make_res ( addr ) ) ) ;
2017-01-30 11:10:58 +01:00
2016-05-29 17:18:37 +02:00
for i in 0 .. 20 {
2018-06-22 15:09:15 +02:00
let addr = tester
. accounts_provider
. new_account ( & format! ( " {} " , i ) . into ( ) )
. unwrap ( ) ;
2019-02-07 14:34:24 +01:00
tester . miner . set_author ( miner ::Author ::External ( addr ) ) ;
2016-05-29 17:18:37 +02:00
2018-09-05 19:21:08 +02:00
assert_eq! ( tester . io . handle_request_sync ( request ) , Some ( make_res ( addr ) ) ) ;
2016-05-29 17:18:37 +02:00
}
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_mining ( ) {
let tester = EthTester ::default ( ) ;
2019-02-07 14:34:24 +01:00
tester . miner . set_author ( miner ::Author ::External (
Address ::from_str ( " d46e8dd67c5d32be8058bb8eb970870f07244567 " ) . unwrap ( ) ,
) ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_mining", "params": [], "id": 1}"# ;
let response = r # "{"jsonrpc":"2.0","result":false,"id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_gas_price ( ) {
let request = r # "{"jsonrpc": "2.0", "method": "eth_gasPrice", "params": [], "id": 1}"# ;
2016-09-02 11:38:16 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x4a817c800","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_accounts ( ) {
2016-06-20 00:10:34 +02:00
let tester = EthTester ::default ( ) ;
2018-06-22 15:09:15 +02:00
let address = tester . accounts_provider . new_account ( & " " . into ( ) ) . unwrap ( ) ;
2017-02-03 13:56:48 +01:00
tester
. accounts_provider
. set_address_name ( 1. into ( ) , " 1 " . into ( ) ) ;
tester
. accounts_provider
. set_address_name ( 10. into ( ) , " 10 " . into ( ) ) ;
2020-08-05 06:08:03 +02:00
2016-12-11 17:51:34 +01:00
// with current policy it should return the account
2016-12-10 12:34:20 +01:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_accounts", "params": [], "id": 1}"# ;
2018-04-02 13:12:52 +02:00
let response = r # "{"jsonrpc":"2.0","result":[""# . to_owned ( )
+ & format! ( " 0x {:x} " , address )
+ r # ""],"id":1}"# ;
2016-12-10 12:34:20 +01:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_block_number ( ) {
let tester = EthTester ::default ( ) ;
tester . client . add_blocks ( 10 , EachBlockWith ::Nothing ) ;
let request = r # "{"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1}"# ;
2016-09-02 11:38:16 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0xa","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_balance ( ) {
let tester = EthTester ::default ( ) ;
tester . client . set_balance ( Address ::from ( 1 ) , U256 ::from ( 5 ) ) ;
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getBalance " ,
" params " : [ " 0x0000000000000000000000000000000000000001 " , " latest " ] ,
" id " : 1
} " #;
2016-09-02 11:38:16 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x5","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_balance_pending ( ) {
let tester = EthTester ::default ( ) ;
2016-05-29 17:07:39 +02:00
tester . client . set_balance ( Address ::from ( 1 ) , U256 ::from ( 5 ) ) ;
2016-05-26 16:59:59 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getBalance " ,
2016-05-29 17:07:39 +02:00
" params " : [ " 0x0000000000000000000000000000000000000001 " , " pending " ] ,
2016-05-26 16:59:59 +02:00
" id " : 1
} " #;
2016-05-29 17:07:39 +02:00
2017-08-04 15:58:14 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x5","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_storage_at ( ) {
let tester = EthTester ::default ( ) ;
tester
. client
. set_storage ( Address ::from ( 1 ) , H256 ::from ( 4 ) , H256 ::from ( 7 ) ) ;
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getStorageAt " ,
" params " : [ " 0x0000000000000000000000000000000000000001 " , " 0x4 " , " latest " ] ,
" id " : 1
} " #;
2016-07-30 23:42:52 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x0000000000000000000000000000000000000000000000000000000000000007","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_transaction_count ( ) {
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getTransactionCount " ,
" params " : [ " 0x0000000000000000000000000000000000000001 " , " latest " ] ,
" id " : 1
} " #;
2016-09-02 11:38:16 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x0","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_block_transaction_count_by_hash ( ) {
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getBlockTransactionCountByHash " ,
" params " : [ " 0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238 " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":null,"id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_transaction_count_by_number ( ) {
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getBlockTransactionCountByNumber " ,
" params " : [ " latest " ] ,
" id " : 1
} " #;
2016-09-02 11:38:16 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x0","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_transaction_count_by_number_pending ( ) {
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getBlockTransactionCountByNumber " ,
" params " : [ " pending " ] ,
" id " : 1
} " #;
2018-04-13 17:34:27 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x0","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_pending_transaction_by_hash ( ) {
2018-01-10 13:35:18 +01:00
use ethereum_types ::H256 ;
2017-01-13 09:51:36 +01:00
use rlp ;
2019-01-04 14:05:46 +01:00
use types ::transaction ::SignedTransaction ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let tester = EthTester ::default ( ) ;
{
2018-05-08 11:22:12 +02:00
let bytes = FromHex ::from_hex ( " f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804 " ) . unwrap ( ) ;
let tx = rlp ::decode ( & bytes ) . expect ( " decoding failure " ) ;
2017-01-13 09:51:36 +01:00
let tx = SignedTransaction ::new ( tx ) . unwrap ( ) ;
2016-07-13 19:59:59 +02:00
tester
. miner
. pending_transactions
. lock ( )
. insert ( H256 ::zero ( ) , tx ) ;
2016-05-26 16:59:59 +02:00
}
2020-08-05 06:08:03 +02:00
2017-10-24 12:13:00 +02:00
let response = r # "{"jsonrpc":"2.0","result":{"blockHash":null,"blockNumber":null,"chainId":null,"condition":null,"creates":null,"from":"0x0f65fe9276bc9a24ae7083ae28e2660ef72df99e","gas":"0x5208","gasPrice":"0x1","hash":"0x41df922fd0d4766fcc02e161f8295ec28522f329ae487f14d811e4b64c8d6e31","input":"0x","nonce":"0x0","publicKey":"0x7ae46da747962c2ee46825839c1ef9298e3bd2e70ca2938495c3693a485ec3eaa8f196327881090ff64cf4fbb0a48485d4f83098e189ed3b7a87d5941b59f789","r":"0x48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353","raw":"0xf85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804","s":"0xefffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804","standardV":"0x0","to":"0x095e7baea6a6c7c4c2dfeb977efac326af552d87","transactionIndex":null,"v":"0x1b","value":"0xa"},"id":1}"# ;
2016-05-26 16:59:59 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getTransactionByHash " ,
" params " : [ " 0x0000000000000000000000000000000000000000000000000000000000000000 " ] ,
" id " : 1
} " #;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_uncle_count_by_block_hash ( ) {
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getUncleCountByBlockHash " ,
" params " : [ " 0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238 " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":null,"id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_uncle_count_by_block_number ( ) {
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getUncleCountByBlockNumber " ,
" params " : [ " latest " ] ,
" id " : 1
} " #;
2016-09-02 11:38:16 +02:00
let response = r # "{"jsonrpc":"2.0","result":"0x0","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_code ( ) {
let tester = EthTester ::default ( ) ;
tester . client . set_code ( Address ::from ( 1 ) , vec! [ 0xff , 0x21 ] ) ;
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getCode " ,
" params " : [ " 0x0000000000000000000000000000000000000001 " , " latest " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":"0xff21","id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
2016-08-04 18:17:21 +02:00
fn rpc_eth_call_latest ( ) {
2016-05-26 16:59:59 +02:00
let tester = EthTester ::default ( ) ;
2016-08-04 18:17:21 +02:00
tester . client . set_execution_result ( Ok ( Executed {
2017-01-12 11:06:12 +01:00
exception : None ,
2016-05-26 16:59:59 +02:00
gas : U256 ::zero ( ) ,
gas_used : U256 ::from ( 0xff30 ) ,
refunded : U256 ::from ( 0x5 ) ,
cumulative_gas_used : U256 ::zero ( ) ,
logs : vec ! [ ] ,
contracts_created : vec ! [ ] ,
output : vec ! [ 0x12 , 0x34 , 0xff ] ,
2016-07-28 20:31:29 +02:00
trace : vec ! [ ] ,
2016-05-30 11:53:20 +02:00
vm_trace : None ,
2016-06-02 12:39:25 +02:00
state_diff : None ,
2016-08-04 18:17:21 +02:00
} ) ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_call " ,
" params " : [ {
" from " : " 0xb60e8dd61c5d32be8058bb8eb970870f07233155 " ,
" to " : " 0xd46e8dd67c5d32be8058bb8eb970870f07244567 " ,
" gas " : " 0x76c0 " ,
" gasPrice " : " 0x9184e72a000 " ,
" value " : " 0x9184e72a " ,
" data " : " 0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675 "
} ,
" latest " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":"0x1234ff","id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2019-11-11 21:57:38 +01:00
#[ test ]
fn rpc_eth_call_pending ( ) {
let tester = EthTester ::default ( ) ;
tester . client . set_execution_result ( Ok ( Executed {
exception : None ,
gas : U256 ::zero ( ) ,
gas_used : U256 ::from ( 0xff30 ) ,
refunded : U256 ::from ( 0x5 ) ,
cumulative_gas_used : U256 ::zero ( ) ,
logs : vec ! [ ] ,
contracts_created : vec ! [ ] ,
output : vec ! [ 0x12 , 0x34 , 0xff ] ,
trace : vec ! [ ] ,
vm_trace : None ,
state_diff : None ,
} ) ) ;
2020-08-05 06:08:03 +02:00
2019-11-11 21:57:38 +01:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_call " ,
" params " : [ {
" from " : " 0xb60e8dd61c5d32be8058bb8eb970870f07233155 " ,
" to " : " 0xd46e8dd67c5d32be8058bb8eb970870f07244567 " ,
" gas " : " 0x76c0 " ,
" gasPrice " : " 0x9184e72a000 " ,
" value " : " 0x9184e72a " ,
" data " : " 0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675 "
} ,
" pending " ] ,
" id " : 1
} " #;
// Falls back to "Latest" and gives the same result.
let response = r # "{"jsonrpc":"2.0","result":"0x1234ff","id":1}"# ;
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
}
2016-08-04 18:17:21 +02:00
#[ test ]
fn rpc_eth_call ( ) {
let tester = EthTester ::default ( ) ;
tester . client . set_execution_result ( Ok ( Executed {
2017-01-12 11:06:12 +01:00
exception : None ,
2016-08-04 18:17:21 +02:00
gas : U256 ::zero ( ) ,
gas_used : U256 ::from ( 0xff30 ) ,
refunded : U256 ::from ( 0x5 ) ,
cumulative_gas_used : U256 ::zero ( ) ,
logs : vec ! [ ] ,
contracts_created : vec ! [ ] ,
output : vec ! [ 0x12 , 0x34 , 0xff ] ,
trace : vec ! [ ] ,
vm_trace : None ,
state_diff : None ,
} ) ) ;
2020-08-05 06:08:03 +02:00
2016-08-04 18:17:21 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_call " ,
" params " : [ {
" from " : " 0xb60e8dd61c5d32be8058bb8eb970870f07233155 " ,
" to " : " 0xd46e8dd67c5d32be8058bb8eb970870f07244567 " ,
" gas " : " 0x76c0 " ,
" gasPrice " : " 0x9184e72a000 " ,
" value " : " 0x9184e72a " ,
" data " : " 0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675 "
} ,
" 0x0 " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":"0x1234ff","id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-08-04 18:17:21 +02:00
}
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_call_default_block ( ) {
let tester = EthTester ::default ( ) ;
2016-08-04 18:17:21 +02:00
tester . client . set_execution_result ( Ok ( Executed {
2017-01-12 11:06:12 +01:00
exception : None ,
2016-05-26 16:59:59 +02:00
gas : U256 ::zero ( ) ,
gas_used : U256 ::from ( 0xff30 ) ,
refunded : U256 ::from ( 0x5 ) ,
cumulative_gas_used : U256 ::zero ( ) ,
logs : vec ! [ ] ,
contracts_created : vec ! [ ] ,
output : vec ! [ 0x12 , 0x34 , 0xff ] ,
2016-07-28 20:31:29 +02:00
trace : vec ! [ ] ,
2016-05-30 11:53:20 +02:00
vm_trace : None ,
2016-06-02 12:39:25 +02:00
state_diff : None ,
2016-08-04 18:17:21 +02:00
} ) ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_call " ,
" params " : [ {
" from " : " 0xb60e8dd61c5d32be8058bb8eb970870f07233155 " ,
" to " : " 0xd46e8dd67c5d32be8058bb8eb970870f07244567 " ,
" gas " : " 0x76c0 " ,
" gasPrice " : " 0x9184e72a000 " ,
" value " : " 0x9184e72a " ,
" data " : " 0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675 "
} ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":"0x1234ff","id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_estimate_gas ( ) {
let tester = EthTester ::default ( ) ;
2016-08-04 18:17:21 +02:00
tester . client . set_execution_result ( Ok ( Executed {
2017-01-12 11:06:12 +01:00
exception : None ,
2016-05-26 16:59:59 +02:00
gas : U256 ::zero ( ) ,
gas_used : U256 ::from ( 0xff30 ) ,
refunded : U256 ::from ( 0x5 ) ,
cumulative_gas_used : U256 ::zero ( ) ,
logs : vec ! [ ] ,
contracts_created : vec ! [ ] ,
output : vec ! [ 0x12 , 0x34 , 0xff ] ,
2016-07-28 20:31:29 +02:00
trace : vec ! [ ] ,
2016-05-30 11:53:20 +02:00
vm_trace : None ,
2016-06-02 12:39:25 +02:00
state_diff : None ,
2016-08-04 18:17:21 +02:00
} ) ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_estimateGas " ,
" params " : [ {
" from " : " 0xb60e8dd61c5d32be8058bb8eb970870f07233155 " ,
" to " : " 0xd46e8dd67c5d32be8058bb8eb970870f07244567 " ,
" gas " : " 0x76c0 " ,
" gasPrice " : " 0x9184e72a000 " ,
" value " : " 0x9184e72a " ,
" data " : " 0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675 "
} ,
" latest " ] ,
" id " : 1
} " #;
2017-01-10 18:56:41 +01:00
let response = r # "{"jsonrpc":"2.0","result":"0x5208","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2019-11-11 21:57:38 +01:00
#[ test ]
fn rpc_eth_estimate_gas_pending ( ) {
let tester = EthTester ::default ( ) ;
tester . client . set_execution_result ( Ok ( Executed {
exception : None ,
gas : U256 ::zero ( ) ,
gas_used : U256 ::from ( 0xff30 ) ,
refunded : U256 ::from ( 0x5 ) ,
cumulative_gas_used : U256 ::zero ( ) ,
logs : vec ! [ ] ,
contracts_created : vec ! [ ] ,
output : vec ! [ 0x12 , 0x34 , 0xff ] ,
trace : vec ! [ ] ,
vm_trace : None ,
state_diff : None ,
} ) ) ;
2020-08-05 06:08:03 +02:00
2019-11-11 21:57:38 +01:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_estimateGas " ,
" params " : [ {
" from " : " 0xb60e8dd61c5d32be8058bb8eb970870f07233155 " ,
" to " : " 0xd46e8dd67c5d32be8058bb8eb970870f07244567 " ,
" gas " : " 0x76c0 " ,
" gasPrice " : " 0x9184e72a000 " ,
" value " : " 0x9184e72a " ,
" data " : " 0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675 "
} ,
" pending " ] ,
" id " : 1
} " #;
// Falls back to "Latest" so the result is the same
let response = r # "{"jsonrpc":"2.0","result":"0x5208","id":1}"# ;
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
}
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_estimate_gas_default_block ( ) {
let tester = EthTester ::default ( ) ;
2016-08-04 18:17:21 +02:00
tester . client . set_execution_result ( Ok ( Executed {
2017-01-12 11:06:12 +01:00
exception : None ,
2016-05-26 16:59:59 +02:00
gas : U256 ::zero ( ) ,
gas_used : U256 ::from ( 0xff30 ) ,
refunded : U256 ::from ( 0x5 ) ,
cumulative_gas_used : U256 ::zero ( ) ,
logs : vec ! [ ] ,
contracts_created : vec ! [ ] ,
output : vec ! [ 0x12 , 0x34 , 0xff ] ,
2016-07-28 20:31:29 +02:00
trace : vec ! [ ] ,
2016-05-30 11:53:20 +02:00
vm_trace : None ,
2016-06-02 12:39:25 +02:00
state_diff : None ,
2016-08-04 18:17:21 +02:00
} ) ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_estimateGas " ,
" params " : [ {
" from " : " 0xb60e8dd61c5d32be8058bb8eb970870f07233155 " ,
" to " : " 0xd46e8dd67c5d32be8058bb8eb970870f07244567 " ,
" gas " : " 0x76c0 " ,
" gasPrice " : " 0x9184e72a000 " ,
" value " : " 0x9184e72a " ,
" data " : " 0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675 "
} ] ,
" id " : 1
} " #;
2017-01-10 18:56:41 +01:00
let response = r # "{"jsonrpc":"2.0","result":"0x5208","id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2016-11-04 18:33:10 +01:00
#[ test ]
fn rpc_eth_send_raw_transaction_error ( ) {
let tester = EthTester ::default ( ) ;
let req = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_sendRawTransaction " ,
" params " : [
" 0x0123 "
] ,
" id " : 1
} " #;
2017-03-22 14:41:46 +01:00
let res = r # "{"jsonrpc":"2.0","error":{"code":-32602,"message":"Invalid RLP.","data":"RlpExpectedToBeList"},"id":1}"# . into ( ) ;
2016-11-04 18:33:10 +01:00
assert_eq! ( tester . io . handle_request_sync ( & req ) , Some ( res ) ) ;
}
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_send_raw_transaction ( ) {
2016-05-29 17:07:39 +02:00
let tester = EthTester ::default ( ) ;
2018-06-22 15:09:15 +02:00
let address = tester
. accounts_provider
. new_account ( & " abcd " . into ( ) )
2016-06-20 00:10:34 +02:00
. unwrap ( ) ;
tester
. accounts_provider
. unlock_account_permanently ( address , " abcd " . into ( ) )
2019-02-07 14:34:24 +01:00
. unwrap ( ) ;
2020-08-05 06:08:03 +02:00
2016-05-29 17:07:39 +02:00
let t = Transaction {
nonce : U256 ::zero ( ) ,
gas_price : U256 ::from ( 0x9184e72a000 u64 ) ,
gas : U256 ::from ( 0x76c0 ) ,
action : Action ::Call (
Address ::from_str ( " d46e8dd67c5d32be8058bb8eb970870f07244567 " ) . unwrap ( ) ,
2020-08-05 06:08:03 +02:00
) ,
2016-05-29 17:07:39 +02:00
value : U256 ::from ( 0x9184e72a u64 ) ,
data : vec ! [ ] ,
2016-06-20 00:10:34 +02:00
} ;
2016-11-03 22:22:25 +01:00
let signature = tester
. accounts_provider
. sign ( address , None , t . hash ( None ) )
. unwrap ( ) ;
let t = t . with_signature ( signature , None ) ;
2020-08-05 06:08:03 +02:00
2018-10-09 22:07:25 +02:00
let rlp = rlp ::encode ( & t ) . to_hex ( ) ;
2020-08-05 06:08:03 +02:00
2016-05-29 17:07:39 +02:00
let req = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_sendRawTransaction " ,
" params " : [
" 0x " #
. to_owned ( )
+ & rlp
+ r #" "
] ,
" id " : 1
} " #;
2018-04-02 13:12:52 +02:00
let res =
r # "{"jsonrpc":"2.0","result":""# . to_owned ( ) + & format! ( " 0x {:x} " , t . hash ( ) ) + r # "","id":1}"# ;
2016-05-29 17:07:39 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! ( tester . io . handle_request_sync ( & req ) , Some ( res ) ) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_transaction_receipt ( ) {
let receipt = LocalizedReceipt {
2018-06-07 16:47:41 +02:00
from : H160 ::from_str ( " b60e8dd61c5d32be8058bb8eb970870f07233155 " ) . unwrap ( ) ,
to : Some ( H160 ::from_str ( " d46e8dd67c5d32be8058bb8eb970870f07244567 " ) . unwrap ( ) ) ,
2016-05-26 16:59:59 +02:00
transaction_hash : H256 ::zero ( ) ,
transaction_index : 0 ,
block_hash : H256 ::from_str (
" ed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5 " ,
2020-08-05 06:08:03 +02:00
)
2016-05-26 16:59:59 +02:00
. unwrap ( ) ,
block_number : 0x4510c ,
cumulative_gas_used : U256 ::from ( 0x20 ) ,
gas_used : U256 ::from ( 0x10 ) ,
contract_address : None ,
logs : vec ! [ LocalizedLogEntry {
entry : LogEntry {
address : Address ::from_str ( " 33990122638b9132ca29c723bdf037f1a891a70c " ) . unwrap ( ) ,
topics : vec ! [
H256 ::from_str (
" a6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc " ,
2020-08-05 06:08:03 +02:00
)
2016-05-26 16:59:59 +02:00
. unwrap ( ) ,
H256 ::from_str (
" 4861736852656700000000000000000000000000000000000000000000000000 " ,
)
. unwrap ( ) ,
] ,
data : vec ! [ ] ,
} ,
block_hash : H256 ::from_str (
" ed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5 " ,
2020-08-05 06:08:03 +02:00
)
2016-05-26 16:59:59 +02:00
. unwrap ( ) ,
block_number : 0x4510c ,
transaction_hash : H256 ::new ( ) ,
transaction_index : 0 ,
2016-12-29 19:48:28 +01:00
transaction_log_index : 0 ,
2016-05-26 16:59:59 +02:00
log_index : 1 ,
2016-11-04 12:33:13 +01:00
} ] ,
log_bloom : 0. into ( ) ,
2017-09-21 10:11:53 +02:00
outcome : TransactionOutcome ::StateRoot ( 0. into ( ) ) ,
2016-05-26 16:59:59 +02:00
} ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let hash =
H256 ::from_str ( " b903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238 " ) . unwrap ( ) ;
let tester = EthTester ::default ( ) ;
2016-12-09 23:01:43 +01:00
tester
. client
. set_transaction_receipt ( TransactionId ::Hash ( hash ) , receipt ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getTransactionReceipt " ,
" params " : [ " 0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238 " ] ,
" id " : 1
} " #;
2019-11-11 21:57:38 +01:00
let response = r # "{"jsonrpc":"2.0","result":{"blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x4510c","contractAddress":null,"cumulativeGasUsed":"0x20","from":"0xb60e8dd61c5d32be8058bb8eb970870f07233155","gasUsed":"0x10","logs":[{"address":"0x33990122638b9132ca29c723bdf037f1a891a70c","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x4510c","data":"0x","logIndex":"0x1","removed":false,"topics":["0xa6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc","0x4861736852656700000000000000000000000000000000000000000000000000"],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","transactionLogIndex":"0x0","type":"mined"}],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","root":"0x0000000000000000000000000000000000000000000000000000000000000000","to":"0xd46e8dd67c5d32be8058bb8eb970870f07244567","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0"},"id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
fn rpc_eth_transaction_receipt_null ( ) {
let tester = EthTester ::default ( ) ;
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getTransactionReceipt " ,
" params " : [ " 0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238 " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":null,"id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2019-11-11 21:57:38 +01:00
#[ test ]
fn rpc_eth_pending_receipt ( ) {
let pending = RichReceipt {
from : H160 ::from_str ( " b60e8dd61c5d32be8058bb8eb970870f07233155 " ) . unwrap ( ) ,
to : Some ( H160 ::from_str ( " d46e8dd67c5d32be8058bb8eb970870f07244567 " ) . unwrap ( ) ) ,
transaction_hash : H256 ::from_str (
" b903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238 " ,
2020-08-05 06:08:03 +02:00
)
2019-11-11 21:57:38 +01:00
. unwrap ( ) ,
transaction_index : 0 ,
cumulative_gas_used : U256 ::from ( 0x20 ) ,
gas_used : U256 ::from ( 0x10 ) ,
contract_address : None ,
logs : Vec ::new ( ) ,
log_bloom : Bloom ::zero ( ) ,
outcome : TransactionOutcome ::Unknown ,
} ;
let tester = EthTester ::default ( ) ;
2020-08-05 06:08:03 +02:00
2019-11-11 21:57:38 +01:00
tester . miner . pending_receipts . lock ( ) . push ( pending ) ;
2020-08-05 06:08:03 +02:00
2019-11-11 21:57:38 +01:00
let request = r #" {
" jsonrpc " : " 2.0 " ,
" method " : " eth_getTransactionReceipt " ,
" params " : [ " 0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238 " ] ,
" id " : 1
} " #;
let response = r # "{"jsonrpc":"2.0","result":{"blockHash":null,"blockNumber":null,"contractAddress":null,"cumulativeGasUsed":"0x20","from":"0xb60e8dd61c5d32be8058bb8eb970870f07233155","gasUsed":"0x10","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","to":"0xd46e8dd67c5d32be8058bb8eb970870f07244567","transactionHash":"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238","transactionIndex":"0x0"},"id":1}"# ;
assert_eq! (
tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
}
2016-07-19 20:40:18 +02:00
// These tests are incorrect: their output is undefined as long as eth_getCompilers is [].
// Will ignore for now, but should probably be replaced by more substantial tests which check
// the output of eth_getCompilers to determine whether to test. CI systems can then be preinstalled
// with solc/serpent/lllc and they'll be proper again.
#[ ignore ]
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_compilers ( ) {
let request = r # "{"jsonrpc": "2.0", "method": "eth_getCompilers", "params": [], "id": 1}"# ;
2017-02-17 12:00:33 +01:00
let response = r # "{"jsonrpc":"2.0","error":{"code":-32070,"message":"Method deprecated","data":"Compilation functionality is deprecated."},"id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2016-07-14 14:25:44 +02:00
#[ ignore ]
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_compile_lll ( ) {
let request = r # "{"jsonrpc": "2.0", "method": "eth_compileLLL", "params": [], "id": 1}"# ;
2017-02-17 12:00:33 +01:00
let response = r # "{"jsonrpc":"2.0","error":{"code":-32070,"message":"Method deprecated","data":"Compilation of LLL via RPC is deprecated"},"id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2016-07-14 14:25:44 +02:00
#[ ignore ]
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_compile_solidity ( ) {
let request = r # "{"jsonrpc": "2.0", "method": "eth_compileSolidity", "params": [], "id": 1}"# ;
2017-02-17 12:00:33 +01:00
let response = r # "{"jsonrpc":"2.0","error":{"code":-32070,"message":"Method deprecated","data":"Compilation of Solidity via RPC is deprecated"},"id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
2016-07-14 14:25:44 +02:00
#[ ignore ]
2016-05-26 16:59:59 +02:00
#[ test ]
fn rpc_eth_compile_serpent ( ) {
let request = r # "{"jsonrpc": "2.0", "method": "eth_compileSerpent", "params": [], "id": 1}"# ;
2017-02-17 12:00:33 +01:00
let response = r # "{"jsonrpc":"2.0","error":{"code":-32070,"message":"Method deprecated","data":"Compilation of Serpent via RPC is deprecated"},"id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
EthTester ::default ( ) . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
2016-08-23 17:07:00 +02:00
fn rpc_get_work_returns_no_work_if_cant_mine ( ) {
2016-05-26 16:59:59 +02:00
let eth_tester = EthTester ::default ( ) ;
eth_tester . client . set_queue_size ( 10 ) ;
let request = r # "{"jsonrpc": "2.0", "method": "eth_getWork", "params": [], "id": 1}"# ;
2017-03-22 07:02:14 +01:00
let response = r # "{"jsonrpc":"2.0","error":{"code":-32001,"message":"Still syncing."},"id":1}"# ;
2016-05-26 16:59:59 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
eth_tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-05-26 16:59:59 +02:00
}
#[ test ]
2016-08-23 17:07:00 +02:00
fn rpc_get_work_returns_correct_work_package ( ) {
2016-05-26 16:59:59 +02:00
let eth_tester = EthTester ::default ( ) ;
2019-02-07 14:34:24 +01:00
eth_tester . miner . set_author ( miner ::Author ::External (
Address ::from_str ( " d46e8dd67c5d32be8058bb8eb970870f07244567 " ) . unwrap ( ) ,
) ) ;
2020-08-05 06:08:03 +02:00
2016-05-26 16:59:59 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_getWork", "params": [], "id": 1}"# ;
2017-09-26 14:19:08 +02:00
let response = r # "{"jsonrpc":"2.0","result":["0x76c7bd86693aee93d1a80a408a09a0585b1a1292afcb56192f171d925ea18e2d","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x1"],"id":1}"# ;
2020-08-05 06:08:03 +02:00
2016-09-01 12:00:00 +02:00
assert_eq! (
eth_tester . io . handle_request_sync ( request ) ,
Some ( response . to_owned ( ) )
) ;
2016-08-03 15:31:00 +02:00
}
2016-08-23 17:07:00 +02:00
#[ test ]
fn rpc_get_work_should_timeout ( ) {
let eth_tester = EthTester ::default ( ) ;
2019-02-07 14:34:24 +01:00
eth_tester . miner . set_author ( miner ::Author ::External (
Address ::from_str ( " d46e8dd67c5d32be8058bb8eb970870f07244567 " ) . unwrap ( ) ,
) ) ;
2018-03-14 12:29:52 +01:00
let timestamp = SystemTime ::now ( )
. duration_since ( UNIX_EPOCH )
. unwrap ( )
. as_secs ( )
- 1000 ; // Set latest block to 1000 seconds ago
eth_tester . client . set_latest_block_timestamp ( timestamp ) ;
2018-04-13 17:34:27 +02:00
let hash = eth_tester
. miner
. work_package ( & * eth_tester . client )
. unwrap ( )
. 0 ;
2020-08-05 06:08:03 +02:00
2016-08-24 13:20:15 +02:00
// Request without providing timeout. This should work since we're disabling timeout.
2016-08-23 17:07:00 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_getWork", "params": [], "id": 1}"# ;
let work_response = format! (
2018-04-02 13:12:52 +02:00
r # "{{"jsonrpc":"2.0","result":["0x{:x}","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x1"],"id":1}}"# ,
2016-08-23 17:07:00 +02:00
hash ,
) ;
2016-09-01 12:00:00 +02:00
assert_eq! (
eth_tester . io . handle_request_sync ( request ) ,
Some ( work_response . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2016-08-24 13:20:15 +02:00
// Request with timeout of 0 seconds. This should work since we're disabling timeout.
2017-07-06 15:25:51 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_getWork", "params": [0], "id": 1}"# ;
2016-08-24 13:20:15 +02:00
let work_response = format! (
2018-04-02 13:12:52 +02:00
r # "{{"jsonrpc":"2.0","result":["0x{:x}","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x1"],"id":1}}"# ,
2016-08-24 13:20:15 +02:00
hash ,
) ;
2016-09-01 12:00:00 +02:00
assert_eq! (
eth_tester . io . handle_request_sync ( request ) ,
Some ( work_response . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2016-08-23 17:07:00 +02:00
// Request with timeout of 10K seconds. This should work.
2017-07-06 15:25:51 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_getWork", "params": [10000], "id": 1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
eth_tester . io . handle_request_sync ( request ) ,
Some ( work_response . to_owned ( ) )
) ;
2020-08-05 06:08:03 +02:00
2016-08-23 17:07:00 +02:00
// Request with timeout of 10 seconds. This should fail.
2017-07-06 15:25:51 +02:00
let request = r # "{"jsonrpc": "2.0", "method": "eth_getWork", "params": [10], "id": 1}"# ;
2017-03-22 07:02:14 +01:00
let err_response =
r # "{"jsonrpc":"2.0","error":{"code":-32003,"message":"Work has not changed."},"id":1}"# ;
2016-09-01 12:00:00 +02:00
assert_eq! (
eth_tester . io . handle_request_sync ( request ) ,
Some ( err_response . to_owned ( ) )
) ;
2016-08-23 17:07:00 +02:00
}