fix mining epoch block issues;

fix ci warning issues;
fix unit test err;

Author: galaio

Cargo.lock

@@ -52,9 +52,9 @@ ethereum-jsonrpc = { git = "https://github.com/vorot93/ethereum-jsonrpc", featur
 ] }
 ethnum = { version = "1", features = ["eio", "rlp"] }
 ethsecp256k1 = { package = "eth-secp256k1", git = "https://github.com/paritytech/rust-secp256k1", rev = "ccc06e7480148b723eb44ac56cf4d20eec380b6f" }
-ethabi = { git = "https://github.com/setunapo/ethabi", package = "ethabi", branch = "akula_ethereum_type_v0.14.0" }
-ethabi-contract = { git = "https://github.com/setunapo/ethabi", package = "ethabi-contract", branch = "akula_ethereum_type_v0.14.0"  }
-ethabi-derive = { git = "https://github.com/setunapo/ethabi", package = "ethabi-derive", branch = "akula_ethereum_type_v0.14.0"  }
+ethabi = { git = "https://github.com/rust-ethereum/ethabi", tag = "v18.0.0", package = "ethabi" }
+ethabi-contract = { git = "https://github.com/rust-ethereum/ethabi", tag = "v18.0.0", package = "ethabi-contract" }
+ethabi-derive = { git = "https://github.com/rust-ethereum/ethabi", tag = "v18.0.0", package = "ethabi-derive" }
 fastrlp = { version = "0.2", features = [
   "derive",
   "ethbloom",

Cargo.toml

@@ -1,4 +1,3 @@
-use crate::devp2p::Swarm;
 use akula::{
     akula_tracing::{self, Component},
     binutil::AkulaDataDir,
@@ -13,7 +12,6 @@ use akula::{
         net::NetApiServerImpl, otterscan::OtterscanApiServerImpl, parity::ParityApiServerImpl,
         trace::TraceApiServerImpl, web3::Web3ApiServerImpl,
     },
-    sentry::*,
     stagedsync,
     stages::{stage_util::IndexParams, *},
     version_string,
@@ -26,12 +24,8 @@ use ethereum_jsonrpc::{
     TraceApiServer, Web3ApiServer,
 };
 use expanded_pathbuf::ExpandedPathBuf;
-use futures::executor::block_on;
 use http::Uri;
-use jsonrpsee::{
-    core::server::rpc_module::Methods,
-    server::ServerBuilder
-};
+use jsonrpsee::{core::server::rpc_module::Methods, server::ServerBuilder};
 use num_bigint::BigInt;
 use secp256k1::SecretKey;
 use std::{
@@ -561,9 +555,9 @@ fn main() -> anyhow::Result<()> {
                     consensus_config.authorize(ECDSASigner::from_secret(&opt.mine_secretkey.unwrap()[..]));
                     let mining_config = Arc::new(Mutex::new(MiningConfig {
                         enabled: true,
-                        ether_base: opt.mine_etherbase.unwrap().clone(),
-                        secret_key: opt.mine_secretkey.unwrap().clone(),
-                        extra_data: opt.mine_extradata.map(Bytes::from).clone(),
+                        ether_base: opt.mine_etherbase.unwrap(),
+                        secret_key: opt.mine_secretkey.unwrap(),
+                        extra_data: opt.mine_extradata.map(Bytes::from),
                         consensus: consensus_config,
                         dao_fork_block: Some(BigInt::new(num_bigint::Sign::Plus, vec![])),
                         dao_fork_support: false,
@@ -604,9 +598,9 @@ fn main() -> anyhow::Result<()> {
 
                     staged_mining.push(
                         MiningFinishBlock {
-                            mining_status: mining_status.clone(),
-                            mining_block: mining_block.clone(),
-                            mining_config: mining_config.clone(),
+                            mining_status,
+                            mining_block,
+                            mining_config,
                             chain_spec: chainspec.clone(),
                             node: node.clone(),
                         },

bin/akula.rs

@@ -1,7 +1,6 @@
 use crate::{
     consensus::{clique::*, SnapDB},
-    kv::{mdbx::*, tables, MdbxWithDirHandle},
-    p2p::types::GetBlockHeadersParams,
+    kv::{mdbx::*, tables},
     HeaderReader,
 };
 use ethereum_types::Address;
@@ -74,8 +73,7 @@ impl CliqueSnapshot {
         if snap
             .recent_proposers
             .iter()
-            .find(|(_, addr)| **addr == proposer)
-            .is_some()
+            .any(|(_, addr)| *addr == proposer)
         {
             return Err(CliqueError::SignerOverLimit { signer: proposer }.into());
         }

src/consensus/clique/clique_snapshot.rs

@@ -1,5 +1,5 @@
 use crate::{consensus::*, crypto};
-use bytes::{Buf, Bytes};
+use bytes::Bytes;
 use ethereum_types::{Address, Public, H256};
 use lazy_static::lazy_static;
 use lru_cache::LruCache;
@@ -68,7 +68,7 @@ pub fn parse_epoch_validators(bytes: &[u8]) -> Result<Vec<Address>, DuoError> {
         return Err(ParliaError::WrongHeaderExtraSignersLen {
             expected: 0,
             got: bytes.len() % ADDRESS_LENGTH,
-            msg: format!("parse_epoch_validators got wrong len!"),
+            msg: "parse_epoch_validators got wrong len!".to_string(),
         }
         .into());
     }
@@ -113,22 +113,17 @@ pub fn recover_creator(header: &BlockHeader, chain_id: ChainId) -> Result<Addres
     let address_slice = &Keccak256::digest(&public.serialize_uncompressed()[1..])[12..];
 
     let creator = Address::from_slice(address_slice);
-    cache.insert(header.hash(), creator.clone());
+    cache.insert(header.hash(), creator);
     Ok(creator)
 }
 
 /// check tx is similar
 pub fn is_similar_tx(actual: &Message, expect: &Message) -> bool {
-    if actual.max_fee_per_gas() == expect.max_fee_per_gas()
+    actual.max_fee_per_gas() == expect.max_fee_per_gas()
         && actual.max_fee_per_gas() == expect.max_fee_per_gas()
         && actual.value() == expect.value()
         && actual.input() == expect.input()
         && actual.action() == expect.action()
-    {
-        true
-    } else {
-        false
-    }
 }
 
 /// find header.block_number - count, block header

src/consensus/clique/clique_util.rs

@@ -6,41 +6,29 @@ pub mod clique_util;
 use crate::{
     consensus::{
         clique_snapshot::CliqueSnapshot, fork_choice_graph::ForkChoiceGraph, state::CliqueBlock,
-        CliqueError, Consensus, ConsensusEngineBase, ConsensusState, DuoError,
-        DuoError::Validation, FinalizationChange, ForkChoiceMode, ValidationError,
+        CliqueError, Consensus, ConsensusEngineBase, ConsensusState, DuoError, FinalizationChange,
+        ForkChoiceMode, ValidationError,
     },
     kv::{mdbx::*, tables},
     models::{
-        Block, BlockHeader, BlockNumber, ChainConfig, ChainId, ChainSpec, MessageWithSender,
-        Receipt, Seal, EMPTY_LIST_HASH,
+        Block, BlockHeader, BlockNumber, ChainConfig, ChainId, ChainSpec, MessageWithSender, Seal,
+        EMPTY_LIST_HASH,
     },
-    state::{IntraBlockState, StateReader},
+    state::StateReader,
     BlockReader, HeaderReader,
 };
 use anyhow::bail;
-use byte_unit::Byte;
 use bytes::Bytes;
-use cipher::typenum::private::IsEqualPrivate;
-//use ethabi::Bytes;
-use ethereum_types::{Address, H256, H64};
+use ethereum_types::{Address, H256};
 use lru_cache::LruCache;
 use mdbx::{EnvironmentKind, TransactionKind};
 use parking_lot::{Mutex, RwLock};
-use rlp::RlpStream;
 use secp256k1::{
     ecdsa::{RecoverableSignature, RecoveryId},
     Message as SecpMessage, SECP256K1,
 };
 use sha3::{Digest, Keccak256};
-use std::{
-    io::Read,
-    sync::Arc,
-    time::{Duration, SystemTime},
-    unreachable,
-};
-use tendermint::signature::Signer;
-use tracing::{debug, info};
-use trust_dns_resolver::proto::{serialize::binary::BinEncodable, Time};
+use std::{sync::Arc, time::Duration, unreachable};
 
 const EXTRA_VANITY: usize = 32;
 const EXTRA_SEAL: usize = 65;

src/consensus/clique/mod.rs

@@ -8,31 +8,28 @@ pub mod parlia;
 use self::fork_choice_graph::ForkChoiceGraph;
 pub use self::{base::*, beacon::*, blockchain::*, clique::*, parlia::*};
 use crate::{
-    consensus::vote::VotePool,
     crypto::signer::ECDSASigner,
     kv::{mdbx::*, tables, MdbxWithDirHandle},
     models::*,
+    p2p::node::Node,
     state::{IntraBlockState, StateReader},
-    BlockReader, HeaderReader,
+    BlockReader, Buffer, HeaderReader,
 };
 use anyhow::{anyhow, bail};
-use arrayvec::ArrayVec;
 use derive_more::{Display, From};
-use ethnum::u256;
 use fastrlp::DecodeError;
 use mdbx::{EnvironmentKind, TransactionKind};
 use milagro_bls::AmclError;
 use parking_lot::Mutex;
 use std::{
     collections::BTreeSet,
-    fmt::{Debug, Display, Formatter},
+    fmt::{Debug, Display},
     net::{Ipv4Addr, SocketAddr, SocketAddrV4},
     sync::Arc,
     time::SystemTimeError,
 };
 use tokio::sync::watch;
 use tracing::*;
-use crate::p2p::node::Node;
 
 #[derive(Debug)]
 pub enum FinalizationChange {
@@ -85,6 +82,15 @@ impl ConsensusNewBlockState {
             _ => ConsensusNewBlockState::Stateless,
         })
     }
+    pub(crate) fn handle_with_txn<E: EnvironmentKind>(
+        chain_spec: &ChainSpec,
+        header: &BlockHeader,
+        tx: &MdbxTransaction<'_, RW, E>,
+    ) -> anyhow::Result<ConsensusNewBlockState> {
+        let mut state = Buffer::new(tx, None);
+        let mut state = IntraBlockState::new(&mut state);
+        ConsensusNewBlockState::handle(chain_spec, header, &mut state)
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -678,21 +684,19 @@ impl Default for InitialParams {
 pub fn pre_validate_transaction(
     txn: &Message,
     canonical_chain_id: ChainId,
-    _base_fee_per_gas: Option<U256>,
+    base_fee_per_gas: Option<U256>,
 ) -> Result<(), ValidationError> {
     if let Some(chain_id) = txn.chain_id() {
         if chain_id != canonical_chain_id {
             return Err(ValidationError::WrongChainId);
         }
     }
 
-    // TODO need pass in system transaction
-    // info!("tx {:?} base fee {:?}, tx {} max1 {} max2 {}", txn.hash(), base_fee_per_gas, txn.max_fee_per_gas(), txn.max_priority_fee_per_gas(), txn.max_fee_per_gas());
-    // if let Some(base_fee_per_gas) = base_fee_per_gas {
-    //     if txn.max_fee_per_gas() < base_fee_per_gas {
-    //         return Err(ValidationError::MaxFeeLessThanBase);
-    //     }
-    // }
+    if let Some(base_fee_per_gas) = base_fee_per_gas {
+        if txn.max_fee_per_gas() < base_fee_per_gas {
+            return Err(ValidationError::MaxFeeLessThanBase);
+        }
+    }
 
     // https://github.com/ethereum/EIPs/pull/3594
     if txn.max_priority_fee_per_gas() > txn.max_fee_per_gas() {

src/consensus/mod.rs

@@ -9,7 +9,7 @@ use lazy_static::lazy_static;
 use rustc_hex::FromHex;
 use std::{collections::HashMap, str::FromStr};
 
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd)]
 pub struct UpgradeConfig {
     pub contract_addr: &'static str,
     pub code: &'static str,
@@ -88,7 +88,7 @@ where
 }
 
 pub fn apply_system_contract_upgrade<'r, S>(
-    upgrade: &Vec<UpgradeConfig>,
+    upgrade: &[UpgradeConfig],
     statedb: &mut IntraBlockState<'r, S>,
 ) -> anyhow::Result<(), DuoError>
 where