Staking Precompiles

runtime/precompiles/Cargo.toml

@@ -16,14 +16,20 @@ frame-support = { git = "https://github.com/paritytech/substrate", branch = "roc
 evm = { version = "0.26.0", default-features = false, features = ["with-codec"] }
 sp-std = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "rococo-v1" }
 sp-core = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "rococo-v1" }
+sp-io = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "rococo-v1" }
 pallet-evm = { git = "https://github.com/purestake/frontier", default-features = false, branch = "notlesh-moonbeam-v0.7" }
 pallet-evm-precompile-bn128 = { git = "https://github.com/purestake/frontier", default-features = false, branch = "notlesh-moonbeam-v0.7" }
 pallet-evm-precompile-dispatch = { git = "https://github.com/purestake/frontier", default-features = false, branch = "notlesh-moonbeam-v0.7" }
 pallet-evm-precompile-modexp = { git = "https://github.com/purestake/frontier", default-features = false, branch = "notlesh-moonbeam-v0.7" }
 pallet-evm-precompile-simple = { git = "https://github.com/purestake/frontier", default-features = false, branch = "notlesh-moonbeam-v0.7" }
+parachain-staking = { path = "../../pallets/parachain-staking", default-features = false }
+frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "rococo-v1" }
+
+[dev-dependencies]
+hex = "0.4"
 
 [features]
-default = [ "std" ]
+default = ["std"]
 std = [
 	"codec/std",
 	"frame-support/std",
@@ -35,4 +41,6 @@ std = [
 	"pallet-evm-precompile-dispatch/std",
 	"pallet-evm-precompile-modexp/std",
 	"pallet-evm-precompile-simple/std",
+	"parachain-staking/std",
+	"frame-system/std",
 ]

runtime/precompiles/src/lib.rs

@@ -16,17 +16,170 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use std::u64;
+
 use codec::Decode;
 use evm::{Context, ExitError, ExitSucceed};
 use frame_support::dispatch::{Dispatchable, GetDispatchInfo, PostDispatchInfo};
+use frame_support::traits::Currency;
+use pallet_evm::AddressMapping;
+use pallet_evm::GasWeightMapping;
 use pallet_evm::{Config, Precompile, PrecompileSet};
 use pallet_evm_precompile_bn128::{Bn128Add, Bn128Mul, Bn128Pairing};
 use pallet_evm_precompile_dispatch::Dispatch;
 use pallet_evm_precompile_modexp::Modexp;
 use pallet_evm_precompile_simple::{ECRecover, Identity, Ripemd160, Sha256};
+use sp_core::offchain::Duration;
 use sp_core::H160;
+use sp_core::U256;
+use sp_io::offchain;
+use sp_std::convert::TryFrom;
+use sp_std::convert::TryInto;
+use sp_std::fmt::Debug;
 use sp_std::{marker::PhantomData, vec::Vec};
 
+/// A precompile intended to burn gas and/or time without actually doing any work.
+/// Meant for testing.
+///
+/// Expects call data to include two u64 values:
+/// 1) The gas to sacrifice (charge)
+/// 2) The time in msec to sleep
+/// TODO: use feature flags / somehow prevent this from deployment onto live networks (or not?)
+struct Sacrifice;
+
+impl Precompile for Sacrifice {
+	fn execute(
+		input: &[u8],
+		target_gas: Option<u64>,
+		_context: &Context,
+	) -> core::result::Result<(ExitSucceed, Vec<u8>, u64), ExitError> {
+		const INPUT_SIZE_BYTES: usize = 16;
+
+		// input should be exactly 16 bytes (two 8-byte unsigned ints in big endian)
+		if input.len() != INPUT_SIZE_BYTES {
+			return Err(ExitError::Other(
+				"input length for Sacrifice must be exactly 16 bytes".into(),
+			));
+		}
+
+		// create 8-byte buffers and populate them from calldata...
+		let mut gas_cost_buf: [u8; 8] = [0; 8];
+		let mut msec_cost_buf: [u8; 8] = [0; 8];
+
+		gas_cost_buf.copy_from_slice(&input[0..8]);
+		msec_cost_buf.copy_from_slice(&input[8..16]);
+
+		// then read them into a u64 as big-endian...
+		let gas_cost = u64::from_be_bytes(gas_cost_buf);
+		let msec_cost = u64::from_be_bytes(msec_cost_buf);
+
+		// ensure we can afford our sacrifice...
+		if let Some(gas_left) = target_gas {
+			if gas_left < gas_cost {
+				return Err(ExitError::OutOfGas);
+			}
+		}
+
+		// TODO: impose gas-per-second constraint?
+
+		if msec_cost > 0 {
+			// TODO: log statement here
+			let deadline = offchain::timestamp();
+			deadline.add(Duration::from_millis(msec_cost));
+			offchain::sleep_until(deadline);
+		}
+
+		// TODO Should this actually be stopped?
+		// https://ethervm.io/#F3
+		// REvisit: does solidity void contract issue stop or return
+		Ok((ExitSucceed::Returned, [0u8; 0].to_vec(), gas_cost))
+	}
+}
+
+/// A precompile to wrap the functionality from parachain_staking::nominate.
+///
+/// EXAMPLE USECASE:
+/// A simple example usecase is a contract that allows donors to donate, and stakes all the funds
+/// toward one fixed address chosen by the deployer.
+/// Such a contract could be deployed by a collator candidate, and the deploy address distributed to
+/// supporters who want to donate toward a perpetual nomination fund.
+pub struct NominateWrapper<Runtime>(PhantomData<Runtime>);
+
+type BalanceOf<Runtime> = <<Runtime as parachain_staking::Config>::Currency as Currency<
+	<Runtime as frame_system::Config>::AccountId,
+>>::Balance;
+
+impl<Runtime> Precompile for NominateWrapper<Runtime>
+where
+	Runtime: parachain_staking::Config + pallet_evm::Config,
+	Runtime::AccountId: From<H160>,
+	BalanceOf<Runtime>: TryFrom<U256> + Debug,
+	Runtime::Call: Dispatchable<PostInfo = PostDispatchInfo> + GetDispatchInfo,
+	<Runtime::Call as Dispatchable>::Origin: From<Option<Runtime::AccountId>>,
+	Runtime::Call: From<parachain_staking::Call<Runtime>>,
+{
+	fn execute(
+		input: &[u8], //Reminder this is big-endian
+		target_gas: Option<u64>,
+		context: &Context,
+	) -> Result<(ExitSucceed, Vec<u8>, u64), ExitError> {
+		// Basic sanity checking for length
+		// https://solidity-by-example.org/primitives/
+		const COLLATOR_SIZE_BYTES: usize = 20;
+		const AMOUNT_SIZE_BYTES: usize = 32;
+		const TOTAL_SIZE_BYTES: usize = COLLATOR_SIZE_BYTES + AMOUNT_SIZE_BYTES;
+
+		if input.len() != COLLATOR_SIZE_BYTES + AMOUNT_SIZE_BYTES {
+			return Err(ExitError::Other(
+				"input length for Sacrifice must be exactly 16 bytes".into(),
+			));
+		}
+
+		// Convert to right data types
+		//TODO I guess we should use the account mapping if possible. Otherwise this won't work for
+		// chains tht have a more standard substrate account type.
+		let collator = H160::from_slice(&input[0..COLLATOR_SIZE_BYTES]);
+
+		let amount: BalanceOf<Runtime> =
+			sp_core::U256::from_big_endian(&input[COLLATOR_SIZE_BYTES..TOTAL_SIZE_BYTES])
+				.try_into()
+				.map_err(|_| {
+					ExitError::Other("amount is too large for Runtime's balance type".into())
+				})?;
+
+		println!("Collator account is {:?}", collator);
+		println!("Amount is {:?}", amount);
+
+		// Construct a call
+		let inner_call = parachain_staking::Call::<Runtime>::nominate(collator.into(), amount);
+		let outer_call: Runtime::Call = inner_call.into();
+		let info = outer_call.get_dispatch_info();
+
+		// Make sure enough gas
+		if let Some(gas_limit) = target_gas {
+			let valid_weight = info.weight <= Runtime::GasWeightMapping::gas_to_weight(gas_limit);
+			if !valid_weight {
+				return Err(ExitError::OutOfGas);
+			}
+		}
+
+		// Dispatch that call
+		let origin = Runtime::AddressMapping::into_account_id(context.caller);
+
+		match outer_call.dispatch(Some(origin).into()) {
+			Ok(post_info) => {
+				let gas_used = Runtime::GasWeightMapping::weight_to_gas(
+					post_info.actual_weight.unwrap_or(info.weight),
+				);
+				Ok((ExitSucceed::Stopped, Default::default(), gas_used))
+			}
+			Err(_) => Err(ExitError::Other(
+				"Parachain staking nomination failed".into(),
+			)),
+		}
+	}
+}
+
 /// The PrecompileSet installed in the Moonbeam runtime.
 /// We include the nine Istanbul precompiles
 /// (https://github.com/ethereum/go-ethereum/blob/3c46f557/core/vm/contracts.go#L69)
@@ -58,6 +211,8 @@ where
 			a if a == hash(8) => Some(Bn128Pairing::execute(input, target_gas, context)),
 			// Moonbeam precompiles :
 			a if a == hash(255) => Some(Dispatch::<R>::execute(input, target_gas, context)),
+			// Moonbeam testing-only precompile(s):
+			a if a == hash(511) => Some(Sacrifice::execute(input, target_gas, context)),
 			_ => None,
 		}
 	}
@@ -66,3 +221,122 @@ where
 fn hash(a: u64) -> H160 {
 	H160::from_low_u64_be(a)
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::time::{Duration, Instant};
+	// use sp_io::TestExternalities; XXX
+	extern crate hex;
+
+	/*
+	 * XXX
+	pub fn new_test_ext() -> TestExternalities {
+		let t = frame_system::GenesisConfig::default()
+			.build_storage::<Test>()
+			.unwrap();
+		TestExternalities::new(t)
+	}
+	*/
+
+	#[test]
+	fn test_invalid_input_length() -> std::result::Result<(), ExitError> {
+		let cost: u64 = 1;
+
+		// TODO: this is very not-DRY, it would be nice to have a default / test impl in Frontier
+		let context: Context = Context {
+			address: Default::default(),
+			caller: Default::default(),
+			apparent_value: From::from(0),
+		};
+
+		// should fail with input of 15 byte length
+		let input: [u8; 15] = [0; 15];
+		assert_eq!(
+			Sacrifice::execute(&input, Some(cost), &context),
+			Err(ExitError::Other(
+				"input length for Sacrifice must be exactly 16 bytes".into()
+			)),
+		);
+
+		// should fail with input of 17 byte length
+		let input: [u8; 17] = [0; 17];
+		assert_eq!(
+			Sacrifice::execute(&input, Some(cost), &context),
+			Err(ExitError::Other(
+				"input length for Sacrifice must be exactly 16 bytes".into()
+			)),
+		);
+
+		Ok(())
+	}
+
+	#[test]
+	fn test_gas_consumption() -> std::result::Result<(), ExitError> {
+		let mut input: [u8; 16] = [0; 16];
+		input[..8].copy_from_slice(&123456_u64.to_be_bytes());
+
+		let context: Context = Context {
+			address: Default::default(),
+			caller: Default::default(),
+			apparent_value: From::from(0),
+		};
+
+		assert_eq!(
+			Sacrifice::execute(&input, None, &context),
+			Ok((ExitSucceed::Returned, [0u8; 0].to_vec(), 123456)),
+		);
+
+		Ok(())
+	}
+
+	#[test]
+	fn test_oog() -> std::result::Result<(), ExitError> {
+		let mut input: [u8; 16] = [0; 16];
+		input[..8].copy_from_slice(&100_u64.to_be_bytes());
+
+		let context: Context = Context {
+			address: Default::default(),
+			caller: Default::default(),
+			apparent_value: From::from(0),
+		};
+
+		assert_eq!(
+			Sacrifice::execute(&input, Some(99), &context),
+			Err(ExitError::OutOfGas),
+		);
+
+		Ok(())
+	}
+
+	/*
+	 * TODO: the sleep() function inside the precompile must be run within an externalities
+	 *       environment
+	#[test]
+	fn test_sleep() -> std::result::Result<(), ExitError> {
+
+		new_test_ext().execute_with(|| {
+			let mut input: [u8; 16] = [0; 16];
+			input[8..].copy_from_slice(&10_u64.to_be_bytes()); // should be 10ms
+
+			let context: Context = Context {
+				address: Default::default(),
+				caller: Default::default(),
+				apparent_value: From::from(0),
+			};
+
+			let start = Instant::now();
+
+			assert_eq!(
+				Sacrifice::execute(&input, Some(99), &context),
+				Ok((ExitSucceed::Returned, [0u8; 0].to_vec(), 0)),
+			);
+
+			assert!(start.elapsed().as_millis() > 10);
+			assert!(start.elapsed().as_millis() < 20); // give plenty of room, but put some bound on it
+
+			Ok(())
+		});
+	}
+	*/
+}