[pallet-revive] implement the block author API

cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs

@@ -1082,6 +1082,7 @@ impl pallet_revive::Config for Runtime {
 	type ChainId = ConstU64<420_420_421>;
 	type NativeToEthRatio = ConstU32<1_000_000>; // 10^(18 - 12) Eth is 10^18, Native is 10^12.
 	type EthGasEncoder = ();
+	type FindAuthor = <Runtime as pallet_authorship::Config>::FindAuthor;
 }
 
 impl TryFrom<RuntimeCall> for pallet_revive::Call<Runtime> {

prdoc/pr_7198.prdoc

@@ -0,0 +1,12 @@
+title: '[pallet-revive] implement the block author API '
+doc:
+- audience: Runtime Dev
+  description: This PR implements the block author API method. Runtimes ought to implement
+    it such that it corresponds to the `coinbase` EVM opcode.
+crates:
+- name: pallet-revive
+  bump: major
+- name: pallet-revive-fixtures
+  bump: minor
+- name: pallet-revive-uapi
+  bump: minor

substrate/bin/node/runtime/src/lib.rs

@@ -1476,6 +1476,7 @@ impl pallet_revive::Config for Runtime {
 	type ChainId = ConstU64<420_420_420>;
 	type NativeToEthRatio = ConstU32<1_000_000>; // 10^(18 - 12) Eth is 10^18, Native is 10^12.
 	type EthGasEncoder = ();
+	type FindAuthor = <Runtime as pallet_authorship::Config>::FindAuthor;
 }
 
 impl pallet_sudo::Config for Runtime {

substrate/frame/revive/fixtures/contracts/block_author.rs

@@ -0,0 +1,37 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![no_std]
+#![no_main]
+
+use common::input;
+use uapi::{HostFn, HostFnImpl as api};
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn deploy() {}
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn call() {
+	input!(expected: &[u8; 20],);
+
+	let mut received = [0; 20];
+	api::block_author(&mut received);
+
+	assert_eq!(expected, &received);
+}

substrate/frame/revive/src/benchmarking/mod.rs

@@ -41,6 +41,7 @@ use frame_support::{
 use frame_system::RawOrigin;
 use pallet_revive_uapi::{CallFlags, ReturnErrorCode, StorageFlags};
 use sp_runtime::traits::{Bounded, Hash};
+use sp_runtime::generic::{Digest, DigestItem};
 
 /// How many runs we do per API benchmark.
 ///
@@ -886,6 +887,29 @@ mod benchmarks {
 		assert_eq!(U256::from_little_endian(&memory[..]), runtime.ext().block_number());
 	}
 
+	#[benchmark(pov_mode = Measured)]
+	fn seal_block_author() {
+		build_runtime!(runtime, memory: [[123u8; 20], ]);
+
+		let mut digest = Digest::default();
+		digest.push(DigestItem::PreRuntime([1, 2, 3, 4], 123.encode()));
+		digest.push(DigestItem::Seal([1, 2, 4, 4], 123.encode()));
+		frame_system::Pallet::<T>::initialize(&Default::default(), &Default::default(), &digest);
+
+		let result;
+		#[block]
+		{
+			result = runtime.bench_block_author(memory.as_mut_slice(), 0);
+		}
+		assert_ok!(result);
+		let block_author = runtime
+			.ext()
+			.block_author()
+			.map(|account| T::AddressMapper::to_address(&account))
+			.unwrap_or(H160::zero());
+		assert_eq!(&memory[..], block_author.as_bytes());
+	}
+
 	#[benchmark(pov_mode = Measured)]
 	fn seal_block_hash() {
 		let mut memory = vec![0u8; 64];

substrate/frame/revive/src/exec.rs

@@ -37,7 +37,7 @@ use frame_support::{
 	traits::{
 		fungible::{Inspect, Mutate},
 		tokens::{Fortitude, Preservation},
-		Contains, OriginTrait, Time,
+		Contains, FindAuthor, OriginTrait, Time,
 	},
 	weights::Weight,
 	Blake2_128Concat, BoundedVec, StorageHasher,
@@ -366,6 +366,9 @@ pub trait Ext: sealing::Sealed {
 	/// `block_number` isn't within the range of the previous 256 blocks.
 	fn block_hash(&self, block_number: U256) -> Option<H256>;
 
+	/// Returns the author of the current block.
+	fn block_author(&self) -> Option<AccountIdOf<Self::T>>;
+
 	/// Returns the maximum allowed size of a storage item.
 	fn max_value_size(&self) -> u32;
 
@@ -1676,6 +1679,13 @@ where
 		self.block_hash(block_number)
 	}
 
+	fn block_author(&self) -> Option<AccountIdOf<Self::T>> {
+		let digest = <frame_system::Pallet<T>>::digest();
+		let pre_runtime_digests = digest.logs.iter().filter_map(|d| d.as_pre_runtime());
+
+		T::FindAuthor::find_author(pre_runtime_digests)
+	}
+
 	fn max_value_size(&self) -> u32 {
 		limits::PAYLOAD_BYTES
 	}

substrate/frame/revive/src/lib.rs

@@ -119,7 +119,7 @@ const LOG_TARGET: &str = "runtime::revive";
 pub mod pallet {
 	use super::*;
 	use crate::debug::Debugger;
-	use frame_support::pallet_prelude::*;
+	use frame_support::{pallet_prelude::*, traits::FindAuthor};
 	use frame_system::pallet_prelude::*;
 	use sp_core::U256;
 	use sp_runtime::Perbill;
@@ -194,6 +194,9 @@ pub mod pallet {
 		#[pallet::no_default_bounds]
 		type ChainExtension: chain_extension::ChainExtension<Self> + Default;
 
+		/// Find the author of the current block.
+		type FindAuthor: FindAuthor<Self::AccountId>;
+
 		/// The amount of balance a caller has to pay for each byte of storage.
 		///
 		/// # Note
@@ -374,6 +377,7 @@ pub mod pallet {
 			type ChainId = ConstU64<0>;
 			type NativeToEthRatio = ConstU32<1>;
 			type EthGasEncoder = ();
+			type FindAuthor = ();
 		}
 	}
 

substrate/frame/revive/src/tests.rs

@@ -55,7 +55,7 @@ use frame_support::{
 	traits::{
 		fungible::{BalancedHold, Inspect, Mutate, MutateHold},
 		tokens::Preservation,
-		ConstU32, ConstU64, Contains, OnIdle, OnInitialize, StorageVersion,
+		ConstU32, ConstU64, Contains, FindAuthor, OnIdle, OnInitialize, StorageVersion,
 	},
 	weights::{constants::WEIGHT_REF_TIME_PER_SECOND, FixedFee, IdentityFee, Weight, WeightMeter},
 };
@@ -509,6 +509,15 @@ parameter_types! {
 	pub static UnstableInterface: bool = true;
 }
 
+impl FindAuthor<<Test as frame_system::Config>::AccountId> for Test {
+	fn find_author<'a, I>(_digests: I) -> Option<<Test as frame_system::Config>::AccountId>
+	where
+		I: 'a + IntoIterator<Item = (frame_support::ConsensusEngineId, &'a [u8])>,
+	{
+		Some(EVE)
+	}
+}
+
 #[derive_impl(crate::config_preludes::TestDefaultConfig)]
 impl Config for Test {
 	type Time = Timestamp;
@@ -525,6 +534,7 @@ impl Config for Test {
 	type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
 	type Debug = TestDebug;
 	type ChainId = ChainId;
+	type FindAuthor = Test;
 }
 
 impl TryFrom<RuntimeCall> for crate::Call<Test> {
@@ -3599,6 +3609,21 @@ fn block_hash_works() {
 	});
 }
 
+#[test]
+fn block_author_works() {
+	let (code, _) = compile_module("block_author").unwrap();
+
+	ExtBuilder::default().existential_deposit(1).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let Contract { addr, .. } =
+			builder::bare_instantiate(Code::Upload(code)).build_and_unwrap_contract();
+
+		// The fixture asserts the input to match the find_author API method output.
+		assert_ok!(builder::call(addr).data(EVE_ADDR.encode()).build());
+	});
+}
+
 #[test]
 fn root_cannot_upload_code() {
 	let (wasm, _) = compile_module("dummy").unwrap();

substrate/frame/revive/src/wasm/runtime.rs

@@ -327,6 +327,8 @@ pub enum RuntimeCosts {
 	BlockNumber,
 	/// Weight of calling `seal_block_hash`.
 	BlockHash,
+	/// Weight of calling `seal_block_author`.
+	BlockAuthor,
 	/// Weight of calling `seal_gas_price`.
 	GasPrice,
 	/// Weight of calling `seal_base_fee`.
@@ -483,6 +485,7 @@ impl<T: Config> Token<T> for RuntimeCosts {
 			MinimumBalance => T::WeightInfo::seal_minimum_balance(),
 			BlockNumber => T::WeightInfo::seal_block_number(),
 			BlockHash => T::WeightInfo::seal_block_hash(),
+			BlockAuthor => T::WeightInfo::seal_block_author(),
 			GasPrice => T::WeightInfo::seal_gas_price(),
 			BaseFee => T::WeightInfo::seal_base_fee(),
 			Now => T::WeightInfo::seal_now(),
@@ -1676,6 +1679,25 @@ pub mod env {
 		)?)
 	}
 
+	/// Stores the current block author into the supplied buffer.
+	/// See [`pallet_revive_uapi::HostFn::block_author`].
+	#[stable]
+	fn block_author(&mut self, memory: &mut M, out_ptr: u32) -> Result<(), TrapReason> {
+		self.charge_gas(RuntimeCosts::BlockAuthor)?;
+		let block_author = self
+			.ext
+			.block_author()
+			.map(|account| <E::T as Config>::AddressMapper::to_address(&account))
+			.unwrap_or(H160::zero());
+		Ok(self.write_fixed_sandbox_output(
+			memory,
+			out_ptr,
+			&block_author.as_bytes(),
+			false,
+			already_charged,
+		)?)
+	}
+
 	/// Computes the KECCAK 256-bit hash on the given input buffer.
 	/// See [`pallet_revive_uapi::HostFn::hash_keccak_256`].
 	#[stable]