Extraction.hpp

#pragma once
 
#include "etl/AmendmentBlockHandlerInterface.hpp"
#include "etl/ExtractorInterface.hpp"
#include "etl/LedgerFetcherInterface.hpp"
#include "etl/Models.hpp"
#include "etl/impl/LedgerFetcher.hpp"
#include "util/log/Logger.hpp"
 
#include <google/protobuf/repeated_ptr_field.h>
#include <sys/types.h>
#include <xrpl/basics/Slice.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/TxMeta.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace etl::impl {
 
using PBObjType = org::xrpl::rpc::v1::RawLedgerObject;
using PBModType = PBObjType::ModificationType;
using PBTxType = org::xrpl::rpc::v1::TransactionAndMetadata;
using PBTxListType = google::protobuf::RepeatedPtrField<PBTxType>;
using PBObjListType = google::protobuf::RepeatedPtrField<PBObjType>;
using PBBookSuccessorType = org::xrpl::rpc::v1::BookSuccessor;
using PBLedgerResponseType = org::xrpl::rpc::v1::GetLedgerResponse;
 
[[nodiscard]] model::Object::ModType
extractModType(PBModType type);
 
[[nodiscard]] model::Transaction
extractTx(PBTxType tx, uint32_t seq);
 
[[nodiscard]] std::vector<model::Transaction>
extractTxs(PBTxListType transactions, uint32_t seq);
 
[[nodiscard]] model::Object
extractObj(PBObjType obj);
 
[[nodiscard]] std::vector<model::Object>
extractObjs(PBObjListType objects);
 
[[nodiscard]] model::BookSuccessor
extractSuccessor(PBBookSuccessorType successor);
 
[[nodiscard]] std::optional<std::vector<model::BookSuccessor>>
maybeExtractSuccessors(PBLedgerResponseType const& data);
 
// fetches the data in gRPC and transforms to local representation
class Extractor : public ExtractorInterface {
    std::shared_ptr<LedgerFetcherInterface> fetcher_;
    std::shared_ptr<AmendmentBlockHandlerInterface> amendmentBlockHandler_;
 
    util::Logger log_{"ETL"};
 
private:
    [[nodiscard]] static auto
    unpack();
 
    [[nodiscard]] std::optional<model::LedgerData>
    guardedUnpack(std::optional<PBLedgerResponseType>&& response, uint32_t seq);
 
public:
    Extractor(
        std::shared_ptr<LedgerFetcherInterface> fetcher,
        std::shared_ptr<AmendmentBlockHandlerInterface> amendmentBlockHandler
    )
        : fetcher_(std::move(fetcher)), amendmentBlockHandler_(std::move(amendmentBlockHandler))
    {
    }
 
    Extractor(Extractor const&) = delete;
    Extractor(Extractor&&) = delete;
    Extractor&
    operator=(Extractor const&) = delete;
    Extractor&
    operator=(Extractor&&) = delete;
 
    [[nodiscard]] std::optional<model::LedgerData>
    extractLedgerWithDiff(uint32_t seq) override;
 
    [[nodiscard]] std::optional<model::LedgerData>
    extractLedgerOnly(uint32_t seq) override;
};
 
}  // namespace etl::impl