Struct GasMeter

pub struct GasMeter<T: Config> { /* private fields */ }

Implementations

impl<T: Config> GasMeter<T>

pub fn new(gas_limit: Weight) -> Self

pub fn nested_take_all(&mut self) -> Self

Create a new gas meter by removing all the gas from the current meter.

This should only be used by the primordial frame in a sequence of calls - every subsequent frame should use nested.

pub fn nested(&mut self, amount: Weight) -> Self

Create a new gas meter for a nested call by removing gas from the current meter.

pub fn absorb_nested(&mut self, nested: Self)

Absorb the remaining gas of a nested meter after we are done using it.

pub fn charge<Tok: Token<T>>( &mut self, token: Tok, ) -> Result<ChargedAmount, DispatchError>

Account for used gas.

Amount is calculated by the given token.

Returns OutOfGas if there is not enough gas or addition of the specified amount of gas has lead to overflow.

NOTE that amount isn’t consumed if there is not enough gas. This is considered safe because we always charge gas before performing any resource-spending action.

pub fn charge_evm_gas(&mut self, gas: u64) -> Result<(), DispatchError>

Charge the specified amount of EVM gas. This is used for basic opcodes (e.g arithmetic, bitwise, …) that don’t have a dedicated benchmark

pub fn adjust_gas<Tok: Token<T>>( &mut self, charged_amount: ChargedAmount, token: Tok, )

Adjust a previously charged amount down to its actual amount.

This is when a maximum a priori amount was charged and then should be partially refunded to match the actual amount.

pub fn sync_from_executor( &mut self, engine_fuel: Gas, ) -> Result<RefTimeLeft, DispatchError>

Hand over the gas metering responsibility from the executor to this meter.

Needs to be called when entering a host function to update this meter with the gas that was tracked by the executor. It tracks the latest seen total value in order to compute the delta that needs to be charged.

pub fn sync_to_executor( &mut self, before: RefTimeLeft, ) -> Result<Syncable, DispatchError>

Hand over the gas metering responsibility from this meter to the executor.

Needs to be called when leaving a host function in order to calculate how much gas needs to be charged from the executor. It updates the last seen executor total value so that it is correct when sync_from_executor is called the next time.

It is important that this does not actually sync with the executor. That has to be done by the caller.

pub fn gas_required(&self) -> Weight

Returns the amount of gas that is required to run the same call.

This can be different from gas_spent because due to adjust_gas the amount of spent gas can temporarily drop and be refunded later.

pub fn gas_consumed(&self) -> Weight

Returns how much gas was spent

pub fn gas_left(&self) -> Weight

Returns how much gas left from the initial budget.

pub fn engine_fuel_left(&self) -> Result<Gas, DispatchError>

The amount of gas in terms of engine gas.

pub fn into_dispatch_result<R, E>( self, result: Result<R, E>, base_weight: Weight, ) -> DispatchResultWithPostInfo

where E: Into<ExecError>,

Turn this GasMeter into a DispatchResult that contains the actually used gas.

pub fn consume_all(&mut self)

Trait Implementations

impl<T: Config> Default for GasMeter<T>

fn default() -> Self

Returns the “default value” for a type.