evm.h

Go to the documentation of this file.

#ifndef EVM_H
#define EVM_H

#include <stdint.h>    // Definition of int64_t, uint64_t.
#include <stddef.h>    // Definition of size_t.

#if __cplusplus
extern "C" {
#endif

// BEGIN Python CFFI declarations

enum { EVM_ABI_VERSION = 0 };

struct evm_uint256be {
    uint8_t bytes[32];
};

struct evm_uint160be {
    uint8_t bytes[20];
};

enum evm_result_code {
    EVM_SUCCESS = 0,               
    EVM_FAILURE = 1,               
    EVM_OUT_OF_GAS = 2,
    EVM_BAD_INSTRUCTION = 3,
    EVM_BAD_JUMP_DESTINATION = 4,
    EVM_STACK_OVERFLOW = 5,
    EVM_STACK_UNDERFLOW = 6,
};

struct evm_result;  

typedef void (*evm_release_result_fn)(struct evm_result const* result);

struct evm_result {
    enum evm_result_code code;

    int64_t gas_left;

    uint8_t const* output_data;

    size_t output_size;

    evm_release_result_fn release;


    char const* error_message;

    void* internal_memory;

};

enum evm_query_key {
    EVM_SLOAD = 0,            
    EVM_ADDRESS = 1,          
    EVM_CALLER = 2,           
    EVM_ORIGIN = 3,           
    EVM_GAS_PRICE = 4,        
    EVM_COINBASE = 5,         
    EVM_DIFFICULTY = 6,       
    EVM_GAS_LIMIT = 7,        
    EVM_NUMBER = 8,           
    EVM_TIMESTAMP = 9,        
    EVM_CODE_BY_ADDRESS = 10, 
    EVM_CODE_SIZE = 11,       
    EVM_BALANCE = 12,         
    EVM_BLOCKHASH = 13,       
    EVM_ACCOUNT_EXISTS = 14,  
    EVM_CALL_DEPTH = 15,      
};


struct evm_env;

union evm_variant {
    int64_t int64;

    struct evm_uint256be uint256be;

    struct {
        uint8_t address_padding[12];

        struct evm_uint160be address;
    };

    struct {
        uint8_t const* data;

        size_t data_size;
    };
};

typedef void (*evm_query_fn)(union evm_variant* result,
                             struct evm_env* env,
                             enum evm_query_key key,
                             const union evm_variant* arg);

enum evm_update_key {
    EVM_SSTORE = 0,        
    EVM_LOG = 1,           
    EVM_SELFDESTRUCT = 2,  
};


typedef void (*evm_update_fn)(struct evm_env* env,
                              enum evm_update_key key,
                              const union evm_variant* arg1,
                              const union evm_variant* arg2);

enum evm_call_kind {
    EVM_CALL = 0,         
    EVM_DELEGATECALL = 1, 
    EVM_CALLCODE = 2,     
    EVM_CREATE = 3        
};

static const int64_t EVM_CALL_FAILURE = 0x8000000000000000;

typedef int64_t (*evm_call_fn)(
    struct evm_env* env,
    enum evm_call_kind kind,
    int64_t gas,
    const struct evm_uint160be* address,
    const struct evm_uint256be* value,
    uint8_t const* input,
    size_t input_size,
    uint8_t* output,
    size_t output_size);


struct evm_instance;  

typedef struct evm_instance* (*evm_create_fn)(evm_query_fn query_fn,
                                              evm_update_fn update_fn,
                                              evm_call_fn call_fn);

typedef void (*evm_destroy_fn)(struct evm_instance* evm);


typedef int (*evm_set_option_fn)(struct evm_instance* evm,
                                 char const* name,
                                 char const* value);


enum evm_mode {
    EVM_FRONTIER = 0,
    EVM_HOMESTEAD = 1,
    EVM_ANTI_DOS = 2,
    EVM_CLEARING = 3
};


typedef struct evm_result (*evm_execute_fn)(struct evm_instance* instance,
                                            struct evm_env* env,
                                            enum evm_mode mode,
                                            struct evm_uint256be code_hash,
                                            uint8_t const* code,
                                            size_t code_size,
                                            int64_t gas,
                                            uint8_t const* input,
                                            size_t input_size,
                                            struct evm_uint256be value);


enum evm_code_status {
    EVM_UNKNOWN,

    EVM_READY,

    EVM_CACHED,
};


typedef enum evm_code_status
(*evm_get_code_status_fn)(struct evm_instance* instance,
                          enum evm_mode mode,
                          struct evm_uint256be code_hash);

typedef void (*evm_prepare_code_fn)(struct evm_instance* instance,
                                    enum evm_mode mode,
                                    struct evm_uint256be code_hash,
                                    uint8_t const* code,
                                    size_t code_size);

struct evm_instance {
    evm_destroy_fn destroy;

    evm_execute_fn execute;

    evm_get_code_status_fn get_code_status;

    evm_prepare_code_fn prepare_code;

    evm_set_option_fn set_option;
};

struct evm_factory {
    int abi_version;

    evm_create_fn create;
};

// END Python CFFI declarations

struct evm_factory examplevm_get_factory(void);


#if __cplusplus
}
#endif

#endif  // EVM_H

---

Generated on Mon Oct 22 2018 15:15:27 for Fabcoin Core by   1.8.11