Models.hpp

#pragma once
 
#include "util/Concepts.hpp"
 
#include <boost/json/object.hpp>
#include <fmt/format.h>
#include <xrpl/basics/Blob.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/proto/org/xrpl/rpc/v1/get_ledger.pb.h>
#include <xrpl/proto/org/xrpl/rpc/v1/ledger.pb.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol/TxMeta.h>
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace etl::model {

template <ripple::TxType... Types>
    requires(util::hasNoDuplicates(Types...))
struct Spec {
    static constexpr bool kSPEC_TAG = true;

    [[nodiscard]] static constexpr bool
    wants(ripple::TxType type) noexcept
    {
        return ((Types == type) || ...);
    }
};

struct Transaction {
    std::string raw;  // raw binary blob
    std::string metaRaw;
 
    // unpacked blob and meta
    ripple::STTx sttx;
    ripple::TxMeta meta;
 
    // commonly used stuff
    ripple::uint256 id;
    std::string key;  // key is the above id as a string of 32 characters
    ripple::TxType type;

    bool
    operator==(Transaction const& other) const
    {
        return raw == other.raw                                           //
            and metaRaw == other.metaRaw                                  //
            and sttx.getTransactionID() == other.sttx.getTransactionID()  //
            and meta.getTxID() == other.meta.getTxID()                    //
            and id == other.id                                            //
            and key == other.key                                          //
            and type == other.type;
    }
};

struct Object {
    enum class ModType : int {
        Unspecified = 0,
        Created = 1,
        Modified = 2,
        Deleted = 3,
    };
 
    ripple::uint256 key;
    std::string keyRaw;
    ripple::Blob data;
    std::string dataRaw;
    std::string successor;
    std::string predecessor;
 
    ModType type;
 
    bool
    operator==(Object const&) const = default;
};

struct BookSuccessor {
    std::string firstBook;
    std::string bookBase;
 
    bool
    operator==(BookSuccessor const&) const = default;
};

struct LedgerData {
    std::vector<Transaction> transactions;
    std::vector<Object> objects;
    std::optional<std::vector<BookSuccessor>> successors;
    std::optional<std::vector<std::string>> edgeKeys;
 
    ripple::LedgerHeader header;
    std::string rawHeader;
    uint32_t seq;

    bool
    operator==(LedgerData const& other) const
    {
        auto const serialized = [](auto const& hdr) {
            ripple::Serializer ser;
            ripple::addRaw(hdr, ser);
            return ser.getString();
        };
 
        return transactions == other.transactions               //
            and objects == other.objects                        //
            and successors == other.successors                  //
            and edgeKeys == other.edgeKeys                      //
            and serialized(header) == serialized(other.header)  //
            and rawHeader == other.rawHeader                    //
            and seq == other.seq;
    }
};

struct Task {
    enum class Priority : uint8_t {
        Lower = 0u,
        Higher = 1u,
    };
 
    Priority priority;
    uint32_t seq;
};
 
}  // namespace etl::model