lib.rs 12.2 KB
Newer Older
Gav's avatar
Gav committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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/>.

17
//! The Polkadot runtime. This can be compiled with ``#[no_std]`, ready for Wasm.
Gav's avatar
Gav committed
18
19
20

#![cfg_attr(not(feature = "std"), no_std)]

Gav Wood's avatar
Gav Wood committed
21
22
23
24
25
26
27
#[cfg(feature = "std")]
#[macro_use]
extern crate serde_derive;

#[cfg(feature = "std")]
extern crate serde;

28
29
30
31
#[macro_use]
extern crate substrate_runtime_io as runtime_io;

#[macro_use]
Gav Wood's avatar
Gav Wood committed
32
extern crate substrate_runtime_support;
33
34
35
36

#[macro_use]
extern crate substrate_runtime_primitives as runtime_primitives;

37
#[cfg(test)]
38
39
40
#[macro_use]
extern crate hex_literal;

41
42
43
44
45
#[cfg(test)]
extern crate substrate_serializer;

extern crate substrate_primitives;

Gav Wood's avatar
Gav Wood committed
46
#[macro_use]
47
extern crate substrate_runtime_std as rstd;
Gav Wood's avatar
Gav Wood committed
48
49

extern crate polkadot_primitives as primitives;
Gav's avatar
Gav committed
50
extern crate substrate_codec as codec;
51
52
53
54
55
56
57
58
extern crate substrate_runtime_consensus as consensus;
extern crate substrate_runtime_council as council;
extern crate substrate_runtime_democracy as democracy;
extern crate substrate_runtime_executive as executive;
extern crate substrate_runtime_session as session;
extern crate substrate_runtime_staking as staking;
extern crate substrate_runtime_system as system;
extern crate substrate_runtime_timestamp as timestamp;
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
59
60
#[macro_use]
extern crate substrate_runtime_version as version;
Gav's avatar
Gav committed
61

Gav Wood's avatar
Gav Wood committed
62
63
#[cfg(feature = "std")]
mod checked_block;
64
mod parachains;
Gav Wood's avatar
Gav Wood committed
65
66
67
68
69
70
mod utils;

#[cfg(feature = "std")]
pub use checked_block::CheckedBlock;
pub use utils::{inherent_extrinsics, check_extrinsic};
pub use staking::address::Address as RawAddress;
71

Gav Wood's avatar
Gav Wood committed
72
use primitives::{AccountId, AccountIndex, Balance, BlockNumber, Hash, Index, Log, SessionKey, Signature};
Gav Wood's avatar
Gav Wood committed
73
use runtime_primitives::{generic, traits::{HasPublicAux, BlakeTwo256, Convert}};
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
74
use version::RuntimeVersion;
75
76

#[cfg(feature = "std")]
Gav Wood's avatar
Gav Wood committed
77
pub use runtime_primitives::BuildStorage;
78
79
80
81

pub use consensus::Call as ConsensusCall;
pub use timestamp::Call as TimestampCall;
pub use parachains::Call as ParachainsCall;
Gav Wood's avatar
Gav Wood committed
82
pub use primitives::Header;
83
84
85
86
87

/// The position of the timestamp set extrinsic.
pub const TIMESTAMP_SET_POSITION: u32 = 0;
/// The position of the parachains set extrinsic.
pub const PARACHAINS_SET_POSITION: u32 = 1;
88

Gav Wood's avatar
Gav Wood committed
89
90
/// The address format for describing accounts.
pub type Address = staking::Address<Concrete>;
Gav Wood's avatar
Gav Wood committed
91
92
93
/// Block Id type for this block.
pub type BlockId = generic::BlockId<Block>;
/// Unchecked extrinsic type as expected by this runtime.
Gav Wood's avatar
Gav Wood committed
94
95
96
97
98
pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Index, Call, Signature>;
/// Extrinsic type as expected by this runtime. This is not the type that is signed.
pub type Extrinsic = generic::Extrinsic<Address, Index, Call>;
/// Extrinsic type that is signed.
pub type BareExtrinsic = generic::Extrinsic<AccountId, Index, Call>;
Gav Wood's avatar
Gav Wood committed
99
100
101
/// Block type as expected by this runtime.
pub type Block = generic::Block<Header, UncheckedExtrinsic>;

102
/// Concrete runtime type used to parameterize the various modules.
Gav Wood's avatar
Gav Wood committed
103
104
105
// Workaround for https://github.com/rust-lang/rust/issues/26925 . Remove when sorted.
#[derive(Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
106
pub struct Concrete;
107

Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
108
109
110
111
/// Polkadot runtime version.
pub const VERSION: RuntimeVersion = RuntimeVersion {
	spec_name: ver_str!("polkadot"),
	impl_name: ver_str!("parity-polkadot"),
Gav Wood's avatar
Gav Wood committed
112
	authoring_version: 1,
Gav Wood's avatar
Gav Wood committed
113
	spec_version: 2,
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
114
115
116
117
118
119
120
121
122
123
	impl_version: 0,
};

impl version::Trait for Concrete {
	const VERSION: RuntimeVersion = VERSION;
}

/// Version module for this concrete runtime.
pub type Version = version::Module<Concrete>;

124
125
126
127
128
129
130
131
132
133
134
impl HasPublicAux for Concrete {
	type PublicAux = AccountId;	// TODO: Option<AccountId>
}

impl system::Trait for Concrete {
	type Index = Index;
	type BlockNumber = BlockNumber;
	type Hash = Hash;
	type Hashing = BlakeTwo256;
	type Digest = generic::Digest<Log>;
	type AccountId = AccountId;
Gav Wood's avatar
Gav Wood committed
135
	type Header = Header;
136
137
138
139
140
}
/// System module for this concrete runtime.
pub type System = system::Module<Concrete>;

impl consensus::Trait for Concrete {
141
	type PublicAux = <Concrete as HasPublicAux>::PublicAux;
142
143
144
145
146
147
	type SessionKey = SessionKey;
}
/// Consensus module for this concrete runtime.
pub type Consensus = consensus::Module<Concrete>;

impl timestamp::Trait for Concrete {
148
149
	const TIMESTAMP_SET_POSITION: u32 = TIMESTAMP_SET_POSITION;
	type Moment = u64;
150
151
152
153
}
/// Timestamp module for this concrete runtime.
pub type Timestamp = timestamp::Module<Concrete>;

Gav Wood's avatar
Gav Wood committed
154
155
156
157
/// Session key conversion.
pub struct SessionKeyConversion;
impl Convert<AccountId, SessionKey> for SessionKeyConversion {
	fn convert(a: AccountId) -> SessionKey {
158
		a.0.into()
Gav Wood's avatar
Gav Wood committed
159
160
161
	}
}

162
impl session::Trait for Concrete {
Gav Wood's avatar
Gav Wood committed
163
	type ConvertAccountIdToSessionKey = SessionKeyConversion;
164
	type OnSessionChange = Staking;
165
166
167
168
169
170
}
/// Session module for this concrete runtime.
pub type Session = session::Module<Concrete>;

impl staking::Trait for Concrete {
	type Balance = Balance;
Gav Wood's avatar
Gav Wood committed
171
	type AccountIndex = AccountIndex;
172
	type OnAccountKill = ();
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
}
/// Staking module for this concrete runtime.
pub type Staking = staking::Module<Concrete>;

impl democracy::Trait for Concrete {
	type Proposal = PrivCall;
}
/// Democracy module for this concrete runtime.
pub type Democracy = democracy::Module<Concrete>;

impl council::Trait for Concrete {}
/// Council module for this concrete runtime.
pub type Council = council::Module<Concrete>;
/// Council voting module for this concrete runtime.
pub type CouncilVoting = council::voting::Module<Concrete>;

189
190
191
192
193
impl parachains::Trait for Concrete {
	const SET_POSITION: u32 = PARACHAINS_SET_POSITION;

	type PublicAux = <Concrete as HasPublicAux>::PublicAux;
}
194
195
196
pub type Parachains = parachains::Module<Concrete>;

impl_outer_dispatch! {
Gav Wood's avatar
Gav Wood committed
197
198
199
	/// Call type for polkadot transactions.
	#[derive(Clone, PartialEq, Eq)]
	#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
200
201
202
203
204
205
206
207
	pub enum Call where aux: <Concrete as HasPublicAux>::PublicAux {
		Consensus = 0,
		Session = 1,
		Staking = 2,
		Timestamp = 3,
		Democracy = 5,
		Council = 6,
		CouncilVoting = 7,
208
		Parachains = 8,
209
210
	}

Gav Wood's avatar
Gav Wood committed
211
212
213
	/// Internal calls.
	#[derive(Clone, PartialEq, Eq)]
	#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
214
215
216
217
218
219
220
	pub enum PrivCall {
		Consensus = 0,
		Session = 1,
		Staking = 2,
		Democracy = 5,
		Council = 6,
		CouncilVoting = 7,
221
		Parachains = 8,
222
223
224
225
	}
}

/// Executive: handles dispatch to the various modules.
Gav Wood's avatar
Gav Wood committed
226
pub type Executive = executive::Executive<Concrete, Block, Staking, Staking,
227
	(((((((), Parachains), Council), Democracy), Staking), Session), Timestamp)>;
228
229
230
231
232
233
234
235
236

impl_outer_config! {
	pub struct GenesisConfig for Concrete {
		ConsensusConfig => consensus,
		SystemConfig => system,
		SessionConfig => session,
		StakingConfig => staking,
		DemocracyConfig => democracy,
		CouncilConfig => council,
237
		TimestampConfig => timestamp,
238
239
240
241
242
243
		ParachainsConfig => parachains,
	}
}

pub mod api {
	impl_stubs!(
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
244
		version => |()| super::Version::version(),
245
246
247
248
249
		authorities => |()| super::Consensus::authorities(),
		initialise_block => |header| super::Executive::initialise_block(&header),
		apply_extrinsic => |extrinsic| super::Executive::apply_extrinsic(extrinsic),
		execute_block => |block| super::Executive::execute_block(block),
		finalise_block => |()| super::Executive::finalise_block(),
Gav Wood's avatar
Gav Wood committed
250
		inherent_extrinsics => |(timestamp, heads)| super::inherent_extrinsics(timestamp, heads),
251
252
253
254
		validator_count => |()| super::Session::validator_count(),
		validators => |()| super::Session::validators()
	);
}
255
256

#[cfg(test)]
257
258
259
mod tests {
	use super::*;
	use substrate_primitives as primitives;
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
260
	use codec::{Encode, Decode};
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
	use substrate_primitives::hexdisplay::HexDisplay;
	use substrate_serializer as ser;
	use runtime_primitives::traits::{Digest as DigestT, Header as HeaderT};
	type Digest = generic::Digest<Log>;

	#[test]
	fn test_header_serialization() {
		let header = Header {
			parent_hash: 5.into(),
			number: 67,
			state_root: 3.into(),
			extrinsics_root: 6.into(),
			digest: { let mut d = Digest::default(); d.push(Log(vec![1])); d },
		};

		assert_eq!(ser::to_string_pretty(&header), r#"{
  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000005",
  "number": 67,
  "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000003",
  "extrinsicsRoot": "0x0000000000000000000000000000000000000000000000000000000000000006",
  "digest": {
    "logs": [
      "0x01"
    ]
  }
}"#);

		let v = header.encode();
		assert_eq!(Header::decode(&mut &v[..]).unwrap(), header);
Gav's avatar
Gav committed
290
291
	}

292
293
294
295
296
	#[test]
	fn block_encoding_round_trip() {
		let mut block = Block {
			header: Header::new(1, Default::default(), Default::default(), Default::default(), Default::default()),
			extrinsics: vec![
Gav Wood's avatar
Gav Wood committed
297
298
				UncheckedExtrinsic::new(
					generic::Extrinsic {
299
300
301
302
						function: Call::Timestamp(timestamp::Call::set(100_000_000)),
						signed: Default::default(),
						index: Default::default(),
					},
Gav Wood's avatar
Gav Wood committed
303
304
					Default::default(),
				)
305
306
307
308
309
310
311
312
			],
		};

		let raw = block.encode();
		let decoded = Block::decode(&mut &raw[..]).unwrap();

		assert_eq!(block, decoded);

Gav Wood's avatar
Gav Wood committed
313
314
		block.extrinsics.push(UncheckedExtrinsic::new(
			generic::Extrinsic {
315
316
317
318
				function: Call::Staking(staking::Call::stake()),
				signed: Default::default(),
				index: 10101,
			},
Gav Wood's avatar
Gav Wood committed
319
320
			Default::default(),
		));
321
322
323

		let raw = block.encode();
		let decoded = Block::decode(&mut &raw[..]).unwrap();
Gav's avatar
Gav committed
324

325
		assert_eq!(block, decoded);
Gav's avatar
Gav committed
326
327
	}

328
329
330
331
332
	#[test]
	fn block_encoding_substrate_round_trip() {
		let mut block = Block {
			header: Header::new(1, Default::default(), Default::default(), Default::default(), Default::default()),
			extrinsics: vec![
Gav Wood's avatar
Gav Wood committed
333
334
				UncheckedExtrinsic::new(
					generic::Extrinsic {
335
336
337
338
						function: Call::Timestamp(timestamp::Call::set(100_000_000)),
						signed: Default::default(),
						index: Default::default(),
					},
Gav Wood's avatar
Gav Wood committed
339
340
					Default::default(),
				)
341
342
343
			],
		};

Gav Wood's avatar
Gav Wood committed
344
345
		block.extrinsics.push(UncheckedExtrinsic::new(
			generic::Extrinsic {
346
347
348
349
				function: Call::Staking(staking::Call::stake()),
				signed: Default::default(),
				index: 10101,
			},
Gav Wood's avatar
Gav Wood committed
350
351
			Default::default()
		));
352
353

		let raw = block.encode();
Gav Wood's avatar
Gav Wood committed
354
355
356
		let decoded_primitive = ::primitives::Block::decode(&mut &raw[..]).unwrap();
		let encoded_primitive = decoded_primitive.encode();
		let decoded = Block::decode(&mut &encoded_primitive[..]).unwrap();
357
358
359
360
361
362

		assert_eq!(block, decoded);
	}

	#[test]
	fn serialize_unchecked() {
Gav Wood's avatar
Gav Wood committed
363
364
365
		let tx = UncheckedExtrinsic::new(
			Extrinsic {
				signed: AccountId::from([1; 32]).into(),
366
				index: 999,
367
368
				function: Call::Timestamp(TimestampCall::set(135135)),
			},
Gav Wood's avatar
Gav Wood committed
369
370
371
372
373
374
375
			runtime_primitives::Ed25519Signature(primitives::hash::H512([0; 64])).into()
		);

		// 6f000000
		// ff0101010101010101010101010101010101010101010101010101010101010101
		// e7030000
		// 0300
376
377
378
		// df0f0200
		// 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
379
		let v = Encode::encode(&tx);
Gav Wood's avatar
Gav Wood committed
380
		assert_eq!(&v[..], &hex!["6f000000ff0101010101010101010101010101010101010101010101010101010101010101e70300000300df0f02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"][..]);
381
382
		println!("{}", HexDisplay::from(&v));
		assert_eq!(UncheckedExtrinsic::decode(&mut &v[..]).unwrap(), tx);
Gav's avatar
Gav committed
383
	}
384
385
386
387

	#[test]
	fn serialize_checked() {
		let xt = Extrinsic {
Gav Wood's avatar
Gav Wood committed
388
			signed: AccountId::from(hex!["0d71d1a9cad6f2ab773435a7dec1bac019994d05d1dd5eb3108211dcf25c9d1e"]).into(),
389
			index: 0,
390
391
392
393
394
395
			function: Call::CouncilVoting(council::voting::Call::propose(Box::new(
				PrivCall::Consensus(consensus::PrivCall::set_code(
					vec![]
				))
			))),
		};
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
396
		let v = Encode::encode(&xt);
397
398
		assert_eq!(Extrinsic::decode(&mut &v[..]).unwrap(), xt);
	}
399
400
401
402
403
404

	#[test]
	fn parachain_calls_are_privcall() {
		let _register = PrivCall::Parachains(parachains::PrivCall::register_parachain(0.into(), vec![1, 2, 3], vec![]));
		let _deregister = PrivCall::Parachains(parachains::PrivCall::deregister_parachain(0.into()));
	}
Gav's avatar
Gav committed
405
}