Struct massa_execution_worker::speculative_ledger::SpeculativeLedger

pub(crate) struct SpeculativeLedger {
    final_state: Arc<RwLock<dyn FinalStateController>>,
    active_history: Arc<RwLock<ActiveHistory>>,
    pub added_changes: LedgerChanges,
    max_datastore_key_length: u8,
    max_datastore_value_size: u64,
    max_bytecode_size: u64,
    storage_costs_constants: StorageCostsConstants,
    transfers_history: Arc<RwLock<Vec<TransferInfo>>>,
}

The SpeculativeLedger contains an thread-safe shared reference to the final ledger (read-only), a list of existing changes that happened o the ledger since its finality, as well as an extra list of “added” changes. The SpeculativeLedger makes it possible to transparently manipulate a virtual ledger that takes into account all those ledger changes and allows adding more while keeping track of all the newly added changes, and never writing in the final ledger.

Fields

final_state: Arc<RwLock<dyn FinalStateController>>

Thread-safe shared access to the final state. For reading only.

active_history: Arc<RwLock<ActiveHistory>>

History of the outputs of recently executed slots. Slots should be consecutive, newest at the back.

added_changes: LedgerChanges

list of ledger changes that were applied to this SpeculativeLedger since its creation

max_datastore_key_length: u8

max datastore key length

max_datastore_value_size: u64

Max datastore value size

max_bytecode_size: u64

Max bytecode size

storage_costs_constants: StorageCostsConstants

storage cost constants

transfers_history: Arc<RwLock<Vec<TransferInfo>>>

Implementations

impl SpeculativeLedger

pub fn new( final_state: Arc<RwLock<dyn FinalStateController>>, active_history: Arc<RwLock<ActiveHistory>>, max_datastore_key_length: u8, max_bytecode_size: u64, max_datastore_value_size: u64, storage_costs_constants: StorageCostsConstants, transfers_history: Arc<RwLock<Vec<TransferInfo>>>, ) -> Self

creates a new SpeculativeLedger

Arguments

• final_state: thread-safe shared access to the final state (for reading only)
• active_history: thread-safe shared access the speculative execution history

pub fn take(&mut self) -> LedgerChanges

Returns the changes caused to the SpeculativeLedger since its creation, and resets their local value to nothing.

pub fn get_snapshot(&self) -> LedgerChanges

Takes a snapshot (clone) of the changes caused to the SpeculativeLedger since its creation

pub fn reset_to_snapshot(&mut self, snapshot: LedgerChanges)

Resets the SpeculativeLedger to a snapshot (see get_snapshot method)

pub fn get_balance(&self, addr: &Address) -> Option<Amount>

Gets the effective balance of an address

Arguments:

addr: the address to query

Returns

Some(Amount) if the address was found, otherwise None

pub fn get_bytecode(&self, addr: &Address) -> Option<Bytecode>

Gets the effective bytecode of an address

Arguments:

addr: the address to query

Returns

Some(Bytecode) if the address was found, otherwise None

pub fn transfer_coins( &mut self, from_addr: Option<Address>, to_addr: Option<Address>, amount: Amount, _context: TransferContext, ) -> Result<(), ExecutionError>

Transfers coins from one address to another. No changes are retained in case of failure. The spending address, if defined, must exist.

Parameters:

• from_addr: optional spending address (use None for pure coin creation)
• to_addr: optional crediting address (use None for pure coin destruction)
• amount: amount of coins to transfer

pub fn entry_exists(&self, addr: &Address) -> bool

Checks if an address exists in the speculative ledger

Arguments:

addr: the address to query

Returns

true if the address was found, otherwise false

pub fn create_new_sc_address( &mut self, creator_address: Address, addr: Address, bytecode: Bytecode, ) -> Result<(), ExecutionError>

Creates a new smart contract address with initial bytecode.

Arguments

• creator_address: address that asked for this creation. Will pay the storage costs.
• addr: address to create
• bytecode: bytecode to set in the new ledger entry

pub fn set_bytecode( &mut self, caller_addr: &Address, addr: &Address, bytecode: Bytecode, ) -> Result<(), ExecutionError>

Sets the bytecode associated to an address in the ledger. Fails if the address doesn’t exist.

Arguments

• caller_addr: address of the caller. Will pay the storage costs.
• addr: target address
• bytecode: bytecode to set for that address

pub fn get_keys( &self, addr: &Address, prefix: &[u8], start_key: Bound<Vec<u8>>, end_key: Bound<Vec<u8>>, count: Option<u32>, ) -> Option<BTreeSet<Vec<u8>>>

Gets a copy of a datastore keys for a given address

Arguments

• addr: address to query
• prefix: prefix to filter keys
• start_key: start key of the range
• end_key: end key of the range
• count: maximum number of keys to return

Returns

Some(Vec<Vec<u8>>) for found keys, None if the address does not exist.

pub fn get_data_entry(&self, addr: &Address, key: &[u8]) -> Option<Vec<u8>>

Gets a copy of a datastore value for a given address and datastore key

Arguments

• addr: address to query
• key: key to query in the address’ datastore

Returns

Some(Vec<u8>) if the value was found, None if the address does not exist or if the key is not in its datastore.

pub fn has_data_entry(&self, addr: &Address, key: &[u8]) -> bool

Checks if a data entry exists for a given address

Arguments

• addr: address to query
• key: datastore key to look for

Returns

true if the key exists in the address datastore, false otherwise

fn get_storage_cost_datastore_entry( &self, key: &[u8], value: &[u8], ) -> Result<Amount, ExecutionError>

Compute the storage costs of a full datastore entry

fn charge_datastore_entry_change_storage( &mut self, caller_addr: &Address, old_key_value: Option<(&[u8], &[u8])>, new_key_value: Option<(&[u8], &[u8])>, ) -> Result<(), ExecutionError>

Charge the storage costs of a datastore entry change, if any.

pub fn set_data_entry( &mut self, caller_addr: &Address, addr: &Address, key: Vec<u8>, value: Vec<u8>, ) -> Result<(), ExecutionError>

Sets a data set entry for a given address in the ledger. Fails if the address doesn’t exist. If the datastore entry does not exist, it is created.

Arguments

• caller_addr: address of the caller. Will pay the storage costs.
• addr: target address
• key: datastore key
• data: value to associate to the datastore key

pub fn delete_data_entry( &mut self, caller_addr: &Address, addr: &Address, key: &[u8], ) -> Result<(), ExecutionError>

Deletes a datastore entry for a given address. Fails if the entry or address does not exist.

Arguments

• caller_addr: address of the caller. Will pay the storage costs.
• addr: address
• key: key of the entry to delete in the address’ datastore