Switch to wasm global gas meter

Author: sug0

crates/gas/src/lib.rs

@@ -248,6 +248,11 @@ pub struct Gas {
 }
 
 impl Gas {
+    /// Initialize a new gas value from its sub units.
+    pub const fn new(sub_units: u64) -> Self {
+        Self { sub: sub_units }
+    }
+
     /// Checked add of `Gas`. Returns `None` on overflow
     pub fn checked_add(&self, rhs: Self) -> Option<Self> {
         self.sub.checked_add(rhs.sub).map(|sub| Self { sub })
@@ -353,6 +358,29 @@ pub trait GasMetering {
     /// will still be updated
     fn consume(&mut self, gas: Gas) -> Result<()>;
 
+    /// Get the gas initially available to the gas meter
+    ///
+    /// This value will be equal to the gas limit minus some
+    /// gas that may have been consumed before the current
+    /// meter was initialized
+    fn get_initially_available_gas(&self) -> Gas;
+
+    /// Get the gas consumed thus far
+    fn get_consumed_gas(&self) -> Gas;
+
+    /// Get the gas limit
+    fn get_gas_limit(&self) -> Gas;
+
+    /// Get the protocol gas scale
+    fn get_gas_scale(&self) -> u64;
+
+    /// Get the amount of gas still available to the transaction
+    fn get_available_gas(&self) -> Gas {
+        self.get_gas_limit()
+            .checked_sub(self.get_consumed_gas())
+            .unwrap_or_default()
+    }
+
     /// Add the compiling cost proportionate to the code length
     fn add_compiling_gas(&mut self, bytes_len: u64) -> Result<()> {
         self.consume(
@@ -383,56 +411,64 @@ pub trait GasMetering {
         )
     }
 
-    /// Get the gas consumed by the tx
-    fn get_tx_consumed_gas(&self) -> Gas;
-
-    /// Get the gas limit
-    fn get_gas_limit(&self) -> Gas;
-
-    /// Get the protocol gas scale
-    fn get_gas_scale(&self) -> u64;
+    /// Check if the meter ran out of gas. Starts with the initial gas.
+    fn check_limit(&self, gas: Gas) -> Result<()> {
+        self.get_initially_available_gas()
+            .checked_sub(gas)
+            .ok_or_else(|| {
+                Error::TransactionGasExceededError(
+                    self.get_gas_limit()
+                        .get_whole_gas_units(self.get_gas_scale()),
+                )
+            })
+            .and(Ok(()))
+    }
 
-    /// Check if the vps went out of gas. Starts with the gas consumed by the
-    /// transaction.
-    fn check_vps_limit(&self, vps_gas: Gas) -> Result<()> {
-        let total = self
-            .get_tx_consumed_gas()
-            .checked_add(vps_gas)
-            .ok_or(Error::GasOverflow)?;
-        let gas_limit = self.get_gas_limit();
-        if total > gas_limit {
-            return Err(Error::TransactionGasExceededError(
-                gas_limit.get_whole_gas_units(self.get_gas_scale()),
-            ));
-        }
+    /// Add the gas required by a wrapper transaction which is comprised of:
+    ///  - cost of validating the wrapper tx
+    ///  - space that the transaction requires in the block
+    ///  - cost of downloading (as part of the block) the transaction bytes over
+    ///    the network
+    fn add_wrapper_gas(&mut self, tx_bytes: &[u8]) -> Result<()> {
+        self.consume(WRAPPER_TX_VALIDATION_GAS.into())?;
 
-        Ok(())
+        let bytes_len = tx_bytes.len() as u64;
+        self.consume(
+            bytes_len
+                .checked_mul(
+                    STORAGE_OCCUPATION_GAS_PER_BYTE
+                        + NETWORK_TRANSMISSION_GAS_PER_BYTE,
+                )
+                .ok_or(Error::GasOverflow)?
+                .into(),
+        )
     }
 }
 
 /// Gas metering in a transaction
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct TxGasMeter {
     /// Track gas overflow
     gas_overflow: bool,
-    // The protocol gas scale
+    /// The protocol gas scale
     gas_scale: u64,
     /// The gas limit for a transaction
-    pub tx_gas_limit: Gas,
+    tx_gas_limit: Gas,
+    /// Gas consumption of the tx
     transaction_gas: Gas,
 }
 
 /// Gas metering in a validity predicate
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct VpGasMeter {
     /// Track gas overflow
     gas_overflow: bool,
-    // The protocol gas scale
+    /// The protocol gas scale
     gas_scale: u64,
     /// The transaction gas limit
     tx_gas_limit: Gas,
     /// The gas consumed by the transaction before the Vp
-    initial_gas: Gas,
+    prev_meter_consumed_gas: Gas,
     /// The current gas usage in the VP
     current_gas: Gas,
 }
@@ -460,8 +496,12 @@ impl GasMetering for TxGasMeter {
         Ok(())
     }
 
-    /// Get the entire gas used by the transaction up until this point
-    fn get_tx_consumed_gas(&self) -> Gas {
+    #[inline]
+    fn get_initially_available_gas(&self) -> Gas {
+        self.get_gas_limit()
+    }
+
+    fn get_consumed_gas(&self) -> Gas {
         if !self.gas_overflow {
             self.transaction_gas.clone()
         } else {
@@ -490,53 +530,6 @@ impl TxGasMeter {
             transaction_gas: Gas::default(),
         }
     }
-
-    /// Add the gas required by a wrapper transaction which is comprised of:
-    ///  - cost of validating the wrapper tx
-    ///  - space that the transaction requires in the block
-    ///  - cost of downloading (as part of the block) the transaction bytes over
-    ///    the network
-    pub fn add_wrapper_gas(&mut self, tx_bytes: &[u8]) -> Result<()> {
-        self.consume(WRAPPER_TX_VALIDATION_GAS.into())?;
-
-        let bytes_len = tx_bytes.len() as u64;
-        self.consume(
-            bytes_len
-                .checked_mul(
-                    STORAGE_OCCUPATION_GAS_PER_BYTE
-                        + NETWORK_TRANSMISSION_GAS_PER_BYTE,
-                )
-                .ok_or(Error::GasOverflow)?
-                .into(),
-        )
-    }
-
-    /// Get the amount of gas still available to the transaction
-    pub fn get_available_gas(&self) -> Gas {
-        self.tx_gas_limit
-            .checked_sub(self.transaction_gas.clone())
-            .unwrap_or_default()
-    }
-
-    /// Set the amount of gas still available to the transaction.
-    ///
-    /// WARNING: Utmost care must be taken when using this function! This must
-    /// never increase the amount available.
-    pub fn set_available_gas(&mut self, gas: impl Into<Gas>) {
-        let gas: Gas = gas.into();
-        let used_gas = self
-            .tx_gas_limit
-            .checked_sub(gas)
-            .unwrap_or_else(|| self.tx_gas_limit.clone());
-        debug_assert!(
-            used_gas > self.transaction_gas,
-            "Used gas must not decrease from {:?}, but trying to set it to \
-             {:?}",
-            self.transaction_gas,
-            used_gas
-        );
-        self.transaction_gas = used_gas;
-    }
 }
 
 impl GasMetering for VpGasMeter {
@@ -554,7 +547,7 @@ impl GasMetering for VpGasMeter {
             })?;
 
         let current_total = self
-            .initial_gas
+            .prev_meter_consumed_gas
             .checked_add(self.current_gas.clone())
             .ok_or(Error::GasOverflow)?;
 
@@ -567,14 +560,16 @@ impl GasMetering for VpGasMeter {
         Ok(())
     }
 
-    /// Get the gas consumed by the tx alone before the vps were executed
-    fn get_tx_consumed_gas(&self) -> Gas {
-        if !self.gas_overflow {
-            self.initial_gas.clone()
-        } else {
-            hints::cold();
-            u64::MAX.into()
-        }
+    fn get_initially_available_gas(&self) -> Gas {
+        self.tx_gas_limit
+            .checked_sub(self.prev_meter_consumed_gas.clone())
+            .unwrap_or_default()
+    }
+
+    fn get_consumed_gas(&self) -> Gas {
+        self.prev_meter_consumed_gas
+            .checked_add(self.get_vp_consumed_gas())
+            .unwrap_or_else(|| u64::MAX.into())
     }
 
     fn get_gas_limit(&self) -> Gas {
@@ -587,13 +582,18 @@ impl GasMetering for VpGasMeter {
 }
 
 impl VpGasMeter {
-    /// Initialize a new VP gas meter from the `TxGasMeter`
+    /// Initialize a new VP gas meter from the [`TxGasMeter`]
     pub fn new_from_tx_meter(tx_gas_meter: &TxGasMeter) -> Self {
+        Self::new_from_meter(tx_gas_meter)
+    }
+
+    /// Initialize a new VP gas meter from the given generic gas meter
+    pub fn new_from_meter(gas_meter: &impl GasMetering) -> Self {
         Self {
             gas_overflow: false,
-            gas_scale: tx_gas_meter.gas_scale,
-            tx_gas_limit: tx_gas_meter.tx_gas_limit.clone(),
-            initial_gas: tx_gas_meter.transaction_gas.clone(),
+            gas_scale: gas_meter.get_gas_scale(),
+            tx_gas_limit: gas_meter.get_gas_limit(),
+            prev_meter_consumed_gas: gas_meter.get_consumed_gas(),
             current_gas: Gas::default(),
         }
     }
@@ -602,15 +602,6 @@ impl VpGasMeter {
     pub fn get_vp_consumed_gas(&self) -> Gas {
         self.current_gas.clone()
     }
-
-    /// Get the amount of gas still available to the VP
-    pub fn get_available_gas(&self) -> Gas {
-        self.tx_gas_limit
-            .checked_sub(self.initial_gas.clone())
-            .unwrap_or_default()
-            .checked_sub(self.current_gas.clone())
-            .unwrap_or_default()
-    }
 }
 
 #[cfg(test)]

crates/node/src/dry_run_tx.rs

@@ -115,7 +115,7 @@ where
         tx_result_string,
         tx_gas_meter
             .borrow()
-            .get_tx_consumed_gas()
+            .get_consumed_gas()
             .get_whole_gas_units(gas_scale),
     );
 

crates/node/src/protocol.rs

@@ -888,7 +888,7 @@ where
 
     tx_gas_meter
         .borrow_mut()
-        .consume(masp_gas_meter.borrow().get_tx_consumed_gas())
+        .consume(masp_gas_meter.borrow().get_consumed_gas())
         .map_err(|e| Error::GasError(e.to_string()))?;
 
     Ok(valid_batched_tx_result)
@@ -1273,7 +1273,7 @@ where
             || (VpsResult::default(), Gas::from(0)),
             |(mut result, mut vps_gas), addr| {
                 let gas_meter =
-                    RefCell::new(VpGasMeter::new_from_tx_meter(tx_gas_meter));
+                    RefCell::new(VpGasMeter::new_from_meter(tx_gas_meter));
                 let tx_accepted = match &addr {
                     Address::Implicit(_) | Address::Established(_) => {
                         let (vp_hash, gas) = state
@@ -1471,7 +1471,7 @@ where
                     ))?;
                 gas_meter
                     .borrow()
-                    .check_vps_limit(vps_gas.clone())
+                    .check_limit(vps_gas.clone())
                     .map_err(|err| Error::GasError(err.to_string()))?;
 
                 Ok((result, vps_gas))
@@ -1503,7 +1503,7 @@ fn merge_vp_results(
         .checked_add(b_gas)
         .ok_or(Error::GasError(gas::Error::GasOverflow.to_string()))?;
     tx_gas_meter
-        .check_vps_limit(vps_gas.clone())
+        .check_limit(vps_gas.clone())
         .map_err(|err| Error::GasError(err.to_string()))?;
 
     Ok((

crates/node/src/shell/finalize_block.rs

@@ -413,7 +413,7 @@ where
                     let gas_scale = tx_data.tx_gas_meter.get_gas_scale();
                     let scaled_gas = tx_data
                         .tx_gas_meter
-                        .get_tx_consumed_gas()
+                        .get_consumed_gas()
                         .get_whole_gas_units(gas_scale);
                     tx_logs
                         .tx_event
@@ -446,7 +446,7 @@ where
                     let gas_scale = tx_data.tx_gas_meter.get_gas_scale();
                     let scaled_gas = tx_data
                         .tx_gas_meter
-                        .get_tx_consumed_gas()
+                        .get_consumed_gas()
                         .get_whole_gas_units(gas_scale);
 
                     tx_logs
@@ -523,7 +523,7 @@ where
         let gas_scale = tx_data.tx_gas_meter.get_gas_scale();
         let scaled_gas = tx_data
             .tx_gas_meter
-            .get_tx_consumed_gas()
+            .get_consumed_gas()
             .get_whole_gas_units(gas_scale);
 
         tx_logs
@@ -806,7 +806,7 @@ where
                 &mut self.state,
             );
             let tx_gas_meter = tx_gas_meter.into_inner();
-            let consumed_gas = tx_gas_meter.get_tx_consumed_gas();
+            let consumed_gas = tx_gas_meter.get_consumed_gas();
 
             // save the gas cost
             self.update_tx_gas(tx_hash, consumed_gas);
@@ -880,7 +880,7 @@ where
                 &mut self.state,
             );
             let tx_gas_meter = tx_gas_meter.into_inner();
-            let consumed_gas = tx_gas_meter.get_tx_consumed_gas();
+            let consumed_gas = tx_gas_meter.get_consumed_gas();
 
             // update the gas cost of the corresponding wrapper
             self.update_tx_gas(tx_hash, consumed_gas);

crates/node/src/shell/mod.rs

@@ -42,7 +42,7 @@ use namada_sdk::eth_bridge::protocol::validation::validator_set_update::validate
 use namada_sdk::eth_bridge::{EthBridgeQueries, EthereumOracleConfig};
 use namada_sdk::ethereum_events::EthereumEvent;
 use namada_sdk::events::log::EventLog;
-use namada_sdk::gas::{Gas, TxGasMeter};
+use namada_sdk::gas::{Gas, GasMetering, TxGasMeter};
 use namada_sdk::hash::Hash;
 use namada_sdk::key::*;
 use namada_sdk::migrations::ScheduledMigration;
@@ -1306,7 +1306,7 @@ where
                 let block_gas_limit: Gas =
                     Gas::from_whole_units(max_block_gas.into(), gas_scale)
                         .expect("Gas limit from parameter must not overflow");
-                if gas_meter.tx_gas_limit > block_gas_limit {
+                if gas_meter.get_gas_limit() > block_gas_limit {
                     response.code = ResultCode::AllocationError.into();
                     response.log = format!(
                         "{INVALID_MSG}: Wrapper transaction exceeds the \

crates/node/src/shell/prepare_proposal.rs

@@ -3,7 +3,7 @@
 use std::cell::RefCell;
 
 use namada_sdk::address::Address;
-use namada_sdk::gas::TxGasMeter;
+use namada_sdk::gas::{GasMetering, TxGasMeter};
 use namada_sdk::key::tm_raw_hash_to_string;
 use namada_sdk::parameters::get_gas_scale;
 use namada_sdk::proof_of_stake::storage::find_validator_by_raw_hash;