precompiles: Optionally use silkpre as implementation

Author: chfast

test/state/CMakeLists.txt

@@ -48,4 +48,9 @@ if(EVMONE_PRECOMPILES_SILKPRE)
 
     target_link_libraries(evmone-state PRIVATE silkpre)
     target_compile_definitions(evmone-state PRIVATE EVMONE_PRECOMPILES_SILKPRE=1)
+    target_sources(
+        evmone-state PRIVATE
+        precompiles_silkpre.hpp
+        precompiles_silkpre.cpp
+    )
 endif()

test/state/precompiles.cpp

@@ -11,6 +11,10 @@
 #include <limits>
 #include <unordered_map>
 
+#ifdef EVMONE_PRECOMPILES_SILKPRE
+#include "precompiles_silkpre.hpp"
+#endif
+
 namespace evmone::state
 {
 using namespace evmc::literals;
@@ -172,6 +176,16 @@ inline constexpr auto traits = []() noexcept {
         {ecpairing_analyze, dummy_execute<PrecompileId::ecpairing>},
         {blake2bf_analyze, dummy_execute<PrecompileId::blake2bf>},
     }};
+#ifdef EVMONE_PRECOMPILES_SILKPRE
+    tbl[static_cast<size_t>(PrecompileId::ecrecover)].execute = silkpre_ecrecover_execute;
+    tbl[static_cast<size_t>(PrecompileId::sha256)].execute = silkpre_sha256_execute;
+    tbl[static_cast<size_t>(PrecompileId::ripemd160)].execute = silkpre_ripemd160_execute;
+    tbl[static_cast<size_t>(PrecompileId::expmod)].execute = silkpre_expmod_execute;
+    tbl[static_cast<size_t>(PrecompileId::ecadd)].execute = silkpre_ecadd_execute;
+    tbl[static_cast<size_t>(PrecompileId::ecmul)].execute = silkpre_ecmul_execute;
+    tbl[static_cast<size_t>(PrecompileId::ecpairing)].execute = silkpre_ecpairing_execute;
+    tbl[static_cast<size_t>(PrecompileId::blake2bf)].execute = silkpre_blake2bf_execute;
+#endif
     return tbl;
 }();
 }  // namespace

test/state/precompiles_silkpre.cpp

@@ -0,0 +1,76 @@
+// evmone: Fast Ethereum Virtual Machine implementation
+// Copyright 2022 The evmone Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+#include "precompiles_silkpre.hpp"
+#include <silkpre/precompile.h>
+#include <cassert>
+#include <cstring>
+
+namespace evmone::state
+{
+namespace
+{
+ExecutionResult execute(const uint8_t* input, size_t input_size, uint8_t* output_buf,
+    [[maybe_unused]] size_t max_output_size, PrecompileId id) noexcept
+{
+    const auto index = static_cast<size_t>(id) - 1;
+    const auto [output, output_size] = kSilkpreContracts[index].run(input, input_size);
+    if (output == nullptr)
+        return {EVMC_PRECOMPILE_FAILURE, 0};
+    assert(output_size <= max_output_size);
+    std::memcpy(output_buf, output, output_size);
+    std::free(output);
+    return {EVMC_SUCCESS, output_size};
+}
+}  // namespace
+
+ExecutionResult silkpre_ecrecover_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::ecrecover);
+}
+
+ExecutionResult silkpre_sha256_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::sha256);
+}
+
+ExecutionResult silkpre_ripemd160_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::ripemd160);
+}
+
+ExecutionResult silkpre_expmod_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::expmod);
+}
+
+ExecutionResult silkpre_ecadd_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::ecadd);
+}
+
+ExecutionResult silkpre_ecmul_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::ecmul);
+}
+
+
+ExecutionResult silkpre_ecpairing_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::ecpairing);
+}
+
+ExecutionResult silkpre_blake2bf_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept
+{
+    return execute(input, input_size, output_buf, max_output_size, PrecompileId::blake2bf);
+}
+}  // namespace evmone::state

test/state/precompiles_silkpre.hpp

@@ -0,0 +1,33 @@
+// evmone: Fast Ethereum Virtual Machine implementation
+// Copyright 2022 The evmone Authors.
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include "precompiles.hpp"
+
+namespace evmone::state
+{
+ExecutionResult silkpre_ecrecover_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+
+ExecutionResult silkpre_sha256_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+
+ExecutionResult silkpre_ripemd160_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+
+ExecutionResult silkpre_expmod_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+
+ExecutionResult silkpre_ecadd_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+
+ExecutionResult silkpre_ecmul_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+
+ExecutionResult silkpre_ecpairing_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+
+ExecutionResult silkpre_blake2bf_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output_buf, size_t max_output_size) noexcept;
+}  // namespace evmone::state