[WIP] Implementing Deep freeze

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

@@ -160,10 +160,12 @@ enum LedgerSpecificFlags {
     lsfHighAuth = 0x00080000,
     lsfLowNoRipple = 0x00100000,
     lsfHighNoRipple = 0x00200000,
-    lsfLowFreeze = 0x00400000,   // True, low side has set freeze flag
-    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.
+    lsfLowFreeze = 0x00400000,      // True, low side has set freeze flag
+    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,  // True, low side has set deep freeze flag
+    lsfHighDeepFreeze = 0x04000000, // True, low side has set deep freeze flag
 
     // 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

@@ -28,10 +28,12 @@
 // Keep it sorted in reverse chronological order.
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
+// clang-format off
 
+XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(MPTokensV1,                 Supported::yes, VoteBehavior::DefaultNo)
 // InvariantsV1_1 will be changes to Supported::yes when all the
 // invariants expected to be included under it are complete.
-XRPL_FEATURE(MPTokensV1,                 Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(InvariantsV1_1,             Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (NFTokenPageLinks,           Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (InnerObjTemplate2,          Supported::yes, VoteBehavior::DefaultNo)
@@ -111,3 +113,5 @@ XRPL_FIX    (NFTokenNegOffer,       Supported::yes, VoteBehavior::Obsolete)
 XRPL_FIX    (NFTokenDirV1,          Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(NonFungibleTokensV1,   Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(CryptoConditionsSuite, Supported::yes, VoteBehavior::Obsolete)
+
+// clang-format on

src/test/app/AMMExtended_test.cpp

@@ -4129,6 +4129,10 @@ struct AMMExtended_test : public jtx::AMMTest
     {
         using namespace test::jtx;
         auto const sa = supported_amendments();
+        testRippleState(sa - featureDeepFreeze);
+        testGlobalFreeze(sa - featureDeepFreeze);
+        testOffersWhenFrozen(sa - featureDeepFreeze);
+
         testRippleState(sa);
         testGlobalFreeze(sa);
         testOffersWhenFrozen(sa);

src/test/app/AMM_test.cpp

@@ -4397,6 +4397,28 @@ 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});
+        }
     }
 
     void
@@ -6882,6 +6904,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