TransactionBuilderBase.h

#pragma once
 
#include <xrpl/protocol/HashPrefix.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAccount.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STArray.h>
#include <xrpl/protocol/STBlob.h>
#include <xrpl/protocol/STInteger.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STXChainBridge.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol/jss.h>
 
namespace xrpl::transactions {
 
template <typename Derived>
class TransactionBuilderBase
{
public:
    TransactionBuilderBase() = default;
 
    TransactionBuilderBase(
        SF_UINT16::type::value_type transactionType,
        SF_ACCOUNT::type::value_type account,
        std::optional<SF_UINT32::type::value_type> sequence,
        std::optional<SF_AMOUNT::type::value_type> fee)
    {
        // Don't call object_.set(soTemplate) - keep object_ as a free object.
        // This avoids creating STBase placeholders for soeDEFAULT fields,
        // which would cause applyTemplate() to throw "may not be explicitly
        // set to default" when building the STTx.
        // The STTx constructor will call applyTemplate() which properly
        // handles missing fields.
        object_[sfTransactionType] = transactionType;
        setAccount(account);
 
        if (sequence)
        {
            setSequence(*sequence);
        }
        if (fee)
        {
            setFee(*fee);
        }
    }
 
    Derived&
    setAccount(AccountID const& value)
    {
        object_[sfAccount] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setFee(STAmount const& value)
    {
        object_[sfFee] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setSequence(std::uint32_t const& value)
    {
        object_[sfSequence] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setTicketSequence(std::uint32_t const& value)
    {
        object_[sfSequence] = 0u;
        object_[sfTicketSequence] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setFlags(std::uint32_t const& value)
    {
        object_[sfFlags] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setSourceTag(std::uint32_t const& value)
    {
        object_[sfSourceTag] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setLastLedgerSequence(std::uint32_t const& value)
    {
        object_[sfLastLedgerSequence] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setAccountTxnID(uint256 const& value)
    {
        object_[sfAccountTxnID] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setPreviousTxnID(uint256 const& value)
    {
        object_[sfPreviousTxnID] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setOperationLimit(std::uint32_t const& value)
    {
        object_[sfOperationLimit] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setMemos(STArray const& value)
    {
        object_.setFieldArray(sfMemos, value);
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setSigners(STArray const& value)
    {
        object_.setFieldArray(sfSigners, value);
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setNetworkID(std::uint32_t const& value)
    {
        object_[sfNetworkID] = value;
        return static_cast<Derived&>(*this);
    }
 
    Derived&
    setDelegate(AccountID const& value)
    {
        object_[sfDelegate] = value;
        return static_cast<Derived&>(*this);
    }
 
    STObject const&
    getSTObject() const
    {
        return object_;
    }
 
protected:
    Derived&
    sign(PublicKey const& publicKey, SecretKey const& secretKey)
    {
        // Set the signing public key
        object_.setFieldVL(sfSigningPubKey, publicKey.slice());
 
        // Build the signing data: HashPrefix::txSign + serialized object
        // (without signing fields)
        Serializer s;
        s.add32(HashPrefix::txSign);
        object_.addWithoutSigningFields(s);
 
        // Sign and set the signature
        auto const sig = xrpl::sign(publicKey, secretKey, s.slice());
        object_.setFieldVL(sfTxnSignature, sig);
 
        return static_cast<Derived&>(*this);
    }
 
    STObject object_{sfTransaction};
};
 
}  // namespace xrpl::transactions