A random beacon

demo/executor/src/lib.rs

@@ -46,7 +46,8 @@ mod tests {
 	use demo_primitives::{Hash, Header, BlockNumber, Digest};
 	use demo_runtime::transaction::{Transaction, UncheckedTransaction};
 	use demo_runtime::block::Block;
-	use demo_runtime::runtime::staking::{self, FreeBalanceOf, balance};
+	use demo_runtime::runtime::staking::{FreeBalanceOf, balance};
+	use demo_runtime::runtime::{staking, system};
 	use demo_runtime::dispatch;
 	use ed25519::{Public, Pair};
 
@@ -76,32 +77,41 @@ mod tests {
 	fn panic_execution_with_foreign_code_gives_error() {
 		let mut t: TestExternalities = map![
 			twox_128(&FreeBalanceOf::key_for(*Alice)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0],
-			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8]
+			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8],
+			twox_128(&system::BlockHashAt::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
-		let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		let r = Executor::new().call(&mut t, BLOATY_CODE, "initialise_block", &vec![].and(&Header::from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&tx()));
 		assert!(r.is_err());
 	}
 
 	#[test]
 	fn panic_execution_with_native_equivalent_code_gives_error() {
 		let mut t: TestExternalities = map![
 			twox_128(&FreeBalanceOf::key_for(*Alice)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0],
-			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8]
+			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8],
+			twox_128(&system::BlockHashAt::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
-		let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		let r = Executor::new().call(&mut t, COMPACT_CODE, "initialise_block", &vec![].and(&Header::from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&tx()));
 		assert!(r.is_err());
 	}
 
 	#[test]
 	fn successful_execution_with_native_equivalent_code_gives_ok() {
 		let mut t: TestExternalities = map![
 			twox_128(&FreeBalanceOf::key_for(*Alice)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
-			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8]
+			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8],
+			twox_128(&system::BlockHashAt::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
-		let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		let r = Executor::new().call(&mut t, COMPACT_CODE, "initialise_block", &vec![].and(&Header::from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&tx()));
 		assert!(r.is_ok());
 
 		runtime_io::with_externalities(&mut t, || {
@@ -114,10 +124,13 @@ mod tests {
 	fn successful_execution_with_foreign_code_gives_ok() {
 		let mut t: TestExternalities = map![
 			twox_128(&FreeBalanceOf::key_for(*Alice)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
-			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8]
+			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8],
+			twox_128(&system::BlockHashAt::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
-		let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		let r = Executor::new().call(&mut t, BLOATY_CODE, "initialise_block", &vec![].and(&Header::from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&tx()));
 		assert!(r.is_ok());
 
 		runtime_io::with_externalities(&mut t, || {
@@ -229,23 +242,29 @@ mod tests {
 	fn panic_execution_gives_error() {
 		let mut t: TestExternalities = map![
 			twox_128(&FreeBalanceOf::key_for(*Alice)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0],
-			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8]
+			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8],
+			twox_128(&system::BlockHashAt::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
 		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.wasm");
-		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "initialise_block", &vec![].and(&Header::from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].and(&tx()));
 		assert!(r.is_err());
 	}
 
 	#[test]
 	fn successful_execution_gives_ok() {
 		let mut t: TestExternalities = map![
 			twox_128(&FreeBalanceOf::key_for(*Alice)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
-			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8]
+			twox_128(staking::TransactionFee::key()).to_vec() => vec![0u8; 8],
+			twox_128(&system::BlockHashAt::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
 		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.compact.wasm");
-		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "initialise_block", &vec![].and(&Header::from_block_number(1u64)));
+		assert!(r.is_ok());
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].and(&tx()));
 		assert!(r.is_ok());
 
 		runtime_io::with_externalities(&mut t, || {

demo/runtime/src/api.rs

@@ -18,8 +18,9 @@ use runtime::{system, consensus, session};
 
 impl_stubs!(
 	execute_block => |block| system::internal::execute_block(block),
-	execute_transaction => |(header, utx)| system::internal::execute_transaction(utx, header),
-	finalise_block => |header| system::internal::finalise_block(header),
+	initialise_block => |header| system::internal::initialise_block(&header),
+	execute_transaction => |utx| system::internal::execute_transaction(utx),
+	finalise_block => |()| system::internal::finalise_block(),
 	validator_count => |()| session::validator_count(),
 	validators => |()| session::validators(),
 	authorities => |()| consensus::authorities()

demo/runtime/src/lib.rs

@@ -38,9 +38,9 @@ extern crate integer_sqrt;
 
 #[macro_use] pub mod dispatch;
 
+pub mod safe_mix;
 pub mod block;
 pub mod transaction;
-pub mod environment;
 pub mod runtime;
 pub mod api;