Protocol.h

#pragma once
 
#include <xrpl/basics/ByteUtilities.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/Units.h>
 
#include <cstdint>
 
namespace xrpl {
 
std::size_t constexpr txMinSizeBytes = 32;
 
std::size_t constexpr txMaxSizeBytes = megabytes(1);
 
std::size_t constexpr unfundedOfferRemoveLimit = 1000;
 
std::size_t constexpr expiredOfferRemoveLimit = 256;
 
std::size_t constexpr oversizeMetaDataCap = 5200;
 
std::size_t constexpr dirNodeMaxEntries = 32;
 
std::uint64_t constexpr dirNodeMaxPages = 262144;
 
std::size_t constexpr dirMaxTokensPerPage = 32;
 
std::size_t constexpr maxDeletableDirEntries = 1000;
 
std::size_t constexpr maxTokenOfferCancelCount = 500;
 
std::size_t constexpr maxDeletableTokenOfferEntries = 500;
 
std::uint16_t constexpr maxTransferFee = 50000;
 
Bips32 constexpr bipsPerUnity(100 * 100);
static_assert(bipsPerUnity == Bips32{10'000});
TenthBips32 constexpr tenthBipsPerUnity(bipsPerUnity.value() * 10);
static_assert(tenthBipsPerUnity == TenthBips32(100'000));
 
constexpr Bips32
percentageToBips(std::uint32_t percentage)
{
    return Bips32(percentage * bipsPerUnity.value() / 100);
}
constexpr TenthBips32
percentageToTenthBips(std::uint32_t percentage)
{
    return TenthBips32(percentage * tenthBipsPerUnity.value() / 100);
}
template <typename T, class TBips>
constexpr T
bipsOfValue(T value, Bips<TBips> bips)
{
    return value * bips.value() / bipsPerUnity.value();
}
template <typename T, class TBips>
constexpr T
tenthBipsOfValue(T value, TenthBips<TBips> bips)
{
    return value * bips.value() / tenthBipsPerUnity.value();
}
 
namespace Lending {
TenthBips16 constexpr maxManagementFeeRate(
    unsafe_cast<std::uint16_t>(percentageToTenthBips(10).value()));
static_assert(maxManagementFeeRate == TenthBips16(std::uint16_t(10'000u)));
 
TenthBips32 constexpr maxCoverRate = percentageToTenthBips(100);
static_assert(maxCoverRate == TenthBips32(100'000u));
 
TenthBips32 constexpr maxOverpaymentFee = percentageToTenthBips(100);
static_assert(maxOverpaymentFee == TenthBips32(100'000u));
 
TenthBips32 constexpr maxInterestRate = percentageToTenthBips(100);
static_assert(maxInterestRate == TenthBips32(100'000u));
 
TenthBips32 constexpr maxLateInterestRate = percentageToTenthBips(100);
static_assert(maxLateInterestRate == TenthBips32(100'000u));
 
TenthBips32 constexpr maxCloseInterestRate = percentageToTenthBips(100);
static_assert(maxCloseInterestRate == TenthBips32(100'000u));
 
TenthBips32 constexpr maxOverpaymentInterestRate = percentageToTenthBips(100);
static_assert(maxOverpaymentInterestRate == TenthBips32(100'000u));
 
static constexpr int loanPaymentsPerFeeIncrement = 5;
 
static constexpr int loanMaximumPaymentsPerTransaction = 100;
}  // namespace Lending
 
std::size_t constexpr maxTokenURILength = 256;
 
std::size_t constexpr maxDIDDocumentLength = 256;
 
std::size_t constexpr maxDIDURILength = 256;
 
std::size_t constexpr maxDIDDataLength = 256;
 
std::size_t constexpr maxDomainLength = 256;
 
std::size_t constexpr maxCredentialURILength = 256;
 
std::size_t constexpr maxCredentialTypeLength = 64;
 
std::size_t constexpr maxCredentialsArraySize = 8;
 
std::size_t constexpr maxPermissionedDomainCredentialsArraySize = 10;
 
std::size_t constexpr maxMPTokenMetadataLength = 1024;
 
std::uint64_t constexpr maxMPTokenAmount = 0x7FFF'FFFF'FFFF'FFFFull;
static_assert(Number::maxRep >= maxMPTokenAmount);
 
std::size_t constexpr maxDataPayloadLength = 256;
 
std::uint8_t constexpr vaultStrategyFirstComeFirstServe = 1;
 
std::uint8_t constexpr vaultDefaultIOUScale = 6;
std::uint8_t constexpr vaultMaximumIOUScale = 18;
 
std::uint8_t constexpr maxAssetCheckDepth = 5;
 
using LedgerIndex = std::uint32_t;
 
std::uint32_t constexpr FLAG_LEDGER_INTERVAL = 256;
 
bool
isVotingLedger(LedgerIndex seq);
 
bool
isFlagLedger(LedgerIndex seq);
 
using TxID = uint256;
 
std::uint16_t constexpr maxDeletableAMMTrustLines = 512;
 
std::size_t constexpr maxOracleURI = 256;
 
std::size_t constexpr maxOracleProvider = 256;
 
std::size_t constexpr maxOracleDataSeries = 10;
 
std::size_t constexpr maxOracleSymbolClass = 16;
 
std::size_t constexpr maxLastUpdateTimeDelta = 300;
 
std::size_t constexpr maxPriceScale = 20;
 
std::size_t constexpr maxTrim = 25;
 
std::size_t constexpr permissionMaxSize = 10;
 
std::size_t constexpr maxBatchTxCount = 8;
 
}  // namespace xrpl