evmc.h

Go to the documentation of this file.

 
#ifndef EVMC_H
#define EVMC_H
 
#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 6)
#define EVMC_DEPRECATED __attribute__((deprecated))
#else
#define EVMC_DEPRECATED
#endif
 
 
#include <stdbool.h> /* Definition of bool, true and false. */
#include <stddef.h>  /* Definition of size_t. */
#include <stdint.h>  /* Definition of int64_t, uint64_t. */
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* BEGIN Python CFFI declarations */
 
enum
{
    EVMC_ABI_VERSION = 12
};
 
 
typedef struct evmc_bytes32
{
    uint8_t bytes[32];
} evmc_bytes32;
 
typedef struct evmc_bytes32 evmc_uint256be;
 
typedef struct evmc_address
{
    uint8_t bytes[20];
} evmc_address;
 
enum evmc_call_kind
{
    EVMC_CALL = 0,         
    EVMC_DELEGATECALL = 1, 
    EVMC_CALLCODE = 2,     
    EVMC_CREATE = 3,       
    EVMC_CREATE2 = 4,      
    EVMC_EOFCREATE = 5     
};
 
enum evmc_flags
{
    EVMC_STATIC = 1 
};
 
struct evmc_message
{
    enum evmc_call_kind kind;
 
    uint32_t flags;
 
    int32_t depth;
 
    int64_t gas;
 
    evmc_address recipient;
 
    evmc_address sender;
 
    const uint8_t* input_data;
 
    size_t input_size;
 
    evmc_uint256be value;
 
    evmc_bytes32 create2_salt;
 
    evmc_address code_address;
 
    const uint8_t* code;
 
    size_t code_size;
};
 
typedef struct evmc_tx_initcode
{
    evmc_bytes32 hash;   
    const uint8_t* code; 
    size_t code_size;    
} evmc_tx_initcode;
 
struct evmc_tx_context
{
    evmc_uint256be tx_gas_price;       
    evmc_address tx_origin;            
    evmc_address block_coinbase;       
    int64_t block_number;              
    int64_t block_timestamp;           
    int64_t block_gas_limit;           
    evmc_uint256be block_prev_randao;  
    evmc_uint256be chain_id;           
    evmc_uint256be block_base_fee;     
    evmc_uint256be blob_base_fee;      
    const evmc_bytes32* blob_hashes;   
    size_t blob_hashes_count;          
    const evmc_tx_initcode* initcodes; 
    size_t initcodes_count;            
};
 
struct evmc_host_context;
 
typedef struct evmc_tx_context (*evmc_get_tx_context_fn)(struct evmc_host_context* context);
 
typedef evmc_bytes32 (*evmc_get_block_hash_fn)(struct evmc_host_context* context, int64_t number);
 
enum evmc_status_code
{
    EVMC_SUCCESS = 0,
 
    EVMC_FAILURE = 1,
 
    EVMC_REVERT = 2,
 
    EVMC_OUT_OF_GAS = 3,
 
    EVMC_INVALID_INSTRUCTION = 4,
 
    EVMC_UNDEFINED_INSTRUCTION = 5,
 
    EVMC_STACK_OVERFLOW = 6,
 
    EVMC_STACK_UNDERFLOW = 7,
 
    EVMC_BAD_JUMP_DESTINATION = 8,
 
    EVMC_INVALID_MEMORY_ACCESS = 9,
 
    EVMC_CALL_DEPTH_EXCEEDED = 10,
 
    EVMC_STATIC_MODE_VIOLATION = 11,
 
    EVMC_PRECOMPILE_FAILURE = 12,
 
    EVMC_CONTRACT_VALIDATION_FAILURE = 13,
 
    EVMC_ARGUMENT_OUT_OF_RANGE = 14,
 
    EVMC_WASM_UNREACHABLE_INSTRUCTION = 15,
 
    EVMC_WASM_TRAP = 16,
 
    EVMC_INSUFFICIENT_BALANCE = 17,
 
    EVMC_INTERNAL_ERROR = -1,
 
    EVMC_REJECTED = -2,
 
    EVMC_OUT_OF_MEMORY = -3
};
 
/* Forward declaration. */
struct evmc_result;
 
typedef void (*evmc_release_result_fn)(const struct evmc_result* result);
 
struct evmc_result
{
    enum evmc_status_code status_code;
 
    int64_t gas_left;
 
    int64_t gas_refund;
 
    const uint8_t* output_data;
 
    size_t output_size;
 
    evmc_release_result_fn release;
 
    evmc_address create_address;
 
    uint8_t padding[4];
};
 
 
typedef bool (*evmc_account_exists_fn)(struct evmc_host_context* context,
                                       const evmc_address* address);
 
typedef evmc_bytes32 (*evmc_get_storage_fn)(struct evmc_host_context* context,
                                            const evmc_address* address,
                                            const evmc_bytes32* key);
 
typedef evmc_bytes32 (*evmc_get_transient_storage_fn)(struct evmc_host_context* context,
                                                      const evmc_address* address,
                                                      const evmc_bytes32* key);
 
 
enum evmc_storage_status
{
    EVMC_STORAGE_ASSIGNED = 0,
 
    EVMC_STORAGE_ADDED = 1,
 
    EVMC_STORAGE_DELETED = 2,
 
    EVMC_STORAGE_MODIFIED = 3,
 
    EVMC_STORAGE_DELETED_ADDED = 4,
 
    EVMC_STORAGE_MODIFIED_DELETED = 5,
 
    EVMC_STORAGE_DELETED_RESTORED = 6,
 
    EVMC_STORAGE_ADDED_DELETED = 7,
 
    EVMC_STORAGE_MODIFIED_RESTORED = 8
};
 
 
typedef enum evmc_storage_status (*evmc_set_storage_fn)(struct evmc_host_context* context,
                                                        const evmc_address* address,
                                                        const evmc_bytes32* key,
                                                        const evmc_bytes32* value);
 
typedef void (*evmc_set_transient_storage_fn)(struct evmc_host_context* context,
                                              const evmc_address* address,
                                              const evmc_bytes32* key,
                                              const evmc_bytes32* value);
 
typedef evmc_uint256be (*evmc_get_balance_fn)(struct evmc_host_context* context,
                                              const evmc_address* address);
 
typedef size_t (*evmc_get_code_size_fn)(struct evmc_host_context* context,
                                        const evmc_address* address);
 
typedef evmc_bytes32 (*evmc_get_code_hash_fn)(struct evmc_host_context* context,
                                              const evmc_address* address);
 
typedef size_t (*evmc_copy_code_fn)(struct evmc_host_context* context,
                                    const evmc_address* address,
                                    size_t code_offset,
                                    uint8_t* buffer_data,
                                    size_t buffer_size);
 
typedef bool (*evmc_selfdestruct_fn)(struct evmc_host_context* context,
                                     const evmc_address* address,
                                     const evmc_address* beneficiary);
 
typedef void (*evmc_emit_log_fn)(struct evmc_host_context* context,
                                 const evmc_address* address,
                                 const uint8_t* data,
                                 size_t data_size,
                                 const evmc_bytes32 topics[],
                                 size_t topics_count);
 
enum evmc_access_status
{
    EVMC_ACCESS_COLD = 0,
 
    EVMC_ACCESS_WARM = 1
};
 
typedef enum evmc_access_status (*evmc_access_account_fn)(struct evmc_host_context* context,
                                                          const evmc_address* address);
 
typedef enum evmc_access_status (*evmc_access_storage_fn)(struct evmc_host_context* context,
                                                          const evmc_address* address,
                                                          const evmc_bytes32* key);
 
typedef struct evmc_result (*evmc_call_fn)(struct evmc_host_context* context,
                                           const struct evmc_message* msg);
 
struct evmc_host_interface
{
    evmc_account_exists_fn account_exists;
 
    evmc_get_storage_fn get_storage;
 
    evmc_set_storage_fn set_storage;
 
    evmc_get_balance_fn get_balance;
 
    evmc_get_code_size_fn get_code_size;
 
    evmc_get_code_hash_fn get_code_hash;
 
    evmc_copy_code_fn copy_code;
 
    evmc_selfdestruct_fn selfdestruct;
 
    evmc_call_fn call;
 
    evmc_get_tx_context_fn get_tx_context;
 
    evmc_get_block_hash_fn get_block_hash;
 
    evmc_emit_log_fn emit_log;
 
    evmc_access_account_fn access_account;
 
    evmc_access_storage_fn access_storage;
 
    evmc_get_transient_storage_fn get_transient_storage;
 
    evmc_set_transient_storage_fn set_transient_storage;
};
 
 
/* Forward declaration. */
struct evmc_vm;
 
typedef void (*evmc_destroy_fn)(struct evmc_vm* vm);
 
enum evmc_set_option_result
{
    EVMC_SET_OPTION_SUCCESS = 0,
    EVMC_SET_OPTION_INVALID_NAME = 1,
    EVMC_SET_OPTION_INVALID_VALUE = 2
};
 
typedef enum evmc_set_option_result (*evmc_set_option_fn)(struct evmc_vm* vm,
                                                          char const* name,
                                                          char const* value);
 
 
enum evmc_revision
{
    EVMC_FRONTIER = 0,
 
    EVMC_HOMESTEAD = 1,
 
    EVMC_TANGERINE_WHISTLE = 2,
 
    EVMC_SPURIOUS_DRAGON = 3,
 
    EVMC_BYZANTIUM = 4,
 
    EVMC_CONSTANTINOPLE = 5,
 
    EVMC_PETERSBURG = 6,
 
    EVMC_ISTANBUL = 7,
 
    EVMC_BERLIN = 8,
 
    EVMC_LONDON = 9,
 
    EVMC_PARIS = 10,
 
    EVMC_SHANGHAI = 11,
 
    EVMC_CANCUN = 12,
 
    EVMC_PRAGUE = 13,
 
    EVMC_OSAKA = 14,
 
    EVMC_MAX_REVISION = EVMC_OSAKA,
 
    EVMC_LATEST_STABLE_REVISION = EVMC_CANCUN
};
 
 
typedef struct evmc_result (*evmc_execute_fn)(struct evmc_vm* vm,
                                              const struct evmc_host_interface* host,
                                              struct evmc_host_context* context,
                                              enum evmc_revision rev,
                                              const struct evmc_message* msg,
                                              uint8_t const* code,
                                              size_t code_size);
 
enum evmc_capabilities
{
    EVMC_CAPABILITY_EVM1 = (1u << 0),
 
    EVMC_CAPABILITY_EWASM = (1u << 1),
 
    EVMC_CAPABILITY_PRECOMPILES = (1u << 2)
};
 
typedef uint32_t evmc_capabilities_flagset;
 
typedef evmc_capabilities_flagset (*evmc_get_capabilities_fn)(struct evmc_vm* vm);
 
 
struct evmc_vm
{
    const int abi_version;
 
    const char* name;
 
    const char* version;
 
    evmc_destroy_fn destroy;
 
    evmc_execute_fn execute;
 
    evmc_get_capabilities_fn get_capabilities;
 
    evmc_set_option_fn set_option;
};
 
/* END Python CFFI declarations */
 
#ifdef EVMC_DOCUMENTATION
struct evmc_vm* evmc_create_example_vm(void);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif