lib.rs 14.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

#![cfg_attr(not(feature = "std"), no_std)]
20
21
// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.
#![recursion_limit="256"]
Gav Wood's avatar
Gav Wood committed
22

23
#[macro_use]
24
25
extern crate parity_codec_derive;
extern crate parity_codec as codec;
26

27
extern crate substrate_primitives;
28
#[macro_use]
29
extern crate substrate_client as client;
30

31
#[macro_use]
32
extern crate sr_std as rstd;
33
#[cfg(test)]
34
extern crate sr_io;
Gav Wood's avatar
Gav Wood committed
35
#[macro_use]
36
extern crate sr_version as version;
Gav's avatar
Gav committed
37
#[macro_use]
38
extern crate sr_primitives;
Gav Wood's avatar
Gav Wood committed
39

40
41
#[macro_use]
extern crate srml_support;
42
43
44
45
46
47
48
49
50
51
extern crate srml_balances as balances;
extern crate srml_consensus as consensus;
extern crate srml_council as council;
extern crate srml_democracy as democracy;
extern crate srml_executive as executive;
extern crate srml_session as session;
extern crate srml_staking as staking;
extern crate srml_system as system;
extern crate srml_timestamp as timestamp;
extern crate srml_treasury as treasury;
Gav's avatar
Gav committed
52

53
54
extern crate polkadot_primitives as primitives;

55
mod parachains;
Gav Wood's avatar
Gav Wood committed
56
57

#[cfg(feature = "std")]
58
use codec::{Encode, Decode};
59
60
use rstd::prelude::*;
use substrate_primitives::u32_trait::{_2, _4};
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
use primitives::{
	AccountId, AccountIndex, Balance, BlockNumber, Hash, Index, SessionKey, Signature,
	parachain, parachain::runtime::ParachainHost, parachain::id::PARACHAIN_HOST,
};
#[cfg(feature = "std")]
use primitives::Block as GBlock;
use client::{block_builder::api::runtime::*, runtime_api::{runtime::*, id::*}};
#[cfg(feature = "std")]
use client::runtime_api::ApiExt;
use sr_primitives::ApplyResult;
use sr_primitives::transaction_validity::TransactionValidity;
use sr_primitives::generic;
use sr_primitives::traits::{Convert, BlakeTwo256, Block as BlockT};
#[cfg(feature = "std")]
use sr_primitives::traits::ApiRef;
#[cfg(feature = "std")]
use substrate_primitives::AuthorityId;
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
78
use version::RuntimeVersion;
79
use council::{motions as council_motions, voting as council_voting};
80
#[cfg(feature = "std")]
81
82
83
84
use council::seats as council_seats;
#[cfg(any(feature = "std", test))]
use version::NativeVersion;
use substrate_primitives::OpaqueMetadata;
85

86
87
#[cfg(any(feature = "std", test))]
pub use sr_primitives::BuildStorage;
88
89
pub use consensus::Call as ConsensusCall;
pub use timestamp::Call as TimestampCall;
90
pub use balances::Call as BalancesCall;
91
pub use parachains::Call as ParachainsCall;
92
93
94
pub use sr_primitives::{Permill, Perbill};
pub use timestamp::BlockPeriod;
pub use srml_support::{StorageValue, RuntimeMetadata};
95

96
97
98
const TIMESTAMP_SET_POSITION: u32 = 0;
const NOTE_OFFLINE_POSITION: u32 = 1;
const PARACHAINS_SET_POSITION: u32 = 2;
99

100
/// Runtime version.
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
101
102
103
pub const VERSION: RuntimeVersion = RuntimeVersion {
	spec_name: ver_str!("polkadot"),
	impl_name: ver_str!("parity-polkadot"),
Gav Wood's avatar
Gav Wood committed
104
	authoring_version: 1,
105
	spec_version: 101,
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
106
	impl_version: 0,
107
108
109
110
111
112
	apis: apis_vec!([
		(BLOCK_BUILDER, 1),
		(TAGGED_TRANSACTION_QUEUE, 1),
		(METADATA, 1),
		(PARACHAIN_HOST, 1),
	]),
Arkadiy Paronyan's avatar
Arkadiy Paronyan committed
113
114
};

115
116
117
118
119
120
121
122
123
/// Native version.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
	NativeVersion {
		runtime_version: VERSION,
		can_author_with: Default::default(),
	}
}

124
125
impl system::Trait for Runtime {
	type Origin = Origin;
126
127
128
129
130
131
	type Index = Index;
	type BlockNumber = BlockNumber;
	type Hash = Hash;
	type Hashing = BlakeTwo256;
	type Digest = generic::Digest<Log>;
	type AccountId = AccountId;
132
	type Header = generic::Header<BlockNumber, BlakeTwo256, Log>;
Gav's avatar
Gav committed
133
	type Event = Event;
134
	type Log = Log;
135
136
}

137
impl balances::Trait for Runtime {
Gav's avatar
Gav committed
138
139
140
	type Balance = Balance;
	type AccountIndex = AccountIndex;
	type OnFreeBalanceZero = Staking;
Gav's avatar
Fix    
Gav committed
141
	type EnsureAccountLiquid = Staking;
Gav's avatar
Gav committed
142
143
144
	type Event = Event;
}

145
impl consensus::Trait for Runtime {
Gav's avatar
Gav committed
146
	const NOTE_OFFLINE_POSITION: u32 = NOTE_OFFLINE_POSITION;
147
	type Log = Log;
148
	type SessionKey = SessionKey;
Gav's avatar
Gav committed
149
	type OnOfflineValidator = Staking;
150
151
}

152
impl timestamp::Trait for Runtime {
153
154
	const TIMESTAMP_SET_POSITION: u32 = TIMESTAMP_SET_POSITION;
	type Moment = u64;
155
156
}

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

165
impl session::Trait for Runtime {
Gav Wood's avatar
Gav Wood committed
166
	type ConvertAccountIdToSessionKey = SessionKeyConversion;
167
	type OnSessionChange = Staking;
Gav's avatar
Gav committed
168
	type Event = Event;
169
170
}

171
172
impl staking::Trait for Runtime {
	type OnRewardMinted = Treasury;
Gav's avatar
Gav committed
173
	type Event = Event;
174
175
}

176
177
178
impl democracy::Trait for Runtime {
	type Proposal = Call;
	type Event = Event;
179
}
180
181
182
183

impl council::Trait for Runtime {
	type Event = Event;
}
184

185
186
187
188
189
190
191
192
193
194
195
196
197
198
impl council::voting::Trait for Runtime {
	type Event = Event;
}

impl council::motions::Trait for Runtime {
	type Origin = Origin;
	type Proposal = Call;
	type Event = Event;
}

impl treasury::Trait for Runtime {
	type ApproveOrigin = council_motions::EnsureMembers<_4>;
	type RejectOrigin = council_motions::EnsureMembers<_2>;
	type Event = Event;
199
}
200
201
202
203

impl parachains::Trait for Runtime {
	const SET_POSITION: u32 = PARACHAINS_SET_POSITION;
}
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

construct_runtime!(
	pub enum Runtime with Log(InternalLog: DigestItem<Hash, SessionKey>) where
		Block = Block,
		UncheckedExtrinsic = UncheckedExtrinsic
	{
		System: system::{default, Log(ChangesTrieRoot)},
		Timestamp: timestamp::{Module, Call, Storage, Config<T>, Inherent},
		Consensus: consensus::{Module, Call, Storage, Config<T>, Log(AuthoritiesChange), Inherent},
		Balances: balances,
		Session: session,
		Staking: staking,
		Democracy: democracy,
		Council: council::{Module, Call, Storage, Event<T>},
		CouncilVoting: council_voting,
		CouncilMotions: council_motions::{Module, Call, Storage, Event<T>, Origin},
		CouncilSeats: council_seats::{Config<T>},
		Treasury: treasury,
		Parachains: parachains::{Module, Call, Storage, Config<T>, Inherent},
Gav's avatar
Gav committed
223
	}
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
);

/// The address format for describing accounts.
pub use balances::address::Address as RawAddress;
/// The address format for describing accounts.
pub type Address = balances::Address<Runtime>;
/// Block header type as expected by this runtime.
pub type Header = generic::Header<BlockNumber, BlakeTwo256, Log>;
/// Block type as expected by this runtime.
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
/// A Block signed with a Justification
pub type SignedBlock = generic::SignedBlock<Block>;
/// BlockId type as expected by this runtime.
pub type BlockId = generic::BlockId<Block>;
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic = generic::UncheckedMortalExtrinsic<Address, Index, Call, Signature>;
/// Extrinsic type that has already been checked.
pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Index, Call>;
/// Executive: handles dispatch to the various modules.
pub type Executive = executive::Executive<Runtime, Block, balances::ChainContext<Runtime>, Balances, AllModules>;

#[cfg(feature = "std")]
pub struct ClientWithApi {
	call: ::std::ptr::NonNull<client::runtime_api::CallApiAt<GBlock>>,
	commit_on_success: ::std::cell::RefCell<bool>,
	initialised_block: ::std::cell::RefCell<Option<GBlockId>>,
	changes: ::std::cell::RefCell<client::runtime_api::OverlayedChanges>,
Gav's avatar
Gav committed
251
252
}

253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
#[cfg(feature = "std")]
unsafe impl Send for ClientWithApi {}
#[cfg(feature = "std")]
unsafe impl Sync for ClientWithApi {}

#[cfg(feature = "std")]
impl ApiExt for ClientWithApi {
	fn map_api_result<F: FnOnce(&Self) -> Result<R, E>, R, E>(&self, map_call: F) -> Result<R, E> {
		*self.commit_on_success.borrow_mut() = false;
		let res = map_call(self);
		*self.commit_on_success.borrow_mut() = true;

		self.commit_on_ok(&res);

		res
268
	}
269
}
270

271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
#[cfg(feature = "std")]
impl client::runtime_api::ConstructRuntimeApi<GBlock> for ClientWithApi {
	fn construct_runtime_api<'a, T: client::runtime_api::CallApiAt<GBlock>>(call: &'a T) -> ApiRef<'a, Self> {
		ClientWithApi {
			call: unsafe {
				::std::ptr::NonNull::new_unchecked(
					::std::mem::transmute(
						call as &client::runtime_api::CallApiAt<GBlock>
					)
				)
			},
			commit_on_success: true.into(),
			initialised_block: None.into(),
			changes: Default::default(),
		}.into()
286
287
288
	}
}

289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
#[cfg(feature = "std")]
impl ClientWithApi {
	fn call_api_at<A: Encode, R: Decode>(
		&self,
		at: &GBlockId,
		function: &'static str,
		args: &A
	) -> client::error::Result<R> {
		let res = unsafe {
			self.call.as_ref().call_api_at(
				at,
				function,
				args.encode(),
				&mut *self.changes.borrow_mut(),
				&mut *self.initialised_block.borrow_mut()
			).and_then(|r|
				R::decode(&mut &r[..])
					.ok_or_else(||
						client::error::ErrorKind::CallResultDecode(function).into()
					)
			)
		};

		self.commit_on_ok(&res);
		res
314
	}
315

316
317
318
319
320
321
322
323
	fn commit_on_ok<R, E>(&self, res: &Result<R, E>) {
		if *self.commit_on_success.borrow() {
			if res.is_err() {
				self.changes.borrow_mut().discard_prospective();
			} else {
				self.changes.borrow_mut().commit_prospective();
			}
		}
324
325
326
	}
}

327
328
#[cfg(feature = "std")]
type GBlockId = generic::BlockId<GBlock>;
329

330
331
332
333
334
#[cfg(feature = "std")]
impl client::runtime_api::Core<GBlock> for ClientWithApi {
	fn version(&self, at: &GBlockId) -> Result<RuntimeVersion, client::error::Error> {
		self.call_api_at(at, "version", &())
	}
335

336
337
338
	fn authorities(&self, at: &GBlockId) -> Result<Vec<AuthorityId>, client::error::Error> {
		self.call_api_at(at, "authorities", &())
	}
339

340
341
	fn execute_block(&self, at: &GBlockId, block: &GBlock) -> Result<(), client::error::Error> {
		self.call_api_at(at, "execute_block", block)
342
343
	}

344
345
346
	fn initialise_block(&self, at: &GBlockId, header: &<GBlock as BlockT>::Header) -> Result<(), client::error::Error> {
		self.call_api_at(at, "initialise_block", header)
	}
347
}
348

349
350
351
352
353
#[cfg(feature = "std")]
impl client::block_builder::api::BlockBuilder<GBlock> for ClientWithApi {
	fn apply_extrinsic(&self, at: &GBlockId, extrinsic: &<GBlock as BlockT>::Extrinsic) -> Result<ApplyResult, client::error::Error> {
		self.call_api_at(at, "apply_extrinsic", extrinsic)
	}
354

355
356
357
	fn finalise_block(&self, at: &GBlockId) -> Result<<GBlock as BlockT>::Header, client::error::Error> {
		self.call_api_at(at, "finalise_block", &())
	}
358

359
360
361
362
	fn inherent_extrinsics<Inherent: Decode + Encode, Unchecked: Decode + Encode>(
		&self, at: &GBlockId, inherent: &Inherent
	) -> Result<Vec<Unchecked>, client::error::Error> {
		self.call_api_at(at, "inherent_extrinsics", inherent)
Gav's avatar
Gav committed
363
364
	}

365
366
367
	fn check_inherents<Inherent: Decode + Encode, Error: Decode + Encode>(&self, at: &GBlockId, block: &GBlock, inherent: &Inherent) -> Result<Result<(), Error>, client::error::Error> {
		self.call_api_at(at, "check_inherents", &(block, inherent))
	}
368

369
370
371
372
	fn random_seed(&self, at: &GBlockId) -> Result<<GBlock as BlockT>::Hash, client::error::Error> {
		self.call_api_at(at, "random_seed", &())
	}
}
373

374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
#[cfg(feature = "std")]
impl client::runtime_api::TaggedTransactionQueue<GBlock> for ClientWithApi {
	fn validate_transaction(
		&self,
		at: &GBlockId,
		utx: &<GBlock as BlockT>::Extrinsic
	) -> Result<TransactionValidity, client::error::Error> {
		self.call_api_at(at, "validate_transaction", utx)
	}
}

#[cfg(feature = "std")]
impl client::runtime_api::Metadata<GBlock> for ClientWithApi {
	fn metadata(&self, at: &GBlockId) -> Result<OpaqueMetadata, client::error::Error> {
		self.call_api_at(at, "metadata", &())
	}
}

#[cfg(feature = "std")]
impl ::primitives::parachain::ParachainHost<GBlock> for ClientWithApi {
	fn validators(&self, at: &GBlockId) -> Result<Vec<primitives::AccountId>, client::error::Error> {
		self.call_api_at(at, "validators", &())
	}
	fn duty_roster(&self, at: &GBlockId) -> Result<primitives::parachain::DutyRoster, client::error::Error> {
		self.call_api_at(at, "calculate_duty_roster", &())
	}
	fn active_parachains(&self, at: &GBlockId) -> Result<Vec<parachain::Id>, client::error::Error> {
		self.call_api_at(at, "active_parachains", &())
	}
	fn parachain_head(&self, at: &GBlockId, id: &parachain::Id) -> Result<Option<Vec<u8>>, client::error::Error> {
		self.call_api_at(at, "parachain_head", &id)
	}
	fn parachain_code(&self, at: &GBlockId, id: &parachain::Id) -> Result<Option<Vec<u8>>, client::error::Error> {
		self.call_api_at(at, "parachain_code", &id)
	}
}
410

411
412
413
414
415
416
417
418
419
420
421
422
423
impl_runtime_apis! {
	impl Core<Block> for Runtime {
		fn version() -> RuntimeVersion {
			VERSION
		}

		fn authorities() -> Vec<SessionKey> {
			Consensus::authorities()
		}

		fn execute_block(block: Block) {
			Executive::execute_block(block)
		}
424

425
426
427
428
		fn initialise_block(header: <Block as BlockT>::Header) {
			Executive::initialise_block(&header)
		}
	}
Gav's avatar
Gav committed
429

430
431
432
433
	impl Metadata for Runtime {
		fn metadata() -> OpaqueMetadata {
			Runtime::metadata().into()
		}
Gav's avatar
Gav committed
434
435
	}

436
437
438
439
440
441
442
443
	impl BlockBuilder<Block, InherentData, UncheckedExtrinsic, InherentData, InherentError> for Runtime {
		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyResult {
			Executive::apply_extrinsic(extrinsic)
		}

		fn finalise_block() -> <Block as BlockT>::Header {
			Executive::finalise_block()
		}
444

445
446
447
		fn inherent_extrinsics(data: InherentData) -> Vec<UncheckedExtrinsic> {
			data.create_inherent_extrinsics()
		}
448

449
450
451
		fn check_inherents(block: Block, data: InherentData) -> Result<(), InherentError> {
			data.check_inherents(block)
		}
452

453
454
455
		fn random_seed() -> <Block as BlockT>::Hash {
			System::random_seed()
		}
456
457
	}

458
459
460
461
	impl TaggedTransactionQueue<Block> for Runtime {
		fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity {
			Executive::validate_transaction(tx)
		}
Gav's avatar
Gav committed
462
	}
463

464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
	impl ParachainHost for Runtime {
		fn validators() -> Vec<AccountId> {
			Session::validators()
		}
		fn duty_roster() -> parachain::DutyRoster {
			Parachains::calculate_duty_roster()
		}
		fn active_parachains() -> Vec<parachain::Id> {
			Parachains::active_parachains()
		}
		fn parachain_head(id: parachain::Id) -> Option<Vec<u8>> {
			Parachains::parachain_head(&id)
		}
		fn parachain_code(id: parachain::Id) -> Option<Vec<u8>> {
			Parachains::parachain_code(&id)
		}
480
	}
Gav's avatar
Gav committed
481
}
482