evmc Namespace Reference

EVMC C++ API - wrappers and bindings for C++. More...

Classes
struct	address
	The big-endian 160-bit hash suitable for keeping an Ethereum address. More...
struct	bytes32
	The fixed size array of 32 bytes for storing 256-bit EVM values. More...
struct	filter_iterator
	The filter iterator adaptor creates a view of an iterator range in which some elements of the range are skipped. More...
class	Host
	Abstract class to be used by Host implementations. More...
class	HostContext
	Wrapper around EVMC host context / host interface. More...
class	HostInterface
	The EVMC Host interface. More...
struct	MockedAccount
	Mocked account. More...
class	MockedHost
	Mocked EVMC Host implementation. More...
class	Result
	The EVM code execution result. More...
struct	skip_space_iterator
	The input filter iterator which skips whitespace characters from the base input iterator. More...
struct	StorageValue
	Extended value (with original value and access flag) for account storage. More...
class	VM
	The VM instance. More...

Typedefs
using	bytes_view = std::basic_string_view< uint8_t >
	String view of uint8_t chars. More...
using	uint256be = bytes32
	The alias for evmc::bytes32 to represent a big-endian 256-bit integer. More...
using	bytes = std::basic_string< uint8_t >
	String of uint8_t chars. More...

Functions
constexpr uint64_t	load64be (const uint8_t *data) noexcept
	Loads 64 bits / 8 bytes of data from the given data array in big-endian order. More...
constexpr uint64_t	load64le (const uint8_t *data) noexcept
	Loads 64 bits / 8 bytes of data from the given data array in little-endian order. More...
constexpr uint32_t	load32be (const uint8_t *data) noexcept
	Loads 32 bits / 4 bytes of data from the given data array in big-endian order. More...
constexpr uint32_t	load32le (const uint8_t *data) noexcept
	Loads 32 bits / 4 bytes of data from the given data array in little-endian order. More...
constexpr bool	operator== (const address &a, const address &b) noexcept
	The "equal to" comparison operator for the evmc::address type. More...
constexpr bool	operator!= (const address &a, const address &b) noexcept
	The "not equal to" comparison operator for the evmc::address type. More...
constexpr bool	operator< (const address &a, const address &b) noexcept
	The "less than" comparison operator for the evmc::address type. More...
constexpr bool	operator> (const address &a, const address &b) noexcept
	The "greater than" comparison operator for the evmc::address type. More...
constexpr bool	operator<= (const address &a, const address &b) noexcept
	The "less than or equal to" comparison operator for the evmc::address type. More...
constexpr bool	operator>= (const address &a, const address &b) noexcept
	The "greater than or equal to" comparison operator for the evmc::address type. More...
constexpr bool	operator== (const bytes32 &a, const bytes32 &b) noexcept
	The "equal to" comparison operator for the evmc::bytes32 type. More...
constexpr bool	operator!= (const bytes32 &a, const bytes32 &b) noexcept
	The "not equal to" comparison operator for the evmc::bytes32 type. More...
constexpr bool	operator< (const bytes32 &a, const bytes32 &b) noexcept
	The "less than" comparison operator for the evmc::bytes32 type. More...
constexpr bool	operator> (const bytes32 &a, const bytes32 &b) noexcept
	The "greater than" comparison operator for the evmc::bytes32 type. More...
constexpr bool	operator<= (const bytes32 &a, const bytes32 &b) noexcept
	The "less than or equal to" comparison operator for the evmc::bytes32 type. More...
constexpr bool	operator>= (const bytes32 &a, const bytes32 &b) noexcept
	The "greater than or equal to" comparison operator for the evmc::bytes32 type. More...
constexpr bool	is_zero (const address &a) noexcept
	Checks if the given address is the zero address. More...
constexpr bool	is_zero (const bytes32 &a) noexcept
	Checks if the given bytes32 object has all zero bytes. More...
const char *	to_string (evmc_status_code status_code) noexcept
	Returns text representation of the evmc_status_code. More...
const char *	to_string (evmc_revision rev) noexcept
	Returns the name of the evmc_revision. More...
constexpr bool	isspace (char ch) noexcept
	The constexpr variant of std::isspace(). More...
constexpr bool	is_not_space (char ch) noexcept
	Checks if a character is not a white space. More...
template<typename BaseIterator >
	skip_space_iterator (BaseIterator, BaseIterator) -> skip_space_iterator< BaseIterator >
	Class template argument deduction guide.
std::string	hex (uint8_t b) noexcept
	Encode a byte to a hex string. More...
std::string	hex (bytes_view bs)
	Encodes bytes as hex string. More...
template<typename InputIt , typename OutputIt >
constexpr bool	from_hex (InputIt begin, InputIt end, OutputIt out) noexcept
	Decodes hex-encoded sequence of characters. More...
bool	validate_hex (std::string_view hex) noexcept
	Validates hex encoded string. More...
std::optional< bytes >	from_hex (std::string_view hex)
	Decodes hex encoded string to bytes. More...
template<typename T >
constexpr std::optional< T >	from_hex (std::string_view s) noexcept
	Decodes hex-encoded string into custom type T with .bytes array of uint8_t. More...
template<typename InputIterator >
std::optional< bytes >	from_spaced_hex (InputIterator begin, InputIterator end) noexcept
	Decodes hex encoded string to bytes. More...
std::optional< bytes >	from_spaced_hex (std::string_view hex) noexcept
	Decodes hex encoded string to bytes. More...

Variables
constexpr auto	make_result = evmc_make_result
	Alias for evmc_make_result(). More...

Detailed Description

EVMC C++ API - wrappers and bindings for C++.

Typedef Documentation

bytes

typedef std::basic_string< uint8_t > evmc::bytes

String of uint8_t chars.

The string of bytes.

Definition at line 15 of file hex.hpp.

bytes_view

typedef std::basic_string_view< uint8_t > evmc::bytes_view

String view of uint8_t chars.

Definition at line 24 of file evmc.hpp.

uint256be

using evmc::uint256be = typedef bytes32

The alias for evmc::bytes32 to represent a big-endian 256-bit integer.

Definition at line 127 of file evmc.hpp.

Function Documentation

from_hex() [1/3]

template<typename InputIt , typename OutputIt >

constexpr bool evmc::from_hex ( InputIt  begin, InputIt  end, OutputIt  out  )

inlineconstexprnoexcept

Decodes hex-encoded sequence of characters.

It is guaranteed that the output will not be longer than half of the input length.

Parameters

begin	The input begin iterator. It only must satisfy input iterator concept.
end	The input end iterator. It only must satisfy input iterator concept.
out	The output iterator. It must satisfy output iterator concept.

Returns

True if successful, false if input is invalid hex.

Definition at line 64 of file hex.hpp.

{
 int hi_nibble = -1; // Init with invalid value, should never be used.
 size_t i = 0;
 for (auto it = begin; it != end; ++it, ++i)
 {
 const auto h = *it;
 const int v = evmc::internal::from_hex_digit(h);
 if (v < 0)
 {
 if (i == 1 && hi_nibble == 0 && h == 'x') // 0x prefix
 continue;
 return false;
 }
 
 if (i % 2 == 0)
 hi_nibble = v << 4;
 else
 *out++ = static_cast<uint8_t>(hi_nibble | v);
 }
 
 return i % 2 == 0;
}

from_hex() [2/3]

std::optional< bytes > evmc::from_hex ( std::string_view  hex )

inline

Decodes hex encoded string to bytes.

In case the input is invalid the returned value is std::nullopt. This can happen if a non-hex digit or odd number of digits is encountered.

Definition at line 107 of file hex.hpp.

{
 bytes bs;
 bs.reserve(hex.size() / 2);
 if (!from_hex(hex.begin(), hex.end(), std::back_inserter(bs)))
 return {};
 return bs;
}

from_hex() [3/3]

template<typename T >

constexpr std::optional< T > evmc::from_hex ( std::string_view  s )

constexprnoexcept

Decodes hex-encoded string into custom type T with .bytes array of uint8_t.

When the input is smaller than the result type, the result is padded with zeros on the left (the result bytes of lowest indices are filled with zeros). TODO: Support optional left alignment.

Definition at line 122 of file hex.hpp.

{
 // Omit the optional 0x prefix.
 if (s.size() >= 2 && s[0] == '0' && s[1] == 'x')
 s.remove_prefix(2);
 
 T r{}; // The T must have .bytes array. This may be lifted if std::bit_cast is available.
 constexpr auto num_out_bytes = std::size(r.bytes);
 const auto num_in_bytes = s.length() / 2;
 if (num_in_bytes > num_out_bytes)
 return {};
 if (!from_hex(s.begin(), s.end(), &r.bytes[num_out_bytes - num_in_bytes]))
 return {};
 return r;
}

from_spaced_hex() [1/2]

template<typename InputIterator >

std::optional< bytes > evmc::from_spaced_hex ( InputIterator  begin, InputIterator  end  )

noexcept

Decodes hex encoded string to bytes.

The whitespace in the input is ignored.

In case the input is invalid the returned value is std::nullopt. This can happen if a non-hex digit or odd number of digits is encountered. The whitespace (as defined by std::isspace) in the input is ignored.

Definition at line 144 of file hex.hpp.

{
 bytes bs;
 if (!from_hex(skip_space_iterator{begin, end}, skip_space_iterator{end, end},
 std::back_inserter(bs)))
 return {};
 return bs;
}

from_spaced_hex() [2/2]

std::optional< bytes > evmc::from_spaced_hex ( std::string_view  hex )

inlinenoexcept

Decodes hex encoded string to bytes.

The whitespace in the input is ignored.

In case the input is invalid the returned value is std::nullopt. This can happen if a non-hex digit or odd number of digits is encountered. The whitespace (as defined by std::isspace) in the input is ignored.

Definition at line 154 of file hex.hpp.

{
 return from_spaced_hex(hex.begin(), hex.end());
}

hex() [1/2]

std::string evmc::hex ( bytes_view  bs )

inline

Encodes bytes as hex string.

Definition at line 29 of file hex.hpp.

{
 std::string str;
 str.reserve(bs.size() * 2);
 for (const auto b : bs)
 str += hex(b);
 return str;
}

hex() [2/2]

std::string evmc::hex ( uint8_t  b )

inlinenoexcept

Encode a byte to a hex string.

Definition at line 22 of file hex.hpp.

{
 static constexpr auto hex_digits = "0123456789abcdef";
 return {hex_digits[b >> 4], hex_digits[b & 0xf]};
}

is_not_space()

constexpr bool evmc::is_not_space ( char  ch )

inlineconstexprnoexcept

Checks if a character is not a white space.

Definition at line 18 of file filter_iterator.hpp.

{
 return !isspace(ch);
}

is_zero() [1/2]

constexpr bool evmc::is_zero ( const address &  a )

inlineconstexprnoexcept

Checks if the given address is the zero address.

Definition at line 261 of file evmc.hpp.

{
 return a == address{};
}

is_zero() [2/2]

constexpr bool evmc::is_zero ( const bytes32 &  a )

inlineconstexprnoexcept

Checks if the given bytes32 object has all zero bytes.

Definition at line 272 of file evmc.hpp.

{
 return a == bytes32{};
}

isspace()

constexpr bool evmc::isspace ( char  ch )

inlineconstexprnoexcept

The constexpr variant of std::isspace().

Definition at line 11 of file filter_iterator.hpp.

{
 // Implementation taken from LLVM's libc.
 return ch == ' ' || (static_cast<unsigned>(ch) - '\t') < 5;
}

load32be()

constexpr uint32_t evmc::load32be ( const uint8_t *  data )

inlineconstexprnoexcept

Loads 32 bits / 4 bytes of data from the given data array in big-endian order.

Definition at line 147 of file evmc.hpp.

{
 return (uint32_t{data[0]} << 24) | (uint32_t{data[1]} << 16) | (uint32_t{data[2]} << 8) |
 uint32_t{data[3]};
}

load32le()

constexpr uint32_t evmc::load32le ( const uint8_t *  data )

inlineconstexprnoexcept

Loads 32 bits / 4 bytes of data from the given data array in little-endian order.

Definition at line 154 of file evmc.hpp.

{
 return uint32_t{data[0]} | (uint32_t{data[1]} << 8) | (uint32_t{data[2]} << 16) |
 (uint32_t{data[3]} << 24);
}

load64be()

constexpr uint64_t evmc::load64be ( const uint8_t *  data )

inlineconstexprnoexcept

Loads 64 bits / 8 bytes of data from the given data array in big-endian order.

Definition at line 131 of file evmc.hpp.

{
 return (uint64_t{data[0]} << 56) | (uint64_t{data[1]} << 48) | (uint64_t{data[2]} << 40) |
 (uint64_t{data[3]} << 32) | (uint64_t{data[4]} << 24) | (uint64_t{data[5]} << 16) |
 (uint64_t{data[6]} << 8) | uint64_t{data[7]};
}

load64le()

constexpr uint64_t evmc::load64le ( const uint8_t *  data )

inlineconstexprnoexcept

Loads 64 bits / 8 bytes of data from the given data array in little-endian order.

Definition at line 139 of file evmc.hpp.

{
 return uint64_t{data[0]} | (uint64_t{data[1]} << 8) | (uint64_t{data[2]} << 16) |
 (uint64_t{data[3]} << 24) | (uint64_t{data[4]} << 32) | (uint64_t{data[5]} << 40) |
 (uint64_t{data[6]} << 48) | (uint64_t{data[7]} << 56);
}

operator!=() [1/2]

constexpr bool evmc::operator!= ( const address &  a, const address &  b  )

inlineconstexprnoexcept

The "not equal to" comparison operator for the evmc::address type.

Definition at line 182 of file evmc.hpp.

{
 return !(a == b);
}

operator!=() [2/2]

constexpr bool evmc::operator!= ( const bytes32 &  a, const bytes32 &  b  )

inlineconstexprnoexcept

The "not equal to" comparison operator for the evmc::bytes32 type.

Definition at line 225 of file evmc.hpp.

{
 return !(a == b);
}

operator<() [1/2]

constexpr bool evmc::operator< ( const address &  a, const address &  b  )

inlineconstexprnoexcept

The "less than" comparison operator for the evmc::address type.

Definition at line 188 of file evmc.hpp.

{
 return load64be(&a.bytes[0]) < load64be(&b.bytes[0]) ||
 (load64be(&a.bytes[0]) == load64be(&b.bytes[0]) &&
 (load64be(&a.bytes[8]) < load64be(&b.bytes[8]) ||
 (load64be(&a.bytes[8]) == load64be(&b.bytes[8]) &&
 load32be(&a.bytes[16]) < load32be(&b.bytes[16]))));
}

operator<() [2/2]

constexpr bool evmc::operator< ( const bytes32 &  a, const bytes32 &  b  )

inlineconstexprnoexcept

The "less than" comparison operator for the evmc::bytes32 type.

Definition at line 231 of file evmc.hpp.

{
 return load64be(&a.bytes[0]) < load64be(&b.bytes[0]) ||
 (load64be(&a.bytes[0]) == load64be(&b.bytes[0]) &&
 (load64be(&a.bytes[8]) < load64be(&b.bytes[8]) ||
 (load64be(&a.bytes[8]) == load64be(&b.bytes[8]) &&
 (load64be(&a.bytes[16]) < load64be(&b.bytes[16]) ||
 (load64be(&a.bytes[16]) == load64be(&b.bytes[16]) &&
 load64be(&a.bytes[24]) < load64be(&b.bytes[24]))))));
}

operator<=() [1/2]

constexpr bool evmc::operator<= ( const address &  a, const address &  b  )

inlineconstexprnoexcept

The "less than or equal to" comparison operator for the evmc::address type.

Definition at line 204 of file evmc.hpp.

{
 return !(b < a);
}

operator<=() [2/2]

constexpr bool evmc::operator<= ( const bytes32 &  a, const bytes32 &  b  )

inlineconstexprnoexcept

The "less than or equal to" comparison operator for the evmc::bytes32 type.

Definition at line 249 of file evmc.hpp.

{
 return !(b < a);
}

operator==() [1/2]

constexpr bool evmc::operator== ( const address &  a, const address &  b  )

inlineconstexprnoexcept

The "equal to" comparison operator for the evmc::address type.

Definition at line 174 of file evmc.hpp.

{
 return load64le(&a.bytes[0]) == load64le(&b.bytes[0]) &&
 load64le(&a.bytes[8]) == load64le(&b.bytes[8]) &&
 load32le(&a.bytes[16]) == load32le(&b.bytes[16]);
}

operator==() [2/2]

constexpr bool evmc::operator== ( const bytes32 &  a, const bytes32 &  b  )

inlineconstexprnoexcept

The "equal to" comparison operator for the evmc::bytes32 type.

Definition at line 216 of file evmc.hpp.

{
 return load64le(&a.bytes[0]) == load64le(&b.bytes[0]) &&
 load64le(&a.bytes[8]) == load64le(&b.bytes[8]) &&
 load64le(&a.bytes[16]) == load64le(&b.bytes[16]) &&
 load64le(&a.bytes[24]) == load64le(&b.bytes[24]);
}

operator>() [1/2]

constexpr bool evmc::operator> ( const address &  a, const address &  b  )

inlineconstexprnoexcept

The "greater than" comparison operator for the evmc::address type.

Definition at line 198 of file evmc.hpp.

{
 return b < a;
}

operator>() [2/2]

constexpr bool evmc::operator> ( const bytes32 &  a, const bytes32 &  b  )

inlineconstexprnoexcept

The "greater than" comparison operator for the evmc::bytes32 type.

Definition at line 243 of file evmc.hpp.

{
 return b < a;
}

operator>=() [1/2]

constexpr bool evmc::operator>= ( const address &  a, const address &  b  )

inlineconstexprnoexcept

The "greater than or equal to" comparison operator for the evmc::address type.

Definition at line 210 of file evmc.hpp.

{
 return !(a < b);
}

operator>=() [2/2]

constexpr bool evmc::operator>= ( const bytes32 &  a, const bytes32 &  b  )

inlineconstexprnoexcept

The "greater than or equal to" comparison operator for the evmc::bytes32 type.

Definition at line 255 of file evmc.hpp.

{
 return !(a < b);
}

to_string() [1/2]

const char * evmc::to_string ( evmc_revision  rev )

inlinenoexcept

Returns the name of the evmc_revision.

Definition at line 318 of file evmc.hpp.

{
 return evmc_revision_to_string(rev);
}

to_string() [2/2]

const char * evmc::to_string ( evmc_status_code  status_code )

inlinenoexcept

Returns text representation of the evmc_status_code.

Definition at line 312 of file evmc.hpp.

{
 return evmc_status_code_to_string(status_code);
}

validate_hex()

bool evmc::validate_hex ( std::string_view  hex )

inlinenoexcept

Validates hex encoded string.

Returns

True if the input is valid hex.

Definition at line 91 of file hex.hpp.

{
 struct noop_output_iterator
 {
 uint8_t sink = {};
 uint8_t& operator*() noexcept { return sink; }
 noop_output_iterator operator++(int) noexcept { return *this; } // NOLINT(cert-dcl21-cpp)
 };
 
 return from_hex(hex.begin(), hex.end(), noop_output_iterator{});
}

Variable Documentation

make_result

constexpr auto evmc::make_result = evmc_make_result

constexpr

Alias for evmc_make_result().

Definition at line 325 of file evmc.hpp.