anvil-polkadot: add genesis coinbase support

crates/anvil-polkadot/Cargo.toml

@@ -34,6 +34,7 @@ polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk.git", branch
 	"sc-client-api",
 	"sc-client-db",
 	"sc-consensus",
+	"sc-consensus-aura",
 	"sc-consensus-manual-seal",
     "sc-executor",
 	"sc-executor-common",
@@ -55,6 +56,7 @@ polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk.git", branch
 	"sc-utils",
 	"sp-blockchain",
 	"sp-consensus",
+	"sp-consensus-slots",
 	"sp-core-hashing",
 	"sp-core-hashing-proc-macro",
 	"sp-database",

crates/anvil-polkadot/src/api_server/server.rs

@@ -150,6 +150,19 @@ impl ApiServer {
             EthRequest::EvmMine(mine) => self.evm_mine(mine).await.to_rpc_result(),
             EthRequest::EvmMineDetailed(mine) => self.evm_mine_detailed(mine).await.to_rpc_result(),
 
+            // ---- Coinbase ----
+            EthRequest::SetCoinbase(address) => {
+                node_info!("anvil_setCoinbase");
+                let latest_block = self.latest_block();
+                self.backend.inject_coinbase(latest_block, address);
+                Ok(()).to_rpc_result()
+            }
+            EthRequest::EthCoinbase(()) => {
+                node_info!("eth_coinbase");
+                let latest_block = self.latest_block();
+                self.backend.read_coinbase(latest_block).map_err(Error::Backend).to_rpc_result()
+            }
+
             //------- TimeMachine---------
             EthRequest::EvmSetBlockTimeStampInterval(time) => {
                 self.set_block_timestamp_interval(time).to_rpc_result()

crates/anvil-polkadot/src/substrate_node/genesis.rs

@@ -32,6 +32,8 @@ pub struct GenesisConfig {
     pub base_fee_per_gas: u64,
     /// The genesis header gas limit.
     pub gas_limit: Option<u128>,
+    /// Coinbase address
+    pub coinbase: Option<Address>,
 }
 
 impl<'a> From<&'a AnvilNodeConfig> for GenesisConfig {
@@ -50,16 +52,22 @@ impl<'a> From<&'a AnvilNodeConfig> for GenesisConfig {
                 .expect("Genesis block number overflow"),
             base_fee_per_gas: anvil_config.get_base_fee(),
             gas_limit: anvil_config.gas_limit,
+            coinbase: anvil_config.genesis.as_ref().map(|g| g.coinbase),
         }
     }
 }
 
 impl GenesisConfig {
     pub fn as_storage_key_value(&self) -> Vec<(Vec<u8>, Vec<u8>)> {
+        let mut aura_authority_id = [0xEE; 32];
+        aura_authority_id[..20].copy_from_slice(
+            self.coinbase.as_ref().map(|addr| addr.0.as_slice()).unwrap_or(&[0; 20]),
+        );
         let storage = vec![
             (well_known_keys::CHAIN_ID.to_vec(), self.chain_id.encode()),
             (well_known_keys::TIMESTAMP.to_vec(), self.timestamp.encode()),
             (well_known_keys::BLOCK_NUMBER_KEY.to_vec(), self.number.encode()),
+            (well_known_keys::AURA_AUTHORITIES.to_vec(), vec![aura_authority_id].encode()),
         ];
         // TODO: add other fields
         storage
@@ -171,8 +179,14 @@ mod tests {
         let block_number: u32 = 5;
         let timestamp: u64 = 10;
         let chain_id: u64 = 42;
-        let genesis_config =
-            GenesisConfig { number: block_number, timestamp, chain_id, ..Default::default() };
+        let authority_id: [u8; 32] = [0xEE; 32];
+        let genesis_config = GenesisConfig {
+            number: block_number,
+            timestamp,
+            chain_id,
+            coinbase: Some(Address::from([0xEE; 20])),
+            ..Default::default()
+        };
         let genesis_storage = genesis_config.as_storage_key_value();
         assert!(
             genesis_storage
@@ -187,5 +201,13 @@ mod tests {
             genesis_storage.contains(&(well_known_keys::CHAIN_ID.to_vec(), chain_id.encode())),
             "Chain id not found in genesis key-value storage"
         );
+
+        assert!(
+            genesis_storage.contains(&(
+                well_known_keys::AURA_AUTHORITIES.to_vec(),
+                vec![authority_id].encode()
+            )),
+            "Authorities not found in genesis key-value storage"
+        );
     }
 }

crates/anvil-polkadot/src/substrate_node/service/backend.rs

@@ -26,6 +26,8 @@ pub enum BackendError {
     MissingTotalIssuance,
     #[error("Could not find chain id in the state")]
     MissingChainId,
+    #[error("Could not find coinbase in the state")]
+    MissingCoinbase,
     #[error("Could not find timestamp in the state")]
     MissingTimestamp,
     #[error("Unable to decode total issuance {0}")]
@@ -42,6 +44,8 @@ pub enum BackendError {
     DecodeCodeInfo(codec::Error),
     #[error("Unable to decode timestamp: {0}")]
     DecodeTimestamp(codec::Error),
+    #[error("Unable to decode coinbase: {0}")]
+    DecodeCoinbase(codec::Error),
 }
 
 type Result<T> = std::result::Result<T, BackendError>;
@@ -75,6 +79,17 @@ impl BackendWithOverlay {
         u64::decode(&mut &value[..]).map_err(BackendError::DecodeChainId)
     }
 
+    pub fn read_coinbase(&self, hash: Hash) -> Result<Address> {
+        let key = well_known_keys::AURA_AUTHORITIES;
+
+        let value =
+            self.read_top_state(hash, key.to_vec())?.ok_or(BackendError::MissingCoinbase)?;
+        let authorities =
+            <Vec<[u8; 32]>>::decode(&mut &value[..]).map_err(BackendError::DecodeCoinbase)?;
+        let authority = authorities.first().ok_or(BackendError::MissingCoinbase)?;
+        Ok(Address::from_slice(&authority[..20]))
+    }
+
     pub fn read_total_issuance(&self, hash: Hash) -> Result<Balance> {
         let key = well_known_keys::TOTAL_ISSUANCE;
 
@@ -136,6 +151,11 @@ impl BackendWithOverlay {
         overrides.set_chain_id(at, chain_id);
     }
 
+    pub fn inject_coinbase(&self, at: Hash, coinbase: Address) {
+        let mut overrides = self.overrides.lock();
+        overrides.set_coinbase(at, coinbase);
+    }
+
     pub fn inject_total_issuance(&self, at: Hash, value: Balance) {
         let mut overrides = self.overrides.lock();
         overrides.set_total_issuance(at, value);
@@ -218,6 +238,17 @@ impl StorageOverrides {
         self.add(latest_block, changeset);
     }
 
+    fn set_coinbase(&mut self, latest_block: Hash, coinbase: Address) {
+        let mut changeset = BlockOverrides::default();
+        let mut account_id = [0xEE; 32];
+        account_id[..20].copy_from_slice(coinbase.0.as_slice());
+        changeset
+            .top
+            .insert(well_known_keys::AURA_AUTHORITIES.to_vec(), Some(vec![account_id].encode()));
+
+        self.add(latest_block, changeset);
+    }
+
     #[allow(unused)]
     fn set_timestamp(&mut self, latest_block: Hash, timestamp: u64) {
         let mut changeset = BlockOverrides::default();

crates/anvil-polkadot/src/substrate_node/service/consensus.rs

@@ -0,0 +1,52 @@
+use polkadot_sdk::{
+    sc_consensus::BlockImportParams,
+    sc_consensus_aura::CompatibleDigestItem,
+    sc_consensus_manual_seal::{ConsensusDataProvider, Error},
+    sp_consensus_aura::ed25519::AuthoritySignature,
+    sp_consensus_babe::Slot,
+    sp_inherents::InherentData,
+    sp_runtime::{Digest, DigestItem, traits::Block as BlockT},
+};
+use std::marker::PhantomData;
+
+/// Consensus data provider for Aura.
+pub struct SameSlotConsensusDataProvider<B, P> {
+    // slot duration
+    _phantom: PhantomData<(B, P)>,
+}
+
+impl<B, P> SameSlotConsensusDataProvider<B, P> {
+    pub fn new() -> Self {
+        Self { _phantom: PhantomData }
+    }
+}
+
+impl<B, P> ConsensusDataProvider<B> for SameSlotConsensusDataProvider<B, P>
+where
+    B: BlockT,
+    P: Send + Sync,
+{
+    type Proof = P;
+
+    fn create_digest(
+        &self,
+        _parent: &B::Header,
+        _inherents: &InherentData,
+    ) -> Result<Digest, Error> {
+        let digest_item = <DigestItem as CompatibleDigestItem<AuthoritySignature>>::aura_pre_digest(
+            Slot::default(),
+        );
+
+        Ok(Digest { logs: vec![digest_item] })
+    }
+
+    fn append_block_import(
+        &self,
+        _parent: &B::Header,
+        _params: &mut BlockImportParams<B>,
+        _inherents: &InherentData,
+        _proof: Self::Proof,
+    ) -> Result<(), Error> {
+        Ok(())
+    }
+}

crates/anvil-polkadot/src/substrate_node/service/mod.rs

@@ -3,13 +3,15 @@ use crate::{
     substrate_node::{
         mining_engine::{MiningEngine, MiningMode, run_mining_engine},
         rpc::spawn_rpc_server,
+        service::consensus::SameSlotConsensusDataProvider,
     },
 };
 use anvil::eth::backend::time::TimeManager;
 use parking_lot::Mutex;
 use polkadot_sdk::{
     parachains_common::opaque::Block,
-    sc_basic_authorship, sc_consensus, sc_consensus_manual_seal,
+    sc_basic_authorship, sc_consensus,
+    sc_consensus_manual_seal::{self},
     sc_service::{
         self, Configuration, RpcHandlers, SpawnTaskHandle, TaskManager,
         error::Error as ServiceError,
@@ -24,6 +26,7 @@ pub use client::Client;
 
 mod backend;
 mod client;
+mod consensus;
 mod executor;
 pub mod storage;
 
@@ -136,7 +139,7 @@ pub fn new(
         pool: transaction_pool.clone(),
         select_chain: SelectChain::new(backend.clone()),
         commands_stream: Box::pin(commands_stream),
-        consensus_data_provider: None,
+        consensus_data_provider: Some(Box::new(SameSlotConsensusDataProvider::new())),
         create_inherent_data_providers,
     };
     let authorship_future = sc_consensus_manual_seal::run_manual_seal(params);

crates/anvil-polkadot/src/substrate_node/service/storage.rs

@@ -86,6 +86,12 @@ pub mod well_known_keys {
         154u8, 202u8, 73u8, 131u8, 172u8,
     ];
 
+    //twox_128(b"Aura" + b"Authorities")
+    pub const AURA_AUTHORITIES: [u8; 32] = [
+        87, 248, 220, 47, 90, 176, 148, 103, 137, 111, 71, 48, 15, 4, 36, 56, 94, 6, 33, 196, 134,
+        154, 166, 12, 2, 190, 154, 220, 201, 138, 13, 29,
+    ];
+
     pub fn system_account_info(account_id: AccountId) -> Vec<u8> {
         let mut key = Vec::new();
         key.extend_from_slice(&twox_128("System".as_bytes()));

crates/anvil-polkadot/substrate-runtime/Cargo.toml

@@ -13,6 +13,7 @@ license.workspace = true
 array-bytes = { version = "6.2.2", default-features = false }
 codec = { version = "3.7.5", default-features = false, package = "parity-scale-codec" }
 polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk.git", branch = "master", default-features = false, features = [
+	"pallet-aura",
 	"pallet-balances",
 	"pallet-revive",
 	"pallet-sudo",
@@ -21,6 +22,7 @@ polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk.git", branch
 	"pallet-transaction-payment-rpc-runtime-api",
 	"parachains-common",
 	"runtime",
+	"sp-consensus-aura",
 	"with-tracing",
 ] }
 scale-info = { version = "2.11.6", default-features = false }

crates/anvil-polkadot/substrate-runtime/src/lib.rs

@@ -7,6 +7,7 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
 
 extern crate alloc;
 
+use crate::sp_runtime::ConsensusEngineId;
 use alloc::{vec, vec::Vec};
 use currency::*;
 use frame_support::weights::{
@@ -17,11 +18,16 @@ use frame_system::limits::BlockWeights;
 use pallet_revive::{AccountId32Mapper, evm::runtime::EthExtra};
 use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
 use polkadot_sdk::{
-    parachains_common::{AccountId, BlockNumber, Hash as CommonHash, Header, Nonce, Signature},
+    parachains_common::{
+        AccountId, AssetHubPolkadotAuraId as AuraId, BlockNumber, Hash as CommonHash, Header,
+        Nonce, Signature,
+    },
     polkadot_sdk_frame::{
         deps::sp_genesis_builder,
         runtime::{apis, prelude::*},
+        traits::FindAuthor,
     },
+    sp_consensus_aura::{self, SlotDuration, runtime_decl_for_aura_api::AuraApiV1},
     *,
 };
 
@@ -222,6 +228,20 @@ mod runtime {
     /// Provides the ability to execute Smart Contracts.
     #[runtime::pallet_index(5)]
     pub type Revive = pallet_revive::Pallet<Runtime>;
+
+    /// Provides the ability to determine AURA authorities for block building.
+    #[runtime::pallet_index(6)]
+    pub type Aura = pallet_aura::Pallet<Runtime>;
+}
+
+impl pallet_aura::Config for Runtime {
+    type AuthorityId = AuraId;
+    type DisabledValidators = ();
+    type MaxAuthorities = ConstU32<1>;
+    type AllowMultipleBlocksPerSlot = ConstBool<true>;
+    // Not relevant in general since the node digest
+    // will refer to slot 0 always.
+    type SlotDuration = ConstU64<6000>;
 }
 
 /// We assume that ~10% of the block weight is consumed by `on_initialize` handlers.
@@ -304,12 +324,25 @@ parameter_types! {
     pub storage ChainId: u64 = 420_420_420;
 }
 
+pub struct BlockAuthor;
+impl FindAuthor<AccountId> for BlockAuthor {
+    fn find_author<'a, I>(_digests: I) -> Option<AccountId>
+    where
+        I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+    {
+        let authorities = Runtime::authorities();
+        let key = authorities[0].clone().into_inner();
+        Some(key.into())
+    }
+}
+
 #[derive_impl(pallet_revive::config_preludes::TestDefaultConfig)]
 impl pallet_revive::Config for Runtime {
     type AddressMapper = AccountId32Mapper<Self>;
     type ChainId = ChainId;
     type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
     type Currency = Balances;
+    type FindAuthor = BlockAuthor;
     type NativeToEthRatio = ConstU32<1_000_000>;
     type UploadOrigin = EnsureSigned<Self::AccountId>;
     type InstantiateOrigin = EnsureSigned<Self::AccountId>;
@@ -435,4 +468,20 @@ pallet_revive::impl_runtime_apis_plus_revive!(
             self::genesis_config_presets::preset_names()
         }
     }
+
+    impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
+        fn slot_duration() -> SlotDuration {
+            // This is not relevant when considering a manual-seal
+            // driven node. The slot duration is used by Aura to determine
+            // the authority, but anvil-polkadot will provide a single slot
+            // always, not taking into consideration computing based on this
+            // runtime API.
+            SlotDuration::from_millis(6000)
+        }
+
+        fn authorities() -> Vec<AuraId> {
+            pallet_aura::Authorities::<Runtime>::get().into_inner()
+        }
+    }
+
 );