Bridge basic message emission

.github/workflows/build-contract-test.sh

@@ -23,7 +23,7 @@ ee make -j "$(nproc)" unit_test
 
 # pack
 ee popd
-ee 'tar -czf ../contract-test.tar.gz build/*'
+ee 'tar -czf ../contract-test.tar.gz --exclude="*.o" build/*'
 ee popd
 
 echo "Done! - ${0##*/}"

.github/workflows/build-contract.sh

@@ -20,6 +20,6 @@ ee make -j "$(nproc)"
 
 # pack
 ee popd
-ee 'tar -czf contract.tar.gz build/*'
+ee 'tar -czf contract.tar.gz --exclude="*.obj" build/*'
 
 echo "Done! - ${0##*/}"

include/evm_runtime/bridge.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <evm_runtime/types.hpp>
+
+namespace evm_runtime { namespace bridge {
+
+struct message_v0 {
+    static constexpr uint32_t id = 0xf781185b; //sha3('bridgeMsgV0(string,bool,bytes)')[:4]
+
+    string account;
+    bool   force_atomic; //currently only atomic is supported
+    bytes  data;
+
+    name get_account_as_name() const {
+        if(!account_.has_value()) {
+            account_ = name{account};
+            eosio::check(account_.value().to_string() == account, "invalid account name");
+        }
+        return *account_;
+    }
+
+    mutable std::optional<name> account_;
+};
+
+using message = std::variant<message_v0>;
+
+message_v0 decode_message_v0(eosio::datastream<const uint8_t*>& ds) {
+    // offset_p1 (32) + p2_value (32) + offset_p3 (32)
+    // p1_len    (32) + p1_data   ((p1_len+31)/32*32)
+    // p3_len    (32) + p3_data   ((p2_len+31)/32*32)
+    uint256  offset_p1, value_p2, offset_p3;
+
+    ds >> offset_p1;
+    eosio::check(offset_p1 == 0x60, "invalid p1 offset");
+    ds >> value_p2;
+    eosio::check(value_p2 <= 1, "invalid p2 value");
+    ds >> offset_p3;
+    eosio::check(offset_p3 == 0xA0, "invalid p3 offset");
+
+    message_v0 res;
+    res.force_atomic = value_p2 ? true : false;
+
+    auto get_length=[&]() -> uint32_t {
+        uint256 len;
+        ds >> len;
+        eosio::check(len < std::numeric_limits<uint32_t>::max(), "invalid length");
+        return static_cast<uint32_t>(len);
+    };
+
+    uint32_t p1_len = get_length();
+    auto p1_len_32 = (p1_len+31)/32*32;
+    res.account.resize(p1_len_32);
+    ds.read(res.account.data(), p1_len_32);
+    res.account.resize(p1_len);
+
+    uint32_t p3_len = get_length();
+    auto p3_len_32 = (p3_len+31)/32*32;
+    res.data.resize(p3_len_32);
+    ds.read(res.data.data(), p3_len_32);
+    res.data.resize(p3_len);
+
+    return res;
+}
+
+std::optional<message> decode_message(ByteView bv) {
+    // method_id (4)
+    eosio::datastream<const uint8_t*> ds(bv.data(), bv.size());
+    uint32_t method_id;
+    ds >> method_id;
+
+    if(method_id == __builtin_bswap32(message_v0::id)) return decode_message_v0(ds);
+    return {};
+}
+
+} //namespace bridge
+} //namespace evm_runtime

include/evm_runtime/evm_contract.hpp

@@ -84,6 +84,12 @@ class [[eosio::contract]] evm_contract : public contract
    /// @return true if all garbage has been collected
    [[eosio::action]] bool gc(uint32_t max);
 
+   [[eosio::action]] void bridgereg(eosio::name receiver, const eosio::asset& min_fee);
+   [[eosio::action]] void bridgeunreg(eosio::name receiver);
+
+   [[eosio::action]] void call(eosio::name from, const bytes& to, const bytes& value, const bytes& data, uint64_t gas_limit);
+   [[eosio::action]] void admincall(const bytes& from, const bytes& to, const bytes& value, const bytes& data, uint64_t gas_limit);
+
 #ifdef WITH_TEST_ACTIONS
    [[eosio::action]] void testtx(const std::optional<bytes>& orlptx, const evm_runtime::test::block_info& bi);
    [[eosio::action]] void
@@ -132,6 +138,7 @@ class [[eosio::contract]] evm_contract : public contract
    }
 
    silkworm::Receipt execute_tx(eosio::name miner, silkworm::Block& block, silkworm::Transaction& tx, silkworm::ExecutionProcessor& ep, bool enforce_chain_id);
+   void process_filtered_messages(const std::vector<silkworm::FilteredMessage>& filtered_messages);
 
    uint64_t get_and_increment_nonce(const name owner);
 
@@ -140,6 +147,8 @@ class [[eosio::contract]] evm_contract : public contract
    void handle_account_transfer(const eosio::asset& quantity, const std::string& memo);
    void handle_evm_transfer(eosio::asset quantity, const std::string& memo);
 
+   void call_(intx::uint256 s, const bytes& to, intx::uint256 value, const bytes& data, uint64_t gas_limit, uint64_t nonce);
+
    // to allow sending through a Bytes (basic_string<uint8_t>) w/o copying over to a std::vector<char>
    void pushtx_bytes(eosio::name miner, const std::basic_string<uint8_t>& rlptx);
    using pushtx_action = eosio::action_wrapper<"pushtx"_n, &evm_contract::pushtx_bytes>;

include/evm_runtime/print_tracer.hpp

@@ -1,8 +1,9 @@
 #pragma once
 #include <evmc/instructions.h>
+#include <eosio/eosio.hpp>
 namespace evm_runtime {
 
-struct print_tracer : EvmTracer {
+struct print_tracer : silkworm::EvmTracer {
 
     const char* const* opcode_names_ = nullptr;
 
@@ -19,27 +20,28 @@ struct print_tracer : EvmTracer {
     }
 
     void on_instruction_start(uint32_t pc, const intx::uint256* stack_top, int stack_height,
-                                      const evmone::ExecutionState& state,
-                                      const IntraBlockState& intra_block_state) noexcept override {
-        const auto opcode = state.code[pc];
+                                int64_t gas, const evmone::ExecutionState& state,
+                                const silkworm::IntraBlockState& intra_block_state) override {
+
+        const auto opcode = state.original_code[pc];
         auto opcode_name = get_opcode_name(opcode_names_, opcode);
         eosio::print(opcode_name.c_str(), "\n");
     }
 
-    void on_execution_end(const evmc_result& result, const IntraBlockState& intra_block_state) noexcept override {
+    void on_execution_end(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override {
         eosio::print("TRACE: end\n");
     }
 
-    void on_creation_completed(const evmc_result& result, const IntraBlockState& intra_block_state) noexcept override {
+    void on_creation_completed(const evmc_result& result, const silkworm::IntraBlockState& intra_block_state) noexcept override {
 
     }
 
     void on_precompiled_run(const evmc_result& result, int64_t gas,
-                                    const IntraBlockState& intra_block_state) noexcept override {
+                                    const silkworm::IntraBlockState& intra_block_state) noexcept override {
 
     }
 
-    void on_reward_granted(const CallResult& result, const IntraBlockState& intra_block_state) noexcept override {
+    void on_reward_granted(const silkworm::CallResult& result, const silkworm::IntraBlockState& intra_block_state) noexcept override {
 
     }
 

include/evm_runtime/tables.hpp

@@ -182,4 +182,24 @@ struct [[eosio::table]] [[eosio::contract("evm_contract")]] allowed_egress_accou
 
 typedef eosio::multi_index<"egresslist"_n, allowed_egress_account> egresslist;
 
-} //namespace evm_runtime
+struct [[eosio::table]] [[eosio::contract("evm_contract")]] message_receiver {
+
+    enum flag : uint32_t {
+        FORCE_ATOMIC = 0x1
+    };
+
+    name     account;
+    asset    min_fee;
+    uint32_t flags;
+
+    uint64_t primary_key() const { return account.value; }
+    bool has_flag(flag f) const {
+        return (flags & f) != 0;
+    }
+
+    EOSLIB_SERIALIZE(message_receiver, (account)(min_fee)(flags));
+};
+
+typedef eosio::multi_index<"msgreceiver"_n, message_receiver> message_receiver_table;
+
+} //namespace evm_runtime

include/evm_runtime/types.hpp

@@ -29,7 +29,7 @@ namespace evm_runtime {
    eosio::checksum256 make_key(bytes data);
    eosio::checksum256 make_key(const evmc::address& addr);
    eosio::checksum256 make_key(const evmc::bytes32& data);
-   
+
    bytes to_bytes(const uint256& val);
    bytes to_bytes(const evmc::bytes32& val);
    bytes to_bytes(const evmc::address& addr);
@@ -63,6 +63,18 @@ namespace evm_runtime {
       EOSLIB_SERIALIZE(exec_output, (status)(data)(context));
    };
 
+   struct bridge_message_v0 {
+      eosio::name        receiver;
+      bytes              sender;
+      eosio::time_point  timestamp;
+      bytes              value;
+      bytes              data;
+
+      EOSLIB_SERIALIZE(bridge_message_v0, (receiver)(sender)(timestamp)(value)(data));
+   };
+
+   using bridge_message = std::variant<bridge_message_v0>;
+
 } //namespace evm_runtime
 
 namespace eosio {

src/CMakeLists.txt

@@ -85,5 +85,5 @@ target_compile_options(evm_runtime PUBLIC --no-missing-ricardian-clause)
 if (WITH_LARGE_STACK)
     target_link_options(evm_runtime PUBLIC --stack-size=50000000)
 else()
-    target_link_options(evm_runtime PUBLIC --stack-size=38560)
+    target_link_options(evm_runtime PUBLIC --stack-size=32768)
 endif()