Enabled GasLimitStorageGrowthRatio (#997)

Co-authored-by: tmpolaczyk <[email protected]>

Author: evgeny-s

Cargo.lock

@@ -867,7 +867,8 @@ parameter_types! {
     pub WeightPerGas: Weight = Weight::from_parts(WEIGHT_PER_GAS, 0);
     pub SuicideQuickClearLimit: u32 = 0;
     pub GasLimitPovSizeRatio: u32 = 16;
-    pub GasLimitStorageGrowthRatio: u64 = 366;
+    /// Hardcoding the value, since it is computed on block execution. Check calculations in the tests
+    pub GasLimitStorageGrowthRatio: u64 = 1464;
 }
 
 impl_on_charge_evm_transaction!();
@@ -897,7 +898,7 @@ impl pallet_evm::Config for Runtime {
     type OnCreate = ();
     type FindAuthor = FindAuthorAdapter;
     type GasLimitPovSizeRatio = GasLimitPovSizeRatio;
-    type GasLimitStorageGrowthRatio = ();
+    type GasLimitStorageGrowthRatio = GasLimitStorageGrowthRatio;
     type Timestamp = Timestamp;
     type WeightInfo = ();
 }
@@ -1548,14 +1549,22 @@ impl_runtime_apis! {
             max_fee_per_gas: Option<U256>,
             max_priority_fee_per_gas: Option<U256>,
             nonce: Option<U256>,
-            _estimate: bool,
+            estimate: bool,
             access_list: Option<Vec<(H160, Vec<H256>)>>,
         ) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {
+            let config = if estimate {
+                let mut config = <Runtime as pallet_evm::Config>::config().clone();
+                config.estimate = true;
+                Some(config)
+            } else {
+                None
+            };
             let is_transactional = false;
             let validate = true;
 
             // Estimated encoded transaction size must be based on the heaviest transaction
             // type (EIP1559Transaction) to be compatible with all transaction types.
+            // TODO: remove, since we will get rid of base_cost
             let mut estimated_transaction_len = data.len() +
                 // pallet ethereum index: 1
                 // transact call index: 1
@@ -1571,13 +1580,15 @@ impl_runtime_apis! {
                 // 65 bytes signature
                 258;
 
-            if access_list.is_some() {
-                estimated_transaction_len += access_list.encoded_size();
+            if let Some(ref list) = access_list {
+                estimated_transaction_len += list.encoded_size();
             }
+
             let gas_limit = gas_limit.min(u64::MAX.into()).low_u64();
             let without_base_extrinsic_weight = true;
-            let (weight_limit, proof_size_base_cost) =
-                match <Runtime as pallet_evm::Config>::GasWeightMapping::gas_to_weight(
+
+            let (weight_limit, proof_size_base_cost) = match
+                <Runtime as pallet_evm::Config>::GasWeightMapping::gas_to_weight(
                     gas_limit,
                     without_base_extrinsic_weight
                 ) {
@@ -1601,7 +1612,7 @@ impl_runtime_apis! {
                 validate,
                 weight_limit,
                 proof_size_base_cost,
-                <Runtime as pallet_evm::Config>::config(),
+                config.as_ref().unwrap_or(<Runtime as pallet_evm::Config>::config()),
             ).map_err(|err| err.error.into())
         }
 
@@ -1613,25 +1624,67 @@ impl_runtime_apis! {
             max_fee_per_gas: Option<U256>,
             max_priority_fee_per_gas: Option<U256>,
             nonce: Option<U256>,
-            _estimate: bool,
+            estimate: bool,
             access_list: Option<Vec<(H160, Vec<H256>)>>,
         ) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {
+            let config = if estimate {
+                let mut config = <Runtime as pallet_evm::Config>::config().clone();
+                config.estimate = true;
+                Some(config)
+            } else {
+                None
+            };
             let is_transactional = false;
             let validate = true;
+
+            let mut estimated_transaction_len = data.len() +
+                        // from: 20
+                        // value: 32
+                        // gas_limit: 32
+                        // nonce: 32
+                        // 1 byte transaction action variant
+                        // chain id 8 bytes
+                        // 65 bytes signature
+                        190;
+
+            if max_fee_per_gas.is_some() {
+                estimated_transaction_len += 32;
+            }
+            if max_priority_fee_per_gas.is_some() {
+                estimated_transaction_len += 32;
+            }
+            if let Some(ref list) = access_list {
+                estimated_transaction_len += list.encoded_size();
+            }
+
+            let gas_limit = gas_limit.min(u64::MAX.into()).low_u64();
+            let without_base_extrinsic_weight = true;
+
+            let (weight_limit, proof_size_base_cost) = match
+                <Runtime as pallet_evm::Config>::GasWeightMapping::gas_to_weight(
+                    gas_limit,
+                    without_base_extrinsic_weight
+                ) {
+                    weight_limit if weight_limit.proof_size() > 0 => {
+                        (Some(weight_limit), Some(estimated_transaction_len as u64))
+                    }
+                    _ => (None, None),
+                };
+
             <Runtime as pallet_evm::Config>::Runner::create(
                 from,
                 data,
                 value,
-                gas_limit.min(u64::MAX.into()).low_u64(),
+                gas_limit,
                 max_fee_per_gas,
                 max_priority_fee_per_gas,
                 nonce,
                 access_list.unwrap_or_default(),
                 is_transactional,
                 validate,
-                None,
-                None,
-                <Runtime as pallet_evm::Config>::config(),
+                weight_limit,
+                proof_size_base_cost,
+                config.as_ref().unwrap_or(<Runtime as pallet_evm::Config>::config()),
             ).map_err(|err| err.error.into())
         }
 
@@ -1844,3 +1897,19 @@ cumulus_pallet_parachain_system::register_validate_block! {
     CheckInherents = CheckInherents,
     BlockExecutor = pallet_author_inherent::BlockExecutor::<Runtime, Executive>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Block storage limit in bytes. Set to 40 KB.
+    const BLOCK_STORAGE_LIMIT: u64 = 40 * 1024;
+
+    #[test]
+    fn check_ratio_constant() {
+        assert_eq!(
+            BlockGasLimit::get().min(u64::MAX.into()).low_u64() / BLOCK_STORAGE_LIMIT,
+            GasLimitStorageGrowthRatio::get()
+        );
+    }
+}

chains/container-chains/runtime-templates/frontier/src/lib.rs

@@ -19,7 +19,7 @@ use {
         xcm_config::{AssetId, ForeignAssetsInstance, XcmConfig},
         AccountId, Balances, ForeignAssetsCreator, Runtime,
     },
-    frame_support::parameter_types,
+    frame_support::{parameter_types, traits::ConstU64},
     pallet_evm_precompile_balances_erc20::{Erc20BalancesPrecompile, Erc20Metadata},
     pallet_evm_precompile_batch::BatchPrecompile,
     pallet_evm_precompile_call_permit::CallPermitPrecompile,
@@ -71,6 +71,10 @@ pub const FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX: &[u8] = &[255u8; 18];
 /// Const to identify ERC20_BALANCES_PRECOMPILE address
 pub const ERC20_BALANCES_PRECOMPILE: u64 = 2048;
 
+/// System account size in bytes = Pallet_Name_Hash (16) + Storage_name_hash (16) +
+/// Blake2_128Concat (16) + AccountId (20) + AccountInfo (4 + 12 + AccountData (4* 16)) = 148
+pub const SYSTEM_ACCOUNT_SIZE: u64 = 148;
+
 parameter_types! {
     pub ForeignAssetPrefix: &'static [u8] = FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX;
 }
@@ -99,7 +103,7 @@ type TemplatePrecompilesAt<R> = (
     // Template specific precompiles:
     PrecompileAt<
         AddressU64<ERC20_BALANCES_PRECOMPILE>,
-        Erc20BalancesPrecompile<R, NativeErc20Metadata>,
+        Erc20BalancesPrecompile<R, NativeErc20Metadata, ConstU64<SYSTEM_ACCOUNT_SIZE>>,
         (CallableByContract, CallableByPrecompile),
     >,
     PrecompileAt<AddressU64<2049>, BatchPrecompile<R>, SubcallWithMaxNesting<2>>,
@@ -110,8 +114,8 @@ type TemplatePrecompilesAt<R> = (
     >,
     PrecompileAt<
         AddressU64<2051>,
-        XcmUtilsPrecompile<R, XcmConfig>,
-        CallableByContract<AllExceptXcmExecute<R, XcmConfig>>,
+        XcmUtilsPrecompile<R, XcmConfig, ConstU64<SYSTEM_ACCOUNT_SIZE>>,
+        CallableByContract<AllExceptXcmExecute<R, XcmConfig, ConstU64<SYSTEM_ACCOUNT_SIZE>>>,
     >,
     PrecompileAt<
         AddressU64<2052>,

chains/container-chains/runtime-templates/frontier/src/precompiles.rs

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity >=0.8.3;
+
+contract Fibonacci {
+    function fib2(uint256 n) public pure returns (uint256 b) {
+        if (n == 0) {
+            return 0;
+        }
+        uint256 a = 1;
+        b = 1;
+        for (uint256 i = 2; i < n; i++) {
+            uint256 c = a + b;
+            a = b;
+            b = c;
+        }
+        return b;
+    }
+}

test/contracts/solidity/Fibonacci.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.2 <0.9.0;
+
+contract StorageLoop {
+    mapping(uint256 => uint256) public map;
+    mapping(uint256 => uint256) public map2;
+
+    function store(uint16 n) public {
+        for (uint16 i = 0; i < n; i++) {
+            map[i] = i + 1;
+        }
+    }
+
+    function store2(uint256 i) public {
+        map2[i] = i;
+    }
+}