Turn storage items into parameters (#2883)

* balances: Turn storage items into parameters.

* contract: Turn storage items into parameters.

* council: Turn storage items into parameters.

* finality-tracker: Turn storage items into parameters.

* treasury: Turn storage items into parameters.

* democracy: Fix tests.

* example: Fix tests.

* executive: Fix tests.

* staking: Fix tests.

* Update runtime.

* Update template-node.

* Update runtime version.

* Fix executor tests.

* Fix node cli tests.

* Address grumbles.

* Add removed default values to docs.

* Make gas price a storage item.

* Set associated consts must be callable outside of build.

* Fix not enough gas to pay for transfer fee.

* Fix build.

* Emit metadata.

* Fix build.

* Add default values for all parameter types.

* Fix build.

* Fix build.

* Fix build.

* Fix build.

substrate/srml/contracts/src/account_db.rs

@@ -17,7 +17,7 @@
 //! Auxilliaries to help with managing partial changes to accounts state.
 
 use super::{
-	AliveContractInfo, BalanceOf, CodeHash, ContractInfo, ContractInfoOf, Module, Trait, TrieId,
+	AliveContractInfo, BalanceOf, CodeHash, ContractInfo, ContractInfoOf, Trait, TrieId,
 	TrieIdGenerator,
 };
 use crate::exec::StorageKey;
@@ -26,7 +26,7 @@ use rstd::collections::btree_map::{BTreeMap, Entry};
 use rstd::prelude::*;
 use runtime_io::blake2_256;
 use runtime_primitives::traits::{Bounded, Zero};
-use srml_support::traits::{Currency, Imbalance, SignedImbalance, UpdateBalanceOutcome};
+use srml_support::traits::{Currency, Get, Imbalance, SignedImbalance, UpdateBalanceOutcome};
 use srml_support::{storage::child, StorageMap};
 use system;
 
@@ -125,7 +125,7 @@ impl<T: Trait> AccountDb<T> for DirectAccountDb {
 				} else if let Some(code_hash) = changed.code_hash {
 					AliveContractInfo::<T> {
 						code_hash,
-						storage_size: <Module<T>>::storage_size_offset(),
+						storage_size: T::StorageSizeOffset::get(),
 						trie_id: <T as Trait>::TrieIdGenerator::trie_id(&address),
 						deduct_block: <system::Module<T>>::block_number(),
 						rent_allowance: <BalanceOf<T>>::max_value(),

substrate/srml/contracts/src/gas.rs

@@ -18,7 +18,8 @@ use crate::{GasSpent, Module, Trait, BalanceOf, NegativeImbalanceOf};
 use rstd::convert::TryFrom;
 use runtime_primitives::BLOCK_FULL;
 use runtime_primitives::traits::{CheckedMul, Zero, SaturatedConversion, SimpleArithmetic, UniqueSaturatedInto};
-use srml_support::{StorageValue, traits::{OnUnbalanced, ExistenceRequirement, WithdrawReason, Currency, Imbalance}};
+use srml_support::StorageValue;
+use srml_support::traits::{Currency, ExistenceRequirement, Get, Imbalance, OnUnbalanced, WithdrawReason};
 
 #[cfg(test)]
 use std::{any::Any, fmt::Debug};
@@ -200,8 +201,8 @@ pub fn buy_gas<T: Trait>(
 	gas_limit: Gas,
 ) -> Result<(GasMeter<T>, NegativeImbalanceOf<T>), &'static str> {
 	// Check if the specified amount of gas is available in the current block.
-	// This cannot underflow since `gas_spent` is never greater than `block_gas_limit`.
-	let gas_available = <Module<T>>::block_gas_limit() - <Module<T>>::gas_spent();
+	// This cannot underflow since `gas_spent` is never greater than `T::BlockGasLimit`.
+	let gas_available = T::BlockGasLimit::get() - <Module<T>>::gas_spent();
 	if gas_limit > gas_available {
 		// gas limit reached, revert the transaction and retry again in the future
 		return Err(BLOCK_FULL);

substrate/srml/contracts/src/lib.rs

@@ -90,7 +90,7 @@ mod tests;
 
 use crate::exec::ExecutionContext;
 use crate::account_db::{AccountDb, DirectAccountDb};
-use crate::gas::Gas;
+pub use crate::gas::Gas;
 
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
@@ -105,7 +105,7 @@ use srml_support::dispatch::{Result, Dispatchable};
 use srml_support::{
 	Parameter, StorageMap, StorageValue, decl_module, decl_event, decl_storage, storage::child
 };
-use srml_support::traits::{OnFreeBalanceZero, OnUnbalanced, Currency};
+use srml_support::traits::{OnFreeBalanceZero, OnUnbalanced, Currency, Get};
 use system::{ensure_signed, RawOrigin};
 use substrate_primitives::storage::well_known_keys::CHILD_STORAGE_KEY_PREFIX;
 use timestamp;
@@ -279,6 +279,22 @@ pub type BalanceOf<T> = <<T as Trait>::Currency as Currency<<T as system::Trait>
 pub type NegativeImbalanceOf<T> =
 	<<T as Trait>::Currency as Currency<<T as system::Trait>::AccountId>>::NegativeImbalance;
 
+pub const DEFAULT_SIGNED_CLAIM_HANDICAP: u32 = 0;
+pub const DEFAULT_TOMBSTONE_DEPOSIT: u32 = 0;
+pub const DEFAULT_STORAGE_SIZE_OFFSET: u32 = 0;
+pub const DEFAULT_RENT_BYTE_FEE: u32 = 0;
+pub const DEFAULT_RENT_DEPOSIT_OFFSET: u32 = 0;
+pub const DEFAULT_SURCHARGE_REWARD: u32 = 0;
+pub const DEFAULT_TRANSFER_FEE: u32 = 0;
+pub const DEFAULT_CREATION_FEE: u32 = 0;
+pub const DEFAULT_TRANSACTION_BASE_FEE: u32 = 0;
+pub const DEFAULT_TRANSACTION_BYTE_FEE: u32 = 0;
+pub const DEFAULT_CONTRACT_FEE: u32 = 21;
+pub const DEFAULT_CALL_BASE_FEE: u32 = 135;
+pub const DEFAULT_CREATE_BASE_FEE: u32 = 175;
+pub const DEFAULT_MAX_DEPTH: u32 = 100;
+pub const DEFAULT_BLOCK_GAS_LIMIT: u32 = 10_000_000;
+
 pub trait Trait: timestamp::Trait {
 	type Currency: Currency<Self::AccountId>;
 
@@ -302,6 +318,67 @@ pub trait Trait: timestamp::Trait {
 
 	/// Handler for the unbalanced reduction when making a gas payment.
 	type GasPayment: OnUnbalanced<NegativeImbalanceOf<Self>>;
+
+	/// Number of block delay an extrinsic claim surcharge has.
+	///
+	/// When claim surchage is called by an extrinsic the rent is checked
+	/// for current_block - delay
+	type SignedClaimHandicap: Get<Self::BlockNumber>;
+
+	/// The minimum amount required to generate a tombstone.
+	type TombstoneDeposit: Get<BalanceOf<Self>>;
+
+	/// Size of a contract at the time of creation. This is a simple way to ensure
+	/// that empty contracts eventually gets deleted.
+	type StorageSizeOffset: Get<u32>;
+
+	/// Price of a byte of storage per one block interval. Should be greater than 0.
+	type RentByteFee: Get<BalanceOf<Self>>;
+
+	/// The amount of funds a contract should deposit in order to offset
+	/// the cost of one byte.
+	///
+	/// Let's suppose the deposit is 1,000 BU (balance units)/byte and the rent is 1 BU/byte/day,
+	/// then a contract with 1,000,000 BU that uses 1,000 bytes of storage would pay no rent.
+	/// But if the balance reduced to 500,000 BU and the storage stayed the same at 1,000,
+	/// then it would pay 500 BU/day.
+	type RentDepositOffset: Get<BalanceOf<Self>>;
+
+	/// Reward that is received by the party whose touch has led
+	/// to removal of a contract.
+	type SurchargeReward: Get<BalanceOf<Self>>;
+
+	/// The fee required to make a transfer.
+	type TransferFee: Get<BalanceOf<Self>>;
+
+	/// The fee required to create an account.
+	type CreationFee: Get<BalanceOf<Self>>;
+
+	/// The fee to be paid for making a transaction; the base.
+	type TransactionBaseFee: Get<BalanceOf<Self>>;
+
+	/// The fee to be paid for making a transaction; the per-byte portion.
+	type TransactionByteFee: Get<BalanceOf<Self>>;
+
+	/// The fee required to create a contract instance. A reasonable default value
+	/// is 21.
+	type ContractFee: Get<BalanceOf<Self>>;
+
+	/// The base fee charged for calling into a contract. A reasonable default
+	/// value is 135.
+	type CallBaseFee: Get<Gas>;
+
+	/// The base fee charged for creating a contract. A reasonable default value
+	/// is 175.
+	type CreateBaseFee: Get<Gas>;
+
+	/// The maximum nesting level of a call/create stack. A reasonable default
+	/// value is 100.
+	type MaxDepth: Get<u32>;
+
+	/// The maximum amount of gas that could be expended per block. A reasonable
+	/// default value is 10_000_000.
+	type BlockGasLimit: Get<Gas>;
 }
 
 /// Simple contract address determiner.
@@ -333,8 +410,8 @@ pub struct DefaultDispatchFeeComputor<T: Trait>(PhantomData<T>);
 impl<T: Trait> ComputeDispatchFee<T::Call, BalanceOf<T>> for DefaultDispatchFeeComputor<T> {
 	fn compute_dispatch_fee(call: &T::Call) -> BalanceOf<T> {
 		let encoded_len = call.using_encoded(|encoded| encoded.len() as u32);
-		let base_fee = <Module<T>>::transaction_base_fee();
-		let byte_fee = <Module<T>>::transaction_byte_fee();
+		let base_fee = T::TransactionBaseFee::get();
+		let byte_fee = T::TransactionByteFee::get();
 		base_fee + byte_fee * encoded_len.into()
 	}
 }
@@ -342,6 +419,67 @@ impl<T: Trait> ComputeDispatchFee<T::Call, BalanceOf<T>> for DefaultDispatchFeeC
 decl_module! {
 	/// Contracts module.
 	pub struct Module<T: Trait> for enum Call where origin: <T as system::Trait>::Origin {
+		/// Number of block delay an extrinsic claim surcharge has.
+		///
+		/// When claim surchage is called by an extrinsic the rent is checked
+		/// for current_block - delay
+		const SignedClaimHandicap: T::BlockNumber = T::SignedClaimHandicap::get();
+
+		/// The minimum amount required to generate a tombstone.
+		const TombstoneDeposit: BalanceOf<T> = T::TombstoneDeposit::get();
+
+		/// Size of a contract at the time of creation. This is a simple way to ensure
+		/// that empty contracts eventually gets deleted.
+		const StorageSizeOffset: u32 = T::StorageSizeOffset::get();
+
+		/// Price of a byte of storage per one block interval. Should be greater than 0.
+		const RentByteFee: BalanceOf<T> = T::RentByteFee::get();
+
+		/// The amount of funds a contract should deposit in order to offset
+		/// the cost of one byte.
+		///
+		/// Let's suppose the deposit is 1,000 BU (balance units)/byte and the rent is 1 BU/byte/day,
+		/// then a contract with 1,000,000 BU that uses 1,000 bytes of storage would pay no rent.
+		/// But if the balance reduced to 500,000 BU and the storage stayed the same at 1,000,
+		/// then it would pay 500 BU/day.
+		const RentDepositOffset: BalanceOf<T> = T::RentDepositOffset::get();
+
+		/// Reward that is received by the party whose touch has led
+		/// to removal of a contract.
+		const SurchargeReward: BalanceOf<T> = T::SurchargeReward::get();
+
+		/// The fee required to make a transfer.
+		const TransferFee: BalanceOf<T> = T::TransferFee::get();
+
+		/// The fee required to create an account.
+		const CreationFee: BalanceOf<T> = T::CreationFee::get();
+
+		/// The fee to be paid for making a transaction; the base.
+		const TransactionBaseFee: BalanceOf<T> = T::TransactionBaseFee::get();
+
+		/// The fee to be paid for making a transaction; the per-byte portion.
+		const TransactionByteFee: BalanceOf<T> = T::TransactionByteFee::get();
+
+		/// The fee required to create a contract instance. A reasonable default value
+		/// is 21.
+		const ContractFee: BalanceOf<T> = T::ContractFee::get();
+
+		/// The base fee charged for calling into a contract. A reasonable default
+		/// value is 135.
+		const CallBaseFee: Gas = T::CallBaseFee::get();
+
+		/// The base fee charged for creating a contract. A reasonable default value
+		/// is 175.
+		const CreateBaseFee: Gas = T::CreateBaseFee::get();
+
+		/// The maximum nesting level of a call/create stack. A reasonable default
+		/// value is 100.
+		const MaxDepth: u32 = T::MaxDepth::get();
+
+		/// The maximum amount of gas that could be expended per block. A reasonable
+		/// default value is 10_000_000.
+		const BlockGasLimit: Gas = T::BlockGasLimit::get();
+
 		fn deposit_event<T>() = default;
 
 		/// Updates the schedule for metering contracts.
@@ -519,14 +657,14 @@ decl_module! {
 			// adding a handicap: for signed extrinsics we use a slightly older block number
 			// for the eviction check. This can be viewed as if we pushed regular users back in past.
 			let handicap = if signed {
-				<Module<T>>::signed_claim_handicap()
+				T::SignedClaimHandicap::get()
 			} else {
 				Zero::zero()
 			};
 
 			// If poking the contract has lead to eviction of the contract, give out the rewards.
 			if rent::try_evict::<T>(&dest, handicap) == rent::RentOutcome::Evicted {
-				T::Currency::deposit_into_existing(rewarded, Self::surcharge_reward())?;
+				T::Currency::deposit_into_existing(rewarded, T::SurchargeReward::get())?;
 			}
 		}
 
@@ -644,45 +782,6 @@ decl_event! {
 
 decl_storage! {
 	trait Store for Module<T: Trait> as Contract {
-		/// Number of block delay an extrinsic claim surcharge has.
-		///
-		/// When claim surchage is called by an extrinsic the rent is checked
-		/// for current_block - delay
-		SignedClaimHandicap get(signed_claim_handicap) config(): T::BlockNumber;
-		/// The minimum amount required to generate a tombstone.
-		TombstoneDeposit get(tombstone_deposit) config(): BalanceOf<T>;
-		/// Size of a contract at the time of creation. This is a simple way to ensure
-		/// that empty contracts eventually gets deleted.
-		StorageSizeOffset get(storage_size_offset) config(): u32;
-		/// Price of a byte of storage per one block interval. Should be greater than 0.
-		RentByteFee get(rent_byte_price) config(): BalanceOf<T>;
-		/// The amount of funds a contract should deposit in order to offset
-		/// the cost of one byte.
-		///
-		/// Let's suppose the deposit is 1,000 BU (balance units)/byte and the rent is 1 BU/byte/day,
-		/// then a contract with 1,000,000 BU that uses 1,000 bytes of storage would pay no rent.
-		/// But if the balance reduced to 500,000 BU and the storage stayed the same at 1,000,
-		/// then it would pay 500 BU/day.
-		RentDepositOffset get(rent_deposit_offset) config(): BalanceOf<T>;
-		/// Reward that is received by the party whose touch has led
-		/// to removal of a contract.
-		SurchargeReward get(surcharge_reward) config(): BalanceOf<T>;
-		/// The fee required to make a transfer.
-		TransferFee get(transfer_fee) config(): BalanceOf<T>;
-		/// The fee required to create an account.
-		CreationFee get(creation_fee) config(): BalanceOf<T>;
-		/// The fee to be paid for making a transaction; the base.
-		TransactionBaseFee get(transaction_base_fee) config(): BalanceOf<T>;
-		/// The fee to be paid for making a transaction; the per-byte portion.
-		TransactionByteFee get(transaction_byte_fee) config(): BalanceOf<T>;
-		/// The fee required to create a contract instance.
-		ContractFee get(contract_fee) config(): BalanceOf<T> = 21.into();
-		/// The price of one unit of gas.
-		GasPrice get(gas_price) config(): BalanceOf<T> = 1.into();
-		/// The maximum nesting level of a call/create stack.
-		MaxDepth get(max_depth) config(): u32 = 100;
-		/// The maximum amount of gas that could be expended per block.
-		BlockGasLimit get(block_gas_limit) config(): Gas = 10_000_000;
 		/// Gas spent so far in this block.
 		GasSpent get(gas_spent): Gas;
 		/// Current cost schedule for contracts.
@@ -695,6 +794,8 @@ decl_storage! {
 		pub AccountCounter: u64 = 0;
 		/// The code associated with a given account.
 		pub ContractInfoOf: map T::AccountId => Option<ContractInfo<T>>;
+		/// The price of one unit of gas.
+		GasPrice get(gas_price) config(): BalanceOf<T> = 1.into();
 	}
 }
 
@@ -725,10 +826,10 @@ impl<T: Trait> Config<T> {
 		Config {
 			schedule: <Module<T>>::current_schedule(),
 			existential_deposit: T::Currency::minimum_balance(),
-			max_depth: <Module<T>>::max_depth(),
-			contract_account_instantiate_fee: <Module<T>>::contract_fee(),
-			account_create_fee: <Module<T>>::creation_fee(),
-			transfer_fee: <Module<T>>::transfer_fee(),
+			max_depth: T::MaxDepth::get(),
+			contract_account_instantiate_fee: T::ContractFee::get(),
+			account_create_fee: T::CreationFee::get(),
+			transfer_fee: T::TransferFee::get(),
 		}
 	}
 }

substrate/srml/contracts/src/rent.rs

@@ -14,10 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate. If not, see <http://www.gnu.org/licenses/>.
 
-use crate::{BalanceOf, ContractInfo, ContractInfoOf, Module, TombstoneContractInfo, Trait};
+use crate::{BalanceOf, ContractInfo, ContractInfoOf, TombstoneContractInfo, Trait};
 use runtime_primitives::traits::{Bounded, CheckedDiv, CheckedMul, Saturating, Zero,
 	SaturatedConversion};
-use srml_support::traits::{Currency, ExistenceRequirement, WithdrawReason};
+use srml_support::traits::{Currency, ExistenceRequirement, Get, WithdrawReason};
 use srml_support::StorageMap;
 
 #[derive(PartialEq, Eq, Copy, Clone)]
@@ -75,14 +75,14 @@ fn try_evict_or_and_pay_rent<T: Trait>(
 	// An amount of funds to charge per block for storage taken up by the contract.
 	let fee_per_block = {
 		let free_storage = balance
-			.checked_div(&<Module<T>>::rent_deposit_offset())
+			.checked_div(&T::RentDepositOffset::get())
 			.unwrap_or_else(Zero::zero);
 
 		let effective_storage_size =
 			<BalanceOf<T>>::from(contract.storage_size).saturating_sub(free_storage);
 
 		effective_storage_size
-			.checked_mul(&<Module<T>>::rent_byte_price())
+			.checked_mul(&T::RentByteFee::get())
 			.unwrap_or(<BalanceOf<T>>::max_value())
 	};
 
@@ -93,7 +93,7 @@ fn try_evict_or_and_pay_rent<T: Trait>(
 	}
 
 	// The minimal amount of funds required for a contract not to be evicted.
-	let subsistence_threshold = T::Currency::minimum_balance() + <Module<T>>::tombstone_deposit();
+	let subsistence_threshold = T::Currency::minimum_balance() + T::TombstoneDeposit::get();
 
 	if balance < subsistence_threshold {
 		// The contract cannot afford to leave a tombstone, so remove the contract info altogether.

substrate/srml/contracts/src/tests.rs

@@ -33,9 +33,10 @@ use runtime_primitives::testing::{Digest, DigestItem, Header, UintAuthorityId, H
 use runtime_primitives::traits::{BlakeTwo256, IdentityLookup};
 use runtime_primitives::BuildStorage;
 use srml_support::{
-	assert_ok, assert_err, impl_outer_dispatch, impl_outer_event, impl_outer_origin, storage::child,
-	traits::Currency, StorageMap, StorageValue
+	assert_ok, assert_err, impl_outer_dispatch, impl_outer_event, impl_outer_origin, parameter_types,
+	storage::child,	StorageMap, StorageValue, traits::{Currency, Get},
 };
+use std::cell::RefCell;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use substrate_primitives::storage::well_known_keys;
 use substrate_primitives::Blake2Hasher;
@@ -64,6 +65,33 @@ impl_outer_dispatch! {
 	}
 }
 
+thread_local! {
+	static EXISTENTIAL_DEPOSIT: RefCell<u64> = RefCell::new(0);
+	static TRANSFER_FEE: RefCell<u64> = RefCell::new(0);
+	static CREATION_FEE: RefCell<u64> = RefCell::new(0);
+	static BLOCK_GAS_LIMIT: RefCell<u64> = RefCell::new(0);
+}
+
+pub struct ExistentialDeposit;
+impl Get<u64> for ExistentialDeposit {
+	fn get() -> u64 { EXISTENTIAL_DEPOSIT.with(|v| *v.borrow()) }
+}
+
+pub struct TransferFee;
+impl Get<u64> for TransferFee {
+	fn get() -> u64 { TRANSFER_FEE.with(|v| *v.borrow()) }
+}
+
+pub struct CreationFee;
+impl Get<u64> for CreationFee {
+	fn get() -> u64 { CREATION_FEE.with(|v| *v.borrow()) }
+}
+
+pub struct BlockGasLimit;
+impl Get<u64> for BlockGasLimit {
+	fn get() -> u64 { BLOCK_GAS_LIMIT.with(|v| *v.borrow()) }
+}
+
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub struct Test;
 impl system::Trait for Test {
@@ -77,6 +105,10 @@ impl system::Trait for Test {
 	type Header = Header;
 	type Event = MetaEvent;
 }
+parameter_types! {
+	pub const BalancesTransactionBaseFee: u64 = 0;
+	pub const BalancesTransactionByteFee: u64 = 0;
+}
 impl balances::Trait for Test {
 	type Balance = u64;
 	type OnFreeBalanceZero = Contract;
@@ -85,11 +117,30 @@ impl balances::Trait for Test {
 	type TransactionPayment = ();
 	type DustRemoval = ();
 	type TransferPayment = ();
+	type ExistentialDeposit = ExistentialDeposit;
+	type TransferFee = TransferFee;
+	type CreationFee = CreationFee;
+	type TransactionBaseFee = BalancesTransactionBaseFee;
+	type TransactionByteFee = BalancesTransactionByteFee;
 }
 impl timestamp::Trait for Test {
 	type Moment = u64;
 	type OnTimestampSet = ();
 }
+parameter_types! {
+	pub const SignedClaimHandicap: u64 = 2;
+	pub const TombstoneDeposit: u64 = 16;
+	pub const StorageSizeOffset: u32 = 8;
+	pub const RentByteFee: u64 = 4;
+	pub const RentDepositOffset: u64 = 10_000;
+	pub const SurchargeReward: u64 = 150;
+	pub const TransactionBaseFee: u64 = 2;
+	pub const TransactionByteFee: u64 = 6;
+	pub const ContractFee: u64 = 21;
+	pub const CallBaseFee: u64 = 135;
+	pub const CreateBaseFee: u64 = 175;
+	pub const MaxDepth: u32 = 100;
+}
 impl Trait for Test {
 	type Currency = Balances;
 	type Call = Call;
@@ -98,6 +149,21 @@ impl Trait for Test {
 	type ComputeDispatchFee = DummyComputeDispatchFee;
 	type TrieIdGenerator = DummyTrieIdGenerator;
 	type GasPayment = ();
+	type SignedClaimHandicap = SignedClaimHandicap;
+	type TombstoneDeposit = TombstoneDeposit;
+	type StorageSizeOffset = StorageSizeOffset;
+	type RentByteFee = RentByteFee;
+	type RentDepositOffset = RentDepositOffset;
+	type SurchargeReward = SurchargeReward;
+	type TransferFee = TransferFee;
+	type CreationFee = CreationFee;
+	type TransactionBaseFee = TransactionBaseFee;
+	type TransactionByteFee = TransactionByteFee;
+	type ContractFee = ContractFee;
+	type CallBaseFee = CallBaseFee;
+	type CreateBaseFee = CreateBaseFee;
+	type MaxDepth = MaxDepth;
+	type BlockGasLimit = BlockGasLimit;
 }
 
 type Balances = balances::Module<Test>;
@@ -182,16 +248,18 @@ impl ExtBuilder {
 		self.creation_fee = creation_fee;
 		self
 	}
+	pub fn set_associated_consts(&self) {
+		EXISTENTIAL_DEPOSIT.with(|v| *v.borrow_mut() = self.existential_deposit);
+		TRANSFER_FEE.with(|v| *v.borrow_mut() = self.transfer_fee);
+		CREATION_FEE.with(|v| *v.borrow_mut() = self.creation_fee);
+		BLOCK_GAS_LIMIT.with(|v| *v.borrow_mut() = self.block_gas_limit);
+	}
 	pub fn build(self) -> runtime_io::TestExternalities<Blake2Hasher> {
+		self.set_associated_consts();
 		let mut t = system::GenesisConfig::default().build_storage::<Test>().unwrap().0;
 		t.extend(
 			balances::GenesisConfig::<Test> {
-				transaction_base_fee: 0,
-				transaction_byte_fee: 0,
 				balances: vec![],
-				existential_deposit: self.existential_deposit,
-				transfer_fee: self.transfer_fee,
-				creation_fee: self.creation_fee,
 				vesting: vec![],
 			}
 			.build_storage()
@@ -200,21 +268,8 @@ impl ExtBuilder {
 		);
 		t.extend(
 			GenesisConfig::<Test> {
-				signed_claim_handicap: 2,
-				rent_byte_price: 4,
-				rent_deposit_offset: 10_000,
-				storage_size_offset: 8,
-				surcharge_reward: 150,
-				tombstone_deposit: 16,
-				transaction_base_fee: 2,
-				transaction_byte_fee: 6,
-				transfer_fee: self.transfer_fee,
-				creation_fee: self.creation_fee,
-				contract_fee: 21,
-				gas_price: self.gas_price,
-				max_depth: 100,
-				block_gas_limit: self.block_gas_limit,
 				current_schedule: Default::default(),
+				gas_price: self.gas_price,
 			}
 			.build_storage()
 			.unwrap()
@@ -253,7 +308,7 @@ fn account_removal_removes_storage() {
 				Balances::deposit_creating(&1, 110);
 				ContractInfoOf::<Test>::insert(1, &ContractInfo::Alive(RawAliveContractInfo {
 					trie_id: trie_id1.clone(),
-					storage_size: Contract::storage_size_offset(),
+					storage_size: <Test as Trait>::StorageSizeOffset::get(),
 					deduct_block: System::block_number(),
 					code_hash: H256::repeat_byte(1),
 					rent_allowance: 40,
@@ -268,7 +323,7 @@ fn account_removal_removes_storage() {
 				Balances::deposit_creating(&2, 110);
 				ContractInfoOf::<Test>::insert(2, &ContractInfo::Alive(RawAliveContractInfo {
 					trie_id: trie_id2.clone(),
-					storage_size: Contract::storage_size_offset(),
+					storage_size: <Test as Trait>::StorageSizeOffset::get(),
 					deduct_block: System::block_number(),
 					code_hash: H256::repeat_byte(2),
 					rent_allowance: 40,
@@ -795,15 +850,15 @@ fn storage_size() {
 				<Test as balances::Trait>::Balance::from(1_000u32).encode() // rent allowance
 			));
 			let bob_contract = ContractInfoOf::<Test>::get(BOB).unwrap().get_alive().unwrap();
-			assert_eq!(bob_contract.storage_size, Contract::storage_size_offset() + 4);
+			assert_eq!(bob_contract.storage_size, <Test as Trait>::StorageSizeOffset::get() + 4);
 
 			assert_ok!(Contract::call(Origin::signed(ALICE), BOB, 0, 100_000, call::set_storage_4_byte()));
 			let bob_contract = ContractInfoOf::<Test>::get(BOB).unwrap().get_alive().unwrap();
-			assert_eq!(bob_contract.storage_size, Contract::storage_size_offset() + 4 + 4);
+			assert_eq!(bob_contract.storage_size, <Test as Trait>::StorageSizeOffset::get() + 4 + 4);
 
 			assert_ok!(Contract::call(Origin::signed(ALICE), BOB, 0, 100_000, call::remove_storage_4_byte()));
 			let bob_contract = ContractInfoOf::<Test>::get(BOB).unwrap().get_alive().unwrap();
-			assert_eq!(bob_contract.storage_size, Contract::storage_size_offset() + 4);
+			assert_eq!(bob_contract.storage_size, <Test as Trait>::StorageSizeOffset::get() + 4);
 		}
 	);
 }