Rename: srml-contract → srml-contracts (#2905)

* srml-contract → srml-contracts

* Trim.

* Bump version

substrate/srml/contracts/src/rent.rs

@@ -0,0 +1,194 @@
+// 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/>.
+
+use crate::{BalanceOf, ContractInfo, ContractInfoOf, Module, TombstoneContractInfo, Trait};
+use runtime_primitives::traits::{Bounded, CheckedDiv, CheckedMul, Saturating, Zero,
+	SaturatedConversion};
+use srml_support::traits::{Currency, ExistenceRequirement, Imbalance, WithdrawReason};
+use srml_support::StorageMap;
+
+#[derive(PartialEq, Eq, Copy, Clone)]
+#[must_use]
+pub enum RentOutcome {
+	/// Exempted from rent iff:
+	/// * rent is offset completely by the `rent_deposit_offset`,
+	/// * or rent has already been paid for this block number,
+	/// * or account doesn't have a contract,
+	/// * or account has a tombstone.
+	Exempted,
+	/// Evicted iff:
+	/// * rent exceed rent allowance,
+	/// * or can't withdraw the rent,
+	/// * or go below subsistence threshold.
+	Evicted,
+	/// The outstanding dues were paid or were able to be paid.
+	Ok,
+}
+
+/// Evict and optionally pay dues (or check account can pay them otherwise) at the current
+/// block number (modulo `handicap`, read on).
+///
+/// `pay_rent` gives an ability to pay or skip paying rent.
+/// `handicap` gives a way to check or pay the rent up to a moment in the past instead
+/// of current block.
+///
+/// NOTE: This function acts eagerly, all modification are committed into the storage.
+fn try_evict_or_and_pay_rent<T: Trait>(
+	account: &T::AccountId,
+	handicap: T::BlockNumber,
+	pay_rent: bool,
+) -> RentOutcome {
+	let contract = match <ContractInfoOf<T>>::get(account) {
+		None | Some(ContractInfo::Tombstone(_)) => return RentOutcome::Exempted,
+		Some(ContractInfo::Alive(contract)) => contract,
+	};
+
+	let current_block_number = <system::Module<T>>::block_number();
+
+	// How much block has passed since the last deduction for the contract.
+	let blocks_passed = {
+		// Calculate an effective block number, i.e. after adjusting for handicap.
+		let effective_block_number = current_block_number.saturating_sub(handicap);
+		let n = effective_block_number.saturating_sub(contract.deduct_block);
+		if n.is_zero() {
+			// Rent has already been paid
+			return RentOutcome::Exempted;
+		}
+		n
+	};
+
+	let balance = T::Currency::free_balance(account);
+
+	// 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())
+			.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())
+			.unwrap_or(<BalanceOf<T>>::max_value())
+	};
+
+	if fee_per_block.is_zero() {
+		// The rent deposit offset reduced the fee to 0. This means that the contract
+		// gets the rent for free.
+		return RentOutcome::Exempted;
+	}
+
+	// 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 dues = fee_per_block
+		.checked_mul(&blocks_passed.saturated_into::<u32>().into())
+		.unwrap_or(<BalanceOf<T>>::max_value());
+
+	let dues_limited = dues.min(contract.rent_allowance);
+	let rent_allowance_exceeded = dues > contract.rent_allowance;
+	let is_below_subsistence = balance < subsistence_threshold;
+	let go_below_subsistence = balance.saturating_sub(dues_limited) < subsistence_threshold;
+	let can_withdraw_rent = T::Currency::ensure_can_withdraw(
+		account,
+		dues_limited,
+		WithdrawReason::Fee,
+		balance.saturating_sub(dues_limited),
+	)
+	.is_ok();
+
+	if !rent_allowance_exceeded && can_withdraw_rent && !go_below_subsistence {
+		// Collect dues
+
+		if pay_rent {
+			let imbalance = T::Currency::withdraw(
+				account,
+				dues,
+				WithdrawReason::Fee,
+				ExistenceRequirement::KeepAlive,
+			)
+			.expect(
+				"Withdraw has been checked above;
+				go_below_subsistence is false and subsistence > existencial_deposit;
+				qed",
+			);
+
+			<ContractInfoOf<T>>::mutate(account, |contract| {
+				let contract = contract
+					.as_mut()
+					.and_then(|c| c.as_alive_mut())
+					.expect("Dead or inexistent account has been exempt above; qed");
+
+				contract.rent_allowance -= imbalance.peek(); // rent_allowance is not exceeded
+				contract.deduct_block = current_block_number;
+			})
+		}
+
+		RentOutcome::Ok
+	} else {
+		// Evict
+
+		if can_withdraw_rent && !go_below_subsistence {
+			T::Currency::withdraw(
+				account,
+				dues,
+				WithdrawReason::Fee,
+				ExistenceRequirement::KeepAlive,
+			)
+			.expect("Can withdraw and don't go below subsistence");
+		} else if !is_below_subsistence {
+			T::Currency::make_free_balance_be(account, subsistence_threshold);
+		} else {
+			T::Currency::make_free_balance_be(account, <BalanceOf<T>>::zero());
+		}
+
+		if !is_below_subsistence {
+			// The contract has funds above subsistence deposit and that means it can afford to
+			// leave tombstone.
+
+			// Note: this operation is heavy.
+			let child_storage_root = runtime_io::child_storage_root(&contract.trie_id);
+
+			let tombstone = <TombstoneContractInfo<T>>::new(
+				&child_storage_root[..],
+				contract.code_hash,
+			);
+			<ContractInfoOf<T>>::insert(account, ContractInfo::Tombstone(tombstone));
+			runtime_io::kill_child_storage(&contract.trie_id);
+		}
+
+		RentOutcome::Evicted
+	}
+}
+
+/// Make account paying the rent for the current block number
+///
+/// NOTE: This function acts eagerly.
+pub fn pay_rent<T: Trait>(account: &T::AccountId) {
+	let _ = try_evict_or_and_pay_rent::<T>(account, Zero::zero(), true);
+}
+
+/// Evict the account if it should be evicted at the given block number.
+///
+/// `handicap` gives a way to check or pay the rent up to a moment in the past instead
+/// of current block. E.g. if the contract is going to be evicted at the current block,
+/// `handicap=1` can defer the eviction for 1 block.
+///
+/// NOTE: This function acts eagerly.
+pub fn try_evict<T: Trait>(account: &T::AccountId, handicap: T::BlockNumber) -> RentOutcome {
+	try_evict_or_and_pay_rent::<T>(account, handicap, false)
+}