Implement the processing of the EVM gas usage. (#3715)

## Motivation

Running the EVM has its cost, known famously as gas/fuel. We need to
have adequate tracking of gas usage.

## Proposal

The following was done:
* For each operation done in storage, we track whether it maps from or
to 0 (meaning inexistent) and whether it changes the value. In a
separate set of tests, we identified when the corresponding gas costs.
* The identified gas costs are then subtracted from the gas_usage
returned by REVM. This is because the storage costs are being billed at
the end when the block is created. Double-counting the costs would be
inadequate.
* The `consume_fuel` and other are multiplied in order to take the
`VmRuntime` as arguments. The additional values are added to the
`Resources` and other entries.
* In a classical REVM run, the runs from separate contracts are grouped
together. However, we do not do that and run the different contracts
separately. Therefore, the other calls are set to zero. The grouping of
the different runs is then done in the `Resources` data types.
* The service tests are bounded in gas usage by the hardcoded value of
20_000_000.
* The metrics are corrected accordingly.

## Test Plan

The CI.

## Release Plan

Normal release of Linera.

## Links

None.

Author: MathieuDutSik

CLI.md

@@ -473,7 +473,8 @@ View or update the resource control policy
 ###### **Options:**
 
 * `--block <BLOCK>` — Set the base price for creating a block
-* `--fuel-unit <FUEL_UNIT>` — Set the price per unit of fuel
+* `--wasm-fuel-unit <WASM_FUEL_UNIT>` — Set the price per unit of Wasm fuel
+* `--evm-fuel-unit <EVM_FUEL_UNIT>` — Set the price per unit of EVM fuel
 * `--read-operation <READ_OPERATION>` — Set the price per read operation
 * `--write-operation <WRITE_OPERATION>` — Set the price per write operation
 * `--byte-read <BYTE_READ>` — Set the price per byte read
@@ -489,7 +490,8 @@ View or update the resource control policy
 * `--message-byte <MESSAGE_BYTE>` — Set the additional price for each byte in the argument of a user message
 * `--service-as-oracle-query <SERVICE_AS_ORACLE_QUERY>` — Set the price per query to a service as an oracle
 * `--http-request <HTTP_REQUEST>` — Set the price for performing an HTTP request
-* `--maximum-fuel-per-block <MAXIMUM_FUEL_PER_BLOCK>` — Set the maximum amount of fuel per block
+* `--maximum-wasm-fuel-per-block <MAXIMUM_WASM_FUEL_PER_BLOCK>` — Set the maximum amount of Wasm fuel per block
+* `--maximum-evm-fuel-per-block <MAXIMUM_EVM_FUEL_PER_BLOCK>` — Set the maximum amount of EVM fuel per block
 * `--maximum-service-oracle-execution-ms <MAXIMUM_SERVICE_ORACLE_EXECUTION_MS>` — Set the maximum time in milliseconds that a block can spend executing services as oracles
 * `--maximum-block-size <MAXIMUM_BLOCK_SIZE>` — Set the maximum size of a block, in bytes
 * `--maximum-blob-size <MAXIMUM_BLOB_SIZE>` — Set the maximum size of data blobs, compressed bytecode and other binary blobs, in bytes
@@ -533,7 +535,8 @@ Create genesis configuration for a Linera deployment. Create initial user chains
   Possible values: `no-fees`, `testnet`
 
 * `--block-price <BLOCK_PRICE>` — Set the base price for creating a block. (This will overwrite value from `--policy-config`)
-* `--fuel-unit-price <FUEL_UNIT_PRICE>` — Set the price per unit of fuel. (This will overwrite value from `--policy-config`)
+* `--wasm-fuel-unit-price <WASM_FUEL_UNIT_PRICE>` — Set the price per unit of Wasm fuel. (This will overwrite value from `--policy-config`)
+* `--evm-fuel-unit-price <EVM_FUEL_UNIT_PRICE>` — Set the price per unit of EVM fuel. (This will overwrite value from `--policy-config`)
 * `--read-operation-price <READ_OPERATION_PRICE>` — Set the price per read operation. (This will overwrite value from `--policy-config`)
 * `--write-operation-price <WRITE_OPERATION_PRICE>` — Set the price per write operation. (This will overwrite value from `--policy-config`)
 * `--byte-read-price <BYTE_READ_PRICE>` — Set the price per byte read. (This will overwrite value from `--policy-config`)
@@ -549,7 +552,8 @@ Create genesis configuration for a Linera deployment. Create initial user chains
 * `--message-byte-price <MESSAGE_BYTE_PRICE>` — Set the additional price for each byte in the argument of a user message. (This will overwrite value from `--policy-config`)
 * `--service-as-oracle-query-price <SERVICE_AS_ORACLE_QUERY_PRICE>` — Set the price per query to a service as an oracle
 * `--http-request-price <HTTP_REQUEST_PRICE>` — Set the price for performing an HTTP request
-* `--maximum-fuel-per-block <MAXIMUM_FUEL_PER_BLOCK>` — Set the maximum amount of fuel per block. (This will overwrite value from `--policy-config`)
+* `--maximum-wasm-fuel-per-block <MAXIMUM_WASM_FUEL_PER_BLOCK>` — Set the maximum amount of Wasm fuel per block. (This will overwrite value from `--policy-config`)
+* `--maximum-evm-fuel-per-block <MAXIMUM_EVM_FUEL_PER_BLOCK>` — Set the maximum amount of EVM fuel per block. (This will overwrite value from `--policy-config`)
 * `--maximum-service-oracle-execution-ms <MAXIMUM_SERVICE_ORACLE_EXECUTION_MS>` — Set the maximum time in milliseconds that a block can spend executing services as oracles
 * `--maximum-block-size <MAXIMUM_BLOCK_SIZE>` — Set the maximum size of a block. (This will overwrite value from `--policy-config`)
 * `--maximum-bytecode-size <MAXIMUM_BYTECODE_SIZE>` — Set the maximum size of decompressed contract or service bytecode, in bytes. (This will overwrite value from `--policy-config`)

examples/meta-counter/src/contract.rs

@@ -60,7 +60,7 @@ impl Contract for MetaCounterContract {
         } = operation;
 
         let mut message = self.runtime.prepare_message(message).with_grant(Resources {
-            fuel: fuel_grant,
+            wasm_fuel: fuel_grant,
             ..Resources::default()
         });
         if authenticated {

linera-base/src/data_types.rs

@@ -269,8 +269,10 @@ impl Display for Timestamp {
     Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize, WitLoad, WitStore, WitType,
 )]
 pub struct Resources {
-    /// An amount of execution fuel.
-    pub fuel: u64,
+    /// An amount of Wasm execution fuel.
+    pub wasm_fuel: u64,
+    /// An amount of EVM execution fuel.
+    pub evm_fuel: u64,
     /// A number of read operations to be executed.
     pub read_operations: u32,
     /// A number of write operations to be executed.

linera-base/src/unit_tests.rs

@@ -51,7 +51,8 @@ fn resources_test_case() -> Resources {
         blobs_to_publish: 73,
         blob_bytes_to_read: 67,
         blob_bytes_to_publish: 71,
-        fuel: 1_000,
+        wasm_fuel: 1_000,
+        evm_fuel: 1_000,
         message_size: 4,
         messages: 93,
         read_operations: 12,
@@ -75,7 +76,8 @@ fn send_message_request_test_case() -> SendMessageRequest<Vec<u8>> {
             blobs_to_publish: 1000,
             blob_bytes_to_read: 10,
             blob_bytes_to_publish: 100,
-            fuel: 8,
+            wasm_fuel: 8,
+            evm_fuel: 8,
             message_size: 1,
             messages: 0,
             read_operations: 1,

linera-chain/src/chain.rs

@@ -109,30 +109,40 @@ static WASM_FUEL_USED_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
 });
 
 #[cfg(with_metrics)]
-static WASM_NUM_READS_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
+static EVM_FUEL_USED_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
     register_histogram_vec(
-        "wasm_num_reads_per_block",
-        "Wasm number of reads per block",
+        "evm_fuel_used_per_block",
+        "EVM fuel used per block",
+        &[],
+        exponential_bucket_interval(10.0, 1_000_000.0),
+    )
+});
+
+#[cfg(with_metrics)]
+static VM_NUM_READS_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
+    register_histogram_vec(
+        "vm_num_reads_per_block",
+        "VM number of reads per block",
         &[],
         exponential_bucket_interval(0.1, 100.0),
     )
 });
 
 #[cfg(with_metrics)]
-static WASM_BYTES_READ_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
+static VM_BYTES_READ_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
     register_histogram_vec(
-        "wasm_bytes_read_per_block",
-        "Wasm number of bytes read per block",
+        "vm_bytes_read_per_block",
+        "VM number of bytes read per block",
         &[],
         exponential_bucket_interval(0.1, 10_000_000.0),
     )
 });
 
 #[cfg(with_metrics)]
-static WASM_BYTES_WRITTEN_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
+static VM_BYTES_WRITTEN_PER_BLOCK: LazyLock<HistogramVec> = LazyLock::new(|| {
     register_histogram_vec(
-        "wasm_bytes_written_per_block",
-        "Wasm number of bytes written per block",
+        "vm_bytes_written_per_block",
+        "VM number of bytes written per block",
         &[],
         exponential_bucket_interval(0.1, 10_000_000.0),
     )
@@ -1140,14 +1150,17 @@ where
         NUM_BLOCKS_EXECUTED.with_label_values(&[]).inc();
         WASM_FUEL_USED_PER_BLOCK
             .with_label_values(&[])
-            .observe(tracker.fuel as f64);
-        WASM_NUM_READS_PER_BLOCK
+            .observe(tracker.wasm_fuel as f64);
+        EVM_FUEL_USED_PER_BLOCK
+            .with_label_values(&[])
+            .observe(tracker.evm_fuel as f64);
+        VM_NUM_READS_PER_BLOCK
             .with_label_values(&[])
             .observe(tracker.read_operations as f64);
-        WASM_BYTES_READ_PER_BLOCK
+        VM_BYTES_READ_PER_BLOCK
             .with_label_values(&[])
             .observe(tracker.bytes_read as f64);
-        WASM_BYTES_WRITTEN_PER_BLOCK
+        VM_BYTES_WRITTEN_PER_BLOCK
             .with_label_values(&[])
             .observe(tracker.bytes_written as f64);
     }

linera-chain/src/unit_tests/chain_tests.rs

@@ -314,7 +314,7 @@ async fn test_application_permissions() -> anyhow::Result<()> {
     );
 
     // Also, blocks without an application operation or incoming message are forbidden.
-    let invalid_block = make_child_block(&value.clone());
+    let invalid_block = make_child_block(&value);
     let result = chain
         .execute_block(&invalid_block, time, None, &[], None)
         .await;

linera-core/src/unit_tests/client_tests.rs

@@ -1080,7 +1080,7 @@ where
     let mut builder = TestBuilder::new(storage_builder, 4, 1, &mut signer)
         .await?
         .with_policy(ResourceControlPolicy {
-            maximum_fuel_per_block: 30_000,
+            maximum_wasm_fuel_per_block: 30_000,
             blob_read: initial_balance + Amount::ONE,
             blob_published: initial_balance + Amount::ONE,
             blob_byte_read: initial_balance + Amount::ONE,

linera-core/src/unit_tests/wasm_client_tests.rs

@@ -882,7 +882,7 @@ async fn test_memory_fuel_limit(wasm_runtime: WasmRuntime) -> anyhow::Result<()>
     // Set a fuel limit that is enough to instantiate the application and do one increment
     // operation, but not ten. We also verify blob fees for the bytecode.
     let policy = ResourceControlPolicy {
-        maximum_fuel_per_block: 30_000,
+        maximum_wasm_fuel_per_block: 30_000,
         blob_read: Amount::from_tokens(10), // Should not be charged.
         blob_published: Amount::from_attos(100),
         blob_byte_read: Amount::from_tokens(10), // Should not be charged.

linera-execution/src/evm/database.rs

@@ -20,58 +20,116 @@ use revm_primitives::{address, BlobExcessGasAndPrice, BlockEnv, EvmState};
 
 use crate::{BaseRuntime, Batch, ContractRuntime, ExecutionError, ViewError};
 
-#[repr(u8)]
-enum KeyTag {
-    /// Key prefix for the storage of the zero contract.
-    ZeroContractAddress,
-    /// Key prefix for the storage of the contract address.
-    ContractAddress,
+/// The cost of loading from storage.
+const SLOAD_COST: u64 = 2100;
+
+/// The cost of storing a non-zero value in the storage for the first time.
+const SSTORE_COST_SET: u64 = 20000;
+
+/// The cost of not changing the state of the variable in the storage.
+const SSTORE_COST_NO_OPERATION: u64 = 100;
+
+/// The cost of overwriting the storage to a different value.
+const SSTORE_COST_RESET: u64 = 2900;
+
+/// The refund from releasing data.
+const SSTORE_REFUND_RELEASE: u64 = 4800;
+
+#[derive(Clone, Default)]
+pub(crate) struct StorageStats {
+    key_no_operation: u64,
+    key_reset: u64,
+    key_set: u64,
+    key_release: u64,
+    key_read: u64,
 }
 
-#[repr(u8)]
-pub enum KeyCategory {
-    AccountInfo,
-    AccountState,
-    Storage,
+impl StorageStats {
+    pub fn storage_costs(&self) -> u64 {
+        let mut storage_costs = 0;
+        storage_costs += self.key_no_operation * SSTORE_COST_NO_OPERATION;
+        storage_costs += self.key_reset * SSTORE_COST_RESET;
+        storage_costs += self.key_set * SSTORE_COST_SET;
+        storage_costs += self.key_read * SLOAD_COST;
+        storage_costs
+    }
+
+    pub fn storage_refund(&self) -> u64 {
+        self.key_release * SSTORE_REFUND_RELEASE
+    }
 }
 
 pub(crate) struct DatabaseRuntime<Runtime> {
+    storage_stats: Arc<Mutex<StorageStats>>,
     pub runtime: Arc<Mutex<Runtime>>,
     pub changes: EvmState,
 }
 
 impl<Runtime> Clone for DatabaseRuntime<Runtime> {
     fn clone(&self) -> Self {
         Self {
+            storage_stats: self.storage_stats.clone(),
             runtime: self.runtime.clone(),
             changes: self.changes.clone(),
         }
     }
 }
 
+#[repr(u8)]
+enum KeyTag {
+    /// Key prefix for the storage of the zero contract.
+    NullAddress,
+    /// Key prefix for the storage of the contract address.
+    ContractAddress,
+}
+
+#[repr(u8)]
+pub enum KeyCategory {
+    AccountInfo,
+    AccountState,
+    Storage,
+}
+
 impl<Runtime> DatabaseRuntime<Runtime> {
-    fn get_uint256_key(val: u8, index: U256) -> Result<Vec<u8>, ExecutionError> {
+    /// Encode the `index` of the EVM storage associated to the smart contract
+    /// in a linera key.
+    fn get_linera_key(val: u8, index: U256) -> Result<Vec<u8>, ExecutionError> {
         let mut key = vec![val, KeyCategory::Storage as u8];
         bcs::serialize_into(&mut key, &index)?;
         Ok(key)
     }
 
+    /// Returns the tag associated to the contract.
     fn get_contract_address_key(&self, address: &Address) -> Option<u8> {
         if address == &Address::ZERO {
-            return Some(KeyTag::ZeroContractAddress as u8);
+            return Some(KeyTag::NullAddress as u8);
         }
         if address == &Address::ZERO.create(0) {
             return Some(KeyTag::ContractAddress as u8);
         }
         None
     }
 
+    /// Creates a new `DatabaseRuntime`.
     pub fn new(runtime: Runtime) -> Self {
+        let storage_stats = StorageStats::default();
         Self {
+            storage_stats: Arc::new(Mutex::new(storage_stats)),
             runtime: Arc::new(Mutex::new(runtime)),
             changes: HashMap::new(),
         }
     }
+
+    /// Returns the current storage states and clears it to default.
+    pub fn take_storage_stats(&self) -> StorageStats {
+        let mut storage_stats_read = self
+            .storage_stats
+            .lock()
+            .expect("The lock should be possible");
+        let storage_stats = storage_stats_read.clone();
+        *storage_stats_read = StorageStats::default();
+        storage_stats
+    }
 }
 
 impl<Runtime> Database for DatabaseRuntime<Runtime>
@@ -151,7 +209,14 @@ where
         let Some(val) = val else {
             panic!("There is no storage associated to externally owned account");
         };
-        let key = Self::get_uint256_key(val, index)?;
+        let key = Self::get_linera_key(val, index)?;
+        {
+            let mut storage_stats = self
+                .storage_stats
+                .lock()
+                .expect("The lock should be possible");
+            storage_stats.key_read += 1;
+        }
         let result = {
             let mut runtime = self.runtime.lock().expect("The lock should be possible");
             let promise = runtime.read_value_bytes_new(key)?;
@@ -171,6 +236,10 @@ where
 {
     /// Effectively commits changes to storage.
     pub fn commit_changes(&mut self) -> Result<(), ExecutionError> {
+        let mut storage_stats = self
+            .storage_stats
+            .lock()
+            .expect("The lock should be possible");
         let mut runtime = self.runtime.lock().expect("The lock should be possible");
         let mut batch = Batch::new();
         let mut list_new_balances = Vec::new();
@@ -207,8 +276,21 @@ where
                     };
                     batch.put_key_value(key_state, &account_state)?;
                     for (index, value) in &account.storage {
-                        let key = Self::get_uint256_key(val, *index)?;
-                        batch.put_key_value(key, &value.present_value())?;
+                        if value.present_value() == value.original_value() {
+                            storage_stats.key_no_operation += 1;
+                        } else {
+                            let key = Self::get_linera_key(val, *index)?;
+                            if value.original_value() == U256::ZERO {
+                                batch.put_key_value(key, &value.present_value())?;
+                                storage_stats.key_set += 1;
+                            } else if value.present_value() == U256::ZERO {
+                                batch.delete_key(key);
+                                storage_stats.key_release += 1;
+                            } else {
+                                batch.put_key_value(key, &value.present_value())?;
+                                storage_stats.key_reset += 1;
+                            }
+                        }
                     }
                 }
             } else {
@@ -239,7 +321,7 @@ where
 {
     pub fn is_initialized(&self) -> Result<bool, ExecutionError> {
         let mut keys = Vec::new();
-        for key_tag in [KeyTag::ZeroContractAddress, KeyTag::ContractAddress] {
+        for key_tag in [KeyTag::NullAddress, KeyTag::ContractAddress] {
             let key = vec![key_tag as u8, KeyCategory::AccountInfo as u8];
             keys.push(key);
         }