Vault.h

// This file is auto-generated. Do not edit.
#pragma once
 
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
 
#include <stdexcept>
#include <optional>
 
namespace xrpl::ledger_entries {
 
class VaultBuilder;

class Vault : public LedgerEntryBase
{
public:
    static constexpr LedgerEntryType entryType = ltVAULT;

    explicit Vault(SLE::const_pointer sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
        if (sle_->getType() != entryType)
        {
            throw std::runtime_error("Invalid ledger entry type for Vault");
        }
    }
 
    // Ledger entry-specific field getters

    [[nodiscard]]
    SF_UINT256::type::value_type
    getPreviousTxnID() const
    {
        return this->sle_->at(sfPreviousTxnID);
    }

    [[nodiscard]]
    SF_UINT32::type::value_type
    getPreviousTxnLgrSeq() const
    {
        return this->sle_->at(sfPreviousTxnLgrSeq);
    }

    [[nodiscard]]
    SF_UINT32::type::value_type
    getSequence() const
    {
        return this->sle_->at(sfSequence);
    }

    [[nodiscard]]
    SF_UINT64::type::value_type
    getOwnerNode() const
    {
        return this->sle_->at(sfOwnerNode);
    }

    [[nodiscard]]
    SF_ACCOUNT::type::value_type
    getOwner() const
    {
        return this->sle_->at(sfOwner);
    }

    [[nodiscard]]
    SF_ACCOUNT::type::value_type
    getAccount() const
    {
        return this->sle_->at(sfAccount);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_VL::type::value_type>
    getData() const
    {
        if (hasData())
            return this->sle_->at(sfData);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasData() const
    {
        return this->sle_->isFieldPresent(sfData);
    }

    [[nodiscard]]
    SF_ISSUE::type::value_type
    getAsset() const
    {
        return this->sle_->at(sfAsset);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_NUMBER::type::value_type>
    getAssetsTotal() const
    {
        if (hasAssetsTotal())
            return this->sle_->at(sfAssetsTotal);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasAssetsTotal() const
    {
        return this->sle_->isFieldPresent(sfAssetsTotal);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_NUMBER::type::value_type>
    getAssetsAvailable() const
    {
        if (hasAssetsAvailable())
            return this->sle_->at(sfAssetsAvailable);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasAssetsAvailable() const
    {
        return this->sle_->isFieldPresent(sfAssetsAvailable);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_NUMBER::type::value_type>
    getAssetsMaximum() const
    {
        if (hasAssetsMaximum())
            return this->sle_->at(sfAssetsMaximum);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasAssetsMaximum() const
    {
        return this->sle_->isFieldPresent(sfAssetsMaximum);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_NUMBER::type::value_type>
    getLossUnrealized() const
    {
        if (hasLossUnrealized())
            return this->sle_->at(sfLossUnrealized);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasLossUnrealized() const
    {
        return this->sle_->isFieldPresent(sfLossUnrealized);
    }

    [[nodiscard]]
    SF_UINT192::type::value_type
    getShareMPTID() const
    {
        return this->sle_->at(sfShareMPTID);
    }

    [[nodiscard]]
    SF_UINT8::type::value_type
    getWithdrawalPolicy() const
    {
        return this->sle_->at(sfWithdrawalPolicy);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT8::type::value_type>
    getScale() const
    {
        if (hasScale())
            return this->sle_->at(sfScale);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasScale() const
    {
        return this->sle_->isFieldPresent(sfScale);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT8::type::value_type>
    getLEVersion() const
    {
        if (hasLEVersion())
            return this->sle_->at(sfLEVersion);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasLEVersion() const
    {
        return this->sle_->isFieldPresent(sfLEVersion);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT8::type::value_type>
    getVaultKind() const
    {
        if (hasVaultKind())
            return this->sle_->at(sfVaultKind);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasVaultKind() const
    {
        return this->sle_->isFieldPresent(sfVaultKind);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT32::type::value_type>
    getSubscriptionDate() const
    {
        if (hasSubscriptionDate())
            return this->sle_->at(sfSubscriptionDate);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasSubscriptionDate() const
    {
        return this->sle_->isFieldPresent(sfSubscriptionDate);
    }

    [[nodiscard]]
    protocol_autogen::Optional<SF_UINT32::type::value_type>
    getRedemptionDate() const
    {
        if (hasRedemptionDate())
            return this->sle_->at(sfRedemptionDate);
        return std::nullopt;
    }

    [[nodiscard]]
    bool
    hasRedemptionDate() const
    {
        return this->sle_->isFieldPresent(sfRedemptionDate);
    }
};

class VaultBuilder : public LedgerEntryBuilderBase<VaultBuilder>
{
public:
    VaultBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ISSUE::type::value_type> const& asset,std::decay_t<typename SF_UINT192::type::value_type> const& shareMPTID,std::decay_t<typename SF_UINT8::type::value_type> const& withdrawalPolicy)
        : LedgerEntryBuilderBase<VaultBuilder>(ltVAULT)
    {
        setPreviousTxnID(previousTxnID);
        setPreviousTxnLgrSeq(previousTxnLgrSeq);
        setSequence(sequence);
        setOwnerNode(ownerNode);
        setOwner(owner);
        setAccount(account);
        setAsset(asset);
        setShareMPTID(shareMPTID);
        setWithdrawalPolicy(withdrawalPolicy);
    }

    VaultBuilder(SLE::const_pointer sle)
    {
        if (sle->at(sfLedgerEntryType) != ltVAULT)
        {
            throw std::runtime_error("Invalid ledger entry type for Vault");
        }
        object_ = *sle;
    }


    VaultBuilder&
    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
    {
        object_[sfPreviousTxnID] = value;
        return *this;
    }

    VaultBuilder&
    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
        object_[sfPreviousTxnLgrSeq] = value;
        return *this;
    }

    VaultBuilder&
    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
        object_[sfSequence] = value;
        return *this;
    }

    VaultBuilder&
    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
    {
        object_[sfOwnerNode] = value;
        return *this;
    }

    VaultBuilder&
    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
    {
        object_[sfOwner] = value;
        return *this;
    }

    VaultBuilder&
    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
    {
        object_[sfAccount] = value;
        return *this;
    }

    VaultBuilder&
    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
    {
        object_[sfData] = value;
        return *this;
    }

    VaultBuilder&
    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
    {
        object_[sfAsset] = STIssue(sfAsset, value);
        return *this;
    }

    VaultBuilder&
    setAssetsTotal(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
    {
        object_[sfAssetsTotal] = value;
        return *this;
    }

    VaultBuilder&
    setAssetsAvailable(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
    {
        object_[sfAssetsAvailable] = value;
        return *this;
    }

    VaultBuilder&
    setAssetsMaximum(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
    {
        object_[sfAssetsMaximum] = value;
        return *this;
    }

    VaultBuilder&
    setLossUnrealized(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
    {
        object_[sfLossUnrealized] = value;
        return *this;
    }

    VaultBuilder&
    setShareMPTID(std::decay_t<typename SF_UINT192::type::value_type> const& value)
    {
        object_[sfShareMPTID] = value;
        return *this;
    }

    VaultBuilder&
    setWithdrawalPolicy(std::decay_t<typename SF_UINT8::type::value_type> const& value)
    {
        object_[sfWithdrawalPolicy] = value;
        return *this;
    }

    VaultBuilder&
    setScale(std::decay_t<typename SF_UINT8::type::value_type> const& value)
    {
        object_[sfScale] = value;
        return *this;
    }

    VaultBuilder&
    setLEVersion(std::decay_t<typename SF_UINT8::type::value_type> const& value)
    {
        object_[sfLEVersion] = value;
        return *this;
    }

    VaultBuilder&
    setVaultKind(std::decay_t<typename SF_UINT8::type::value_type> const& value)
    {
        object_[sfVaultKind] = value;
        return *this;
    }

    VaultBuilder&
    setSubscriptionDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
        object_[sfSubscriptionDate] = value;
        return *this;
    }

    VaultBuilder&
    setRedemptionDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
    {
        object_[sfRedemptionDate] = value;
        return *this;
    }

    Vault
    build(uint256 const& index)
    {
        return Vault{std::make_shared<SLE>(std::move(object_), index)};
    }
};
 
}  // namespace xrpl::ledger_entries