PaychanAndEscrowForTokens: Token-Enabled Escrows and Payment Channels support (XLS-34d+)

src/ripple/app/paths/TrustLine.cpp

@@ -32,6 +32,8 @@ TrustLineBase::TrustLineBase(
     , mLowLimit(sle->getFieldAmount(sfLowLimit))
     , mHighLimit(sle->getFieldAmount(sfHighLimit))
     , mBalance(sle->getFieldAmount(sfBalance))
+    , mLockedBalance((*sle)[~sfLockedBalance])
+    , mLockCount((*sle)[~sfLockCount])
     , mFlags(sle->getFieldU32(sfFlags))
     , mViewLowest(mLowLimit.getIssuer() == viewAccount)
 {

src/ripple/app/paths/TrustLine.h

@@ -152,6 +152,18 @@ class TrustLineBase
         return mBalance;
     }
 
+    std::optional<STAmount> const&
+    getLockedBalance() const
+    {
+        return mLockedBalance;
+    }
+
+    std::optional<uint32_t> const&
+    getLockCount() const
+    {
+        return mLockCount;
+    }
+
     STAmount const&
     getLimit() const
     {
@@ -174,6 +186,9 @@ class TrustLineBase
     STAmount const mHighLimit;
 
     STAmount mBalance;
+    std::optional<STAmount> mLockedBalance;
+    std::optional<uint32_t> mLockCount;  // RH NOTE: this is from sfLockCount
+                                         // has nothing to do with a mutex.
 
     std::uint32_t mFlags;
 

src/ripple/app/tx/impl/Escrow.cpp

@@ -30,6 +30,7 @@
 #include <ripple/ledger/View.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/Indexes.h>
+#include <ripple/protocol/Rate.h>
 #include <ripple/protocol/TxFlags.h>
 #include <ripple/protocol/digest.h>
 #include <ripple/protocol/st.h>
@@ -93,7 +94,8 @@ after(NetClock::time_point now, std::uint32_t mark)
 TxConsequences
 EscrowCreate::makeTxConsequences(PreflightContext const& ctx)
 {
-    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
+    return TxConsequences{
+        ctx.tx, isXRP(ctx.tx[sfAmount]) ? ctx.tx[sfAmount].xrp() : beast::zero};
 }
 
 NotTEC
@@ -105,8 +107,18 @@ EscrowCreate::preflight(PreflightContext const& ctx)
     if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
         return ret;
 
-    if (!isXRP(ctx.tx[sfAmount]))
-        return temBAD_AMOUNT;
+    STAmount const amount{ctx.tx[sfAmount]};
+    if (!isXRP(amount))
+    {
+        if (!ctx.rules.enabled(featurePaychanAndEscrowForTokens))
+            return temBAD_AMOUNT;
+
+        if (!isLegalNet(amount))
+            return temBAD_AMOUNT;
+
+        if (isFakeXRP(amount))
+            return temBAD_CURRENCY;
+    }
 
     if (ctx.tx[sfAmount] <= beast::zero)
         return temBAD_AMOUNT;
@@ -198,17 +210,70 @@ EscrowCreate::doApply()
     if (!sle)
         return tefINTERNAL;
 
-    // Check reserve and funds availability
-    {
-        auto const balance = STAmount((*sle)[sfBalance]).xrp();
-        auto const reserve =
-            ctx_.view().fees().accountReserve((*sle)[sfOwnerCount] + 1);
+    STAmount const amount{ctx_.tx[sfAmount]};
+
+    std::shared_ptr<SLE> sleLine;
 
-        if (balance < reserve)
-            return tecINSUFFICIENT_RESERVE;
+    auto const balance = STAmount((*sle)[sfBalance]).xrp();
+    auto const reserve =
+        ctx_.view().fees().accountReserve((*sle)[sfOwnerCount] + 1);
+    bool const isIssuer = amount.getIssuer() == account;
 
+    if (balance < reserve)
+        return tecINSUFFICIENT_RESERVE;
+
+    // Check reserve and funds availability
+    if (isXRP(amount))
+    {
         if (balance < reserve + STAmount(ctx_.tx[sfAmount]).xrp())
             return tecUNFUNDED;
+        // pass
+    }
+    else
+    {
+        // preflight will prevent this ever firing, included
+        // defensively for completeness
+        if (!ctx_.view().rules().enabled(featurePaychanAndEscrowForTokens))
+            return temDISABLED;
+
+        TER const result = trustTransferAllowed(
+            ctx_.view(),
+            {account, ctx_.tx[sfDestination]},
+            amount.issue(),
+            ctx_.journal);
+
+        JLOG(ctx_.journal.trace())
+            << "EscrowCreate::doApply trustTransferAllowed result=" << result;
+
+        if (!isTesSuccess(result))
+            return result;
+
+        // issuer does not need to lock anything
+        if (!isIssuer)
+        {
+            // perform the lock as a dry run before
+            // we modify anything on-ledger
+            sleLine = ctx_.view().peek(keylet::line(
+                account, amount.getIssuer(), amount.getCurrency()));
+
+            // check if the escrow is capable of being
+            // finished before we allow it to be created
+            if (!sleLine)
+                return tecNO_LINE;
+
+            {
+                TER const result = trustAdjustLockedBalance(
+                    ctx_.view(), sleLine, amount, 1, ctx_.journal, DryRun);
+
+                JLOG(ctx_.journal.trace())
+                    << "EscrowCreate::doApply trustAdjustLockedBalance (dry) "
+                       "result="
+                    << result;
+
+                if (!isTesSuccess(result))
+                    return result;
+            }
+        }
     }
 
     // Check destination account
@@ -223,7 +288,7 @@ EscrowCreate::doApply()
 
         // Obeying the lsfDissalowXRP flag was a bug.  Piggyback on
         // featureDepositAuth to remove the bug.
-        if (!ctx_.view().rules().enabled(featureDepositAuth) &&
+        if (!ctx_.view().rules().enabled(featureDepositAuth) && isXRP(amount) &&
             ((*sled)[sfFlags] & lsfDisallowXRP))
             return tecNO_TARGET;
     }
@@ -242,6 +307,12 @@ EscrowCreate::doApply()
     (*slep)[~sfFinishAfter] = ctx_.tx[~sfFinishAfter];
     (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
 
+    if (ctx_.view().rules().enabled(featurePaychanAndEscrowForTokens))
+    {
+        auto const xferRate = transferRate(view(), amount.getIssuer());
+        (*slep)[~sfTransferRate] = xferRate.value;
+    }
+
     ctx_.view().insert(slep);
 
     // Add escrow to sender's owner directory
@@ -264,7 +335,33 @@ EscrowCreate::doApply()
     }
 
     // Deduct owner's balance, increment owner count
-    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
+    if (isXRP(amount))
+        (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
+    else
+    {
+        if (!ctx_.view().rules().enabled(featurePaychanAndEscrowForTokens))
+            return temDISABLED;
+
+        // issuer does not need to lock anything
+        if (!isIssuer)
+        {
+            if (!sleLine)
+                return tecNO_LINE;
+
+            // do the lock-up for real now
+            TER const result = trustAdjustLockedBalance(
+                ctx_.view(), sleLine, amount, 1, ctx_.journal, WetRun);
+
+            JLOG(ctx_.journal.trace())
+                << "EscrowCreate::doApply trustAdjustLockedBalance (wet) "
+                   "result="
+                << result;
+
+            if (!isTesSuccess(result))
+                return result;
+        }
+    }
+
     adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
     ctx_.view().update(sle);
 
@@ -359,6 +456,10 @@ EscrowFinish::doApply()
     if (!slep)
         return tecNO_TARGET;
 
+    AccountID const account = (*slep)[sfAccount];
+    auto const sle = ctx_.view().peek(keylet::account(account));
+    auto const amount = slep->getFieldAmount(sfAmount);
+
     // If a cancel time is present, a finish operation should only succeed prior
     // to that time. fix1571 corrects a logic error in the check that would make
     // a finish only succeed strictly after the cancel time.
@@ -459,7 +560,42 @@ EscrowFinish::doApply()
         }
     }
 
-    AccountID const account = (*slep)[sfAccount];
+    if (!isXRP(amount))
+    {
+        if (!ctx_.view().rules().enabled(featurePaychanAndEscrowForTokens))
+            return temDISABLED;
+
+        if (!slep->isFieldPresent(sfTransferRate))
+            return tecINTERNAL;
+
+        Rate lockedRate = ripple::Rate(slep->getFieldU32(sfTransferRate));
+        auto const issuerAccID = amount.getIssuer();
+        auto const xferRate = transferRate(view(), issuerAccID);
+        // update if issuer rate is less than locked rate
+        if (xferRate < lockedRate)
+            lockedRate = xferRate;
+
+        // perform a dry run of the transfer before we
+        // change anything on-ledger
+        TER const result = trustTransferLockedBalance(
+            ctx_.view(),
+            account_,  // txn signing account
+            sle,       // src account
+            sled,      // dst account
+            amount,    // xfer amount
+            -1,
+            lockedRate,
+            j_,
+            DryRun  // dry run
+        );
+
+        JLOG(j_.trace())
+            << "EscrowFinish::doApply trustTransferLockedBalance (dry) result="
+            << result;
+
+        if (!isTesSuccess(result))
+            return result;
+    }
 
     // Remove escrow from owner directory
     {
@@ -483,12 +619,47 @@ EscrowFinish::doApply()
         }
     }
 
-    // Transfer amount to destination
-    (*sled)[sfBalance] = (*sled)[sfBalance] + (*slep)[sfAmount];
+    if (isXRP(amount))
+        (*sled)[sfBalance] = (*sled)[sfBalance] + (*slep)[sfAmount];
+    else
+    {
+        // compute transfer fee, if any
+        if (!slep->isFieldPresent(sfTransferRate))
+            return tecINTERNAL;
+
+        Rate lockedRate = ripple::Rate(slep->getFieldU32(sfTransferRate));
+        auto const issuerAccID = amount.getIssuer();
+        auto const xferRate = transferRate(view(), issuerAccID);
+        // update if issuer rate is less than locked rate
+        if (xferRate < lockedRate)
+            lockedRate = xferRate;
+
+        // all the significant complexity of checking the validity of this
+        // transfer and ensuring the lines exist etc is hidden away in this
+        // function, all we need to do is call it and return if unsuccessful.
+        TER const result = trustTransferLockedBalance(
+            ctx_.view(),
+            account_,  // txn signing account
+            sle,       // src account
+            sled,      // dst account
+            amount,    // xfer amount
+            -1,
+            lockedRate,
+            j_,
+            WetRun  // wet run;
+        );
+
+        JLOG(j_.trace())
+            << "EscrowFinish::doApply trustTransferLockedBalance (wet) result="
+            << result;
+
+        if (!isTesSuccess(result))
+            return result;
+    }
+
     ctx_.view().update(sled);
 
     // Adjust source owner count
-    auto const sle = ctx_.view().peek(keylet::account(account));
     adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
     ctx_.view().update(sle);
 
@@ -542,6 +713,30 @@ EscrowCancel::doApply()
     }
 
     AccountID const account = (*slep)[sfAccount];
+    auto const sle = ctx_.view().peek(keylet::account(account));
+    auto const amount = slep->getFieldAmount(sfAmount);
+    bool const isIssuer = amount.getIssuer() == account;
+
+    std::shared_ptr<SLE> sleLine;
+
+    if (!isXRP(amount))
+    {
+        if (!ctx_.view().rules().enabled(featurePaychanAndEscrowForTokens))
+            return temDISABLED;
+
+        // issuer does not need to lock anything
+        if (!isIssuer)
+        {
+            sleLine = ctx_.view().peek(keylet::line(
+                account, amount.getIssuer(), amount.getCurrency()));
+
+            // dry run before we make any changes to ledger
+            if (TER const result = trustAdjustLockedBalance(
+                    ctx_.view(), sleLine, -amount, -1, ctx_.journal, DryRun);
+                result != tesSUCCESS)
+                return result;
+        }
+    }
 
     // Remove escrow from owner directory
     {
@@ -568,9 +763,32 @@ EscrowCancel::doApply()
         }
     }
 
-    // Transfer amount back to owner, decrement owner count
-    auto const sle = ctx_.view().peek(keylet::account(account));
-    (*sle)[sfBalance] = (*sle)[sfBalance] + (*slep)[sfAmount];
+    // Transfer amount back to the owner (or unlock it in TL case)
+    if (isXRP(amount))
+        (*sle)[sfBalance] = (*sle)[sfBalance] + (*slep)[sfAmount];
+    else
+    {
+        if (!ctx_.view().rules().enabled(featurePaychanAndEscrowForTokens))
+            return temDISABLED;
+
+        // issuer does not need to lock anything
+        if (!isIssuer)
+        {
+            // unlock previously locked tokens from source line
+            TER const result = trustAdjustLockedBalance(
+                ctx_.view(), sleLine, -amount, -1, ctx_.journal, WetRun);
+
+            JLOG(ctx_.journal.trace())
+                << "EscrowCancel::doApply trustAdjustLockedBalance (wet) "
+                   "result="
+                << result;
+
+            if (!isTesSuccess(result))
+                return result;
+        }
+    }
+
+    // Decrement owner count
     adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
     ctx_.view().update(sle);