Add deep freeze feature (XLS-77d)

include/xrpl/protocol/Feature.h

@@ -80,7 +80,7 @@ namespace detail {
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 80;
+static constexpr std::size_t numFeatures = 81;
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated

include/xrpl/protocol/LedgerFormats.h

@@ -164,6 +164,8 @@ enum LedgerSpecificFlags {
     lsfHighFreeze = 0x00800000,  // True, high side has set freeze flag
     lsfAMMNode = 0x01000000,     // True, trust line to AMM. Used by client
                                  // apps to identify payments via AMM.
+    lsfLowDeepFreeze = 0x02000000,
+    lsfHighDeepFreeze = 0x04000000,
 
     // ltSIGNER_LIST
     lsfOneOwnerCount = 0x00010000,  // True, uses only one OwnerCount

include/xrpl/protocol/TxFlags.h

@@ -114,9 +114,11 @@ constexpr std::uint32_t tfSetNoRipple                      = 0x00020000;
 constexpr std::uint32_t tfClearNoRipple                    = 0x00040000;
 constexpr std::uint32_t tfSetFreeze                        = 0x00100000;
 constexpr std::uint32_t tfClearFreeze                      = 0x00200000;
+constexpr std::uint32_t tfSetDeepFreeze                    = 0x00400000;
+constexpr std::uint32_t tfClearDeepFreeze                  = 0x00800000;
 constexpr std::uint32_t tfTrustSetMask =
     ~(tfUniversal | tfSetfAuth | tfSetNoRipple | tfClearNoRipple | tfSetFreeze |
-      tfClearFreeze);
+      tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze);
 
 // EnableAmendment flags:
 constexpr std::uint32_t tfGotMajority                      = 0x00010000;

include/xrpl/protocol/detail/features.macro

@@ -31,6 +31,7 @@
 
 // InvariantsV1_1 will be changes to Supported::yes when all the
 // invariants expected to be included under it are complete.
+XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV1,                 Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(InvariantsV1_1,             Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (NFTokenPageLinks,           Supported::yes, VoteBehavior::DefaultNo)

src/test/app/AMMExtended_test.cpp

@@ -3615,6 +3615,184 @@ struct AMMExtended_test : public jtx::AMMTest
         }
     }
 
+    void
+    testRippleDeepState(FeatureBitset features)
+    {
+        testcase("RippleState Deep Freeze");
+
+        using namespace test::jtx;
+        Env env(*this, features);
+
+        Account const G1{"G1"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+
+        env.fund(XRP(1'000), G1, alice, bob);
+        env.close();
+
+        env.trust(G1["USD"](100), bob);
+        env.trust(G1["USD"](205), alice);
+        env.close();
+
+        env(pay(G1, bob, G1["USD"](10)));
+        env(pay(G1, alice, G1["USD"](205)));
+        env.close();
+
+        AMM ammAlice(env, alice, XRP(500), G1["USD"](105));
+
+        {
+            auto lines = getAccountLines(env, bob);
+            if (!BEAST_EXPECT(checkArraySize(lines[jss::lines], 1u)))
+                return;
+            BEAST_EXPECT(lines[jss::lines][0u][jss::account] == G1.human());
+            BEAST_EXPECT(lines[jss::lines][0u][jss::limit] == "100");
+            BEAST_EXPECT(lines[jss::lines][0u][jss::balance] == "10");
+        }
+
+        {
+            auto lines = getAccountLines(env, alice, G1["USD"]);
+            if (!BEAST_EXPECT(checkArraySize(lines[jss::lines], 1u)))
+                return;
+            BEAST_EXPECT(lines[jss::lines][0u][jss::account] == G1.human());
+            BEAST_EXPECT(lines[jss::lines][0u][jss::limit] == "205");
+            // 105 transferred to AMM
+            BEAST_EXPECT(lines[jss::lines][0u][jss::balance] == "100");
+        }
+
+        {
+            // Account with line unfrozen (proving operations normally work)
+            //   test: can make Payment on that line
+            env(pay(alice, bob, G1["USD"](1)));
+
+            //   test: can receive Payment on that line
+            env(pay(bob, alice, G1["USD"](1)));
+            env.close();
+        }
+
+        {
+            // Is created via a TrustSet with SetFreeze flag
+            //   test: sets LowFreeze | HighFreeze flags
+            env(trust(G1, bob["USD"](0), tfSetFreeze | tfSetDeepFreeze));
+            auto affected = env.meta()->getJson(
+                JsonOptions::none)[sfAffectedNodes.fieldName];
+            if (!BEAST_EXPECT(checkArraySize(affected, 2u)))
+                return;
+            auto ff =
+                affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName];
+            BEAST_EXPECT(
+                ff[sfLowLimit.fieldName] ==
+                G1["USD"](0).value().getJson(JsonOptions::none));
+            if (features[featureDeepFreeze])
+            {
+                BEAST_EXPECT(ff[jss::Flags].asUInt() & lsfLowDeepFreeze);
+                BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighDeepFreeze));
+            }
+            else
+            {
+                BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfLowDeepFreeze));
+                BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighDeepFreeze));
+            }
+            env.close();
+        }
+
+        {
+            // Account with line deep frozen by issuer
+            //    test: can not buy more assets on that line
+            if (features[featureDeepFreeze])
+            {
+                env(offer(bob, G1["USD"](5), XRP(25)), ter(tecFROZEN));
+            }
+            else
+            {
+                env(offer(bob, G1["USD"](5), XRP(25)));
+            }
+            env.close();
+        }
+
+        {
+            //    test: can not sell assets from that line
+            env(offer(bob, XRP(1), G1["USD"](5)), ter(tecUNFUNDED_OFFER));
+
+            //    test: can not make Payment from that line
+            env(pay(bob, alice, G1["USD"](1)), ter(tecPATH_DRY));
+
+            if (features[featureDeepFreeze])
+            {
+                //    test: can not receive Payment on that line
+                env(pay(alice, bob, G1["USD"](1)), ter(tecPATH_DRY));
+            }
+            else
+            {
+                //    test: can receive Payment on that line
+                env(pay(alice, bob, G1["USD"](1)));
+            }
+        }
+
+        {
+            // check G1 account lines
+            //    test: shows deep freeze
+            auto lines = getAccountLines(env, G1);
+            Json::Value bobLine;
+            for (auto const& it : lines[jss::lines])
+            {
+                if (it[jss::account] == bob.human())
+                {
+                    bobLine = it;
+                    break;
+                }
+            }
+            if (!BEAST_EXPECT(bobLine))
+                return;
+            BEAST_EXPECT(bobLine[jss::freeze] == true);
+            if (features[featureDeepFreeze])
+                BEAST_EXPECT(bobLine[jss::balance] == "-10");
+            else
+                BEAST_EXPECT(bobLine[jss::balance] == "-16");
+        }
+
+        {
+            //    test: shows deep freeze peer
+            auto lines = getAccountLines(env, bob);
+            Json::Value g1Line;
+            for (auto const& it : lines[jss::lines])
+            {
+                if (it[jss::account] == G1.human())
+                {
+                    g1Line = it;
+                    break;
+                }
+            }
+            if (!BEAST_EXPECT(g1Line))
+                return;
+            BEAST_EXPECT(g1Line[jss::freeze_peer] == true);
+            if (features[featureDeepFreeze])
+                BEAST_EXPECT(g1Line[jss::balance] == "10");
+            else
+                BEAST_EXPECT(g1Line[jss::balance] == "16");
+        }
+
+        {
+            // Is cleared via a TrustSet with ClearDeepFreeze flag
+            //    test: sets LowDeepFreeze | HighDeepFreeze flags
+            env(trust(G1, bob["USD"](0), tfClearDeepFreeze));
+            auto affected = env.meta()->getJson(
+                JsonOptions::none)[sfAffectedNodes.fieldName];
+            if (!features[featureDeepFreeze] &&
+                BEAST_EXPECT(checkArraySize(affected, 1u)))
+                return;
+            if (!BEAST_EXPECT(checkArraySize(affected, 2u)))
+                return;
+            auto ff =
+                affected[1u][sfModifiedNode.fieldName][sfFinalFields.fieldName];
+            BEAST_EXPECT(
+                ff[sfLowLimit.fieldName] ==
+                G1["USD"](0).value().getJson(JsonOptions::none));
+            BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfLowDeepFreeze));
+            BEAST_EXPECT(!(ff[jss::Flags].asUInt() & lsfHighDeepFreeze));
+            env.close();
+        }
+    }
+
     void
     testGlobalFreeze(FeatureBitset features)
     {
@@ -4129,7 +4307,13 @@ struct AMMExtended_test : public jtx::AMMTest
     {
         using namespace test::jtx;
         auto const sa = supported_amendments();
+        testRippleState(sa - featureDeepFreeze);
+        testRippleDeepState(sa - featureDeepFreeze);
+        testGlobalFreeze(sa - featureDeepFreeze);
+        testOffersWhenFrozen(sa - featureDeepFreeze);
+
         testRippleState(sa);
+        testRippleDeepState(sa);
         testGlobalFreeze(sa);
         testOffersWhenFrozen(sa);
     }

src/test/app/AMM_test.cpp

@@ -4397,6 +4397,48 @@ struct AMM_test : public jtx::AMMTest
             0,
             std::nullopt,
             {features});
+
+        // Individually deep frozen account
+        if (features[featureDeepFreeze])
+        {
+            testAMM(
+                [&](AMM& ammAlice, Env& env) {
+                    env(trust(
+                        gw, carol["USD"](0), tfSetFreeze | tfSetDeepFreeze));
+                    env(trust(
+                        gw, alice["USD"](0), tfSetFreeze | tfSetDeepFreeze));
+                    env.close();
+                    env(pay(alice, carol, USD(1)),
+                        path(~USD),
+                        sendmax(XRP(10)),
+                        txflags(tfNoRippleDirect | tfPartialPayment),
+                        ter(tecPATH_DRY));
+                },
+                std::nullopt,
+                0,
+                std::nullopt,
+                {features});
+        }
+        else
+        {
+            testAMM(
+                [&](AMM& ammAlice, Env& env) {
+                    env(trust(
+                        gw, carol["USD"](0), tfSetFreeze | tfSetDeepFreeze));
+                    env(trust(
+                        gw, alice["USD"](0), tfSetFreeze | tfSetDeepFreeze));
+                    env.close();
+                    env(pay(alice, carol, USD(1)),
+                        path(~USD),
+                        sendmax(XRP(10)),
+                        txflags(tfNoRippleDirect | tfPartialPayment),
+                        ter(tesSUCCESS));
+                },
+                std::nullopt,
+                0,
+                std::nullopt,
+                {features});
+        }
     }
 
     void
@@ -6882,6 +6924,7 @@ struct AMM_test : public jtx::AMMTest
         testBasicPaymentEngine(all - fixAMMv1_1);
         testBasicPaymentEngine(all - fixReducedOffersV2);
         testBasicPaymentEngine(all - fixAMMv1_1 - fixReducedOffersV2);
+        testBasicPaymentEngine(all - featureDeepFreeze);
         testAMMTokens();
         testAmendment();
         testFlags();

src/test/app/Check_test.cpp

@@ -546,6 +546,72 @@ class Check_test : public beast::unit_test::suite
             env(trust(alice, USD(0), tfClearFreeze));
             env.close();
         }
+        {
+            // Deep Frozen trust line.  Check creation should be similar to
+            // payment behavior in the face of frozen trust lines.
+            env.trust(USD(1000), alice);
+            env.trust(USD(1000), bob);
+            env.close();
+            env(pay(gw1, alice, USD(25)));
+            env(pay(gw1, bob, USD(25)));
+            env.close();
+
+            // Setting trustline deep freeze in one direction prevents alice
+            // from creating a check for USD.  And bob and gw1 should not be
+            // able to create a check for USD to alice.
+            env(trust(gw1, alice["USD"](0), tfSetFreeze | tfSetDeepFreeze));
+            env.close();
+            env(check::create(alice, bob, USD(50)), ter(tecFROZEN));
+            env.close();
+            env(pay(alice, bob, USD(1)), ter(tecPATH_DRY));
+            env.close();
+            env(check::create(bob, alice, USD(50)));
+            env.close();
+            if (features[featureDeepFreeze])
+                env(pay(bob, alice, USD(1)), ter(tecPATH_DRY));
+            else
+                env(pay(bob, alice, USD(1)));
+            env.close();
+            env(check::create(gw1, alice, USD(50)));
+            env.close();
+            env(pay(gw1, alice, USD(1)));
+            env.close();
+
+            // Clear that freeze.  Now check creation works.
+            env(trust(gw1, alice["USD"](0), tfClearFreeze | tfClearDeepFreeze));
+            env.close();
+            env(check::create(alice, bob, USD(50)));
+            env.close();
+            env(check::create(bob, alice, USD(50)));
+            env.close();
+            env(check::create(gw1, alice, USD(50)));
+            env.close();
+
+            // Deep Freezing in the other direction does effect alice's USD
+            // check creation, and prevents bob and gw1 from writing a check
+            // for USD to alice.
+            env(trust(alice, USD(0), tfSetFreeze | tfSetDeepFreeze));
+            env.close();
+            env(check::create(alice, bob, USD(50)));
+            env.close();
+            if (features[featureDeepFreeze])
+                env(pay(alice, bob, USD(1)), ter(tecPATH_DRY));
+            else
+                env(pay(alice, bob, USD(1)));
+            env.close();
+            env(check::create(bob, alice, USD(50)), ter(tecFROZEN));
+            env.close();
+            env(pay(bob, alice, USD(1)), ter(tecPATH_DRY));
+            env.close();
+            env(check::create(gw1, alice, USD(50)), ter(tecFROZEN));
+            env.close();
+            env(pay(gw1, alice, USD(1)), ter(tecPATH_DRY));
+            env.close();
+
+            // Clear that deep freeze.
+            env(trust(alice, USD(0), tfClearFreeze | tfClearDeepFreeze));
+            env.close();
+        }
 
         // Expired expiration.
         env(check::create(alice, bob, USD(50)),
@@ -2719,6 +2785,7 @@ class Check_test : public beast::unit_test::suite
         auto const sa = supported_amendments();
         testWithFeats(sa - featureCheckCashMakesTrustLine);
         testWithFeats(sa - disallowIncoming);
+        testWithFeats(sa - featureDeepFreeze);
         testWithFeats(sa);
 
         testTrustLineCreation(sa);  // Test with featureCheckCashMakesTrustLine