add ticket tests (XRPLF#129)

Author: dangell7

src/ripple/protocol/impl/TxFormats.cpp

@@ -198,7 +198,6 @@ TxFormats::TxFormats()
             {sfLedgerSequence,  soeREQUIRED},
             {sfActiveValidator, soeOPTIONAL},
             {sfImportVLKey,     soeOPTIONAL},
-
         },
         commonFields);
 
@@ -308,13 +307,15 @@ TxFormats::TxFormats()
         ttHOOK_SET,
         {
             {sfHooks, soeREQUIRED},
+            {sfTicketSequence, soeOPTIONAL},
         },
         commonFields);
 
     add(jss::ClaimReward,
         ttCLAIM_REWARD,
         {
-            {sfIssuer, soeOPTIONAL}
+            {sfIssuer, soeOPTIONAL},
+            {sfTicketSequence, soeOPTIONAL},
         },
         commonFields);
 
@@ -380,6 +381,7 @@ TxFormats::TxFormats()
         {
             {sfBlob, soeREQUIRED},
             {sfIssuer, soeOPTIONAL},
+            {sfTicketSequence, soeOPTIONAL},
         },
         commonFields);
 
@@ -390,6 +392,7 @@ TxFormats::TxFormats()
             {sfDestination, soeOPTIONAL},
             {sfInvoiceID, soeOPTIONAL},
             {sfDestinationTag, soeOPTIONAL},
+            {sfTicketSequence, soeOPTIONAL},
         },
         commonFields);
 

src/test/app/ClaimReward_test.cpp

@@ -351,13 +351,36 @@ struct ClaimReward_test : public beast::unit_test::suite
         BEAST_EXPECT(expectNoRewards(env, alice) == true);
     }
 
+    void
+    testUsingTickets(FeatureBitset features)
+    {
+        testcase("using tickets");
+        using namespace jtx;
+        using namespace std::literals::chrono_literals;
+        Env env{*this, features};
+        auto const alice = Account("alice");
+        auto const issuer = Account("issuer");
+        env.fund(XRP(10000), alice, issuer);
+        std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+        env(ticket::create(alice, 10));
+        std::uint32_t const aliceSeq{env.seq(alice)};
+        env.require(owners(alice, 10));
+
+        env(claim(alice, issuer), ticket::use(aliceTicketSeq++), ter(tesSUCCESS));
+
+        env.require(tickets(alice, env.seq(alice) - aliceTicketSeq));
+        BEAST_EXPECT(env.seq(alice) == aliceSeq);
+        env.require(owners(alice, 9));
+    }
+
     void
     testWithFeats(FeatureBitset features)
     {
         testEnabled(features);
         testInvalidPreflight(features);
         testInvalidPreclaim(features);
         testValidNoHook(features);
+        testUsingTickets(features);
     }
 
 public:

src/test/app/Import_test.cpp

@@ -4415,6 +4415,52 @@ class Import_test : public beast::unit_test::suite
         }
     }
 
+    void
+    testUsingTickets(FeatureBitset features)
+    {
+        testcase("using tickets");
+
+        using namespace test::jtx;
+        using namespace std::literals;
+
+        {
+            test::jtx::Env env{*this, makeNetworkVLConfig(21337, keys)};
+            auto const feeDrops = env.current()->fees().base;
+
+            // confirm total coins header
+            auto const initCoins = env.current()->info().drops;
+            BEAST_EXPECT(initCoins == 100'000'000'000'000'000);
+
+            // burn 10'000 xrp
+            auto const master = Account("masterpassphrase");
+            env(noop(master), fee(10'000'000'000), ter(tesSUCCESS));
+            env.close();
+
+            // confirm total coins header
+            auto const burnCoins = env.current()->info().drops;
+            BEAST_EXPECT(burnCoins == initCoins - 10'000'000'000);
+
+            auto const alice = Account("alice");
+            env.fund(XRP(1000), alice);
+            env.close();
+
+            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            env(ticket::create(alice, 10));
+            std::uint32_t const aliceSeq{env.seq(alice)};
+            env.require(owners(alice, 10));
+
+            env(import(alice, loadXpop(ImportTCAccountSet::w_seed)),
+                fee(feeDrops * 10),
+                ticket::use(aliceTicketSeq++),
+                ter(tesSUCCESS));
+            env.close();
+
+            env.require(tickets(alice, env.seq(alice) - aliceTicketSeq));
+            BEAST_EXPECT(env.seq(alice) == aliceSeq);
+            env.require(owners(alice, 9));
+        }
+    }
+
     void
     testAccountIndex(FeatureBitset features)
     {
@@ -5581,6 +5627,7 @@ class Import_test : public beast::unit_test::suite
         testSetRegularKey(features);
         testSetRegularKeyFlags(features);
         testSignersListSet(features);
+        testUsingTickets(features);
         testAccountIndex(features);
         testHookIssuer(features);
         testImportSequence(features);

src/test/app/Invoke_test.cpp

@@ -232,6 +232,28 @@ class Invoke_test : public beast::unit_test::suite
         }
     }
 
+    void
+    testUsingTickets(FeatureBitset features)
+    {
+        testcase("invoke using tickets");
+        using namespace jtx;
+        using namespace std::literals::chrono_literals;
+        Env env{*this, features};
+        auto const alice = Account("alice");
+        env.fund(XRP(10000), alice);
+        std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+        env(ticket::create(alice, 10));
+        std::uint32_t const aliceSeq{env.seq(alice)};
+        env.require(owners(alice, 10));
+
+        env(invoke(alice), ticket::use(aliceTicketSeq++), ter(tesSUCCESS));
+        env(invoke(alice), ticket::use(aliceTicketSeq++), ter(tesSUCCESS));
+
+        env.require(tickets(alice, env.seq(alice) - aliceTicketSeq));
+        BEAST_EXPECT(env.seq(alice) == aliceSeq);
+        env.require(owners(alice, 8));
+    }
+
 public:
     void
     run() override
@@ -247,6 +269,7 @@ class Invoke_test : public beast::unit_test::suite
         testInvalidPreflight(features);
         testInvalidPreclaim(features);
         testInvoke(features);
+        testUsingTickets(features);
     }
 };
 

src/test/app/SetHook_test.cpp

@@ -1540,6 +1540,32 @@ class SetHook_test : public beast::unit_test::suite
         }
     }
 
+    void
+    testWithTickets()
+    {
+        testcase("with tickets");
+        using namespace jtx;
+        
+        Env env{*this, supported_amendments()};
+
+        auto const alice = Account{"alice"};
+        env.fund(XRP(10000), alice);
+
+        std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+        env(ticket::create(alice, 10));
+        std::uint32_t const aliceSeq{env.seq(alice)};
+        env.require(owners(alice, 10));
+
+        env(ripple::test::jtx::hook(alice, {{hso(accept_wasm)}}, 0),
+            HSFEE,
+            ticket::use(aliceTicketSeq++),
+            ter(tesSUCCESS));
+
+        env.require(tickets(alice, env.seq(alice) - aliceTicketSeq));
+        BEAST_EXPECT(env.seq(alice) == aliceSeq);
+        env.require(owners(alice, 9 + 1));
+    }
+
     void
     testInferHookSetOperation()
     {
@@ -11400,7 +11426,6 @@ class SetHook_test : public beast::unit_test::suite
     void
     run() override
     {
-        // testTicketSetHook();  // RH TODO
 
         testHooksDisabled();
         testTxStructure();
@@ -11411,6 +11436,7 @@ class SetHook_test : public beast::unit_test::suite
         testDelete();
         testInstall();
         testCreate();
+        testWithTickets();
 
         testUpdate();
 
@@ -11644,7 +11670,7 @@ class SetHook_test : public beast::unit_test::suite
 
     HASH_WASM(accept2);
 };
-BEAST_DEFINE_TESTSUITE(SetHook, tx, ripple);
+BEAST_DEFINE_TESTSUITE(SetHook, app, ripple);
 }  // namespace test
 }  // namespace ripple
 #undef M

src/test/app/URIToken_test.cpp

@@ -1444,10 +1444,9 @@ struct URIToken_test : public beast::unit_test::suite
         env(buy(bob, hexid, USD(1500)),
             ticket::use(bobTicketSeq++),
             ter(tecINSUFFICIENT_FUNDS));
-        env.require(tickets(alice, env.seq(alice) - aliceTicketSeq));
+        env.require(tickets(bob, env.seq(bob) - bobTicketSeq));
 
         env(buy(bob, hexid, USD(1000)), ticket::use(bobTicketSeq++));
-
         env.require(tickets(bob, env.seq(bob) - bobTicketSeq));
         BEAST_EXPECT(env.seq(bob) == bobSeq);
         BEAST_EXPECT(inOwnerDir(*env.current(), bob, tid));