include/xrpl/protocol/ConfidentialTransfer.h

#pragma once
 
#include <xrpl/basics/Buffer.h>
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STInteger.h>  // IWYU pragma: keep
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/detail/secp256k1.h>
 
#include <secp256k1.h>
 
#include <cstdint>
#include <limits>
#include <optional>
 
namespace xrpl {

struct ConfidentialRecipient
{
    Slice publicKey;

    Slice encryptedAmount;
};

struct EcPair
{
    secp256k1_pubkey c1;

    secp256k1_pubkey c2;
};

inline void
incrementConfidentialVersion(STObject& mptoken)
{
    // Retrieve current version and increment, wrapping back to 0 at UINT32_MAX.
    // The wrap is computed explicitly rather than relying on unsigned overflow
    // of `+ 1u`, as it trips the unsigned-integer-overflow sanitizer in the UBSan CI build.
    auto const current = mptoken[~sfConfidentialBalanceVersion].valueOr(0u);
    mptoken[sfConfidentialBalanceVersion] =
        current == std::numeric_limits<std::uint32_t>::max() ? 0u : current + 1u;
}

uint256
getSendContextHash(
    AccountID const& account,
    uint192 const& issuanceID,
    std::uint32_t sequence,
    AccountID const& destination,
    std::uint32_t version);

uint256
getClawbackContextHash(
    AccountID const& account,
    uint192 const& issuanceID,
    std::uint32_t sequence,
    AccountID const& holder);

uint256
getConvertContextHash(AccountID const& account, uint192 const& issuanceID, std::uint32_t sequence);

uint256
getConvertBackContextHash(
    AccountID const& account,
    uint192 const& issuanceID,
    std::uint32_t sequence,
    std::uint32_t version);

std::optional<EcPair>
makeEcPair(Slice const& buffer);

std::optional<Buffer>
serializeEcPair(EcPair const& pair);

bool
isValidCiphertext(Slice const& buffer);

bool
isValidCompressedECPoint(Slice const& buffer);

std::optional<Buffer>
homomorphicAdd(Slice const& a, Slice const& b);

std::optional<Buffer>
homomorphicSubtract(Slice const& a, Slice const& b);

std::optional<Buffer>
rerandomizeCiphertext(Slice const& ciphertext, Slice const& pubKeySlice, Slice const& randomness);

std::optional<Buffer>
encryptAmount(uint64_t const amt, Slice const& pubKeySlice, Slice const& blindingFactor);

std::optional<Buffer>
encryptCanonicalZeroAmount(Slice const& pubKeySlice, AccountID const& account, MPTID const& mptId);

TER
verifySchnorrProof(Slice const& pubKeySlice, Slice const& proofSlice, uint256 const& contextHash);

NotTEC
checkEncryptedAmountFormat(STObject const& object);

TER
verifyRevealedAmount(
    uint64_t const amount,
    Slice const& blindingFactor,
    ConfidentialRecipient const& holder,
    ConfidentialRecipient const& issuer,
    std::optional<ConfidentialRecipient> const& auditor);

constexpr uint8_t
getConfidentialRecipientCount(bool hasAuditor)
{
    return hasAuditor ? 4 : 3;
}

TER
verifyClawbackProof(
    uint64_t const amount,
    Slice const& proof,
    Slice const& pubKeySlice,
    Slice const& ciphertext,
    uint256 const& contextHash);

Buffer
generateBlindingFactor();

TER
verifySendProof(
    Slice const& proof,
    ConfidentialRecipient const& sender,
    ConfidentialRecipient const& destination,
    ConfidentialRecipient const& issuer,
    std::optional<ConfidentialRecipient> const& auditor,
    Slice const& spendingBalance,
    Slice const& amountCommitment,
    Slice const& balanceCommitment,
    uint256 const& contextHash);

TER
verifyConvertBackProof(
    Slice const& proof,
    Slice const& pubKeySlice,
    Slice const& spendingBalance,
    Slice const& balanceCommitment,
    uint64_t amount,
    uint256 const& contextHash);
 
}  // namespace xrpl