rlp.hpp

Go to the documentation of this file.

// Copyright (c) 2022 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef OPENCBDC_TX_SRC_PARSEC_AGENT_RUNNERS_EVM_RLP_H_
#define OPENCBDC_TX_SRC_PARSEC_AGENT_RUNNERS_EVM_RLP_H_
 
#include "format.hpp"
#include "util/common/buffer.hpp"
#include "util/serialization/buffer_serializer.hpp"
#include "util/serialization/format.hpp"
#include "util/serialization/serializer.hpp"
#include "util/serialization/util.hpp"
 
#include <evmc/evmc.hpp>
#include <optional>
#include <vector>
 
namespace cbdc {
    enum class rlp_value_type {
        array,
        buffer,
    };
 
    class rlp_value {
      public:
        rlp_value();
 
        explicit rlp_value(rlp_value_type type);
 
        explicit rlp_value(const buffer& data);
 
        void assign(const buffer& data);
 
        auto push_back(const rlp_value& val) -> bool;
 
        void write_to(serializer& ser) const;
 
        void read_from(serializer& ser);
 
        [[nodiscard]] auto value_at(size_t idx) const -> rlp_value;
 
        [[nodiscard]] auto size() const -> size_t;
 
        [[nodiscard]] auto type() const -> rlp_value_type;
 
        [[nodiscard]] auto data() const -> const void*;
 
        template<typename T>
        [[nodiscard]] auto value() const -> typename std::enable_if_t<
            std::is_same<T, evmc::bytes32>::value
                || std::is_same<T, evmc::address>::value,
            T> {
            auto res = T();
            auto buf = cbdc::buffer();
            buf.extend(sizeof(res.bytes));
            std::memcpy(buf.data_at(sizeof(res.bytes) - m_buffer.size()),
                        m_buffer.data(),
                        m_buffer.size());
            std::memcpy(&res.bytes, buf.data(), buf.size());
            return res;
        }
 
      private:
        void write_array_to(serializer& ser) const;
        void write_buffer_to(serializer& ser) const;
        void read_buffer_from(serializer& ser, size_t size);
        void read_array_from(serializer& ser, size_t size);
 
        buffer m_buffer{};
        std::vector<rlp_value> m_values{};
        rlp_value_type m_type{};
    };
 
    template<typename T>
    auto make_rlp_value(const T& obj, bool trim_leading_zeroes = false)
        -> rlp_value {
        auto pkt = make_buffer(obj);
        if(trim_leading_zeroes) {
            size_t start_idx = 0;
            std::byte b{};
            auto sz = pkt.size();
            while(start_idx < sz) {
                std::memcpy(&b, pkt.data_at(start_idx), 1);
                if(b != std::byte(0)) {
                    break;
                }
                start_idx++;
            }
 
            auto buf = cbdc::buffer();
            buf.extend(sz - start_idx);
            std::memcpy(buf.data(), pkt.data_at(start_idx), buf.size());
            return rlp_value(buf);
        }
        return rlp_value(pkt);
    }
 
    template<typename... Args>
    auto make_rlp_array(const Args&... values) -> rlp_value {
        std::vector<rlp_value> vec = {values...};
        auto val = rlp_value(rlp_value_type::array);
        for(const auto& v : vec) {
            val.push_back(v);
        }
        return val;
    }
 
    void
    serialize_rlp_length(serializer& ser, size_t len, unsigned char offset);
 
    auto serialize_size(size_t size) -> std::vector<std::byte>;
 
    auto rlp_encode_access_list(
        const parsec::agent::runner::evm_access_list& access_list)
        -> rlp_value;
 
    auto rlp_decode_access_list(const rlp_value& rlp)
        -> std::optional<parsec::agent::runner::evm_access_list>;
 
    auto deserialize_size(const cbdc::buffer& buf) -> size_t;
 
    auto operator<<(serializer& ser, const rlp_value& v) -> serializer&;
 
    auto operator>>(serializer& ser, cbdc::rlp_value& v) -> serializer&;
}
 
#endif // OPENCBDC_TX_SRC_PARSEC_AGENT_RUNNERS_EVM_RLP_H_