ConfidentialMPTHolderKeyUpdate.cpp

#include <xrpl/tx/transactors/token/ConfidentialMPTHolderKeyUpdate.h>
 
#include <xrpl/basics/Slice.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/core/ServiceRegistry.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/ConfidentialTransfer.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/tx/Transactor.h>
 
#include <bit>
#include <cstdint>
 
namespace xrpl {
 
bool
ConfidentialMPTHolderKeyUpdate::checkExtraFeatures(PreflightContext const& ctx)
{
    // Holder key update is only meaningful when confidential transfers are enabled.
    return ctx.rules.enabled(featureConfidentialTransfer);
}
 
std::uint32_t
ConfidentialMPTHolderKeyUpdate::getFlagsMask(PreflightContext const& ctx)
{
    return tfConfidentialMPTHolderKeyUpdateMask;
}
 
NotTEC
ConfidentialMPTHolderKeyUpdate::preflight(PreflightContext const& ctx)
{
    bool const rotation = ctx.tx.isFlag(tfHolderKeyRotation);
    bool const recovery = ctx.tx.isFlag(tfHolderKeyRecovery);
    bool const cancel = ctx.tx.isFlag(tfCancelRecovery);
 
    // Exactly one of the three mode flags must be set.
    static constexpr auto modeFlags = tfHolderKeyRotation | tfHolderKeyRecovery | tfCancelRecovery;
    if (std::popcount(ctx.tx.getFlags() & modeFlags) != 1)
        return temINVALID_FLAG;
 
    // The issuer cannot hold confidential balances.
    if (ctx.tx[sfAccount] == MPTIssue(ctx.tx[sfMPTokenIssuanceID]).getIssuer())
        return temMALFORMED;
 
    bool const hasHolderKey = ctx.tx.isFieldPresent(sfHolderEncryptionKey);
    bool const hasSpending = ctx.tx.isFieldPresent(sfConfidentialBalanceSpending);
    bool const hasInbox = ctx.tx.isFieldPresent(sfConfidentialBalanceInbox);
    bool const hasProof = ctx.tx.isFieldPresent(sfZKProof);
 
    if (cancel)
    {
        // Cancel mode only revokes a pending recovery authorization; it
        // carries no key material, balances, or proof.
        if (hasHolderKey || hasSpending || hasInbox || hasProof)
            return temMALFORMED;
 
        return tesSUCCESS;
    }
 
    // Rotation and Recovery both require a holder key and a proof.
    if (!hasHolderKey || !hasProof)
        return temMALFORMED;
 
    // Rotation mode requires re-encrypted balances; Recovery mode must not
    // provide them since the holder cannot decrypt the current ones.
    if (rotation && (!hasSpending || !hasInbox))
        return temMALFORMED;
 
    if (recovery && (hasSpending || hasInbox))
        return temMALFORMED;
 
    if (hasSpending &&
        ctx.tx[sfConfidentialBalanceSpending].length() != kEcGamalEncryptedTotalLength)
        return temBAD_CIPHERTEXT;
 
    if (hasInbox && ctx.tx[sfConfidentialBalanceInbox].length() != kEcGamalEncryptedTotalLength)
        return temBAD_CIPHERTEXT;
 
    if (!isValidCompressedECPoint(ctx.tx[sfHolderEncryptionKey]))
        return temMALFORMED;
 
    if (hasSpending && !isValidCiphertext(ctx.tx[sfConfidentialBalanceSpending]))
        return temBAD_CIPHERTEXT;
 
    if (hasInbox && !isValidCiphertext(ctx.tx[sfConfidentialBalanceInbox]))
        return temBAD_CIPHERTEXT;
 
    return tesSUCCESS;
}
 
XRPAmount
ConfidentialMPTHolderKeyUpdate::calculateBaseFee(ReadView const& view, STTx const& tx)
{
    return Transactor::calculateBaseFee(view, tx, kConfidentialFeeMultiplier);
}
 
TER
ConfidentialMPTHolderKeyUpdate::preclaim(PreclaimContext const& ctx)
{
    auto const account = ctx.tx[sfAccount];
    auto const mptIssuanceID = ctx.tx[sfMPTokenIssuanceID];
 
    auto const sleIssuance = ctx.view.read(keylet::mptokenIssuance(mptIssuanceID));
    if (!sleIssuance)
        return tecOBJECT_NOT_FOUND;
 
    if (!sleIssuance->isFlag(lsfMPTCanHoldConfidentialBalance))
        return tecNO_PERMISSION;
 
    auto const sleMptoken = ctx.view.read(keylet::mptoken(mptIssuanceID, account));
    if (!sleMptoken)
        return tecOBJECT_NOT_FOUND;
 
    if (!sleMptoken->isFieldPresent(sfHolderEncryptionKey) ||
        !sleMptoken->isFieldPresent(sfConfidentialBalanceSpending) ||
        !sleMptoken->isFieldPresent(sfConfidentialBalanceInbox))
    {
        return tecNO_PERMISSION;
    }
 
    if (ctx.tx.isFlag(tfCancelRecovery))
    {
        // Nothing to cancel if no recovery is pending.
        if (!sleMptoken->isFieldPresent(sfRecoveryKey))
            return tecNO_PERMISSION;
 
        return tesSUCCESS;
    }
 
    if (ctx.tx[sfHolderEncryptionKey] == (*sleMptoken)[sfHolderEncryptionKey])
        return tecDUPLICATE;
 
    // Recovery mode: reject if a recovery is already pending
    if (ctx.tx.isFlag(tfHolderKeyRecovery) && sleMptoken->isFieldPresent(sfRecoveryKey))
        return tecNO_PERMISSION;
 
    return tesSUCCESS;
}
 
TER
ConfidentialMPTHolderKeyUpdate::doApply()
{
    auto const mptIssuanceID = ctx_.tx[sfMPTokenIssuanceID];
    auto sleMptoken = view().peek(keylet::mptoken(mptIssuanceID, accountID_));
    if (!sleMptoken)
    {
        // LCOV_EXCL_START
        UNREACHABLE(
            "xrpl::ConfidentialMPTHolderKeyUpdate::doApply : preclaim already validated the "
            "MPToken exists");
        return tecINTERNAL;
        // LCOV_EXCL_STOP
    }
 
    if (ctx_.tx.isFlag(tfCancelRecovery))
    {
        // The holder revokes their pending recovery authorization; the
        // current key and balances are left untouched.
        sleMptoken->makeFieldAbsent(sfRecoveryKey);
        view().update(sleMptoken);
        return tesSUCCESS;
    }
 
    auto const newPubKey = ctx_.tx[sfHolderEncryptionKey];
 
    if (ctx_.tx.isFlag(tfHolderKeyRotation))
    {
        // Replace the key and balances in rotation mode. Rotation proves the
        // holder still has the old key, so any pending recovery is cancelled.
        (*sleMptoken)[sfHolderEncryptionKey] = newPubKey;
        (*sleMptoken)[sfConfidentialBalanceSpending] = ctx_.tx[sfConfidentialBalanceSpending];
        (*sleMptoken)[sfConfidentialBalanceInbox] = ctx_.tx[sfConfidentialBalanceInbox];
        sleMptoken->makeFieldAbsent(sfRecoveryKey);
        incrementConfidentialVersion(*sleMptoken);
    }
    else if (ctx_.tx.isFlag(tfHolderKeyRecovery))
    {
        // Recovery mode: the holder cannot decrypt their current balances,
        // so only the pending recovery key is recorded. The balances are
        // rewritten separately by the issuer via ConfidentialMPTRecoverBalance.
        (*sleMptoken)[sfRecoveryKey] = newPubKey;
    }
    else
    {
        // LCOV_EXCL_START
        UNREACHABLE("xrpl::ConfidentialMPTHolderKeyUpdate::doApply : invalid mode");
        return tecINTERNAL;
        // LCOV_EXCL_STOP
    }
 
    view().update(sleMptoken);
    return tesSUCCESS;
}
 
void
ConfidentialMPTHolderKeyUpdate::visitInvariantEntry(bool, SLE::ConstRef, SLE::ConstRef)
{
}
 
bool
ConfidentialMPTHolderKeyUpdate::finalizeInvariants(
    STTx const&,
    TER,
    XRPAmount,
    ReadView const&,
    beast::Journal const&)
{
    return true;
}
 
}  // namespace xrpl