support account mptokens

Author: yinyiqian1

src/rpc/CMakeLists.txt

@@ -24,6 +24,8 @@ target_sources(
           handlers/AccountCurrencies.cpp
           handlers/AccountInfo.cpp
           handlers/AccountLines.cpp
+          handlers/AccountMPTokenIssuances.cpp
+          handlers/AccountMPTokens.cpp
           handlers/AccountNFTs.cpp
           handlers/AccountObjects.cpp
           handlers/AccountOffers.cpp

src/rpc/common/impl/HandlerProvider.cpp

@@ -31,6 +31,8 @@
 #include "rpc/handlers/AccountCurrencies.hpp"
 #include "rpc/handlers/AccountInfo.hpp"
 #include "rpc/handlers/AccountLines.hpp"
+#include "rpc/handlers/AccountMPTokenIssuances.hpp"
+#include "rpc/handlers/AccountMPTokens.hpp"
 #include "rpc/handlers/AccountNFTs.hpp"
 #include "rpc/handlers/AccountObjects.hpp"
 #include "rpc/handlers/AccountOffers.hpp"
@@ -85,6 +87,9 @@ ProductionHandlerProvider::ProductionHandlerProvider(
           {"account_currencies", {.handler = AccountCurrenciesHandler{backend}}},
           {"account_info", {.handler = AccountInfoHandler{backend, amendmentCenter}}},
           {"account_lines", {.handler = AccountLinesHandler{backend}}},
+          {"account_mptoken_issuances",
+           {.handler = AccountMPTokenIssuancesHandler{backend}, .isClioOnly = true}},              // clio only
+          {"account_mptokens", {.handler = AccountMPTokensHandler{backend}, .isClioOnly = true}},  // clio only
           {"account_nfts", {.handler = AccountNFTsHandler{backend}}},
           {"account_objects", {.handler = AccountObjectsHandler{backend}}},
           {"account_offers", {.handler = AccountOffersHandler{backend}}},

src/rpc/handlers/AccountMPTokenIssuances.cpp

@@ -0,0 +1,247 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "rpc/handlers/AccountMPTokenIssuances.hpp"
+
+#include "rpc/Errors.hpp"
+#include "rpc/JS.hpp"
+#include "rpc/RPCHelpers.hpp"
+#include "rpc/common/Types.hpp"
+#include "util/Assert.hpp"
+#include "util/JsonUtils.hpp"
+
+#include <boost/json/conversion.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/value_to.hpp>
+#include <xrpl/basics/strHex.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/UintTypes.h>
+#include <xrpl/protocol/jss.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rpc {
+
+void
+AccountMPTokenIssuancesHandler::addMPTokenIssuance(
+    std::vector<MPTokenIssuancesResponse>& issuances,
+    ripple::SLE const& sle,
+    ripple::AccountID const& account
+)
+{
+    MPTokenIssuancesResponse issuance;
+
+    issuance.issuer = ripple::to_string(account);
+    issuance.sequence = sle.getFieldU32(ripple::sfSequence);
+    auto const flags = sle.getFieldU32(ripple::sfFlags);
+
+    if ((flags & ripple::lsfMPTLocked) != 0u)
+        issuance.mptLocked = true;
+    if ((flags & ripple::lsfMPTCanLock) != 0u)
+        issuance.mptCanLock = true;
+    if ((flags & ripple::lsfMPTRequireAuth) != 0u)
+        issuance.mptRequireAuth = true;
+    if ((flags & ripple::lsfMPTCanEscrow) != 0u)
+        issuance.mptCanEscrow = true;
+    if ((flags & ripple::lsfMPTCanTrade) != 0u)
+        issuance.mptCanTrade = true;
+    if ((flags & ripple::lsfMPTCanTransfer) != 0u)
+        issuance.mptCanTransfer = true;
+    if ((flags & ripple::lsfMPTCanClawback) != 0u)
+        issuance.mptCanClawback = true;
+
+    if (sle.isFieldPresent(ripple::sfTransferFee))
+        issuance.transferFee = sle.getFieldU16(ripple::sfTransferFee);
+
+    if (sle.isFieldPresent(ripple::sfAssetScale))
+        issuance.assetScale = sle.getFieldU8(ripple::sfAssetScale);
+
+    if (sle.isFieldPresent(ripple::sfMaximumAmount))
+        issuance.maximumAmount = sle.getFieldU64(ripple::sfMaximumAmount);
+
+    if (sle.isFieldPresent(ripple::sfOutstandingAmount))
+        issuance.outstandingAmount = sle.getFieldU64(ripple::sfOutstandingAmount);
+
+    if (sle.isFieldPresent(ripple::sfLockedAmount))
+        issuance.lockedAmount = sle.getFieldU64(ripple::sfLockedAmount);
+
+    if (sle.isFieldPresent(ripple::sfMPTokenMetadata))
+        issuance.mptokenMetadata = ripple::strHex(sle.getFieldVL(ripple::sfMPTokenMetadata));
+
+    if (sle.isFieldPresent(ripple::sfDomainID))
+        issuance.domainID = ripple::strHex(sle.getFieldH256(ripple::sfDomainID));
+
+    issuances.push_back(issuance);
+}
+
+AccountMPTokenIssuancesHandler::Result
+AccountMPTokenIssuancesHandler::process(AccountMPTokenIssuancesHandler::Input const& input, Context const& ctx) const
+{
+    auto const range = sharedPtrBackend_->fetchLedgerRange();
+    ASSERT(range.has_value(), "AccountMPTokenIssuances' ledger range must be available");
+    auto const expectedLgrInfo = getLedgerHeaderFromHashOrSeq(
+        *sharedPtrBackend_, ctx.yield, input.ledgerHash, input.ledgerIndex, range->maxSequence
+    );
+
+    if (!expectedLgrInfo.has_value())
+        return Error{expectedLgrInfo.error()};
+
+    auto const& lgrInfo = expectedLgrInfo.value();
+    auto const accountID = accountFromStringStrict(input.account);
+    auto const accountLedgerObject =
+        sharedPtrBackend_->fetchLedgerObject(ripple::keylet::account(*accountID).key, lgrInfo.seq, ctx.yield);
+
+    if (not accountLedgerObject)
+        return Error{Status{RippledError::rpcACT_NOT_FOUND, "accountNotFound"}};
+
+    Output response;
+    response.issuances.reserve(input.limit);
+
+    auto const addToResponse = [&](ripple::SLE const& sle) {
+        if (sle.getType() == ripple::ltMPTOKEN_ISSUANCE) {
+            addMPTokenIssuance(response.issuances, sle, *accountID);
+        }
+    };
+
+    auto const expectedNext = traverseOwnedNodes(
+        *sharedPtrBackend_, *accountID, lgrInfo.seq, input.limit, input.marker, ctx.yield, addToResponse
+    );
+
+    if (!expectedNext.has_value())
+        return Error{expectedNext.error()};
+
+    auto const nextMarker = expectedNext.value();
+
+    response.account = input.account;
+    response.limit = input.limit;
+
+    response.ledgerHash = ripple::strHex(lgrInfo.hash);
+    response.ledgerIndex = lgrInfo.seq;
+
+    if (nextMarker.isNonZero())
+        response.marker = nextMarker.toString();
+
+    return response;
+}
+
+AccountMPTokenIssuancesHandler::Input
+tag_invoke(boost::json::value_to_tag<AccountMPTokenIssuancesHandler::Input>, boost::json::value const& jv)
+{
+    auto input = AccountMPTokenIssuancesHandler::Input{};
+    auto const& jsonObject = jv.as_object();
+
+    input.account = boost::json::value_to<std::string>(jv.at(JS(account)));
+
+    if (jsonObject.contains(JS(limit)))
+        input.limit = util::integralValueAs<uint32_t>(jv.at(JS(limit)));
+
+    if (jsonObject.contains(JS(marker)))
+        input.marker = boost::json::value_to<std::string>(jv.at(JS(marker)));
+
+    if (jsonObject.contains(JS(ledger_hash)))
+        input.ledgerHash = boost::json::value_to<std::string>(jv.at(JS(ledger_hash)));
+
+    if (jsonObject.contains(JS(ledger_index))) {
+        if (!jsonObject.at(JS(ledger_index)).is_string()) {
+            input.ledgerIndex = util::integralValueAs<uint32_t>(jv.at(JS(ledger_index)));
+        } else if (jsonObject.at(JS(ledger_index)).as_string() != "validated") {
+            input.ledgerIndex = std::stoi(boost::json::value_to<std::string>(jv.at(JS(ledger_index))));
+        }
+    }
+
+    return input;
+}
+
+void
+tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AccountMPTokenIssuancesHandler::Output const& output)
+{
+    using boost::json::value_from;
+
+    auto obj = boost::json::object{
+        {JS(account), output.account},
+        {JS(ledger_hash), output.ledgerHash},
+        {JS(ledger_index), output.ledgerIndex},
+        {JS(validated), output.validated},
+        {JS(limit), output.limit},
+        {"mpt_issuances", value_from(output.issuances)},
+    };
+
+    if (output.marker)
+        obj[JS(marker)] = output.marker.value();
+
+    jv = std::move(obj);
+}
+
+void
+tag_invoke(
+    boost::json::value_from_tag,
+    boost::json::value& jv,
+    AccountMPTokenIssuancesHandler::MPTokenIssuancesResponse const& issuance
+)
+{
+    auto obj = boost::json::object{
+        {JS(issuer), issuance.issuer},
+        {JS(sequence), issuance.sequence},
+    };
+
+    if (issuance.transferFee)
+        obj["transfer_fee"] = *issuance.transferFee;
+    if (issuance.assetScale)
+        obj["asset_scale"] = *issuance.assetScale;
+    if (issuance.maximumAmount)
+        obj["maximum_amount"] = *issuance.maximumAmount;
+    if (issuance.outstandingAmount)
+        obj["outstanding_amount"] = *issuance.outstandingAmount;
+    if (issuance.lockedAmount)
+        obj["locked_amount"] = *issuance.lockedAmount;
+    if (issuance.mptokenMetadata)
+        obj["mptoken_metadata"] = *issuance.mptokenMetadata;
+    if (issuance.domainID)
+        obj["domain_id"] = *issuance.domainID;
+
+    if (issuance.mptLocked)
+        obj["mpt_locked"] = *issuance.mptLocked;
+    if (issuance.mptCanLock)
+        obj["mpt_can_lock"] = *issuance.mptCanLock;
+    if (issuance.mptRequireAuth)
+        obj["mpt_require_auth"] = *issuance.mptRequireAuth;
+    if (issuance.mptCanEscrow)
+        obj["mpt_can_escrow"] = *issuance.mptCanEscrow;
+    if (issuance.mptCanTrade)
+        obj["mpt_can_trade"] = *issuance.mptCanTrade;
+    if (issuance.mptCanTransfer)
+        obj["mpt_can_transfer"] = *issuance.mptCanTransfer;
+    if (issuance.mptCanClawback)
+        obj["mpt_can_clawback"] = *issuance.mptCanClawback;
+
+    jv = std::move(obj);
+}
+
+}  // namespace rpc