TrustSet_test.cpp

 
#include <test/jtx/Account.h>
#include <test/jtx/Env.h>
#include <test/jtx/amount.h>
#include <test/jtx/balance.h>  // IWYU pragma: keep
#include <test/jtx/flags.h>
#include <test/jtx/pay.h>
#include <test/jtx/require.h>
#include <test/jtx/ter.h>
#include <test/jtx/ticket.h>
#include <test/jtx/trust.h>
#include <test/jtx/txflags.h>
 
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/json/json_value.h>
#include <xrpl/json/to_string.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/jss.h>
 
#include <cstdint>
#include <limits>
 
namespace xrpl::test {
 
class TrustSet_test : public beast::unit_test::Suite
{
public:
    void
    testTrustLineDelete()
    {
        testcase("Test deletion of trust lines: revert trust line limit to zero");
 
        using namespace jtx;
        Env env(*this);
 
        Account const alice = Account{"alice"};
        Account const becky = Account{"becky"};
 
        env.fund(XRP(10000), becky, alice);
        env.close();
 
        // becky wants to hold at most 50 tokens of alice["USD"]
        // becky is the customer, alice is the issuer
        // becky can be sent at most 50 tokens of alice's USD
        env(trust(becky, alice["USD"](50)));
        env.close();
 
        // Since the settings of the trust lines are non-default for both
        // alice and becky, both of them will be charged an owner reserve
        // Irrespective of whether the issuer or the customer initiated
        // the trust-line creation, both will be charged
        env.require(lines(alice, 1));
        env.require(lines(becky, 1));
 
        // Fetch the trust-lines via RPC for verification
        json::Value jv;
        jv["account"] = becky.human();
        auto beckyLines = env.rpc("json", "account_lines", to_string(jv));
 
        jv["account"] = alice.human();
        auto aliceLines = env.rpc("json", "account_lines", to_string(jv));
 
        BEAST_EXPECT(aliceLines[jss::result][jss::lines].size() == 1);
        BEAST_EXPECT(beckyLines[jss::result][jss::lines].size() == 1);
 
        //         reset the trust line limits to zero
        env(trust(becky, alice["USD"](0)));
        env.close();
 
        // the reset of the trust line limits deletes the trust-line
        // this occurs despite the authorization of the trust-line by the
        // issuer(alice, in this unit test)
        env.require(lines(becky, 0));
        env.require(lines(alice, 0));
 
        // second verification check via RPC calls
        jv["account"] = becky.human();
        beckyLines = env.rpc("json", "account_lines", to_string(jv));
 
        jv["account"] = alice.human();
        aliceLines = env.rpc("json", "account_lines", to_string(jv));
 
        BEAST_EXPECT(aliceLines[jss::result][jss::lines].size() == 0);
        BEAST_EXPECT(beckyLines[jss::result][jss::lines].size() == 0);
 
        // additionally, verify that account_objects is an empty array
        jv["account"] = becky.human();
        auto const beckyObj = env.rpc("json", "account_objects", to_string(jv));
        BEAST_EXPECT(beckyObj[jss::result][jss::account_objects].size() == 0);
 
        jv["account"] = alice.human();
        auto const aliceObj = env.rpc("json", "account_objects", to_string(jv));
        BEAST_EXPECT(aliceObj[jss::result][jss::account_objects].size() == 0);
    }
 
    void
    testTrustLineResetWithAuthFlag()
    {
        testcase(
            "Reset trust line limit with Authorised Lines: Verify "
            "deletion of trust lines");
 
        using namespace jtx;
        Env env(*this);
 
        Account const alice = Account{"alice"};
        Account const becky = Account{"becky"};
 
        env.fund(XRP(10000), becky, alice);
        env.close();
 
        // alice wants to ensure that all holders of her tokens are authorised
        env(fset(alice, asfRequireAuth));
        env.close();
 
        // becky wants to hold at most 50 tokens of alice["USD"]
        // becky is the customer, alice is the issuer
        // becky can be sent at most 50 tokens of alice's USD
        env(trust(becky, alice["USD"](50)));
        env.close();
 
        // alice authorizes becky to hold alice["USD"] tokens
        env(trust(alice, alice["USD"](0), becky, tfSetfAuth));
        env.close();
 
        // Since the settings of the trust lines are non-default for both
        // alice and becky, both of them will be charged an owner reserve
        // Irrespective of whether the issuer or the customer initiated
        // the trust-line creation, both will be charged
        env.require(lines(alice, 1));
        env.require(lines(becky, 1));
 
        // Fetch the trust-lines via RPC for verification
        json::Value jv;
        jv["account"] = becky.human();
        auto beckyLines = env.rpc("json", "account_lines", to_string(jv));
 
        jv["account"] = alice.human();
        auto aliceLines = env.rpc("json", "account_lines", to_string(jv));
 
        BEAST_EXPECT(aliceLines[jss::result][jss::lines].size() == 1);
        BEAST_EXPECT(beckyLines[jss::result][jss::lines].size() == 1);
 
        //         reset the trust line limits to zero
        env(trust(becky, alice["USD"](0)));
        env.close();
 
        // the reset of the trust line limits deletes the trust-line
        // this occurs despite the authorization of the trust-line by the
        // issuer(alice, in this unit test)
        env.require(lines(becky, 0));
        env.require(lines(alice, 0));
 
        // second verification check via RPC calls
        jv["account"] = becky.human();
        beckyLines = env.rpc("json", "account_lines", to_string(jv));
 
        jv["account"] = alice.human();
        aliceLines = env.rpc("json", "account_lines", to_string(jv));
 
        BEAST_EXPECT(aliceLines[jss::result][jss::lines].size() == 0);
        BEAST_EXPECT(beckyLines[jss::result][jss::lines].size() == 0);
    }
 
    void
    testFreeTrustlines(FeatureBitset features, bool thirdLineCreatesLE, bool createOnHighAcct)
    {
        if (thirdLineCreatesLE)
        {
            testcase("Allow two free trustlines");
        }
        else
        {
            testcase("Dynamic reserve for trustline");
        }
 
        using namespace jtx;
        Env env(*this, features);
 
        auto const gwA = Account{"gwA"};
        auto const gwB = Account{"gwB"};
        auto const acctC = Account{"acctC"};
        auto const acctD = Account{"acctD"};
 
        auto const& creator = createOnHighAcct ? acctD : acctC;
        auto const& assistor = createOnHighAcct ? acctC : acctD;
 
        auto const txFee = env.current()->fees().base;
        auto const baseReserve = env.current()->fees().reserve;
        auto const threelineReserve = env.current()->fees().accountReserve(3);
 
        env.fund(XRP(10000), gwA, gwB, assistor);
 
        // Fund creator with ...
        env.fund(
            baseReserve /* enough to hold an account */
                + drops(3 * txFee) /* and to pay for 3 transactions */,
            creator);
 
        env(trust(creator, gwA["USD"](100)), Require(lines(creator, 1)));
        env(trust(creator, gwB["USD"](100)), Require(lines(creator, 2)));
 
        if (thirdLineCreatesLE)
        {
            // creator does not have enough for the third trust line
            env(trust(creator, assistor["USD"](100)),
                Ter(tecNO_LINE_INSUF_RESERVE),
                Require(lines(creator, 2)));
        }
        else
        {
            // First establish opposite trust direction from assistor
            env(trust(assistor, creator["USD"](100)), Require(lines(creator, 3)));
 
            // creator does not have enough to create the other direction on
            // the existing trust line ledger entry
            env(trust(creator, assistor["USD"](100)), Ter(tecINSUF_RESERVE_LINE));
        }
 
        // Fund creator additional amount to cover
        env(pay(env.master, creator, STAmount{threelineReserve - baseReserve}));
 
        if (thirdLineCreatesLE)
        {
            env(trust(creator, assistor["USD"](100)), Require(lines(creator, 3)));
        }
        else
        {
            env(trust(creator, assistor["USD"](100)), Require(lines(creator, 3)));
 
            json::Value jv;
            jv["account"] = creator.human();
            auto const lines = env.rpc("json", "account_lines", to_string(jv));
            // Verify that all lines have 100 limit from creator
            BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
            BEAST_EXPECT(lines[jss::result][jss::lines].size() == 3);
            for (auto const& line : lines[jss::result][jss::lines])
            {
                BEAST_EXPECT(line[jss::limit] == "100");
            }
        }
    }
 
    void
    testTicketTrustSet(FeatureBitset features)
    {
        testcase("TrustSet using a ticket");
 
        using namespace jtx;
 
        //  Verify that TrustSet transactions can use tickets.
        Env env{*this, features};
        auto const gw = Account{"gateway"};
        auto const alice = Account{"alice"};
        auto const usd = gw["USD"];
 
        env.fund(XRP(10000), gw, alice);
        env.close();
 
        // Cannot pay alice without a trustline.
        env(pay(gw, alice, usd(200)), Ter(tecPATH_DRY));
        env.close();
 
        // Create a ticket.
        std::uint32_t const ticketSeq{env.seq(alice) + 1};
        env(ticket::create(alice, 1));
        env.close();
 
        // Use that ticket to create a trust line.
        env(trust(alice, usd(1000)), ticket::Use(ticketSeq));
        env.close();
 
        // Now the payment succeeds.
        env(pay(gw, alice, usd(200)));
        env.close();
    }
 
    static json::Value
    trustExplicitAmt(jtx::Account const& a, STAmount const& amt)
    {
        json::Value jv;
        jv[jss::Account] = a.human();
        jv[jss::LimitAmount] = amt.getJson(JsonOptions::Values::None);
        jv[jss::TransactionType] = jss::TrustSet;
        jv[jss::Flags] = 0;
        return jv;
    }
 
    void
    testMalformedTransaction(FeatureBitset features)
    {
        testcase("TrustSet checks for malformed transactions");
 
        using namespace jtx;
        Env env{*this, features};
 
        auto const gw = Account{"gateway"};
        auto const alice = Account{"alice"};
        env.fund(XRP(10000), gw, alice);
 
        // Require valid tf flags
        for (std::uint64_t badFlag = 1u; badFlag <= std::numeric_limits<std::uint32_t>::max();
             badFlag *= 2)
        {
            if ((badFlag & tfTrustSetMask) != 0u)
            {
                env(trust(alice, gw["USD"](100), static_cast<std::uint32_t>(badFlag)),
                    Ter(temINVALID_FLAG));
            }
        }
 
        // trust amount can't be XRP
        env(trustExplicitAmt(alice, drops(10000)), Ter(temBAD_LIMIT));
 
        // trust amount can't be badCurrency IOU
        env(trustExplicitAmt(alice, gw[to_string(badCurrency())](100)), Ter(temBAD_CURRENCY));
 
        // trust amount can't be negative
        env(trust(alice, gw["USD"](-1000)), Ter(temBAD_LIMIT));
 
        // trust amount can't be from invalid issuer
        env(trustExplicitAmt(alice, STAmount{Issue{toCurrency("USD"), noAccount()}, 100}),
            Ter(temDST_NEEDED));
 
        // trust cannot be to self
        env(trust(alice, alice["USD"](100)), Ter(temDST_IS_SRC));
 
        // tfSetAuth flag should not be set if not required by lsfRequireAuth
        env(trust(alice, gw["USD"](100), tfSetfAuth), Ter(tefNO_AUTH_REQUIRED));
    }
 
    void
    testExceedTrustLineLimit()
    {
        testcase(
            "Ensure that trust line limits are respected in payment "
            "transactions");
 
        using namespace jtx;
        Env env{*this};
 
        auto const gw = Account{"gateway"};
        auto const alice = Account{"alice"};
        env.fund(XRP(10000), gw, alice);
 
        // alice wants to hold at most 100 of gw's USD tokens
        env(trust(alice, gw["USD"](100)));
        env.close();
 
        // send a payment for a large quantity through the trust line
        env(pay(gw, alice, gw["USD"](200)), Ter(tecPATH_PARTIAL));
        env.close();
 
        // on the other hand, smaller payments should succeed
        env(pay(gw, alice, gw["USD"](20)));
        env.close();
    }
 
    void
    testAuthFlagTrustLines()
    {
        testcase(
            "Ensure that authorised trust lines do not allow payments "
            "from unauthorised counter-parties");
 
        using namespace jtx;
        Env env{*this};
 
        auto const bob = Account{"bob"};
        auto const alice = Account{"alice"};
        env.fund(XRP(10000), bob, alice);
 
        // alice wants to ensure that all holders of her tokens are authorised
        env(fset(alice, asfRequireAuth));
        env.close();
 
        // create a trust line from bob to alice. bob wants to hold at most
        // 100 of alice's USD tokens. Note: alice hasn't authorised this
        // trust line yet.
        env(trust(bob, alice["USD"](100)));
        env.close();
 
        // send a payment from alice to bob, validate that the payment fails
        env(pay(alice, bob, alice["USD"](10)), Ter(tecPATH_DRY));
        env.close();
    }
 
    void
    testTrustLineLimitsWithRippling()
    {
        testcase(
            "Check that trust line limits are respected in conjunction "
            "with rippling feature");
 
        using namespace jtx;
        Env env{*this};
 
        auto const bob = Account{"bob"};
        auto const alice = Account{"alice"};
        env.fund(XRP(10000), bob, alice);
 
        // create a trust line from bob to alice. bob wants to hold at most
        // 100 of alice's USD tokens.
        env(trust(bob, alice["USD"](100)));
        env.close();
 
        // archetypical payment transaction from alice to bob must succeed
        env(pay(alice, bob, alice["USD"](20)), Ter(tesSUCCESS));
        env.close();
 
        // Issued tokens are fungible. i.e. alice's USD is identical to bob's
        // USD
        env(pay(bob, alice, bob["USD"](10)), Ter(tesSUCCESS));
        env.close();
 
        // bob cannot place alice in his debt i.e. alice's balance of the USD
        // tokens cannot go below zero.
        env(pay(bob, alice, bob["USD"](11)), Ter(tecPATH_PARTIAL));
        env.close();
 
        // payments that respect the trust line limits of alice should succeed
        env(pay(bob, alice, bob["USD"](10)), Ter(tesSUCCESS));
        env.close();
    }
 
    void
    testModifyQualityOfTrustline(FeatureBitset features, bool createQuality, bool createOnHighAcct)
    {
        testcase << "TrustSet " << (createQuality ? "creates" : "removes")
                 << " quality of trustline for " << (createOnHighAcct ? "high" : "low")
                 << " account";
 
        using namespace jtx;
        Env env{*this, features};
 
        auto const alice = Account{"alice"};
        auto const bob = Account{"bob"};
 
        auto const& fromAcct = createOnHighAcct ? alice : bob;
        auto const& toAcct = createOnHighAcct ? bob : alice;
 
        env.fund(XRP(10000), fromAcct, toAcct);
 
        auto txWithoutQuality = trust(toAcct, fromAcct["USD"](100));
        txWithoutQuality["QualityIn"] = "0";
        txWithoutQuality["QualityOut"] = "0";
 
        auto txWithQuality = txWithoutQuality;
        txWithQuality["QualityIn"] = "1000";
        txWithQuality["QualityOut"] = "1000";
 
        auto& tx1 = createQuality ? txWithQuality : txWithoutQuality;
        auto& tx2 = createQuality ? txWithoutQuality : txWithQuality;
 
        auto checkQuality = [&](bool const exists) {
            json::Value jv;
            jv["account"] = toAcct.human();
            auto const lines = env.rpc("json", "account_lines", to_string(jv));
            auto quality = exists ? 1000 : 0;
            BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
            BEAST_EXPECT(lines[jss::result][jss::lines].size() == 1);
            BEAST_EXPECT(lines[jss::result][jss::lines][0u][jss::quality_in] == quality);
            BEAST_EXPECT(lines[jss::result][jss::lines][0u][jss::quality_out] == quality);
        };
 
        env(tx1, Require(lines(toAcct, 1)), Require(lines(fromAcct, 1)));
        checkQuality(createQuality);
 
        env(tx2, Require(lines(toAcct, 1)), Require(lines(fromAcct, 1)));
        checkQuality(!createQuality);
    }
 
    void
    testDisallowIncoming(FeatureBitset features)
    {
        testcase("Create trustline with disallow incoming");
 
        using namespace test::jtx;
 
        // fixDisallowIncomingV1
        {
            for (bool const withFix : {true, false})
            {
                auto const amend = withFix ? features : features - fixDisallowIncomingV1;
 
                Env env{*this, amend};
                auto const dist = Account("dist");
                auto const gw = Account("gw");
                auto const usd = gw["USD"];
                auto const distUSD = dist["USD"];
 
                env.fund(XRP(1000), gw, dist);
                env.close();
 
                env(fset(gw, asfRequireAuth));
                env.close();
 
                env(fset(dist, asfDisallowIncomingTrustline));
                env.close();
 
                env(trust(dist, usd(10000)));
                env.close();
 
                // withFix: can set trustline
                // withOutFix: cannot set trustline
                auto const trustResult = withFix ? Ter(tesSUCCESS) : Ter(tecNO_PERMISSION);
                env(trust(gw, distUSD(10000)), Txflags(tfSetfAuth), trustResult);
                env.close();
 
                auto const txResult = withFix ? Ter(tesSUCCESS) : Ter(tecPATH_DRY);
                env(pay(gw, dist, usd(1000)), txResult);
                env.close();
            }
        }
 
        Env env{*this, features};
 
        auto const gw = Account{"gateway"};
        auto const alice = Account{"alice"};
        auto const bob = Account{"bob"};
        auto const usd = gw["USD"];
 
        env.fund(XRP(10000), gw, alice, bob);
        env.close();
 
        // Set flag on gateway
        env(fset(gw, asfDisallowIncomingTrustline));
        env.close();
 
        // Create a trustline which will fail
        env(trust(alice, usd(1000)), Ter(tecNO_PERMISSION));
        env.close();
 
        // Unset the flag
        env(fclear(gw, asfDisallowIncomingTrustline));
        env.close();
 
        // Create a trustline which will now succeed
        env(trust(alice, usd(1000)));
        env.close();
 
        // Now the payment succeeds.
        env(pay(gw, alice, usd(200)));
        env.close();
 
        // Set flag on gateway again
        env(fset(gw, asfDisallowIncomingTrustline));
        env.close();
 
        // Destroy the balance by sending it back
        env(pay(gw, alice, usd(200)));
        env.close();
 
        // The trustline still exists in default state
        // So a further payment should work
        env(pay(gw, alice, usd(200)));
        env.close();
 
        // Also set the flag on bob
        env(fset(bob, asfDisallowIncomingTrustline));
        env.close();
 
        // But now bob can't open a trustline because he didn't already have one
        env(trust(bob, usd(1000)), Ter(tecNO_PERMISSION));
        env.close();
 
        // The gateway also can't open this trustline because bob has the flag
        // set
        env(trust(gw, bob["USD"](1000)), Ter(tecNO_PERMISSION));
        env.close();
 
        // Unset the flag only on the gateway
        env(fclear(gw, asfDisallowIncomingTrustline));
        env.close();
 
        // Now bob can open a trustline
        env(trust(bob, usd(1000)));
        env.close();
 
        // And the gateway can send bob a balance
        env(pay(gw, bob, usd(200)));
        env.close();
    }
 
    void
    testWithFeats(FeatureBitset features)
    {
        testFreeTrustlines(features, true, false);
        testFreeTrustlines(features, false, true);
        testFreeTrustlines(features, false, true);
        // true, true case doesn't matter since creating a trustline ledger
        // entry requires reserve from the creator
        // independent of hi/low account ids for endpoints
        testTicketTrustSet(features);
        testMalformedTransaction(features);
        testModifyQualityOfTrustline(features, false, false);
        testModifyQualityOfTrustline(features, false, true);
        testModifyQualityOfTrustline(features, true, false);
        testModifyQualityOfTrustline(features, true, true);
        testDisallowIncoming(features);
        testTrustLineResetWithAuthFlag();
        testTrustLineDelete();
        testExceedTrustLineLimit();
        testAuthFlagTrustLines();
        testTrustLineLimitsWithRippling();
    }
 
public:
    void
    run() override
    {
        using namespace test::jtx;
        auto const sa = testableAmendments();
        testWithFeats(sa);
    }
};
BEAST_DEFINE_TESTSUITE(TrustSet, app, xrpl);
}  // namespace xrpl::test