test: enable unit tests to work with variable reference fee

src/test/app/AMMExtended_test.cpp

@@ -3230,7 +3230,9 @@ struct AMMExtended_test : public jtx::AMMTest
                 txflags(tfPartialPayment),
                 sendmax(XRP(5)),
                 ter(tecPATH_PARTIAL));
-            env.require(balance(alice, XRP(9'999.99999)));
+            env.require(balance(
+                alice,
+                drops(10'000'000'000 - env.current()->fees().base.drops())));
             env.require(balance(bob, XRP(10'000)));
         }
 

src/test/app/AMM_test.cpp

@@ -1239,14 +1239,15 @@ struct AMM_test : public jtx::AMMTest
 
         // Equal deposit: 1000000 tokens, 10% of the current pool
         testAMM([&](AMM& ammAlice, Env& env) {
+            auto const baseFee = env.current()->fees().base;
             ammAlice.deposit(carol, 1'000'000);
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(11'000), USD(11'000), IOUAmount{11'000'000, 0}));
             // 30,000 less deposited 1,000
             BEAST_EXPECT(expectLine(env, carol, USD(29'000)));
             // 30,000 less deposited 1,000 and 10 drops tx fee
-            BEAST_EXPECT(
-                expectLedgerEntryRoot(env, carol, XRPAmount{28'999'999'990}));
+            BEAST_EXPECT(expectLedgerEntryRoot(
+                env, carol, XRPAmount{29'000'000'000 - baseFee}));
         });
 
         // equal asset deposit: unit test to exercise the rounding-down of
@@ -2056,6 +2057,7 @@ struct AMM_test : public jtx::AMMTest
         // Equal withdrawal by Carol: 1000000 of tokens, 10% of the current
         // pool
         testAMM([&](AMM& ammAlice, Env& env) {
+            auto const baseFee = env.current()->fees().base.drops();
             // Single deposit of 100000 worth of tokens,
             // which is 10% of the pool. Carol is LP now.
             ammAlice.deposit(carol, 1'000'000);
@@ -2066,16 +2068,16 @@ struct AMM_test : public jtx::AMMTest
             // 30,000 less deposited 1,000
             BEAST_EXPECT(expectLine(env, carol, USD(29'000)));
             // 30,000 less deposited 1,000 and 10 drops tx fee
-            BEAST_EXPECT(
-                expectLedgerEntryRoot(env, carol, XRPAmount{28'999'999'990}));
+            BEAST_EXPECT(expectLedgerEntryRoot(
+                env, carol, XRPAmount{29'000'000'000 - baseFee}));
 
             // Carol withdraws all tokens
             ammAlice.withdraw(carol, 1'000'000);
             BEAST_EXPECT(
                 ammAlice.expectLPTokens(carol, IOUAmount(beast::Zero())));
             BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
-            BEAST_EXPECT(
-                expectLedgerEntryRoot(env, carol, XRPAmount{29'999'999'980}));
+            BEAST_EXPECT(expectLedgerEntryRoot(
+                env, carol, XRPAmount{30'000'000'000 - 2 * baseFee}));
         });
 
         // Equal withdrawal by tokens 1000000, 10%
@@ -3222,12 +3224,14 @@ struct AMM_test : public jtx::AMMTest
         // preflight tests
         {
             Env env(*this, features);
+            auto const baseFee = env.current()->fees().base;
+
             fund(env, gw, {alice, bob}, XRP(2'000), {USD(2'000)});
             AMM amm(env, gw, XRP(1'000), USD(1'010), false, 1'000);
             Json::Value tx = amm.bid({.account = alice, .bidMin = 500});
 
             {
-                auto jtx = env.jt(tx, seq(1), fee(10));
+                auto jtx = env.jt(tx, seq(1), fee(baseFee));
                 env.app().config().features.erase(featureAMM);
                 PreflightContext pfctx(
                     env.app(),
@@ -3241,7 +3245,7 @@ struct AMM_test : public jtx::AMMTest
             }
 
             {
-                auto jtx = env.jt(tx, seq(1), fee(10));
+                auto jtx = env.jt(tx, seq(1), fee(baseFee));
                 jtx.jv["TxnSignature"] = "deadbeef";
                 jtx.stx = env.ust(jtx);
                 PreflightContext pfctx(
@@ -3255,7 +3259,7 @@ struct AMM_test : public jtx::AMMTest
             }
 
             {
-                auto jtx = env.jt(tx, seq(1), fee(10));
+                auto jtx = env.jt(tx, seq(1), fee(baseFee));
                 jtx.jv["Asset2"]["currency"] = "XRP";
                 jtx.jv["Asset2"].removeMember("issuer");
                 jtx.stx = env.ust(jtx);
@@ -3314,11 +3318,12 @@ struct AMM_test : public jtx::AMMTest
 
         // Can't pay into AMM with escrow.
         testAMM([&](AMM& ammAlice, Env& env) {
+            auto const baseFee = env.current()->fees().base;
             env(escrow(carol, ammAlice.ammAccount(), XRP(1)),
                 condition(cb1),
                 finish_time(env.now() + 1s),
                 cancel_time(env.now() + 2s),
-                fee(1'500),
+                fee(baseFee * 150),
                 ter(tecNO_PERMISSION));
         });
 
@@ -4407,6 +4412,7 @@ struct AMM_test : public jtx::AMMTest
 
         // Offer crossing with AMM LPTokens and XRP.
         testAMM([&](AMM& ammAlice, Env& env) {
+            auto const baseFee = env.current()->fees().base.drops();
             auto const token1 = ammAlice.lptIssue();
             auto priceXRP = withdrawByTokens(
                 STAmount{XRPAmount{10'000'000'000}},
@@ -4432,15 +4438,19 @@ struct AMM_test : public jtx::AMMTest
             env(ammAlice.bid({.account = carol, .bidMin = 100}));
             BEAST_EXPECT(ammAlice.expectLPTokens(carol, IOUAmount{4'999'900}));
             BEAST_EXPECT(ammAlice.expectAuctionSlot(0, 0, IOUAmount{100}));
-            BEAST_EXPECT(accountBalance(env, carol) == "22499999960");
+            BEAST_EXPECT(
+                accountBalance(env, carol) ==
+                std::to_string(22500000000 - 4 * baseFee));
             priceXRP = withdrawByTokens(
                 STAmount{XRPAmount{10'000'000'000}},
                 STAmount{token1, 9'999'900},
                 STAmount{token1, 4'999'900},
                 0);
             // Carol withdraws
             ammAlice.withdrawAll(carol, XRP(0));
-            BEAST_EXPECT(accountBalance(env, carol) == "29999949949");
+            BEAST_EXPECT(
+                accountBalance(env, carol) ==
+                std::to_string(29999949999 - 5 * baseFee));
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRPAmount{10'000'000'000} - priceXRP,
                 USD(10'000),
@@ -5154,7 +5164,10 @@ struct AMM_test : public jtx::AMMTest
                     BEAST_EXPECT(expectLine(env, alice, USD(30'000)));
                 // alice XRP balance is 30,000initial - 50 ammcreate fee -
                 // 10drops fee
-                BEAST_EXPECT(accountBalance(env, alice) == "29949999990");
+                BEAST_EXPECT(
+                    accountBalance(env, alice) ==
+                    std::to_string(
+                        29950000000 - env.current()->fees().base.drops()));
             },
             std::nullopt,
             0,
@@ -5210,13 +5223,19 @@ struct AMM_test : public jtx::AMMTest
             BEAST_EXPECT(accountBalance(env, simon) == xrpBalance);
             BEAST_EXPECT(accountBalance(env, chris) == xrpBalance);
             BEAST_EXPECT(accountBalance(env, dan) == xrpBalance);
+
+            auto const baseFee = env.current()->fees().base.drops();
             // 30,000 initial - (deposit+withdraw) * 10
-            BEAST_EXPECT(accountBalance(env, carol) == "29999999800");
+            BEAST_EXPECT(
+                accountBalance(env, carol) ==
+                std::to_string(30000000000 - 20 * baseFee));
             BEAST_EXPECT(accountBalance(env, ed) == xrpBalance);
             BEAST_EXPECT(accountBalance(env, paul) == xrpBalance);
             BEAST_EXPECT(accountBalance(env, nataly) == xrpBalance);
             // 30,000 initial - 50 ammcreate fee - 10drops withdraw fee
-            BEAST_EXPECT(accountBalance(env, alice) == "29949999990");
+            BEAST_EXPECT(
+                accountBalance(env, alice) ==
+                std::to_string(29950000000 - baseFee));
         });
     }
 

src/test/app/DID_test.cpp

@@ -87,6 +87,7 @@ struct DID_test : public beast::unit_test::suite
         // the reserve for creating a DID.
         auto const acctReserve = env.current()->fees().accountReserve(0);
         auto const incReserve = env.current()->fees().increment;
+        auto const baseFee = env.current()->fees().base;
         env.fund(acctReserve, alice);
         env.close();
         BEAST_EXPECT(env.balance(alice) == acctReserve);
@@ -98,8 +99,10 @@ struct DID_test : public beast::unit_test::suite
         BEAST_EXPECT(ownerCount(env, alice) == 0);
 
         // Pay alice almost enough to make the reserve for a DID.
-        env(pay(env.master, alice, incReserve + drops(19)));
-        BEAST_EXPECT(env.balance(alice) == acctReserve + incReserve + drops(9));
+        env(pay(env.master, alice, drops(incReserve + 2 * baseFee - 1)));
+        BEAST_EXPECT(
+            env.balance(alice) ==
+            acctReserve + incReserve + drops(baseFee - 1));
         env.close();
 
         // alice still does not have enough XRP for the reserve of a DID.
@@ -108,7 +111,7 @@ struct DID_test : public beast::unit_test::suite
         BEAST_EXPECT(ownerCount(env, alice) == 0);
 
         // Pay alice enough to make the reserve for a DID.
-        env(pay(env.master, alice, drops(11)));
+        env(pay(env.master, alice, drops(baseFee + 1)));
         env.close();
 
         // Now alice can create a DID.

src/test/app/DeliverMin_test.cpp

@@ -67,7 +67,8 @@ class DeliverMin_test : public beast::unit_test::suite
                 txflags(tfPartialPayment),
                 sendmax(XRP(5)),
                 ter(tecPATH_PARTIAL));
-            env.require(balance("alice", XRP(9999.99999)));
+            env.require(balance(
+                "alice", XRP(10000) - drops(env.current()->fees().base)));
             env.require(balance("bob", XRP(10000)));
         }
 

src/test/app/DepositAuth_test.cpp

@@ -184,18 +184,19 @@ struct DepositAuth_test : public beast::unit_test::suite
         Account const bob{"bob"};
 
         Env env(*this);
+        auto const baseFee = env.current()->fees().base;
 
         env.fund(XRP(10000), alice, bob);
 
         // bob sets the lsfDepositAuth flag.
-        env(fset(bob, asfDepositAuth), fee(drops(10)));
+        env(fset(bob, asfDepositAuth), fee(drops(baseFee)));
         env.close();
-        BEAST_EXPECT(env.balance(bob, XRP) == XRP(10000) - drops(10));
+        BEAST_EXPECT(env.balance(bob, XRP) == XRP(10000) - drops(baseFee));
 
         // bob has more XRP than the base reserve.  Any XRP payment should fail.
         env(pay(alice, bob, drops(1)), ter(tecNO_PERMISSION));
         env.close();
-        BEAST_EXPECT(env.balance(bob, XRP) == XRP(10000) - drops(10));
+        BEAST_EXPECT(env.balance(bob, XRP) == XRP(10000) - drops(baseFee));
 
         // Change bob's XRP balance to exactly the base reserve.
         {
@@ -257,7 +258,7 @@ struct DepositAuth_test : public beast::unit_test::suite
         BEAST_EXPECT(env.balance(bob, XRP) == drops(1));
 
         // Pay bob enough so he can afford the fee to clear lsfDepositAuth.
-        env(pay(alice, bob, drops(9)));
+        env(pay(alice, bob, drops(baseFee - 1)));
         env.close();
 
         // Interestingly, at this point the terINSUF_FEE_B retry grabs the
@@ -550,7 +551,7 @@ struct DepositPreauth_test : public beast::unit_test::suite
         env.require(owners(becky, 0));
 
         // carol gets enough XRP to (barely) meet the reserve.
-        env(pay(alice, carol, drops(11)));
+        env(pay(alice, carol, drops(env.current()->fees().base + 1)));
         env.close();
         env(deposit::auth(carol, becky));
         env.close();