transformation.hpp

Go to the documentation of this file.

#pragma once
#include <string>
#include <regex>
#include <algorithm>
 
#include <absl/hash/hash.h>
#include <spdlog/spdlog.h>
 
#include "transformation.pb.h"
 
#include "parser.hpp"
#include "chain.hpp"
 
namespace dcn
{
    template <typename H>
    inline H AbslHashValue(H h, const Transformation& t) {
        return H::combine(std::move(h), t.name(), t.sol_src());
    }
    
    parse::Result<std::string> constructTransformationSolidityCode(const Transformation & transformation);
}
 
namespace dcn::pt
{
    struct TransformationAddedEvent
    {
        chain::Address caller{};
        std::string name;
        chain::Address transformation_address{};
        chain::Address owner{};
        std::uint32_t args_count{};
    };
 
    std::optional<TransformationAddedEvent> decodeTransformationAddedEvent(
        const std::uint8_t* data,
        std::size_t data_size,
        const evmc::bytes32 topics[],
        std::size_t num_topics);
 
    std::optional<TransformationAddedEvent> decodeTransformationAddedEvent(
        const std::string & data_hex,
        const std::vector<std::string> & topics_hex);
 
}
 
namespace dcn::parse
{   
    template<>
    Result<json> parseToJson(Transformation transformation, use_json_t);
 
    template<>
    Result<Transformation> parseFromJson(json json_obj, use_json_t);
 
    template<>
    Result<std::string> parseToJson(Transformation transformation, use_protobuf_t);
 
    template<>
    Result<Transformation> parseFromJson(std::string json_str, use_protobuf_t);
 
    
    template<>
    Result<json> parseToJson(TransformationRecord transformation_record, use_json_t);
 
    template<>
    Result<std::string> parseToJson(TransformationRecord transformation_record, use_protobuf_t);
 
    template<>
    Result<TransformationRecord> parseFromJson(json json_obj, use_json_t);
    
    template<>
    Result<TransformationRecord> parseFromJson(std::string json_str, use_protobuf_t);
 
}