Minimal parachain framework part 1 (#113)

* dynamic inclusion threshold calculator * collators interface * collation helpers * initial proposal-creation future * create proposer when asked to propose * remove local_availability duty * statement table tracks includable parachain count * beginnings of timing future * finish proposal logic * remove stray println * extract shared table to separate module * change ordering * includability tracking * fix doc * initial changes to parachains module * initialise dummy block before API calls * give polkadot control over round proposer based on random seed * propose only after enough candidates * flesh out parachains module a bit more * set_heads * actually introduce set_heads to runtime * update block_builder to accept parachains * split block validity errors from real errors in evaluation * update WASM runtimes * polkadot-api methods for parachains additions * delay evaluation until candidates are ready * comments * fix dynamic inclusion with zero initial * test for includability tracker * wasm validation of parachain candidates * move primitives to primitives crate * remove runtime-std dependency from codec * adjust doc * polkadot-parachain-primitives * kill legacy polkadot-validator crate * basic-add test chain * test for basic_add parachain * move to test-chains dir * use wasm-build * new wasm directory layout * reorganize a bit more * Fix for rh-minimal-parachain (#141) * Remove extern "C" We already encountered such behavior (bug?) in pwasm-std, I believe. * Fix `panic_fmt` signature by adding `_col` Wrong `panic_fmt` signature can inhibit some optimizations in LTO mode. * Add linker flags and use wasm-gc in build script Pass --import-memory to LLD to emit wasm binary with imported memory. Also use wasm-gc instead of wasm-build. * Fix effective_max. I'm not sure why it was the way it was actually. * Recompile wasm. * Fix indent * more basic_add tests * validate parachain WASM * produce statements on receiving statements * tests for reactive statement production * fix build * add OOM lang item to runtime-io * use dynamic_inclusion when evaluating as well * fix update_includable_count * remove dead code * grumbles * actually defer round_proposer logic * update wasm * address a few more grumbles * grumbles * update WASM checkins * remove dependency on tokio-timer
2026-05-30 22:11:02 +00:00 · 2018-05-25 16:16:01 +02:00
parent 59e8adb604
commit c473c0c734
41 changed files with 2769 additions and 872 deletions
@@ -0,0 +1,143 @@
+// 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/>.
+
+//! Basic parachain that adds a number as part of its state.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(alloc, core_intrinsics, global_allocator, lang_items))]
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+extern crate polkadot_parachain as parachain;
+extern crate wee_alloc;
+extern crate tiny_keccak;
+extern crate pwasm_libc;
+
+use parachain::codec::{Slicable, Input};
+
+#[cfg(not(feature = "std"))]
+mod wasm;
+
+#[cfg(not(feature = "std"))]
+pub use wasm::*;
+
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+
+// Define global allocator.
+#[cfg(not(feature = "std"))]
+#[global_allocator]
+static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+
+// Head data for this parachain.
+#[derive(Default, Clone)]
+struct HeadData {
+	// Block number
+	number: u64,
+	// parent block keccak256
+	parent_hash: [u8; 32],
+	// hash of post-execution state.
+	post_state: [u8; 32],
+}
+
+impl Slicable for HeadData {
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.number.using_encoded(|s| v.extend(s));
+		self.parent_hash.using_encoded(|s| v.extend(s));
+		self.post_state.using_encoded(|s| v.extend(s));
+
+		v
+	}
+
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(HeadData {
+			number: Slicable::decode(input)?,
+			parent_hash: Slicable::decode(input)?,
+			post_state: Slicable::decode(input)?,
+		})
+	}
+}
+
+// Block data for this parachain.
+#[derive(Default, Clone)]
+struct BlockData {
+	// State to begin from.
+	state: u64,
+	// Amount to add (overflowing)
+	add: u64,
+}
+
+impl Slicable for BlockData {
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.state.using_encoded(|s| v.extend(s));
+		self.add.using_encoded(|s| v.extend(s));
+
+		v
+	}
+
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(BlockData {
+			state: Slicable::decode(input)?,
+			add: Slicable::decode(input)?,
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use parachain::ValidationParams;
+
+	const TEST_CODE: &[u8] = include_bytes!("../wasm/test.wasm");
+
+	fn hash_state(state: u64) -> [u8; 32] {
+		::tiny_keccak::keccak256(state.encode().as_slice())
+	}
+
+	fn hash_head(head: &HeadData) -> [u8; 32] {
+		::tiny_keccak::keccak256(head.encode().as_slice())
+	}
+
+	#[test]
+	fn execute_good_on_parent() {
+		let parent_head = HeadData {
+			number: 0,
+			parent_hash: [0; 32],
+			post_state: hash_state(0),
+		};
+
+		let block_data = BlockData {
+			state: 0,
+			add: 512,
+		};
+
+		let ret = parachain::wasm::validate_candidate(TEST_CODE, ValidationParams {
+			parent_head: parent_head.encode(),
+			block_data: block_data.encode(),
+		}).unwrap();
+
+		let new_head = HeadData::decode(&mut &ret.head_data[..]).unwrap();
+
+		assert_eq!(new_head.number, 1);
+		assert_eq!(new_head.parent_hash, hash_head(&parent_head));
+		assert_eq!(new_head.post_state, hash_state(512));
+	}
+}
@@ -0,0 +1 @@
+src
@@ -0,0 +1,58 @@
+// 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/>.
+
+//! Defines WASM module logic.
+
+use parachain::{self, ValidationResult};
+use parachain::codec::Slicable;
+use super::{HeadData, BlockData};
+
+#[lang = "panic_fmt"]
+#[no_mangle]
+pub extern fn panic_fmt(
+	_args: ::core::fmt::Arguments,
+	_file: &'static str,
+	_line: u32,
+	_col: u32,
+) -> ! {
+	use core::intrinsics;
+	unsafe {
+		intrinsics::abort();
+	}
+}
+
+#[no_mangle]
+pub extern fn validate(offset: usize, len: usize) -> usize {
+	let hash_state = |state: u64| ::tiny_keccak::keccak256(state.encode().as_slice());
+
+	let params = unsafe { ::parachain::load_params(offset, len) };
+	let parent_head = HeadData::decode(&mut &params.parent_head[..])
+		.expect("invalid parent head format.");
+
+	let block_data = BlockData::decode(&mut &params.block_data[..])
+		.expect("invalid block data format.");
+
+	assert_eq!(hash_state(block_data.state), parent_head.post_state, "wrong post-state proof");
+	let new_state = block_data.state.saturating_add(block_data.add);
+
+	let new_head = HeadData {
+		number: parent_head.number + 1,
+		parent_hash: ::tiny_keccak::keccak256(&params.parent_head[..]),
+		post_state: hash_state(new_state),
+	};
+
+	parachain::write_result(ValidationResult { head_data: new_head.encode() })
+}