TransactionBase.h

#pragma once
 
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAccount.h>
#include <xrpl/protocol/STArray.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol_autogen/STObjectValidation.h>
#include <xrpl/protocol_autogen/Utils.h>
 
#include <optional>
#include <string>
 
namespace xrpl::transactions {
 
class TransactionBase
{
public:
    explicit TransactionBase(std::shared_ptr<STTx const> tx) : tx_(std::move(tx))
    {
    }
 
    [[nodiscard]]
    bool
    validate(std::string& reason) const
    {
        if (!protocol_autogen::validateSTObject(
                *tx_, TxFormats::getInstance().findByType(tx_->getTxnType())->getSOTemplate()))
        {
            // LCOV_EXCL_START
            reason = "Transaction failed schema validation";
            return false;
            // LCOV_EXCL_STOP
        }
 
        // Pseudo transactions are not submitted to the network
        if (isPseudoTx(*tx_))
        {
            return true;
        }
        return passesLocalChecks(*tx_, reason);
    }
 
    [[nodiscard]]
    xrpl::TxType
    getTransactionType() const
    {
        return tx_->getTxnType();
    }
 
    [[nodiscard]]
    AccountID
    getAccount() const
    {
        return tx_->at(sfAccount);
    }
 
    [[nodiscard]]
    std::uint32_t
    getSequence() const
    {
        return tx_->at(sfSequence);
    }
 
    [[nodiscard]]
    STAmount
    getFee() const
    {
        return tx_->at(sfFee);
    }
 
    [[nodiscard]]
    Blob
    getSigningPubKey() const
    {
        return tx_->getFieldVL(sfSigningPubKey);
    }
 
    [[nodiscard]]
    std::optional<uint32_t>
    getFlags() const
    {
        if (tx_->isFieldPresent(sfFlags))
            return tx_->at(sfFlags);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasFlags() const
    {
        return tx_->isFieldPresent(sfFlags);
    }
 
    [[nodiscard]]
    std::optional<uint32_t>
    getSourceTag() const
    {
        if (tx_->isFieldPresent(sfSourceTag))
            return tx_->at(sfSourceTag);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasSourceTag() const
    {
        return tx_->isFieldPresent(sfSourceTag);
    }
 
    [[nodiscard]]
    std::optional<uint256>
    getPreviousTxnID() const
    {
        if (tx_->isFieldPresent(sfPreviousTxnID))
            return tx_->at(sfPreviousTxnID);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasPreviousTxnID() const
    {
        return tx_->isFieldPresent(sfPreviousTxnID);
    }
 
    [[nodiscard]]
    std::optional<uint32_t>
    getLastLedgerSequence() const
    {
        if (tx_->isFieldPresent(sfLastLedgerSequence))
            return tx_->at(sfLastLedgerSequence);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasLastLedgerSequence() const
    {
        return tx_->isFieldPresent(sfLastLedgerSequence);
    }
 
    [[nodiscard]]
    std::optional<uint256>
    getAccountTxnID() const
    {
        if (tx_->isFieldPresent(sfAccountTxnID))
            return tx_->at(sfAccountTxnID);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasAccountTxnID() const
    {
        return tx_->isFieldPresent(sfAccountTxnID);
    }
 
    [[nodiscard]]
    std::optional<uint32_t>
    getOperationLimit() const
    {
        if (tx_->isFieldPresent(sfOperationLimit))
            return tx_->at(sfOperationLimit);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasOperationLimit() const
    {
        return tx_->isFieldPresent(sfOperationLimit);
    }
 
    [[nodiscard]]
    std::optional<std::reference_wrapper<STArray const>>
    getMemos() const
    {
        if (tx_->isFieldPresent(sfMemos))
            return tx_->getFieldArray(sfMemos);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasMemos() const
    {
        return tx_->isFieldPresent(sfMemos);
    }
 
    [[nodiscard]]
    std::optional<uint32_t>
    getTicketSequence() const
    {
        if (tx_->isFieldPresent(sfTicketSequence))
            return tx_->at(sfTicketSequence);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasTicketSequence() const
    {
        return tx_->isFieldPresent(sfTicketSequence);
    }
 
    [[nodiscard]]
    std::optional<Blob>
    getTxnSignature() const
    {
        if (tx_->isFieldPresent(sfTxnSignature))
            return tx_->getFieldVL(sfTxnSignature);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasTxnSignature() const
    {
        return tx_->isFieldPresent(sfTxnSignature);
    }
 
    [[nodiscard]]
    std::optional<std::reference_wrapper<STArray const>>
    getSigners() const
    {
        if (tx_->isFieldPresent(sfSigners))
            return tx_->getFieldArray(sfSigners);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasSigners() const
    {
        return tx_->isFieldPresent(sfSigners);
    }
 
    [[nodiscard]]
    std::optional<uint32_t>
    getNetworkID() const
    {
        if (tx_->isFieldPresent(sfNetworkID))
            return tx_->at(sfNetworkID);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasNetworkID() const
    {
        return tx_->isFieldPresent(sfNetworkID);
    }
 
    [[nodiscard]]
    std::optional<AccountID>
    getDelegate() const
    {
        if (tx_->isFieldPresent(sfDelegate))
            return tx_->at(sfDelegate);
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool
    hasDelegate() const
    {
        return tx_->isFieldPresent(sfDelegate);
    }
 
    [[nodiscard]]
    std::shared_ptr<STTx const>
    getSTTx() const
    {
        return tx_;
    }
 
protected:
    std::shared_ptr<STTx const> tx_;
};
 
}  // namespace xrpl::transactions