evmc::MockedHost Class Reference

Mocked EVMC Host implementation. More...

#include <mocked_host.hpp>

Inheritance diagram for evmc::MockedHost:

Classes
struct	log_record
	LOG record. More...

Public Member Functions
bool	account_exists (const address &addr) const noexcept override
	Returns true if an account exists (EVMC Host method).
bytes32	get_storage (const address &addr, const bytes32 &key) const noexcept override
	Get the account's storage value at the given key (EVMC Host method).
evmc_storage_status	set_storage (const address &addr, const bytes32 &key, const bytes32 &value) noexcept override
	Set the account's storage value (EVMC Host method).
uint256be	get_balance (const address &addr) const noexcept override
	Get the account's balance (EVMC Host method).
size_t	get_code_size (const address &addr) const noexcept override
	Get the account's code size (EVMC host method).
bytes32	get_code_hash (const address &addr) const noexcept override
	Get the account's code hash (EVMC host method).
size_t	copy_code (const address &addr, size_t code_offset, uint8_t *buffer_data, size_t buffer_size) const noexcept override
	Copy the account's code to the given buffer (EVMC host method).
bool	selfdestruct (const address &addr, const address &beneficiary) noexcept override
	Selfdestruct the account (EVMC host method).
Result	call (const evmc_message &msg) noexcept override
	Call/create other contract (EVMC host method).
evmc_tx_context	get_tx_context () const noexcept override
	Get transaction context (EVMC host method).
bytes32	get_block_hash (int64_t block_number) const noexcept override
	Get the block header hash (EVMC host method).
void	emit_log (const address &addr, const uint8_t *data, size_t data_size, const bytes32 topics[], size_t topics_count) noexcept override
	Emit LOG (EVMC host method).
evmc_access_status	access_account (const address &addr) noexcept override
	Record an account access.
evmc_access_status	access_storage (const address &addr, const bytes32 &key) noexcept override
	Access the account's storage value at the given key.
bytes32	get_transient_storage (const address &addr, const bytes32 &key) const noexcept override
	Get account's transient storage.
void	set_transient_storage (const address &addr, const bytes32 &key, const bytes32 &value) noexcept override
	Set account's transient storage.
Public Member Functions inherited from evmc::Host
evmc_host_context *	to_context () noexcept
	Converts the Host object to the opaque host context pointer.
virtual bool	account_exists (const address &addr) const noexcept=0
	Check account existence callback function.
virtual bytes32	get_storage (const address &addr, const bytes32 &key) const noexcept=0
	Get storage callback function.
virtual evmc_storage_status	set_storage (const address &addr, const bytes32 &key, const bytes32 &value) noexcept=0
	Set storage callback function.
virtual uint256be	get_balance (const address &addr) const noexcept=0
	Get balance callback function.
virtual size_t	get_code_size (const address &addr) const noexcept=0
	Get code size callback function.
virtual bytes32	get_code_hash (const address &addr) const noexcept=0
	Get code hash callback function.
virtual size_t	copy_code (const address &addr, size_t code_offset, uint8_t *buffer_data, size_t buffer_size) const noexcept=0
	Copy code callback function.
virtual bool	selfdestruct (const address &addr, const address &beneficiary) noexcept=0
	Selfdestruct callback function.
virtual Result	call (const evmc_message &msg) noexcept=0
	Call callback function.
virtual evmc_tx_context	get_tx_context () const noexcept=0
	Get transaction context callback function.
virtual bytes32	get_block_hash (int64_t block_number) const noexcept=0
	Get block hash callback function.
virtual void	emit_log (const address &addr, const uint8_t *data, size_t data_size, const bytes32 topics[], size_t num_topics) noexcept=0
	Emit log callback function.
virtual evmc_access_status	access_account (const address &addr) noexcept=0
	Access account callback function.
virtual evmc_access_status	access_storage (const address &addr, const bytes32 &key) noexcept=0
	Access storage callback function.
virtual bytes32	get_transient_storage (const address &addr, const bytes32 &key) const noexcept=0
	Get transient storage callback function.
virtual void	set_transient_storage (const address &addr, const bytes32 &key, const bytes32 &value) noexcept=0
	Set transient storage callback function.

Public Attributes
std::unordered_map< address, MockedAccount >	accounts
	The set of all accounts in the Host, organized by their addresses.
evmc_tx_context	tx_context = {}
	The EVMC transaction context to be returned by get_tx_context().
bytes32	block_hash = {}
	The block header hash value to be returned by get_block_hash().
evmc_result	call_result = {}
	The call result to be returned by the call() method.
std::vector< int64_t >	recorded_blockhashes
	The record of all block numbers for which get_block_hash() was called.
std::vector< address >	recorded_account_accesses
	The record of all account accesses.
std::vector< evmc_message >	recorded_calls
	The record of all call messages requested in the call() method.
std::vector< log_record >	recorded_logs
	The record of all LOGs passed to the emit_log() method.
std::unordered_map< address, std::vector< address > >	recorded_selfdestructs
	The record of all SELFDESTRUCTs from the selfdestruct() method as a map selfdestructed_address => [beneficiary1, beneficiary2, ...].

Static Public Attributes
static constexpr auto	max_recorded_account_accesses = 200
	The maximum number of entries in recorded_account_accesses record.
static constexpr auto	max_recorded_calls = 100
	The maximum number of entries in recorded_calls record.

Additional Inherited Members
Static Public Member Functions inherited from evmc::Host
static const evmc_host_interface &	get_interface () noexcept
	Provides access to the global host interface.
template<typename DerivedClass = Host>
static DerivedClass *	from_context (evmc_host_context *context) noexcept
	Converts the opaque host context pointer back to the original Host object.

Detailed Description

Mocked EVMC Host implementation.

Definition at line 75 of file mocked_host.hpp.

Member Function Documentation

access_account()

evmc_access_status evmc::MockedHost::access_account ( const address &  addr )

inlineoverridevirtualnoexcept

Record an account access.

This method is required by EIP-2929 introduced in EVMC_BERLIN. It will record the account access in MockedHost::recorded_account_accesses and return previous access status. This methods returns EVMC_ACCESS_WARM for known addresses of precompiles. The EIP-2929 specifies that evmc_message::sender and evmc_message::recipient are always EVMC_ACCESS_WARM. Therefore, you should init the MockedHost with:

mocked_host.access_account(msg.sender);
mocked_host.access_account(msg.recipient);

The same way you can mock transaction access list (EIP-2930) for account addresses.

Parameters

addr	The address of the accessed account.

Returns

The EVMC_ACCESS_WARM if the account has been accessed before, the EVMC_ACCESS_COLD otherwise.

Implements evmc::HostInterface.

Definition at line 440 of file mocked_host.hpp.

 {
 // Check if the address have been already accessed.
 const auto already_accessed =
 std::find(recorded_account_accesses.begin(), recorded_account_accesses.end(), addr) !=
 recorded_account_accesses.end();
 
 record_account_access(addr);
 
 // Accessing precompiled contracts is always warm.
 if (addr >= 0x0000000000000000000000000000000000000001_address &&
 addr <= 0x0000000000000000000000000000000000000009_address)
 return EVMC_ACCESS_WARM;
 
 return already_accessed ? EVMC_ACCESS_WARM : EVMC_ACCESS_COLD;
 }

access_storage()

evmc_access_status evmc::MockedHost::access_storage ( const address &  addr, const bytes32 &  key  )

inlineoverridevirtualnoexcept

Access the account's storage value at the given key.

This method is required by EIP-2929 introduced in EVMC_BERLIN. In records that the given account's storage key has been access and returns the previous access status. To mock storage access list (EIP-2930), you can pre-init account's storage values with the EVMC_ACCESS_WARM flag:

mocked_host.accounts[msg.recipient].storage[key] = {value,
EVMC_ACCESS_WARM};

Parameters

addr	The account address.
key	The account's storage key.

Returns

The EVMC_ACCESS_WARM if the storage key has been accessed before, the EVMC_ACCESS_COLD otherwise.

Implements evmc::HostInterface.

Definition at line 471 of file mocked_host.hpp.

 {
 auto& value = accounts[addr].storage[key];
 const auto access_status = value.access_status;
 value.access_status = EVMC_ACCESS_WARM;
 return access_status;
 }

account_exists()

bool evmc::MockedHost::account_exists ( const address &  addr ) const

inlineoverridevirtualnoexcept

Returns true if an account exists (EVMC Host method).

Implements evmc::HostInterface.

Definition at line 150 of file mocked_host.hpp.

 {
 record_account_access(addr);
 return accounts.count(addr) != 0;
 }

call()

Result evmc::MockedHost::call ( const evmc_message &  msg )

inlineoverridevirtualnoexcept

Call/create other contract (EVMC host method).

Implements evmc::HostInterface.

Definition at line 380 of file mocked_host.hpp.

 {
 record_account_access(msg.recipient);
 
 if (recorded_calls.empty())
 {
 recorded_calls.reserve(max_recorded_calls);
 m_recorded_calls_inputs.reserve(max_recorded_calls); // Iterators will not invalidate.
 }
 
 if (recorded_calls.size() < max_recorded_calls)
 {
 recorded_calls.emplace_back(msg);
 auto& call_msg = recorded_calls.back();
 if (call_msg.input_size > 0)
 {
 m_recorded_calls_inputs.emplace_back(call_msg.input_data, call_msg.input_size);
 const auto& input_copy = m_recorded_calls_inputs.back();
 call_msg.input_data = input_copy.data();
 }
 }
 return Result{call_result};
 }

copy_code()

size_t evmc::MockedHost::copy_code ( const address &  addr, size_t  code_offset, uint8_t *  buffer_data, size_t  buffer_size  ) const

inlineoverridevirtualnoexcept

Copy the account's code to the given buffer (EVMC host method).

Implements evmc::HostInterface.

Definition at line 348 of file mocked_host.hpp.

 {
 record_account_access(addr);
 const auto it = accounts.find(addr);
 if (it == accounts.end())
 return 0;
 
 const auto& code = it->second.code;
 
 if (code_offset >= code.size())
 return 0;
 
 const auto n = std::min(buffer_size, code.size() - code_offset);
 
 if (n > 0)
 std::copy_n(&code[code_offset], n, buffer_data);
 return n;
 }

emit_log()

void evmc::MockedHost::emit_log ( const address &  addr, const uint8_t *  data, size_t  data_size, const bytes32  topics[], size_t  topics_count  )

inlineoverridevirtualnoexcept

Emit LOG (EVMC host method).

Implements evmc::HostInterface.

Definition at line 415 of file mocked_host.hpp.

 {
 recorded_logs.push_back({addr, {data, data_size}, {topics, topics + topics_count}});
 }

get_balance()

uint256be evmc::MockedHost::get_balance ( const address &  addr ) const

inlineoverridevirtualnoexcept

Get the account's balance (EVMC Host method).

Implements evmc::HostInterface.

Definition at line 317 of file mocked_host.hpp.

 {
 record_account_access(addr);
 const auto it = accounts.find(addr);
 if (it == accounts.end())
 return {};
 
 return it->second.balance;
 }

get_block_hash()

bytes32 evmc::MockedHost::get_block_hash ( int64_t  block_number ) const

inlineoverridevirtualnoexcept

Get the block header hash (EVMC host method).

Implements evmc::HostInterface.

Definition at line 408 of file mocked_host.hpp.

 {
 recorded_blockhashes.emplace_back(block_number);
 return block_hash;
 }

get_code_hash()

bytes32 evmc::MockedHost::get_code_hash ( const address &  addr ) const

inlineoverridevirtualnoexcept

Get the account's code hash (EVMC host method).

Implements evmc::HostInterface.

Definition at line 338 of file mocked_host.hpp.

 {
 record_account_access(addr);
 const auto it = accounts.find(addr);
 if (it == accounts.end())
 return {};
 return it->second.codehash;
 }

get_code_size()

size_t evmc::MockedHost::get_code_size ( const address &  addr ) const

inlineoverridevirtualnoexcept

Get the account's code size (EVMC host method).

Implements evmc::HostInterface.

Definition at line 328 of file mocked_host.hpp.

 {
 record_account_access(addr);
 const auto it = accounts.find(addr);
 if (it == accounts.end())
 return 0;
 return it->second.code.size();
 }

get_storage()

bytes32 evmc::MockedHost::get_storage ( const address &  addr, const bytes32 &  key  ) const

inlineoverridevirtualnoexcept

Get the account's storage value at the given key (EVMC Host method).

Implements evmc::HostInterface.

Definition at line 157 of file mocked_host.hpp.

 {
 record_account_access(addr);
 
 const auto account_iter = accounts.find(addr);
 if (account_iter == accounts.end())
 return {};
 
 const auto storage_iter = account_iter->second.storage.find(key);
 if (storage_iter != account_iter->second.storage.end())
 return storage_iter->second.current;
 return {};
 }

get_transient_storage()

bytes32 evmc::MockedHost::get_transient_storage ( const address &  addr, const bytes32 &  key  ) const

inlineoverridevirtualnoexcept

Get account's transient storage.

Parameters

addr	The account address.
key	The account's transient storage key.

Returns

The transient storage value. Null value in case the account does not exist.

Implements evmc::HostInterface.

Definition at line 484 of file mocked_host.hpp.

 {
 record_account_access(addr);
 
 const auto account_iter = accounts.find(addr);
 if (account_iter == accounts.end())
 return {};
 
 const auto storage_iter = account_iter->second.transient_storage.find(key);
 if (storage_iter != account_iter->second.transient_storage.end())
 return storage_iter->second;
 return {};
 }

get_tx_context()

evmc_tx_context evmc::MockedHost::get_tx_context ( ) const

inlineoverridevirtualnoexcept

Get transaction context (EVMC host method).

Implements evmc::HostInterface.

Definition at line 405 of file mocked_host.hpp.

{ return tx_context; }

selfdestruct()

bool evmc::MockedHost::selfdestruct ( const address &  addr, const address &  beneficiary  )

inlineoverridevirtualnoexcept

Selfdestruct the account (EVMC host method).

Implements evmc::HostInterface.

Definition at line 371 of file mocked_host.hpp.

 {
 record_account_access(addr);
 auto& beneficiaries = recorded_selfdestructs[addr];
 beneficiaries.emplace_back(beneficiary);
 return beneficiaries.size() == 1;
 }

set_storage()

evmc_storage_status evmc::MockedHost::set_storage ( const address &  addr, const bytes32 &  key, const bytes32 &  value  )

inlineoverridevirtualnoexcept

Set the account's storage value (EVMC Host method).

Implements evmc::HostInterface.

Definition at line 172 of file mocked_host.hpp.

 {
 record_account_access(addr);
 
 // Get the reference to the storage entry value.
 // This will create the account in case it was not present.
 // This is convenient for unit testing and standalone EVM execution to preserve the
 // storage values after the execution terminates.
 auto& s = accounts[addr].storage[key];
 
 // Follow the EIP-2200 specification as closely as possible.
 // https://eips.ethereum.org/EIPS/eip-2200
 // Warning: this is not the most efficient implementation. The storage status can be
 // figured out by combining only 4 checks:
 // - original != current (dirty)
 // - original == value (restored)
 // - current != 0
 // - value != 0
 const auto status = [&original = s.original, &current = s.current, &value]() {
 // Clause 1 is irrelevant:
 // 1. "If gasleft is less than or equal to gas stipend,
 // fail the current call frame with ‘out of gas’ exception"
 
 // 2. "If current value equals new value (this is a no-op)"
 if (current == value)
 {
 // "SLOAD_GAS is deducted"
 return EVMC_STORAGE_ASSIGNED;
 }
 // 3. "If current value does not equal new value"
 else
 {
 // 3.1. "If original value equals current value
 // (this storage slot has not been changed by the current execution context)"
 if (original == current)
 {
 // 3.1.1 "If original value is 0"
 if (is_zero(original))
 {
 // "SSTORE_SET_GAS is deducted"
 return EVMC_STORAGE_ADDED;
 }
 // 3.1.2 "Otherwise"
 else
 {
 // "SSTORE_RESET_GAS gas is deducted"
 auto st = EVMC_STORAGE_MODIFIED;
 
 // "If new value is 0"
 if (is_zero(value))
 {
 // "add SSTORE_CLEARS_SCHEDULE gas to refund counter"
 st = EVMC_STORAGE_DELETED;
 }
 
 return st;
 }
 }
 // 3.2. "If original value does not equal current value
 // (this storage slot is dirty),
 // SLOAD_GAS gas is deducted.
 // Apply both of the following clauses."
 else
 {
 // Because we need to apply "both following clauses"
 // we first collect information which clause is triggered
 // then assign status code to combination of these clauses.
 enum
 {
 None = 0,
 RemoveClearsSchedule = 1 << 0,
 AddClearsSchedule = 1 << 1,
 RestoredBySet = 1 << 2,
 RestoredByReset = 1 << 3,
 };
 int triggered_clauses = None;
 
 // 3.2.1. "If original value is not 0"
 if (!is_zero(original))
 {
 // 3.2.1.1. "If current value is 0"
 if (is_zero(current))
 {
 // "(also means that new value is not 0)"
 assert(!is_zero(value));
 // "remove SSTORE_CLEARS_SCHEDULE gas from refund counter"
 triggered_clauses |= RemoveClearsSchedule;
 }
 // 3.2.1.2. "If new value is 0"
 if (is_zero(value))
 {
 // "(also means that current value is not 0)"
 assert(!is_zero(current));
 // "add SSTORE_CLEARS_SCHEDULE gas to refund counter"
 triggered_clauses |= AddClearsSchedule;
 }
 }
 
 // 3.2.2. "If original value equals new value (this storage slot is reset)"
 // Except: we use term 'storage slot restored'.
 if (original == value)
 {
 // 3.2.2.1. "If original value is 0"
 if (is_zero(original))
 {
 // "add SSTORE_SET_GAS - SLOAD_GAS to refund counter"
 triggered_clauses |= RestoredBySet;
 }
 // 3.2.2.2. "Otherwise"
 else
 {
 // "add SSTORE_RESET_GAS - SLOAD_GAS gas to refund counter"
 triggered_clauses |= RestoredByReset;
 }
 }
 
 switch (triggered_clauses)
 {
 case RemoveClearsSchedule:
 return EVMC_STORAGE_DELETED_ADDED;
 case AddClearsSchedule:
 return EVMC_STORAGE_MODIFIED_DELETED;
 case RemoveClearsSchedule | RestoredByReset:
 return EVMC_STORAGE_DELETED_RESTORED;
 case RestoredBySet:
 return EVMC_STORAGE_ADDED_DELETED;
 case RestoredByReset:
 return EVMC_STORAGE_MODIFIED_RESTORED;
 case None:
 return EVMC_STORAGE_ASSIGNED;
 default:
 assert(false); // Other combinations are impossible.
 return evmc_storage_status{};
 }
 }
 }
 }();
 
 s.current = value; // Finally update the current storage value.
 return status;
 }

set_transient_storage()

void evmc::MockedHost::set_transient_storage ( const address &  addr, const bytes32 &  key, const bytes32 &  value  )

inlineoverridevirtualnoexcept

Set account's transient storage.

Parameters

addr	The account address.
key	The account's transient storage key.
value	The value to be stored.

Implements evmc::HostInterface.

Definition at line 503 of file mocked_host.hpp.

 {
 record_account_access(addr);
 accounts[addr].transient_storage[key] = value;
 }

Member Data Documentation

accounts

std::unordered_map<address, MockedAccount> evmc::MockedHost::accounts

The set of all accounts in the Host, organized by their addresses.

Definition at line 98 of file mocked_host.hpp.

block_hash

bytes32 evmc::MockedHost::block_hash = {}

The block header hash value to be returned by get_block_hash().

Definition at line 104 of file mocked_host.hpp.

call_result

evmc_result evmc::MockedHost::call_result = {}

The call result to be returned by the call() method.

Definition at line 107 of file mocked_host.hpp.

max_recorded_account_accesses

constexpr auto evmc::MockedHost::max_recorded_account_accesses = 200

staticconstexpr

The maximum number of entries in recorded_account_accesses record.

This is arbitrary value useful in fuzzing when we don't want the record to explode.

Definition at line 117 of file mocked_host.hpp.

max_recorded_calls

constexpr auto evmc::MockedHost::max_recorded_calls = 100

staticconstexpr

The maximum number of entries in recorded_calls record.

This is arbitrary value useful in fuzzing when we don't want the record to explode.

Definition at line 124 of file mocked_host.hpp.

recorded_account_accesses

std::vector<address> evmc::MockedHost::recorded_account_accesses

mutable

The record of all account accesses.

Definition at line 113 of file mocked_host.hpp.

recorded_blockhashes

std::vector<int64_t> evmc::MockedHost::recorded_blockhashes

mutable

The record of all block numbers for which get_block_hash() was called.

Definition at line 110 of file mocked_host.hpp.

recorded_calls

std::vector<evmc_message> evmc::MockedHost::recorded_calls

The record of all call messages requested in the call() method.

Definition at line 120 of file mocked_host.hpp.

recorded_logs

std::vector<log_record> evmc::MockedHost::recorded_logs

The record of all LOGs passed to the emit_log() method.

Definition at line 127 of file mocked_host.hpp.

recorded_selfdestructs

std::unordered_map<address, std::vector<address> > evmc::MockedHost::recorded_selfdestructs

The record of all SELFDESTRUCTs from the selfdestruct() method as a map selfdestructed_address => [beneficiary1, beneficiary2, ...].

Definition at line 131 of file mocked_host.hpp.

tx_context

evmc_tx_context evmc::MockedHost::tx_context = {}

The EVMC transaction context to be returned by get_tx_context().

Definition at line 101 of file mocked_host.hpp.

---

The documentation for this class was generated from the following file:

• include/evmc/mocked_host.hpp