Protocol.h

#pragma once
 
#include <xrpl/basics/ByteUtilities.h>
#include <xrpl/basics/Number.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/safe_cast.h>
#include <xrpl/protocol/Units.h>
 
#include <mpt_protocol.h>
#include <secp256k1_mpt.h>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <limits>
 
namespace xrpl {

constexpr std::size_t kTxMinSizeBytes = 32;

constexpr std::size_t kTxMaxSizeBytes = megabytes(1);

constexpr std::size_t kUnfundedOfferRemoveLimit = 1000;

constexpr std::size_t kExpiredOfferRemoveLimit = 256;

constexpr std::size_t kOversizeMetaDataCap = 5200;

constexpr std::size_t kDirNodeMaxEntries = 32;

constexpr std::uint64_t kDirNodeMaxPages = 262144;

constexpr std::size_t kDirMaxTokensPerPage = 32;

constexpr std::size_t kMaxDeletableDirEntries = 1000;

constexpr std::size_t kMaxTokenOfferCancelCount = 500;

constexpr std::size_t kMaxDeletableTokenOfferEntries = 500;

constexpr std::uint16_t kMaxTransferFee = 50000;

constexpr Bips32 kBipsPerUnity(100 * 100);
static_assert(kBipsPerUnity == Bips32{10'000});
constexpr TenthBips32 kTenthBipsPerUnity(kBipsPerUnity.value() * 10);
static_assert(kTenthBipsPerUnity == TenthBips32(100'000));
 
constexpr Bips32
percentageToBips(std::uint32_t percentage)
{
    return Bips32(percentage * kBipsPerUnity.value() / 100);
}
constexpr TenthBips32
percentageToTenthBips(std::uint32_t percentage)
{
    return TenthBips32(percentage * kTenthBipsPerUnity.value() / 100);
}
template <typename T, class TBips>
constexpr T
bipsOfValue(T value, Bips<TBips> bips)
{
    return value * bips.value() / kBipsPerUnity.value();
}
template <typename T, class TBips>
constexpr T
tenthBipsOfValue(T value, TenthBips<TBips> bips)
{
    return value * bips.value() / kTenthBipsPerUnity.value();
}
 
namespace lending {
constexpr TenthBips16 kMaxManagementFeeRate(
    unsafeCast<std::uint16_t>(percentageToTenthBips(10).value()));
static_assert(kMaxManagementFeeRate == TenthBips16(std::uint16_t(10'000u)));

constexpr TenthBips32 kMaxCoverRate = percentageToTenthBips(100);
static_assert(kMaxCoverRate == TenthBips32(100'000u));

constexpr TenthBips32 kMaxOverpaymentFee = percentageToTenthBips(100);
static_assert(kMaxOverpaymentFee == TenthBips32(100'000u));

constexpr TenthBips32 kMaxInterestRate = percentageToTenthBips(100);
static_assert(kMaxInterestRate == TenthBips32(100'000u));

constexpr TenthBips32 kMaxLateInterestRate = percentageToTenthBips(100);
static_assert(kMaxLateInterestRate == TenthBips32(100'000u));

constexpr TenthBips32 kMaxCloseInterestRate = percentageToTenthBips(100);
static_assert(kMaxCloseInterestRate == TenthBips32(100'000u));

constexpr TenthBips32 kMaxOverpaymentInterestRate = percentageToTenthBips(100);
static_assert(kMaxOverpaymentInterestRate == TenthBips32(100'000u));

static constexpr int kLoanPaymentsPerFeeIncrement = 5;

static constexpr int kLoanMaximumPaymentsPerTransaction = 100;
}  // namespace lending

constexpr std::size_t kMaxTokenUriLength = 256;

constexpr std::size_t kMaxDidDocumentLength = 256;

constexpr std::size_t kMaxDidUriLength = 256;

constexpr std::size_t kMaxDidDataLength = 256;

constexpr std::size_t kMaxDomainLength = 256;

constexpr std::size_t kMaxCredentialUriLength = 256;

constexpr std::size_t kMaxCredentialTypeLength = 64;

constexpr std::size_t kMaxCredentialsArraySize = 8;

constexpr std::size_t kMaxPermissionedDomainCredentialsArraySize = 10;

constexpr std::size_t kMaxMpTokenMetadataLength = 1024;

constexpr std::uint64_t kMaxMpTokenAmount = 0x7FFF'FFFF'FFFF'FFFFull;
static_assert(Number::kMaxRep >= kMaxMpTokenAmount);

constexpr std::size_t kMaxDataPayloadLength = 256;

constexpr std::uint8_t kVaultStrategyFirstComeFirstServe = 1;

constexpr std::uint8_t kVaultDefaultIouScale = 6;
constexpr std::uint8_t kVaultMaximumIouScale = 18;

enum class VaultVersion : uint8_t {
    Legacy = 0,
    CashBasis,
};

enum class VaultKind : std::uint8_t {
    OpenEnded = 0,
    ClosedEnded = 1,
};

enum class VaultPhase : std::uint8_t {
    NoPhase = 0,
    Subscription,
    Investment,
    Redemption,
};

constexpr std::uint32_t kLoanRedemptionBuffer = std::chrono::seconds{60}.count();

constexpr std::uint32_t kMinInvestmentPeriod = std::chrono::seconds{180}.count();
// This is 946708560 seconds which 30 x 365.2425 days (the average length of a Gregorian year).
constexpr std::uint32_t kMaxInvestmentPeriod = std::chrono::seconds{std::chrono::years{30}}.count();

constexpr std::uint8_t kMaxAssetCheckDepth = 5;

using LedgerIndex = std::uint32_t;
 
constexpr std::uint32_t kFlagLedgerInterval = 256;

bool
isVotingLedger(LedgerIndex seq);

bool
isFlagLedger(LedgerIndex seq);

using TxID = UInt256;

constexpr std::uint16_t kMaxDeletableAmmTrustLines = 512;

constexpr std::size_t kMaxOracleUri = 256;

constexpr std::size_t kMaxOracleProvider = 256;

constexpr std::size_t kMaxOracleDataSeries = 10;

constexpr std::size_t kMaxOracleSymbolClass = 16;

constexpr std::size_t kMaxLastUpdateTimeDelta = 300;

constexpr std::size_t kMaxPriceScale = 20;

constexpr std::size_t kMaxTrim = 25;

constexpr std::size_t kPermissionMaxSize = 10;

constexpr std::size_t kMaxBatchTxCount = 8;

constexpr std::size_t kMaxBatchSigners = kMaxBatchTxCount * 3;

constexpr std::size_t kEcScalarLength = kMPT_SCALAR_SIZE;

constexpr std::size_t kCompressedEcPointLength = 33;

constexpr std::size_t kEcCiphertextComponentLength = kMPT_ELGAMAL_CIPHER_SIZE;

constexpr std::size_t kEcGamalEncryptedTotalLength = kMPT_ELGAMAL_TOTAL_SIZE;

constexpr std::size_t kEcPubKeyLength = kMPT_PUBKEY_SIZE;

constexpr std::size_t kEcPrivKeyLength = kMPT_PRIVKEY_SIZE;

constexpr std::size_t kEcBlindingFactorLength = kMPT_BLINDING_FACTOR_SIZE;

constexpr std::size_t kEcSchnorrProofLength = kMPT_SCHNORR_PROOF_SIZE;

constexpr std::size_t kEcPedersenCommitmentLength = kMPT_PEDERSEN_COMMIT_SIZE;

constexpr std::size_t kEcSingleBulletproofLength = kMPT_SINGLE_BULLETPROOF_SIZE;

constexpr std::size_t kEcDoubleBulletproofLength = kMPT_DOUBLE_BULLETPROOF_SIZE;

constexpr std::size_t kEcSendSigmaProofLength = SECP256K1_COMPACT_STANDARD_PROOF_SIZE;

constexpr std::size_t kEcSendProofLength = kEcSendSigmaProofLength + kEcDoubleBulletproofLength;

constexpr std::size_t kEcConvertBackSigmaProofLength = SECP256K1_COMPACT_CONVERTBACK_PROOF_SIZE;

constexpr std::size_t kEcConvertBackProofLength =
    kEcConvertBackSigmaProofLength + kEcSingleBulletproofLength;

constexpr std::size_t kEcClawbackProofLength = SECP256K1_COMPACT_CLAWBACK_PROOF_SIZE;

constexpr std::size_t kEcEqualityProofLength = 128;

constexpr std::uint32_t kConfidentialFeeMultiplier = 9;

constexpr std::uint32_t kMaxKeyEpoch = std::numeric_limits<std::uint32_t>::max();

constexpr std::uint8_t kEcCompressedPrefixEvenY = 0x02;

constexpr std::uint8_t kEcCompressedPrefixOddY = 0x03;
 
}  // namespace xrpl