Big refactor.

native-runtime/support/src/lib.rs

@@ -6,7 +6,8 @@ pub use std::vec::Vec;
 pub use std::rc::Rc;
 pub use std::cell::RefCell;
 pub use std::boxed::Box;
-pub use std::mem::{size_of, transmute, swap};
+pub use std::slice;
+pub use std::mem::{size_of, transmute, swap, uninitialized};
 
 pub use polkadot_state_machine::Externalities;
 use std::fmt;

wasm-runtime/polkadot/src/consensus.rs

@@ -0,0 +1,72 @@
+use keyedvec::KeyedVec;
+use storage::Storage;
+use primitives::{AccountID, SessionKey, BlockNumber};
+use storage::storage_into;
+
+pub fn set_authority(index: u32, authority: AccountID) {
+	authority.store(&index.to_keyed_vec(b"con\0aut\0"));
+}
+
+fn authority(index: u32) -> AccountID {
+	storage_into(&index.to_keyed_vec(b"con\0aut\0"))
+}
+
+pub fn set_authority_count(count: u32) {
+	(count..authority_count()).for_each(|i| set_authority(i, SessionKey::default()));
+	count.store(b"con\0aut\0len");
+}
+
+fn authority_count() -> u32 {
+	storage_into(b"con\0aut\0len")
+}
+
+/// Get the current set of authorities. These are the session keys.
+pub fn authorities() -> Vec<AccountID> {
+	(0..authority_count()).into_iter().map(authority).collect()
+}
+
+/// Set the current set of authorities' session keys.
+///
+/// Called by `next_session` only.
+pub fn set_authorities(authorities: &[AccountID]) {
+	set_authority_count(authorities.len() as u32);
+	authorities.iter().enumerate().for_each(|(v, &i)| set_authority(v as u32, i));
+}
+
+/// Get the current set of validators. These are the long-term identifiers for the validators
+/// and will be mapped to a session key with the most recent `set_next_session_key`.
+pub fn validators() -> Vec<AccountID> {
+	unimplemented!()
+}
+
+/// Set the current set of validators.
+///
+/// Called by staking::next_era() only.
+pub fn set_validators(_new: &[AccountID]) {
+	unimplemented!()
+}
+
+/// The number of blocks in each session.
+pub fn session_length() -> BlockNumber {
+	storage_into(b"con\0bps")
+}
+
+/// Sets the session key of `_transactor` to `_session`. This doesn't take effect until the next
+/// session.
+pub fn set_session_key(_transactor: &AccountID, _session: &AccountID) {
+	unimplemented!()
+}
+
+/// Move onto next session: register the new authority set.
+pub fn next_session() {
+	// TODO: Call set_authorities().
+	unimplemented!()
+}
+
+/// Hook to be called prior to transaction processing.
+pub fn pre_transactions() {}
+
+/// Hook to be called after to transaction processing.
+pub fn post_transactions() {
+	// TODO: check block number and call next_session if necessary.
+}

wasm-runtime/polkadot/src/endiansensitive.rs

@@ -0,0 +1,29 @@
+pub trait EndianSensitive: Sized {
+	fn to_le(self) -> Self { self }
+	fn to_be(self) -> Self { self }
+	fn from_le(self) -> Self { self }
+	fn from_be(self) -> Self { self }
+	fn as_be_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { f(&self) }
+	fn as_le_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { f(&self) }
+}
+
+macro_rules! impl_endians {
+	( $( $t:ty ),* ) => { $(
+		impl EndianSensitive for $t {
+			fn to_le(self) -> Self { <$t>::to_le(self) }
+			fn to_be(self) -> Self { <$t>::to_be(self) }
+			fn from_le(self) -> Self { <$t>::from_le(self) }
+			fn from_be(self) -> Self { <$t>::from_be(self) }
+			fn as_be_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { let d = self.to_be(); f(&d) }
+			fn as_le_then<T, F: FnOnce(&Self) -> T>(&self, f: F) -> T { let d = self.to_le(); f(&d) }
+		}
+	)* }
+}
+macro_rules! impl_non_endians {
+	( $( $t:ty ),* ) => { $(
+		impl EndianSensitive for $t {}
+	)* }
+}
+
+impl_endians!(u16, u32, u64, usize, i16, i32, i64, isize);
+impl_non_endians!(u8, i8, [u8; 20], [u8; 32]);

wasm-runtime/polkadot/src/environment.rs

@@ -0,0 +1,33 @@
+use runtime_support::{Rc, RefCell, transmute, Box};
+use primitives::{BlockNumber, Digest};
+
+#[derive(Default)]
+pub struct Environment {
+	pub block_number: BlockNumber,
+	pub digest: Digest,
+	pub next_log_index: usize,
+}
+
+pub fn with_env<T, F: FnOnce(&mut Environment) -> T>(f: F) -> T {
+	let e = env();
+	let mut eb = e.borrow_mut();
+	f(&mut *eb)
+}
+
+pub fn env() -> Rc<RefCell<Environment>> {
+	// Initialize it to a null value
+	static mut SINGLETON: *const Rc<RefCell<Environment>> = 0 as *const Rc<RefCell<Environment>>;
+
+	unsafe {
+		if SINGLETON == 0 as *const Rc<RefCell<Environment>> {
+			// Make it
+			let singleton: Rc<RefCell<Environment>> = Rc::new(RefCell::new(Default::default()));
+
+			// Put it in the heap so it can outlive this call
+			SINGLETON = transmute(Box::new(singleton));
+		}
+
+		// Now we give out a copy of the data that is safe to use concurrently.
+		(*SINGLETON).clone()
+	}
+}

wasm-runtime/polkadot/src/function.rs

@@ -0,0 +1,50 @@
+use staking;
+use consensus;
+use primitives::AccountID;
+use streamreader::StreamReader;
+
+/// The functions that a transaction can call (and be dispatched to).
+#[cfg_attr(test, derive(PartialEq, Debug))]
+#[derive(Clone, Copy)]
+pub enum Function {
+	StakingStake,
+	StakingUnstake,
+	StakingTransferStake,
+	ConsensusSetSessionKey,
+}
+
+impl Function {
+	pub fn from_u8(value: u8) -> Option<Function> {
+		match value {
+			x if x == Function::StakingStake as u8 => Some(Function::StakingStake),
+			x if x == Function::StakingUnstake as u8 => Some(Function::StakingUnstake),
+			x if x == Function::StakingTransferStake as u8 => Some(Function::StakingTransferStake),
+			x if x == Function::ConsensusSetSessionKey as u8 => Some(Function::ConsensusSetSessionKey),
+			_ => None,
+		}
+	}
+}
+
+impl Function {
+	/// Dispatch the function.
+	pub fn dispatch(&self, transactor: &AccountID, data: &[u8]) {
+		let mut params = StreamReader::new(data);
+		match *self {
+			Function::StakingStake => {
+				staking::stake(transactor);
+			}
+			Function::StakingUnstake => {
+				staking::unstake(transactor);
+			}
+			Function::StakingTransferStake => {
+				let dest = params.read().unwrap();
+				let value = params.read().unwrap();
+				staking::transfer_stake(transactor, &dest, value);
+			}
+			Function::ConsensusSetSessionKey => {
+				let session = params.read().unwrap();
+				consensus::set_session_key(transactor, &session);
+			}
+		}
+	}
+}

wasm-runtime/polkadot/src/keyedvec.rs

@@ -0,0 +1,30 @@
+use primitives::AccountID;
+use slicable::Slicable;
+
+pub trait KeyedVec {
+	fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8>;
+}
+
+impl KeyedVec for AccountID {
+	fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> {
+		let mut r = prepend_key.to_vec();
+		r.extend_from_slice(self);
+		r
+	}
+}
+
+macro_rules! impl_endians {
+	( $( $t:ty ),* ) => { $(
+		impl KeyedVec for $t {
+			fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> {
+				self.as_slice_then(|slice| {
+					let mut r = prepend_key.to_vec();
+					r.extend_from_slice(slice);
+					r
+				})
+			}
+		}
+	)* }
+}
+
+impl_endians!(u16, u32, u64, usize, i16, i32, i64, isize);