feat: Implement MPT changes

src/data/BackendInterface.hpp

@@ -342,8 +342,7 @@ class BackendInterface {
      *
      * @param mptID MPTIssuanceID you wish you query.
      * @param limit Paging limit.
-     * @param cursorIn Optional cursor to allow us to pick up from where we
-     * last left off.
+     * @param cursorIn Optional cursor to allow us to pick up from where we last left off.
      * @param ledgerSequence The ledger sequence to fetch for
      * @param yield Currently executing coroutine.
      * @return std::vector<Blob> of MPToken balances and an optional marker
@@ -591,7 +590,7 @@ class BackendInterface {
      * @param data A vector of MPT ID and account pairs
      */
     virtual void
-    writeMPTHolders(std::vector<std::pair<ripple::uint192, ripple::AccountID>> const& data) = 0;
+    writeMPTHolders(std::vector<MPTHolderData> const& data) = 0;
 
     /**
      * @brief Write a new successor.

src/data/CassandraBackend.hpp

@@ -578,19 +578,17 @@ class BasicCassandraBackend : public BackendInterface {
             cursor = holder;
         }
 
-        auto const mptObjects = doFetchLedgerObjects(mptKeys, ledgerSequence, yield);
+        auto mptObjects = doFetchLedgerObjects(mptKeys, ledgerSequence, yield);
 
-        // need to filter out the objs that don't exist at the ledger seq because these MPT are in no particular time
-        // order. The MPToken at the specified ledger index may not exist.
-        std::vector<Blob> filteredMpt;
-        std::copy_if(mptObjects.begin(), mptObjects.end(), std::back_inserter(filteredMpt), [](Blob mpt) {
-            return mpt.size() != 0;
-        });
+        auto it = std::remove_if(mptObjects.begin(), mptObjects.end(), [](Blob mpt) { return mpt.size() == 0; });
+
+        mptObjects.erase(it, mptObjects.end());
 
+        ASSERT(mptKeys.size() <= limit, "Number of keys can't exceed the limit");
         if (mptKeys.size() == limit)
-            return {filteredMpt, cursor};
+            return {mptObjects, cursor};
 
-        return {filteredMpt, {}};
+        return {mptObjects, {}};
     }
 
     std::optional<Blob>
@@ -891,15 +889,11 @@ class BasicCassandraBackend : public BackendInterface {
     }
 
     void
-    writeMPTHolders(std::vector<std::pair<ripple::uint192, ripple::AccountID>> const& data) override
+    writeMPTHolders(std::vector<MPTHolderData> const& data) override
     {
         std::vector<Statement> statements;
-        for (auto const& record : data) {
-            auto const mptId = record.first;
-            auto const holder = record.second;
-
-            statements.push_back(schema_->insertMPTHolder.bind(mptId, holder));
-        }
+        for (auto [mptId, holder] : data)
+            statements.push_back(schema_->insertMPTHolder.bind(std::move(mptId), std::move(holder)));
 
         executor_.write(std::move(statements));
     }

src/data/DBHelpers.hpp

@@ -172,6 +172,14 @@ struct NFTsData {
     }
 };
 
+/**
+ * @brief Represents an MPT and holder pair
+ */
+struct MPTHolderData {
+    ripple::uint192 mptID;
+    ripple::AccountID holder;
+};
+
 /**
  * @brief Check whether the supplied object is an offer.
  *

src/data/cassandra/Schema.hpp

@@ -287,7 +287,7 @@ class Schema {
                   ( 
                     mpt_id blob,
                     holder blob,
-                    PRIMARY KEY (mpt_id, holder)
+                   PRIMARY KEY (mpt_id, holder)
                   ) 
              WITH CLUSTERING ORDER BY (holder ASC)
               AND default_time_to_live = {}

src/etl/MPTHelpers.cpp

@@ -36,7 +36,7 @@ namespace etl {
  * @param txMeta Transaction metadata
  * @return MPT and holder account pair
  */
-static std::optional<std::pair<ripple::uint192, ripple::AccountID>>
+static std::optional<MPTHolderData>
 getMPTokenAuthorize(ripple::TxMeta const& txMeta)
 {
     for (ripple::STObject const& node : txMeta.getNodes()) {
@@ -45,13 +45,13 @@ getMPTokenAuthorize(ripple::TxMeta const& txMeta)
 
         if (node.getFName() == ripple::sfCreatedNode) {
             auto const& newMPT = node.peekAtField(ripple::sfNewFields).downcast<ripple::STObject>();
-            return std::make_pair(newMPT[ripple::sfMPTokenIssuanceID], newMPT.getAccountID(ripple::sfAccount));
+            return MPTHolderData{newMPT[ripple::sfMPTokenIssuanceID], newMPT.getAccountID(ripple::sfAccount)};
         }
     }
     return {};
 }
 
-std::optional<std::pair<ripple::uint192, ripple::AccountID>>
+std::optional<MPTHolderData>
 getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx)
 {
     if (txMeta.getResultTER() != ripple::tesSUCCESS || sttx.getTxnType() != ripple::TxType::ttMPTOKEN_AUTHORIZE)
@@ -60,7 +60,7 @@ getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx)
     return getMPTokenAuthorize(txMeta);
 }
 
-std::optional<std::pair<ripple::uint192, ripple::AccountID>>
+std::optional<MPTHolderData>
 getMPTHolderFromObj(std::string const& key, std::string const& blob)
 {
     ripple::STLedgerEntry const sle =
@@ -72,7 +72,7 @@ getMPTHolderFromObj(std::string const& key, std::string const& blob)
     auto const mptIssuanceID = sle[ripple::sfMPTokenIssuanceID];
     auto const holder = sle.getAccountID(ripple::sfAccount);
 
-    return std::make_pair(mptIssuanceID, holder);
+    return MPTHolderData{mptIssuanceID, holder};
 }
 
 }  // namespace etl

src/etl/MPTHelpers.hpp

@@ -34,7 +34,7 @@ namespace etl {
  * @param sttx The transaction
  * @return The MPTIssuanceID and holder pair as a optional
  */
-std::optional<std::pair<ripple::uint192, ripple::AccountID>>
+std::optional<MPTHolderData>
 getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx);
 
 /**
@@ -44,7 +44,7 @@ getMPTHolderFromTx(ripple::TxMeta const& txMeta, ripple::STTx const& sttx);
  * @param blob Object data as blob
  * @return The MPTIssuanceID and holder pair as a optional
  */
-std::optional<std::pair<ripple::uint192, ripple::AccountID>>
+std::optional<MPTHolderData>
 getMPTHolderFromObj(std::string const& key, std::string const& blob);
 
 }  // namespace etl

src/etl/impl/LedgerLoader.hpp

@@ -56,7 +56,7 @@ struct FormattedTransactionsData {
     std::vector<AccountTransactionsData> accountTxData;
     std::vector<NFTTransactionsData> nfTokenTxData;
     std::vector<NFTsData> nfTokensData;
-    std::vector<std::pair<ripple::uint192, ripple::AccountID>> mptHoldersData;
+    std::vector<MPTHolderData> mptHoldersData;
 };
 
 namespace etl::impl {
@@ -262,7 +262,7 @@ class LedgerLoader {
                 backend_->writeAccountTransactions(std::move(insertTxResult.accountTxData));
                 backend_->writeNFTs(insertTxResult.nfTokensData);
                 backend_->writeNFTTransactions(insertTxResult.nfTokenTxData);
-                backend_->writeMPTHolders(std::move(insertTxResult.mptHoldersData));
+                backend_->writeMPTHolders(insertTxResult.mptHoldersData);
             }
 
             backend_->finishWrites(sequence);

src/etl/impl/Transformer.hpp

@@ -213,7 +213,7 @@ class Transformer {
         backend_->writeAccountTransactions(std::move(insertTxResultOp->accountTxData));
         backend_->writeNFTs(insertTxResultOp->nfTokensData);
         backend_->writeNFTTransactions(insertTxResultOp->nfTokenTxData);
-        backend_->writeMPTHolders(std::move(insertTxResultOp->mptHoldersData));
+        backend_->writeMPTHolders(insertTxResultOp->mptHoldersData);
 
         auto [success, duration] =
             ::util::timed<std::chrono::duration<double>>([&]() { return backend_->finishWrites(lgrInfo.seq); });

src/rpc/handlers/LedgerEntry.cpp

@@ -143,9 +143,11 @@ LedgerEntryHandler::process(LedgerEntryHandler::Input input, Context const& ctx)
         auto const mptIssuanceID = ripple::uint192{std::string_view(*(input.mptIssuance))};
         key = ripple::keylet::mptIssuance(mptIssuanceID).key;
     } else if (input.mptoken) {
-        auto const holder = ripple::parseBase58<ripple::AccountID>(input.mptoken->at(JS(account)).as_string().c_str());
+        auto const holder =
+            ripple::parseBase58<ripple::AccountID>(boost::json::value_to<std::string>(input.mptoken->at(JS(account))));
         auto const mptIssuanceID =
-            ripple::uint192{std::string_view(input.mptoken->at(JS(mpt_issuance_id)).as_string().c_str())};
+            ripple::uint192{std::string_view(boost::json::value_to<std::string>(input.mptoken->at(JS(mpt_issuance_id))))
+            };
         key = ripple::keylet::mptoken(mptIssuanceID, *holder).key;
     } else {
         // Must specify 1 of the following fields to indicate what type

src/rpc/handlers/MPTHolders.cpp

@@ -55,14 +55,11 @@ MPTHoldersHandler::process(MPTHoldersHandler::Input input, Context const& ctx) c
         return Error{*status};
 
     auto const lgrInfo = std::get<LedgerInfo>(lgrInfoOrStatus);
-
     auto const limit = input.limit.value_or(MPTHoldersHandler::LIMIT_DEFAULT);
-
     auto const mptID = ripple::uint192{input.mptID.c_str()};
 
     auto const issuanceLedgerObject =
         sharedPtrBackend_->fetchLedgerObject(ripple::keylet::mptIssuance(mptID).key, lgrInfo.seq, ctx.yield);
-
     if (!issuanceLedgerObject)
         return Error{Status{RippledError::rpcOBJECT_NOT_FOUND, "objectNotFound"}};
 
@@ -71,9 +68,7 @@ MPTHoldersHandler::process(MPTHoldersHandler::Input input, Context const& ctx) c
         cursor = ripple::AccountID{input.marker->c_str()};
 
     auto const dbResponse = sharedPtrBackend_->fetchMPTHolders(mptID, limit, cursor, lgrInfo.seq, ctx.yield);
-
     auto output = MPTHoldersHandler::Output{};
-
     output.mptID = to_string(mptID);
     output.limit = limit;
     output.ledgerIndex = lgrInfo.seq;

unittests/rpc/handlers/AccountObjectsTests.cpp

@@ -1720,4 +1720,4 @@ TEST_F(RPCAccountObjectsHandlerTest, TypeFilterMPTokenType)
         ASSERT_EQ(accountObjects.size(), 1);
         EXPECT_EQ(accountObjects.front().at("LedgerEntryType").as_string(), "MPToken");
     });
-}
+}

unittests/rpc/handlers/LedgerDataTests.cpp

@@ -805,4 +805,4 @@ TEST_F(RPCLedgerDataHandlerTest, TypeFilterMPToken)
         auto const& objects = output->as_object().at("state").as_array();
         EXPECT_EQ(objects.front().at("LedgerEntryType").as_string(), "MPToken");
     });
-}
+}

unittests/util/MockBackend.hpp

@@ -192,12 +192,7 @@ struct MockBackend : public BackendInterface {
 
     MOCK_METHOD(bool, doFinishWrites, (), (override));
 
-    MOCK_METHOD(
-        void,
-        writeMPTHolders,
-        ((std::vector<std::pair<ripple::uint192, ripple::AccountID>> const&)),
-        (override)
-    );
+    MOCK_METHOD(void, writeMPTHolders, ((std::vector<MPTHolderData> const&)), (override));
 
     MOCK_METHOD(
         MPTHoldersAndCursor,

unittests/util/TestObject.cpp

@@ -1045,4 +1045,4 @@ CreateMPTokenObject(
         mptoken.setFieldU64(ripple::sfLockedAmount, lockedAmount);
 
     return mptoken;
-}
+}