Introduce basic skeleton for Polkadot runtime. (#32)

* Introduce basic skeleton for Polkador runtime. * Clean up the runtime skeleton. * Make initial runtime skeleton compile. * Compile polkadot-runtime both for Wasm ad native, allowing for testing and direct usage. * More fleshing out on runtime. * Update native support. * Fix warning. * Update gitignore * Update path. * Fix path. * Remove accidentally committed files. * Add wasm binaries. * Fix test. * Native storage support API. * Add environmental module * Add native environment to make native source-code compatible with wasm. Also tests. * Finish up & polish environment stuff. * Avoid using reentrancy issues. * Add some docs and a test. * Remove unneeded function. * Documentation * Tweak docs * Remove TODOs. * Balance transfers + util methods. * Rejig tests and ensure authorities are addressed consistently. * Add marshaller for xfer function * Transaction dispatch test. * Minor fix. * Add test for ser/de transaction. * Add ser/de for header. * Add tests for header ser/de * Introduce basic block decoding/execution framework. * Introduce block decoding/execution framework (p2) * Big refactor. * Split out joiner. * Hide away support modules. * Fix up wasm runtime. * use externalities for chain_id * Clean up (Test)Externalities. * Repot and introduce keccak-256 external. * Signing with crypto. * fix unsafety hole in environmental using function * Introduce Ed25519 crypto. * Repotting. * Add ed25519_verify external. * Introduce Ed25519 verify as an external. * fix unsafety hole around unwinding * Compile fixes. * use new environmental API * Tests for ed25519 verify. * Polish * Introduce UncheckedTransaction & test. * Implement basic block and tx processing * Introduce static hex and valid signature for block test. * Repot session. * comments. * Refactor and timestamp test * Remove fluff * Remove fluff. * Staking eras and tests. * Implement sessions. * Polish * Test sessions. * Introduce better hashing. - Blake2 for secure hashing - XX for fast hashing * Fix tests. * Introduce staking. * Tests for simple staking system. * Build fix for wasm. * Fix tests. * Repotting and docs. * Docs and licence. * Documentation. * Remove superfluous code. * Remove dummy key. * Remove other superfluous file. * Optimise with swap_remove
2026-06-12 14:41:11 +00:00 · 2018-01-23 15:24:17 +01:00
parent 28d84d8ac4
commit 3402f169a7
70 changed files with 3578 additions and 282 deletions
@@ -0,0 +1,149 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! The with-std support functions for the runtime.
+
+#[macro_use]
+extern crate environmental;
+extern crate polkadot_state_machine;
+extern crate polkadot_primitives as primitives;
+
+use std::fmt;
+use primitives::ed25519;
+
+pub use std::vec::Vec;
+pub use std::rc::Rc;
+pub use std::cell::RefCell;
+pub use std::boxed::Box;
+pub use std::slice;
+pub use std::mem::{size_of, transmute, swap, uninitialized};
+
+pub use polkadot_state_machine::Externalities;
+
+// TODO: use the real error, not NoError.
+
+#[derive(Debug)]
+/// As it says - an empty type we use for errors.
+pub struct NoError;
+impl fmt::Display for NoError {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "") }
+}
+
+environmental!(ext : Externalities<Error=NoError> + 'static);
+
+/// Get `key` from storage and return a `Vec`, empty if there's a problem.
+pub fn storage(key: &[u8]) -> Vec<u8> {
+	ext::with(|ext| ext.storage(key).ok().map(|s| s.to_vec()))
+		.unwrap_or(None)
+		.unwrap_or_else(|| vec![])
+}
+
+/// Get `key` from storage, placing the value into `value_out` (as much as possible) and return
+/// the number of bytes that the key in storage was.
+pub fn read_storage(key: &[u8], value_out: &mut [u8]) -> usize {
+	ext::with(|ext| {
+		if let Ok(value) = ext.storage(key) {
+			let written = ::std::cmp::min(value.len(), value_out.len());
+			value_out[0..written].copy_from_slice(&value[0..written]);
+			value.len()
+		} else {
+			0
+		}
+	}).unwrap_or(0)
+}
+
+pub fn set_storage(key: &[u8], value: &[u8]) {
+	ext::with(|ext|
+		ext.set_storage(key.to_vec(), value.to_vec())
+	);
+}
+
+/// The current relay chain identifier.
+pub fn chain_id() -> u64 {
+	ext::with(|ext|
+		ext.chain_id()
+	).unwrap_or(0)
+}
+
+/// Conduct a Keccak-256 hash of the given data.
+pub use primitives::{blake2_256, twox_128, twox_256};
+
+/// Verify a ed25519 signature.
+pub fn ed25519_verify(sig: &[u8; 64], msg: &[u8], pubkey: &[u8; 32]) -> bool {
+	ed25519::verify(&sig[..], msg, &pubkey[..])
+}
+
+/// Execute the given closure with global function available whose functionality routes into the
+/// externalities `ext`. Forwards the value that the closure returns.
+pub fn with_externalities<R, F: FnOnce() -> R>(ext: &mut (Externalities<Error=NoError> + 'static), f: F) -> R {
+	ext::using(ext, f)
+}
+
+#[macro_export]
+macro_rules! impl_stubs {
+	($( $name:ident ),*) => {}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::collections::HashMap;
+
+	#[derive(Debug, Default)]
+	struct TestExternalities {
+		storage: HashMap<Vec<u8>, Vec<u8>>,
+	}
+	impl Externalities for TestExternalities {
+		type Error = NoError;
+
+		fn storage(&self, key: &[u8]) -> Result<&[u8], NoError> {
+			Ok(self.storage.get(&key.to_vec()).map_or(&[] as &[u8], Vec::as_slice))
+		}
+
+		fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>) {
+			self.storage.insert(key, value);
+		}
+
+		fn chain_id(&self) -> u64 { 42 }
+	}
+
+	macro_rules! map {
+		($( $name:expr => $value:expr ),*) => (
+			vec![ $( ( $name, $value ) ),* ].into_iter().collect()
+		)
+	}
+
+	#[test]
+	fn storage_works() {
+		let mut t = TestExternalities { storage: map![], };
+		assert!(with_externalities(&mut t, || {
+			assert_eq!(storage(b"hello"), b"".to_vec());
+			set_storage(b"hello", b"world");
+			assert_eq!(storage(b"hello"), b"world".to_vec());
+			assert_eq!(storage(b"foo"), b"".to_vec());
+			set_storage(b"foo", &[1, 2, 3][..]);
+			true
+		}));
+
+		t.storage = map![b"foo".to_vec() => b"bar".to_vec()];
+
+		assert!(!with_externalities(&mut t, || {
+			assert_eq!(storage(b"hello"), b"".to_vec());
+			assert_eq!(storage(b"foo"), b"bar".to_vec());
+			false
+		}));
+	}
+}