Merge pull request #2269 from jonjove/cap-0024

CAP-0024

Reviewed-by: MonsieurNicolas

src/invariant/LiabilitiesMatchOffers.cpp

@@ -29,7 +29,8 @@ getOfferBuyingLiabilities(LedgerEntry const& le)
 {
     auto const& oe = le.data.offer();
     auto res = exchangeV10WithoutPriceErrorThresholds(
-        oe.price, oe.amount, INT64_MAX, INT64_MAX, INT64_MAX, false);
+        oe.price, oe.amount, INT64_MAX, INT64_MAX, INT64_MAX,
+        RoundingType::NORMAL);
     return res.numSheepSend;
 }
 
@@ -38,7 +39,8 @@ getOfferSellingLiabilities(LedgerEntry const& le)
 {
     auto const& oe = le.data.offer();
     auto res = exchangeV10WithoutPriceErrorThresholds(
-        oe.price, oe.amount, INT64_MAX, INT64_MAX, INT64_MAX, false);
+        oe.price, oe.amount, INT64_MAX, INT64_MAX, INT64_MAX,
+        RoundingType::NORMAL);
     return res.numWheatReceived;
 }
 

src/test/TestAccount.cpp

@@ -298,7 +298,7 @@ TestAccount::pay(PublicKey const& destination, Asset const& asset,
     applyTx(tx({payment(destination, asset, amount)}), mApp);
 }
 
-PathPaymentResult
+PathPaymentStrictReceiveResult
 TestAccount::pay(PublicKey const& destination, Asset const& sendCur,
                  int64_t sendMax, Asset const& destCur, int64_t destAmount,
                  std::vector<Asset> const& path, Asset* noIssuer)
@@ -309,19 +309,49 @@ TestAccount::pay(PublicKey const& destination, Asset const& sendCur,
     {
         applyTx(transaction, mApp);
     }
-    catch (ex_PATH_PAYMENT_NO_ISSUER&)
+    catch (ex_PATH_PAYMENT_STRICT_RECEIVE_NO_ISSUER&)
     {
         REQUIRE(noIssuer);
         REQUIRE(*noIssuer == transaction->getResult()
                                  .result.results()[0]
                                  .tr()
-                                 .pathPaymentResult()
+                                 .pathPaymentStrictReceiveResult()
                                  .noIssuer());
         throw;
     }
 
     REQUIRE(!noIssuer);
 
-    return getFirstResult(*transaction).tr().pathPaymentResult();
+    return getFirstResult(*transaction).tr().pathPaymentStrictReceiveResult();
+}
+
+PathPaymentStrictSendResult
+TestAccount::pathPaymentStrictSend(PublicKey const& destination,
+                                   Asset const& sendCur, int64_t sendAmount,
+                                   Asset const& destCur, int64_t destMin,
+                                   std::vector<Asset> const& path,
+                                   Asset* noIssuer)
+{
+    auto transaction = tx({txtest::pathPaymentStrictSend(
+        destination, sendCur, sendAmount, destCur, destMin, path)});
+
+    try
+    {
+        applyTx(transaction, mApp);
+    }
+    catch (ex_PATH_PAYMENT_STRICT_SEND_NO_ISSUER&)
+    {
+        REQUIRE(noIssuer);
+        REQUIRE(*noIssuer == transaction->getResult()
+                                 .result.results()[0]
+                                 .tr()
+                                 .pathPaymentStrictSendResult()
+                                 .noIssuer());
+        throw;
+    }
+
+    REQUIRE(!noIssuer);
+
+    return getFirstResult(*transaction).tr().pathPaymentStrictSendResult();
 }
 };

src/test/TestAccount.h

@@ -70,9 +70,16 @@ class TestAccount
 
     void pay(PublicKey const& destination, int64_t amount);
     void pay(PublicKey const& destination, Asset const& asset, int64_t amount);
-    PathPaymentResult pay(PublicKey const& destination, Asset const& sendCur,
-                          int64_t sendMax, Asset const& destCur,
-                          int64_t destAmount, std::vector<Asset> const& path,
+    PathPaymentStrictReceiveResult pay(PublicKey const& destination,
+                                       Asset const& sendCur, int64_t sendMax,
+                                       Asset const& destCur, int64_t destAmount,
+                                       std::vector<Asset> const& path,
+                                       Asset* noIssuer = nullptr);
+
+    PathPaymentStrictSendResult
+    pathPaymentStrictSend(PublicKey const& destination, Asset const& sendCur,
+                          int64_t sendAmount, Asset const& destCur,
+                          int64_t destMin, std::vector<Asset> const& path,
                           Asset* noIssuer = nullptr);
 
     operator SecretKey() const

src/test/TestExceptions.cpp

@@ -61,35 +61,71 @@ throwIf(PaymentResult const& result)
 }
 
 void
-throwIf(PathPaymentResult const& result)
+throwIf(PathPaymentStrictReceiveResult const& result)
 {
     switch (result.code())
     {
-    case PATH_PAYMENT_MALFORMED:
-        throw ex_PATH_PAYMENT_MALFORMED{};
-    case PATH_PAYMENT_UNDERFUNDED:
-        throw ex_PATH_PAYMENT_UNDERFUNDED{};
-    case PATH_PAYMENT_SRC_NO_TRUST:
-        throw ex_PATH_PAYMENT_SRC_NO_TRUST{};
-    case PATH_PAYMENT_SRC_NOT_AUTHORIZED:
-        throw ex_PATH_PAYMENT_SRC_NOT_AUTHORIZED{};
-    case PATH_PAYMENT_NO_DESTINATION:
-        throw ex_PATH_PAYMENT_NO_DESTINATION{};
-    case PATH_PAYMENT_NO_TRUST:
-        throw ex_PATH_PAYMENT_NO_TRUST{};
-    case PATH_PAYMENT_NOT_AUTHORIZED:
-        throw ex_PATH_PAYMENT_NOT_AUTHORIZED{};
-    case PATH_PAYMENT_LINE_FULL:
-        throw ex_PATH_PAYMENT_LINE_FULL{};
-    case PATH_PAYMENT_NO_ISSUER:
-        throw ex_PATH_PAYMENT_NO_ISSUER{};
-    case PATH_PAYMENT_TOO_FEW_OFFERS:
-        throw ex_PATH_PAYMENT_TOO_FEW_OFFERS{};
-    case PATH_PAYMENT_OFFER_CROSS_SELF:
-        throw ex_PATH_PAYMENT_OFFER_CROSS_SELF{};
-    case PATH_PAYMENT_OVER_SENDMAX:
-        throw ex_PATH_PAYMENT_OVER_SENDMAX{};
-    case PATH_PAYMENT_SUCCESS:
+    case PATH_PAYMENT_STRICT_RECEIVE_MALFORMED:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_MALFORMED{};
+    case PATH_PAYMENT_STRICT_RECEIVE_UNDERFUNDED:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_UNDERFUNDED{};
+    case PATH_PAYMENT_STRICT_RECEIVE_SRC_NO_TRUST:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_SRC_NO_TRUST{};
+    case PATH_PAYMENT_STRICT_RECEIVE_SRC_NOT_AUTHORIZED:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_SRC_NOT_AUTHORIZED{};
+    case PATH_PAYMENT_STRICT_RECEIVE_NO_DESTINATION:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_NO_DESTINATION{};
+    case PATH_PAYMENT_STRICT_RECEIVE_NO_TRUST:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_NO_TRUST{};
+    case PATH_PAYMENT_STRICT_RECEIVE_NOT_AUTHORIZED:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_NOT_AUTHORIZED{};
+    case PATH_PAYMENT_STRICT_RECEIVE_LINE_FULL:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_LINE_FULL{};
+    case PATH_PAYMENT_STRICT_RECEIVE_NO_ISSUER:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_NO_ISSUER{};
+    case PATH_PAYMENT_STRICT_RECEIVE_TOO_FEW_OFFERS:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_TOO_FEW_OFFERS{};
+    case PATH_PAYMENT_STRICT_RECEIVE_OFFER_CROSS_SELF:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_OFFER_CROSS_SELF{};
+    case PATH_PAYMENT_STRICT_RECEIVE_OVER_SENDMAX:
+        throw ex_PATH_PAYMENT_STRICT_RECEIVE_OVER_SENDMAX{};
+    case PATH_PAYMENT_STRICT_RECEIVE_SUCCESS:
+        break;
+    default:
+        throw ex_UNKNOWN{};
+    }
+}
+
+void
+throwIf(PathPaymentStrictSendResult const& result)
+{
+    switch (result.code())
+    {
+    case PATH_PAYMENT_STRICT_SEND_MALFORMED:
+        throw ex_PATH_PAYMENT_STRICT_SEND_MALFORMED{};
+    case PATH_PAYMENT_STRICT_SEND_UNDERFUNDED:
+        throw ex_PATH_PAYMENT_STRICT_SEND_UNDERFUNDED{};
+    case PATH_PAYMENT_STRICT_SEND_SRC_NO_TRUST:
+        throw ex_PATH_PAYMENT_STRICT_SEND_SRC_NO_TRUST{};
+    case PATH_PAYMENT_STRICT_SEND_SRC_NOT_AUTHORIZED:
+        throw ex_PATH_PAYMENT_STRICT_SEND_SRC_NOT_AUTHORIZED{};
+    case PATH_PAYMENT_STRICT_SEND_NO_DESTINATION:
+        throw ex_PATH_PAYMENT_STRICT_SEND_NO_DESTINATION{};
+    case PATH_PAYMENT_STRICT_SEND_NO_TRUST:
+        throw ex_PATH_PAYMENT_STRICT_SEND_NO_TRUST{};
+    case PATH_PAYMENT_STRICT_SEND_NOT_AUTHORIZED:
+        throw ex_PATH_PAYMENT_STRICT_SEND_NOT_AUTHORIZED{};
+    case PATH_PAYMENT_STRICT_SEND_LINE_FULL:
+        throw ex_PATH_PAYMENT_STRICT_SEND_LINE_FULL{};
+    case PATH_PAYMENT_STRICT_SEND_NO_ISSUER:
+        throw ex_PATH_PAYMENT_STRICT_SEND_NO_ISSUER{};
+    case PATH_PAYMENT_STRICT_SEND_TOO_FEW_OFFERS:
+        throw ex_PATH_PAYMENT_STRICT_SEND_TOO_FEW_OFFERS{};
+    case PATH_PAYMENT_STRICT_SEND_OFFER_CROSS_SELF:
+        throw ex_PATH_PAYMENT_STRICT_SEND_OFFER_CROSS_SELF{};
+    case PATH_PAYMENT_STRICT_SEND_UNDER_DESTMIN:
+        throw ex_PATH_PAYMENT_STRICT_SEND_UNDER_DESTMIN{};
+    case PATH_PAYMENT_STRICT_SEND_SUCCESS:
         break;
     default:
         throw ex_UNKNOWN{};
@@ -362,8 +398,8 @@ throwIf(TransactionResult const& result)
     case PAYMENT:
         throwIf(opResult.tr().paymentResult());
         break;
-    case PATH_PAYMENT:
-        throwIf(opResult.tr().pathPaymentResult());
+    case PATH_PAYMENT_STRICT_RECEIVE:
+        throwIf(opResult.tr().pathPaymentStrictReceiveResult());
         break;
     case MANAGE_SELL_OFFER:
         throwIf(opResult.tr().manageSellOfferResult());
@@ -395,6 +431,9 @@ throwIf(TransactionResult const& result)
     case MANAGE_BUY_OFFER:
         throwIf(opResult.tr().manageBuyOfferResult());
         break;
+    case PATH_PAYMENT_STRICT_SEND:
+        throwIf(opResult.tr().pathPaymentStrictSendResult());
+        break;
     }
 }
 }

src/test/TestExceptions.h

@@ -92,19 +92,33 @@ TEST_EXCEPTION(ex_MANAGE_BUY_OFFER_BUY_NO_ISSUER)
 TEST_EXCEPTION(ex_MANAGE_BUY_OFFER_NOT_FOUND)
 TEST_EXCEPTION(ex_MANAGE_BUY_OFFER_LOW_RESERVE)
 
-TEST_EXCEPTION(ex_PATH_PAYMENT_SUCCESS)
-TEST_EXCEPTION(ex_PATH_PAYMENT_MALFORMED)
-TEST_EXCEPTION(ex_PATH_PAYMENT_UNDERFUNDED)
-TEST_EXCEPTION(ex_PATH_PAYMENT_SRC_NO_TRUST)
-TEST_EXCEPTION(ex_PATH_PAYMENT_SRC_NOT_AUTHORIZED)
-TEST_EXCEPTION(ex_PATH_PAYMENT_NO_DESTINATION)
-TEST_EXCEPTION(ex_PATH_PAYMENT_NO_TRUST)
-TEST_EXCEPTION(ex_PATH_PAYMENT_NOT_AUTHORIZED)
-TEST_EXCEPTION(ex_PATH_PAYMENT_LINE_FULL)
-TEST_EXCEPTION(ex_PATH_PAYMENT_NO_ISSUER)
-TEST_EXCEPTION(ex_PATH_PAYMENT_TOO_FEW_OFFERS)
-TEST_EXCEPTION(ex_PATH_PAYMENT_OFFER_CROSS_SELF)
-TEST_EXCEPTION(ex_PATH_PAYMENT_OVER_SENDMAX)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_SUCCESS)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_MALFORMED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_UNDERFUNDED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_SRC_NO_TRUST)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_SRC_NOT_AUTHORIZED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_NO_DESTINATION)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_NO_TRUST)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_NOT_AUTHORIZED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_LINE_FULL)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_NO_ISSUER)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_TOO_FEW_OFFERS)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_OFFER_CROSS_SELF)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_RECEIVE_OVER_SENDMAX)
+
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_SUCCESS)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_MALFORMED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_UNDERFUNDED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_SRC_NO_TRUST)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_SRC_NOT_AUTHORIZED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_NO_DESTINATION)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_NO_TRUST)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_NOT_AUTHORIZED)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_LINE_FULL)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_NO_ISSUER)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_TOO_FEW_OFFERS)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_OFFER_CROSS_SELF)
+TEST_EXCEPTION(ex_PATH_PAYMENT_STRICT_SEND_UNDER_DESTMIN)
 
 TEST_EXCEPTION(ex_PAYMENT_MALFORMED)
 TEST_EXCEPTION(ex_PAYMENT_UNDERFUNDED)

src/test/TxTests.cpp

@@ -14,17 +14,7 @@
 #include "test/TestExceptions.h"
 #include "test/TestUtils.h"
 #include "test/test.h"
-#include "transactions/AllowTrustOpFrame.h"
-#include "transactions/BumpSequenceOpFrame.h"
-#include "transactions/ChangeTrustOpFrame.h"
-#include "transactions/CreateAccountOpFrame.h"
-#include "transactions/InflationOpFrame.h"
-#include "transactions/ManageDataOpFrame.h"
-#include "transactions/ManageSellOfferOpFrame.h"
-#include "transactions/MergeOpFrame.h"
-#include "transactions/PathPaymentOpFrame.h"
-#include "transactions/PaymentOpFrame.h"
-#include "transactions/SetOptionsOpFrame.h"
+#include "transactions/OperationFrame.h"
 #include "transactions/TransactionFrame.h"
 #include "transactions/TransactionUtils.h"
 #include "util/Logging.h"
@@ -534,8 +524,8 @@ pathPayment(PublicKey const& to, Asset const& sendCur, int64_t sendMax,
             std::vector<Asset> const& path)
 {
     Operation op;
-    op.body.type(PATH_PAYMENT);
-    PathPaymentOp& ppop = op.body.pathPaymentOp();
+    op.body.type(PATH_PAYMENT_STRICT_RECEIVE);
+    PathPaymentStrictReceiveOp& ppop = op.body.pathPaymentStrictReceiveOp();
     ppop.sendAsset = sendCur;
     ppop.sendMax = sendMax;
     ppop.destAsset = destCur;
@@ -546,6 +536,24 @@ pathPayment(PublicKey const& to, Asset const& sendCur, int64_t sendMax,
     return op;
 }
 
+Operation
+pathPaymentStrictSend(PublicKey const& to, Asset const& sendCur,
+                      int64_t sendAmount, Asset const& destCur, int64_t destMin,
+                      std::vector<Asset> const& path)
+{
+    Operation op;
+    op.body.type(PATH_PAYMENT_STRICT_SEND);
+    PathPaymentStrictSendOp& ppop = op.body.pathPaymentStrictSendOp();
+    ppop.sendAsset = sendCur;
+    ppop.sendAmount = sendAmount;
+    ppop.destAsset = destCur;
+    ppop.destMin = destMin;
+    ppop.destination = to;
+    std::copy(std::begin(path), std::end(path), std::back_inserter(ppop.path));
+
+    return op;
+}
+
 Operation
 createPassiveOffer(Asset const& selling, Asset const& buying,
                    Price const& price, int64_t amount)

src/test/TxTests.h

@@ -127,6 +127,11 @@ Operation pathPayment(PublicKey const& to, Asset const& sendCur,
                       int64_t sendMax, Asset const& destCur, int64_t destAmount,
                       std::vector<Asset> const& path);
 
+Operation pathPaymentStrictSend(PublicKey const& to, Asset const& sendCur,
+                                int64_t sendAmount, Asset const& destCur,
+                                int64_t destMin,
+                                std::vector<Asset> const& path);
+
 Operation manageOffer(int64 offerId, Asset const& selling, Asset const& buying,
                       Price const& price, int64_t amount);
 Operation manageBuyOffer(int64 offerId, Asset const& selling,

src/transactions/ManageBuyOfferOpFrame.cpp

@@ -53,7 +53,7 @@ ManageBuyOfferOpFrame::getOfferBuyingLiabilities()
 {
     auto res = exchangeV10WithoutPriceErrorThresholds(
         getInversePrice(mManageBuyOffer.price), INT64_MAX, INT64_MAX, INT64_MAX,
-        mManageBuyOffer.buyAmount, false);
+        mManageBuyOffer.buyAmount, RoundingType::NORMAL);
     return res.numSheepSend;
 }
 
@@ -62,7 +62,7 @@ ManageBuyOfferOpFrame::getOfferSellingLiabilities()
 {
     auto res = exchangeV10WithoutPriceErrorThresholds(
         getInversePrice(mManageBuyOffer.price), INT64_MAX, INT64_MAX, INT64_MAX,
-        mManageBuyOffer.buyAmount, false);
+        mManageBuyOffer.buyAmount, RoundingType::NORMAL);
     return res.numWheatReceived;
 }
 

src/transactions/ManageOfferOpFrameBase.cpp

@@ -272,7 +272,7 @@ ManageOfferOpFrameBase::doApply(AbstractLedgerTxn& ltxOuter)
         Price maxWheatPrice(mPrice.d, mPrice.n);
         ConvertResult r = convertWithOffers(
             ltx, mSheep, maxSheepSend, sheepSent, mWheat, maxWheatReceive,
-            wheatReceived, false,
+            wheatReceived, RoundingType::NORMAL,
             [this, passive, &maxWheatPrice](LedgerTxnEntry const& entry) {
                 auto const& o = entry.current().data.offer();
                 assert(o.offerID != mOfferID);

src/transactions/ManageSellOfferOpFrame.cpp

@@ -62,7 +62,7 @@ ManageSellOfferOpFrame::getOfferBuyingLiabilities()
 {
     auto res = exchangeV10WithoutPriceErrorThresholds(
         mManageSellOffer.price, mManageSellOffer.amount, INT64_MAX, INT64_MAX,
-        INT64_MAX, false);
+        INT64_MAX, RoundingType::NORMAL);
     return res.numSheepSend;
 }
 
@@ -71,7 +71,7 @@ ManageSellOfferOpFrame::getOfferSellingLiabilities()
 {
     auto res = exchangeV10WithoutPriceErrorThresholds(
         mManageSellOffer.price, mManageSellOffer.amount, INT64_MAX, INT64_MAX,
-        INT64_MAX, false);
+        INT64_MAX, RoundingType::NORMAL);
     return res.numWheatReceived;
 }