Struct ResourceMeter 

pub struct ResourceMeter<T: Config, S: State> { /* private fields */ }

Resource meter tracking weight and storage deposit consumption.

Implementations

impl<T: Config, S: State> ResourceMeter<T, S>

pub fn new_nested( &self, limit: &CallResources<T>, ) -> Result<FrameMeter<T>, DispatchError>

Create a new nested meter with derived resource limits.

pub fn absorb_weight_meter_only(&mut self, other: FrameMeter<T>)

Absorb only the weight consumption from a nested frame meter.

pub fn absorb_all_meters( &mut self, other: FrameMeter<T>, contract: &T::AccountId, info: Option<&mut ContractInfo<T>>, )

Absorb all resource consumption from a nested frame meter.

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

Charge a weight token against this meter’s remaining weight limit.

Returns Err(Error::OutOfGas) if the weight limit would be exceeded.

pub fn charge_or_halt<Tok: Token<T>>( &mut self, token: Tok, ) -> ControlFlow<Halt, ChargedAmount>

Try to charge a weight token or halt if not enough weight is left.

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

Adjust an earlier weight charge with the actual weight consumed.

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

Synchronize meter state with PolkaVM executor’s fuel consumption.

Maps the VM’s internal fuel accounting to weight consumption:

• Converts engine fuel units to weight units
• Updates meter state to match actual VM resource usage

pub fn sync_to_executor(&mut self) -> Gas

Convert meter state to PolkaVM executor fuel units.

Prepares for VM execution by:

• Computing remaining available weight
• Converting weight units to VM fuel units and return

pub fn consume_all_weight(&mut self)

Consume all remaining weight in the meter.

pub fn charge_deposit( &mut self, deposit: &StorageDeposit<BalanceOf<T>>, ) -> DispatchResult

Record a storage deposit charge against this meter.

pub fn eth_gas_left(&self) -> Option<BalanceOf<T>>

Get remaining ethereum gas equivalent.

Converts remaining resources to ethereum gas units:

• For ethereum mode: computes directly from gas accounting
• For substrate mode: converts weight+deposit to gas equivalent Returns None if resources are exhausted or conversion fails.

pub fn weight_left(&self) -> Option<Weight>

Get remaining weight available.

Computes remaining computational capacity:

• For ethereum mode: converts from gas to weight units
• For substrate mode: subtracts consumed from weight limit Returns None if resources are exhausted.

pub fn deposit_left(&self) -> Option<BalanceOf<T>>

Get remaining deposit available.

Computes remaining storage deposit allowance:

• For ethereum mode: converts from gas to deposit units
• For substrate mode: subtracts consumed from deposit limit Returns None if resources are exhausted.

pub fn total_consumed_gas(&self) -> BalanceOf<T>

Calculate total gas consumed so far.

Computes the ethereum-gas equivalent of all resource usage:

• Converts weight and deposit consumption to gas units
• For ethereum mode: uses direct gas accounting
• For substrate mode: synthesizes from weight+deposit usage

pub fn weight_consumed(&self) -> Weight

Get total weight consumed

pub fn weight_required(&self) -> Weight

Get total weight required This is the maximum amount of weight consumption that occurred during execution so far This is relevant because consumed weight can decrease in case it is asjusted a posteriori for some operations

pub fn deposit_consumed(&self) -> StorageDeposit<BalanceOf<T>>

Get total storage deposit consumed in the current frame.

Returns the net storage deposit change from this frame,

pub fn deposit_required(&self) -> StorageDeposit<BalanceOf<T>>

Get maximum storage deposit required at any point.

Returns the highest deposit amount needed during execution, accounting for temporary storage spikes before later refunds.

pub fn eth_gas_consumed(&self) -> BalanceOf<T>

Get the Ethereum gas that has been consumed during the lifetime of this meter

impl<T: Config> ResourceMeter<T, Root>

pub fn new( transaction_limits: TransactionLimits<T>, ) -> Result<Self, DispatchError>

Create a new transaction-level meter with the specified resource limits.

Initializes either:

• An ethereum-style gas-based meter or
• A substrate-style meter with explicit weight and deposit limits

pub fn new_from_limits( weight_limit: Weight, deposit_limit: BalanceOf<T>, ) -> Result<Self, DispatchError>

Convenience constructor for substrate-style weight+deposit limits.

pub fn execute_postponed_deposits( &mut self, origin: &Origin<T>, exec_config: &ExecConfig<T>, ) -> Result<StorageDeposit<BalanceOf<T>>, DispatchError>

Execute all postponed storage deposit operations.

Returns Err(Error::StorageDepositNotEnoughFunds) if deposit limit would be exceeded.

pub fn terminate( &mut self, contract_account: T::AccountId, refunded: BalanceOf<T>, )

Mark a contract as terminated

This will signal to the meter to discard all charged and refunds incured by this contract. Furthermore it will record that there was a refund of refunded and adapt the total deposit accordingly

impl<T: Config> ResourceMeter<T, Nested>

pub fn charge_contract_deposit_and_transfer( &mut self, contract: T::AccountId, amount: StorageDeposit<BalanceOf<T>>, ) -> DispatchResult

Record a contract’s storage deposit and schedule the transfer.

Updates the frame’s deposit accounting and schedules the actual token transfer for later execution – at the end of the transaction execution.

pub fn record_contract_storage_changes(&mut self, diff: &Diff) -> DispatchResult

Record storage changes of a contract.

pub fn finalize(&mut self, info: Option<&mut ContractInfo<T>>) -> DispatchResult

Self::charge_contract_deposit_and_transfer and Self::record_contract_storage_changes does not enforce the storage limit since we want to do this check as late as possible to allow later refunds to offset earlier charges.

Trait Implementations

impl<T: Config, S: State> Default for ResourceMeter<T, S>

fn default() -> Self

Returns the “default value” for a type.