STTx.h

#ifndef XRPL_PROTOCOL_STTX_H_INCLUDED
#define XRPL_PROTOCOL_STTX_H_INCLUDED
 
#include <xrpl/basics/Expected.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/SeqProxy.h>
#include <xrpl/protocol/TxFormats.h>
 
#include <boost/container/flat_set.hpp>
 
#include <functional>
 
namespace ripple {
 
enum TxnSql : char {
    txnSqlNew = 'N',
    txnSqlConflict = 'C',
    txnSqlHeld = 'H',
    txnSqlValidated = 'V',
    txnSqlIncluded = 'I',
    txnSqlUnknown = 'U'
};
 
class STTx final : public STObject, public CountedObject<STTx>
{
    uint256 tid_;
    TxType tx_type_;
 
public:
    static constexpr std::size_t minMultiSigners = 1;
    static constexpr std::size_t maxMultiSigners = 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.
    SerializedTypeID
    getSType() const override;
 
    std::string
    getFullText() const override;
 
    // Outer transaction functions / signature functions.
    static Blob
    getSignature(STObject const& sigObject);
 
    Blob
    getSignature() const
    {
        return getSignature(*this);
    }
 
    uint256
    getSigningHash() const;
 
    TxType
    getTxnType() const;
 
    Blob
    getSigningPubKey() const;
 
    SeqProxy
    getSeqProxy() const;
 
    std::uint32_t
    getSeqValue() const;
 
    boost::container::flat_set<AccountID>
    getMentionedAccounts() const;
 
    uint256
    getTransactionID() const;
 
    Json::Value
    getJson(JsonOptions options) const override;
 
    Json::Value
    getJson(JsonOptions options, bool binary) const;
 
    void
    sign(
        PublicKey const& publicKey,
        SecretKey const& secretKey,
        std::optional<std::reference_wrapper<SField const>> signatureTarget =
            {});
 
    enum class RequireFullyCanonicalSig : bool { no, yes };
 
    Expected<void, std::string>
    checkSign(RequireFullyCanonicalSig requireCanonicalSig, Rules const& rules)
        const;
 
    Expected<void, std::string>
    checkBatchSign(
        RequireFullyCanonicalSig requireCanonicalSig,
        Rules const& rules) const;
 
    // SQL Functions with metadata.
    static std::string const&
    getMetaSQLInsertReplaceHeader();
 
    std::string
    getMetaSQL(std::uint32_t inLedger, std::string const& escapedMetaData)
        const;
 
    std::string
    getMetaSQL(
        Serializer rawTxn,
        std::uint32_t inLedger,
        char status,
        std::string const& escapedMetaData) const;
 
    std::vector<uint256> const&
    getBatchTransactionIDs() const;
 
private:
    Expected<void, std::string>
    checkSign(
        RequireFullyCanonicalSig requireCanonicalSig,
        Rules const& rules,
        STObject const& sigObject) const;
 
    Expected<void, std::string>
    checkSingleSign(
        RequireFullyCanonicalSig requireCanonicalSig,
        STObject const& sigObject) const;
 
    Expected<void, std::string>
    checkMultiSign(
        RequireFullyCanonicalSig requireCanonicalSig,
        Rules const& rules,
        STObject const& sigObject) const;
 
    Expected<void, std::string>
    checkBatchSingleSign(
        STObject const& batchSigner,
        RequireFullyCanonicalSig requireCanonicalSig) const;
 
    Expected<void, std::string>
    checkBatchMultiSign(
        STObject const& batchSigner,
        RequireFullyCanonicalSig requireCanonicalSig,
        Rules const& rules) const;
 
    STBase*
    copy(std::size_t n, void* buf) const override;
    STBase*
    move(std::size_t n, void* buf) override;
 
    friend class detail::STVar;
    mutable std::vector<uint256> batchTxnIds_;
};
 
bool
passesLocalChecks(STObject const& st, std::string&);
 
std::shared_ptr<STTx const>
sterilize(STTx const& stx);
 
bool
isPseudoTx(STObject const& tx);
 
inline STTx::STTx(SerialIter&& sit) : STTx(sit)
{
}
 
inline TxType
STTx::getTxnType() const
{
    return tx_type_;
}
 
inline Blob
STTx::getSigningPubKey() const
{
    return getFieldVL(sfSigningPubKey);
}
 
inline uint256
STTx::getTransactionID() const
{
    return tid_;
}
 
}  // namespace ripple
 
#endif