WIP: Publish DeliverMax using appropriate API

src/ripple/app/ledger/BookListeners.cpp

@@ -40,6 +40,7 @@ BookListeners::removeSubscriber(std::uint64_t seq)
 void
 BookListeners::publish(
     Json::Value const& jvObj,
+    Json::Value const& jvObjApiVer2,
     hash_set<std::uint64_t>& havePublished)
 {
     std::lock_guard sl(mLock);
@@ -54,7 +55,10 @@ BookListeners::publish(
             // Only publish jvObj if this is the first occurence
             if (havePublished.emplace(p->getSeq()).second)
             {
-                p->send(jvObj, true);
+                if (p->getApiVersion() == 1)
+                    p->send(jvObj, true);
+                else
+                    p->send(jvObjApiVer2, true);
             }
             ++it;
         }

src/ripple/app/ledger/BookListeners.h

@@ -58,7 +58,7 @@ class BookListeners
 
     */
     void
-    publish(Json::Value const& jvObj, hash_set<std::uint64_t>& havePublished);
+    publish(Json::Value const& jvObj, Json::Value const& jvObjApiVer2, hash_set<std::uint64_t>& havePublished);
 
 private:
     std::recursive_mutex mLock;

src/ripple/app/ledger/OrderBookDB.cpp

@@ -250,7 +250,8 @@ void
 OrderBookDB::processTxn(
     std::shared_ptr<ReadView const> const& ledger,
     const AcceptedLedgerTx& alTx,
-    Json::Value const& jvObj)
+    Json::Value const& jvObj,
+    Json::Value const& jvObjApiVer2)
 {
     std::lock_guard sl(mLock);
 
@@ -277,7 +278,7 @@ OrderBookDB::processTxn(
                             {data->getFieldAmount(sfTakerGets).issue(),
                              data->getFieldAmount(sfTakerPays).issue()});
                         if (listeners)
-                            listeners->publish(jvObj, havePublished);
+                            listeners->publish(jvObj, jvObjApiVer2, havePublished);
                     }
                 };
 

src/ripple/app/ledger/OrderBookDB.h

@@ -63,7 +63,8 @@ class OrderBookDB
     processTxn(
         std::shared_ptr<ReadView const> const& ledger,
         const AcceptedLedgerTx& alTx,
-        Json::Value const& jvObj);
+        Json::Value const& jvObj,
+        Json::Value const& jvObjApiVer2);
 
 private:
     Application& app_;

src/ripple/app/ledger/impl/LedgerToJson.cpp

@@ -136,7 +136,8 @@ fillJsonTx(
                     txn,
                     {txn->getTransactionID(), fill.ledger.seq(), *stMeta});
 
-            insertDeliverMax(txJson[jss::metaData], *fill.context, txnType);
+            RPC::insertDeliverMax(
+                txJson[jss::metaData], txnType, fill.context->apiVersion);
         }
     }
 

src/ripple/app/misc/NetworkOPs.cpp

@@ -64,6 +64,7 @@
 #include <ripple/resource/Fees.h>
 #include <ripple/resource/ResourceManager.h>
 #include <ripple/rpc/BookChanges.h>
+#include <ripple/rpc/DeliverMax.h>
 #include <ripple/rpc/DeliveredAmount.h>
 #include <ripple/rpc/ServerHandler.h>
 #include <ripple/rpc/impl/RPCHelpers.h>
@@ -3149,11 +3150,18 @@ NetworkOPsImp::pubValidatedTransaction(
 
     Json::Value jvObj =
         transJson(*stTxn, transaction.getResult(), true, ledger);
+    Json::Value jvObjApi2 =
+        transJson(*stTxn, transaction.getResult(), true, ledger);
 
     {
         auto const& meta = transaction.getMeta();
         jvObj[jss::meta] = meta.getJson(JsonOptions::none);
         RPC::insertDeliveredAmount(jvObj[jss::meta], *ledger, stTxn, meta);
+        RPC::insertDeliverMax(jvObj[jss::meta], stTxn->getTxnType(), 1);
+
+        jvObjApi2[jss::meta] = meta.getJson(JsonOptions::none);
+        RPC::insertDeliveredAmount(jvObjApi2[jss::meta], *ledger, stTxn, meta);
+        RPC::insertDeliverMax(jvObjApi2[jss::meta], stTxn->getTxnType(), 2);
     }
 
     {
@@ -3166,7 +3174,10 @@ NetworkOPsImp::pubValidatedTransaction(
 
             if (p)
             {
-                p->send(jvObj, true);
+                if (p->getApiVersion() == 1)
+                    p->send(jvObj, true);
+                else
+                    p->send(jvObjApi2, true);
                 ++it;
             }
             else
@@ -3181,7 +3192,10 @@ NetworkOPsImp::pubValidatedTransaction(
 
             if (p)
             {
-                p->send(jvObj, true);
+                if (p->getApiVersion() == 1)
+                    p->send(jvObj, true);
+                else
+                    p->send(jvObjApi2, true);
                 ++it;
             }
             else
@@ -3190,7 +3204,7 @@ NetworkOPsImp::pubValidatedTransaction(
     }
 
     if (transaction.getResult() == tesSUCCESS)
-        app_.getOrderBookDB().processTxn(ledger, transaction, jvObj);
+        app_.getOrderBookDB().processTxn(ledger, transaction, jvObj, jvObjApi2);
 
     pubAccountTransaction(ledger, transaction, last);
 }
@@ -3296,28 +3310,53 @@ NetworkOPsImp::pubAccountTransaction(
 
         Json::Value jvObj =
             transJson(*stTxn, transaction.getResult(), true, ledger);
+        Json::Value jvObjApi2 =
+            transJson(*stTxn, transaction.getResult(), true, ledger);
 
         {
             auto const& meta = transaction.getMeta();
 
             jvObj[jss::meta] = meta.getJson(JsonOptions::none);
             RPC::insertDeliveredAmount(jvObj[jss::meta], *ledger, stTxn, meta);
+            RPC::insertDeliverMax(jvObj[jss::meta], stTxn->getTxnType(), 1);
+
+            jvObjApi2[jss::meta] = meta.getJson(JsonOptions::none);
+            RPC::insertDeliveredAmount(
+                jvObjApi2[jss::meta], *ledger, stTxn, meta);
+            RPC::insertDeliverMax(jvObjApi2[jss::meta], stTxn->getTxnType(), 2);
         }
 
         for (InfoSub::ref isrListener : notify)
-            isrListener->send(jvObj, true);
+        {
+            if (isrListener->getApiVersion() == 1)
+                isrListener->send(jvObj, true);
+            else
+                isrListener->send(jvObjApi2, true);
+        }
 
         if (last)
+        {
             jvObj[jss::account_history_boundary] = true;
+            jvObjApi2[jss::account_history_boundary] = true;
+        }
 
         assert(!jvObj.isMember(jss::account_history_tx_stream));
         for (auto& info : accountHistoryNotify)
         {
             auto& index = info.index_;
             if (index->forwardTxIndex_ == 0 && !index->haveHistorical_)
+            {
                 jvObj[jss::account_history_tx_first] = true;
-            jvObj[jss::account_history_tx_index] = index->forwardTxIndex_++;
-            info.sink_->send(jvObj, true);
+                jvObjApi2[jss::account_history_tx_first] = true;
+            }
+            jvObj[jss::account_history_tx_index] = index->forwardTxIndex_;
+            jvObjApi2[jss::account_history_tx_index] = index->forwardTxIndex_;
+            index->forwardTxIndex_ += 1;
+
+            if (info.sink_->getApiVersion() == 1)
+                info.sink_->send(jvObj, true);
+            else
+                info.sink_->send(jvObjApi2, true);
         }
     }
 }
@@ -3585,6 +3624,24 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo)
                 return false;
             };
 
+            auto send2 = [&](Json::Value const& jvObj,
+                             Json::Value const& jvObjApi2,
+                             bool unsubscribe) -> bool {
+                if (auto sptr = subInfo.sinkWptr_.lock(); sptr)
+                {
+                    if (sptr->getApiVersion() == 1)
+                        sptr->send(jvObj, true);
+                    else
+                        sptr->send(jvObjApi2, true);
+
+                    if (unsubscribe)
+                        unsubAccountHistory(sptr, accountId, false);
+                    return true;
+                }
+
+                return false;
+            };
+
             auto getMoreTxns =
                 [&](std::uint32_t minLedger,
                     std::uint32_t maxLedger,
@@ -3743,21 +3800,41 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo)
                             send(rpcError(rpcINTERNAL), true);
                             return;
                         }
+
                         Json::Value jvTx = transJson(
                             *stTxn, meta->getResultTER(), true, curTxLedger);
                         jvTx[jss::meta] = meta->getJson(JsonOptions::none);
-                        jvTx[jss::account_history_tx_index] = txHistoryIndex--;
+                        jvTx[jss::account_history_tx_index] = txHistoryIndex;
+
+                        Json::Value jvTxApi2 = transJson(
+                            *stTxn, meta->getResultTER(), true, curTxLedger);
+                        jvTxApi2[jss::meta] = meta->getJson(JsonOptions::none);
+                        jvTxApi2[jss::account_history_tx_index] =
+                            txHistoryIndex;
+                        txHistoryIndex -= 1;
 
                         if (i + 1 == num_txns ||
                             txns[i + 1].first->getLedger() != tx->getLedger())
+                        {
                             jvTx[jss::account_history_boundary] = true;
+                            jvTxApi2[jss::account_history_boundary] = true;
+                        }
 
                         RPC::insertDeliveredAmount(
                             jvTx[jss::meta], *curTxLedger, stTxn, *meta);
+                        RPC::insertDeliverMax(
+                            jvTx[jss::meta], stTxn->getTxnType(), 1);
+
+                        RPC::insertDeliveredAmount(
+                            jvTxApi2[jss::meta], *curTxLedger, stTxn, *meta);
+                        RPC::insertDeliverMax(
+                            jvTxApi2[jss::meta], stTxn->getTxnType(), 2);
+
                         if (isFirstTx(tx, meta))
                         {
                             jvTx[jss::account_history_tx_first] = true;
-                            send(jvTx, false);
+                            jvTxApi2[jss::account_history_tx_first] = true;
+                            send2(jvTx, jvTxApi2, false);
 
                             JLOG(m_journal.trace())
                                 << "AccountHistory job for account "
@@ -3767,7 +3844,7 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo)
                         }
                         else
                         {
-                            send(jvTx, false);
+                            send2(jvTx, jvTxApi2, false);
                         }
                     }
 

src/ripple/net/InfoSub.h

@@ -229,6 +229,12 @@ class InfoSub : public CountedObject<InfoSub>
     std::shared_ptr<InfoSubRequest> const&
     getRequest();
 
+    void
+    setApiVersion(int apiVersion);
+
+    int
+    getApiVersion() const noexcept;
+
 protected:
     std::mutex mLock;
 
@@ -240,6 +246,7 @@ class InfoSub : public CountedObject<InfoSub>
     std::shared_ptr<InfoSubRequest> request_;
     std::uint64_t mSeq;
     hash_set<AccountID> accountHistorySubscriptions_;
+    int apiVersion = 1;
 
     static int
     assign_id()

src/ripple/net/impl/InfoSub.cpp

@@ -136,4 +136,16 @@ InfoSub::getRequest()
     return request_;
 }
 
+void
+InfoSub::setApiVersion(int apiVersion)
+{
+    this->apiVersion = apiVersion;
+}
+
+int
+InfoSub::getApiVersion() const noexcept
+{
+    return this->apiVersion;
+}
+
 }  // namespace ripple

src/ripple/rpc/DeliverMax.h

@@ -48,13 +48,13 @@ struct Context;
    Copy `Amount` field to `DeliverMax` field to the `meta` input/output
    parameter. This only applies to certain transaction types.
 
-   When context.apiVersion > 1 will also remove `Amount`.
+   When apiVersion > 1 will also remove `Amount`.
    This function is meant to be used on Json API output.
    @{
  */
 
 void
-insertDeliverMax(Json::Value& meta, RPC::Context const& context, TxType txnType);
+insertDeliverMax(Json::Value& meta, TxType txnType, int apiVersion);
 
 /** @} */
 

src/ripple/rpc/handlers/AccountTx.cpp

@@ -336,8 +336,10 @@ populateJsonResponse(
                             jvObj[jss::meta], context, txn, *txnMeta);
                         auto const& sttx = txn->getSTransaction();
                         insertNFTSyntheticInJson(jvObj, sttx, *txnMeta);
-                        insertDeliverMax(
-                            jvObj[jss::meta], context, sttx->getTxnType());
+                        RPC::insertDeliverMax(
+                            jvObj[jss::meta],
+                            sttx->getTxnType(),
+                            context.apiVersion);
                     }
                 }
             }

src/ripple/rpc/handlers/PathFind.cpp

@@ -46,6 +46,8 @@ doPathFind(RPC::JsonContext& context)
     if (!context.infoSub)
         return rpcError(rpcNO_EVENTS);
 
+    context.infoSub->setApiVersion(context.apiVersion);
+
     auto sSubCommand = context.params[jss::subcommand].asString();
 
     if (sSubCommand == "create")

src/ripple/rpc/handlers/Subscribe.cpp

@@ -110,6 +110,7 @@ doSubscribe(RPC::JsonContext& context)
     {
         ispSub = context.infoSub;
     }
+    ispSub->setApiVersion(context.apiVersion);
 
     if (context.params.isMember(jss::streams))
     {

src/ripple/rpc/handlers/TransactionEntry.cpp

@@ -75,8 +75,10 @@ doTransactionEntry(RPC::JsonContext& context)
             if (stobj)
             {
                 jvResult[jss::metadata] = stobj->getJson(JsonOptions::none);
-                insertDeliverMax(
-                    jvResult[jss::metadata], context, sttx->getTxnType());
+                RPC::insertDeliverMax(
+                    jvResult[jss::metadata],
+                    sttx->getTxnType(),
+                    context.apiVersion);
             }
             // 'accounts'
             // 'engine_...'

src/ripple/rpc/handlers/Tx.cpp

@@ -331,8 +331,10 @@ populateJsonResponse(
                 auto const& sttx = result.txn->getSTransaction();
                 insertNFTSyntheticInJson(response, sttx, *meta);
                 // TODO fix misnomer, we might be replacing Amount
-                insertDeliverMax(
-                    response[jss::meta], context, sttx->getTxnType());
+                RPC::insertDeliverMax(
+                    response[jss::meta],
+                    sttx->getTxnType(),
+                    context.apiVersion);
             }
         }
         response[jss::validated] = result.validated;

src/ripple/rpc/handlers/TxHistory.cpp

@@ -67,7 +67,8 @@ doTxHistory(RPC::JsonContext& context)
     {
         Json::Value tx_json = t->getJson(JsonOptions::none);
         // TODO fix misnomer, we might be replacing Amount
-        insertDeliverMax(tx_json, context, t->getSTransaction()->getTxnType());
+        RPC::insertDeliverMax(
+            tx_json, t->getSTransaction()->getTxnType(), context.apiVersion);
         txs.append(tx_json);
     }