STTx.h

#pragma once
 
#include <xrpl/basics/Blob.h>
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/HashPrefix.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STBase.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/SeqProxy.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/Sign.h>
#include <xrpl/protocol/TxFormats.h>
 
#include <boost/container/flat_set.hpp>
 
#include <cstddef>
#include <cstdint>
#include <expected>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace xrpl {
 
enum class TxnSql : char {
    New = 'N',
    Conflict = 'C',
    Held = 'H',
    Validated = 'V',
    Included = 'I',
    Unknown = 'U'
};
 
class STTx final : public STObject, public CountedObject<STTx>
{
    UInt256 tid_;
    TxType txType_;
 
public:
    static constexpr std::size_t kMinMultiSigners = 1;
    static constexpr std::size_t kMaxMultiSigners = 32;
 
    STTx() = delete;
    STTx(STTx const& other) = default;
    STTx&
    operator=(STTx const& other) = delete;
 
    explicit STTx(SerialIter& sit);
    explicit STTx(SerialIter&& sit);
    explicit STTx(STObject&& object);

    STTx(TxType type, std::function<void(STObject&)> assembler);
 
    // STObject functions.
    [[nodiscard]] SerializedTypeID
    getSType() const override;
 
    [[nodiscard]] std::string
    getFullText() const override;
 
    // Outer transaction functions / signature functions.
    static Blob
    getSignature(STObject const& sigObject);
 
    [[nodiscard]] Blob
    getSignature() const
    {
        return getSignature(*this);
    }
 
    [[nodiscard]] UInt256
    getSigningHash() const;
 
    [[nodiscard]] TxType
    getTxnType() const;
 
    [[nodiscard]] Blob
    getSigningPubKey() const;
 
    [[nodiscard]] SeqProxy
    getSeqProxy() const;
 
    [[nodiscard]] boost::container::flat_set<AccountID>
    getMentionedAccounts() const;
 
    [[nodiscard]] UInt256
    getTransactionID() const;
 
    [[nodiscard]] json::Value
    getJson(JsonOptions options) const override;
 
    [[nodiscard]] json::Value
    getJson(JsonOptions options, bool binary) const;

    void
    sign(PublicKey const& publicKey, SecretKey const& secretKey);

    void
    sign(
        PublicKey const& publicKey,
        SecretKey const& secretKey,
        SignatureRole role,
        Rules const& rules);

    [[nodiscard]] std::expected<void, std::string>
    checkSign(Rules const& rules) const;
 
    [[nodiscard]] std::expected<void, std::string>
    checkBatchSign() const;
 
    // SQL Functions with metadata.
    static std::string const&
    getMetaSQLInsertReplaceHeader();
 
    [[nodiscard]] std::string
    getMetaSQL(std::uint32_t inLedger, std::string const& escapedMetaData) const;
 
    [[nodiscard]] std::string
    getMetaSQL(
        Serializer rawTxn,
        std::uint32_t inLedger,
        TxnSql status,
        std::string const& escapedMetaData) const;

    [[nodiscard]] std::vector<UInt256>
    getBatchTransactionIDs() const;

    [[nodiscard]] std::vector<std::shared_ptr<STTx const>> const&
    getBatchTransactions() const;

    [[nodiscard]] AccountID
    getInitiator() const;
 
    [[nodiscard]] AccountID
    getFeePayerID() const;
 
private:
    [[nodiscard]] std::expected<void, std::string>
    checkSign(Rules const& rules, STObject const& sigObject, SignatureRole role) const;
 
    [[nodiscard]] std::expected<void, std::string>
    checkSingleSign(STObject const& sigObject, HashPrefix prefix) const;
 
    [[nodiscard]] std::expected<void, std::string>
    checkMultiSign(STObject const& sigObject, HashPrefix prefix) const;
 
    [[nodiscard]] std::expected<void, std::string>
    checkBatchSingleSign(STObject const& batchSigner, std::vector<UInt256> const& txIds) const;
 
    [[nodiscard]] std::expected<void, std::string>
    checkBatchMultiSign(STObject const& batchSigner, std::vector<UInt256> const& txIds) const;
 
    void
    buildBatchTxns();
 
    STBase*
    copy(std::size_t n, void* buf) const override;
    STBase*
    move(std::size_t n, void* buf) override;
 
    friend class detail::STVar;
    std::optional<std::vector<std::shared_ptr<STTx const>>> batchTxns_;
};
 
bool
passesLocalChecks(STTx const& tx, std::string&);

std::shared_ptr<STTx const>
sterilize(STTx const& stx);

bool
isPseudoTx(STObject const& tx);
 
inline STTx::STTx(SerialIter&& sit)  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
    : STTx(sit)
{
}
 
inline TxType
STTx::getTxnType() const
{
    return txType_;
}
 
inline Blob
STTx::getSigningPubKey() const
{
    return getFieldVL(sfSigningPubKey);
}
 
inline UInt256
STTx::getTransactionID() const
{
    return tid_;
}
 
}  // namespace xrpl