condition.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 "condition.pb.h"
 
#include "parser.hpp"
#include "chain.hpp"
 
namespace dcn
{
    template <typename H>
    inline H AbslHashValue(H h, const Condition & c) {
        return H::combine(std::move(h), c.name(), c.args_count());
    }

    parse::Result<std::uint32_t> countConditionArgs(const std::string & sol_src);
 
    parse::Result<std::string> constructConditionSolidityCode(const Condition & condition);
}
 
namespace dcn::pt
{
    struct ConditionAddedEvent
    {
        chain::Address caller{};
        std::string name;
        chain::Address condition_address{};
        chain::Address owner{};
        std::uint32_t args_count{};
    };
 
    std::optional<ConditionAddedEvent> decodeConditionAddedEvent(
        const std::uint8_t* data,
        std::size_t data_size,
        const evmc::bytes32 topics[],
        std::size_t num_topics);
 
    std::optional<ConditionAddedEvent> decodeConditionAddedEvent(
        const std::string & data_hex,
        const std::vector<std::string> & topics_hex);
 
}
 
namespace dcn::parse
{
    template<>
    Result<json> parseToJson(Condition condition, use_json_t);

    template<>
    Result<Condition> parseFromJson(json json_obj, use_json_t);

    template<>
    Result<std::string> parseToJson(Condition condition, use_protobuf_t);

    template<>
    Result<Condition> parseFromJson(std::string json_str, use_protobuf_t);
 

    template<>
    Result<json> parseToJson(ConditionRecord condition_record, use_json_t);

    template<>
    Result<std::string> parseToJson(ConditionRecord condition_record, use_protobuf_t);

    template<>
    Result<ConditionRecord> parseFromJson(json json_obj, use_json_t);
    
    template<>
    Result<ConditionRecord> parseFromJson(std::string json_str, use_protobuf_t);
}