Per-transaction weight for srml

core/consensus/rhd/src/lib.rs

@@ -32,6 +32,9 @@
 
 #![cfg(feature="rhd")]
 // FIXME #1020 doesn't compile
+// NOTE: this is the legacy constant used for transaction size. No longer used except
+// for the rhd code which is not updated. Placed here for compatibility.
+const MAX_TRANSACTIONS_SIZE: u32 = 4 * 1024 * 1024;
 
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};

core/primitives/src/storage.rs

@@ -73,9 +73,6 @@ pub mod well_known_keys {
 	/// Current extrinsic index (u32) is stored under this key.
 	pub const EXTRINSIC_INDEX: &'static [u8] = b":extrinsic_index";
 
-	/// Sum of all lengths of executed extrinsics (u32).
-	pub const ALL_EXTRINSICS_LEN: &'static [u8] = b":all_extrinsics_len";
-
 	/// Changes trie configuration is stored under this key.
 	pub const CHANGES_TRIE_CONFIG: &'static [u8] = b":changes_trie";
 

core/sr-primitives/src/generic/checked_extrinsic.rs

@@ -18,6 +18,7 @@
 //! stage.
 
 use crate::traits::{self, Member, SimpleArithmetic, MaybeDisplay};
+use crate::weights::{WeighableCall, Weight};
 
 /// Definition of something that the external world might want to say; its
 /// existence implies that it has been checked and is good, particularly with
@@ -32,8 +33,7 @@ pub struct CheckedExtrinsic<AccountId, Index, Call> {
 	pub function: Call,
 }
 
-impl<AccountId, Index, Call> traits::Applyable
-	for CheckedExtrinsic<AccountId, Index, Call>
+impl<AccountId, Index, Call> traits::Applyable for CheckedExtrinsic<AccountId, Index, Call>
 where
 	AccountId: Member + MaybeDisplay,
 	Index: Member + MaybeDisplay + SimpleArithmetic,
@@ -55,3 +55,12 @@ where
 		(self.function, self.signed.map(|x| x.0))
 	}
 }
+
+impl<AccountId, Index, Call> WeighableCall for CheckedExtrinsic<AccountId, Index, Call>
+where
+	Call: WeighableCall,
+{
+	fn weight(&self, len: usize) -> Weight {
+		self.function.weight(len)
+	}
+}

core/sr-primitives/src/lib.rs

@@ -38,6 +38,7 @@ use codec::{Encode, Decode};
 #[cfg(feature = "std")]
 pub mod testing;
 
+pub mod weights;
 pub mod traits;
 use traits::{SaturatedConversion, UniqueSaturatedInto};
 

core/sr-primitives/src/testing.rs

@@ -20,6 +20,7 @@ use serde::{Serialize, Serializer, Deserialize, de::Error as DeError, Deserializ
 use std::{fmt::Debug, ops::Deref, fmt};
 use crate::codec::{Codec, Encode, Decode};
 use crate::traits::{self, Checkable, Applyable, BlakeTwo256, Convert};
+use crate::weights::{WeighableCall, Weight};
 use crate::generic::DigestItem as GenDigestItem;
 pub use substrate_primitives::H256;
 use substrate_primitives::U256;
@@ -239,3 +240,8 @@ impl<Call> Applyable for TestXt<Call> where
 		(self.2, self.0)
 	}
 }
+impl<Call> WeighableCall for TestXt<Call> {
+	fn weight(&self, len: usize) -> Weight {
+		len as Weight
+	}
+}

core/sr-primitives/src/weights.rs

@@ -0,0 +1,85 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Primitives for transaction weighting.
+//!
+//! Each dispatch function withing `decl_module!` can now have an optional
+//! `#[weight = $x]` attribute. $x can be any object that implements the
+//! [`WeighableTransaction`] trait. By default, All transactions are annotated by
+//! `#[weight = TransactionWeight::default()]`.
+//!
+//! Note that the decl_module macro _cannot_ enforce this and will simply fail
+//! if an invalid struct is passed in.
+//!
+//! Note that [`WeighableCall`] and [`WeighableTransaction`] are more or less similar.
+//! The distinction is because one serves to pass the weight from the the
+//! dispatchable function's attribute to the call enum ([`WeighableTransaction`]) and the
+//! other to pass the final weight from call enum to the executive module
+//! ([`WeighableCall`]).
+
+/// The final type that each `#[weight = $x:expr]`'s
+/// expression must evaluate to.
+pub type Weight = u32;
+
+/// A `Call` enum that can be weighted using the custom weight attribute of the
+/// its dispatchable functions. Is implemented by default in the `decl_module!`.
+pub trait WeighableCall {
+	/// Return the weight of this call.
+	fn weight(&self, len: usize) -> Weight;
+}
+
+/// a _dispatchable_ function (anything inside `decl_module! {}`) that can be weighted.
+/// A type implementing this trait can _optionally_ be passed to the as
+/// `#[weight = X]`. Otherwise, default implementation will be used.
+pub trait WeighableTransaction {
+	/// Consume self and return the final weight of the call given the length
+	/// of the extrinsic.
+	fn calculate_weight(self, len: usize) -> Weight;
+}
+
+/// Default weight wrapper.
+/// This is tailored for the Polkadot use case. Users may replace it with anything.
+pub enum TransactionWeight {
+	/// basic weight (base, byte).
+	/// The values contained are the base weight and byte weight respectively.
+	Basic(Weight, Weight),
+	/// Maximum fee. This implies that this transaction _might_ get included but
+	/// no more transaction can be added. This can be done by setting the
+	/// implementation to _maximum block weight_.
+	Max,
+	/// Free. The transaction does not increase the total weight
+	/// (i.e. is not included in weight calculation).
+	Free,
+}
+
+impl WeighableTransaction for TransactionWeight {
+	fn calculate_weight(self, len: usize) -> Weight {
+		match self {
+			TransactionWeight::Basic(base, byte) => base + byte * len as Weight,
+			TransactionWeight::Max => 3 * 1024 * 1024,
+			TransactionWeight::Free => 0,
+		}
+	}
+}
+
+impl Default for TransactionWeight {
+	fn default() -> Self {
+		// This implies that the weight is currently equal to tx-size, nothing more
+		// for all substrate transactions that do NOT explicitly annotate weight.
+		// TODO #2431 needs to be updated with proper max values.
+		TransactionWeight::Basic(0, 1)
+	}
+}

core/state-machine/src/lib.rs

@@ -1062,7 +1062,6 @@ mod tests {
 		).execute_using_consensus_failure_handler::<_, NeverNativeValue, fn() -> _>(
 			ExecutionManager::Both(|we, _ne| {
 				consensus_failed = true;
-				println!("HELLO!");
 				we
 			}),
 			true,

node/runtime/src/lib.rs

@@ -59,7 +59,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	impl_name: create_runtime_str!("substrate-node"),
 	authoring_version: 10,
 	spec_version: 92,
-	impl_version: 92,
+	impl_version: 93,
 	apis: RUNTIME_API_VERSIONS,
 };
 

srml/democracy/src/lib.rs

@@ -15,7 +15,7 @@
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Democratic system: Handles administration of general stakeholder voting.
-
+#![recursion_limit="128"]
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use rstd::prelude::*;

srml/example/Cargo.toml

@@ -10,11 +10,11 @@ parity-codec = { version = "3.3", default-features = false }
 srml-support = { path = "../support", default-features = false }
 system = { package = "srml-system", path = "../system", default-features = false }
 balances = { package = "srml-balances", path = "../balances", default-features = false }
+sr-primitives = { path = "../../core/sr-primitives", default-features = false }
 
 [dev-dependencies]
 sr-io = { path = "../../core/sr-io" }
 substrate-primitives = { path = "../../core/primitives" }
-sr-primitives = { path = "../../core/sr-primitives" }
 
 [features]
 default = ["std"]

srml/example/src/lib.rs

@@ -16,7 +16,7 @@
 
 //! # Example Module
 //!
-//! <!-- Original author of paragraph: @gavofyork --> 
+//! <!-- Original author of paragraph: @gavofyork -->
 //! The Example: A simple example of a runtime module demonstrating
 //! concepts, APIs and structures common to most runtime modules.
 //!
@@ -64,7 +64,7 @@
 //!
 //! \## Overview
 //!
-//! <!-- Original author of paragraph: Various. See https://github.com/paritytech/substrate-developer-hub/issues/44 --> 
+//! <!-- Original author of paragraph: Various. See https://github.com/paritytech/substrate-developer-hub/issues/44 -->
 //! // Short description of module purpose.
 //! // Links to Traits that should be implemented.
 //! // What this module is for.
@@ -205,7 +205,7 @@
 //!
 //! \```rust
 //! use <INSERT_CUSTOM_MODULE_NAME>;
-//! 
+//!
 //! pub trait Trait: <INSERT_CUSTOM_MODULE_NAME>::Trait { }
 //! \```
 //!
@@ -251,6 +251,7 @@
 
 use srml_support::{StorageValue, dispatch::Result, decl_module, decl_storage, decl_event};
 use system::ensure_signed;
+use sr_primitives::weights::TransactionWeight;
 
 /// Our module's configuration trait. All our types and consts go in here. If the
 /// module is dependent on specific other modules, then their configuration traits
@@ -388,6 +389,19 @@ decl_module! {
 		// no progress.
 		//
 		// If you don't respect these rules, it is likely that your chain will be attackable.
+		//
+		// Each transaction can optionally indicate a weight. The weight is passed in as a
+		// custom attribute and the value can be anything that implements the `WeighableTransaction`
+		// trait. Most often using substrate's default `TransactionWeight` is enough for you. A basic
+		// weight is a tuple of `(base_weight, byte_weight)`. Upon including each transaction in a block,
+		// the final weight is calculated as `base_weight + byte_weight * tx_size`. If this value,
+		// added to the weight of all included transactions, exceeds `MAX_TRANSACTION_WEIGHT`,
+		// the transaction is not included. If no weight attribute is provided, the `::default()`
+		// implementation of `TransactionWeight()` is used.
+		//
+		// The example below showcases a transaction which is relatively costly, but less dependent on
+		// the input, hence byte_weight is configured smaller.
+		#[weight = TransactionWeight::Basic(10_000, 100)]
 		fn accumulate_dummy(origin, increase_by: T::Balance) -> Result {
 			// This is a public call, so we ensure that the origin is some signed account.
 			let _sender = ensure_signed(origin)?;