mirror of https://github.com/status-im/evmc.git
125 lines
3.7 KiB
C
125 lines
3.7 KiB
C
#include <evmc.h>
|
|
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
struct examplevm
|
|
{
|
|
struct evmc_instance instance;
|
|
int verbose;
|
|
};
|
|
|
|
static void evmc_destroy(struct evmc_instance* evm)
|
|
{
|
|
free(evm);
|
|
}
|
|
|
|
/// Example options.
|
|
///
|
|
/// VMs are allowed to omit this function implementation.
|
|
int evmc_set_option(struct evmc_instance* instance, char const* name, char const* value)
|
|
{
|
|
struct examplevm* vm = (struct examplevm*)instance;
|
|
if (strcmp(name, "verbose") == 0)
|
|
{
|
|
long int v = strtol(value, NULL, 0);
|
|
if (v > INT_MAX || v < INT_MIN)
|
|
return 0;
|
|
vm->verbose = (int)v;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void evmc_release_result(struct evmc_result const* result)
|
|
{
|
|
(void)result;
|
|
}
|
|
|
|
static void free_result_output_data(struct evmc_result const* result)
|
|
{
|
|
free((uint8_t*)result->output_data);
|
|
}
|
|
|
|
static struct evmc_result execute(struct evmc_instance* instance, struct evmc_context* context,
|
|
enum evmc_revision rev, const struct evmc_message* msg, const uint8_t* code, size_t code_size)
|
|
{
|
|
struct evmc_result ret = {.status_code = EVMC_INTERNAL_ERROR};
|
|
if (code_size == 0)
|
|
{
|
|
// In case of empty code return a fancy error message.
|
|
const char* error = rev == EVMC_BYZANTIUM ? "Welcome to Byzantium!" : "Hello Ethereum!";
|
|
ret.output_data = (const uint8_t*)error;
|
|
ret.output_size = strlen(error);
|
|
ret.status_code = EVMC_FAILURE;
|
|
ret.release = NULL; // We don't need to release the constant messages.
|
|
return ret;
|
|
}
|
|
|
|
struct examplevm* vm = (struct examplevm*)instance;
|
|
|
|
// Simulate executing by checking for some code patterns.
|
|
// Solidity inline assembly is used in the examples instead of EVM bytecode.
|
|
|
|
// Assembly: `{ mstore(0, address()) return(0, msize()) }`.
|
|
const char return_address[] = "30600052596000f3";
|
|
|
|
// Assembly: `{ sstore(0, add(sload(0), 1)) }`
|
|
const char counter[] = "600160005401600055";
|
|
|
|
if (code_size == strlen(return_address) &&
|
|
strncmp((const char*)code, return_address, code_size) == 0)
|
|
{
|
|
static const size_t address_size = sizeof(msg->destination);
|
|
uint8_t* output_data = (uint8_t*)malloc(address_size);
|
|
if (!output_data)
|
|
{
|
|
// malloc failed, report internal error.
|
|
ret.status_code = EVMC_INTERNAL_ERROR;
|
|
return ret;
|
|
}
|
|
memcpy(output_data, &msg->destination, address_size);
|
|
ret.status_code = EVMC_SUCCESS;
|
|
ret.output_data = output_data;
|
|
ret.output_size = address_size;
|
|
ret.release = &free_result_output_data;
|
|
return ret;
|
|
}
|
|
else if (code_size == strlen(counter) && strncmp((const char*)code, counter, code_size) == 0)
|
|
{
|
|
struct evmc_uint256be value;
|
|
const struct evmc_uint256be index = {{0}};
|
|
context->fn_table->get_storage(&value, context, &msg->destination, &index);
|
|
value.bytes[31] += 1;
|
|
context->fn_table->set_storage(context, &msg->destination, &index, &value);
|
|
ret.status_code = EVMC_SUCCESS;
|
|
return ret;
|
|
}
|
|
|
|
ret.release = evmc_release_result;
|
|
ret.status_code = EVMC_FAILURE;
|
|
ret.gas_left = 0;
|
|
|
|
if (vm->verbose)
|
|
printf("Execution done.\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
struct evmc_instance* examplevm_create()
|
|
{
|
|
struct evmc_instance init = {
|
|
.abi_version = EVMC_ABI_VERSION,
|
|
.destroy = evmc_destroy,
|
|
.execute = execute,
|
|
.set_option = evmc_set_option,
|
|
};
|
|
struct examplevm* vm = calloc(1, sizeof(struct examplevm));
|
|
struct evmc_instance* interface = &vm->instance;
|
|
memcpy(interface, &init, sizeof(init));
|
|
return interface;
|
|
}
|